feat: M6.44+M6.45 收编 — 真机 0.8.45 现场保全(reader章节/key_router按键路由/WiFi连接修复/ncm bench+IME修复)

脏工作区现场收编：devdocs/local/m6_44_45_dirty_tracked.patch(46 个已跟踪文本文件,
+3090/-585, 已对 M6.43 基线干净适配) + m6_44_45_untracked_src.tar.gz 中 patch_v2/ 下
13 个新增源文件, 合成单个提交, 内容与容器工作树(R3ProII/patch_v2)逐字节一致。

- reader 章节: 新增 core/rdchapter.{h,c} — TXT 章节规范解析器, 扫描 512KB 码位对齐段文件
  逐段流式识别标题行(行首缩进≤4/显示宽≤40/行内标点≤1 三重约束防误判), 输出标题+全书字符
  偏移+段号/段内偏移+阿拉伯章号(中文数字归一), 首章前内容归"卷首"; book/reader/rdenc/
  rdlayout/settings 接入章节跳转与进度锚点, 附 chapter_smoke/turn_repro/build_turn_repro.sh
- key_router 按键路由: 新增 meow_launcherd/key_router.{h,c} — launcher-UI 页物理键统一路由
  (P1 仅音量键), 把读取边沿+防抖+长按 held+ramp 推进从 5 个会话收敛为进程内单开;
  各页每圈 key_router_pump() 取防抖后边沿, 动作(调音量/光标导航)仍由调用页决定,
  保留 run_menu 的 meow_mode 分支; App 前台 volume_page 武装时边沿抑制;
  main_menu/now_playing/notif_center/settings_page/subpage 接入, 附 test_key_router_vol/test_np_keys
- WiFi 连接修复: meow_netmgrd connect 有界等待 wpa_state=COMPLETED(普通 10s/隐藏网络 15s,
  env 可调)修设置页连接无响应; list_networks/scan_results 的 \xNN 转义还原始字节, 修中文 SSID
  永不命中致新建同名 open 记录顶影; launcher netmgr_ipc 配读超时; 附 test_wifi_connect(桩
  wpa_cli 驱动 static wifi_connect_ex), test_netmgrd.sh 补用例; wifi_page 同步
- ncm bench: 新增 bench/lyric_sim.c、bench/plpage_sim.c, vol_sync_sim 与 ncm core/app 同步
- SDK IME 修复: shift 大小写、K_ENTER 只提交不关、阻塞 IME 循环喂 on_tick 不被遮挡、
  IME 打开 ~200ms TAP 冷却窗吞 stray-TAP; 附 sdk/test_ime_fix.c
- 同期: meow_audiod 音量异步 ACK 线程(代际防 fd/槽复用竞态)、watchdog 音量收编(首选 audiod
  权威, settings.conf 覆盖路径)、panel 文件搜索(F1-④)与蓝牙只读详情(F1-③)、各类 build 脚本同步

范围红线: third_party/legado-E-main 原开发者未跟踪, 本次不入库(保留 devdocs/local tar 参考);
二进制不入库(后续重编); devdocs/ 不入库。59 文件全部在 patch_v2/ 下, 无 third_party/devdocs。
验证: git apply --check 干净; 59 文件 md5 与容器 patch_v2 逐一比对 59/59 一致(含
key_router.c/rdchapter.c/meow_ui_ime.c/test_wifi_connect.c 抽查); 可执行位保守
(check_lgpl_release.sh 100755, build_turn_repro.sh 100644 与容器一致)。

patch_v2/reader_app/test/book_smoke.c

@@ -20,10 +20,82 @@ static void write_txt(const char *path)
                    "它包含汉字、标点，以及一些 English words 混合排版。"
                    "断行、避头尾与分页行为都要正确。\n", i + 1);
     }
-    fprintf(f, "\nChapter two: the quick brown fox jumps over the lazy dog.\n");
+    fprintf(f, "\n第二章 尾声\n这是一段章尾正文，用于验证章节跳转与章内翻页。\n");
     fclose(f);
 }
 
+/* ---- Phase 2A/2C：跨段拼接页连续性（硬用例）。
+ * 构造恰好 512KB 的段 0（5242×100B + 88B，末行为短段落），段 1 开头放唯一标记 SEG1MARKER；
+ * 建段 1 触发滚动拼接后，段界页（段 0 末页）应包含段 1 开头的文本（拼接页含两段文本），
+ * 且跨段往返翻页后锚 (seg,ch) 稳定。 ---- */
+typedef struct { char *buf; size_t len, cap; } linecol;
+static void linecol_add(int x, int y, const char *utf8, int len, void *ctx)
+{
+    (void)x; (void)y;
+    linecol *lc = (linecol *)ctx;
+    if (lc->len + (size_t)len + 2 > lc->cap) {
+        size_t nc = lc->cap ? lc->cap * 2 : 4096;
+        while (nc < lc->len + (size_t)len + 2) nc *= 2;
+        char *nb = (char *)realloc(lc->buf, nc);
+        if (!nb) return;
+        lc->buf = nb; lc->cap = nc;
+    }
+    memcpy(lc->buf + lc->len, utf8, (size_t)len);
+    lc->len += (size_t)len;
+    lc->buf[lc->len++] = '\n';
+    lc->buf[lc->len] = 0;
+}
+
+static void phase2a_stitch(const char *font)
+{
+    const char *txt = "/tmp/rdbook_stitch.txt";
+    FILE *f = fopen(txt, "wb");
+    char line[100];
+    memset(line, 'a', 99); line[99] = '\n';
+    for (int i = 0; i < 5242; i++) fwrite(line, 1, 100, f);   /* 524200 B */
+    for (int i = 0; i < 88; i++) fputc('a', f);               /* 共 524288 B = 512KB 码位边界 */
+    fprintf(f, "SEG1MARKER 段一开头唯一标记，证明拼接页跨段包含两段文本。\n");
+    for (int i = 0; i < 2000; i++)
+        fprintf(f, "段一正文第%d行：滚动拼接后段界无短页，页表与进度锚稳定。\n", i + 1);
+    fclose(f);
+
+    rd_book_set_seg_base("/tmp/meow_seg_stitch");
+    rd_book_set_index_dir("/tmp/meow_seg_stitch_index");
+    rd_book *b = NULL;
+    int rc = rd_book_open(&b, txt, font, 20, 130, 480, 720, 16, 20, 62);
+    CHECK(rc == 0, "stitch open");
+    if (rc != 0) { remove(txt); return; }
+    int nseg = rd_book_seg_n(b);
+    CHECK(nseg >= 2, "stitch multi-seg");
+    if (nseg >= 2) {
+        int p1 = rd_book_seg_page(b, 1);            /* 建段 1 → 触发段 0 末页拼接 */
+        CHECK(p1 >= 0, "stitch seg1 built");
+        int ps = rd_book_seg_page(b, 0);
+        int pc = rd_book_seg_page_count(b, 0);
+        CHECK(ps == 0 && pc > 0, "stitch seg0 pages");
+        int bnd = ps + pc - 1;
+        linecol lc = { NULL, 0, 0 };
+        int rr = rd_book_render_text(b, bnd, linecol_add, &lc);
+        CHECK(rr == 0, "stitch boundary render_text ok");
+        CHECK(lc.buf && strstr(lc.buf, "SEG1MARKER") != NULL, "stitch boundary contains seg1 text");
+        free(lc.buf);
+        /* 跨段往返：段界页翻前/后，锚 (seg,ch) 不变 */
+        int as = -1; int32_t ach = -1;
+        rd_book_set_page(b, bnd);
+        rd_book_anchor(b, &as, &ach);
+        CHECK(as == 0 && ach >= 0, "stitch boundary anchor seg0");
+        int cur = rd_book_current(b);
+        int fwd = rd_book_turn(b, 1);
+        int back = rd_book_turn(b, -1);
+        CHECK(fwd == cur + 1 && back == cur, "stitch boundary turn roundtrip");
+        int as2 = -1; int32_t ach2 = -1;
+        rd_book_anchor(b, &as2, &ach2);
+        CHECK(as2 == as && ach2 == ach, "stitch boundary anchor stable");
+    }
+    rd_book_close(b);
+    remove(txt);
+}
+
 int main(int argc, char **argv)
 {
     const char *font = (argc > 1) ? argv[1] : "/home/Aska/Project/R3ProII/font/src/MiSans-Regular.otf";
@@ -82,8 +154,40 @@ int main(int argc, char **argv)
     int np3 = rd_book_set_size(b, 20, 150);
     CHECK(np3 >= 0 && np3 < rd_book_pages(b), "set_size reflow ok");
 
+    /* R3.3 章节：解析 + 章节→页映射 + 章内翻页单调（页号递增不跳变） */
+    int nch = rd_book_chapter_n(b);
+    printf("  chapters=%d\n", nch);
+    CHECK(nch == 2, "book has 2 chapters");
+    if (nch == 2) {
+        char t0[160], t1[160]; int n0 = -1, n1 = -1; int64_t c0 = -1, c1 = -1;
+        CHECK(rd_book_chapter(b, 0, t0, sizeof t0, &c0, NULL, NULL, &n0) == 0, "chapter0 get");
+        CHECK(n0 == 1, "chapter0 number 1");
+        CHECK(c0 == 0, "chapter0 char_off 0");
+        int p0 = rd_book_page_for_char(b, c0);
+        CHECK(p0 == 0 && p0 < rd_book_pages(b), "chapter0 start page 0");
+        CHECK(rd_book_chapter(b, 1, t1, sizeof t1, &c1, NULL, NULL, &n1) == 0, "chapter1 get");
+        CHECK(n1 == 2, "chapter1 number 2");
+        int p1 = rd_book_page_for_char(b, c1);
+        CHECK(p1 >= p0 && p1 < rd_book_pages(b), "chapter1 start page in range");
+        printf("  chapter1('%s') at page %d (of %d)\n", t1, p1, rd_book_pages(b));
+        /* 跳到章二首页，验证章内翻页 +1 单调（不越过章界仍递增） */
+        int landed = rd_book_set_page(b, p1);
+        CHECK(landed == p1, "jump lands on chapter1 start");
+        int cur1 = rd_book_current(b);
+        int nxt1 = rd_book_turn(b, 1);
+        CHECK((nxt1 == cur1 + 1) || (nxt1 == cur1), "chapter-internal turn +1 (clamp-safe)");
+        /* R3.4 手动重解析（清 .chap 缓存 + 重扫）应幂等返回同章数，且章节仍可用 */
+        int nrep = rd_book_reparse_chapters(b);
+        CHECK(nrep == nch, "reparse returns same chapter count");
+        CHECK(rd_book_chapter_n(b) == nch, "reparse keeps chapters");
+    }
+
     free(buf);
     rd_book_close(b);
+
+    /* Phase 2A/2C：跨段拼接页连续性 + 段界锚稳定（另开一本 >512KB 的多段书） */
+    phase2a_stitch(font);
+
     printf("book_smoke: %s\n", fails ? "FAIL" : "PASS");
     return fails ? 1 : 0;
 }

patch_v2/reader_app/test/build_turn_repro.sh

@@ -0,0 +1,20 @@
+#!/bin/bash
+# test/build_turn_repro.sh — cross-compile turn_repro for mipsel (mirrors book_smoke_mipsel link line).
+set -e
+cd "$(dirname "$0")/.."
+ROOT="$HOME/Project/R3ProII"
+CC="$ROOT/.tools/zig-mipsel-cc"
+SYSROOT="$ROOT/.tools/mipsel-linux-muslsf-cross/mipsel-linux-muslsf"
+VENDOR="$PWD/vendor"
+OBJ="$VENDOR/build"
+FT_BUILD="$VENDOR/freetype-build"
+FT_SRC="$VENDOR/freetype-src"
+FT_INCS="-I$FT_BUILD -I$FT_BUILD/include -I$FT_SRC/include"
+COREINC="-Icore -Ivendor/miniz -Ivendor/stb -Ivendor/libmobi/src -Ivendor/zlib"
+$CC -Os -static -Wall -Wextra -Iapp -Icore -Iengine $FT_INCS $COREINC \
+  test/turn_repro.c \
+  app/book.c core/rdenc.c core/rdlayout.c core/rdtxt.c core/seg.c core/rdxml.c core/rdhtml.c core/rdsb.c core/rdzip.c \
+  core/rdsrc.c core/rdepub.c core/rdfb2.c core/rdmobi.c core/rdcbz.c engine/rdft.c \
+  "$OBJ"/mz_*.o "$OBJ"/lm_*.o "$OBJ"/rdimg.o "$SYSROOT/lib/libz.a" "$FT_BUILD/libfreetype.a" \
+  -o test/turn_repro_mipsel
+echo "build OK -> test/turn_repro_mipsel"

patch_v2/reader_app/test/chapter_smoke.c

@@ -0,0 +1,275 @@
+/* test/chapter_smoke.c — os.meow.reader 章节规范解析器宿主单测（纯 C，无 SDK/Freetype）。
+ *
+ * 覆盖（按需求 5 样本 + 跨段 + 中文数字转换）：
+ *   C1 标准中文数字章（第一章/第二章/第十一章 → 1/2/11，char_off 单调）
+ *   C2 阿拉伯章（第1章/第2章/第3章 → 1/2/3）
+ *   C3 楔子/序章/尾声/番外（无号，number==-1，char_off 单调）
+ *   C4 无章节纯文本（n==0，seg_char_start 仍完整）
+ *   C5 开头长书名+简介再进第一章（卷首识别 as entries[0]、章号、防误判正文行 ）
+ *   C6 跨段：>512KB 书，章落在后段（seg_idx>=1，char_off 跨段单调）
+ *   C7 中文数字转换：十一/二十三/一百零一/一千零一/两
+ *
+ * 跑法：build_reader.sh 内 `test/chapter_smoke_host`；本文件只依赖 rdchapter + seg + rdenc。
+ */
+#include "rdchapter.h"
+#include "seg.h"
+#include "rdenc.h"
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+static int g_pass = 0, g_fail = 0;
+#define CHECK(cond, msg) do { if (cond) { g_pass++; } else { g_fail++; printf("FAIL %s:%d  %s\n", __FILE__, __LINE__, msg); } } while (0)
+
+static char g_dir[600];
+
+static void write_file(const char *path, const char *data)
+{
+    FILE *f = fopen(path, "wb");
+    fwrite(data, 1, strlen(data), f);
+    fclose(f);
+}
+
+/* 建段目录 + 切段，返回段数（<0=错误）。 */
+static int seg_for(const char *path, const char *base)
+{
+    rdseg_set_base(base);
+    char dir[600];
+    if (rdseg_dir_for(path, dir, sizeof dir) != 0) return -1;
+    strcpy(g_dir, dir);
+    return rdseg_build(path, RD_ENC_UTF8, dir);
+}
+
+static int scan_book(rdchapter *c, const char *basename)
+{
+    return rdchapter_scan(g_dir, RD_ENC_UTF8, basename, c);
+}
+
+static void test_c1(void)
+{
+    const char *txt = "/tmp/ch_s1.txt";
+    write_file(txt,
+        "第一章 风起\n"
+        "这是第一章的正文内容。\n"
+        "第二章 云涌\n"
+        "这是第二章的正文内容。\n"
+        "第十一章 破晓\n"
+        "这是第十一章的正文内容。\n");
+    CHECK(seg_for(txt, "/tmp/ch_base1") >= 1, "c1 seg build");
+    rdchapter c; rdchapter_init(&c);
+    CHECK(scan_book(&c, "s1") == 0, "c1 scan");
+    CHECK(c.n == 3, "c1 n==3");
+    if (c.n == 3) {
+        CHECK(c.entries[0].number == 1, "c1 #1");
+        CHECK(c.entries[1].number == 2, "c1 #2");
+        CHECK(c.entries[2].number == 11, "c1 #11");
+        CHECK(c.entries[0].char_off == 0, "c1 first at 0 (no preface)");
+        CHECK(c.entries[0].char_off < c.entries[1].char_off &&
+              c.entries[1].char_off < c.entries[2].char_off, "c1 char_off monotonic");
+        CHECK(c.entries[0].seg_idx == 0 && c.entries[0].seg_char == 0, "c1 seg0 char0");
+        CHECK(strcmp(c.entries[0].title, "第一章 风起") == 0, "c1 title");
+        CHECK(c.has_pre == 0, "c1 no preface");
+    }
+    rdchapter_free(&c);
+    remove(txt);
+}
+
+static void test_c2(void)
+{
+    const char *txt = "/tmp/ch_s2.txt";
+    write_file(txt,
+        "第1章 起源\n"
+        "正文A。\n"
+        "第2章 发展\n"
+        "正文B。\n"
+        "第3章 终局\n"
+        "正文C。\n");
+    CHECK(seg_for(txt, "/tmp/ch_base2") >= 1, "c2 seg build");
+    rdchapter c; rdchapter_init(&c);
+    CHECK(scan_book(&c, "s2") == 0, "c2 scan");
+    CHECK(c.n == 3, "c2 n==3");
+    if (c.n == 3) {
+        CHECK(c.entries[0].number == 1, "c2 #1");
+        CHECK(c.entries[1].number == 2, "c2 #2");
+        CHECK(c.entries[2].number == 3, "c2 #3");
+        CHECK(c.entries[0].char_off < c.entries[1].char_off &&
+              c.entries[1].char_off < c.entries[2].char_off, "c2 char_off monotonic");
+    }
+    rdchapter_free(&c);
+    remove(txt);
+}
+
+static void test_c3(void)
+{
+    const char *txt = "/tmp/ch_s3.txt";
+    write_file(txt,
+        "楔子\n"
+        "一段开篇。\n"
+        "第一章 正传\n"
+        "正文内容。\n"
+        "尾声\n"
+        "后记文字。\n"
+        "番外 归途\n"
+        "番外正文。\n");
+    CHECK(seg_for(txt, "/tmp/ch_base3") >= 1, "c3 seg build");
+    rdchapter c; rdchapter_init(&c);
+    CHECK(scan_book(&c, "s3") == 0, "c3 scan");
+    CHECK(c.n == 4, "c3 n==4");
+    if (c.n == 4) {
+        CHECK(c.entries[0].number == -1, "c3 楔子 number -1");
+        CHECK(strcmp(c.entries[0].title, "楔子") == 0, "c3 楔子 title");
+        CHECK(c.entries[1].number == 1, "c3 第一章 number 1");
+        CHECK(c.entries[2].number == -1, "c3 尾声 number -1");
+        CHECK(c.entries[3].number == -1, "c3 番外 number -1");
+        CHECK(c.entries[0].char_off < c.entries[1].char_off &&
+              c.entries[1].char_off < c.entries[2].char_off &&
+              c.entries[2].char_off < c.entries[3].char_off, "c3 char_off monotonic");
+    }
+    rdchapter_free(&c);
+    remove(txt);
+}
+
+static void test_c4(void)
+{
+    const char *txt = "/tmp/ch_s4.txt";
+    write_file(txt,
+        "这是一个没有章节标题的长篇小说文本。\n"
+        "它只有连续不断的段落，没有任何章回节的标识。\n"
+        "所有的文字都是纯粹的故事内容。\n");
+    CHECK(seg_for(txt, "/tmp/ch_base4") >= 1, "c4 seg build");
+    rdchapter c; rdchapter_init(&c);
+    CHECK(scan_book(&c, "s4") == 0, "c4 scan");
+    CHECK(c.n == 0, "c4 no chapters");
+    CHECK(c.nsegs == 1, "c4 nsegs==1");
+    CHECK(c.seg_char_start && c.seg_char_start[0] == 0 && c.seg_char_start[1] > 0, "c4 seg_char_start");
+    rdchapter_free(&c);
+    remove(txt);
+}
+
+static void test_c5(void)
+{
+    const char *txt = "/tmp/ch_s5.txt";
+    write_file(txt,
+        "《大漠孤烟》这是一本很长的书名，作者著。\n"
+        "简介：这是一个故事的开头，讲述少年成长。\n"
+        "第一章风雨欲来，全书开场，命运由此转折。\n"
+        "第一章 离家\n"
+        "正文内容。\n"
+        "第二章 远行\n"
+        "正文内容。\n");
+    CHECK(seg_for(txt, "/tmp/ch_base5") >= 1, "c5 seg build");
+    rdchapter c; rdchapter_init(&c);
+    CHECK(scan_book(&c, "sample5") == 0, "c5 scan");
+    CHECK(c.n == 3, "c5 n==3 (preface + 2 chapters)");
+    if (c.n == 3) {
+        CHECK(c.has_pre == 1, "c5 has preface");
+        CHECK(c.entries[0].number == -1, "c5 preface number -1");
+        CHECK(strcmp(c.entries[0].title, "sample5") == 0, "c5 preface title = basename");
+        CHECK(c.entries[0].char_off == 0, "c5 preface char_off 0");
+        CHECK(c.entries[1].number == 1 && c.entries[2].number == 2, "c5 chapter numbers 1/2");
+        CHECK(c.entries[1].char_off > 0, "c5 ch1 after preface");
+        CHECK(c.entries[0].char_off < c.entries[1].char_off &&
+              c.entries[1].char_off < c.entries[2].char_off, "c5 monotonic");
+        /* 防误判：正文行「第一章风雨欲来，全书开场。」带两个正文标点 → 未被识别为章 */
+        CHECK(c.entries[1].seg_char > 0, "c5 decoy line not counted (ch1 seg_char>0)");
+    }
+    rdchapter_free(&c);
+    remove(txt);
+}
+
+static void test_c6(void)
+{
+    /* 跨段：写 ~600KB filler，在 ~600KB 处放一个章 → 应落在后段（seg_idx>=1） */
+    const char *txt = "/tmp/ch_s6.txt";
+    FILE *f = fopen(txt, "wb");
+    const char *para = "这是一段用于填充页面的中文正文，包含标点，中文English混合，反复出现，占据空间。\n";
+    size_t plen = strlen(para);
+    size_t total = 0;
+    while (total < 600 * 1024) {
+        fwrite(para, 1, plen, f); total += plen;
+    }
+    fwrite("第二百章 跨段检测\n", 1, strlen("第二百章 跨段检测\n"), f);
+    const char *tail = "这是跨段之后的一小段正文。\n";
+    fwrite(tail, 1, strlen(tail), f);
+    fclose(f);
+    CHECK(seg_for(txt, "/tmp/ch_base6") >= 2, "c6 seg build >=2");
+    rdchapter c; rdchapter_init(&c);
+    CHECK(scan_book(&c, "s6") == 0, "c6 scan");
+    /* 前置 filler（600KB 无章节）→ entries[0]=卷首；真正章节在后段 */
+    CHECK(c.n == 2, "c6 n==2 (preface + 1 chapter)");
+    if (c.n == 2) {
+        CHECK(c.entries[0].number == -1, "c6 preface number -1");
+        CHECK(c.entries[1].number == 200, "c6 number 200");
+        CHECK(c.entries[1].seg_idx >= 1, "c6 chapter in later segment");
+        CHECK(c.entries[1].seg_idx < c.nsegs, "c6 seg_idx in range");
+        CHECK(c.entries[1].seg_char >= 0, "c6 seg_char >=0");
+        CHECK(c.seg_char_start[0] == 0 &&
+              c.seg_char_start[0] < c.seg_char_start[1] &&
+              c.seg_char_start[c.nsegs - 1] < c.seg_char_start[c.nsegs], "c6 seg_char_start monotonic");
+        /* 跨段 char_off：章首偏移应在段 1 起点之后 */
+        CHECK(c.entries[1].char_off >= c.seg_char_start[c.entries[1].seg_idx], "c6 char_off within seg");
+    }
+    rdchapter_free(&c);
+    remove(txt);
+}
+
+static void test_c7(void)
+{
+    CHECK(rdchapter_cn_num("十一", 6) == 11, "c7 十一=11");
+    CHECK(rdchapter_cn_num("二十三", 9) == 23, "c7 二十三=23");
+    CHECK(rdchapter_cn_num("一百零一", 12) == 101, "c7 一百零一=101");
+    CHECK(rdchapter_cn_num("一千零一", 12) == 1001, "c7 一千零一=1001");
+    CHECK(rdchapter_cn_num("两", 3) == 2, "c7 两=2");
+    CHECK(rdchapter_cn_num("一百", 6) == 100, "c7 一百=100");
+    CHECK(rdchapter_cn_num("foobar", 6) == -1, "c7 invalid -1");
+}
+
+static void test_c8(void)
+{
+    /* R3.4 英文章节：文字数字（one/twenty-one/two hundred fifty）+ 罗马（IV）+ 拒绝无空格（ChapterX） */
+    const char *txt = "/tmp/ch_s8.txt";
+    write_file(txt,
+        "Chapter one\n"
+        "正文。\n"
+        "Chapter IV\n"
+        "正文。\n"
+        "Chapter twenty-one\n"
+        "正文。\n"
+        "Chapter two hundred fifty\n"
+        "正文。\n"
+        "ChapterX\n"
+        "正文。\n"
+        "Chapter twelve\n"
+        "正文。\n");
+    CHECK(seg_for(txt, "/tmp/ch_base8") >= 1, "c8 seg build");
+    rdchapter c; rdchapter_init(&c);
+    CHECK(scan_book(&c, "s8") == 0, "c8 scan");
+    /* ChapterX 不认（无空格）；其余 5 个认 */
+    CHECK(c.n == 5, "c8 n==5");
+    if (c.n == 5) {
+        static const int exp[5] = { 1, 4, 21, 250, 12 };
+        for (int i = 0; i < 5; i++) CHECK(c.entries[i].number == exp[i], "c8 word number value");
+        CHECK(c.entries[0].char_off < c.entries[1].char_off &&
+              c.entries[1].char_off < c.entries[2].char_off &&
+              c.entries[2].char_off < c.entries[3].char_off &&
+              c.entries[3].char_off < c.entries[4].char_off, "c8 char_off monotonic");
+        CHECK(strcmp(c.entries[0].title, "Chapter one") == 0, "c8 title Chapter one");
+        CHECK(strcmp(c.entries[3].title, "Chapter two hundred fifty") == 0, "c8 title two hundred fifty");
+    }
+    rdchapter_free(&c);
+    remove(txt);
+}
+
+int main(void)
+{
+    test_c1();
+    test_c2();
+    test_c3();
+    test_c4();
+    test_c5();
+    test_c6();
+    test_c7();
+    test_c8();
+    printf("chapter_smoke: %d pass, %d fail\n", g_pass, g_fail);
+    return g_fail ? 1 : 0;
+}

patch_v2/reader_app/test/test_reader_core.c

@@ -341,10 +341,121 @@ static void t13(void)
     CHECK(rd_enc_detect(gbk, sizeof gbk, NULL) == RD_ENC_GB18030, "t13 gbk still gb18030");
 }
 
+/* t14 — TXT `\r` 归一化（READER_ADVANCED §3-1）：`\r\n`→`\n`、孤 `\r`→`\n`，
+ * 码点流不含 0x0D（行尾 \r 在无 U+000D 映射的字体里落成 .notdef 豆腐；MiSans 虽映射到
+ * 零宽空字形不可见，归一化后对所有字体稳健，且章节/页表/进度锚同处无 \r 码点空间）。 */
+static void t14(void)
+{
+    const uint8_t u8[] = "ab\r\ncd\ref\n\r\ngh\r";
+    uint32_t *cps = NULL; size_t n = 0;
+    CHECK(rd_utf8_to_cp(u8, sizeof u8 - 1, &cps, &n) == RD_ENC_OK, "t14 utf8→cp ok");
+    const uint32_t expect[] = { 'a','b','\n','c','d','\n','e','f','\n','\n','g','h','\n' };
+    CHECK(n == sizeof expect / sizeof expect[0], "t14 count");
+    int no_cr = 1;
+    for (size_t i = 0; i < n; i++) if (cps[i] == 0x0D) no_cr = 0;
+    CHECK(no_cr, "t14 no 0x0D in cps");
+    CHECK(n == 13 && memcmp(cps, expect, n * sizeof(uint32_t)) == 0, "t14 normalized sequence");
+    free(cps);
+    /* GB18030 路径同样归一化（rd_to_utf8 → rd_utf8_to_cp） */
+    const uint8_t gbk[] = { 0xC4,0xE3,0xBA,0xC3, 0x0D,0x0A, 0xCA,0xC0,0xBD,0xE7 };  /* 你好\r\n世界 */
+    uint8_t out[64]; size_t olen = 0;
+    CHECK(rd_to_utf8(RD_ENC_GB18030, gbk, sizeof gbk, out, sizeof out, &olen) == RD_ENC_OK, "t14 gbk decode");
+    uint32_t *c2 = NULL; size_t n2 = 0;
+    CHECK(rd_utf8_to_cp(out, olen, &c2, &n2) == RD_ENC_OK, "t14 gbk→cp");
+    CHECK(n2 == 5 && c2[0] == 0x4F60 && c2[2] == '\n' && c2[3] == 0x4E16, "t14 gbk crlf→lf");
+    free(c2);
+}
+
+/* t15 — 页级微排版 vs 全排版逐行一致（Phase 2C 硬用例）：
+ * 全排版 rd_layout → 对每页 first_char 起 rd_layout_page，断言行区间（s/e/x/y/w/para 标志）
+ * 与该页完全一致，且 next_start == 下一页 first_char（或文末）。含伪随机长文覆盖段界/空段/
+ * Kinsoku/长词/页满边界；显式构造 mid_para=1（段中续行起始）。 */
+static uint32_t g_lcg = 0x12345678u;
+static uint32_t lcg(void) { g_lcg = g_lcg * 1664525u + 1013904223u; return g_lcg >> 8; }
+
+static void t15_check_text(const char *txt, int fs, int ls, int pw, int ph, const char *tag)
+{
+    uint32_t *cps = NULL; size_t n = 0;
+    rd_utf8_to_cp((const uint8_t *)txt, strlen(txt), &cps, &n);
+    rd_line *fl = (rd_line *)malloc((n + 1) * sizeof(rd_line));
+    rd_page *fp = (rd_page *)malloc((n + 1) * sizeof(rd_page));
+    rd_line *ml = (rd_line *)malloc((size_t)(ph + 4) * sizeof(rd_line));
+    CHECK(fl && fp && ml, "t15 alloc");
+    rd_layout_in in = { cps, (int32_t)n, fs, ls, pw, ph, fs, meas_mock, NULL };
+    rd_layout_out out;
+    out.lines = fl; out.pages = fp; out.max_lines = (int)n + 1; out.max_pages = (int)n + 1;
+    int rc = rd_layout(&in, &out);
+    CHECK(rc == RD_LAYOUT_OK, tag);
+    if (rc != RD_LAYOUT_OK) { free(cps); free(fl); free(fp); free(ml); return; }
+    for (int p = 0; p < out.npages; p++) {
+        int32_t start = out.pages[p].first_char;
+        int mid = !(start == 0 || cps[start - 1] == '\n');
+        int mnl = -1; int32_t nxt = -1;
+        int mrc = rd_layout_page(&in, start, mid, ml, ph + 3, &mnl, &nxt);
+        CHECK(mrc == RD_LAYOUT_OK, "t15 micro rc");
+        CHECK(mnl == out.pages[p].nlines, "t15 page nlines equal");
+        if (mnl > 0 && mnl == out.pages[p].nlines) {
+            for (int li = 0; li < mnl; li++) {
+                const rd_line *a = &out.lines[out.pages[p].first_line + li];
+                const rd_line *b = &ml[li];
+                CHECK(a->s == b->s && a->e == b->e && a->x == b->x && a->y == b->y &&
+                      a->w == b->w && a->para_start == b->para_start && a->para_end == b->para_end,
+                      "t15 line-for-line equal");
+            }
+        }
+        int32_t want_next = (p + 1 < out.npages) ? out.pages[p + 1].first_char : (int32_t)n;
+        CHECK(nxt == want_next, "t15 next_start == next page first_char");
+    }
+    free(cps); free(fl); free(fp); free(ml);
+}
+
+static void t15(void)
+{
+    /* 固定样本：多段/空段/中英混排/标点/长词/末尾换行 */
+    t15_check_text("第一章 开始\n\n这是一段正文，包含 English words 与标点。第二句继续填充，"
+                   "直到页面溢出产生多页。\n另一段（左括号测试）右标点，簇！？混合。"
+                   "supercalifragilisticexpialidocious longword\n\n\n末段无换行结尾",
+                   20, 130, 440, 300, "t15 fixed layout");
+    /* 伪随机长文（确定性种子）：40+ 页，覆盖段中页首/页满边界 */
+    size_t cap = 65536;
+    char *buf = (char *)malloc(cap);
+    size_t o = 0;
+    static const char *cjk[] = { "的","一","是","不","了","人","我","在","有","他","这","中","大",
+                                 "来","上","国","个","到","说","们","为","子","和","你","地","出" };
+    static const char *lat[] = { "a","test","word","x","hello","longwordish","b","qk","reader","zz" };
+    static const char *pnc[] = { "。","，","、","？","！","（","）"," ", "  ", ".", "," };
+    g_lcg = 0xC0FFEE;
+    while (o + 16 < cap) {
+        uint32_t r = lcg() % 100;
+        const char *s;
+        if (r < 55) s = cjk[lcg() % (sizeof cjk / sizeof cjk[0])];
+        else if (r < 80) s = lat[lcg() % (sizeof lat / sizeof lat[0])];
+        else if (r < 92) s = pnc[lcg() % (sizeof pnc / sizeof pnc[0])];
+        else if (r < 97) s = "\n";
+        else s = "\n\n";
+        size_t sl = strlen(s);
+        memcpy(buf + o, s, sl); o += sl;
+    }
+    buf[o] = 0;
+    t15_check_text(buf, 20, 130, 440, 640, "t15 random layout A");
+    t15_check_text(buf, 17, 150, 200, 300, "t15 random layout B");   /* 窄页小字：更多断行/页 */
+    free(buf);
+    /* 段中续行起始显式用例：整段一行到底（无 \n），页首必为 mid_para=1 */
+    {
+        char *one = (char *)malloc(16384);
+        size_t k = 0;
+        for (int i = 0; i < 400; i++) { const char *w = "持续不断的正文"; size_t wl = strlen(w); memcpy(one + k, w, wl); k += wl; }
+        one[k] = 0;
+        t15_check_text(one, 20, 130, 440, 640, "t15 single-para layout");
+        free(one);
+    }
+}
+
 int main(void)
 {
     t1(); t2(); t3(); t4(); t5();
     t6(); t7(); t8(); t9(); t10(); t11(); t12(); t13();
+    t14(); t15();
     printf("test_reader_core: %d pass, %d fail\n", g_pass, g_fail);
     return g_fail ? 1 : 0;
 }

patch_v2/reader_app/test/turn_repro.c

@@ -0,0 +1,83 @@
+/* test/turn_repro.c — 复现「翻页跳页」（R3.2 分段流式）。
+ * 模拟真机序列：open → (可选 set_enc 到 UTF-16LE) → 跳页/翻页 → 渲染校验（非空/seg 边界正确）。
+ * 跑于 qemu-mipsel（静态）。
+ * 用法：qemu-mipsel ./test/turn_repro_mipsel <font.otf> <book.txt> <dirprefix> [enc] [turns]
+ */
+#include "book.h"
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+static int render_buf(uint16_t *buf, int W, int H, rd_book *b, int page, uint16_t bg, uint16_t fg)
+{
+    for (int i = 0; i < W * H; i++) buf[i] = bg;
+    int rc = rd_book_render(b, page, buf, W * 2, bg, fg);
+    if (rc != 0) return -100 + rc;
+    int ink = 0;
+    for (int i = 0; i < W * H; i++) if (buf[i] != bg) ink++;
+    return ink;
+}
+
+int main(int argc, char **argv)
+{
+    const char *font = (argc > 1) ? argv[1] : "/home/Aska/Project/R3ProII/font/src/MiSans-Regular.otf";
+    const char *book = (argc > 2) ? argv[2] : "/tmp/rdsample/tongyi.txt";
+    const char *pref = (argc > 3) ? argv[3] : "/tmp/rdsample/repro";
+    int force_enc = (argc > 4) ? atoi(argv[4]) : 0;
+    int turns = (argc > 5) ? atoi(argv[5]) : 200;
+    char segbase[420], idxdir[420];
+    snprintf(segbase, sizeof segbase, "%s/segbase", pref);
+    snprintf(idxdir, sizeof idxdir, "%s/index", pref);
+    rd_book_set_seg_base(segbase);
+    rd_book_set_index_dir(idxdir);
+
+    int fs = 16, ls = 135, pw = 480, ph = 724, mx = 16, my = 20, top = 62;
+    uint16_t *buf = (uint16_t *)malloc((size_t)pw * ph * 2);
+
+    rd_book *b = NULL;
+    int rc = rd_book_open(&b, book, font, fs, ls, pw, ph, mx, my, top);
+    printf("open rc=%d enc=%s\n", rc, rc == 0 ? rd_book_encname(b) : "-");
+    if (rc != 0) return 1;
+    if (force_enc) { printf("set_enc(%d)->rc=%d\n", force_enc, rd_book_set_enc(b, (rd_enc_t)force_enc)); }
+    int np = rd_book_pages(b);
+    printf("npages=%d\n", np);
+
+    /* ① 翻页序列：跨段边界观察 cur 跳变 */
+    rd_book_set_page(b, 2);
+    int prev = rd_book_current(b), jumps = 0;
+    for (int i = 0; i < turns; i++) {
+        int nxt = rd_book_turn(b, 1);
+        int d = nxt - prev;
+        if (d != 1) { printf("  JUMP turn#%d %d->%d d=%d npages=%d\n", i, prev, nxt, d, rd_book_pages(b)); if (d > 1) jumps++; }
+        prev = nxt;
+        if (rd_book_pages(b) < 1) break;
+    }
+    printf("turn jumps>1=%d\n", jumps);
+
+    /* ② 渲染首页/第3页/中间页 校验非空 */
+    int targets[3] = { 0, 2, np > 3 ? np / 2 : 0 };
+    for (int t = 0; t < 3; t++) {
+        if (targets[t] >= rd_book_pages(b)) continue;
+        int ink = render_buf(buf, pw, ph, b, targets[t], 0xFFFF, 0x0000);
+        printf("render page %d -> %s (ink=%d)\n", targets[t], ink < 0 ? "ERR" : (ink > 50 ? "OK" : "BLANK"), ink);
+    }
+
+    /* ③ set_page 到远页（触发按需补段），渲染校验 + 观察是否落到目标 */
+    int far = 316;
+    int got = rd_book_set_page(b, far);
+    printf("set_page(%d) -> cur=%d npages=%d\n", far, got, rd_book_pages(b));
+    int ink = render_buf(buf, pw, ph, b, got, 0xFFFF, 0x0000);
+    printf("render page %d -> %s (ink=%d)\n", got, ink < 0 ? "ERR" : (ink > 50 ? "OK" : "BLANK"), ink);
+
+    /* ④ 跳到更远（超过当前 npages，强制补段到 seg 20） */
+    int far2 = 4000;
+    int got2 = rd_book_set_page(b, far2);
+    printf("set_page(%d) -> cur=%d npages=%d\n", far2, got2, rd_book_pages(b));
+    ink = render_buf(buf, pw, ph, b, got2, 0xFFFF, 0x0000);
+    printf("render page %d -> %s (ink=%d)\n", got2, ink < 0 ? "ERR" : (ink > 50 ? "OK" : "BLANK"), ink);
+
+    free(buf);
+    rd_book_close(b);
+    printf("done\n");
+    return 0;
+}