fix:1.3.4 (a)

- **重构：统一闭合归属判定**
  - 新增统一的归属仲裁函数，集中处理 shorthand / full-form 的闭合竞争。
  - shorthand 的 push、close、fallback 恢复路径改为复用同一套规则。
- **修复：full-form close 与 shorthand continuation 竞争时，优先 full-form**
  - 当 `tagClose` 与父级 `endTag` 在同一游标重叠时，优先保留父级 full-form 闭合归属。
  - 避免 shorthand 抢占父级闭合，覆盖 `=bold<bold<=bold<>=>=` 及等价自定义分隔符场景。
- **修复：endTag 延迟确认显式化，且对截断安全**
  - endTag 探测结果细分为 `full` / `truncated-prefix` / `none`。
  - 仅 `full` 视为可消费闭合；命中截断前缀时立即解除延迟并恢复常规扫描。
- **模型一致性**
  - 移除分支内各自猜测式判优，收敛为单一、确定的归属规则。
- 无公共 API 变化

Author: chiba233

CHANGELOG.md

@@ -4,17 +4,17 @@
 
 ### 1.3.4
 
-- **Fix: resolve shorthand/full-form close conflicts by preserving full-form close ownership**
-  - In inline-arg context, when shorthand close (`tagClose`) overlaps a parent full-form close (`endTag`), the parser now prioritizes full-form close ownership.
-  - This fixes conflict cases such as `=bold<bold<=bold<>=>=` and nested custom-syntax variants without introducing broad fallback heuristics.
-- **Parser model refinement: local overlap decision instead of long-range rescue scanning**
-  - Removed forward-looking rescue behavior that depended on scanning ahead for another `endTag`.
-  - Conflict handling is now decided at the current cursor position with stack-top frame semantics, keeping behavior deterministic and consistent with stepwise parsing.
-- **Fix: delayed endTag confirmation with truncation-safe matching**
-  - Added explicit end-tag match states (`full` / `truncated-prefix` / `none`) for overlap points.
-  - If an `endTag` prefix is truncated, delay is dropped immediately and scanning continues as text; only `full` matches are treated as close tokens.
-- **Performance: avoid redundant overlap work in shorthand ambiguity path**
-  - Kept shorthand probe reuse and switched overlap checks to bounded match evaluation at the cursor, reducing unnecessary repeated scans in conflict-heavy inputs.
+- **Refactor: unified close-ownership arbitration**
+  - Added one shared ownership resolver for shorthand/full-form close conflicts.
+  - The same rule is now used in shorthand push, shorthand close, and fallback resume paths.
+- **Fix: full-form close wins when competing with shorthand continuation**
+  - When `tagClose` and parent `endTag` overlap at the same cursor, parser keeps ownership for the parent full-form close.
+  - Prevents shorthand from stealing parent closure in conflict cases such as `=bold<bold<=bold<>=>=` (and equivalent custom delimiters).
+- **Fix: delayed endTag confirmation is explicit and truncation-safe**
+  - End-tag probe now returns `full` / `truncated-prefix` / `none`.
+  - Only `full` consumes close; truncated prefix immediately exits delay and resumes normal scan.
+- **Model consistency**
+  - Removed branch-local conflict guessing and consolidated to one deterministic ownership rule.
 - No public API changes
 
 ### 1.3.3

CHANGELOG.zh-CN.md

@@ -4,17 +4,17 @@
 
 ### 1.3.4
 
-- **修复：shorthand / full-form 闭合冲突时，优先保留 full-form 闭合归属**
-  - 在 inline 参数上下文中，当 shorthand 的闭合符（`tagClose`）与父级 full-form 闭合（`endTag`）发生重叠时，现优先保 full-form 闭合归属。
-  - 修复了 `=bold<bold<=bold<>=>=` 及其自定义语法嵌套变体中的冲突归属问题，同时避免引入宽泛回退副作用。
-- **解析模型收敛：移除“向前找救济”的长距前瞻**
-  - 删除依赖“继续向后扫描是否还有 `endTag`”的救济分支。
-  - 冲突判定改为当前位置、基于栈顶 frame 的局部决策，行为更确定，符合步进状态机语义。
-- **修复：endTag 延迟确认 + 截断安全匹配**
-  - 新增 endTag 匹配状态（`full` / `truncated-prefix` / `none`）。
-  - 当仅命中 endTag 前缀但被截断时，立即解除延迟并继续按文本扫描；仅 `full` 命中才视为闭合 token。
-- **性能：减少 shorthand 歧义路径中的重复开销**
-  - 保留 shorthand 前探复用，并将重叠判定收敛为当前位置有界匹配，降低冲突密集输入下的重复扫描成本。
+- **重构：统一闭合归属判定**
+  - 新增统一的归属仲裁函数，集中处理 shorthand / full-form 的闭合竞争。
+  - shorthand 的 push、close、fallback 恢复路径改为复用同一套规则。
+- **修复：full-form close 与 shorthand continuation 竞争时，优先 full-form**
+  - 当 `tagClose` 与父级 `endTag` 在同一游标重叠时，优先保留父级 full-form 闭合归属。
+  - 避免 shorthand 抢占父级闭合，覆盖 `=bold<bold<=bold<>=>=` 及等价自定义分隔符场景。
+- **修复：endTag 延迟确认显式化，且对截断安全**
+  - endTag 探测结果细分为 `full` / `truncated-prefix` / `none`。
+  - 仅 `full` 视为可消费闭合；命中截断前缀时立即解除延迟并恢复常规扫描。
+- **模型一致性**
+  - 移除分支内各自猜测式判优，收敛为单一、确定的归属规则。
 - 无公共 API 变化
 
 ### 1.3.3

src/structural.ts

@@ -565,21 +565,31 @@ const parseNodesWithFactory = <TNode extends StructuralNode | IndexedStructuralN
     return "full";
   };
 
-  const tryPushInlineShorthandChild = (
-    frame: ParseFrame,
-    tagStartI: number,
-    info: ShorthandStartInfo,
-  ): boolean => {
-    // Guard ambiguity like `=bold<bold<>=`:
-    // if shorthand arg starts exactly at parent's inline close token (`endTag`),
-    // this `name<` is text and the following close belongs to parent.
-    if (frame.inlineCloseToken === endTag && scanEndTagAt(frame.text, info.argStart, frame.textEnd) === "full") {
-      return false;
-    }
+  type ShorthandOwnershipPhase = "push" | "close" | "eof";
+  type ShorthandOwnershipDecision = "allow" | "defer-parent";
+  interface ShorthandOwnershipInput {
+    phase: ShorthandOwnershipPhase;
+    frame: ParseFrame;
+    parent: ParseFrame | null;
+    info?: ShorthandStartInfo;
+    at?: number;
+  }
+  const resolveShorthandOwnership = (input: ShorthandOwnershipInput): ShorthandOwnershipDecision => {
+    if (input.phase === "push") {
+      const info = input.info;
+      if (!info) return "allow";
+      const frame = input.frame;
+
+      // `name<` 的 argStart 与父级 endTag 完全重叠时，优先父级闭合。
+      if (
+        frame.inlineCloseToken === endTag &&
+        scanEndTagAt(frame.text, info.argStart, frame.textEnd) === "full"
+      ) {
+        return "defer-parent";
+      }
+
+      if (frame.inlineCloseToken !== endTag) return "allow";
 
-    // Guard ambiguity where shorthand would consume the `tagClose` that is
-    // actually the start of parent's `endTag` (e.g. `=bold<bold<<>=`).
-    if (frame.inlineCloseToken === endTag) {
       const canReuseProbe =
         frame.shorthandProbeStartI >= 0 &&
         frame.shorthandProbeBoundaryI >= 0 &&
@@ -596,8 +606,6 @@ const parseNodesWithFactory = <TNode extends StructuralNode | IndexedStructuralN
             probe = nextEsc;
             continue;
           }
-          // Full DSL structure has priority over shorthand:
-          // once a full tag starts, shorthand child would end before it.
           if (readTagStartInfo(frame.text, probe, syntax, tagName)) {
             boundary = probe;
             reject = false;
@@ -616,9 +624,38 @@ const parseNodesWithFactory = <TNode extends StructuralNode | IndexedStructuralN
         frame.shorthandProbeReject = reject;
       }
 
-      if (frame.shorthandProbeReject) {
-        return false;
-      }
+      return frame.shorthandProbeReject ? "defer-parent" : "allow";
+    }
+
+    if (input.phase === "close") {
+      const at = input.at;
+      if (at === undefined) return "allow";
+      const frame = input.frame;
+      const parent = input.parent;
+      if (!frame.implicitInlineShorthand) return "allow";
+      if (!parent || parent.inlineCloseToken !== endTag) return "allow";
+      if (scanEndTagAt(frame.text, at, frame.textEnd) !== "full") return "allow";
+      return "defer-parent";
+    }
+
+    // EOF 恢复统一交给父帧继续决议（历史语义：回到 argStart 重扫）。
+    return "defer-parent";
+  };
+
+  const tryPushInlineShorthandChild = (
+    frame: ParseFrame,
+    tagStartI: number,
+    info: ShorthandStartInfo,
+  ): boolean => {
+    if (
+      resolveShorthandOwnership({
+        phase: "push",
+        frame,
+        parent: null,
+        info,
+      }) === "defer-parent"
+    ) {
+      return false;
     }
 
     if (frame.depth >= depthLimit) {
@@ -664,6 +701,16 @@ const parseNodesWithFactory = <TNode extends StructuralNode | IndexedStructuralN
         );
         stack.pop();
         const parent = stack[frame.parentIndex];
+        const eofOwnership = resolveShorthandOwnership({
+          phase: "eof",
+          frame,
+          parent: parent ?? null,
+        });
+        if (eofOwnership === "defer-parent") {
+          appendBuf(parent, frame.tagStartI, frame.argStartI);
+          parent.i = frame.argStartI;
+          continue;
+        }
         appendBuf(parent, frame.tagStartI, frame.argStartI);
         parent.i = frame.argStartI;
         continue;
@@ -700,18 +747,22 @@ const parseNodesWithFactory = <TNode extends StructuralNode | IndexedStructuralN
 
       if (frame.inlineCloseToken === tagClose) {
         if (frameText.startsWith(tagClose, i)) {
-          if (frame.implicitInlineShorthand) {
-            const parent = stack[frame.parentIndex];
-            if (
-              parent &&
-              parent.inlineCloseToken === endTag &&
-              scanEndTagAt(frameText, i, frame.textEnd) === "full"
-            ) {
-              stack.pop();
-              appendBuf(parent, frame.tagStartI, frame.argStartI);
-              parent.i = frame.argStartI;
+          const parent = frame.parentIndex >= 0 ? stack[frame.parentIndex] : null;
+          if (
+            resolveShorthandOwnership({
+              phase: "close",
+              frame,
+              parent,
+              at: i,
+            }) === "defer-parent"
+          ) {
+            stack.pop();
+            if (!parent) {
               continue;
             }
+            appendBuf(parent, frame.tagStartI, frame.argStartI);
+            parent.i = frame.argStartI;
+            continue;
           }
           flushBuffer(frame);
           frame.inlineCloseWidth = tagClose.length;