bug处理

internal/service/reader/rule/analyzer.go

@@ -332,13 +332,14 @@ func (a *AnalyzeRule) getStringListRules(ruleList []*SourceRule, mContent any, i
 		result = strings.Split(s, "\n")
 	}
 	if isUrl {
+		// 这里必须接受任何切片形态：书源的下一页地址/章节地址规则常常由 JS 生成，
+		// goja 导出的是 []any。早期只认 []string，JS 给的地址数组会被静默丢掉，
+		// 表现为「nextTocUrl 明明有规则却永远不翻页」。
 		var urlList []string
-		if lst, ok := result.([]string); ok {
-			for _, u := range lst {
-				abs := a.absolutize(u)
-				if abs != "" && !containsStr(urlList, abs) {
-					urlList = append(urlList, abs)
-				}
+		for _, u := range resultStrings(result) {
+			abs := a.absolutize(u)
+			if abs != "" && !containsStr(urlList, abs) {
+				urlList = append(urlList, abs)
 			}
 		}
 		return urlList, nil
@@ -363,6 +364,32 @@ func (a *AnalyzeRule) getStringListRules(ruleList []*SourceRule, mContent any, i
 	}
 }
 
+// resultStrings 把任意分析结果归一成字符串切片（[]string / []any / []*html.Node / 单值）。
+func resultStrings(result any) []string {
+	switch t := result.(type) {
+	case nil:
+		return nil
+	case []string:
+		return t
+	case []any:
+		out := make([]string, 0, len(t))
+		for _, v := range t {
+			out = append(out, anyToString(v))
+		}
+		return out
+	case []*html.Node:
+		out := make([]string, 0, len(t))
+		for _, v := range t {
+			out = append(out, outerHTML(v))
+		}
+		return out
+	case string:
+		return strings.Split(t, "\n")
+	default:
+		return []string{anyToString(result)}
+	}
+}
+
 // GetString 对应 getString(rule, mContent, isUrl)。
 func (a *AnalyzeRule) GetString(ruleStr string, mContent any, isUrl bool) (string, error) {
 	if ruleStr == "" {

internal/service/reader/rule/analyzer_url_list_test.go

@@ -0,0 +1,40 @@
+package rule
+
+import (
+	"strings"
+	"testing"
+)
+
+// TestGetStringListURLFromJSArray URL 类规则（nextTocUrl / chapterUrl / coverUrl…）
+// 由 JS 生成时，goja 导出的是 []any。早期实现只认 []string，JS 给的地址数组会被
+// 静默丢掉，表现为「书源写了 nextTocUrl 却永远不翻页」。
+func TestGetStringListURLFromJSArray(t *testing.T) {
+	ar := NewAnalyzeRule()
+	ar.SetContent(`{"total":399,"limit":100}`, "https://api.example.com/toc?limit=100&offset=0")
+	ar.SetJSRunner(func(js string, result any) (any, error) {
+		return NewJSRunner(JSConfig{BaseURL: "https://api.example.com/toc?limit=100&offset=0"}).Run(nil, js, result, "https://api.example.com/toc?limit=100&offset=0")
+	})
+
+	// JS 返回数组（真实书源就是这种写法：一次给出全部后续页）
+	rule := `<js>['https://api.example.com/toc?offset=100','https://api.example.com/toc?offset=200']</js>`
+	urls, err := ar.GetStringList(rule, nil, true)
+	if err != nil {
+		t.Fatalf("err=%v", err)
+	}
+	if len(urls) != 2 {
+		t.Fatalf("拿到 %d 个地址，期望 2（JS 数组被丢掉了）: %v", len(urls), urls)
+	}
+	if urls[0] != "https://api.example.com/toc?offset=100" || urls[1] != "https://api.example.com/toc?offset=200" {
+		t.Fatalf("地址不对: %v", urls)
+	}
+
+	// 相对地址要按当前页绝对化
+	ruleRel := `<js>['/toc?offset=300']</js>`
+	urls, err = ar.GetStringList(ruleRel, nil, true)
+	if err != nil {
+		t.Fatalf("err=%v", err)
+	}
+	if len(urls) != 1 || !strings.HasPrefix(urls[0], "https://api.example.com/toc?offset=300") {
+		t.Fatalf("相对地址没有绝对化: %v", urls)
+	}
+}

internal/service/reader/rule/bridge.go

@@ -13,6 +13,7 @@ import (
 	"strings"
 
 	"github.com/dop251/goja"
+	"github.com/google/uuid"
 )
 
 // 本文件对应 legado JsExtensions / JsEncodeUtils / RegexJsExtensions 中
@@ -401,9 +402,38 @@ func newJavaObject(vm *goja.Runtime, r *JSRunner, a *AnalyzeRule) *goja.Object {
 	set("getWebViewUA", func(call goja.FunctionCall) goja.Value {
 		return vm.ToValue(defaultWebViewUA)
 	})
-	set("t2s", func(call goja.FunctionCall) goja.Value { return vm.ToValue(stringArg(call, 0)) })
-	set("s2t", func(call goja.FunctionCall) goja.Value { return vm.ToValue(stringArg(call, 0)) })
+	// 简繁转换（对应 legado ChineseUtils → quick-transfer）。这里按单字映射实现，
+	// 见 zh_convert.go 的说明。
+	set("t2s", func(call goja.FunctionCall) goja.Value { return vm.ToValue(zhToSimplified(stringArg(call, 0))) })
+	set("s2t", func(call goja.FunctionCall) goja.Value { return vm.ToValue(zhToTraditional(stringArg(call, 0))) })
 	set("htmlFormat", func(call goja.FunctionCall) goja.Value { return vm.ToValue(stringArg(call, 0)) })
+	// randomUUID：部分书源拿它生成设备标识/请求 ID（缺失会让整条规则抛异常）。
+	set("randomUUID", func(call goja.FunctionCall) goja.Value { return vm.ToValue(uuid.NewString()) })
+	// toNumChapter：章节标题里的数字规整成阿拉伯数字（见 zh_number.go）。
+	set("toNumChapter", func(call goja.FunctionCall) goja.Value { return vm.ToValue(numChapter(stringArg(call, 0))) })
+	// toURL(url[, baseUrl])：对应 legado JsURL（host/origin/pathname/searchParams）。
+	set("toURL", func(call goja.FunctionCall) goja.Value {
+		base := ""
+		if len(call.Arguments) > 1 && !goja.IsUndefined(call.Arguments[1]) && !goja.IsNull(call.Arguments[1]) {
+			base = call.Arguments[1].String()
+		}
+		obj, err := newJSURLObject(vm, stringArg(call, 0), base)
+		if err != nil {
+			bridgeErr("toURL", err)
+		}
+		return obj
+	})
+	// logType：调试用，打印值的类型（对应 legado 的日志实现）。
+	set("logType", func(call goja.FunctionCall) goja.Value {
+		if r.cfg.Log != nil {
+			if len(call.Arguments) == 0 || goja.IsNull(call.Arguments[0]) || goja.IsUndefined(call.Arguments[0]) {
+				r.cfg.Log("null")
+			} else {
+				r.cfg.Log(fmt.Sprintf("%T", call.Arguments[0].Export()))
+			}
+		}
+		return goja.Null()
+	})
 
 	// ── 书源会话状态（legado 中 `java` 与 `source` 是同一对象） ──
 	if r.state != nil {
@@ -496,21 +526,26 @@ func newJavaObject(vm *goja.Runtime, r *JSRunner, a *AnalyzeRule) *goja.Object {
 	//   open / searchBook —— legado 中仅做原生界面跳转（打开搜索页 / 登录页），
 	//                        服务端没有对应页面，谎报成功会让书源走错分支
 
-	// 需要真正无头浏览器/本地文件系统的能力：明确抛出不支持
-	unsupported := func(name string) func(goja.FunctionCall) goja.Value {
+	// 需要真正无头浏览器/本地文件系统的能力：明确抛出不支持，并把原因说清楚
+	// （书源调试面板会把这句原样显示出来，用户能立刻判断该不该继续折腾这个源）。
+	unsupported := func(name, reason string) func(goja.FunctionCall) goja.Value {
 		return func(call goja.FunctionCall) goja.Value {
-			panic(vm.ToValue("java." + name + " 需要浏览器或本地文件能力，服务端不支持"))
+			panic(vm.ToValue(fmt.Sprintf("java.%s 服务端不支持：%s", name, reason)))
 		}
 	}
 	for _, name := range []string{
 		"webView", "webViewGetSource", "webViewGetOverrideUrl",
 		"openVideoPlayer", "getVerificationCode",
+	} {
+		set(name, unsupported(name, "需要无头浏览器（WebView）"))
+	}
+	for _, name := range []string{
 		"importScript", "cacheFile", "downloadFile", "readFile", "readTxtFile", "deleteFile",
 		"unzipFile", "un7zFile", "unrarFile", "unArchiveFile", "getTxtInFolder",
 		"getZipStringContent", "getZipByteArrayContent",
 		"getRarStringContent", "get7zStringContent",
 	} {
-		set(name, unsupported(name))
+		set(name, unsupported(name, "需要本地文件/压缩包能力"))
 	}
 
 	return o

internal/service/reader/rule/errors.go

@@ -11,5 +11,5 @@ var (
 	// JS 引擎（goja + java.* 桥）在 P2 阶段接入，届时移除本错误路径。
 	ErrJsUnsupported = errors.New("书源使用了 JS 规则，当前阶段暂不支持")
 	// ErrWebJSUnsupported 书源依赖 webView/webJs 抓取，服务端无头浏览器不在支持范围。
-	ErrWebJSUnsupported = errors.New("书源依赖 webView 抓取，暂不支持")
+	ErrWebJSUnsupported = errors.New("书源依赖 webView/webJs（需要无头浏览器），服务端不支持；该源请在阅读 App 内使用")
 )

internal/service/reader/rule/json.go

@@ -2,6 +2,8 @@ package rule
 
 import (
 	"encoding/json"
+	"sort"
+	"strconv"
 	"strings"
 )
 
@@ -38,6 +40,8 @@ func jsonRead(root any, path string) any {
 }
 
 // jsonValueToString 对应 Kotlin 的 ob.toString() / joinToString("\n")。
+// 列表按 "\n" 拼接（legado 的 getString 就是这么做的）；对象走 Java 的 Map.toString
+// 形态（见 javaValueString），书源的正则大量依赖这个形态。
 func jsonValueToString(ob any) string {
 	switch t := ob.(type) {
 	case nil:
@@ -51,7 +55,63 @@ func jsonValueToString(ob any) string {
 		}
 		return strings.Join(parts, "\n")
 	default:
-		return anyToString(t)
+		return javaValueString(t)
+	}
+}
+
+// javaValueString 按 Java 的 Map/List toString 形态输出 JSON 值。
+//
+// 书源规则里的正则就是照着这个形态写的，最典型的是拷贝漫画的作者规则
+// `$.author##.*name=(.*?)\,.*##$1`：它期望拿到 `{name=岸本斉史, alias=…}`。
+// 之前这里用 Go 的 fmt 输出 `map[alias:… name:…]`，`name=` 根本匹配不到，
+// 作者字段就退化成一整串 map 文本。
+//
+// 已知差异：Java 的 LinkedTreeMap 保留 JSON 里的键顺序，而 Go 的
+// map[string]interface{} 不保序（JSONPath 库也只认这个类型），这里按 **键排序**
+// 输出以保证确定性。绝大多数「取某个键」的正则不受影响，但依赖原始键序的正则
+// （如 `.*name=(.*?)\,` 且 name 是最后一个键）仍可能与阅读 App 的结果不同。
+func javaValueString(v any) string {
+	switch t := v.(type) {
+	case nil:
+		return "null"
+	case string:
+		return t
+	case bool:
+		return strconv.FormatBool(t)
+	case float64:
+		return strconv.FormatFloat(t, 'f', -1, 64)
+	case int:
+		return strconv.Itoa(t)
+	case int64:
+		return strconv.FormatInt(t, 10)
+	case json.Number:
+		return t.String()
+	case []any:
+		parts := make([]string, len(t))
+		for i, e := range t {
+			parts[i] = javaValueString(e)
+		}
+		return "[" + strings.Join(parts, ", ") + "]"
+	case map[string]any:
+		keys := make([]string, 0, len(t))
+		for k := range t {
+			keys = append(keys, k)
+		}
+		sort.Strings(keys)
+		var sb strings.Builder
+		sb.WriteByte('{')
+		for i, k := range keys {
+			if i > 0 {
+				sb.WriteString(", ")
+			}
+			sb.WriteString(k)
+			sb.WriteByte('=')
+			sb.WriteString(javaValueString(t[k]))
+		}
+		sb.WriteByte('}')
+		return sb.String()
+	default:
+		return anyToString(v)
 	}
 }
 

internal/service/reader/rule/jsurl.go

@@ -0,0 +1,89 @@
+package rule
+
+import (
+	"fmt"
+	"net/url"
+	"strings"
+
+	"github.com/dop251/goja"
+)
+
+// newJSURLObject 构造 legado JsURL 的等效对象（java.toURL）。
+//
+// 对应 io.legado.app.utils.JsURL：它只暴露四个属性 ——
+//
+//	host         主机名
+//	origin       "scheme://host[:port]"（默认端口不写）
+//	pathname     路径（原样，未解码）
+//	searchParams 查询参数（值已 URL 解码；同名只留最后一个，与 legado 一致）
+//
+// legado 返回的是 Java Map，Rhino 下书源会写 searchParams.get("x")，
+// 而 goja 里更自然的是 searchParams.x，所以两者都支持。
+func newJSURLObject(vm *goja.Runtime, raw, base string) (*goja.Object, error) {
+	u, err := parseJSURL(raw, base)
+	if err != nil {
+		return nil, err
+	}
+	obj := vm.NewObject()
+	origin := u.Scheme + "://" + u.Hostname()
+	if port := u.Port(); port != "" {
+		origin += ":" + port
+	}
+	_ = obj.Set("host", u.Hostname())
+	_ = obj.Set("origin", origin)
+	_ = obj.Set("pathname", u.EscapedPath())
+
+	params := vm.NewObject()
+	for key, values := range u.Query() {
+		if len(values) == 0 {
+			continue
+		}
+		_ = params.Set(key, values[len(values)-1])
+	}
+	// searchParams.get(name)：兼容 Java Map 的取法；不存在时给 null（对应 Java 的 null）。
+	get := func(call goja.FunctionCall) goja.Value {
+		if len(call.Arguments) == 0 {
+			return goja.Null()
+		}
+		v := params.Get(call.Arguments[0].String())
+		if v == nil || goja.IsUndefined(v) {
+			return goja.Null()
+		}
+		return v
+	}
+	_ = params.Set("get", get)
+	_ = obj.Set("searchParams", params)
+	return obj, nil
+}
+
+// parseJSURL 解析 java.toURL 的入参。base 非空时按基础地址解析相对路径
+// （对应 Java 的 URL(base, url)）；解析不出绝对地址时报错（Java 会抛 MalformedURLException）。
+func parseJSURL(raw, base string) (*url.URL, error) {
+	raw = strings.TrimSpace(raw)
+	if raw == "" {
+		return nil, fmt.Errorf("toURL: 地址为空")
+	}
+	if base != "" {
+		b, err := url.Parse(strings.TrimSpace(base))
+		if err != nil || !b.IsAbs() {
+			return nil, fmt.Errorf("toURL: baseUrl 不是绝对地址: %s", base)
+		}
+		rel, err := url.Parse(raw)
+		if err != nil {
+			return nil, fmt.Errorf("toURL: %v", err)
+		}
+		u := b.ResolveReference(rel)
+		if !u.IsAbs() || u.Host == "" {
+			return nil, fmt.Errorf("toURL: 解析结果不是绝对地址: %s", raw)
+		}
+		return u, nil
+	}
+	u, err := url.Parse(raw)
+	if err != nil {
+		return nil, fmt.Errorf("toURL: %v", err)
+	}
+	if u.Scheme == "" || u.Host == "" {
+		return nil, fmt.Errorf("toURL: 不是绝对地址: %s", raw)
+	}
+	return u, nil
+}

internal/service/reader/rule/jsurl_test.go

@@ -0,0 +1,92 @@
+package rule
+
+import (
+	"strings"
+	"testing"
+)
+
+// TestJavaValueStringMatchesJavaMapToString 书源正则依赖 Java 的 Map.toString 形态。
+// 真实案例：拷贝漫画的 author 规则 `$.author##.*name=(.*?)\,.*##$1`，
+// 期望拿到 `{name=岸本斉史, alias=…}`；Go 的 `map[...]` 形态匹配不到，作者会退化成一串 map 文本。
+func TestJavaValueStringMatchesJavaMapToString(t *testing.T) {
+	ar := NewAnalyzeRule()
+	ar.SetContent(`{"author":[{"name":"岸本斉史","alias":"岸本齐史,キシモトマサ","path_word":"anbenqishi"}]}`, "https://api.example.com")
+
+	got, err := ar.GetString(`$.author##.*name=(.*?)\,.*##$1`, nil, false)
+	if err != nil {
+		t.Fatalf("err=%v", err)
+	}
+	if got != "岸本斉史" {
+		t.Fatalf("author = %q，期望 岸本斉史（Java Map 形态没对上）", got)
+	}
+
+	// 对象/数组/标量的字符串形态
+	str, err := ar.GetString(`$.author[0]`, nil, false)
+	if err != nil {
+		t.Fatalf("err=%v", err)
+	}
+	for _, want := range []string{"{", "name=岸本斉史", "alias=岸本齐史,キシモトマサ", "path_word=anbenqishi"} {
+		if !strings.Contains(str, want) {
+			t.Errorf("对象字符串 %q 缺少 %q", str, want)
+		}
+	}
+	if strings.Contains(str, "map[") {
+		t.Errorf("仍是 Go 的 map 形态: %q", str)
+	}
+}
+
+// TestJavaValueStringScalars 标量与嵌套结构按 Java 习惯输出。
+func TestJavaValueStringScalars(t *testing.T) {
+	cases := []struct {
+		in   any
+		want string
+	}{
+		{nil, "null"},
+		{"x", "x"},
+		{true, "true"},
+		{float64(399), "399"},
+		{float64(1.5), "1.5"},
+		{[]any{float64(1), "a"}, "[1, a]"},
+		{map[string]any{"b": float64(1), "a": "x"}, "{a=x, b=1}"},
+		{map[string]any{"n": []any{"x", "y"}}, "{n=[x, y]}"},
+	}
+	for _, c := range cases {
+		if got := javaValueString(c.in); got != c.want {
+			t.Errorf("javaValueString(%#v) = %q，期望 %q", c.in, got, c.want)
+		}
+	}
+}
+
+// TestJavaToURL legado JsURL 的四个属性（并兼容 Java Map 的 searchParams.get）。
+func TestJavaToURL(t *testing.T) {
+	r := NewJSRunner(JSConfig{})
+	ar := NewAnalyzeRule()
+
+	check := func(expr, want string) {
+		t.Helper()
+		v, err := r.Run(ar, expr, nil, "")
+		if err != nil {
+			t.Fatalf("%s 失败: %v", expr, err)
+		}
+		if got := anyToString(v); got != want {
+			t.Errorf("%s = %q，期望 %q", expr, got, want)
+		}
+	}
+
+	check(`java.toURL('https://api.example.com:8443/a/b?x=1&y=%E4%B8%AD%E6%96%87').host`, "api.example.com")
+	check(`java.toURL('https://api.example.com:8443/a/b?x=1&y=%E4%B8%AD%E6%96%87').origin`, "https://api.example.com:8443")
+	check(`java.toURL('https://api.example.com/a/b').origin`, "https://api.example.com")
+	check(`java.toURL('https://api.example.com/a/b?x=1').pathname`, "/a/b")
+	check(`java.toURL('https://api.example.com/a/b?x=1&y=%E4%B8%AD%E6%96%87').searchParams.x`, "1")
+	check(`java.toURL('https://api.example.com/a/b?x=1&y=%E4%B8%AD%E6%96%87').searchParams.y`, "中文")
+	check(`java.toURL('https://api.example.com/a/b?x=1').searchParams.get('x')`, "1")
+	// 相对地址按 baseUrl 解析（对应 Java 的 URL(base, url)）
+	check(`java.toURL('/next?p=2', 'https://api.example.com/a/b').origin`, "https://api.example.com")
+	check(`java.toURL('/next?p=2', 'https://api.example.com/a/b').pathname`, "/next")
+	// 不存在的参数给 null（对应 Java Map.get 返回 null）
+	check(`String(java.toURL('https://api.example.com/a').searchParams.get('nope'))`, "null")
+	// 非绝对地址必须报错（Java 抛 MalformedURLException），不能静默给一个空对象
+	if _, err := r.Run(ar, `java.toURL('not-a-url').host`, nil, ""); err == nil {
+		t.Error("非绝对地址应当报错")
+	}
+}

internal/service/reader/rule/url.go

@@ -48,6 +48,8 @@ type Request struct {
 	// Unsupported 非 nil 表示该请求依赖当前阶段不支持的能力，
 	// 值为对应错误（webView；JS 在接入 runner 后已支持）。
 	Unsupported error
+	// Retry 对应 URL 选项的 retry：可恢复失败时的额外重试次数。
+	Retry *int
 }
 
 // ParseAnalyzeUrl 对应 AnalyzeUrl.init：URL 规则 → 可执行请求。
@@ -202,6 +204,7 @@ func ParseAnalyzeUrlWithJS(mUrl, key string, page int, baseUrl string, runner *J
 			}
 		}
 		req.Charset = option.Charset
+		req.Retry = option.Retry
 		// 对应 legado AnalyzeUrl.type：值本身不参与判断，只要非空就把响应按
 		// 「原始字节的 hex」返回。书源借此把 data: 地址当参数信封用。
 		if option.Type != "" {

internal/service/reader/rule/zh_convert_test.go

@@ -0,0 +1,66 @@
+package rule
+
+import (
+	"strings"
+	"testing"
+)
+
+// TestZhToSimplified 常用繁体字要真的转成简体。
+// 这是书源里 java.t2s(key) / java.t2s(result) 的语义：阅读 App 会转换，
+// 不实现时繁体站点既搜不到（关键字没转）也显示不对（标题保持繁体）。
+func TestZhToSimplified(t *testing.T) {
+	cases := map[string]string{
+		"島忍者神龜": "岛忍者神龟",
+		"航海王":   "航海王",
+		"我們的書":  "我们的书",
+		"學習園地":  "学习园地",
+		"":      "",
+		"abc123": "abc123", // 非中文原样返回
+	}
+	for in, want := range cases {
+		if got := zhToSimplified(in); got != want {
+			t.Errorf("zhToSimplified(%q) = %q，期望 %q", in, got, want)
+		}
+	}
+}
+
+// TestZhToTraditional 反向转换。
+func TestZhToTraditional(t *testing.T) {
+	cases := map[string]string{
+		"岛忍者神龟": "島忍者神龜",
+		"我们的书":  "我們的書",
+		"学习园地":  "學習園地",
+		"":      "",
+	}
+	for in, want := range cases {
+		if got := zhToTraditional(in); got != want {
+			t.Errorf("zhToTraditional(%q) = %q，期望 %q", in, got, want)
+		}
+	}
+}
+
+// TestZhConvertLeavesPlainTextAlone 不需要转换的文本必须原样返回（含表情/符号）。
+func TestZhConvertLeavesPlainTextAlone(t *testing.T) {
+	const s = "第1话 ROMANCE DAWN 冒险的序幕 🏴‍☠️"
+	if got := zhToSimplified(s); got != s {
+		t.Fatalf("zhToSimplified 改动了无需转换的文本: %q", got)
+	}
+}
+
+// TestZhDictParsed 词典要真的解析出来了（防止生成文件被截断）。
+func TestZhDictParsed(t *testing.T) {
+	zhInit()
+	if len(zhT2S) < 3000 {
+		t.Fatalf("t2s 词典条目 %d，明显偏少", len(zhT2S))
+	}
+	if len(zhS2T) < 3000 {
+		t.Fatalf("s2t 词典条目 %d，明显偏少", len(zhS2T))
+	}
+	// 空格/竖线不属于任何键
+	if _, ok := zhT2S[' ']; ok {
+		t.Fatal("词典里混进了分隔符")
+	}
+	if strings.ContainsRune(zhT2SData, '\uFFFD') {
+		t.Fatal("词典数据含替换符，生成过程有损")
+	}
+}

internal/service/reader/rule/zh_number.go

@@ -0,0 +1,93 @@
+package rule
+
+import (
+	"regexp"
+	"strconv"
+)
+
+// 中文数字 → 阿拉伯数字，用于 java.toNumChapter。
+//
+// 对应 legado 的 `AppPattern.titleNumPattern` + `StringUtils.stringToInt`：把
+// 「第一百零八章」规整成「第108章」。书源用它统一章节标题（排序/去重）。
+// 解析不出来时原样返回，不做猜测。
+var chapterTokenRe = regexp.MustCompile(`[0-9]+|[〇零一二三四五六七八九十百千万两兩]+`)
+
+var (
+	zhDigits   = map[rune]int{'〇': 0, '零': 0, '一': 1, '二': 2, '两': 2, '兩': 2, '三': 3, '四': 4, '五': 5, '六': 6, '七': 7, '八': 8, '九': 9}
+	zhUnits    = map[rune]int{'十': 10, '百': 100, '千': 1000}
+	zhBigUnits = map[rune]int{'万': 10000, '億': 100000000, '亿': 100000000}
+)
+
+// numChapter 把标题里第一处数字规整成阿拉伯数字。
+func numChapter(s string) string {
+	loc := chapterTokenRe.FindStringIndex(s)
+	if loc == nil {
+		return s
+	}
+	n, ok := parseCNSNum(s[loc[0]:loc[1]])
+	if !ok {
+		return s
+	}
+	return s[:loc[0]] + strconv.Itoa(n) + s[loc[1]:]
+}
+
+// parseCNSNum 解析纯阿拉伯数字或中文数字；无法解析返回 false。
+func parseCNSNum(tok string) (int, bool) {
+	if tok == "" {
+		return 0, false
+	}
+	if n, err := strconv.Atoi(tok); err == nil {
+		return n, true
+	}
+	// 全是数字字符（如「一〇二」这种按位念法）→ 逐位拼起来
+	if digitsOnly(tok) {
+		n := 0
+		for _, r := range tok {
+			n = n*10 + zhDigits[r]
+		}
+		return n, true
+	}
+	total, section, num := 0, 0, 0
+	seen := false
+	for _, r := range tok {
+		if d, ok := zhDigits[r]; ok {
+			num = d
+			seen = true
+			continue
+		}
+		if u, ok := zhUnits[r]; ok {
+			if num == 0 {
+				num = 1 // 「十二」这类省略了前导一的写法
+			}
+			section += num * u
+			num = 0
+			seen = true
+			continue
+		}
+		if big, ok := zhBigUnits[r]; ok {
+			section += num
+			if section == 0 {
+				section = 1
+			}
+			total += section * big
+			section, num = 0, 0
+			seen = true
+			continue
+		}
+		return 0, false
+	}
+	if !seen {
+		return 0, false
+	}
+	return total + section + num, true
+}
+
+// digitsOnly 判断字符串是否只由中文数字字符组成。
+func digitsOnly(s string) bool {
+	for _, r := range s {
+		if _, ok := zhDigits[r]; !ok {
+			return false
+		}
+	}
+	return true
+}

internal/service/reader/rule/zh_number_test.go

@@ -0,0 +1,53 @@
+package rule
+
+import (
+	"strings"
+	"testing"
+)
+
+// TestNumChapter 章节标题里的中文/阿拉伯数字要规整成阿拉伯数字。
+// 书源用 java.toNumChapter 统一标题；缺这个函数时整条规则会抛异常（源直接不可用）。
+func TestNumChapter(t *testing.T) {
+	cases := map[string]string{
+		"第一百零八章":  "第108章",
+		"第十二话":    "第12话",
+		"第3话":      "第3话",
+		"第一话 冒险的序幕": "第1话 冒险的序幕",
+		"一〇二":      "102",
+		"两千零一":     "2001",
+		"航海王":      "航海王", // 没有数字：原样返回
+		"":         "",
+	}
+	for in, want := range cases {
+		if got := numChapter(in); got != want {
+			t.Errorf("numChapter(%q) = %q，期望 %q", in, got, want)
+		}
+	}
+}
+
+// TestJavaExtraHelpers 书源 JS 里会直接调用的几个函数必须存在且可用。
+func TestJavaExtraHelpers(t *testing.T) {
+	r := NewJSRunner(JSConfig{})
+
+	v, err := r.Run(NewAnalyzeRule(), `java.randomUUID()`, nil, "")
+	if err != nil {
+		t.Fatalf("java.randomUUID() 失败: %v", err)
+	}
+	id := anyToString(v)
+	if len(id) != 36 || strings.Count(id, "-") != 4 {
+		t.Fatalf("randomUUID 返回值不像 UUID: %q", id)
+	}
+
+	v, err = r.Run(NewAnalyzeRule(), `java.toNumChapter('第一百零八章')`, nil, "")
+	if err != nil {
+		t.Fatalf("java.toNumChapter() 失败: %v", err)
+	}
+	if got := anyToString(v); got != "第108章" {
+		t.Fatalf("toNumChapter = %q，期望 第108章", got)
+	}
+
+	// 未声明设备能力时 java.deviceID 仍应抛异常（保持「不谎报运行环境」的语义）
+	if _, err := r.Run(NewAnalyzeRule(), `java.deviceID()`, nil, ""); err == nil {
+		t.Fatal("java.deviceID() 应当抛异常")
+	}
+}