From 2fcf7180fef38234c819ca85ae07e19fcff0905d Mon Sep 17 00:00:00 2001
From: argszero <argszero@gmail.com>
Date: Tue, 15 Sep 2026 15:13:38 +0800
Subject: [PATCH] fix(ui): own static i18n content at the innermost element
 that carries it
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

`applyStatic()` in `ui/js/i18n.js` walks every `[data-i18n]` element and does
`els[i].innerHTML = t(key)`. A element that already carries a *text* `data-i18n`
therefore cannot also rely on language hooks on its children: the ancestor's
step replaces the whole inner HTML, detaching the child element (and its own
`data-i18n*` attribute) from the document; the loop then assigns into that
detached node -- no exception, no effect. jsdom measures `isConnected === false`.

Two sites did this, and both existing gates are structurally blind to it:
`every_static_i18n_attribute_resolves` only asks whether the key exists in both
packs (it does), and a "find the key as text" dead-key scan sees the key literal
sitting right there in `index.html` (so it counts as used). An attribute that can
never take effect is neither.

- `index.html:617` -- the raise-request card:
  `<h3 data-i18n="admin.raise.title">加额申请 <span data-i18n="admin.raise.sub">…</span></h3>`.
  Both pack values are plain text, so the child span was permanently destroyed:
  the hint "(member applies -> admin approves / rejects)" did not render in
  *either* language, and it never recovers -- `app.js` only writes
  `#raise-requests` and never redraws that heading. Fixed by making the two
  strings sibling carriers (the repository already uses this shape in
  `.wallet-hint`), so the heading keeps its own localization.
- `index.html:79` -- the login footer:
  `<p data-i18n="login.foot">…<a id="reg-link" data-i18n="login.register">…</a>…</p>`.
  `login.foot`'s value *embeds* the same markup (including `id="reg-link"`), so
  the rendered text and the click (a document-delegated listener keyed on
  `t.id`) were never broken -- but the static hook was dead, which made
  `login.register` an orphan key fed only by it. Removed the dead attribute and
  the now-unreferenced key from both packs (the value already carries the link).

Guard rails:

- New scanner `scan_i18n_nesting` + test
  `no_data_i18n_attribute_nests_inside_a_data_i18n_element` in `src/i18n_pack.rs`:
  a tag-stack walk over `index.html` that fails when any `data-i18n*` attribute
  sits inside an ancestor with a text `data-i18n`. HTML comments are stripped
  first (their markup is not structure), void/self-closing elements never enter
  the stack, and the tag-end scan skips quoted `>` so an attribute value cannot
  desynchronise the parser. It also reports three positive controls (start tags,
  text carriers, unclosed stack at EOF) so "0 violations" cannot be misread as
  "the scanner saw nothing".
- `nested_i18n_detector_detects_injected_defects`: a negative control built from
  the real pre-fix markup, plus positive controls that the legal shapes are not
  reported -- an ancestor carrying only an *attribute-kind* hook
  (`data-i18n-title` / `-label` write a single attribute via `setAttribute` and
  leave child markup alone, which is why `select#tx-range`'s five
  `<option data-i18n="tx.range.*">` and `div#help-panel`'s `<strong>` are fine),
  and that the reported line number is the real one.
- `ui/README.md`: the convention (sibling carriers; a pack value that embeds its
  own markup is a second legitimate shape and is exactly why `login.foot`
  survives), the measured boundary, and the gate's scope.

Scope, stated honestly rather than papered over: the gate pins the *nesting*
axis only. The A/B leg `m_drop_parent` (delete the heading's own `data-i18n`) is
GREEN by construction -- it genuinely removes the nesting, but it trades a
never-applied attribute for a lost localization: `admin.raise.title` then has
zero references outside the pack (the orphan set grows by exactly one, measured).
Orphan keys are a different axis, uncovered today (dozens already exist), and are
out of scope here; the A/B declares that leg GREEN instead of pretending it was
rejected.

The other measured boundary is JS-cleared containers: a `data-i18n*` attribute
inside a container whose contents `app.js` replaces wholesale is dead the same
way. Measured at 0 sites today, so not gated -- the lexical approximation (id ->
`innerHTML =`) is weaker than this rule and can wait.

Cache-bust `ui/js/i18n.js?v=20260915-4` -> `-5`; the `i18n_pack` positive-control
constants are recalibrated to the values the gates reported (static attrs
333 -> 332 / 308 -> 307, key counts 812 -> 811 each), not hand-computed.

Tests: `cargo test` 292 -> 294; `cargo fmt --check` clean; clippy reports only the
pre-existing `protocol.rs:662`. A/B (`tmp/c2151_gate_ab.py`) mutates the tree in
place, restores it byte-exactly (md5 checked) and declares every leg's
expectation: FIX green; unfixed red with exactly the two axis sites
(`index.html:79`, `index.html:617`); half-fix (one site only) red; cosmetic
escape (keep the nesting, re-materialise the hint from the pack value) red.
---
 src/i18n_pack.rs | 354 ++++++++++++++++++++++++++++++++++++++++++++++-
 ui/README.md     |  45 ++++++
 ui/index.html    |   6 +-
 ui/js/i18n.js    |   2 -
 4 files changed, 398 insertions(+), 9 deletions(-)

diff --git a/src/i18n_pack.rs b/src/i18n_pack.rs
index 5d7ea96..18f9491 100644
--- a/src/i18n_pack.rs
+++ b/src/i18n_pack.rs
@@ -94,10 +94,10 @@ const EN_END: &str = "\n  };";
 ///
 /// ⚠️ `T_LITERAL_COUNT` 是 `T("…")` **调用点**总数，不是键数，也不是去重后的键数 ——
 /// 三个集合各不相同（坑 99）；说「这个数不该变」之前先确认它在数哪个集合。
-const ZH_KEY_COUNT: usize = 812;
-const EN_KEY_COUNT: usize = 812;
-const STATIC_ATTR_COUNT: usize = 333;
-const STATIC_ATTR_DISTINCT: usize = 308;
+const ZH_KEY_COUNT: usize = 811;
+const EN_KEY_COUNT: usize = 811;
+const STATIC_ATTR_COUNT: usize = 332;
+const STATIC_ATTR_DISTINCT: usize = 307;
 const T_LITERAL_COUNT: usize = 542;
 const T_LITERAL_DISTINCT: usize = 433;
 
@@ -195,6 +195,232 @@ fn scan_static_attributes(src: &str) -> Vec<String> {
     out
 }
 
+/// `data-i18n` 的四种静态属性形态（与 `scan_static_attributes` 的后缀集合一致）。
+const I18N_ATTRS: [&str; 4] = [
+    "data-i18n",
+    "data-i18n-ph",
+    "data-i18n-title",
+    "data-i18n-label",
+];
+
+/// 从 `lt`（`<` 的下标）出发，返回该标签 `>` 的下标。
+///
+/// **必须跳过引号内的 `>`**：属性值里出现 `>` 是合法 HTML（本仓真实形态：
+/// `title="搜索用户名 / 邮箱…"` 之类倒没有，但 `data-i18n` 的**值**由语言包决定，
+/// 未来随时可能含尖括号）。一个被 `>` 提前截断的解析器会把后续标记错位、静默漏检。
+fn html_tag_end(src: &str, lt: usize) -> Option<usize> {
+    let b = src.as_bytes();
+    let mut i = lt + 1;
+    let mut quote: Option<u8> = None;
+    while i < b.len() {
+        let c = b[i];
+        match quote {
+            Some(q) => {
+                if c == q {
+                    quote = None;
+                }
+            }
+            None => {
+                if c == b'"' || c == b'\'' {
+                    quote = Some(c);
+                } else if c == b'>' {
+                    return Some(i);
+                }
+            }
+        }
+        i += 1;
+    }
+    None
+}
+
+/// 把起始标签体（`<` 与 `>` 之间，不含尖括号）切成 `(属性名, 属性值)`，值已去引号。
+///
+/// 逐属性切分而不是在整段里搜 `data-i18n=`：后者会命中**别的属性值里**的字符串
+/// （如 `title="data-i18n=x"`），把一个装饰性文本当成真属性。
+fn tag_attributes(body: &str) -> Vec<(String, String)> {
+    fn ws(c: u8) -> bool {
+        matches!(c, b' ' | b'\t' | b'\n' | b'\r')
+    }
+    let b = body.as_bytes();
+    let mut out = Vec::new();
+    let mut i = 0usize;
+    // 跳过标签名
+    while i < b.len() && !ws(b[i]) && b[i] != b'/' {
+        i += 1;
+    }
+    while i < b.len() {
+        while i < b.len() && ws(b[i]) {
+            i += 1;
+        }
+        if i >= b.len() || b[i] == b'/' {
+            break;
+        }
+        let ns = i;
+        while i < b.len() && !ws(b[i]) && b[i] != b'=' {
+            i += 1;
+        }
+        let name = body[ns..i].to_string();
+        let mut j = i;
+        while j < b.len() && ws(b[j]) {
+            j += 1;
+        }
+        if j < b.len() && b[j] == b'=' {
+            j += 1;
+            while j < b.len() && ws(b[j]) {
+                j += 1;
+            }
+            if j < b.len() && (b[j] == b'"' || b[j] == b'\'') {
+                let q = b[j];
+                let vs = j + 1;
+                let mut e = vs;
+                while e < b.len() && b[e] != q {
+                    e += 1;
+                }
+                out.push((name, body[vs..e.min(b.len())].to_string()));
+                i = (e + 1).min(b.len());
+            } else {
+                let vs = j;
+                while j < b.len() && !ws(b[j]) {
+                    j += 1;
+                }
+                out.push((name, body[vs..j].to_string()));
+                i = j;
+            }
+        } else {
+            out.push((name, String::new()));
+            i = j;
+        }
+    }
+    out
+}
+
+/// `scan_i18n_nesting` 的结果。带阳性对照字段，好让「0 违规」不被误读为「扫描器瞎了」。
+struct I18nNestingScan {
+    /// 违规清单（已格式化成可直接断言的文本）
+    violations: Vec<String>,
+    /// 带**文本** `data-i18n` 属性的元素个数（阳性对照：为 0 ⇒ 扫描器没在看）
+    text_carriers: usize,
+    /// 解析到的起始标签数（阳性对照：为 0 ⇒ 扫描器没在看）
+    start_tags: usize,
+    /// EOF 时仍未闭合的元素名（非空 ⇒ 语料把扫描器弄瞎了，拒绝据此判绿）
+    leftover: Vec<String>,
+}
+
+/// 扫描 `index.html`：`data-i18n*` 属性**绝不能**落在「带文本 `data-i18n` 的祖先元素」内部。
+///
+/// 为什么（`ui/js/i18n.js::applyStatic`）：
+/// ```js
+/// els = document.querySelectorAll("[data-i18n]");
+/// for (i = 0; i < els.length; i++) { if (key && ZH[key]) els[i].innerHTML = t(key); }
+/// ```
+/// 祖先那一步把 `innerHTML` **整体换成语包值** ⇒ 后代元素（连同它自己的 `data-i18n` 属性）
+/// 被从文档里摘掉；随后循环再对那个**已分离**的节点设值 —— 无异常、无效果。
+/// 实测（jsdom）：`<h3 data-i18n="admin.raise.title">加额申请 <span data-i18n="admin.raise.sub">…</span></h3>`
+/// 里那个 span 的 `isConnected` 为 `false`，两种语言下都不显示。
+///
+/// ⚠️ 只有**文本**属性（`data-i18n`）会砸后代：`data-i18n-title` / `-label` / `-ph`
+/// 走 `setAttribute`，只写那一个属性，子标记原样保留。因此 `select#tx-range`（带
+/// `data-i18n-title`）里的五个 `<option data-i18n="tx.range.*">` 是**合法**形态，
+/// 本规则不会误报 —— 这条边界由 `nested_i18n_detector_detects_injected_defects` 钉住。
+///
+/// ⚠️ 为什么两道既有门禁都看不见这类缺陷：`every_static_i18n_attribute_resolves` 只问
+/// 「键在不在两个包里」（在 ⇒ 过），而「按文本找引用」的死键扫描会看到那个键的**字面量
+/// 就写在 `index.html` 里**（⇒ 判「有人用」）。于是「一个永远不会被应用的属性」是它们的盲区。
+fn scan_i18n_nesting(src: &str) -> I18nNestingScan {
+    // HTML 空元素：没有闭合标签，不入栈
+    const VOID: [&str; 14] = [
+        "area", "base", "br", "col", "embed", "hr", "img", "input", "link", "meta", "param",
+        "source", "track", "wbr",
+    ];
+    let b = src.as_bytes();
+    // 栈元素：元素名 + 该元素自己的**文本** `data-i18n` 键（没有则 None）
+    let mut stack: Vec<(String, Option<String>)> = Vec::new();
+    let mut violations: Vec<String> = Vec::new();
+    let mut text_carriers = 0usize;
+    let mut start_tags = 0usize;
+    let mut i = 0usize;
+    while let Some(off) = src[i..].find('<') {
+        let lt = i + off;
+        // 注释：整段跳过（注释里的标记不是结构）—— #296 同族：证据文本必须先剥注释
+        if src[lt + 1..].starts_with("!--") {
+            match src[lt..].find("-->") {
+                Some(p) => {
+                    i = lt + p + 3;
+                    continue;
+                }
+                None => break,
+            }
+        }
+        // doctype / 处理指令
+        if matches!(b.get(lt + 1), Some(b'!') | Some(b'?')) {
+            match src[lt..].find('>') {
+                Some(p) => {
+                    i = lt + p + 1;
+                    continue;
+                }
+                None => break,
+            }
+        }
+        let gt = match html_tag_end(src, lt) {
+            Some(g) => g,
+            None => break,
+        };
+        let body = &src[lt + 1..gt];
+        i = gt + 1;
+        if let Some(rest) = body.strip_prefix('/') {
+            // 闭合标签：弹到最近的同名元素（连同它一起弹出）
+            let name = rest.trim().to_ascii_lowercase();
+            if let Some(pos) = stack.iter().rposition(|(n, _)| *n == name) {
+                stack.truncate(pos);
+            }
+            continue;
+        }
+        let self_close = body.trim_end().ends_with('/');
+        let name = body
+            .split(|c: char| c.is_ascii_whitespace() || c == '/' || c == '>')
+            .next()
+            .unwrap_or("")
+            .to_ascii_lowercase();
+        if name.is_empty() {
+            continue;
+        }
+        start_tags += 1;
+        let attrs = tag_attributes(body);
+        let i18n: Vec<(&str, &str)> = attrs
+            .iter()
+            .filter(|(n, _)| I18N_ATTRS.contains(&n.as_str()))
+            .map(|(n, v)| (n.as_str(), v.as_str()))
+            .collect();
+        if !i18n.is_empty() {
+            if let Some((_, Some(ancestor))) = stack.iter().rev().find(|(_, k)| k.is_some()) {
+                let line = src[..lt].bytes().filter(|c| *c == b'\n').count() + 1;
+                let desc: Vec<String> = i18n.iter().map(|(n, v)| format!("{n}=\"{v}\"")).collect();
+                violations.push(format!(
+                    "index.html:{line}: {} 落在 data-i18n=\"{ancestor}\" 的元素内部 —— \
+                     祖先的 innerHTML 替换会把它连同属性一起摘掉，该属性永远不会生效",
+                    desc.join(" ")
+                ));
+            }
+        }
+        if VOID.contains(&name.as_str()) || self_close {
+            continue;
+        }
+        match i18n.iter().find(|(n, _)| *n == "data-i18n") {
+            Some((_, v)) => {
+                text_carriers += 1;
+                stack.push((name, Some((*v).to_string())));
+            }
+            None => stack.push((name, None)),
+        }
+    }
+    I18nNestingScan {
+        violations,
+        text_carriers,
+        start_tags,
+        leftover: stack.into_iter().map(|(n, _)| n).collect(),
+    }
+}
+
 /// 扫描 `T("字面量")` 形态的文案键，返回其中的字面量。
 ///
 /// 前置字符若是标识符字符或 `.` 则跳过，避免命中 `fmt(` / `obj.T(` 之类。
@@ -714,6 +940,126 @@ mod tests {
         );
     }
 
+    /// 内容归属门禁（C2150）：`data-i18n*` 属性不得嵌在另一个**带文本 `data-i18n`** 的元素内部。
+    ///
+    /// 这类属性永远不会生效 —— 祖先的 `innerHTML = t(key)` 会把它连同元素一起从文档里摘掉。
+    /// 它同时是**必须**的：`every_static_i18n_attribute_resolves` 与任何「按文本找引用」的
+    /// 死键扫描都看不见它（键在两包俱在、字面量也写在 `index.html` 里）。
+    #[test]
+    fn no_data_i18n_attribute_nests_inside_a_data_i18n_element() {
+        let scan = scan_i18n_nesting(INDEX_HTML);
+        assert!(
+            scan.leftover.is_empty(),
+            "index.html 的标签栈在 EOF 未清空（{:?}）—— 扫描器被语料弄瞎了，拒绝据此判绿",
+            scan.leftover
+        );
+        // 阳性对照：扫描器真的在看，且看到了东西
+        assert!(scan.start_tags > 0, "未解析到任何起始标签 —— 扫描器已失真");
+        assert!(
+            scan.text_carriers > 0,
+            "未扫到任何带文本 data-i18n 的元素 —— 扫描器已失真，「0 违规」是假的"
+        );
+        assert!(
+            scan.violations.is_empty(),
+            "以下 data-i18n* 属性永远不会生效（祖先的 innerHTML 替换会把它们摘掉）：\n  - {}",
+            scan.violations.join("\n  - ")
+        );
+    }
+
+    /// 阴性对照：内容归属检查器必须真的会失败。
+    ///
+    /// 只断言「当前 0 违规」是不够的 —— 一个恒真的检查等价于没有检查。
+    /// 这里拿真实缺陷形态（含修复前的那两处原文）构造语料，断言检查器把它们报出来。
+    #[test]
+    fn nested_i18n_detector_detects_injected_defects() {
+        // ① 缺陷原形：修复前的 `admin.raise.title`（文本祖先 + 后代 `data-i18n` 子元素）
+        //    ⚠️ 语料含 `href="#"` ⇒ 必须用 `r##"…"##`：`r#"…"#` 会被 `"#` 提前闭合。
+        for bad in [
+            r##"<h3 data-i18n="admin.raise.title">加额申请 <span data-i18n="admin.raise.sub">（…）</span></h3>"##,
+            r##"<p data-i18n="login.foot">x<a href="#" id="reg-link" data-i18n="login.register">注册</a></p>"##,
+        ] {
+            let s = scan_i18n_nesting(bad);
+            assert_eq!(
+                s.violations.len(),
+                1,
+                "阴性对照失败：嵌套属性未被检出：{bad}"
+            );
+            assert!(
+                s.violations[0].contains("index.html:1:"),
+                "违规应带行号：{:?}",
+                s.violations[0]
+            );
+            assert!(s.leftover.is_empty(), "对照语料应为良构：{bad}");
+        }
+
+        // ② 正确形态：兄弟 span（修复后的写法）⇒ 不得报出
+        let good = r#"<h3><span data-i18n="admin.raise.title">加额申请</span> <span data-i18n="admin.raise.sub">（…）</span></h3>"#;
+        let s = scan_i18n_nesting(good);
+        assert!(
+            s.violations.is_empty(),
+            "阳性对照失败：兄弟写法被误报：{:?}",
+            s.violations
+        );
+        assert_eq!(s.text_carriers, 2, "阳性对照：应看到 2 个文本载体");
+
+        // ③ 合法形态：祖先只带**属性型**钩子（`data-i18n-title`），子标记存活。
+        //    真实形态＝`select#tx-range` 里的五个 `<option data-i18n="tx.range.*">`。
+        let title_parent = r#"<select data-i18n-title="tx.range.title"><option data-i18n="tx.range.24h">24 小时</option><option data-i18n="tx.range.7d">7 天</option></select>"#;
+        assert!(
+            scan_i18n_nesting(title_parent).violations.is_empty(),
+            "阳性对照失败：仅写属性的祖先（data-i18n-title）被误报"
+        );
+        // 同理，`data-i18n-label` 祖先（真实形态＝`div#help-panel`）
+        let label_parent = r#"<div id="help-panel" data-i18n-label="help.title"><strong data-i18n="help.title">快捷键</strong></div>"#;
+        assert!(
+            scan_i18n_nesting(label_parent).violations.is_empty(),
+            "阳性对照失败：data-i18n-label 祖先被误报"
+        );
+
+        // ④ 反向：后代带的是**属性型**钩子，同样会被文本祖先摘掉 ⇒ 必须报出
+        let nested_attr_kind =
+            r##"<p data-i18n="login.foot">x<a href="#" data-i18n-title="login.or">y</a></p>"##;
+        assert_eq!(
+            scan_i18n_nesting(nested_attr_kind).violations.len(),
+            1,
+            "阴性对照失败：被摘掉的属性型钩子未被检出"
+        );
+
+        // ⑤ 解析器不得被属性值里的 `>` / 引号骗到（否则会静默漏检后面的缺陷）
+        let tricky = r#"<p data-i18n="a.b" title="x > y" data-note='a "quoted" b'><span data-i18n="c.d">z</span></p>"#;
+        assert_eq!(
+            scan_i18n_nesting(tricky).violations.len(),
+            1,
+            "解析器被属性值里的尖括号/引号骗了"
+        );
+
+        // ⑥ 空元素与自闭合标签不得破坏标签栈
+        let voids = r#"<div data-i18n="a.b">t<br><img src="x"><input value="y"><span data-i18n="c.d">z</span></div>"#;
+        let s = scan_i18n_nesting(voids);
+        assert_eq!(s.violations.len(), 1, "空元素破坏了标签栈");
+        assert!(s.leftover.is_empty(), "空元素应不入栈：{:?}", s.leftover);
+
+        // ⑦ 注释里的标记不参与结构（#296 同族：证据文本必须先剥注释）
+        let commented = r#"<div data-i18n="a.b">t<!-- <span data-i18n="c.d">z</span> --></div>"#;
+        let s = scan_i18n_nesting(commented);
+        assert!(
+            s.violations.is_empty(),
+            "注释里的标记被当成了结构：{:?}",
+            s.violations
+        );
+
+        // ⑧ 违规行号必须是真的行号（不是恒 1）
+        let multiline =
+            "<div data-i18n=\"a.b\">\n  <p>x</p>\n  <span data-i18n=\"c.d\">z</span>\n</div>";
+        let s = scan_i18n_nesting(multiline);
+        assert_eq!(s.violations.len(), 1);
+        assert!(
+            s.violations[0].contains("index.html:3:"),
+            "违规行号应为 3，实得 {:?}",
+            s.violations[0]
+        );
+    }
+
     #[test]
     fn every_t_literal_resolves() {
         let LanguagePacks {
diff --git a/ui/README.md b/ui/README.md
index 845b250..4c58090 100644
--- a/ui/README.md
+++ b/ui/README.md
@@ -726,3 +726,48 @@ function txQuerySig() {                      // 只此一处定义「载荷是
 `A2`（持久化但不消费）拒掉；但 CI 里没有 JS 运行器，长期守住这条约定的是上面那条静态门禁
 （原地变异 6/6 如声明：未修树红、过度纠正红、半修红、只标记不解释红、只写一包红、修复树绿）。
 
+
+## 静态 `data-i18n` 属性归语言层所有，不属于它的子元素（C2150）
+
+`applyStatic()`（`ui/js/i18n.js`）对每个 `[data-i18n]` 元素执行 `innerHTML = t(key)`。
+因此**一个已经带文本 `data-i18n` 的元素，不能同时指望它子元素上的语言层钩子生效** ——
+祖先那一步会把后代元素连同它自己的 `data-i18n*` 属性一起从文档里摘掉；随后循环再对那个
+**已分离**的节点设值，无异常、无效果（jsdom 实测 `isConnected === false`）。
+
+改前的两张脸：
+
+| 位置 | 缺陷 |
+|------|------|
+| `index.html` 加额申请卡片 | `<h3 data-i18n="admin.raise.title">加额申请 <span data-i18n="admin.raise.sub">（…）</span></h3>` —— 两个包的值都是**纯文本**，子 `span` 被摘掉 ⇒ 提示「（成员申请 → 管理员批准 / 驳回）」**两种语言都不显示**，且 `app.js` 只写 `#raise-requests`、从不重画那个 `h3` ⇒ **永不恢复** |
+| `index.html` 登录页底 | `<p data-i18n="login.foot">…<a id="reg-link" data-i18n="login.register">注册</a>…</p>` —— 值**自带**同样的标记（含 `id="reg-link"`），复原后文本正确、点击是 document 委托在 `app.js` 里按 `t.id` 匹配 ⇒ **行为无损**；但那个属性是死的 ⇒ 键 `login.register` 沦为只喂死钩子的孤儿 |
+
+**约定**：
+
+1. 带文本 `data-i18n` 的元素**内部不得**再出现任何 `data-i18n*` 属性。要在一行里放两段文案，
+   写成**兄弟**元素（成例：`wallet.hint` + `wallet.tx` + `wallet.hint.suffix` 那个 `<p class="wallet-hint">`，
+   父元素不带 `data-i18n`）。
+2. **值自带宽标记**是另一种合法形态（`login.brand.headline` 的值含 `<span class="nb">`、
+   `ops.users.sub` 含 `<strong>`、`login.foot` 含两个 `<a>`）—— 之所以有效，是因为**值自己把它写了出来**。
+   只在该标记必须携带 `id` 等属性时才用它；否则用兄弟元素。
+3. **只有文本属性会砸后代**：`data-i18n-title` / `data-i18n-label` / `data-i18n-ph` 走 `setAttribute`，
+   各写一个属性，子标记原样保留。故 `select#tx-range`（带 `data-i18n-title`）里的五个
+   `<option data-i18n="tx.range.*">`、以及 `div#help-panel`（带 `data-i18n-label`）里的
+   `<strong data-i18n="help.title">` 都是**合法**形态。
+4. 两种既有门禁都看不见这类缺陷：`every_static_i18n_attribute_resolves` 只问「键在不在两个包里」，
+   而「按文本找引用」的死键扫描会看到键的**字面量就写在 `index.html` 里** ⇒ 判「有人用」。
+
+**CI 覆盖**（`src/i18n_pack.rs::no_data_i18n_attribute_nests_inside_a_data_i18n_element`）：
+对 `index.html` 做标签栈扫描，`data-i18n*` 属性落在带文本 `data-i18n` 的祖先内部即红；
+先剥 HTML 注释（注释里的标记不参与结构），空元素/自闭合不入栈，属性值里的 `>` 不截断标签
+（判别式由 `nested_i18n_detector_detects_injected_defects` 用合成输入钉住）。**零豁免清单**。
+扫描器另报三个阳性对照（起始标签数、文本载体数、EOF 未闭合栈），避免「0 违规」被误读成「扫描器瞎了」。
+
+⚠️ **射程只到「嵌套」这一条轴**：A/B 里那条竞争修法 `m_drop_parent`（把祖先的 `data-i18n` 整个删掉，
+例如让 `<h3>` 不带钩子）**确能让本门禁通过** —— 它真的消掉了嵌套。但它换来的是**另一条轴**上的缺陷：
+那位祖先的文案从此不再本地化，键 `admin.raise.title` 沦为**孤儿**（除语言包外零引用，实测孤儿集
+恰好 +1）。孤儿键今天无人守（全仓已有 60 余个不可达键）、**本次不入射程**，A/B 如实记录这条腿
+按声明为 GREEN，而不是伪装成被拒绝。
+
+⚠️ **本次未覆盖的边界**（已测量、非盲区）：`data-i18n*` 属性若落在**被 JS 整体替换内容的容器**里
+（`app.js` 对某 id 做 `innerHTML =`）同样是死的。今日实测为 **0 处**，故未建门禁 ——
+该判定的词法近似（按 id 找 `innerHTML =`）比本条脆弱，留待需要时再收。
diff --git a/ui/index.html b/ui/index.html
index 20f681d..5f288f5 100644
--- a/ui/index.html
+++ b/ui/index.html
@@ -76,7 +76,7 @@ <h2 id="auth-title" data-i18n="login.title">进入平台</h2>
     <div id="auth-login-extras">
       <div class="divider"><span data-i18n="login.or">或</span></div>
       <button type="button" class="btn btn-ghost btn-block" id="guest-browse-btn" data-i18n="login.guest">先逛逛市场</button>
-      <p class="login-foot" data-i18n="login.foot">还没有账号？<a href="#" id="reg-link" data-i18n="login.register">注册</a> · <a href="#" id="forgot-link">找回密码</a></p>
+      <p class="login-foot" data-i18n="login.foot">还没有账号？<a href="#" id="reg-link">注册</a> · <a href="#" id="forgot-link">找回密码</a></p>
       <p class="login-tip" data-i18n="login.tip">已对接后端 API · 登录后进入真实数据界面 · 管理员账号登录可见「管理视图」</p>
     </div>
     <!-- 注册表单（rant 2026-08-19T14:36:19：自助注册入口，默认隐藏） -->
@@ -614,7 +614,7 @@ <h3 data-i18n="admin.emp.list">成员列表</h3>
           </div>
         </div>
         <div class="card mt16">
-          <h3 data-i18n="admin.raise.title">加额申请 <span class="muted" style="font-weight:400;font-size:12px" data-i18n="admin.raise.sub">（成员申请 → 管理员批准 / 驳回）</span></h3>
+          <h3><span data-i18n="admin.raise.title">加额申请</span> <span class="muted" style="font-weight:400;font-size:12px" data-i18n="admin.raise.sub">（成员申请 → 管理员批准 / 驳回）</span></h3>
           <div id="raise-requests"></div>
         </div>
       </div>
@@ -854,7 +854,7 @@ <h3 id="chat-title">使用模型</h3>
 
 <script src="js/api.js?v=20260914-13"></script>
 <script src="js/data.js?v=20260914-11"></script>
-<script src="js/i18n.js?v=20260915-4"></script>
+<script src="js/i18n.js?v=20260915-5"></script>
 <script src="js/app.js?v=20260915-15"></script>
 </body>
 </html>
diff --git a/ui/js/i18n.js b/ui/js/i18n.js
index 2ca71db..4fcd94f 100644
--- a/ui/js/i18n.js
+++ b/ui/js/i18n.js
@@ -60,7 +60,6 @@
     "login.or": "或",
     "login.guest": "先逛逛市场",
     "login.foot": "还没有账号？<a href=\"#\" id=\"reg-link\">注册</a> · <a href=\"#\" id=\"forgot-link\">找回密码</a>",
-    "login.register": "注册",
     "login.forgot": "找回密码",
     "login.tip": "已对接后端 API · 登录后进入真实数据界面 · 管理员账号登录可见「管理视图」",
     "login.logging": "登录中…",
@@ -907,7 +906,6 @@
     "login.or": "or",
     "login.guest": "Browse market as guest",
     "login.foot": "No account? <a href=\"#\" id=\"reg-link\">Register</a> · <a href=\"#\" id=\"forgot-link\">Forgot password</a>",
-    "login.register": "Register",
     "login.forgot": "Forgot password",
     "login.tip": "Connected to backend API · real data after login · admin accounts see the Admin view",
     "login.logging": "Signing in…",