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

tuku/test/run_webtoon_tests.sh

@@ -0,0 +1,47 @@
+#!/bin/bash
+# run_webtoon_tests.sh — M7 条漫/模式/续读/跳页宿主测试（纯 C，不链 SDK、不需要设备）。
+#   - test_webtoon_strip：条漫排版（适宽高度/偏移表/可见窗口/未知尺寸兜底/跳页互逆）
+#   - test_jump_page：跳页状态机（预解码落位/超时降级/非法目标）与落位偏移映射
+#   - test_mode_persist：阅读模式与每册 last page 的 meow_config 持久化/坏值/写失败
+#   - test_cont_adjacent：册间自然序边界（首/末册/嵌套/符号链接）+ 书库续读角标
+# 编译口径同 test/run_tests.sh（-I. + SDK 头，不链 meow_ui.a；配置/日志用存根）。
+set -e
+cd "$(dirname "$0")/.."
+SDK="${MEOW_SDK_DIR:-$HOME/Proj/MeowOS-SDK/sdk}"
+CFLAGS="-Wall -Wextra -O1 -I. -I$SDK"
+OUT="build/host"
+mkdir -p "$OUT"
+
+gcc $CFLAGS test/test_webtoon_strip.c logic/reader/nav.c -o "$OUT/test_webtoon_strip"
+"$OUT/test_webtoon_strip"
+
+gcc $CFLAGS test/test_jump_page.c logic/reader/nav.c -o "$OUT/test_jump_page"
+"$OUT/test_jump_page"
+
+gcc $CFLAGS test/test_mode_persist.c logic/reader.c test/settings_reader_stub.c \
+    -o "$OUT/test_mode_persist"
+"$OUT/test_mode_persist"
+
+gcc $CFLAGS test/test_cont_adjacent.c logic/library.c logic/reader.c \
+    test/settings_reader_stub.c -o "$OUT/test_cont_adjacent"
+"$OUT/test_cont_adjacent"
+
+# 可选：真实 SDK 源码树上的阅读器集成测试（模式切换/续读/跳页/册间衔接）。
+# 只发布 meow_ui.a 的交付环境自动 SKIP（与 test/run_tests.sh 的 settings_lock_host 同口径）。
+if [ -f "$SDK/meow_ui_view.c" ] && [ -f "$SDK/meow_ui_config.c" ]; then
+    gcc $CFLAGS -DMEOW_UI_HOST_TEST -DMR_READER_HOST_TEST -I"$SDK/include" \
+        test/test_mode_switch_host.c ui/reader/reader.c \
+        logic/library.c logic/reader.c logic/reader/page_source.c logic/reader/nav.c \
+        "$SDK"/meow_ui_gfx.c "$SDK"/meow_ui_sys.c "$SDK"/meow_ui_theme.c \
+        "$SDK"/meow_ui_vol.c "$SDK"/meow_ui_log.c "$SDK"/meow_ui_widget.c \
+        "$SDK"/meow_ui_input.c "$SDK"/meow_ui_activity.c "$SDK"/meow_ui_dialog.c \
+        "$SDK"/meow_ui_ime.c "$SDK"/meow_ui_str.c "$SDK"/meow_pinyin.c \
+        "$SDK"/meow_ui_draw.c "$SDK"/meow_ui_view.c "$SDK"/meow_ui_box.c \
+        "$SDK"/meow_ui_anim.c "$SDK"/meow_ui_scroll.c "$SDK"/meow_ui_img.c \
+        "$SDK"/meow_ui_media.c "$SDK"/meow_notify_ipc.c "$SDK"/meow_ui_config.c \
+        "$SDK"/meow_ui_nav.c "$SDK"/stb_image.c "$SDK"/test_host_stub.c \
+        -pthread -lm -o "$OUT/test_mode_switch_host"
+    "$OUT/test_mode_switch_host"
+else
+    echo "SKIP test_mode_switch_host: SDK 源码树不可用（只发布 meow_ui.a 的环境）"
+fi

tuku/test/test_cont_adjacent.c

@@ -0,0 +1,249 @@
+/* test_cont_adjacent.c — 册间顺序边界 + 书库续读角标宿主测试（无 SDK/硬件）。
+ *
+ * 覆盖：
+ *   A1 「直接含图」判定：含图目录=书；只有子目录含图/空目录/仅非图文件=不是书；
+ *   A2 兄弟册排序：同父目录、书库自然序（vol2 < vol10）；首/末册无相邻返回 0；
+ *   A3 边界：末页前进→下一册、首页后退→上一册（调用方语义）；路径末尾斜杠等价；
+ *   A4 排除：隐藏/系统目录、符号链接、普通文件不参与兄弟册；
+ *   A5 参数：delta 非 ±1、NULL/小缓冲、不存在的目录；
+ *   A6 书库扫描接线：有续读记录的册，行副标题出现「· 续读 Pn」角标。
+ *
+ * 编译（在 tuku/ 下）：
+ *   gcc -Wall -Wextra -O1 -I. test/test_cont_adjacent.c logic/library.c logic/reader.c \
+ *       test/settings_reader_stub.c -o test/test_cont_adjacent
+ * 或 test/run_webtoon_tests.sh。
+ */
+#include "logic/library.h"
+#include "logic/reader.h"
+#include "test/settings_reader_stub.h"
+
+#include <dirent.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/stat.h>
+#include <unistd.h>
+
+static int g_pass, g_fail;
+#define CHECK(cond, ...) do { \
+    if (cond) { g_pass++; } \
+    else { g_fail++; printf("FAIL %s:%d  ", __FILE__, __LINE__); printf(__VA_ARGS__); printf("\n"); } \
+} while (0)
+
+static int mkdir_p(const char *path)
+{
+    char tmp[MR_PATH_MAX];
+    snprintf(tmp, sizeof tmp, "%s", path);
+    for (size_t i = 1; i <= strlen(tmp); i++) {
+        if (tmp[i] == '/' || tmp[i] == '\0') {
+            char ch = tmp[i];
+            tmp[i] = '\0';
+            if (mkdir(tmp, 0755) != 0) {
+                struct stat st;
+                if (stat(tmp, &st) != 0 || !S_ISDIR(st.st_mode)) return -1;
+            }
+            tmp[i] = ch;
+        }
+    }
+    return 0;
+}
+
+static int touch_file(const char *path)
+{
+    FILE *f = fopen(path, "wb");
+    if (!f) return -1;
+    int ok = fwrite("x", 1, 1, f) == 1;
+    fclose(f);
+    return ok ? 0 : -1;
+}
+
+static int rm_rf(const char *path)
+{
+    struct stat st;
+    if (lstat(path, &st) != 0) return -1;
+    if (!S_ISDIR(st.st_mode)) return unlink(path);
+    DIR *d = opendir(path);
+    if (!d) return -1;
+    struct dirent *de;
+    while ((de = readdir(d)) != NULL) {
+        if (strcmp(de->d_name, ".") == 0 || strcmp(de->d_name, "..") == 0) continue;
+        char full[MR_PATH_MAX];
+        snprintf(full, sizeof full, "%s/%s", path, de->d_name);
+        rm_rf(full);
+    }
+    closedir(d);
+    return rmdir(path);
+}
+
+static void joinp(char *out, int outsz, const char *a, const char *b)
+{
+    snprintf(out, (size_t)outsz, "%s/%s", a, b);
+}
+
+static void test_has_images(const char *root)
+{
+    char p[MR_PATH_MAX];
+    CHECK(mr_library_dir_has_images(root) == 1,
+          "root has a loose image file (scan/adjacency only treats subdirs as books)");
+
+    joinp(p, sizeof p, root, "vol1");
+    CHECK(mr_library_dir_has_images(p) == 1, "vol1 is a book");
+    joinp(p, sizeof p, root, "dirs_only");
+    CHECK(mr_library_dir_has_images(p) == 0, "dirs_only is not a book");
+    joinp(p, sizeof p, root, "empty");
+    CHECK(mr_library_dir_has_images(p) == 0, "empty is not a book");
+    joinp(p, sizeof p, root, "txonly");
+    CHECK(mr_library_dir_has_images(p) == 0, "text-only dir is not a book");
+    CHECK(mr_library_dir_has_images("/no/such/dir/xyz") == 0, "missing dir");
+    CHECK(mr_library_dir_has_images(NULL) == 0 && mr_library_dir_has_images("") == 0,
+          "NULL/empty safe");
+}
+
+static void expect_neighbor(const char *dir, int delta, const char *want, const char *tag)
+{
+    char out[MR_PATH_MAX];
+    int r = mr_book_adjacent(dir, delta, out, (int)sizeof out);
+    if (!want) {
+        CHECK(r == 0 && out[0] == '\0', "%s: no neighbor (r=%d out=%s)", tag, r, out);
+    } else {
+        CHECK(r == 1 && strcmp(out, want) == 0, "%s: got %s (want %s)", tag, out, want);
+    }
+}
+
+static void test_adjacent(const char *root)
+{
+    char vol1[MR_PATH_MAX], vol2[MR_PATH_MAX], vol10[MR_PATH_MAX];
+    char series_a[MR_PATH_MAX], series_b[MR_PATH_MAX];
+    char dirs_only[MR_PATH_MAX], out[MR_PATH_MAX];
+
+    joinp(vol1, sizeof vol1, root, "vol1");
+    joinp(vol2, sizeof vol2, root, "vol2");
+    joinp(vol10, sizeof vol10, root, "vol10");
+    joinp(series_a, sizeof series_a, root, "series/a");
+    joinp(series_b, sizeof series_b, root, "series/b");
+    joinp(dirs_only, sizeof dirs_only, root, "dirs_only");
+
+    /* 自然序：vol1 < vol2 < vol10（vol0 是符号链接，不参与） */
+    expect_neighbor(vol1, 1, vol2, "vol1 next");
+    expect_neighbor(vol2, 1, vol10, "vol2 next");
+    expect_neighbor(vol10, 1, NULL, "vol10 next (end)");
+    expect_neighbor(vol1, -1, NULL, "vol1 prev (start)");
+    expect_neighbor(vol2, -1, vol1, "vol2 prev");
+    expect_neighbor(vol10, -1, vol2, "vol10 prev");
+
+    /* 末尾斜杠等价 */
+    char slash[MR_PATH_MAX];
+    snprintf(slash, sizeof slash, "%s/", vol2);
+    expect_neighbor(slash, 1, vol10, "trailing slash next");
+    expect_neighbor(slash, -1, vol1, "trailing slash prev");
+
+    /* 嵌套父目录：series/a <-> series/b */
+    expect_neighbor(series_a, 1, series_b, "series a next");
+    expect_neighbor(series_b, -1, series_a, "series b prev");
+    expect_neighbor(series_b, 1, NULL, "series b next (end)");
+
+    /* 不是书的目录：不在兄弟表中 */
+    expect_neighbor(dirs_only, 1, NULL, "dirs_only not a book");
+    expect_neighbor(dirs_only, -1, NULL, "dirs_only not a book prev");
+
+    /* 路径参数：delta/缓冲/不存在 */
+    CHECK(mr_book_adjacent(vol1, 0, out, (int)sizeof out) == -1, "delta 0 invalid");
+    CHECK(mr_book_adjacent(vol1, 2, out, (int)sizeof out) == -1, "delta 2 invalid");
+    CHECK(mr_book_adjacent(vol1, -2, out, (int)sizeof out) == -1, "delta -2 invalid");
+    CHECK(mr_book_adjacent(NULL, 1, out, (int)sizeof out) == -1, "NULL dir");
+    CHECK(mr_book_adjacent(vol1, 1, NULL, 32) == -1, "NULL out");
+    CHECK(mr_book_adjacent(vol1, 1, out, 4) == 0, "small out -> no fit (0)");
+    CHECK(mr_book_adjacent("/no/such/book", 1, out, (int)sizeof out) == 0,
+          "missing parent -> 0");
+    CHECK(mr_book_adjacent("/", 1, out, (int)sizeof out) == -1, "root path invalid");
+}
+
+static void test_library_badge(const char *root)
+{
+    mr_test_cfg_clear();
+    char vol1[MR_PATH_MAX], vol2[MR_PATH_MAX];
+    joinp(vol1, sizeof vol1, root, "vol1");
+    joinp(vol2, sizeof vol2, root, "vol2");
+
+    /* vol1 有续读记录（第 5 页），vol2 没有 */
+    mr_cont_save(vol1, 4, MR_MODE_WEBTOON);
+
+    mr_library lib;
+    memset(&lib, 0, sizeof lib);
+    int n = mr_library_scan(&lib, root, MR_LIB_MAX_DEPTH);
+    CHECK(n > 0, "library scan n=%d", n);
+
+    int seen1 = 0, seen2 = 0;
+    for (int i = 0; i < lib.count; i++) {
+        mr_library_entry *e = &lib.items[i];
+        if (strcmp(e->name, "vol1") == 0) {
+            seen1 = 1;
+            CHECK(strstr(e->subtitle, "续读 P5") != NULL, "vol1 subtitle=%s", e->subtitle);
+            CHECK(strstr(e->subtitle, "page") != NULL, "vol1 keeps pages text: %s", e->subtitle);
+        }
+        if (strcmp(e->name, "vol2") == 0) {
+            seen2 = 1;
+            CHECK(strstr(e->subtitle, "续读") == NULL, "vol2 no badge: %s", e->subtitle);
+            CHECK(strcmp(e->subtitle, "1 page") == 0, "vol2 subtitle=%s", e->subtitle);
+        }
+    }
+    CHECK(seen1 == 1, "vol1 listed");
+    CHECK(seen2 == 1, "vol2 listed");
+    mr_library_free(&lib);
+
+    /* 记录清除后角标消失 */
+    mr_cont_save(vol1, 0, MR_MODE_WEBTOON);
+    memset(&lib, 0, sizeof lib);
+    CHECK(mr_library_scan(&lib, root, MR_LIB_MAX_DEPTH) > 0, "rescan");
+    for (int i = 0; i < lib.count; i++)
+        if (strcmp(lib.items[i].name, "vol1") == 0)
+            CHECK(strstr(lib.items[i].subtitle, "续读") == NULL, "cleared badge gone");
+    mr_library_free(&lib);
+}
+
+int main(void)
+{
+    char tmpl[] = "./mr_cont_adj_XXXXXX";
+    char *root = mkdtemp(tmpl);
+    CHECK(root != NULL, "mkdtemp");
+    if (!root) return 1;
+
+    char p[MR_PATH_MAX];
+    const char *books[] = { "vol1", "vol2", "vol10", "series/a", "series/b", "dirs_only/inside" };
+    for (unsigned i = 0; i < sizeof books / sizeof books[0]; i++) {
+        joinp(p, sizeof p, root, books[i]);
+        CHECK(mkdir_p(p) == 0, "mkdir %s", p);
+        char img[MR_PATH_MAX];
+        joinp(img, sizeof img, p, "001.png");
+        CHECK(touch_file(img) == 0, "image %s", img);
+    }
+    joinp(p, sizeof p, root, "empty");
+    mkdir_p(p);
+    joinp(p, sizeof p, root, "txonly");
+    mkdir_p(p);
+    joinp(p, sizeof p, root, "txonly/readme.txt");
+    touch_file(p);
+    joinp(p, sizeof p, root, ".hidden");
+    mkdir_p(p);
+    joinp(p, sizeof p, root, ".hidden/001.png");
+    touch_file(p);
+    joinp(p, sizeof p, root, "MeowOS");
+    mkdir_p(p);
+    joinp(p, sizeof p, root, "MeowOS/001.png");
+    touch_file(p);
+    joinp(p, sizeof p, root, "loose.png");
+    touch_file(p);
+
+    char vol1[MR_PATH_MAX], vol0[MR_PATH_MAX];
+    joinp(vol1, sizeof vol1, root, "vol1");
+    joinp(vol0, sizeof vol0, root, "vol0");
+    if (symlink(vol1, vol0) == 0) { /* 有权限才测；无权限时 symlink 失败也不影响上面的断言 */ }
+
+    test_has_images(root);
+    test_adjacent(root);
+    test_library_badge(root);
+
+    rm_rf(root);
+    printf("%s: %d passed, %d failed\n", g_fail ? "FAIL" : "PASS", g_pass, g_fail);
+    return g_fail ? 1 : 0;
+}

tuku/test/test_jump_page.c

@@ -0,0 +1,140 @@
+/* test_jump_page.c — 跳页状态机 + 条漫落位映射宿主测试（无 SDK/硬件）。
+ *
+ * 覆盖：
+ *   J1 跳页状态：begin 夹取/非法取消、active/target、预解码就绪落位、超时降级落位；
+ *   J2 落位映射：mr_strip_offset_for_page 与 page_at 互逆（首/中/末页，max 夹取）；
+ *   J3 边界：空册/越界/重复取消；正常等待不提前落位（不白屏——没有图就不落）。
+ *
+ * 编译（在 tuku/ 下）：
+ *   gcc -Wall -Wextra -O1 -I. test/test_jump_page.c logic/reader/nav.c \
+ *       -o test/test_jump_page && ./test/test_jump_page
+ * 或 test/run_webtoon_tests.sh。
+ */
+#include "logic/reader/nav.h"
+
+#include <stdio.h>
+#include <string.h>
+
+static int g_pass, g_fail;
+#define CHECK(cond, ...) do { \
+    if (cond) { g_pass++; } \
+    else { g_fail++; printf("FAIL %s:%d  ", __FILE__, __LINE__); printf(__VA_ARGS__); printf("\n"); } \
+} while (0)
+
+#define VW 480
+#define VH 720
+#define TIMEOUT 2500ULL
+
+static int g_meta_w[8], g_meta_h[8], g_meta_n;
+
+static int meta_cb(void *ctx, int i, int *w, int *h)
+{
+    (void)ctx;
+    if (i < 0 || i >= g_meta_n) return 0;
+    *w = g_meta_w[i];
+    *h = g_meta_h[i];
+    return 1;
+}
+
+static void build_strip(mr_strip *s, int pages)
+{
+    memset(s, 0, sizeof *s);
+    g_meta_n = pages;
+    for (int i = 0; i < pages; i++) {
+        g_meta_w[i] = 800;
+        g_meta_h[i] = 1200;              /* 适宽后每页 720px */
+    }
+    CHECK(mr_strip_build(s, pages, VW, VH, meta_cb, NULL) == 0, "build strip pages=%d", pages);
+}
+
+static void test_jump_state(void)
+{
+    mr_jump j;
+    memset(&j, 0, sizeof j);
+    CHECK(mr_jump_active(&j) == 0, "fresh inactive");
+    CHECK(mr_jump_target(&j) == -1, "fresh target -1");
+
+    /* 正常：开始 → 未就绪继续等 → 就绪落位 */
+    mr_jump_begin(&j, 4, 10, 100);
+    CHECK(mr_jump_active(&j) == 1 && mr_jump_target(&j) == 4, "begin active target=4");
+    int to = -1;
+    CHECK(mr_jump_poll(&j, 0, 200, TIMEOUT, &to) == 0 && to == 0, "waiting no timeout");
+    CHECK(mr_jump_active(&j) == 1, "still active while waiting");
+    CHECK(mr_jump_poll(&j, 1, 300, TIMEOUT, &to) == 1 && to == 0, "ready lands");
+    CHECK(mr_jump_active(&j) == 0 && mr_jump_target(&j) == -1, "cleared after land");
+
+    /* 超时：仍然落位，但标记降级 */
+    mr_jump_begin(&j, 2, 10, 1000);
+    CHECK(mr_jump_poll(&j, 0, 1000 + TIMEOUT - 1, TIMEOUT, &to) == 0, "just before timeout waits");
+    CHECK(mr_jump_poll(&j, 0, 1000 + TIMEOUT, TIMEOUT, &to) == 1 && to == 1, "timeout lands");
+    CHECK(mr_jump_active(&j) == 0, "timeout clears");
+
+    /* 就绪与超时同时成立：优先算正常就绪 */
+    mr_jump_begin(&j, 1, 10, 0);
+    CHECK(mr_jump_poll(&j, 1, 999999, TIMEOUT, &to) == 1 && to == 0,
+          "ready wins over timeout");
+
+    /* timeout=0 表示不限时 */
+    mr_jump_begin(&j, 1, 10, 0);
+    CHECK(mr_jump_poll(&j, 0, 999999999ULL, 0, &to) == 0 && to == 0, "no timeout when 0");
+
+    /* begin 夹取/非法 */
+    mr_jump_begin(&j, -1, 10, 0);
+    CHECK(mr_jump_active(&j) == 0, "begin(-1) cancels");
+    mr_jump_begin(&j, 10, 10, 0);
+    CHECK(mr_jump_active(&j) == 0, "begin(count) cancels");
+    mr_jump_begin(&j, 0, 0, 0);
+    CHECK(mr_jump_active(&j) == 0, "begin empty book cancels");
+
+    /* 取消幂等；NULL 安全 */
+    mr_jump_begin(&j, 3, 10, 5);
+    mr_jump_cancel(&j);
+    mr_jump_cancel(&j);
+    CHECK(mr_jump_active(&j) == 0, "cancel idempotent");
+    CHECK(mr_jump_poll(NULL, 1, 1, TIMEOUT, &to) == 0, "poll NULL");
+    mr_jump_cancel(NULL);
+    mr_jump_begin(NULL, 0, 10, 0);
+
+    /* timed_out 可为 NULL */
+    mr_jump_begin(&j, 5, 10, 0);
+    CHECK(mr_jump_poll(&j, 0, TIMEOUT + 1, TIMEOUT, NULL) == 1, "poll NULL timed_out");
+}
+
+static void test_land_mapping(void)
+{
+    mr_strip s;
+    build_strip(&s, 5);
+    CHECK(mr_strip_total(&s) == 3600, "total=%d", mr_strip_total(&s));
+    CHECK(mr_strip_max_offset(&s) == 2880, "max=%d", mr_strip_max_offset(&s));
+
+    int expect_top[5] = { 0, 720, 1440, 2160, 2880 };
+    for (int i = 0; i < 5; i++) {
+        int off = mr_strip_offset_for_page(&s, i);
+        CHECK(off == expect_top[i], "page %d offset %d (want %d)", i, off, expect_top[i]);
+        CHECK(mr_strip_page_at(&s, off) == i, "page_at(offset(%d)) == %d", i, i);
+    }
+    /* 末页顶端恰在 max（整页铺满视口），落位不会越界 */
+    CHECK(mr_strip_offset_for_page(&s, 4) == mr_strip_max_offset(&s), "last page == max");
+    /* page+1 的偏移等于 page 的末端（页间无缝） */
+    CHECK(mr_strip_top(&s, 1) == mr_strip_top(&s, 0) + mr_strip_page_h(&s, 0),
+          "page tops contiguous");
+
+    /* 跳页目标页必须在解码窗里（否则会被淘汰）：窗口只给 1 槽时也能覆盖目标 */
+    int f = -1, l = -1;
+    CHECK(mr_strip_window(&s, 0, 1, &f, &l) == 1 && f == l, "single-slot window");
+    mr_strip_free(&s);
+
+    /* 空册：没有可落位目标 */
+    mr_strip e;
+    memset(&e, 0, sizeof e);
+    CHECK(mr_strip_offset_for_page(&e, 0) == -1, "empty book no offset");
+    CHECK(mr_strip_page_at(&e, 0) == -1, "empty book no page");
+}
+
+int main(void)
+{
+    test_jump_state();
+    test_land_mapping();
+    printf("%s: %d passed, %d failed\n", g_fail ? "FAIL" : "PASS", g_pass, g_fail);
+    return g_fail ? 1 : 0;
+}

tuku/test/test_mode_persist.c

@@ -0,0 +1,165 @@
+/* test_mode_persist.c — 阅读模式 + 每册续读状态持久化宿主测试（无 SDK/硬件）。
+ *
+ * 覆盖：
+ *   P1 模式值：valid/name/parse（paged/webtoon，非法值回退）；
+ *   P2 册标识键：reader.page/mode.<FNV1a64(规范路径)>，末尾斜杠等价、不同册不同键、
+ *      键字符集安全（[A-Za-z0-9._-]）；
+ *   P3 默认值：无记录时 get_mode/get_page 返回调用方给的默认值；
+ *   P4 读写往返 + 册间隔离 + 一次 save 写两键；
+ *   P5 坏值/非法模式忽略（不覆盖已有记录）；写失败只 WARN 不崩；
+ *   P6 书库角标：page>0 → "续读 Pn"；page==0/无记录 → 无角标。
+ *
+ * 编译（在 tuku/ 下）：
+ *   gcc -Wall -Wextra -O1 -I. test/test_mode_persist.c logic/reader.c \
+ *       test/settings_reader_stub.c -o test/test_mode_persist
+ * 或 test/run_webtoon_tests.sh。
+ */
+#include "logic/reader.h"
+#include "test/settings_reader_stub.h"
+#include "include/meow_ui_config.h"
+
+#include <ctype.h>
+#include <stdio.h>
+#include <string.h>
+
+static int g_pass, g_fail;
+#define CHECK(cond, ...) do { \
+    if (cond) { g_pass++; } \
+    else { g_fail++; printf("FAIL %s:%d  ", __FILE__, __LINE__); printf(__VA_ARGS__); printf("\n"); } \
+} while (0)
+
+static void test_mode_values(void)
+{
+    CHECK(mr_mode_valid(MR_MODE_PAGED) == 1, "paged valid");
+    CHECK(mr_mode_valid(MR_MODE_WEBTOON) == 1, "webtoon valid");
+    CHECK(mr_mode_valid(-1) == 0 && mr_mode_valid(2) == 0, "invalid modes");
+    CHECK(strcmp(mr_mode_name(MR_MODE_PAGED), "paged") == 0, "name paged");
+    CHECK(strcmp(mr_mode_name(MR_MODE_WEBTOON), "webtoon") == 0, "name webtoon");
+    CHECK(strcmp(mr_mode_name(99), "paged") == 0, "name invalid -> paged");
+    CHECK(mr_mode_parse("paged") == MR_MODE_PAGED, "parse paged");
+    CHECK(mr_mode_parse("webtoon") == MR_MODE_WEBTOON, "parse webtoon");
+    CHECK(mr_mode_parse("WEBTOON") == -1, "parse case sensitive");
+    CHECK(mr_mode_parse("") == -1 && mr_mode_parse(NULL) == -1, "parse empty/NULL");
+}
+
+static void test_keys(void)
+{
+    char a[64], b[64], c[64];
+    CHECK(mr_cont_key("/sd/book1", "page", a, (int)sizeof a) == 0, "key ok");
+    CHECK(strncmp(a, "reader.page.", 12) == 0, "key prefix %s", a);
+    CHECK(strlen(a) == 12 + 16, "key len=%zu", strlen(a));
+    for (size_t i = 12; i < strlen(a); i++)
+        CHECK(isxdigit((unsigned char)a[i]) != 0, "key hex char");
+    CHECK(mr_cont_key("/sd/book1/", "page", b, (int)sizeof b) == 0, "key trailing slash");
+    CHECK(strcmp(a, b) == 0, "trailing slash normalizes: %s vs %s", a, b);
+    CHECK(mr_cont_key("/sd/book1", "mode", c, (int)sizeof c) == 0, "mode key");
+    CHECK(strncmp(c, "reader.mode.", 12) == 0, "mode prefix %s", c);
+    CHECK(strcmp(a, c) != 0, "field differs");
+    CHECK(mr_cont_key("/sd/book2", "page", c, (int)sizeof c) == 0, "book2 key");
+    CHECK(strcmp(a, c) != 0, "different books differ");
+
+    /* 参数/缓冲边界 */
+    CHECK(mr_cont_key(NULL, "page", a, (int)sizeof a) == -1, "NULL dir");
+    CHECK(mr_cont_key("", "page", a, (int)sizeof a) == -1, "empty dir");
+    CHECK(mr_cont_key("/a", NULL, a, (int)sizeof a) == -1, "NULL field");
+    CHECK(mr_cont_key("/a", "page", NULL, 32) == -1, "NULL out");
+    CHECK(mr_cont_key("/a", "page", a, 8) == -1 && a[0] == '\0', "small out");
+}
+
+static void test_defaults_and_roundtrip(void)
+{
+    mr_test_cfg_clear();
+    CHECK(mr_cont_get_mode("/sd/a", MR_MODE_PAGED) == MR_MODE_PAGED, "default paged");
+    CHECK(mr_cont_get_mode("/sd/a", MR_MODE_WEBTOON) == MR_MODE_WEBTOON, "default param used");
+    CHECK(mr_cont_get_page("/sd/a", 0) == 0, "default page 0");
+    CHECK(mr_cont_get_page("/sd/a", 7) == 7, "default page param");
+    CHECK(mr_cont_badge("/sd/a", NULL, 0) == 0, "badge NULL safe");
+
+    char badge[24];
+    CHECK(mr_cont_badge("/sd/a", badge, (int)sizeof badge) == 0 && badge[0] == '\0',
+          "no record -> no badge");
+
+    mr_cont_set_mode("/sd/a", MR_MODE_WEBTOON);
+    CHECK(mr_cont_get_mode("/sd/a", MR_MODE_PAGED) == MR_MODE_WEBTOON, "mode roundtrip");
+    CHECK(mr_cont_get_mode("/sd/b", MR_MODE_PAGED) == MR_MODE_PAGED, "mode isolated per book");
+
+    mr_cont_set_page("/sd/a", 17);
+    CHECK(mr_cont_get_page("/sd/a", -1) == 17, "page roundtrip");
+    CHECK(mr_cont_get_page("/sd/b", -1) == -1, "page isolated per book");
+    CHECK(mr_cont_badge("/sd/a", badge, (int)sizeof badge) == 1, "badge shown");
+    CHECK(strcmp(badge, "续读 P18") == 0, "badge text %s", badge);
+
+    /* 一次 save 两键（模式 + 页码） */
+    mr_cont_save("/sd/c", 3, MR_MODE_WEBTOON);
+    CHECK(mr_cont_get_page("/sd/c", -1) == 3, "save page");
+    CHECK(mr_cont_get_mode("/sd/c", MR_MODE_PAGED) == MR_MODE_WEBTOON, "save mode");
+    CHECK(mr_cont_badge("/sd/c", badge, (int)sizeof badge) == 1 &&
+          strcmp(badge, "续读 P4") == 0, "save badge %s", badge);
+
+    /* page 0 视为「没有进度」，不出角标 */
+    mr_cont_save("/sd/d", 0, MR_MODE_PAGED);
+    CHECK(mr_cont_badge("/sd/d", badge, (int)sizeof badge) == 0 && badge[0] == '\0',
+          "page 0 -> no badge");
+
+    /* NULL/空路径安全 */
+    mr_cont_set_page(NULL, 5);
+    mr_cont_set_mode(NULL, MR_MODE_WEBTOON);
+    mr_cont_save(NULL, 1, 1);
+    mr_cont_save("", 1, 1);
+    CHECK(mr_cont_get_page(NULL, 9) == 9 && mr_cont_get_mode(NULL, MR_MODE_PAGED) == MR_MODE_PAGED,
+          "NULL dir safe");
+}
+
+static void test_bad_values(void)
+{
+    mr_test_cfg_clear();
+    char key[64];
+    char buf[24];
+
+    /* 坏模式值 → 默认；坏页码（负数/非数字/超上限）→ 默认 */
+    CHECK(mr_cont_key("/sd/x", "mode", key, (int)sizeof key) == 0, "bad key");
+    mr_test_cfg_put(key, "vertical");
+    CHECK(mr_cont_get_mode("/sd/x", MR_MODE_PAGED) == MR_MODE_PAGED, "bad mode -> def");
+
+    CHECK(mr_cont_key("/sd/x", "page", key, (int)sizeof key) == 0, "bad page key");
+    mr_test_cfg_put(key, "-3");
+    CHECK(mr_cont_get_page("/sd/x", 11) == 11, "negative page -> def");
+    mr_test_cfg_put(key, "abc");
+    CHECK(mr_cont_get_page("/sd/x", 12) == 12, "non-numeric page -> def");
+    mr_test_cfg_put(key, "99999999");
+    CHECK(mr_cont_get_page("/sd/x", 13) == 13, "too-large page -> def");
+    mr_test_cfg_put(key, "0");
+    CHECK(mr_cont_get_page("/sd/x", 14) == 0, "zero page readable");
+
+    /* 非法模式值不覆盖已有记录 */
+    mr_cont_set_mode("/sd/y", MR_MODE_WEBTOON);
+    mr_cont_set_mode("/sd/y", 42);
+    CHECK(mr_cont_get_mode("/sd/y", MR_MODE_PAGED) == MR_MODE_WEBTOON, "invalid set ignored");
+
+    /* 写失败：只告警，内存保持旧值；不崩 */
+    mr_cont_save("/sd/z", 5, MR_MODE_PAGED);
+    int warns = mr_test_log_warns();
+    mr_test_cfg_fail_writes(1);
+    mr_cont_set_page("/sd/z", 9);
+    mr_cont_set_mode("/sd/z", MR_MODE_WEBTOON);
+    mr_cont_save("/sd/z", 10, MR_MODE_WEBTOON);
+    CHECK(mr_test_log_warns() > warns, "write failure warns (warns=%d)", mr_test_log_warns());
+    CHECK(mr_cont_get_page("/sd/z", -1) == 5, "failed write keeps old page");
+    CHECK(mr_cont_get_mode("/sd/z", MR_MODE_PAGED) == MR_MODE_PAGED, "failed write keeps old mode");
+    mr_test_cfg_fail_writes(0);
+
+    /* 写入后读回同一字符串（便于排查：paged/webtoon 明文） */
+    CHECK(mr_cont_key("/sd/y", "mode", key, (int)sizeof key) == 0, "read mode key");
+    CHECK(mr_test_cfg_get(key, buf, (int)sizeof buf) == 1 && strcmp(buf, "webtoon") == 0,
+          "stored mode string %s", buf);
+}
+
+int main(void)
+{
+    test_mode_values();
+    test_keys();
+    test_defaults_and_roundtrip();
+    test_bad_values();
+    printf("%s: %d passed, %d failed\n", g_fail ? "FAIL" : "PASS", g_pass, g_fail);
+    return g_fail ? 1 : 0;
+}

tuku/test/test_mode_switch_host.c

@@ -0,0 +1,273 @@
+/* test_mode_switch_host.c — 阅读器模式/续读/跳页/册间衔接的宿主集成测试（可选，需 SDK 源码树）。
+ *
+ * 只做纯逻辑测试覆盖不到的接缝：真实 SDK view/activity/widget + 真实图片解码 + 真实
+ * meow_scroll/meow_anim 节拍。用 40x60 BMP 当页图（stb 可解，无外部依赖），在临时目录
+ * 建两本相邻册，然后模拟用户操作：
+ *   H1 进入：默认翻页模式、页码 0、控件归属 ACT_READER（顶栏在 on_enter 建）；
+ *   H2 chrome 图标一键切模式：翻页 ⇄ 条漫，切换立即写 meow_config（每册记忆）；
+ *   H3 跳页滑块：展开 → 拖到末页 → 目标页解码完成后落位（不是先白屏再跳）；
+ *   H4 离开/重进：恢复上次页 + 模式（续读）；
+ *   H5 册间衔接：条漫末页上拉 → 下一册首页；首页下拉 → 上一册末页；首册再无上一册时
+ *      停在原地（不退出、不崩）。
+ *
+ * 编译：test/run_webtoon_tests.sh（需 SDK 源码树；只发布 meow_ui.a 时自动 SKIP）。
+ */
+#include "tuku_internal.h"
+#include "ui/reader/reader.h"
+#include "include/meow_ui_anim.h"
+#include "meow_ui_internal.h"   /* MEOW_EV_TAP / MEOW_EV_SWIPE（宿主测试内部头） */
+
+#include <dirent.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/stat.h>
+#include <unistd.h>
+
+static int g_fail;
+#define CHECK(cond, ...) do { \
+    if (cond) { printf("  PASS\n"); } \
+    else { g_fail++; printf("  FAIL %s:%d  ", __FILE__, __LINE__); printf(__VA_ARGS__); printf("\n"); } \
+} while (0)
+
+/* app.c 的导航上报在测试里不需要网络侧实现。 */
+void mr_nav_report(void) {}
+
+static int g_lib_enters;
+static void lib_enter(meow_view *v, void *c) { (void)v; (void)c; g_lib_enters++; }
+static void lib_leave(meow_view *v, void *c) { (void)v; (void)c; }
+
+/* ---- 临时目录 + 最小 BMP24（stb 可解） ---- */
+static void put16(unsigned char *p, unsigned v) { p[0] = (unsigned char)v; p[1] = (unsigned char)(v >> 8); }
+static void put32(unsigned char *p, unsigned v)
+{
+    p[0] = (unsigned char)v; p[1] = (unsigned char)(v >> 8);
+    p[2] = (unsigned char)(v >> 16); p[3] = (unsigned char)(v >> 24);
+}
+
+static int write_bmp24(const char *path, int w, int h)
+{
+    int stride = ((w * 3 + 3) / 4) * 4;
+    int imgsz = stride * h;
+    unsigned char fh[14] = { 0 }, ih[40] = { 0 };
+    fh[0] = 'B'; fh[1] = 'M';
+    put32(fh + 2, (unsigned)(54 + imgsz));
+    put32(fh + 10, 54);
+    put32(ih + 0, 40);
+    put32(ih + 4, (unsigned)w);
+    put32(ih + 8, (unsigned)h);
+    put16(ih + 12, 1);
+    put16(ih + 14, 24);
+    put32(ih + 20, (unsigned)imgsz);
+
+    FILE *f = fopen(path, "wb");
+    if (!f) return -1;
+    int ok = fwrite(fh, 1, sizeof fh, f) == sizeof fh &&
+             fwrite(ih, 1, sizeof ih, f) == sizeof ih;
+    unsigned char *row = (unsigned char *)calloc(1, (size_t)stride);
+    if (!row) ok = 0;
+    for (int y = 0; ok && y < h; y++)
+        if (fwrite(row, 1, (size_t)stride, f) != (size_t)stride) ok = 0;
+    free(row);
+    if (fclose(f) != 0) ok = 0;
+    return ok ? 0 : -1;
+}
+
+static int mkdir_p(const char *path)
+{
+    char tmp[MR_PATH_MAX];
+    snprintf(tmp, sizeof tmp, "%s", path);
+    for (size_t i = 1; i <= strlen(tmp); i++) {
+        if (tmp[i] == '/' || tmp[i] == '\0') {
+            char ch = tmp[i];
+            tmp[i] = '\0';
+            if (mkdir(tmp, 0755) != 0) {
+                struct stat st;
+                if (stat(tmp, &st) != 0 || !S_ISDIR(st.st_mode)) return -1;
+            }
+            tmp[i] = ch;
+        }
+    }
+    return 0;
+}
+
+static int rm_rf(const char *path)
+{
+    struct stat st;
+    if (lstat(path, &st) != 0) return -1;
+    if (!S_ISDIR(st.st_mode)) return unlink(path);
+    DIR *d = opendir(path);
+    if (!d) return -1;
+    struct dirent *de;
+    while ((de = readdir(d)) != NULL) {
+        if (strcmp(de->d_name, ".") == 0 || strcmp(de->d_name, "..") == 0) continue;
+        char full[MR_PATH_MAX];
+        snprintf(full, sizeof full, "%s/%s", path, de->d_name);
+        rm_rf(full);
+    }
+    closedir(d);
+    return rmdir(path);
+}
+
+/* 驱动 SDK 动画节拍（宿主没有 meow_ui_run 主循环）。 */
+static void pump_ms(int ms)
+{
+    for (int i = 0; i < ms / 10; i++) {
+        usleep(10 * 1000);
+        meow_anim_tick();
+    }
+}
+
+/* 模拟 app.c 的点击路由：on_touch_down → on_tap（阅读页 tap 不在 view on_event 里）。 */
+static int tap(int x, int y)
+{
+    reader_on_touch_down(x, y);
+    reader_on_tap(x, y);
+    return 1;
+}
+
+static int swipe(int dir, int dist)
+{
+    return meow_view_dispatch_event(MEOW_EV_SWIPE, dir, dist);
+}
+
+int main(void)
+{
+    const char *base = getenv("TMPDIR");
+    if (!base || !base[0]) base = ".";
+    char tmpl[512];
+    snprintf(tmpl, sizeof tmpl, "%s/mr_mode_host_XXXXXX", base);
+    char *data = mkdtemp(tmpl);
+    if (!data) { printf("SKIP: mkdtemp failed\n"); return 0; }
+    setenv("MEOW_DATA_DIR", data, 1);
+
+    char root[MR_PATH_MAX], book1[MR_PATH_MAX], book2[MR_PATH_MAX];
+    snprintf(root, sizeof root, "./mr_mode_books_%ld", (long)getpid());
+    snprintf(book1, sizeof book1, "%s/vol1", root);
+    snprintf(book2, sizeof book2, "%s/vol2", root);
+    mkdir_p(book1);
+    mkdir_p(book2);
+    for (int b = 0; b < 2; b++) {
+        const char *dir = b ? book2 : book1;
+        for (int i = 0; i < 3; i++) {
+            char p[MR_PATH_MAX];
+            snprintf(p, sizeof p, "%s/p%d.bmp", dir, i + 1);
+            if (write_bmp24(p, 40, 60) != 0) { printf("SKIP: bmp write failed\n"); return 0; }
+        }
+    }
+
+    meow_ui_opts o = { 480, 720 };
+    if (meow_ui_init(&o) != 0) { printf("SKIP: meow_ui_init failed (no host backend)\n"); return 0; }
+
+    static const meow_view_hooks lh = { .on_enter = lib_enter, .on_leave = lib_leave };
+    meow_view *lib = meow_view_create(ACT_LIBRARY, MEOW_VIEW_ACTIVITY, &lh, NULL);
+    meow_view *reader = reader_view_create();
+    meow_view_page_push(ACT_LIBRARY);
+
+    /* TopAppBar 动作格（位图）：右起每格 48px；动作 0=模式 / 1=跳页 / 2=fit。 */
+    int w = meow_ui_width();
+    int mode_x = w - 10 - 48 * 3 + 24;
+    int jump_x = w - 10 - 48 * 2 + 24;
+    int bar_y = 28;
+    int slider_y = 56 + 4 + 20;
+    int sx = 24, sw = w - 48;
+
+    /* ---- H1 进入：翻页模式、第 1 页 ---- */
+    mr_reader_open_dir(book1);
+    CHECK(meow_ui_activity_active() == ACT_READER, "reader active after open");
+    CHECK(mr_reader_ui_count() == 3, "book pages=%d", mr_reader_ui_count());
+    CHECK(mr_reader_ui_mode() == MR_MODE_PAGED, "default mode is paged");
+    CHECK(mr_reader_ui_page() == 0, "start at page 0");
+    pump_ms(300);
+
+    /* ---- H2 模式切换：chrome 图标一键切，立即持久化 ---- */
+    CHECK(tap(mode_x, bar_y) == 1, "mode icon tap consumed");
+    CHECK(mr_reader_ui_mode() == MR_MODE_WEBTOON, "switched to webtoon");
+    CHECK(mr_cont_get_mode(book1, MR_MODE_PAGED) == MR_MODE_WEBTOON,
+          "webtoon mode persisted per book");
+    CHECK(tap(mode_x, bar_y) == 1, "mode icon tap consumed (back)");
+    CHECK(mr_reader_ui_mode() == MR_MODE_PAGED, "switched back to paged");
+    CHECK(mr_cont_get_mode(book1, MR_MODE_PAGED) == MR_MODE_PAGED, "paged mode persisted");
+    CHECK(tap(mode_x, bar_y) == 1, "mode icon tap consumed (again)");
+    CHECK(mr_reader_ui_mode() == MR_MODE_WEBTOON, "webtoon again for continuity");
+
+    /* ---- H3 跳页：滑块展开 → 拖到末页 → 预解码完成后落位 ---- */
+    CHECK(tap(jump_x, bar_y) == 1, "jump icon tap consumed");
+    CHECK(mr_reader_ui_jump_open() == 1, "slider open");
+    reader_on_touch_down(sx + sw, slider_y);
+    reader_on_tap(sx + sw, slider_y);
+    CHECK(mr_reader_ui_jump_open() == 0, "slider closed after pick");
+    CHECK(mr_reader_ui_jump_pending() == 1 || mr_reader_ui_page() == 2,
+          "jump pending (waiting for target decode)");
+    pump_ms(600);
+    CHECK(mr_reader_ui_jump_pending() == 0, "jump landed");
+    CHECK(mr_reader_ui_page() == 2, "jumped to last page (got %d)", mr_reader_ui_page());
+
+    /* ---- H4 续读：离开保存 page+mode，重进恢复 ---- */
+    CHECK(swipe(MEOW_SWIPE_LEFT, 200) == 0, "reader leaves back-swipe to app.c");
+    meow_view_page_pop();
+    CHECK(meow_ui_activity_active() == ACT_LIBRARY, "back to library");
+    CHECK(mr_cont_get_page(book1, -1) == 2, "last page saved (got %d)",
+          mr_cont_get_page(book1, -1));
+    CHECK(mr_cont_get_mode(book1, MR_MODE_PAGED) == MR_MODE_WEBTOON, "mode saved");
+    CHECK(g_lib_enters >= 2, "library re-entered");
+
+    mr_reader_open_dir(book1);
+    CHECK(mr_reader_ui_mode() == MR_MODE_WEBTOON, "mode restored on reopen");
+    CHECK(mr_reader_ui_page() == 2, "page restored on reopen (got %d)", mr_reader_ui_page());
+    pump_ms(300);
+
+    /* ---- H5 册间衔接：条漫末页上拉 → 下一册首页 ---- */
+    reader_on_touch_down(240, 600);
+    for (int i = 1; i <= 6; i++) {
+        reader_on_touch_move(240, 600 - i * 40);
+        usleep(5 * 1000);
+    }
+    CHECK(swipe(MEOW_SWIPE_UP, 240) == 1, "webtoon up-swipe consumed");
+    CHECK(strcmp(mr_reader_dir(), book2) == 0, "advanced to next book (got %s)", mr_reader_dir());
+    CHECK(mr_reader_ui_page() == 0, "next book starts at page 0");
+    CHECK(mr_reader_ui_mode() == MR_MODE_WEBTOON, "mode carried into fresh book");
+    pump_ms(300);
+
+    /* 首页下拉 → 上一册末页 */
+    reader_on_touch_down(240, 300);
+    for (int i = 1; i <= 6; i++) {
+        reader_on_touch_move(240, 300 + i * 40);
+        usleep(5 * 1000);
+    }
+    CHECK(swipe(MEOW_SWIPE_DOWN, 240) == 1, "webtoon down-swipe consumed");
+    CHECK(strcmp(mr_reader_dir(), book1) == 0, "back to previous book (got %s)", mr_reader_dir());
+    CHECK(mr_reader_ui_page() == 2, "previous book lands at last page (got %d)",
+          mr_reader_ui_page());
+    pump_ms(300);
+
+    /* 跳到首页后，再往上一册：没有相邻册，停在原地并提示（不退出/不崩）。 */
+    CHECK(tap(jump_x, bar_y) == 1, "jump icon tap consumed (to first page)");
+    CHECK(mr_reader_ui_jump_open() == 1, "slider open again");
+    reader_on_touch_down(sx + 2, slider_y);
+    reader_on_tap(sx + 2, slider_y);
+    pump_ms(500);
+    CHECK(mr_reader_ui_page() == 0, "jumped to first page (got %d)", mr_reader_ui_page());
+
+    reader_on_touch_down(240, 300);
+    for (int i = 1; i <= 6; i++) {
+        reader_on_touch_move(240, 300 + i * 40);
+        usleep(5 * 1000);
+    }
+    CHECK(swipe(MEOW_SWIPE_DOWN, 240) == 1, "edge down-swipe consumed");
+    CHECK(strcmp(mr_reader_dir(), book1) == 0, "no previous book: stay put");
+    CHECK(meow_ui_activity_active() == ACT_READER, "no previous book: still in reader (no exit)");
+
+    /* ---- 收尾 ---- */
+    meow_view_page_pop();
+    CHECK(meow_ui_activity_active() == ACT_LIBRARY, "popped back to library");
+    meow_view_free(reader);
+    meow_view_free(lib);
+    meow_ui_shutdown();
+
+    rm_rf(root);
+    rm_rf(data);
+    printf("%s: %s\n", g_fail ? "FAIL" : "PASS",
+           g_fail ? "see failures above" : "reader mode/continuity integration checks passed");
+    return g_fail ? 1 : 0;
+}

tuku/test/test_webtoon_strip.c

@@ -0,0 +1,220 @@
+/* test_webtoon_strip.c — 条漫排版/滚动窗口纯逻辑宿主测试（无 SDK/硬件）。
+ *
+ * 覆盖：
+ *   W1 单页：高度=适宽、总高、max_offset=0、窗口只有本页、顶/底同时成立；
+ *   W2 多页：按页高累加 offsets；page_at 二分定位（页边界/末页/越界）；
+ *   W3 可见窗口：视口±1 页；max_pages 截断；条底/条顶窗口不越界；
+ *   W4 尺寸兜底：未知 meta → 2:3 占位；横图适宽；极端长图夹到上限；
+ *   W5 参数/生命周期：空册、非法视口、重复 free、重建；
+ *   W6 跳页落位：offset_for_page 与 page_at 互逆（含末页 max 夹取）。
+ *
+ * 编译（在 tuku/ 下）：
+ *   gcc -Wall -Wextra -O1 -I. test/test_webtoon_strip.c logic/reader/nav.c \
+ *       -o test/test_webtoon_strip && ./test/test_webtoon_strip
+ * 或 test/run_webtoon_tests.sh。
+ */
+#include "logic/reader/nav.h"
+
+#include <stdio.h>
+#include <string.h>
+
+static int g_pass, g_fail;
+#define CHECK(cond, ...) do { \
+    if (cond) { g_pass++; } \
+    else { g_fail++; printf("FAIL %s:%d  ", __FILE__, __LINE__); printf(__VA_ARGS__); printf("\n"); } \
+} while (0)
+
+#define VW 480
+#define VH 720
+
+typedef struct fake_meta {
+    int n;
+    int w[16];
+    int h[16];
+    int known[16];
+} fake_meta;
+
+static int meta_cb(void *ctx, int i, int *w, int *h)
+{
+    fake_meta *m = (fake_meta *)ctx;
+    if (!m || i < 0 || i >= m->n) return 0;
+    *w = m->w[i];
+    *h = m->h[i];
+    return m->known[i];
+}
+
+static void meta_page(fake_meta *m, int i, int w, int h, int known)
+{
+    m->w[i] = w;
+    m->h[i] = h;
+    m->known[i] = known;
+    if (i + 1 > m->n) m->n = i + 1;
+}
+
+static void test_single_page(void)
+{
+    fake_meta m;
+    memset(&m, 0, sizeof m);
+    meta_page(&m, 0, 800, 1200, 1);
+
+    mr_strip s;
+    memset(&s, 0, sizeof s);
+    CHECK(mr_strip_build(&s, 1, VW, VH, meta_cb, &m) == 0, "build single");
+    CHECK(s.count == 1, "count=%d", s.count);
+    CHECK(mr_strip_page_h(&s, 0) == 720, "single h=%d", mr_strip_page_h(&s, 0));
+    CHECK(mr_strip_total(&s) == 720, "single total=%d", mr_strip_total(&s));
+    CHECK(mr_strip_max_offset(&s) == 0, "single max=%d", mr_strip_max_offset(&s));
+    CHECK(mr_strip_page_at(&s, 0) == 0, "single page at 0");
+    CHECK(mr_strip_page_at(&s, 719) == 0, "single page at 719");
+    CHECK(mr_strip_page_at(&s, 720) == 0, "single page at total clamps");
+    CHECK(mr_strip_at_end(&s, 0) == 1, "single at end");
+    CHECK(mr_strip_at_start(&s, 0) == 1, "single at start");
+
+    int f = -1, l = -1;
+    CHECK(mr_strip_window(&s, 0, 4, &f, &l) == 1 && f == 0 && l == 0,
+          "single window %d..%d", f, l);
+    CHECK(mr_strip_offset_for_page(&s, 0) == 0, "single offset page0");
+    CHECK(mr_strip_offset_for_page(&s, 9) == 0, "single offset OOB clamps");
+    mr_strip_free(&s);
+}
+
+static void test_multi_pages(void)
+{
+    fake_meta m;
+    memset(&m, 0, sizeof m);
+    /* 0: 800x1200 -> 720；1: 未知 -> 720 占位；2: 横图 1500x1000 -> 320；
+     * 3: 方图 400x400 -> 480；4: 极端长图 1x2000 -> 夹到 200000。 */
+    meta_page(&m, 0, 800, 1200, 1);
+    meta_page(&m, 1, 0, 0, 0);
+    meta_page(&m, 2, 1500, 1000, 1);
+    meta_page(&m, 3, 400, 400, 1);
+    meta_page(&m, 4, 1, 2000, 1);
+
+    mr_strip s;
+    memset(&s, 0, sizeof s);
+    CHECK(mr_strip_build(&s, 5, VW, VH, meta_cb, &m) == 0, "build multi");
+    CHECK(mr_strip_page_h(&s, 0) == 720, "h0=%d", mr_strip_page_h(&s, 0));
+    CHECK(mr_strip_page_h(&s, 1) == 720, "h1(unknown)=%d", mr_strip_page_h(&s, 1));
+    CHECK(mr_strip_page_h(&s, 2) == 320, "h2(landscape)=%d", mr_strip_page_h(&s, 2));
+    CHECK(mr_strip_page_h(&s, 3) == 480, "h3(square)=%d", mr_strip_page_h(&s, 3));
+    CHECK(mr_strip_page_h(&s, 4) == MR_STRIP_MAX_PAGE_H, "h4(extreme)=%d",
+          mr_strip_page_h(&s, 4));
+
+    CHECK(mr_strip_top(&s, 0) == 0, "top0=%d", mr_strip_top(&s, 0));
+    CHECK(mr_strip_top(&s, 1) == 720, "top1=%d", mr_strip_top(&s, 1));
+    CHECK(mr_strip_top(&s, 2) == 1440, "top2=%d", mr_strip_top(&s, 2));
+    CHECK(mr_strip_top(&s, 3) == 1760, "top3=%d", mr_strip_top(&s, 3));
+    CHECK(mr_strip_top(&s, 4) == 2240, "top4=%d", mr_strip_top(&s, 4));
+    CHECK(mr_strip_top(&s, 5) == 202240, "top[count]=%d", mr_strip_top(&s, 5));
+    CHECK(mr_strip_total(&s) == 202240, "total=%d", mr_strip_total(&s));
+    CHECK(mr_strip_max_offset(&s) == 201520, "max=%d", mr_strip_max_offset(&s));
+
+    CHECK(mr_strip_page_at(&s, 0) == 0, "page_at 0");
+    CHECK(mr_strip_page_at(&s, 719) == 0, "page_at 719");
+    CHECK(mr_strip_page_at(&s, 720) == 1, "page_at 720");
+    CHECK(mr_strip_page_at(&s, 1439) == 1, "page_at 1439");
+    CHECK(mr_strip_page_at(&s, 1440) == 2, "page_at 1440");
+    CHECK(mr_strip_page_at(&s, 1759) == 2, "page_at 1759");
+    CHECK(mr_strip_page_at(&s, 1760) == 3, "page_at 1760");
+    CHECK(mr_strip_page_at(&s, 2239) == 3, "page_at 2239");
+    CHECK(mr_strip_page_at(&s, 2240) == 4, "page_at 2240");
+    CHECK(mr_strip_page_at(&s, 9999999) == 4, "page_at huge -> last");
+    CHECK(mr_strip_page_at(&s, -50) == 0, "page_at negative -> first");
+    CHECK(mr_strip_page_at(&s, 0) == 0 && mr_strip_page_at(NULL, 0) == -1, "page_at NULL");
+
+    /* 视口窗口：off=0 只看得到页 0（页 1 从 720 开始）→ ±1 = [0,1] */
+    int f = -1, l = -1;
+    CHECK(mr_strip_window(&s, 0, 4, &f, &l) == 2 && f == 0 && l == 1,
+          "window top %d..%d", f, l);
+    /* off=1000：可见页 1..2 → 窗口 [0,3] */
+    CHECK(mr_strip_window(&s, 1000, 4, &f, &l) == 4 && f == 0 && l == 3,
+          "window mid %d..%d", f, l);
+    /* off=max：可见页 4 → 窗口 [3,4] */
+    CHECK(mr_strip_window(&s, 201520, 4, &f, &l) == 2 && f == 3 && l == 4,
+          "window bottom %d..%d", f, l);
+    /* 只用 1 个槽位：窗口收缩到焦点页 */
+    CHECK(mr_strip_window(&s, 1000, 1, &f, &l) == 1 && f >= 1 && f <= 2 && f == l,
+          "window max_pages=1 %d..%d", f, l);
+    CHECK(mr_strip_window(&s, -100, 4, &f, &l) == 2 && f == 0 && l == 1,
+          "window negative off %d..%d", f, l);
+
+    CHECK(mr_strip_at_end(&s, 0) == 0, "not at end at 0");
+    CHECK(mr_strip_at_end(&s, 201519) == 0, "not at end just before max");
+    CHECK(mr_strip_at_end(&s, 201520) == 1, "at end at max");
+    CHECK(mr_strip_at_start(&s, 0) == 1, "at start 0");
+    CHECK(mr_strip_at_start(&s, 1) == 0, "not at start 1");
+
+    /* 跳页落位：每页 offset 回读一致（末页夹到 max） */
+    for (int i = 0; i < 5; i++) {
+        int off = mr_strip_offset_for_page(&s, i);
+        int back = mr_strip_page_at(&s, off);
+        CHECK(back == i, "roundtrip page %d -> off %d -> page %d", i, off, back);
+    }
+    CHECK(mr_strip_offset_for_page(&s, 4) == 2240, "last page offset = its top");
+
+    /* 短册（内容不足一屏）：任何页都夹到 max=0 */
+    fake_meta m2;
+    memset(&m2, 0, sizeof m2);
+    meta_page(&m2, 0, 800, 300, 1);          /* 高 180 */
+    meta_page(&m2, 1, 800, 300, 1);
+    mr_strip s2;
+    memset(&s2, 0, sizeof s2);
+    CHECK(mr_strip_build(&s2, 2, VW, VH, meta_cb, &m2) == 0, "build short");
+    CHECK(mr_strip_total(&s2) == 360 && mr_strip_max_offset(&s2) == 0, "short totals");
+    CHECK(mr_strip_offset_for_page(&s2, 1) == 0, "short last page clamps to 0");
+    CHECK(mr_strip_at_end(&s2, 0) == 1 && mr_strip_at_start(&s2, 0) == 1, "short edges");
+    mr_strip_free(&s2);
+
+    /* 越界参数 */
+    CHECK(mr_strip_page_h(&s, -1) == 0 && mr_strip_page_h(&s, 5) == 0, "page_h OOB");
+    CHECK(mr_strip_top(&s, -1) == 0 && mr_strip_top(&s, 6) == 0, "top OOB");
+
+    mr_strip_free(&s);
+    CHECK(s.top == NULL && s.height == NULL && s.count == 0, "free clears");
+    mr_strip_free(&s);
+}
+
+static void test_build_contract(void)
+{
+    fake_meta m;
+    memset(&m, 0, sizeof m);
+    meta_page(&m, 0, 800, 1200, 1);
+
+    mr_strip s;
+    memset(&s, 0, sizeof s);
+    CHECK(mr_strip_build(NULL, 1, VW, VH, meta_cb, &m) == -1, "NULL strip");
+    CHECK(mr_strip_build(&s, 0, VW, VH, meta_cb, &m) == -1, "count 0 -> -1");
+    CHECK(s.top == NULL && s.count == 0, "failed build clears");
+    CHECK(mr_strip_build(&s, 1, 0, VH, meta_cb, &m) == -1, "vw 0 -> -1");
+    CHECK(mr_strip_build(&s, 1, VW, 0, meta_cb, &m) == -1, "vh 0 -> -1");
+
+    /* meta 回调为 NULL → 全部按 2:3 占位 */
+    CHECK(mr_strip_build(&s, 2, VW, VH, NULL, NULL) == 0, "NULL meta build");
+    CHECK(mr_strip_page_h(&s, 0) == 720 && mr_strip_page_h(&s, 1) == 720,
+          "NULL meta fallback heights");
+    mr_strip_free(&s);
+
+    /* meta 返回失败（0）也按占位处理 */
+    CHECK(mr_strip_build(&s, 1, VW, VH, meta_cb, &m) == 0, "rebuild after free");
+    CHECK(mr_strip_page_h(&s, 0) == 720, "rebuild height");
+    mr_strip_free(&s);
+
+    /* 空排版查询全部安全 */
+    mr_strip e;
+    memset(&e, 0, sizeof e);
+    CHECK(mr_strip_total(&e) == 0 && mr_strip_max_offset(&e) == 0, "empty totals");
+    CHECK(mr_strip_page_at(&e, 0) == -1, "empty page_at");
+    CHECK(mr_strip_offset_for_page(&e, 0) == -1, "empty offset_for_page");
+    int f = 9, l = 9;
+    CHECK(mr_strip_window(&e, 0, 4, &f, &l) == 0 && l == -1, "empty window");
+    CHECK(mr_strip_at_end(&e, 0) == 0 && mr_strip_at_start(&e, 0) == 0, "empty edges");
+}
+
+int main(void)
+{
+    test_single_page();
+    test_multi_pages();
+    test_build_contract();
+    printf("%s: %d passed, %d failed\n", g_fail ? "FAIL" : "PASS", g_pass, g_fail);
+    return g_fail ? 1 : 0;
+}

tuku/ui/reader/reader.h

@@ -13,6 +13,15 @@ extern "C" {
 void reader_on_touch_down(int x, int y);
 void reader_on_touch_move(int x, int y);
 
+#ifdef MR_READER_HOST_TEST
+/* 宿主集成测试专用：只读观察本页状态（不参与产品逻辑）。 */
+int mr_reader_ui_mode(void);        /* MR_MODE_PAGED / MR_MODE_WEBTOON */
+int mr_reader_ui_page(void);        /* 当前页（条漫=视口顶端所在页） */
+int mr_reader_ui_count(void);       /* 当前册页数 */
+int mr_reader_ui_jump_open(void);   /* 1=跳页滑块已展开 */
+int mr_reader_ui_jump_pending(void);/* 1=跳页目标等待解码 */
+#endif
+
 #ifdef __cplusplus
 }
 #endif