diff --git a/docs/index.html b/docs/index.html
index 319258a..1b53a9a 100644
--- a/docs/index.html
+++ b/docs/index.html
@@ -1,11 +1,11 @@
-<!-- built with theme=dracula, mode=report, at=2026-07-10T17:48:40Z -->
+<!-- built with theme=dracula, mode=report, at=2026-07-17T11:33:35Z -->
 <!DOCTYPE html>
 <html lang="zh-Hant">
 <head>
 <meta charset="UTF-8">
 <meta name="viewport" content="width=device-width, initial-scale=1">
 <title>聚珍（Juzhen）</title>
-<meta name="generated-at" content="2026-06-02">
+<meta name="generated-at" content="2026-07-17">
 <meta name="source" content="cjk-autospace · 使用文檔">
 <style>
 /* ---------- Core tokens ----------
@@ -311,30 +311,13 @@
 :where(:lang(zh), :lang(ja), :lang(ko))
 {
     text-spacing-trim:   trim-all;
-    text-autospace:      no-autospace;     /* native disabled; JS shim (runtime.js, Pangu.js rules) inserts <span class="cjk-autospace"> ( ) at boundaries; user-select: none on the span keeps the inserted space out of selection & clipboard */
+    text-autospace:      no-autospace;     /* native disabled; juzhen (runtime.js) injects <jz-hws> inter-script boundary gaps instead — sized in juzhen.css, copy-clean via margin */
     hanging-punctuation: first allow-end;
     line-break:          strict;
     overflow-wrap:       anywhere;
 }
 
-/* Helper span injected by runtime.js's autospace shim. The span
-   contains a real ASCII space so layout treats it as genuine
-   whitespace: collapses at line ends / starts, allows line break
-   opportunities, and participates in justify expansion. None of
-   which an inline-block with a fixed em width can do — that was
-   the original shape and it broke two-end justify when a digit
-   ran up against the line edge.
-
-   `user-select: none` makes the browser skip this element when
-   computing the selection range, so neither the visual selection
-   rectangle nor the clipboard payload includes the inserted space. */
-.cjk-autospace
-{
-    -webkit-user-select: none;
-    user-select:         none;
-}
-
-/* Pass C 配套：cjk-autospace lib 把長英文段包進 <span lang="en">，此處
+/* 聚珍 longWord 配套：聚珍把長英文段包進 <span lang="en">，此處
    讓瀏覽器原生 hyphens: auto 用 en 字典做斷詞 + 渲染連字符。連字符純
    視覺（DOM 不存在），複製返回原文無污染。
 
@@ -356,27 +339,35 @@
     -webkit-hyphenate-character: "-";
 }
 
-/* Default two-sided justified alignment for any multi-line prose / data
-   container in CJK lang. Auto-applies — no class required. Principle:
-   text that wraps to 2+ lines should justify regardless of tag (table
-   cells, list items, definition descriptions, captions, etc.).
-   `text-align-last: left` keeps the paragraph-final line and any
-   single-line content (which IS its own last line) naturally left-
-   aligned, so only true middle lines stretch.
+/* Two-sided justified alignment for CJK paragraphs — driven by juzhen's
+   block-level classification hook (ONE source of truth with kinsoku /
+   widow). The levelMark pass stamps `data-jz-block-level="paragraph"` on
+   every block that directly bears processable text and is classified a
+   paragraph (and `"text"` on non-paragraph blocks — headings, `<th>`, UI
+   chrome), removed on `revert()`. Justify keys off it, so a prose
+   container can NEVER drift out of alignment with jinze / orphan — the old
+   failure mode (`<div class="callout">` bound punctuation yet rendered
+   ragged-right because it wasn't in a hand-maintained tag whitelist) is
+   structurally impossible. Pure containers (`ul`, `table`, layout `div`s)
+   bear no direct text → unmarked → don't inherit-pollute. `.justify` /
+   `.justify *` stay as a manual force-on escape hatch.
 
-   `text-justify: auto` (NOT `inter-character`): the juzhen typesetter
-   wraps punctuation in inline-block `jz-char` justify atoms and holds
-   CJK↔Latin gaps as a FIXED `jz-hws` margin. `inter-character` forces
-   the UA to also distribute slack between every character — including
-   around those fixed margins and inside Latin words ("KaTeX" → "K a T e
-   X") — which compounds into wildly uneven spacing. `auto` lets the UA
-   justify CJK normally (inter-ideograph) and leaves the atoms to carry
-   the stretch, so Latin words stay intact and gaps stay even.
+   `text-align-last: left` keeps the paragraph-final / single line left.
+   `text-justify: auto` (NOT `inter-character`): juzhen's inline-block
+   `jz-char` atoms carry the justification stretch and CJK↔Latin gaps are
+   FIXED `jz-hws` margins; inter-character would also stretch inside Latin
+   words ("KaTeX" → "K a T e X") and around those fixed gaps — uneven.
 
-   Code / mono content (`<pre>`, `<code>`, `<kbd>`, `<samp>`) opts out
-   via the mono rule far above (text-align: revert added there).        */
+   Opt-outs win by coming later at ≥ specificity: `.no-justify`, the mono
+   rule (code / kbd / pre / diff / `.timeline .ts` / `.marginalia`), and
+   the `.text-*` utilities. Mono and `.marginalia` opt out even though
+   juzhen marks them paragraph — narrow columns justify badly.
+
+   NOTE: the hook applies after juzhen's render (levelMark pass), so CJK
+   prose is briefly left-aligned until init runs — imperceptible on the
+   normal path; academic runs juzhen before Paged.js paginates.          */
 :where(:lang(zh), :lang(ja), :lang(ko))
-    :is(p, li, blockquote, td, dd, summary, figcaption, caption, .justify, .justify *)
+    :is([data-jz-block-level="paragraph"], .justify, .justify *)
 {
     text-align:      justify;
     text-justify:    auto;
@@ -2530,7 +2521,7 @@ main > *:nth-child(n+6)            { animation-delay: 0.46s; }
     <div class="meta">
         <h1>聚珍（Juzhen）</h1>
         <p class="subtitle">現代簡／繁中文網頁排版套件——Han.css 之現代化重寫，複製乾淨、依 lang 全角／開明切換、justify 句末標點單份間距、跨瀏覽器一致。</p>
-        <p class="timestamp"><time>2026-06-02</time> · <span>cjk-autospace · 使用文檔</span></p>
+        <p class="timestamp"><time>2026-07-17</time> · <span>cjk-autospace · 使用文檔</span></p>
     </div>
     <div class="actions">
         <button class="btn" type="button" data-action="export-md"    title="Copy Markdown to clipboard">Copy MD</button>
@@ -2569,6 +2560,27 @@ import "cjk-autospace/css";
 createJuzhen({ lang: { default: "zh-Hant" } }).render(document.querySelector("main"));</code></pre>
 <div class="callout info"><span class="label">JS 與 CSS 缺一不可</span> JS 只注入 <code>jz-*</code> 結構，所有視覺尺寸（間隙寬度、擠壓量、<code>justify</code> 原子化、字體堆疊）都在 <code>juzhen.css</code>。缺 CSS 則全部失效。</div>
 
+<h3>動態頁面：增量恢復（局部變化免全樹重掃）</h3>
+<p><code>render(root)</code>／<code>revert(root)</code> <strong>皆可傳入局部 Element</strong>——頁面局部變化時只重處理受影響之子樹，成本 <code>O(該塊)</code> 而非 <code>O(全文)</code>（實測編輯 400 段中之一段，局部恢復較全樹重掃快數百倍）。實例內部持久化 <code>Finder</code>，跨 <code>render</code> 復用元素分類／功能級別／功能開關之快取，非每次重建。</p>
+<pre><code>const jz = createJuzhen();
+jz.render(document.body);        // 初次全樹
+
+// 局部變化後（手動）：
+jz.rerender(changedBlock);       // ＝ revert(changedBlock) + render(changedBlock)
+jz.render(newlyAppendedBlock);   // 新增之塊：直接 render（無須 revert）
+
+// 自動（opt-in）：觀察 DOM，內容／分類屬性變化時只重處理受影響之最近塊
+jz.observe(document.body);
+// jz.disconnect();              // 停止觀察</code></pre>
+<ul>
+<li><strong><code>rerender(root?)</code></strong>：<code>revert</code> 後 <code>render</code> 同一（子）樹之便利方法。</li>
+<li><strong><code>observe(root?)</code>／<code>disconnect()</code></strong>：以 <code>MutationObserver</code> 自動增量。聚珍自身之注入於處理期間暫停觀察、<strong>絕不自觸發</strong>；新增之塊直接 render（免全容器重掃）。需 <code>MutationObserver</code>（瀏覽器／jsdom 有，無則 no-op）。</li>
+<li><strong><code>invalidate(root?)</code></strong>：清該子樹之內部快取。<code>revert</code> 已自動失效其子樹，故僅在「改了既有元素之分類相關屬性（<code>class</code>／<code>data-jz-*</code>／<code>lang</code>）<strong>但不走 <code>revert</code></strong>」時才需顯式調用。純內容（子節點／文本）變化不改分類、無需 <code>invalidate</code>（但仍須 <code>revert</code>＋<code>render</code> 該塊方能重處理）。</li>
+</ul>
+<div class="callout info"><span class="label">元素變化之正確性</span> 快取隨實例持久、非每次 render 重建。<strong>改變既有元素之分類相關屬性（分類／級別／功能開關）後，須經 <code>revert</code>／<code>rerender</code>／<code>invalidate</code>／<code>observe</code> 任一使該子樹快取失效</strong>，否則沿用舊分類。新增／移除元素與純內容編輯無此顧慮（新元素重算、移除者自動回收）。</div>
+<div class="callout"><span class="label">增量之粒度為「塊」</span> 換塊內容（<code>textContent</code>／<code>innerHTML</code>）、增刪塊、改分類屬性——皆與全量重繪一致。<strong>不支持</strong>對聚珍已切分之文本節點做外科式 <code>characterData</code> 直改（如持有 render <strong>前</strong>之 <code>p.firstChild</code> 引用、事後直改其 <code>.data</code>）：render 後原文本節點已被 <code>jz-*</code> 切分／替換，該引用已非原整段。此為後處理排版器之固有限制（任何外科式文本 patch 之框架皆會與注入後之 DOM 失步）、<strong>非缺陷</strong>——聚珍對當前 DOM 之處理始終自洽。欲改文字，以塊為單位替換內容即可。</div>
+<div class="callout warn"><span class="label">revert 之範圍</span> <code>revert</code> 乾淨移除聚珍注入之全部結構（<code>jz-*</code>／<code>data-jz-*</code>），DOM 回到<strong>邏輯等價</strong>態；但<strong>不還原</strong> <code>spacing</code> 依契約規範化之贅餘作者空格（CJK↔西文吸收為間隙、CJK↔CJK 剝除）。差異穩定、不隨反覆 render／revert 累積。消費端若需保留原始作者空格以供編輯，應自存原文、<strong>勿以 <code>revert</code> 當「還原到未處理源碼」</strong>。</div>
+
 <h2>已實作功能</h2>
 <table>
 <thead><tr><th>功能</th><th>說明</th></tr></thead>
@@ -2610,6 +2622,22 @@ createJuzhen({ lang: { default: "zh-Hant" } }).render(document.querySelector("ma
 &lt;p data-juzhen-off="jiya"&gt;…&lt;/p&gt;          &lt;!-- 黑名單：停用 jiya，其餘繼承 --&gt;
 &lt;div lang="zh-Hans"&gt;…&lt;/div&gt;              &lt;!-- lang 驅動全角／開明 --&gt;</code></pre>
 
+<h2><code>data-jz-block-level</code>：resolved 分類之 CSS 鉤子（輸出屬性）</h2>
+<p><code>render</code> 時，聚珍把 <strong>resolved</strong> 功能級別寫回每個「直接承載可處理文本」之塊級元素，供消費端 CSS 查詢——與段落級功能（見上「功能分級」）之判定同源：</p>
+<pre><code>&lt;div class="callout" data-jz-block-level="paragraph"&gt;…&lt;/div&gt;  &lt;!-- 判為段落級 --&gt;
+&lt;h2 data-jz-block-level="text"&gt;…&lt;/h2&gt;                          &lt;!-- 判為文本級 --&gt;
+&lt;ul&gt;                                                           &lt;!-- 純容器：不標 --&gt;
+    &lt;li data-jz-block-level="paragraph"&gt;…&lt;/li&gt;
+&lt;/ul&gt;</code></pre>
+<p>消費端之<strong>段落級 CSS</strong>（首要：CJK 兩端對齊）從此與聚珍之段落級 pass（禁則／垂懸）共用<strong>單一真相源</strong>，免另行維護一份必然漂移之選擇器白名單：</p>
+<pre><code>[data-jz-block-level="paragraph"] { text-align: justify; }
+.marginalia[data-jz-block-level="paragraph"] { text-align: start; } /* 窄欄 opt-out */</code></pre>
+<ul>
+<li><strong>僅標直接承載文本之塊</strong>——純容器（<code>body</code>／<code>ul</code>／<code>table</code>…，直接文本僅空白）不標，否則 <code>body</code> 恆被判段落級、justify 鉤子經繼承污染全頁。此集合恰為段落級 pass 實際作用之塊集；avoid 子樹／pill 內部之文本不計，故未被處理之塊一致不標。</li>
+<li><strong>輸出專用、輸入輸出分離</strong>：作者輸入屬性 <code>data-jz-level</code> 只讀不寫；本屬性由聚珍寫入、<strong>絕不讀取</strong>（消費端手寫無效），<code>revert</code> 時全數移除。增量模式（<code>observe</code>）下分類屬性變化自動刷新。</li>
+<li>是否對齊仍由消費端 CSS 決定（justify 非段落之純函數——窄欄邊注可 opt-out）；聚珍只供分類、<strong>不介入樣式</strong>。</li>
+</ul>
+
 <h2>標點半形：<code>halt</code> 預設與 <code>margin</code> 後備</h2>
 <p>開明／半角式把標點收成「半形」，有兩種渲染機制：</p>
 <table>
@@ -2752,6 +2780,17 @@ createJuzhen({ lang: { default: "zh-Hant" } }).render(document.querySelector("ma
 
 JS 只注入 `jz-*` 結構，所有視覺尺寸在 juzhen.css，缺一不可。
 
+## 動態頁面：增量恢復（局部變化免全樹重掃）
+
+`render(root)`／`revert(root)` 皆可傳入局部 Element，成本 O(該塊) 而非 O(全文)（實測編輯 400 段中之一段快數百倍）。實例持久化 Finder，跨 render 復用元素分類／級別／開關快取、非每次重建。
+
+- `rerender(root?)`：revert 後 render 同一子樹之便利方法。
+- `observe(root?)`／`disconnect()`：以 MutationObserver 自動增量；聚珍注入期間暫停觀察、絕不自觸發；新增之塊直接 render。需 MutationObserver（瀏覽器／jsdom 有，無則 no-op）。
+- `invalidate(root?)`：清子樹快取；revert 已自動失效，僅「改既有元素之 class／data-jz-*／lang 等分類屬性但不走 revert」時需顯式調用。純內容變化不改分類。
+- 元素變化正確性：快取隨實例持久；改既有元素之分類相關屬性後須經 revert／rerender／invalidate／observe 任一失效該子樹，否則沿用舊分類。新增／移除與純內容編輯無此顧慮。
+- 增量之粒度為「塊」：換塊內容（textContent／innerHTML）、增刪塊、改分類屬性皆與全量一致；不支持對已切分文本節點之外科式 characterData 直改（render 後原節點已被 jz-* 替換，舊引用已脫離）——後處理排版器之固有限制、非缺陷。欲改文字以塊為單位替換內容即可。
+- revert 之範圍：乾淨移除 jz-*／data-jz-*，DOM 回邏輯等價態；但不還原 spacing 契約規範化之作者空格（CJK↔西文吸收、CJK↔CJK 剝除），差異穩定不累積。需原始源請自存、勿以 revert 當還原源碼。
+
 ## 已實作功能
 
 - spacing 中西間隙（margin 模型，copy-clean；含 pill／隔離元素邊界與作者空格正規化）【文本級】
@@ -2763,6 +2802,10 @@ JS 只注入 `jz-*` 結構，所有視覺尺寸在 juzhen.css，缺一不可。
 - level 功能分級（文本級 vs 段落級；data-jz-level="text"／level:{text:選擇器} 標記標題等僅跑文本級）
 - justify 句末標點單份間距（jz-char inline-block 原子）
 
+## data-jz-block-level：resolved 分類之 CSS 鉤子（輸出屬性）
+
+render 時把 resolved 功能級別寫回每個「直接承載可處理文本」之塊：`data-jz-block-level="paragraph|text"`。純容器（body／ul／table，直接文本僅空白）不標，否則 body 恆判段落級、justify 經繼承污染全頁；此集合恰為段落級 pass 作用之塊集，avoid 子樹／pill 內部之文本不計。消費端段落級 CSS 從此與禁則／垂懸共用單一真相源：`[data-jz-block-level="paragraph"]{ text-align: justify }`＋`.marginalia[data-jz-block-level="paragraph"]{ text-align: start }`（窄欄 opt-out）。輸出專用、輸入輸出分離：作者輸入 data-jz-level 只讀不寫，本屬性聚珍絕不讀取（手寫無效）、revert 全移除、observe 下自動刷新。是否對齊由消費端 CSS 決定，聚珍只供分類、不介入樣式。
+
 ## 標點半形：halt 預設與 margin 後備
 
 - halt（預設，`jiya: true`）：字型 OpenType halt 定位，需字型支援。
@@ -2846,6 +2889,27 @@ var Juzhen = (() => {
       this.includeSelector = opts.scope.include;
       this.featureCache = /* @__PURE__ */ new WeakMap();
       this.levelCache = /* @__PURE__ */ new WeakMap();
+      this.categoryCache = /* @__PURE__ */ new WeakMap();
+      this.pillAncestorCache = /* @__PURE__ */ new WeakMap();
+      this.avoidAncestorCache = /* @__PURE__ */ new WeakMap();
+    }
+    /**
+     * 清除 el 及其**整棵子樹**之元素鍵快取（C1 失效原語）。持久化 Finder（跨 render 復用快取）
+     * 下，元素之屬性或內容變化會令其分類（category）／級別（level）／功能（feature）／祖先游走
+     * （pill／avoid ancestor）快取失效。**須清整棵子樹、非僅該元素**：level／feature／祖先游走
+     * 之結果依賴祖先鏈，某祖先之 data-jz-level／data-juzhen／class 變化會令其**後代**之快取值變脏，
+     * 即便後代自身未動。querySelectorAll('*') 走子樹（O(子樹)，native、無遞迴棧風險）。移除之元素
+     * 由 WeakMap 自動回收，無需顯式清。 */
+    invalidate(el) {
+      this.forget(el);
+      el.querySelectorAll("*").forEach((c) => this.forget(c));
+    }
+    forget(e) {
+      this.categoryCache.delete(e);
+      this.pillAncestorCache.delete(e);
+      this.avoidAncestorCache.delete(e);
+      this.levelCache.delete(e);
+      this.featureCache.delete(e);
     }
     /** 該元素是否匹配 pill 選擇器（三分類之「整體」：code／kbd／行內公式等）。 */
     pillMatches(el) {
@@ -2860,41 +2924,100 @@ var Juzhen = (() => {
      *  一切 pass 不可見——不 charify、不收 run、不切分、不於其內插間隙（下游問題六：
      *  .katex 內部曾被 jiya／spacing 直接變更）。 */
     insidePill(node) {
-      let p = node.parentNode;
-      while (p && p.nodeType === 1) {
-        if (this.pillMatches(p)) {
-          return true;
-        }
-        p = p.parentNode;
-      }
-      return false;
+      const p = node.parentElement;
+      return p ? this.ancestorOrSelfPill(p) : false;
     }
-    /** 邏輯文本應**透明穿越**之行內元素：樣式行內標籤，以及聚珍自身之 wrap 類
-     *  jz-*（jz-hws 間隙、jz-jinze 禁則群組、jz-char／jz-inner 標點原子）。穿越這些
-     *  才能正確找到跨包裝之邏輯鄰字（如 jinze 已把 pill 納入 jz-jinze 後，pill 之左
-     *  鄰字仍須可達；I7）。
-     *  ⚠ 以**元素**而非標籤名判定：pill／isolate／avoid 縱使標籤名在樣式集亦為邊界、
-     *  不可穿越（下游問題六：KaTeX 全樹皆 SPAN，名字判定令整棵公式被當透明下潛而
-     *  肢解；scope.avoid／skipAttribute 命中自身者同理）。
-     *  ⚠ jz-char／jz-inner 必須透明：否則 adjacentLogicalChar 之 descend 遇標點原子既
-     *  不進入亦不終止、而是**跳過**它續找更前之兄弟（下游 Bug：`汉字。<code>` 經 jinze
-     *  綁定為 `汉<jz-jinze>字<jz-char>。</jz-char></jz-jinze><code>`，pill 之左鄰字應
-     *  為「。」、不補間隙；舊邏輯卻越過 jz-char 取到「字」→ 誤包 jz-hws 於「字。」之間）。
-     *  jz-char 僅含標點（jiya 只 charify biaodian），標點非 pillNeighbor，故透明後 descend
-     *  回傳標點 → 不補隙，與 collectRuns 之既有透明遞迴一致。jz-inner 亦須列入，否則
-     *  descend 進入 jz-char 後因 jz-inner 不透明而跳過其內標點。 */
-    transparentInline(el) {
-      if (this.pillMatches(el) || this.isolateMatches(el) || this.avoidsSelf(el)) {
-        return false;
+    /** el 或其祖先鏈任一為 pill（記憶化）。沿祖先鏈迭代（非遞迴，任意深度棧安全）至最近之
+     *  已快取／pill 命中／鏈頂，途中非 pill 元素入棧、以斷點之值一次回填——每元素恰算一次，
+     *  兄弟共用祖先鏈快取。insidePill 為 pillMatches 之最大來源（S3 延伸）。 */
+    ancestorOrSelfPill(el) {
+      const chain = [];
+      let cur = el;
+      let base = false;
+      while (cur) {
+        const c = this.pillAncestorCache.get(cur);
+        if (c !== void 0) {
+          base = c;
+          break;
+        }
+        if (this.pillMatches(cur)) {
+          this.pillAncestorCache.set(cur, true);
+          base = true;
+          break;
+        }
+        chain.push(cur);
+        cur = cur.parentElement;
       }
+      for (const e of chain) {
+        this.pillAncestorCache.set(e, base);
+      }
+      return base;
+    }
+    /**
+     * 行內元素分類（§4.1）——一元素對排版之口徑，**恰屬其一**。**優先序**（依序短路，即多
+     * 選擇器同命中時之定案規則）：`avoid ＞ pill ＞ isolate ＞ block ＞ transparent ＞ opaque`
+     * （opaque＝未在 styleInlines 之未知行內標籤，嚴格白名單下當隔離式邊界）。故：同時命中
+     * pill 與 isolate → **pill**（pill 覆蓋 isolate）；帶 data-jz-skip 之 pill／isolate → **avoid**
+     * （自身排除最高）。**邏輯文本流之遍歷原語**（collectRuns／jiyaAdjacency／adjacentLogicalChar
+     * 之 isTransparent）皆據此**單一分類**分派；core/split 之 canSplit ＝ SPLITTABLE 白名單 ∩
+     * transparent（結構切分為獨立層，故更窄）。
+     *
+     * **記憶化**（S3）：分類含至多三次 el.matches()（pill／isolate／avoid 選擇器），且被
+     * collectRuns／jiyaAdjacency／jinze／orphan／split 各 pass 逐元素重算——以 categoryCache
+     * 記憶化砍除跨 pass 重複。安全性：單次 render 內一元素之分類**恆定**（class／skip 屬性／
+     * nodeName 皆不因 render 變更；jz-* 包裹為新建元素、按 nodeName 分類亦恆定），且 Finder
+     * 隨 makeCtx 每次 render 重建 → 快取僅存活單次 render，無跨 render 失效問題（持久化屬 C1，
+     * 另議）。
+     */
+    category(el) {
+      const cached = this.categoryCache.get(el);
+      if (cached) {
+        return cached;
+      }
+      const result = this.computeCategory(el);
+      this.categoryCache.set(el, result);
+      return result;
+    }
+    computeCategory(el) {
+      if (this.avoidsSelf(el)) {
+        return "avoid";
+      }
+      if (this.pillMatches(el)) {
+        return "pill";
+      }
+      if (this.isolateMatches(el)) {
+        return "isolate";
+      }
+      if (this.blockSet.has(el.nodeName)) {
+        return "block";
+      }
+      if (this.isTransparentTag(el)) {
+        return "transparent";
+      }
+      return "opaque";
+    }
+    /** category 之透明判定末步：styleInlines 標籤，或聚珍自身之 wrap 類 jz-*（jz-hws 間隙、
+     *  jz-jinze 禁則群組、**jz-char／jz-inner 標點原子**）。前四步已排除 avoid/pill/isolate/block。
+     *  jz-char／jz-inner 必須列入：否則 adjacentLogicalChar 之 descend 遇標點原子既不進入亦不
+     *  終止、而**跳過**它續找更前之字（`汉字。<code>` 綁定後 pill 左鄰字應為「。」卻誤取「字」
+     *  補 jz-hws）；jz-char 僅含標點（非 pillNeighbor），透明後 descend 回傳標點、不補隙。 */
+    isTransparentTag(el) {
       const name = el.nodeName;
       return this.styleSet.has(name) || name === "JZ-HWS" || name === "JZ-JINZE" || name === "JZ-CHAR" || name === "JZ-INNER";
     }
-    /** 該元素**自身**是否為 avoid 邊界（內建 skip 名單 / SVG / contentEditable /
-     *  data-jz-skip / skipAttribute / avoid 選擇器 / isSkipped）。isAvoided 沿祖先
-     *  鏈逐層呼叫本判定；遍歷原語另須對「正要進入」之元素直接判自身——舊版僅查
-     *  祖先，元素自身命中 avoid 時被當透明穿越（下游問題六：scope.avoid 對 .katex
-     *  形同虛設）。 */
+    /** el 是否為邏輯文本流可透明穿越者（＝ category "transparent"）。 */
+    isTransparent(el) {
+      return this.category(el) === "transparent";
+    }
+    /** 該元素**自身**是否為 avoid 邊界。avoid 之七種來源，依序短路判定、任一命中即是：
+     *    ① isSkipped 謂詞（消費端函數）        ② skipTags 標籤名單（PRE／SAMP／SCRIPT…，可覆寫）
+     *    ③ SVG 命名空間                        ④ contentEditable
+     *    ⑤ data-jz-skip 屬性（內建）            ⑥ skipAttribute（消費端指定屬性名）
+     *    ⑦ scope.avoid 選擇器
+     *  **此為自身判定**，供遍歷原語（collectRuns／jiyaAdjacency／canSplit／isTransparent）於
+     *  下探時逐元素自判（祖先由遞迴涵蓋）。**一次性**問「某節點是否被 avoid（自身或祖先）」
+     *  請改用 isAvoided（單一組合入口），勿只用本方法而漏判祖先、或只用 isAvoided 而漏判自身
+     *  （下游問題六／階段一 #2：漏一半致 avoid 對自身形同虛設）。 */
     avoidsSelf(el) {
       if (this.userIsSkipped && this.userIsSkipped(el)) {
         return true;
@@ -2919,20 +3042,43 @@ var Juzhen = (() => {
       }
       return false;
     }
-    /** 節點是否處於 avoid 子樹（祖先鏈上任一元素 avoidsSelf；自身不計——元素
-     *  自身之邊界判定由遍歷原語以 avoidsSelf 執行）。 */
+    /** 某節點是否被 avoid——**自身即邊界**（元素經 avoidsSelf 之七源；非元素節點僅判
+     *  isSkipped）**或**祖先鏈上任一為 avoid 邊界。此為「是否 avoid」之**單一組合入口（安全
+     *  預設）**：一次性檢查用此，免除「avoidsSelf ‖ isAvoided」易漏一半之誤用。遍歷原語逐
+     *  元素下探時則用 avoidsSelf（僅自身，祖先由遞迴涵蓋）。 */
     isAvoided(node) {
+      if (node.nodeType === 1) {
+        return this.ancestorOrSelfAvoided(node);
+      }
       if (this.userIsSkipped && this.userIsSkipped(node)) {
         return true;
       }
-      let p = node.parentNode;
-      while (p && p.nodeType === 1) {
-        if (this.avoidsSelf(p)) {
-          return true;
+      const p = node.parentElement;
+      return p ? this.ancestorOrSelfAvoided(p) : false;
+    }
+    /** el 或其祖先鏈任一為 avoid 邊界（記憶化，迭代回填，同 ancestorOrSelfPill）。 */
+    ancestorOrSelfAvoided(el) {
+      const chain = [];
+      let cur = el;
+      let base = false;
+      while (cur) {
+        const c = this.avoidAncestorCache.get(cur);
+        if (c !== void 0) {
+          base = c;
+          break;
         }
-        p = p.parentNode;
+        if (this.avoidsSelf(cur)) {
+          this.avoidAncestorCache.set(cur, true);
+          base = true;
+          break;
+        }
+        chain.push(cur);
+        cur = cur.parentElement;
       }
-      return false;
+      for (const e of chain) {
+        this.avoidAncestorCache.set(e, base);
+      }
+      return base;
     }
     /** scope.include 啟用判定：未設則恆 true；設則須有命中祖先（opt-in）。 */
     inScope(node) {
@@ -2983,9 +3129,9 @@ var Juzhen = (() => {
       }
     }
     /**
-     * 收集 block 之邏輯文本 run（架構 §4.1，I7）：樣式行內元素與 wrap 類
-     * jz-* 透明穿越；block／pill／avoid／間隙 marker（jz-hws）中斷 run。
-     * 回傳 text.length >= 2 之 run（短於 2 無間隙可言）。
+     * 收集 block 之邏輯文本 run（架構 §4.1，I7）：透明行內（isTransparent：styleInlines
+     * ＋ wrap 類 jz-*）穿越、run 延續；block／pill／avoid 中斷 run；isolate 與**未知行內
+     * 標籤**（嚴格白名單）中斷 run 且內部自成獨立 run。回傳 text.length >= 2 之 run。
      */
     collectRuns(block) {
       const runs = [];
@@ -3018,28 +3164,30 @@ var Juzhen = (() => {
           return;
         }
         const el = node;
-        if (this.avoidsSelf(el) || this.blockSet.has(el.nodeName)) {
-          flush();
-          return;
-        }
-        if (this.pillMatches(el)) {
-          flush();
-          return;
-        }
-        if (this.isolateMatches(el)) {
-          flush();
-          let ic = el.firstChild;
-          while (ic) {
-            visit(ic);
-            ic = ic.nextSibling;
+        const recurse = () => {
+          let c2 = el.firstChild;
+          while (c2) {
+            visit(c2);
+            c2 = c2.nextSibling;
+          }
+        };
+        switch (this.category(el)) {
+          case "avoid":
+          case "block":
+          case "pill": {
+            flush();
+            return;
+          }
+          case "transparent": {
+            recurse();
+            return;
+          }
+          default: {
+            flush();
+            recurse();
+            flush();
+            return;
           }
-          flush();
-          return;
-        }
-        let c2 = el.firstChild;
-        while (c2) {
-          visit(c2);
-          c2 = c2.nextSibling;
         }
       };
       let c = block.firstChild;
@@ -3072,7 +3220,7 @@ var Juzhen = (() => {
             return pickEnd(n2);
           }
           if (n2.nodeType === 1) {
-            if (!this.transparentInline(n2)) {
+            if (!this.isTransparent(n2)) {
               return "blocked";
             }
             const r = descend(n2);
@@ -3097,7 +3245,7 @@ var Juzhen = (() => {
           }
           if (n.nodeType === 1) {
             const e = n;
-            if (!this.transparentInline(e)) {
+            if (!this.isTransparent(e)) {
               return null;
             }
             const r = descend(e);
@@ -3112,7 +3260,7 @@ var Juzhen = (() => {
           }
           n = direction === -1 ? n.previousSibling : n.nextSibling;
         }
-        if (!p || p.nodeType !== 1 || !this.transparentInline(p)) {
+        if (!p || p.nodeType !== 1 || !this.isTransparent(p)) {
           return null;
         }
         const pe = p;
@@ -3306,14 +3454,6 @@ var Juzhen = (() => {
         }
       }
     }
-    if (opts.attrs) {
-      for (const k in opts.attrs) {
-        const v = opts.attrs[k];
-        if (v !== void 0) {
-          el.setAttribute(k, v);
-        }
-      }
-    }
     if (opts.text !== void 0) {
       el.textContent = opts.text;
     }
@@ -3383,6 +3523,16 @@ var Juzhen = (() => {
     }
     return null;
   }
+  function isJz(node, pass) {
+    if (!node || node.nodeType !== 1) {
+      return false;
+    }
+    const el = node;
+    if (!el.hasAttribute(PASS_ATTR)) {
+      return false;
+    }
+    return pass === void 0 || el.getAttribute(PASS_ATTR) === pass;
+  }
 
   // src/core/locale.ts
   var DEFAULT_POLICY = {
@@ -3435,7 +3585,32 @@ var Juzhen = (() => {
     }
     return DEFAULT_POLICY[langClass];
   }
+  function isPunctStyle(v) {
+    return v === "quanjiao" || v === "kaiming" || v === "banjiao";
+  }
+  function resolveStyleOverride(node, stylePolicy) {
+    let el = node.nodeType === 1 ? node : node.parentElement;
+    while (el) {
+      const attr = el.getAttribute ? el.getAttribute("data-jz-style") : null;
+      if (isPunctStyle(attr)) {
+        return attr;
+      }
+      if (stylePolicy) {
+        for (const rule of stylePolicy) {
+          if (rule.selector && el.matches && el.matches(rule.selector)) {
+            return rule.style;
+          }
+        }
+      }
+      el = el.parentElement;
+    }
+    return null;
+  }
   function resolveStyle(node, config) {
+    const override = resolveStyleOverride(node, config.stylePolicy);
+    if (override) {
+      return override;
+    }
     const lang = effectiveLang(node, config.default);
     return styleFor(classify(lang), config);
   }
@@ -3444,7 +3619,6 @@ var Juzhen = (() => {
   var CJK = "\u2E80-\u2EFF\u2F00-\u2FDF\u3040-\u309F\u30A0-\u30FA\u30FC-\u30FF\u3100-\u312F\u3200-\u32FF\u3400-\u4DBF\u4E00-\u9FFF\uF900-\uFAFF";
   var ALNUM = "A-Za-z0-9";
   var ALPHA = "A-Za-z";
-  var ANY_CJK = new RegExp("[" + CJK + "]");
   var WEST_SHARED = "0-9\\$%\\^&\\*\\-\\+\\\\=\\u0370-\\u03ff\\u0100-\\u024f\\u0400-\\u04ff\\u00a1-\\u00b6\\u00b8-\\u00ff\\u20a0-\\u20bf\\u2150-\\u21ff\\u2200-\\u22ff\\u2700-\\u27bf";
   var ANS_AFTER_CJK = ALPHA + "@" + WEST_SHARED;
   var ANS_BEFORE_CJK = ALPHA + WEST_SHARED;
@@ -3454,7 +3628,6 @@ var Juzhen = (() => {
   var BD_CLOSE = "\u300D\u300F\uFF09\u300B\u3009\u3011\u3017\u3015\uFF3D\uFF5D\u201D\u2019";
   var BD_MIDDLE = "\xB7\u30FB\u2027";
   var BD_LIGA = "\u2026\u2014";
-  var BD_ALL = BD_STOP + BD_PAUSE + BD_OPEN + BD_CLOSE + BD_MIDDLE + BD_LIGA;
   var BD_ORDER = [
     "stop",
     "pause",
@@ -3655,8 +3828,7 @@ var Juzhen = (() => {
     level: "text",
     enabled: (o) => o.features.jiya,
     render(ctx) {
-      const { finder, options } = ctx;
-      const blockSet = options.finder.blockTags;
+      const { finder } = ctx;
       let prev = null;
       const squeeze = (L, R) => {
         if (!finder.featureEnabledFor(L, PASS)) {
@@ -3692,20 +3864,24 @@ var Juzhen = (() => {
               squeeze(prev, el);
             }
             prev = el;
-          } else if (finder.pillMatches(el)) {
-            prev = null;
-          } else if (finder.avoidsSelf(el)) {
-            prev = null;
-          } else if (finder.isolateMatches(el)) {
-            prev = null;
-            visit(el);
-            prev = null;
-          } else if (blockSet.has(nm)) {
-            prev = null;
-            visit(el);
-            prev = null;
           } else {
-            visit(el);
+            switch (finder.category(el)) {
+              case "avoid":
+              case "pill": {
+                prev = null;
+                break;
+              }
+              case "transparent": {
+                visit(el);
+                break;
+              }
+              default: {
+                prev = null;
+                visit(el);
+                prev = null;
+                break;
+              }
+            }
           }
         }
       };
@@ -3733,7 +3909,7 @@ var Juzhen = (() => {
     "SUP"
   ]);
   function canSplit(el, finder) {
-    return SPLITTABLE.has(el.nodeName) && !el.hasAttribute("id") && !finder.pillMatches(el) && !finder.isolateMatches(el) && !finder.avoidsSelf(el);
+    return SPLITTABLE.has(el.nodeName) && !el.hasAttribute("id") && finder.category(el) === "transparent";
   }
   function firstText(el, finder) {
     for (let c = el.firstChild; c; c = c.nextSibling) {
@@ -3794,6 +3970,14 @@ var Juzhen = (() => {
     return s;
   }
   function splitTreeAfter(top, textNode, offset, pass, finder) {
+    for (let a = textNode.parentNode; a && a.nodeType === 1; a = a.parentNode) {
+      if (!canSplit(a, finder)) {
+        return null;
+      }
+      if (a === top) {
+        break;
+      }
+    }
     if (offset <= 0 && firstText(top, finder) === textNode) {
       return null;
     }
@@ -3873,21 +4057,66 @@ var Juzhen = (() => {
   function isCharEl(n) {
     return !!n && n.nodeType === 1 && n.nodeName === "JZ-CHAR";
   }
+  function firstMeaningfulChild(el) {
+    for (let c = el.firstChild; c; c = c.nextSibling) {
+      if (c.nodeType === 3 && c.data.length === 0) {
+        continue;
+      }
+      return c;
+    }
+    return null;
+  }
+  function lastMeaningfulChild(el) {
+    for (let c = el.lastChild; c; c = c.previousSibling) {
+      if (c.nodeType === 3 && c.data.length === 0) {
+        continue;
+      }
+      return c;
+    }
+    return null;
+  }
+  function atEdge(node, el, side) {
+    return node === (side === "head" ? firstMeaningfulChild(el) : lastMeaningfulChild(el));
+  }
+  function edgeCharEl(node, side, finder) {
+    let n = node;
+    while (n && n.nodeType === 1) {
+      if (isCharEl(n)) {
+        return n;
+      }
+      if (!finder.isTransparent(n)) {
+        return null;
+      }
+      n = side === "head" ? firstMeaningfulChild(n) : lastMeaningfulChild(n);
+    }
+    return null;
+  }
   function forbiddenBreak(a, b, finder) {
-    if (isCharEl(b)) {
-      const c = bdClassOf(b);
-      if (c && AVOID_HEAD.has(c) && finder.featureEnabledFor(b, PASS2)) {
+    const head = edgeCharEl(b, "head", finder);
+    if (head) {
+      const c = bdClassOf(head);
+      if (c && AVOID_HEAD.has(c) && finder.featureEnabledFor(head, PASS2)) {
         return true;
       }
     }
-    if (isCharEl(a)) {
-      const c = bdClassOf(a);
-      if (c && AVOID_TAIL.has(c) && finder.featureEnabledFor(a, PASS2)) {
+    const tail = edgeCharEl(a, "tail", finder);
+    if (tail) {
+      const c = bdClassOf(tail);
+      if (c && AVOID_TAIL.has(c) && finder.featureEnabledFor(tail, PASS2)) {
         return true;
       }
     }
     return false;
   }
+  function depthOf(node) {
+    let d = 0;
+    let p = node.parentNode;
+    while (p) {
+      d += 1;
+      p = p.parentNode;
+    }
+    return d;
+  }
   function isTokenChar2(ch, anyCjk) {
     return !anyCjk.test(ch) && !/\s/.test(ch);
   }
@@ -3928,6 +4157,9 @@ var Juzhen = (() => {
     }
   }
   function processParent(parent, finder, anyCjk) {
+    if (isJz(parent, PASS2)) {
+      return;
+    }
     for (let c = parent.firstChild; c; c = c.nextSibling) {
       if (c.nodeType === 1 && c.nodeName === "JZ-JINZE") {
         return;
@@ -3996,18 +4228,31 @@ var Juzhen = (() => {
     level: "paragraph",
     enabled: (o) => o.features.jinze,
     render(ctx) {
+      const { finder } = ctx;
       const anyCjk = new RegExp("[" + ctx.options.ruleset.cjk + "]");
       const parents = /* @__PURE__ */ new Set();
       ctx.root.querySelectorAll("jz-char").forEach((c) => {
-        if (!ctx.finder.levelAllows(c, "paragraph")) {
+        if (!finder.levelAllows(c, "paragraph")) {
           return;
         }
-        if (c.parentNode) {
-          parents.add(c.parentNode);
+        let child = c;
+        let parent = c.parentNode;
+        while (parent && parent.nodeType === 1) {
+          parents.add(parent);
+          const pe = parent;
+          if (!finder.isTransparent(pe)) {
+            break;
+          }
+          if (!atEdge(child, pe, "head") && !atEdge(child, pe, "tail")) {
+            break;
+          }
+          child = pe;
+          parent = pe.parentNode;
         }
       });
-      for (const parent of parents) {
-        processParent(parent, ctx.finder, anyCjk);
+      const ordered = Array.from(parents).sort((a, b) => depthOf(b) - depthOf(a));
+      for (const parent of ordered) {
+        processParent(parent, finder, anyCjk);
       }
     },
     revert(ctx) {
@@ -4015,6 +4260,63 @@ var Juzhen = (() => {
     }
   };
 
+  // src/typeset/levelmark.ts
+  var ATTR = "data-jz-block-level";
+  var levelMarkPass = {
+    name: "levelMark",
+    kind: "standalone",
+    order: 10,
+    level: "text",
+    // 不受段落級閘限制：text 級之塊亦須標記（標記本身即分級輸出）
+    enabled: () => true,
+    // 分類鉤子非排版功能，恆開（純屬性輸出、零版面影響）
+    render(ctx) {
+      const { finder, options } = ctx;
+      const blockSet = options.finder.blockTags;
+      const nearest = /* @__PURE__ */ new Map();
+      const nearestBlock = (p) => {
+        const cached = nearest.get(p);
+        if (cached !== void 0) {
+          return cached;
+        }
+        let e = p;
+        let block = null;
+        while (e) {
+          if (blockSet.has(e.nodeName)) {
+            block = e;
+            break;
+          }
+          if (e === ctx.root) {
+            break;
+          }
+          e = e.parentElement;
+        }
+        nearest.set(p, block);
+        return block;
+      };
+      finder.eachTextNode(ctx.root, (t) => {
+        if (!/\S/.test(t.data)) {
+          return;
+        }
+        const p = t.parentElement;
+        const block = p ? nearestBlock(p) : null;
+        if (!block) {
+          return;
+        }
+        const level = finder.levelFor(block);
+        if (block.getAttribute(ATTR) !== level) {
+          block.setAttribute(ATTR, level);
+        }
+      });
+    },
+    revert(ctx) {
+      if (ctx.root.hasAttribute(ATTR)) {
+        ctx.root.removeAttribute(ATTR);
+      }
+      ctx.root.querySelectorAll("[" + ATTR + "]").forEach((el) => el.removeAttribute(ATTR));
+    }
+  };
+
   // src/typeset/lineedge.ts
   var LE = "jz-half-le";
   var ALL_EDGE = [LE];
@@ -4187,9 +4489,29 @@ var Juzhen = (() => {
     }
   };
   var TRIM = "jz-hws-trim";
+  function skippableAlign(g, cache) {
+    const key = g.parentElement;
+    if (!key) {
+      return false;
+    }
+    const cached = cache.get(key);
+    if (cached !== void 0) {
+      return cached;
+    }
+    let result = false;
+    const view = g.ownerDocument ? g.ownerDocument.defaultView : null;
+    if (view) {
+      const cs = view.getComputedStyle(g);
+      const ltr = cs.direction !== "rtl";
+      result = cs.textAlign === "left" || cs.textAlign === "start" && ltr;
+    }
+    cache.set(key, result);
+    return result;
+  }
   function trimGaps(root, finder, wrapSet) {
+    const alignCache = /* @__PURE__ */ new Map();
     const gaps = Array.from(root.querySelectorAll("jz-hws")).filter(
-      (g) => finder.inScope(g) && !finder.isAvoided(g) && finder.levelAllows(g, "paragraph")
+      (g) => finder.inScope(g) && !finder.isAvoided(g) && finder.levelAllows(g, "paragraph") && finder.featureEnabledFor(g, "spacing") && !skippableAlign(g, alignCache)
     );
     if (!gaps.length) {
       return;
@@ -4368,6 +4690,20 @@ var Juzhen = (() => {
       const anyCjk = new RegExp("[" + options.ruleset.cjk + "]");
       const biaodian = options.ruleset.biaodian;
       const chars = options.orphan.chars;
+      const sel = Array.from(blockSet).map((t) => t.toLowerCase()).join(",");
+      const nonLeaf = /* @__PURE__ */ new Set();
+      if (sel) {
+        ctx.root.querySelectorAll(sel).forEach((b) => {
+          let p = b.parentElement;
+          while (p) {
+            if (blockSet.has(p.nodeName)) {
+              nonLeaf.add(p);
+              break;
+            }
+            p = p.parentElement;
+          }
+        });
+      }
       finder.eachBlock(ctx.root, (block) => {
         if (!finder.levelAllows(block, "paragraph")) {
           return;
@@ -4375,11 +4711,10 @@ var Juzhen = (() => {
         if (!finder.featureEnabledFor(block, PASS4)) {
           return;
         }
-        if (finder.avoidsSelf(block) || finder.isAvoided(block)) {
+        if (finder.isAvoided(block)) {
           return;
         }
-        const sel = Array.from(blockSet).map((t) => t.toLowerCase()).join(",");
-        if (sel && block.querySelector(sel)) {
+        if (nonLeaf.has(block)) {
           return;
         }
         processBlock(block, finder, blockSet, anyCjk, biaodian, chars);
@@ -4708,8 +5043,6 @@ var Juzhen = (() => {
     "HR"
   ];
   var DEFAULT_SKIP_TAGS = [
-    "CODE",
-    "KBD",
     "PRE",
     "SAMP",
     "TT",
@@ -4727,7 +5060,8 @@ var Juzhen = (() => {
     jinzePass,
     orphanPass,
     lineEdgePass,
-    gapTrimPass
+    gapTrimPass,
+    levelMarkPass
   ];
   function feature(v, dflt) {
     return v === void 0 ? dflt : !!v;
@@ -4766,7 +5100,8 @@ var Juzhen = (() => {
       locale: {
         default: langOpt.default || "zh-Hant",
         ...langOpt.style ? { style: langOpt.style } : {},
-        policy: langOpt.policy || {}
+        policy: langOpt.policy || {},
+        stylePolicy: Array.isArray(langOpt.stylePolicy) ? langOpt.stylePolicy.slice() : []
       },
       ruleset: resolveRuleset(opts.charClass),
       justifyAtoms: opts.justifyAtoms === false ? false : true,
@@ -4778,10 +5113,11 @@ var Juzhen = (() => {
       },
       features: {
         spacing: feature(opts.spacing, true),
-        longWord: opts.longWord === false ? false : feature(opts.longWord, true),
+        // feature(v,dflt) 對 v===false 即回 false，故無需 ===false 特判（與 jiya／jinze 同構）。
+        longWord: feature(opts.longWord, true),
         jiya: feature(opts.jiya, true),
         jinze: feature(opts.jinze, true),
-        orphan: opts.orphan === false ? false : feature(opts.orphan, true),
+        orphan: feature(opts.orphan, true),
         biaodian: feature(opts.biaodian, false),
         emphasis: feature(opts.emphasis, false),
         ruby: feature(opts.ruby, false)
@@ -4816,10 +5152,135 @@ var Juzhen = (() => {
     }
     return typeof document !== "undefined" ? document.body : null;
   }
+  var OBSERVE_ATTRS = [
+    "class",
+    "lang",
+    "id",
+    "contenteditable",
+    "data-jz-skip",
+    "data-jz-level",
+    "data-jz-style",
+    "data-juzhen",
+    "data-juzhen-off"
+  ];
   function createJuzhen(opts = {}) {
     const options = normalizeOptions(opts);
+    const finder = new Finder(options);
     function makeCtx(root) {
-      return { root, options, finder: new Finder(options) };
+      return { root, options, finder };
+    }
+    function renderImpl(el) {
+      runPasses(PASSES, makeCtx(el));
+      if (options.features.jiya && options.jiyaConfig.halfWidth === "margin") {
+        el.setAttribute("data-jz-halfwidth", "margin");
+      }
+      if (!options.justifyAtoms) {
+        el.setAttribute("data-jz-atoms", "inline");
+      }
+    }
+    function revertImpl(el) {
+      revertPasses(PASSES, makeCtx(el));
+      el.removeAttribute("data-jz-halfwidth");
+      el.removeAttribute("data-jz-atoms");
+      finder.invalidate(el);
+    }
+    let observer = null;
+    let observeRoot = null;
+    const observeConfig = {
+      subtree: true,
+      childList: true,
+      characterData: true,
+      attributes: true,
+      attributeFilter: OBSERVE_ATTRS.slice()
+    };
+    function pauseObserver() {
+      if (observer) {
+        observer.disconnect();
+      }
+    }
+    function resumeObserver() {
+      if (observer && observeRoot) {
+        observer.takeRecords();
+        observer.observe(observeRoot, observeConfig);
+      }
+    }
+    function nearestBlock(node) {
+      let e = node.nodeType === 1 ? node : node.parentElement;
+      while (e) {
+        if (options.finder.blockTags.has(e.nodeName)) {
+          return e;
+        }
+        if (e === observeRoot) {
+          break;
+        }
+        e = e.parentElement;
+      }
+      return observeRoot;
+    }
+    function onMutations(records) {
+      const rerenderBlocks = /* @__PURE__ */ new Set();
+      const renderNew = [];
+      for (const m of records) {
+        if (m.type === "childList") {
+          m.addedNodes.forEach((n) => {
+            if (n.nodeType === 1 && options.finder.blockTags.has(n.nodeName)) {
+              const np = n;
+              const P = np.parentElement;
+              const pIsBlock = !!P && options.finder.blockTags.has(P.nodeName);
+              const pHadLeafOrphan = !!P && Array.prototype.some.call(
+                P.children,
+                (c) => c.nodeName === "JZ-ORPHAN"
+              );
+              if (pIsBlock && pHadLeafOrphan) {
+                rerenderBlocks.add(P);
+              } else if (!pIsBlock && P) {
+                const b = nearestBlock(P);
+                if (b) {
+                  rerenderBlocks.add(b);
+                }
+              } else {
+                renderNew.push(np);
+              }
+            } else if (n.nodeType === 1 || n.nodeType === 3) {
+              const b = nearestBlock(m.target);
+              if (b) {
+                rerenderBlocks.add(b);
+              }
+            }
+          });
+          if (m.removedNodes.length) {
+            const b = nearestBlock(m.target);
+            if (b) {
+              rerenderBlocks.add(b);
+            }
+          }
+        } else {
+          const b = nearestBlock(m.target);
+          if (b) {
+            rerenderBlocks.add(b);
+          }
+        }
+      }
+      if (!rerenderBlocks.size && !renderNew.length) {
+        return;
+      }
+      pauseObserver();
+      const all = Array.from(rerenderBlocks).filter((b) => b.isConnected);
+      const blocks = all.filter((b) => !all.some((o) => o !== b && o.contains(b)));
+      for (const b of blocks) {
+        revertImpl(b);
+        renderImpl(b);
+      }
+      for (const el of renderNew) {
+        if (!el.isConnected) {
+          continue;
+        }
+        if (blocks.some((b) => b.contains(el))) {
+          continue;
+        }
+        renderImpl(el);
+      }
+      resumeObserver();
     }
     return {
       options,
@@ -4828,22 +5289,56 @@ var Juzhen = (() => {
         if (!el) {
           return;
         }
-        runPasses(PASSES, makeCtx(el));
-        if (options.features.jiya && options.jiyaConfig.halfWidth === "margin") {
-          el.setAttribute("data-jz-halfwidth", "margin");
-        }
-        if (!options.justifyAtoms) {
-          el.setAttribute("data-jz-atoms", "inline");
-        }
+        pauseObserver();
+        renderImpl(el);
+        resumeObserver();
       },
       revert(root) {
         const el = resolveRoot(root, options);
         if (!el) {
           return;
         }
-        revertPasses(PASSES, makeCtx(el));
-        el.removeAttribute("data-jz-halfwidth");
-        el.removeAttribute("data-jz-atoms");
+        pauseObserver();
+        revertImpl(el);
+        resumeObserver();
+      },
+      rerender(root) {
+        const el = resolveRoot(root, options);
+        if (!el) {
+          return;
+        }
+        pauseObserver();
+        revertImpl(el);
+        renderImpl(el);
+        resumeObserver();
+      },
+      invalidate(root) {
+        const el = resolveRoot(root, options);
+        if (el) {
+          finder.invalidate(el);
+        }
+      },
+      observe(root) {
+        if (typeof MutationObserver === "undefined") {
+          return;
+        }
+        const el = resolveRoot(root, options);
+        if (!el) {
+          return;
+        }
+        if (observer) {
+          observer.disconnect();
+        }
+        observeRoot = el;
+        observer = new MutationObserver(onMutations);
+        observer.observe(el, observeConfig);
+      },
+      disconnect() {
+        if (observer) {
+          observer.disconnect();
+          observer = null;
+          observeRoot = null;
+        }
       }
     };
   }
@@ -5087,6 +5582,24 @@ window.__JUZHEN_PUNCT__="quanjiao";window.__JUZHEN_JUSTIFY_ATOMS__=true;window._
             if (hw === "margin") { halfWidth = "margin"; }
         }
         catch (e) { /* getComputedStyle 不可用時退預設 halt */ }
+        /* 段落標點樣式（模式注入）：一般模式 quanjiao 全角式、academic kaiming 開明式。
+           非段落一律 kaiming（見下方 lang.stylePolicy）——與段落形成寬窄對比，標題／表頭／
+           UI chrome 之標點較正文緊。 */
+        var paraStyle = (typeof window.__JUZHEN_PUNCT__ === "string" ? window.__JUZHEN_PUNCT__ : "quanjiao");
+        /* 「非段落」結構選擇器——**單一來源**，同時餵給 level.text（決定跑哪些 pass）與
+           lang.stylePolicy（決定標點寬度），杜絕兩處漂移。**只列非段落 chrome 本身，切勿
+           納入包裹正文的容器**（.deck-stage／.deck／.cols-2……），否則「最近祖先勝」會把整
+           棵子樹正文一併降級（曾誤納 .deck-stage 致 slides 全 deck 正文無禁則、標點落行首）。 */
+        var nonParaText = [
+            "h1, h2, h3, h4, h5, h6",                 // 全部標題（含 deck-／section-／slide-／tp-／toc-title）
+            "button, [role=button], .btn",            // 控制項
+            ".subtitle, .section-subtitle, .deck-subtitle",   // 副標題
+            ".meta, .timestamp, .actions, .page",     // report chrome
+            ".cover-block, .slide-foot, .toc-list",   // slides 封面／頁尾／目錄條目
+            ".deck-nav, .deck-counter, .deck-author, .deck-institute, .deck-date, .deck-actions",
+            ".title-page, .toc-page, .simple-title",  // academic 前置 chrome（含 tp-／st- 欄位）
+            "th",                                     // 表頭：恒為標籤，非段落
+        ].join(", ");
         window.Juzhen.createJuzhen({
             /* mark 不列 pill——隔離（isolateSelector 預設 "mark"）即其正確語義：
                兩端補隙、內部標點／中西邊界照常處理；列 pill 反令內部不可見。
@@ -5105,19 +5618,13 @@ window.__JUZHEN_PUNCT__="quanjiao";window.__JUZHEN_JUSTIFY_ATOMS__=true;window._
                .lede／.marginalia／.references／.appendix……）不命中、維持全功能。最近祖先勝，
                故標題與 chrome 容器一旦命中，其後代（如 .slide-title 內的 .section-name／
                .slide-dot、.title-page 內的作者欄）一併降級。選擇器涵蓋三模式；某模式不存在之
-               class 自然不命中。**切記只列「非段落 chrome 本身」，切勿納入包裹正文的容器**
-               （如 .deck-stage／.deck／.cols-2）——否則「最近祖先勝」會把整個子樹正文一併降級、
-               喪失禁則／垂懸／長詞（曾誤納 .deck-stage 致 slides 全 deck 正文無禁則、標點落行首）。 */
+               class 自然不命中。**段落／非段落單軸**：作者以 `data-jz-level="text"｜"paragraph"`
+               逐元素覆寫，同時改「跑哪些 pass」（此處 level 原生讀取，屬性優先、最近祖先勝）與
+               「標點寬度」（下方 stylePolicy 以同一屬性鏡像）。歧義元素（td／li／figcaption／dd／
+               blockquote）預設段落作安全兜底（漏標時真段落不致喪失禁則／垂懸），作者應積極標記
+               非段落者為 text——多數 td／caption 實為非段落。 */
             level: {
-                text: [
-                    "h1, h2, h3, h4, h5, h6",                 // 全部標題（含 deck-／section-／slide-／tp-／toc-title）
-                    "button, [role=button], .btn",            // 控制項
-                    ".subtitle, .section-subtitle, .deck-subtitle",   // 副標題
-                    ".meta, .timestamp, .actions, .page",     // report chrome
-                    ".cover-block, .slide-foot, .toc-list",   // slides 封面／頁尾／目錄條目
-                    ".deck-nav, .deck-counter, .deck-author, .deck-institute, .deck-date, .deck-actions",
-                    ".title-page, .toc-page, .simple-title",  // academic 前置 chrome（含 tp-／st- 欄位）
-                ].join(", "),
+                text: nonParaText,
             },
             /* orphan（垂懸字避免，聚珍 §6.5.1）：段末行 CJK 實義字 < 2 時，把末 2 字
                包入 `<jz-orphan white-space:nowrap>` 拉下首字，杜絕「孤字成行」。判定僅計
@@ -5133,9 +5640,27 @@ window.__JUZHEN_PUNCT__="quanjiao";window.__JUZHEN_JUSTIFY_ATOMS__=true;window._
                但改於分頁「之後」排版（DEFER），故不踩 Paged.js chunker 對 inline-block
                的錯誤量測。 */
             justifyAtoms:  (window.__JUZHEN_JUSTIFY_ATOMS__ !== false),
+            /* lang.stylePolicy（逐元素標點樣式，聚珍 §4.3）：把段落／非段落單軸鏡像到標點
+               寬度。解析＝自身向上找最近命中（近祖先勝、同層 data-jz-style 屬性優先、同層多
+               選擇器取陣列首條，見 lib locale.ts resolveStyleOverride）。**次序關鍵——顯式屬性
+               標記須先於結構標籤選擇器**，否則 `p[data-jz-level="text"]` 會被 ③ 的 p 規則搶先
+               判為段落。故四條依序：
+                 ① 顯式 text → kaiming（最高，壓過下方 p 規則）；
+                 ② 顯式 paragraph → paraStyle（最高）；
+                 ③ 結構段落 p → paraStyle（即便嵌於非段落容器內也還原）；
+                 ④ 結構非段落 nonParaText → kaiming。
+               非段落一律 kaiming：academic 段落本即 kaiming（此處無視覺差、僅 level 有別），
+               一般模式段落 quanjiao、非段落 kaiming 形成寬窄對比。`data-jz-style` 屬性可作
+               一次性最高優先例外。 */
             lang: {
                 default: "zh-Hans",
-                style:   (typeof window.__JUZHEN_PUNCT__ === "string" ? window.__JUZHEN_PUNCT__ : "quanjiao"),
+                style:   paraStyle,
+                stylePolicy: [
+                    { selector: "[data-jz-level='text']",      style: "kaiming"  },
+                    { selector: "[data-jz-level='paragraph']", style: paraStyle  },
+                    { selector: "p",                           style: paraStyle  },
+                    { selector: nonParaText,                   style: "kaiming"  },
+                ],
             },
         }).render(root);
     }
diff --git a/docs/index.src.html b/docs/index.src.html
index c8a38be..946f39a 100644
--- a/docs/index.src.html
+++ b/docs/index.src.html
@@ -4,7 +4,7 @@
 <meta charset="UTF-8">
 <meta name="viewport" content="width=device-width, initial-scale=1">
 <title>聚珍（Juzhen）</title>
-<meta name="generated-at" content="2026-06-02">
+<meta name="generated-at" content="2026-07-17">
 <meta name="source" content="cjk-autospace · 使用文檔">
 <!-- RUNTIME_CSS -->
 </head>
@@ -14,7 +14,7 @@
     <div class="meta">
         <h1>聚珍（Juzhen）</h1>
         <p class="subtitle">現代簡／繁中文網頁排版套件——Han.css 之現代化重寫，複製乾淨、依 lang 全角／開明切換、justify 句末標點單份間距、跨瀏覽器一致。</p>
-        <p class="timestamp"><time>2026-06-02</time> · <span>cjk-autospace · 使用文檔</span></p>
+        <p class="timestamp"><time>2026-07-17</time> · <span>cjk-autospace · 使用文檔</span></p>
     </div>
     <div class="actions">
 <!-- ACTIONS -->
@@ -49,6 +49,27 @@ import "cjk-autospace/css";
 createJuzhen({ lang: { default: "zh-Hant" } }).render(document.querySelector("main"));</code></pre>
 <div class="callout info"><span class="label">JS 與 CSS 缺一不可</span> JS 只注入 <code>jz-*</code> 結構，所有視覺尺寸（間隙寬度、擠壓量、<code>justify</code> 原子化、字體堆疊）都在 <code>juzhen.css</code>。缺 CSS 則全部失效。</div>
 
+<h3>動態頁面：增量恢復（局部變化免全樹重掃）</h3>
+<p><code>render(root)</code>／<code>revert(root)</code> <strong>皆可傳入局部 Element</strong>——頁面局部變化時只重處理受影響之子樹，成本 <code>O(該塊)</code> 而非 <code>O(全文)</code>（實測編輯 400 段中之一段，局部恢復較全樹重掃快數百倍）。實例內部持久化 <code>Finder</code>，跨 <code>render</code> 復用元素分類／功能級別／功能開關之快取，非每次重建。</p>
+<pre><code>const jz = createJuzhen();
+jz.render(document.body);        // 初次全樹
+
+// 局部變化後（手動）：
+jz.rerender(changedBlock);       // ＝ revert(changedBlock) + render(changedBlock)
+jz.render(newlyAppendedBlock);   // 新增之塊：直接 render（無須 revert）
+
+// 自動（opt-in）：觀察 DOM，內容／分類屬性變化時只重處理受影響之最近塊
+jz.observe(document.body);
+// jz.disconnect();              // 停止觀察</code></pre>
+<ul>
+<li><strong><code>rerender(root?)</code></strong>：<code>revert</code> 後 <code>render</code> 同一（子）樹之便利方法。</li>
+<li><strong><code>observe(root?)</code>／<code>disconnect()</code></strong>：以 <code>MutationObserver</code> 自動增量。聚珍自身之注入於處理期間暫停觀察、<strong>絕不自觸發</strong>；新增之塊直接 render（免全容器重掃）。需 <code>MutationObserver</code>（瀏覽器／jsdom 有，無則 no-op）。</li>
+<li><strong><code>invalidate(root?)</code></strong>：清該子樹之內部快取。<code>revert</code> 已自動失效其子樹，故僅在「改了既有元素之分類相關屬性（<code>class</code>／<code>data-jz-*</code>／<code>lang</code>）<strong>但不走 <code>revert</code></strong>」時才需顯式調用。純內容（子節點／文本）變化不改分類、無需 <code>invalidate</code>（但仍須 <code>revert</code>＋<code>render</code> 該塊方能重處理）。</li>
+</ul>
+<div class="callout info"><span class="label">元素變化之正確性</span> 快取隨實例持久、非每次 render 重建。<strong>改變既有元素之分類相關屬性（分類／級別／功能開關）後，須經 <code>revert</code>／<code>rerender</code>／<code>invalidate</code>／<code>observe</code> 任一使該子樹快取失效</strong>，否則沿用舊分類。新增／移除元素與純內容編輯無此顧慮（新元素重算、移除者自動回收）。</div>
+<div class="callout"><span class="label">增量之粒度為「塊」</span> 換塊內容（<code>textContent</code>／<code>innerHTML</code>）、增刪塊、改分類屬性——皆與全量重繪一致。<strong>不支持</strong>對聚珍已切分之文本節點做外科式 <code>characterData</code> 直改（如持有 render <strong>前</strong>之 <code>p.firstChild</code> 引用、事後直改其 <code>.data</code>）：render 後原文本節點已被 <code>jz-*</code> 切分／替換，該引用已非原整段。此為後處理排版器之固有限制（任何外科式文本 patch 之框架皆會與注入後之 DOM 失步）、<strong>非缺陷</strong>——聚珍對當前 DOM 之處理始終自洽。欲改文字，以塊為單位替換內容即可。</div>
+<div class="callout warn"><span class="label">revert 之範圍</span> <code>revert</code> 乾淨移除聚珍注入之全部結構（<code>jz-*</code>／<code>data-jz-*</code>），DOM 回到<strong>邏輯等價</strong>態；但<strong>不還原</strong> <code>spacing</code> 依契約規範化之贅餘作者空格（CJK↔西文吸收為間隙、CJK↔CJK 剝除）。差異穩定、不隨反覆 render／revert 累積。消費端若需保留原始作者空格以供編輯，應自存原文、<strong>勿以 <code>revert</code> 當「還原到未處理源碼」</strong>。</div>
+
 <h2>已實作功能</h2>
 <table>
 <thead><tr><th>功能</th><th>說明</th></tr></thead>
@@ -90,6 +111,22 @@ createJuzhen({ lang: { default: "zh-Hant" } }).render(document.querySelector("ma
 &lt;p data-juzhen-off="jiya"&gt;…&lt;/p&gt;          &lt;!-- 黑名單：停用 jiya，其餘繼承 --&gt;
 &lt;div lang="zh-Hans"&gt;…&lt;/div&gt;              &lt;!-- lang 驅動全角／開明 --&gt;</code></pre>
 
+<h2><code>data-jz-block-level</code>：resolved 分類之 CSS 鉤子（輸出屬性）</h2>
+<p><code>render</code> 時，聚珍把 <strong>resolved</strong> 功能級別寫回每個「直接承載可處理文本」之塊級元素，供消費端 CSS 查詢——與段落級功能（見上「功能分級」）之判定同源：</p>
+<pre><code>&lt;div class="callout" data-jz-block-level="paragraph"&gt;…&lt;/div&gt;  &lt;!-- 判為段落級 --&gt;
+&lt;h2 data-jz-block-level="text"&gt;…&lt;/h2&gt;                          &lt;!-- 判為文本級 --&gt;
+&lt;ul&gt;                                                           &lt;!-- 純容器：不標 --&gt;
+    &lt;li data-jz-block-level="paragraph"&gt;…&lt;/li&gt;
+&lt;/ul&gt;</code></pre>
+<p>消費端之<strong>段落級 CSS</strong>（首要：CJK 兩端對齊）從此與聚珍之段落級 pass（禁則／垂懸）共用<strong>單一真相源</strong>，免另行維護一份必然漂移之選擇器白名單：</p>
+<pre><code>[data-jz-block-level="paragraph"] { text-align: justify; }
+.marginalia[data-jz-block-level="paragraph"] { text-align: start; } /* 窄欄 opt-out */</code></pre>
+<ul>
+<li><strong>僅標直接承載文本之塊</strong>——純容器（<code>body</code>／<code>ul</code>／<code>table</code>…，直接文本僅空白）不標，否則 <code>body</code> 恆被判段落級、justify 鉤子經繼承污染全頁。此集合恰為段落級 pass 實際作用之塊集；avoid 子樹／pill 內部之文本不計，故未被處理之塊一致不標。</li>
+<li><strong>輸出專用、輸入輸出分離</strong>：作者輸入屬性 <code>data-jz-level</code> 只讀不寫；本屬性由聚珍寫入、<strong>絕不讀取</strong>（消費端手寫無效），<code>revert</code> 時全數移除。增量模式（<code>observe</code>）下分類屬性變化自動刷新。</li>
+<li>是否對齊仍由消費端 CSS 決定（justify 非段落之純函數——窄欄邊注可 opt-out）；聚珍只供分類、<strong>不介入樣式</strong>。</li>
+</ul>
+
 <h2>標點半形：<code>halt</code> 預設與 <code>margin</code> 後備</h2>
 <p>開明／半角式把標點收成「半形」，有兩種渲染機制：</p>
 <table>
@@ -216,6 +253,17 @@ createJuzhen({ lang: { default: "zh-Hant" } }).render(document.querySelector("ma
 
 JS 只注入 `jz-*` 結構，所有視覺尺寸在 juzhen.css，缺一不可。
 
+## 動態頁面：增量恢復（局部變化免全樹重掃）
+
+`render(root)`／`revert(root)` 皆可傳入局部 Element，成本 O(該塊) 而非 O(全文)（實測編輯 400 段中之一段快數百倍）。實例持久化 Finder，跨 render 復用元素分類／級別／開關快取、非每次重建。
+
+- `rerender(root?)`：revert 後 render 同一子樹之便利方法。
+- `observe(root?)`／`disconnect()`：以 MutationObserver 自動增量；聚珍注入期間暫停觀察、絕不自觸發；新增之塊直接 render。需 MutationObserver（瀏覽器／jsdom 有，無則 no-op）。
+- `invalidate(root?)`：清子樹快取；revert 已自動失效，僅「改既有元素之 class／data-jz-*／lang 等分類屬性但不走 revert」時需顯式調用。純內容變化不改分類。
+- 元素變化正確性：快取隨實例持久；改既有元素之分類相關屬性後須經 revert／rerender／invalidate／observe 任一失效該子樹，否則沿用舊分類。新增／移除與純內容編輯無此顧慮。
+- 增量之粒度為「塊」：換塊內容（textContent／innerHTML）、增刪塊、改分類屬性皆與全量一致；不支持對已切分文本節點之外科式 characterData 直改（render 後原節點已被 jz-* 替換，舊引用已脫離）——後處理排版器之固有限制、非缺陷。欲改文字以塊為單位替換內容即可。
+- revert 之範圍：乾淨移除 jz-*／data-jz-*，DOM 回邏輯等價態；但不還原 spacing 契約規範化之作者空格（CJK↔西文吸收、CJK↔CJK 剝除），差異穩定不累積。需原始源請自存、勿以 revert 當還原源碼。
+
 ## 已實作功能
 
 - spacing 中西間隙（margin 模型，copy-clean；含 pill／隔離元素邊界與作者空格正規化）【文本級】
@@ -227,6 +275,10 @@ JS 只注入 `jz-*` 結構，所有視覺尺寸在 juzhen.css，缺一不可。
 - level 功能分級（文本級 vs 段落級；data-jz-level="text"／level:{text:選擇器} 標記標題等僅跑文本級）
 - justify 句末標點單份間距（jz-char inline-block 原子）
 
+## data-jz-block-level：resolved 分類之 CSS 鉤子（輸出屬性）
+
+render 時把 resolved 功能級別寫回每個「直接承載可處理文本」之塊：`data-jz-block-level="paragraph|text"`。純容器（body／ul／table，直接文本僅空白）不標，否則 body 恆判段落級、justify 經繼承污染全頁；此集合恰為段落級 pass 作用之塊集，avoid 子樹／pill 內部之文本不計。消費端段落級 CSS 從此與禁則／垂懸共用單一真相源：`[data-jz-block-level="paragraph"]{ text-align: justify }`＋`.marginalia[data-jz-block-level="paragraph"]{ text-align: start }`（窄欄 opt-out）。輸出專用、輸入輸出分離：作者輸入 data-jz-level 只讀不寫，本屬性聚珍絕不讀取（手寫無效）、revert 全移除、observe 下自動刷新。是否對齊由消費端 CSS 決定，聚珍只供分類、不介入樣式。
+
 ## 標點半形：halt 預設與 margin 後備
 
 - halt（預設，`jiya: true`）：字型 OpenType halt 定位，需字型支援。
