feat(tuku): M7 条漫模式与续读——模式一键切换/每册记忆、视口±1 懒解码、滑块跳页、册间衔接

- 条漫：meow_scroll 跟手+fling，按滚动位置懒解码视口±1 页（驻留上限 4 页）；
  排版用 mr_book_meta 累加适宽高度（nav.c 纯逻辑，宿主可测）
- 模式：阅读 chrome 图标一键切翻页/条漫；每册模式与 last page 经 meow_config 持久化
  （reader.mode/page.<FNV1a64(册路径)>），重进该册恢复模式与页码
- 续读：离开/翻页/滚动停止节流落盘；书库扫描给含图册副标题追加「· 续读 Pn」
- 册间衔接：末页前进→同父目录下一含图册首页，首页后退→上一册末页；无相邻册轻提示不退出
- 跳页：chrome 内 meow_slider，目标页预解码完成后落位（2.5s 超时降级提示）
- 解码：改走 M12 预算解码 meow_img_load_file_dim；超大 PNG/BMP 先 probe 预判，
  超 40MiB 原始 RGBA 跳过并显示「图片无法显示」，12MiB 以上记 WARN（如实保留残余风险）
- 测试：新增条漫排版/跳页状态/模式续读持久化/册间边界宿主测试，以及真实 SDK 源码树上的
  阅读器集成测试（模式切换/跳页落位/续读/跨册），test/run_webtoon_tests.sh 一键运行

tuku/logic/library.c

@@ -7,8 +7,14 @@
  *      收进结果并自然排序——因此根视图不会列出后代条目，进入子目录时再重新扫描该层。
  *
  * 内存：条目数组倍增分配；路径/名称定长，随 mr_library_free() 释放。
+ *
+ * M7 追加（不改扫描语义）：
+ *   - 续读角标：含图册的副标题后缀「· 续读 Pn」（读 logic/reader 的每册 last page）；
+ *   - 册间衔接：mr_book_adjacent 给出同父目录下按书库自然序的相邻「含图册」，
+ *     供阅读器末页前进/首页后退跨册；mr_library_dir_has_images 是共享的「是不是一本书」判据。
  */
 #include "library.h"
+#include "logic/reader.h"   /* mr_cont_badge：书库行续读角标（M7） */
 
 #include <ctype.h>
 #include <dirent.h>
@@ -215,6 +221,17 @@ int mr_library_scan(mr_library *lib, const char *dir, int max_depth)
         else
             snprintf(e.subtitle, sizeof e.subtitle, "%d folder%s", e.subdirs,
                      e.subdirs == 1 ? "" : "s");
+        /* 续读角标（M7）：有 last page 记录的册，在副标题后缀「· 续读 Pn」。
+         * config 读失败/无记录时 mr_cont_badge 返回 0，副标题保持原样。 */
+        if (e.has_images) {
+            char badge[24];
+            if (mr_cont_badge(e.path, badge, (int)sizeof badge)) {
+                int used = (int)strlen(e.subtitle);
+                if (used < (int)sizeof e.subtitle - 2)
+                    snprintf(e.subtitle + used, sizeof e.subtitle - (size_t)used,
+                             " · %s", badge);
+            }
+        }
         if (lib_add(lib, &e) != 0) {
             closedir(d);
             mr_library_free(lib);
@@ -245,3 +262,101 @@ int mr_path_parent(const char *path, char *out, int outsz)
     out[n] = '\0';
     return 0;
 }
+
+/* ============================================================ */
+/* 册间衔接（M7）                                                */
+/* ============================================================ */
+int mr_library_dir_has_images(const char *dir)
+{
+    if (!dir || !dir[0]) return 0;
+    DIR *d = opendir(dir);
+    if (!d) return 0;
+
+    int found = 0;
+    struct dirent *de;
+    while ((de = readdir(d)) != NULL) {
+        const char *name = de->d_name;
+        if (name[0] == '.' || !mr_path_is_image(name)) continue;
+        char full[MR_PATH_MAX];
+        if (join_path(full, (int)sizeof full, dir, name) != 0) continue;
+        struct stat st;
+        if (lstat(full, &st) != 0 || !S_ISREG(st.st_mode)) continue;
+        found = 1;
+        break;
+    }
+    closedir(d);
+    return found;
+}
+
+static int name_ptr_cmp(const void *pa, const void *pb)
+{
+    const char *a = *(const char *const *)pa;
+    const char *b = *(const char *const *)pb;
+    return mr_natural_cmp(a, b);
+}
+
+int mr_book_adjacent(const char *dir, int delta, char *out, int outsz)
+{
+    if (!out || outsz <= 0) return -1;
+    out[0] = '\0';
+    if (!dir || !dir[0] || (delta != 1 && delta != -1)) return -1;
+
+    char norm[MR_PATH_MAX];
+    size_t dl = strlen(dir);
+    while (dl > 1 && dir[dl - 1] == '/') dl--;
+    if (dl >= sizeof norm) return -1;
+    memcpy(norm, dir, dl);
+    norm[dl] = '\0';
+
+    const char *slash = strrchr(norm, '/');
+    if (!slash || !slash[1]) return -1;
+    const char *cur = slash + 1;
+
+    char parent[MR_PATH_MAX];
+    if (mr_path_parent(norm, parent, (int)sizeof parent) != 0) return -1;
+
+    DIR *d = opendir(parent);
+    if (!d) return 0;
+
+    char **names = NULL;
+    int n = 0, cap = 0;
+    struct dirent *de;
+    while ((de = readdir(d)) != NULL) {
+        const char *name = de->d_name;
+        if (strcmp(name, ".") == 0 || strcmp(name, "..") == 0) continue;
+        if (ignored_dir_name(name)) continue;
+
+        char full[MR_PATH_MAX];
+        if (join_path(full, (int)sizeof full, parent, name) != 0) continue;
+        struct stat st;
+        if (lstat(full, &st) != 0 || S_ISLNK(st.st_mode) || !S_ISDIR(st.st_mode)) continue;
+        if (!mr_library_dir_has_images(full)) continue;   /* 只算「一本书」，中间目录跳过 */
+
+        if (n >= cap) {
+            int nc = cap ? cap * 2 : 16;
+            char **nn = (char **)realloc(names, (size_t)nc * sizeof *nn);
+            if (!nn) break;
+            names = nn;
+            cap = nc;
+        }
+        size_t len = strlen(name);
+        names[n] = (char *)malloc(len + 1);
+        if (!names[n]) break;
+        memcpy(names[n], name, len + 1);
+        n++;
+    }
+    closedir(d);
+
+    int rc = 0;
+    if (n > 1) qsort(names, (size_t)n, sizeof *names, name_ptr_cmp);
+    int idx = -1;
+    for (int i = 0; i < n; i++)
+        if (strcmp(names[i], cur) == 0) { idx = i; break; }
+    int target = idx + delta;
+    if (idx >= 0 && target >= 0 && target < n) {
+        if (join_path(out, outsz, parent, names[target]) == 0) rc = 1;
+    }
+    for (int i = 0; i < n; i++) free(names[i]);
+    free(names);
+    return rc;
+}

tuku/logic/library.h

@@ -1,6 +1,8 @@
 /* logic/library.h — 漫画书库扫描/排序（纯 C，不依赖 meow_ui.h）。
  *
  * 分层契约同 examples/hello：logic 层只含文件系统与纯数据，宿主 gcc 可直接裸测。
+ * （M7 起另提供每册续读角标与册间顺序查询；续读状态本身由 logic/reader.c 持久化，
+ *   本层只读它来拼副标题，宿主测试用配置存根顶替。）
  * 书库语义：
  *   - 从 TF 卡根（MR_ROOT_DIR）起列「直接子目录」；
  *   - 只保留自身含 PNG/JPEG/BMP 的目录，或子树中最终含图的中间目录（可继续导航）；
@@ -57,6 +59,16 @@ void mr_library_free(mr_library *lib);
  * 成功 0；参数非法/输出缓冲不足 -1。 */
 int mr_path_parent(const char *path, char *out, int outsz);
 
+/* 目录是否**直接**含受支持图片（= 书库语义里的「一本书」，可直接进 reader）。
+ * 1=有；0=没有/不可读。 */
+int mr_library_dir_has_images(const char *dir);
+
+/* 册间衔接（M7）：同父目录下按书库自然序排列的「直接含图」兄弟册。
+ * delta=+1 下一册 / -1 上一册。1=找到并写入 out 完整路径；
+ * 0=没有相邻册（当前册是首/末册，或当前册不在兄弟表中）；-1=参数非法。
+ * 语义与书库一致：跳过隐藏/系统目录与符号链接，排序同 mr_natural_cmp。 */
+int mr_book_adjacent(const char *dir, int delta, char *out, int outsz);
+
 #ifdef __cplusplus
 }
 #endif

tuku/logic/reader.c

@@ -1,10 +1,12 @@
-/* logic/reader.c — 阅读方向状态（默认 RTL；M4/M6 的阅读器直接复用）。
+/* logic/reader.c — 阅读方向状态（默认 RTL；M4/M6 的阅读器直接复用）+ 每册续读状态（M7）。
  *
  * M5 评审 P1 修复：方向设置要「下次启动生效」。最小持久化（不新增任何方向状态）：
  *   - mr_reader_set_direction 成功切换后 best-effort 写 meow_config("reader.dir","rtl"/"ltr")；
  *     写失败只打 WARN，不阻断切换（本次运行仍生效）；
  *   - mr_reader_get_direction 首次调用惰性读一次配置恢复；无配置/值非法 → 默认 RTL；
  *     之后走纯内存快路径（不再读配置）。
+ * M7：阅读模式（翻页/条漫）与每册 last page 同为 meow_config 小键（reader.mode/page.<册标识>，
+ *     册标识=规范化目录路径的 FNV-1a64）；书库行角标经 mr_cont_badge 读取同一份状态。
  * 依赖面：只 include 配置/日志两个模块头（不含 UI）；宿主测试用
  * test/settings_reader_stub.c 顶替 meow_config_* 与 meow_log。
  */
@@ -12,6 +14,8 @@
 #include "include/meow_ui_config.h"
 #include "include/meow_ui_log.h"
 
+#include <stdio.h>
+#include <stdlib.h>
 #include <string.h>
 
 #define MR_DIR_CFG_KEY "reader.dir"
@@ -59,3 +63,122 @@ void mr_reader_test_reset(void)
     g_restored = 0;
 }
 #endif
+
+/* ============================================================ */
+/* 阅读模式 + 每册续读状态（M7）                                 */
+/* ============================================================ */
+int mr_mode_valid(int mode)
+{
+    return mode == MR_MODE_PAGED || mode == MR_MODE_WEBTOON;
+}
+
+const char *mr_mode_name(int mode)
+{
+    return mode == MR_MODE_WEBTOON ? "webtoon" : "paged";
+}
+
+int mr_mode_parse(const char *s)
+{
+    if (!s) return -1;
+    if (strcmp(s, "paged") == 0) return MR_MODE_PAGED;
+    if (strcmp(s, "webtoon") == 0) return MR_MODE_WEBTOON;
+    return -1;
+}
+
+/* 目录规范化：去掉末尾 '/'（根 "/" 保留），保证同一册跨调用/跨启动得到同一键。 */
+static void cont_norm_dir(const char *dir, char *out, int outsz)
+{
+    if (!out || outsz <= 0) return;
+    out[0] = '\0';
+    if (!dir || !dir[0]) return;
+    int n = (int)strlen(dir);
+    while (n > 1 && dir[n - 1] == '/') n--;
+    if (n >= outsz) n = outsz - 1;
+    memcpy(out, dir, (size_t)n);
+    out[n] = '\0';
+}
+
+static unsigned long long cont_fnv1a64(const char *s)
+{
+    unsigned long long h = 1469598103934665603ULL;
+    for (const unsigned char *p = (const unsigned char *)s; *p; p++) {
+        h ^= (unsigned long long)*p;
+        h *= 1099511628211ULL;
+    }
+    return h;
+}
+
+int mr_cont_key(const char *dir, const char *field, char *out, int outsz)
+{
+    if (!out || outsz <= 0) return -1;
+    out[0] = '\0';
+    if (!dir || !dir[0] || !field || !field[0]) return -1;
+    char norm[MR_CONT_PATH_MAX];
+    cont_norm_dir(dir, norm, (int)sizeof norm);
+    if (!norm[0]) return -1;
+    int n = snprintf(out, (size_t)outsz, "reader.%s.%016llx", field, cont_fnv1a64(norm));
+    if (n <= 0 || n >= outsz) { out[0] = '\0'; return -1; }
+    return 0;
+}
+
+int mr_cont_get_page(const char *dir, int def)
+{
+    char key[64];
+    char buf[24];
+    if (mr_cont_key(dir, "page", key, (int)sizeof key) != 0) return def;
+    if (meow_config_get(key, buf, (int)sizeof buf) != MEOW_CFG_OK) return def;
+    char *end = NULL;
+    long v = strtol(buf, &end, 10);
+    if (end == buf || (end && *end != '\0')) return def;
+    if (v < 0 || v > MR_CONT_PAGE_MAX) return def;
+    return (int)v;
+}
+
+void mr_cont_set_page(const char *dir, int page)
+{
+    char key[64];
+    char val[24];
+    if (page < 0) page = 0;
+    if (page > MR_CONT_PAGE_MAX) page = MR_CONT_PAGE_MAX;
+    if (mr_cont_key(dir, "page", key, (int)sizeof key) != 0) return;
+    snprintf(val, sizeof val, "%d", page);
+    if (meow_config_set(key, val) != MEOW_CFG_OK)
+        meow_log(MEOW_LOG_WARN, "reader: save page failed (best-effort)");
+}
+
+int mr_cont_get_mode(const char *dir, int def)
+{
+    char key[64];
+    char buf[16];
+    if (!mr_mode_valid(def)) def = MR_MODE_PAGED;
+    if (mr_cont_key(dir, "mode", key, (int)sizeof key) != 0) return def;
+    if (meow_config_get(key, buf, (int)sizeof buf) != MEOW_CFG_OK) return def;
+    int m = mr_mode_parse(buf);
+    return m >= 0 ? m : def;
+}
+
+void mr_cont_set_mode(const char *dir, int mode)
+{
+    char key[64];
+    if (!mr_mode_valid(mode)) return;
+    if (mr_cont_key(dir, "mode", key, (int)sizeof key) != 0) return;
+    if (meow_config_set(key, mr_mode_name(mode)) != MEOW_CFG_OK)
+        meow_log(MEOW_LOG_WARN, "reader: save mode failed (best-effort)");
+}
+
+void mr_cont_save(const char *dir, int page, int mode)
+{
+    if (!dir || !dir[0]) return;
+    mr_cont_set_page(dir, page);
+    mr_cont_set_mode(dir, mode);
+}
+
+int mr_cont_badge(const char *dir, char *out, int outsz)
+{
+    if (!out || outsz <= 0) return 0;
+    out[0] = '\0';
+    int page = mr_cont_get_page(dir, -1);
+    if (page <= 0) return 0;
+    snprintf(out, (size_t)outsz, "续读 P%d", page + 1);
+    return 1;
+}

tuku/logic/reader.h

@@ -1,6 +1,7 @@
-/* logic/reader.h — 阅读器纯逻辑接缝（M4 填充实现，M3 先落状态 API）。
+/* logic/reader.h — 阅读器纯逻辑接缝（M4 填充实现，M3 先落状态 API；M7 追加模式与每册续读状态）。
  *
  * 阅读方向默认 RTL（日式漫画从右往左翻）；设置页/阅读器可切 LTR。
+ * 阅读模式（翻页/条漫）与每册 last page 走 meow_config 持久化，键含册标识。
  * 本模块保持纯 C（不 include meow_ui.h），宿主可直接测。
  */
 #ifndef MR_READER_H
@@ -17,6 +18,36 @@ int  mr_reader_get_direction(void);
 /* 只接受 MR_DIR_RTL / MR_DIR_LTR；其它值忽略（保持原方向）。 */
 void mr_reader_set_direction(int dir);
 
+/* ============================================================ */
+/* 阅读模式（M7）：左右翻页 / 条漫竖向连续滚动                    */
+/* ============================================================ */
+#define MR_MODE_PAGED   0   /* 左右翻页（默认） */
+#define MR_MODE_WEBTOON 1   /* 条漫：垂直连续滚动 */
+
+int         mr_mode_valid(int mode);
+const char *mr_mode_name(int mode);    /* "paged" / "webtoon"（配置值；非法按 paged） */
+int         mr_mode_parse(const char *s);   /* -1=未知 */
+
+/* ============================================================ */
+/* 每册续读状态（last page + mode，meow_config 持久化）           */
+/* ------------------------------------------------------------
+ * 键 = reader.<field>.<FNV-1a64(规范化目录路径)>：同一册（同一目录）跨启动恢复，
+ * 不同册互不影响；目录改名/移动视为新册。写失败只 WARN（best-effort，不阻断阅读）。
+ * 依赖：只 include 配置/日志两个模块头，宿主测试用 settings_reader_stub 顶替。
+ * ============================================================ */
+#define MR_CONT_PATH_MAX  512     /* 册路径规范化的本地缓冲（同 MR_PATH_MAX 口径） */
+#define MR_CONT_PAGE_MAX  1000000 /* 配置里 last page 的合理上限（防坏值） */
+
+int  mr_cont_key(const char *dir, const char *field, char *out, int outsz);
+int  mr_cont_get_mode(const char *dir, int def);
+void mr_cont_set_mode(const char *dir, int mode);
+int  mr_cont_get_page(const char *dir, int def);
+void mr_cont_set_page(const char *dir, int page);
+/* 一次写 page+mode（尽最大努力，两键分别尝试）。 */
+void mr_cont_save(const char *dir, int page, int mode);
+/* 书库行续读角标：1=写入 "续读 P5"（page>0 才有记录）；0=无。 */
+int  mr_cont_badge(const char *dir, char *out, int outsz);
+
 #ifdef __cplusplus
 }
 #endif

tuku/logic/reader/nav.c

@@ -1,5 +1,8 @@
 /* logic/reader/nav.c — 阅读导航纯逻辑实现（见 nav.h 的方向语义说明）。 */
 #include "logic/reader/nav.h"
+#include "logic/reader/page_source.h"   /* MR_BOOK_MAX_PAGES（条漫排版页数上限） */
+
+#include <stdlib.h>
 
 int mr_nav_tap_zone(int x, int view_w)
 {
@@ -118,3 +121,209 @@ int mr_nav_fit_next(int fit)
     if (fit < 0 || fit >= MR_FIT_COUNT) return MR_FIT_WIDTH;
     return (fit + 1) % MR_FIT_COUNT;
 }
+
+/* ============================================================ */
+/* 条漫排版 / 滚动窗口                                           */
+/* ============================================================ */
+static int strip_page_height(int src_w, int src_h, int vw)
+{
+    long long h;
+    if (vw <= 0) vw = 1;
+    if (src_w > 0 && src_h > 0)
+        h = (long long)src_h * vw / src_w;      /* 适宽等比 */
+    else
+        h = (long long)vw * 3 / 2;              /* 未知尺寸：2:3 竖图占位 */
+    if (h < 1) h = 1;
+    if (h > MR_STRIP_MAX_PAGE_H) h = MR_STRIP_MAX_PAGE_H;
+    return (int)h;
+}
+
+void mr_strip_free(mr_strip *s)
+{
+    if (!s) return;
+    free(s->top);
+    free(s->height);
+    s->top = NULL;
+    s->height = NULL;
+    s->count = s->total = 0;
+    s->vw = s->vh = 0;
+}
+
+int mr_strip_build(mr_strip *s, int count, int vw, int vh,
+                   mr_strip_meta_fn meta, void *ctx)
+{
+    if (!s) return -1;
+    mr_strip_free(s);
+    if (count <= 0 || count > MR_BOOK_MAX_PAGES || vw <= 0 || vh <= 0) return -1;
+
+    s->top = (int *)calloc((size_t)count + 1, sizeof *s->top);
+    s->height = (int *)calloc((size_t)count, sizeof *s->height);
+    if (!s->top || !s->height) { mr_strip_free(s); return -1; }
+
+    s->count = count;
+    s->vw = vw;
+    s->vh = vh;
+    long long y = 0;
+    for (int i = 0; i < count; i++) {
+        int sw = 0, sh = 0;
+        if (meta && !meta(ctx, i, &sw, &sh)) { sw = sh = 0; }   /* 未知/失败 → 占位 */
+        int h = strip_page_height(sw, sh, vw);
+        s->height[i] = h;
+        s->top[i] = (int)y;
+        y += h;
+        if (y > 1000000000LL) {                 /* 累计偏移上限（防溢出；正常书远达不到） */
+            y = 1000000000LL;
+            for (int k = i + 1; k < count; k++) {
+                s->height[k] = 1;
+                s->top[k] = (int)y;
+                y += 1;
+                if (y > 1000000000LL) y = 1000000000LL;
+            }
+            s->top[count] = (int)y;
+            s->total = (int)y;
+            return 0;
+        }
+    }
+    s->top[count] = (int)y;
+    s->total = (int)y;
+    return 0;
+}
+
+int mr_strip_page_h(const mr_strip *s, int index)
+{
+    if (!s || !s->height || index < 0 || index >= s->count) return 0;
+    return s->height[index];
+}
+
+int mr_strip_top(const mr_strip *s, int index)
+{
+    if (!s || !s->top || index < 0 || index > s->count) return 0;
+    return s->top[index];
+}
+
+int mr_strip_total(const mr_strip *s)
+{
+    return s ? s->total : 0;
+}
+
+int mr_strip_max_offset(const mr_strip *s)
+{
+    if (!s || s->count <= 0) return 0;
+    int m = s->total - s->vh;
+    return m > 0 ? m : 0;
+}
+
+int mr_strip_page_at(const mr_strip *s, int off)
+{
+    if (!s || s->count <= 0 || !s->top) return -1;
+    if (off <= 0) return 0;
+    if (off >= s->total) return s->count - 1;
+    int lo = 0, hi = s->count - 1;
+    while (lo < hi) {                           /* 最大的 top[i] <= off */
+        int mid = lo + (hi - lo + 1) / 2;
+        if (s->top[mid] <= off) lo = mid;
+        else hi = mid - 1;
+    }
+    return lo;
+}
+
+int mr_strip_offset_for_page(const mr_strip *s, int page)
+{
+    if (!s || s->count <= 0) return -1;
+    if (page < 0) page = 0;
+    if (page >= s->count) page = s->count - 1;
+    int off = s->top[page];
+    int m = mr_strip_max_offset(s);
+    if (off > m) off = m;
+    if (off < 0) off = 0;
+    return off;
+}
+
+int mr_strip_window(const mr_strip *s, int off, int max_pages,
+                    int *first, int *last)
+{
+    if (first) *first = 0;
+    if (last) *last = -1;
+    if (!s || s->count <= 0) return 0;
+    if (max_pages <= 0) max_pages = 1;
+
+    int m = mr_strip_max_offset(s);
+    if (off < 0) off = 0;
+    if (off > m) off = m;
+
+    int f = mr_strip_page_at(s, off);
+    int l = mr_strip_page_at(s, off + s->vh - 1);
+    if (l < f) l = f;
+
+    int lo = f - 1;                             /* 视口 ±1 页 */
+    int hi = l + 1;
+    if (lo < 0) lo = 0;
+    if (hi > s->count - 1) hi = s->count - 1;
+    if (hi - lo + 1 > max_pages) {              /* 驻留上限：从视口中心向外截 */
+        int center = (f + l) / 2;
+        lo = center - (max_pages - 1) / 2;
+        hi = lo + max_pages - 1;
+        if (lo < 0) { lo = 0; hi = max_pages - 1; }
+        if (hi > s->count - 1) { hi = s->count - 1; lo = hi - max_pages + 1; }
+        if (lo < 0) lo = 0;
+    }
+    if (first) *first = lo;
+    if (last) *last = hi;
+    return hi - lo + 1;
+}
+
+int mr_strip_at_end(const mr_strip *s, int off)
+{
+    if (!s || s->count <= 0) return 0;
+    return off >= mr_strip_max_offset(s);
+}
+
+int mr_strip_at_start(const mr_strip *s, int off)
+{
+    if (!s || s->count <= 0) return 0;
+    return off <= 0;
+}
+
+/* ============================================================ */
+/* 跳页状态                                                     */
+/* ============================================================ */
+void mr_jump_cancel(mr_jump *j)
+{
+    if (!j) return;
+    j->pending = 0;
+    j->target = -1;
+    j->t0 = 0;
+}
+
+void mr_jump_begin(mr_jump *j, int page, int count, unsigned long long now)
+{
+    if (!j) return;
+    if (count <= 0 || page < 0 || page >= count) { mr_jump_cancel(j); return; }
+    j->pending = 1;
+    j->target = page;
+    j->t0 = now;
+}
+
+int mr_jump_active(const mr_jump *j)
+{
+    return j && j->pending ? 1 : 0;
+}
+
+int mr_jump_target(const mr_jump *j)
+{
+    return (j && j->pending) ? j->target : -1;
+}
+
+int mr_jump_poll(mr_jump *j, int have_img, unsigned long long now,
+                 unsigned long long timeout_ms, int *timed_out)
+{
+    if (timed_out) *timed_out = 0;
+    if (!j || !j->pending) return 0;
+    if (have_img) { mr_jump_cancel(j); return 1; }
+    if (timeout_ms > 0 && now - j->t0 >= timeout_ms) {
+        mr_jump_cancel(j);
+        if (timed_out) *timed_out = 1;
+        return 1;
+    }
+    return 0;
+}

tuku/logic/reader/nav.h

@@ -64,6 +64,65 @@ int mr_nav_slide_from(int rtl, int delta, int view_w);
 /* fit 档循环：适宽 → 适高 → 原始 → 适宽。 */
 int mr_nav_fit_next(int fit);
 
+/* ============================================================ */
+/* 条漫（M7）：竖向连续滚动的排版 / 滚动窗口 / 跳页状态           */
+/* ------------------------------------------------------------
+ * 排版用页源契约的 meta()（原始像素尺寸，不解码）：每页按屏宽等比换算显示高度，
+ * 累加成「整条」的 y 偏移表。未知尺寸的页按 2:3 竖图占位（排版稳定，解码后不改布局）。
+ * 全部纯整数运算、无 SDK 依赖；reader.c 与宿主测试共用（logic/reader/nav.c）。
+ * ============================================================ */
+#define MR_STRIP_MAX_PAGE_H 200000   /* 单页显示高度上限（防坏头/极端长图撑爆累计偏移） */
+
+typedef struct mr_strip {
+    int  count;
+    int  vw, vh;
+    int *top;        /* count+1 个：top[i]=第 i 页顶端偏移；top[count]=整条总高 */
+    int *height;     /* count 个：每页显示高度（>=1） */
+    int  total;
+} mr_strip;
+
+/* 页尺寸回调（通常是 mr_book_meta）：1=已知原始尺寸，0=未知。 */
+typedef int (*mr_strip_meta_fn)(void *ctx, int index, int *w, int *h);
+
+/* 建排版表。0=成功；参数非法/内存不足 -1（已清空、可安全 free）。 */
+int  mr_strip_build(mr_strip *s, int count, int vw, int vh,
+                    mr_strip_meta_fn meta, void *ctx);
+/* 释放偏移表并清零（可重复调用）。 */
+void mr_strip_free(mr_strip *s);
+
+int  mr_strip_page_h(const mr_strip *s, int index);      /* 越界 0 */
+int  mr_strip_top(const mr_strip *s, int index);         /* index==count 返回总高；越界 0 */
+int  mr_strip_total(const mr_strip *s);
+int  mr_strip_max_offset(const mr_strip *s);             /* max(0, total-vh) */
+/* 视口顶端（off）落在哪一页；空册 -1。 */
+int  mr_strip_page_at(const mr_strip *s, int off);
+/* 落位到某页顶端所需的滚动量（夹到 [0,max_offset]）；空册 -1。 */
+int  mr_strip_offset_for_page(const mr_strip *s, int page);
+/* 视口可见页范围 [first,last] + ±1 解码窗，条数不超过 max_pages。
+ * 返回窗口页数；空册 0。first/last 可 NULL。 */
+int  mr_strip_window(const mr_strip *s, int off, int max_pages,
+                     int *first, int *last);
+int  mr_strip_at_end(const mr_strip *s, int off);        /* 1=已到条底 */
+int  mr_strip_at_start(const mr_strip *s, int off);      /* 1=已在条顶 */
+
+/* ---- 跳页（chrome 滑块）：目标页预解码完成后再落位，避免白屏/闪烁 ---- */
+typedef struct mr_jump {
+    int pending;                 /* 1=正在等目标页 */
+    int target;                  /* 目标页；pending==0 时无意义 */
+    unsigned long long t0;       /* 开始等待的时刻（ms） */
+} mr_jump;
+
+/* 开始跳页：page 夹到 [0,count)；count<=0 或 page<0 时取消。 */
+void mr_jump_begin(mr_jump *j, int page, int count, unsigned long long now);
+int  mr_jump_active(const mr_jump *j);
+int  mr_jump_target(const mr_jump *j);      /* 无 pending 返回 -1 */
+void mr_jump_cancel(mr_jump *j);
+/* 轮询：have_img=目标页是否已解码。1=可以落位（已清除 pending）；
+ * timed_out 非 NULL 时写入「是否因超时落位」（调用方据此提示降级）。
+ * 未就绪且未超时返回 0（继续等）。 */
+int  mr_jump_poll(mr_jump *j, int have_img, unsigned long long now,
+                  unsigned long long timeout_ms, int *timed_out);
+
 #ifdef __cplusplus
 }
 #endif