parseman 0.48.0 → 0.49.0

package/src/plugin/index.ts

@@ -23,7 +23,7 @@ import { createUnplugin } from 'unplugin'
 import { parseSync } from 'oxc-parser'
 import { ResolverFactory } from 'oxc-resolver'
 import MagicString from 'magic-string'
-import { evaluateExpr, evaluateCombinatorArray, evaluateParserFactory, evaluateStaticValue, evaluateWordFactory, evaluateWhenFactory, evaluateRefDeclaration, applyDefineStatement, referencesAny, setReducerResolver, propName, type Scope, type ScopeEntry } from './evaluator.ts'
+import { evaluateExpr, evaluateCombinatorArray, evaluateParserFactory, evaluateStaticValue, evaluateWordFactory, evaluateWhenFactory, evaluateRefDeclaration, applyDefineStatement, referencesAny, setReducerResolver, setBuilderImportResolver, propName, type Scope, type ScopeEntry } from './evaluator.ts'
 import { classifyRuleMap } from '../analysis/commitment.ts'
 import { compile } from '../table/compile.ts'
 import { compileRuleMap } from '../table/compile-rule-map.ts'
@@ -516,6 +516,7 @@ export function transformMacro(
     return transformMacroImpl(code, id, moduleAliases, warnUnloweredRegex, recovery, grammarCoverage)
   } finally {
     setReducerResolver(null)
+    setBuilderImportResolver(null)
     // Both are idempotent: on the success path the body already released them and these
     // are no-ops. On an aborted transform they are what stops the leak.
     for (const d of unwindDegradationCapture(depth)) console.warn(formatDegradation(d))
@@ -666,6 +667,10 @@ function transformMacroImpl(
    */
   const reducerResolver = createReducerResolver(id, body as unknown[], code)
   setReducerResolver(reducerResolver, code)
+  /* A direct builder's free name is rescuable when THIS module imported it — the
+   * artifact carries `{ source, imported }` and a downstream compose() re-emits the
+   * import (see the re-lower pass below). Module-private consts stay refusals. */
+  setBuilderImportResolver(name => importBindings.get(name) ?? null)
 
   const topLevelFunction = (moduleBody: AnyNode[], name: string): AnyNode | null => {
     for (const st of moduleBody) {
@@ -797,6 +802,69 @@ function transformMacroImpl(
    * at the end of this transform is what proves it was actually emitted.
    */
   let usedTableRuntime = false
+  /**
+   * `source` -> (local -> imported) for direct-builder free names that rode in on a
+   * carried piece's IR (a composed base grammar whose reducers call imported AST
+   * factories). Re-emitted as real imports into THIS module so the inlined builder
+   * source has bindings to resolve. A name this module already imports is skipped.
+   */
+  const pendingBuilderImports = new Map<string, Map<string, string>>()
+  /**
+   * Harvest direct-builder import provenance off a MERGED rule graph so the re-lower
+   * pass re-emits those imports. `buildImports` rides on a `node()`'s `_def`, but a
+   * rule that ANOTHER rule references (`g.X`) is materialized in the evaluated map as
+   * a `lazy` proxy whose definition node sits behind `_def.thunk()` — never an own
+   * property. A generic `Object.values` descent therefore skips it entirely, silently
+   * dropping the imports of every cross-referenced rule (the css base's `VarCall`,
+   * referenced by its selector/value parents, is the canonical case: its `funcCall` /
+   * `isValueSlotValue` reads were lost and the fused downstream module threw "bound by
+   * nothing" / left a runtime compose()).
+   *
+   * The fused table encodes exactly the WINNER of each rule name and binds every
+   * reference BY NAME to that winner (`enc.winners`), so the imports it inlines are
+   * exactly the union over the winning rule bodies. Harvest that set: walk each rule
+   * entry's own body (following the entry lazy's thunk), and STOP at a named `lazy`
+   * reference inside a body — it resolves to a winner already covered as its own
+   * entry, so descending it would reach an OVERRIDDEN rule's shadowed original and
+   * re-emit a dead import. An anonymous `lazy` is inline recursion and is followed.
+   * One `seen` set is shared across every rule so a cyclic grammar terminates.
+   */
+  const collectBuilderImports = (ruleMap: ReadonlyArray<readonly [string, Combinator<unknown>]>): void => {
+    const seen = new Set<unknown>()
+    const walk = (v: unknown): void => {
+      if (v === null || typeof v !== 'object' || seen.has(v)) return
+      seen.add(v)
+      const def = (v as { _def?: { tag?: string; thunk?: () => unknown; buildImports?: ReadonlyArray<{ local: string; source: string; imported: string }> } })._def
+      for (const bi of def?.buildImports ?? []) {
+        let m = pendingBuilderImports.get(bi.source)
+        if (!m) { m = new Map(); pendingBuilderImports.set(bi.source, m) }
+        m.set(bi.local, bi.imported)
+      }
+      // An ANONYMOUS lazy is inline recursion — follow the thunk. A NAMED lazy is a
+      // rule reference bound by name to a winner covered as its own entry; do not
+      // descend it (that path reaches an overridden rule's shadowed original).
+      if (def?.tag === 'lazy' && (v as { _ruleName?: string })._ruleName === undefined && typeof def.thunk === 'function') {
+        let target: unknown = null
+        try { target = def.thunk() } catch { /* external ref — no definition to walk */ }
+        walk(target)
+      }
+      for (const child of Object.values(v as Record<string, unknown>)) {
+        if (Array.isArray(child)) { for (const c of child) walk(c) } else walk(child)
+      }
+    }
+    for (const [, rule] of ruleMap) {
+      walk(rule)
+      // A referenced rule entry is a named lazy whose body node (with its builder
+      // imports) is behind the thunk; `walk` skips a named lazy's thunk, so follow
+      // the WINNER'S body explicitly here. A raw-node entry was already fully walked.
+      const def = rule._def as { tag?: string; thunk?: () => unknown }
+      if (def?.tag === 'lazy' && typeof def.thunk === 'function') {
+        let body: unknown = null
+        try { body = def.thunk() } catch { /* unresolved winner — nothing to walk */ }
+        walk(body)
+      }
+    }
+  }
   /** Exported `rules()` factories, whose bodies are left verbatim. See the push site. */
   const exportedFactories: Array<{ name: string; pos: number }> = []
   let runtimeComposeFallback = false
@@ -1457,6 +1525,9 @@ function transformMacroImpl(
     const merged = mergedCarriedRules(carried)
     if (merged !== null) {
       if (composing) applyComposingTrivia(merged.rules, composing)
+      // Harvest the direct-builder import provenance carried on the merged graph so
+      // the re-lower pass at the end of this transform re-emits those imports.
+      collectBuilderImports(merged.rules)
       const refusals: string[] = []
       const compiled = compileRuleMap(merged.rules, {
         ...(composing ? { trivia: composing } : {}),
@@ -2186,6 +2257,73 @@ function transformMacroImpl(
   if (usedTableRuntime && applied.length > 0) {
     ms.prepend(`import { tableRules } from ${JSON.stringify(TABLE_RUNTIME_SPECIFIER)}\n`)
   }
+  /* Re-bind the direct-builder free names carried in on composed IR: a base
+   * grammar's reducer calls `dimension` from '@jesscss/core/ast', that provenance
+   * rode in on the carried piece, and the fused table inlines the reducer source
+   * here — so this module must import the same binding.
+   *
+   * The inlined builder source spells the free name VERBATIM, so a re-emitted import
+   * cannot be aliased away: the local name is load-bearing. Two things therefore make
+   * a carried import unsatisfiable, and both are refused rather than silently mis-bound
+   * or emitted as a duplicate declaration:
+   *
+   *  - the name is ALREADY BOUND in this module to something else — a named import
+   *    from a DIFFERENT source/symbol (the inlined builder would call the wrong
+   *    binding), a default/namespace import, or a top-level const/function/class
+   *    (re-emitting the import would be a redeclaration `SyntaxError`). The
+   *    free-identifier net below cannot catch either: a wrong-binding read is bound,
+   *    and a redeclaration is the opposite of an unbound read.
+   *  - two DISTINCT carried sources need the SAME local name (the map is keyed by
+   *    source, so each would emit its own `import { X } from …`).
+   *
+   * A name this module already imports from the SAME source under the SAME symbol is
+   * the benign case — the exact import the builder needs is already present, so it is
+   * skipped (no duplicate). */
+  if (applied.length > 0 && pendingBuilderImports.size > 0) {
+    // Every top-level binding of THIS module, not just its named imports.
+    const boundLocally = new Set<string>()
+    for (const stmt of body as Statement[]) {
+      if (stmt.type === 'ImportDeclaration') {
+        for (const sp of (stmt as unknown as ImportDeclaration).specifiers) boundLocally.add(sp.local.name)
+        continue
+      }
+      const decl = stmt.type === 'ExportNamedDeclaration'
+        ? ((stmt as unknown as ExportNamedDeclaration).declaration as unknown as AnyNode | undefined)
+        : (stmt as unknown as AnyNode)
+      if (decl?.type === 'FunctionDeclaration' || decl?.type === 'ClassDeclaration') {
+        const n = (decl as unknown as { id?: { name?: string } }).id?.name
+        if (n) boundLocally.add(n)
+        continue
+      }
+      const vd = unwrapVd(stmt)
+      for (const d of vd?.declarations ?? []) {
+        const n = (d.id as unknown as { name?: string }).name
+        if (n) boundLocally.add(n)
+      }
+    }
+    const emitted = new Set<string>()
+    for (const [source, locals] of pendingBuilderImports) {
+      const needed: Array<[string, string]> = []
+      for (const [local, imported] of locals) {
+        const own = importBindings.get(local)
+        // Exact same import already present: the builder's need is satisfied. Skip.
+        if (own && own.source === source && own.imported === imported) continue
+        if (boundLocally.has(local) || emitted.has(local)) {
+          throw new Error(
+            `${id} — parseman will not emit this module: a fused builder needs \`${imported}\` from `
+            + `${JSON.stringify(source)} bound as \`${local}\`, but this module already binds \`${local}\` `
+            + `to something else. The inlined builder source names \`${local}\` verbatim, so the import `
+            + `cannot be aliased; rename the conflicting local binding so the builder's import can be re-emitted.`,
+          )
+        }
+        emitted.add(local)
+        needed.push([local, imported])
+      }
+      if (needed.length === 0) continue
+      const specs = needed.map(([local, imported]) => imported === local ? local : `${imported} as ${local}`)
+      ms.prepend(`import { ${specs.join(', ')} } from ${JSON.stringify(source)}\n`)
+    }
+  }
   if (applied.length > 0) {
     ms.prepend(
       `// Generated by parseman v${PARSEMAN_VERSION} — DO NOT EDIT.\n` +
@@ -2259,6 +2397,7 @@ function transformMacroImpl(
   // caller's config does not break; it is now inert.
 
   setReducerResolver(null)
+  setBuilderImportResolver(null)
   // Every place the compiler chose a correct-but-slower path for this module. Reported
   // on the ordinary warning channel and greppable on `[parseman] degraded`, so a
   // consumer's build gate can assert zero of them the way jess's `check:macro` already

package/src/table/assemble.ts

@@ -224,13 +224,13 @@ type MaskedChoiceBlock = (
   input: string, pos: number, ctx: ParseContext, bits: number,
   need: boolean, mRaw: number, mTl: number, mLv: number, mFl: number,
   mEr: number, mLog: number, mRoot: number,
-  acc: string[] | undefined, prev: number,
+  acc: string[] | undefined, prev: number, best: number,
 ) => unknown
 type GeneralChoiceBlock = (
   input: string, pos: number, ctx: ParseContext, c: number,
   need: boolean, mRaw: number, mTl: number, mLv: number, mFl: number,
   mEr: number, mLog: number, mRoot: number,
-  acc: string[] | undefined, prev: number,
+  acc: string[] | undefined, prev: number, best: number,
 ) => unknown
 type ExclusiveChoiceBlock = (arm: number, input: string, pos: number, ctx: ParseContext) => unknown
 type DispatchMatcher = (key: string) => boolean
@@ -1008,19 +1008,7 @@ export function assemble(t: ResolvedTable, prog: TableProgram, cfg: RunCfg): Ass
     return c._fc === true
   }
 
-  /**
-   * Accumulate one failed choice arm's expected set, in arm order.
-   *
-   * `choice.ts:167` is `expected.push(...result.expected)` per failed arm, and the
-   * accumulation — not the static union of the arms' OPENERS — is what a failing
-   * ordered choice reports. A left-factored or shared-prefix choice whose arms all
-   * failed PAST their common opener reported that opener alone: `['/::?/']` where
-   * the interpreter says `['"before"', '"hover"']`.
-   *
-   * Returns the accumulator so the common one-failing-arm case borrows the arm's
-   * own array (`slice` once) instead of building one per choice execution the way
-   * the interpreter's eager `const expected: string[] = []` does.
-   */
+  /** Append an exact-depth failed arm set in source order. Callers own depth ranking. */
   function accSet(ax: readonly string[] | undefined, acc: string[] | undefined): string[] | undefined {
     if (ax === undefined || ax.length === 0) return acc
     if (acc === undefined) return ax.slice()
@@ -1062,13 +1050,16 @@ export function assemble(t: ResolvedTable, prog: TableProgram, cfg: RunCfg): Ass
     total: number,
     choiceFx: string[],
   ): MaskedChoiceBlock {
-    return (input, pos, ctx, bits, need, mRaw, mTl, mLv, mFl, mEr, mLog, mRoot, acc, prev) => {
+    return (input, pos, ctx, bits, need, mRaw, mTl, mLv, mFl, mEr, mLog, mRoot, acc, prev, best) => {
       if ((bits & (1 << start)) !== 0) {
         ctx._fc = false
         const v = a0(input, pos, ctx)
         if (v !== FAIL) return v
-        acc = through(start, prev, acc); prev = start + 1
-        acc = accSet(ctx._fx, acc)
+        if (best === pos) acc = through(start, prev, acc)
+        prev = start + 1
+        const at = ctx._fe ?? pos
+        if (at > best) { best = at; acc = undefined }
+        if (at === best) acc = accSet(ctx._fx, acc)
         if (committed(ctx)) { if (acc !== undefined) ctx._fx = acc; return FAIL }
         if (need) rollbackTriviaAt(ctx, mRaw, mTl, mLv, mFl, mEr, mLog, mRoot)
       }
@@ -1076,8 +1067,11 @@ export function assemble(t: ResolvedTable, prog: TableProgram, cfg: RunCfg): Ass
         ctx._fc = false
         const v = a1(input, pos, ctx)
         if (v !== FAIL) return v
-        acc = through(start + 1, prev, acc); prev = start + 2
-        acc = accSet(ctx._fx, acc)
+        if (best === pos) acc = through(start + 1, prev, acc)
+        prev = start + 2
+        const at = ctx._fe ?? pos
+        if (at > best) { best = at; acc = undefined }
+        if (at === best) acc = accSet(ctx._fx, acc)
         if (committed(ctx)) { if (acc !== undefined) ctx._fx = acc; return FAIL }
         if (need) rollbackTriviaAt(ctx, mRaw, mTl, mLv, mFl, mEr, mLog, mRoot)
       }
@@ -1085,8 +1079,11 @@ export function assemble(t: ResolvedTable, prog: TableProgram, cfg: RunCfg): Ass
         ctx._fc = false
         const v = a2(input, pos, ctx)
         if (v !== FAIL) return v
-        acc = through(start + 2, prev, acc); prev = start + 3
-        acc = accSet(ctx._fx, acc)
+        if (best === pos) acc = through(start + 2, prev, acc)
+        prev = start + 3
+        const at = ctx._fe ?? pos
+        if (at > best) { best = at; acc = undefined }
+        if (at === best) acc = accSet(ctx._fx, acc)
         if (committed(ctx)) { if (acc !== undefined) ctx._fx = acc; return FAIL }
         if (need) rollbackTriviaAt(ctx, mRaw, mTl, mLv, mFl, mEr, mLog, mRoot)
       }
@@ -1094,15 +1091,18 @@ export function assemble(t: ResolvedTable, prog: TableProgram, cfg: RunCfg): Ass
         ctx._fc = false
         const v = a3(input, pos, ctx)
         if (v !== FAIL) return v
-        acc = through(start + 3, prev, acc); prev = start + 4
-        acc = accSet(ctx._fx, acc)
+        if (best === pos) acc = through(start + 3, prev, acc)
+        prev = start + 4
+        const at = ctx._fe ?? pos
+        if (at > best) { best = at; acc = undefined }
+        if (at === best) acc = accSet(ctx._fx, acc)
         if (committed(ctx)) { if (acc !== undefined) ctx._fx = acc; return FAIL }
         if (need) rollbackTriviaAt(ctx, mRaw, mTl, mLv, mFl, mEr, mLog, mRoot)
       }
       if (next !== undefined) {
-        return next(input, pos, ctx, bits, need, mRaw, mTl, mLv, mFl, mEr, mLog, mRoot, acc, prev)
+        return next(input, pos, ctx, bits, need, mRaw, mTl, mLv, mFl, mEr, mLog, mRoot, acc, prev, best)
       }
-      acc = through(total, prev, acc)
+      if (best === pos) acc = through(total, prev, acc)
       ctx._fe = pos; ctx._fx = acc ?? choiceFx
       return FAIL
     }
@@ -1119,13 +1119,16 @@ export function assemble(t: ResolvedTable, prog: TableProgram, cfg: RunCfg): Ass
     total: number,
     choiceFx: string[],
   ): GeneralChoiceBlock {
-    return (input, pos, ctx, c, need, mRaw, mTl, mLv, mFl, mEr, mLog, mRoot, acc, prev) => {
+    return (input, pos, ctx, c, need, mRaw, mTl, mLv, mFl, mEr, mLog, mRoot, acc, prev, best) => {
       if (g0 === null || classHas(g0, c)) {
         ctx._fc = false
         const v = a0(input, pos, ctx)
         if (v !== FAIL) return v
-        acc = through(start, prev, acc); prev = start + 1
-        acc = accSet(ctx._fx, acc)
+        if (best === pos) acc = through(start, prev, acc)
+        prev = start + 1
+        const at = ctx._fe ?? pos
+        if (at > best) { best = at; acc = undefined }
+        if (at === best) acc = accSet(ctx._fx, acc)
         if (committed(ctx)) { if (acc !== undefined) ctx._fx = acc; return FAIL }
         if (need) rollbackTriviaAt(ctx, mRaw, mTl, mLv, mFl, mEr, mLog, mRoot)
       }
@@ -1133,8 +1136,11 @@ export function assemble(t: ResolvedTable, prog: TableProgram, cfg: RunCfg): Ass
         ctx._fc = false
         const v = a1(input, pos, ctx)
         if (v !== FAIL) return v
-        acc = through(start + 1, prev, acc); prev = start + 2
-        acc = accSet(ctx._fx, acc)
+        if (best === pos) acc = through(start + 1, prev, acc)
+        prev = start + 2
+        const at = ctx._fe ?? pos
+        if (at > best) { best = at; acc = undefined }
+        if (at === best) acc = accSet(ctx._fx, acc)
         if (committed(ctx)) { if (acc !== undefined) ctx._fx = acc; return FAIL }
         if (need) rollbackTriviaAt(ctx, mRaw, mTl, mLv, mFl, mEr, mLog, mRoot)
       }
@@ -1142,8 +1148,11 @@ export function assemble(t: ResolvedTable, prog: TableProgram, cfg: RunCfg): Ass
         ctx._fc = false
         const v = a2(input, pos, ctx)
         if (v !== FAIL) return v
-        acc = through(start + 2, prev, acc); prev = start + 3
-        acc = accSet(ctx._fx, acc)
+        if (best === pos) acc = through(start + 2, prev, acc)
+        prev = start + 3
+        const at = ctx._fe ?? pos
+        if (at > best) { best = at; acc = undefined }
+        if (at === best) acc = accSet(ctx._fx, acc)
         if (committed(ctx)) { if (acc !== undefined) ctx._fx = acc; return FAIL }
         if (need) rollbackTriviaAt(ctx, mRaw, mTl, mLv, mFl, mEr, mLog, mRoot)
       }
@@ -1151,15 +1160,18 @@ export function assemble(t: ResolvedTable, prog: TableProgram, cfg: RunCfg): Ass
         ctx._fc = false
         const v = a3(input, pos, ctx)
         if (v !== FAIL) return v
-        acc = through(start + 3, prev, acc); prev = start + 4
-        acc = accSet(ctx._fx, acc)
+        if (best === pos) acc = through(start + 3, prev, acc)
+        prev = start + 4
+        const at = ctx._fe ?? pos
+        if (at > best) { best = at; acc = undefined }
+        if (at === best) acc = accSet(ctx._fx, acc)
         if (committed(ctx)) { if (acc !== undefined) ctx._fx = acc; return FAIL }
         if (need) rollbackTriviaAt(ctx, mRaw, mTl, mLv, mFl, mEr, mLog, mRoot)
       }
       if (next !== undefined) {
-        return next(input, pos, ctx, c, need, mRaw, mTl, mLv, mFl, mEr, mLog, mRoot, acc, prev)
+        return next(input, pos, ctx, c, need, mRaw, mTl, mLv, mFl, mEr, mLog, mRoot, acc, prev, best)
       }
-      acc = through(total, prev, acc)
+      if (best === pos) acc = through(total, prev, acc)
       ctx._fe = pos; ctx._fx = acc ?? choiceFx
       return FAIL
     }
@@ -2690,10 +2702,8 @@ export function assemble(t: ResolvedTable, prog: TableProgram, cfg: RunCfg): Ass
               // THE CUT — a committed failure fails the whole choice.
               if (committed(ctx)) return FAIL
               // THE DISPATCHED ARM'S OWN SET IS THE ANSWER, at the choice's own
-              // position — the rule both shipped engines apply (choice.ts:105,
-              // codegen.ts:1985). `_fx` already holds it; reporting the arm is
-              // declining to overwrite it. See `exec.ts` for why this is NOT
-              // furthest-failure merging and what the residual JSON gap is.
+              // position. `_fx` already holds it; reporting the sole selected arm
+              // is declining to overwrite it.
               const armFx = ctx._fx
               if (armFx !== undefined && armFx.length > 0) { ctx._fe = pos; return FAIL }
             }
@@ -2739,6 +2749,7 @@ export function assemble(t: ResolvedTable, prog: TableProgram, cfg: RunCfg): Ass
             const mLog = need ? ctx._triviaLog?.length ?? 0 : 0
             const mRoot = need ? ctx._rootTriviaLog?.length ?? 0 : 0
             let acc: string[] | undefined
+            let best = pos
             if (c < 128) {
               const bits = mask[c < 0 ? 128 : c]!
               let prev = 0
@@ -2747,7 +2758,9 @@ export function assemble(t: ResolvedTable, prog: TableProgram, cfg: RunCfg): Ass
                 const v = a0(input, pos, ctx)
                 if (v !== FAIL) return v
                 prev = 1
-                acc = accSet(ctx._fx, acc)
+                const at = ctx._fe ?? pos
+                if (at > best) { best = at; acc = undefined }
+                if (at === best) acc = accSet(ctx._fx, acc)
                 if (committed(ctx)) { if (acc !== undefined) ctx._fx = acc; return FAIL }
                 if (need) rollbackTriviaAt(ctx, mRaw, mTl, mLv, mFl, mEr, mLog, mRoot)
               }
@@ -2755,9 +2768,11 @@ export function assemble(t: ResolvedTable, prog: TableProgram, cfg: RunCfg): Ass
                 ctx._fc = false
                 const v = a1(input, pos, ctx)
                 if (v !== FAIL) return v
-                if (prev < 1) acc = accSet(e0, acc)
+                if (best === pos && prev < 1) acc = accSet(e0, acc)
                 prev = 2
-                acc = accSet(ctx._fx, acc)
+                const at = ctx._fe ?? pos
+                if (at > best) { best = at; acc = undefined }
+                if (at === best) acc = accSet(ctx._fx, acc)
                 if (committed(ctx)) { if (acc !== undefined) ctx._fx = acc; return FAIL }
                 if (need) rollbackTriviaAt(ctx, mRaw, mTl, mLv, mFl, mEr, mLog, mRoot)
               }
@@ -2765,16 +2780,18 @@ export function assemble(t: ResolvedTable, prog: TableProgram, cfg: RunCfg): Ass
                 ctx._fc = false
                 const v = a2!(input, pos, ctx)
                 if (v !== FAIL) return v
-                if (prev < 1) acc = accSet(e0, acc)
-                if (prev < 2) acc = accSet(e1, acc)
+                if (best === pos && prev < 1) acc = accSet(e0, acc)
+                if (best === pos && prev < 2) acc = accSet(e1, acc)
                 prev = 3
-                acc = accSet(ctx._fx, acc)
+                const at = ctx._fe ?? pos
+                if (at > best) { best = at; acc = undefined }
+                if (at === best) acc = accSet(ctx._fx, acc)
                 if (committed(ctx)) { if (acc !== undefined) ctx._fx = acc; return FAIL }
                 if (need) rollbackTriviaAt(ctx, mRaw, mTl, mLv, mFl, mEr, mLog, mRoot)
               }
-              if (prev < 1) acc = accSet(e0, acc)
-              if (prev < 2) acc = accSet(e1, acc)
-              if (n === 3 && prev < 3) acc = accSet(e2, acc)
+              if (best === pos && prev < 1) acc = accSet(e0, acc)
+              if (best === pos && prev < 2) acc = accSet(e1, acc)
+              if (best === pos && n === 3 && prev < 3) acc = accSet(e2, acc)
               ctx._fe = pos; ctx._fx = acc ?? choiceFx
               return FAIL
             }
@@ -2783,27 +2800,33 @@ export function assemble(t: ResolvedTable, prog: TableProgram, cfg: RunCfg): Ass
               ctx._fc = false
               const v = a0(input, pos, ctx)
               if (v !== FAIL) return v
-              acc = accSet(ctx._fx, acc)
+              const at = ctx._fe ?? pos
+              if (at > best) { best = at; acc = undefined }
+              if (at === best) acc = accSet(ctx._fx, acc)
               if (committed(ctx)) { if (acc !== undefined) ctx._fx = acc; return FAIL }
               if (need) rollbackTriviaAt(ctx, mRaw, mTl, mLv, mFl, mEr, mLog, mRoot)
-            } else acc = accSet(e0, acc)
+            } else if (best === pos) acc = accSet(e0, acc)
             if (g1 === null || classHas(g1, c)) {
               ctx._fc = false
               const v = a1(input, pos, ctx)
               if (v !== FAIL) return v
-              acc = accSet(ctx._fx, acc)
+              const at = ctx._fe ?? pos
+              if (at > best) { best = at; acc = undefined }
+              if (at === best) acc = accSet(ctx._fx, acc)
               if (committed(ctx)) { if (acc !== undefined) ctx._fx = acc; return FAIL }
               if (need) rollbackTriviaAt(ctx, mRaw, mTl, mLv, mFl, mEr, mLog, mRoot)
-            } else acc = accSet(e1, acc)
+            } else if (best === pos) acc = accSet(e1, acc)
             if (n === 3) {
               if (g2 === null || classHas(g2, c)) {
                 ctx._fc = false
                 const v = a2!(input, pos, ctx)
                 if (v !== FAIL) return v
-                acc = accSet(ctx._fx, acc)
+                const at = ctx._fe ?? pos
+                if (at > best) { best = at; acc = undefined }
+                if (at === best) acc = accSet(ctx._fx, acc)
                 if (committed(ctx)) { if (acc !== undefined) ctx._fx = acc; return FAIL }
                 if (need) rollbackTriviaAt(ctx, mRaw, mTl, mLv, mFl, mEr, mLog, mRoot)
-              } else acc = accSet(e2, acc)
+              } else if (best === pos) acc = accSet(e2, acc)
             }
             ctx._fe = pos; ctx._fx = acc ?? choiceFx
             return FAIL
@@ -2869,11 +2892,11 @@ export function assemble(t: ResolvedTable, prog: TableProgram, cfg: RunCfg): Ass
             if (c < 128) {
               return masked(
                 input, pos, ctx, mask[c < 0 ? 128 : c]!,
-                need, mRaw, mTl, mLv, mFl, mEr, mLog, mRoot, undefined, 0,
+                need, mRaw, mTl, mLv, mFl, mEr, mLog, mRoot, undefined, 0, pos,
               )
             }
             return general(
-              input, pos, ctx, c, need, mRaw, mTl, mLv, mFl, mEr, mLog, mRoot, undefined, 0,
+              input, pos, ctx, c, need, mRaw, mTl, mLv, mFl, mEr, mLog, mRoot, undefined, 0, pos,
             )
           }
         }
@@ -2889,7 +2912,7 @@ export function assemble(t: ResolvedTable, prog: TableProgram, cfg: RunCfg): Ass
           const mLog = need ? ctx._triviaLog?.length ?? 0 : 0
           const mRoot = need ? ctx._rootTriviaLog?.length ?? 0 : 0
           return general(
-            input, pos, ctx, c, need, mRaw, mTl, mLv, mFl, mEr, mLog, mRoot, undefined, 0,
+            input, pos, ctx, c, need, mRaw, mTl, mLv, mFl, mEr, mLog, mRoot, undefined, 0, pos,
           )
         }
       }

package/src/table/emit-assembly.ts

@@ -1463,9 +1463,11 @@ return FAIL
 ctx._fc=false
 {const v=${arm}(input,pos,ctx)
 if(v!==FAIL)return v}
-acc=${catchName}(${i},prev,acc)
+if(best===pos)acc=${catchName}(${i},prev,acc)
 prev=${i + 1}
-acc=_accSet(ctx._fx,acc)
+{const at=ctx._fe??pos
+if(at>best){best=at;acc=undefined}
+if(at===best)acc=_accSet(ctx._fx,acc)}
 if(ctx._fc===true){if(acc!==undefined)ctx._fx=acc;return FAIL}
 ${emitRollback(p, L.buf, sinks)}
 }`
@@ -1474,20 +1476,23 @@ ${emitRollback(p, L.buf, sinks)}
 ctx._fc=false
 {const v=${arm}(input,pos,ctx)
 if(v!==FAIL)return v}
-acc=_accSet(ctx._fx,acc)
+{const at=ctx._fe??pos
+if(at>best){best=at;acc=undefined}
+if(at===best)acc=_accSet(ctx._fx,acc)}
 if(ctx._fc===true){if(acc!==undefined)ctx._fx=acc;return FAIL}
 ${emitRollback(p, L.buf, sinks)}
-}else acc=_accSet(${expected[i]},acc)`).join('\n')
+}else if(best===pos)acc=_accSet(${expected[i]},acc)`).join('\n')
 
           return `${head}
 const c=lead(input,pos)
 ${emitMark(p, L.buf, sinks)}
 let acc
+let best=pos
 ${maskable ? `if(c<128){
 const bits=${maskName}[c<0?128:c]
 let prev=0
 ${maskArms}
-acc=${catchName}(${n},prev,acc)
+if(best===pos)acc=${catchName}(${n},prev,acc)
 ctx._fe=pos;ctx._fx=acc??${choiceFx}
 return FAIL
 }

package/src/table/encode.ts

@@ -1078,20 +1078,16 @@ class Encoder {
           ? -1 : this.charClass(finalChoice.firstSets[i]!))
         const dispIdx = this.disp.length
         this.disp.push(classes)
-        // PER-ARM EXPECTED SETS RIDE ALONG, after the arm offsets. The ordered
-        // path reports the CONCATENATION of the arms' sets (`choice.ts:167`), and
-        // it must include the arms the driver's char gate declined to enter — the
-        // interpreter has no such gate, runs them, and gets exactly their static
-        // opener set back. Without these words a partially-gated site reported
-        // only the arms that happened to run.
+        // PER-ARM EXPECTED SETS RIDE ALONG, after the arm offsets. While the best
+        // failure remains at the choice position, an arm declined by the driver's
+        // char gate contributes the static opener set the interpreter would get by
+        // entering it. A deeper dynamic arm failure discards those shallower sets.
         const head = this.emitHead(OP_CHOICE, 3 + 2 * kids.length)
         this.code[head + 1] = dispIdx
         this.code[head + 2] = kids.length
         // THE CHOICE'S OWN SET IS THE ARMS' FLATMAP, NOT `deriveExpected(p)`.
-        // `deriveExpected` DEDUPES, and neither engine does: `choice.ts:110-118`
-        // is `parsers.flatMap(p => p.parse(...).expected)`, so a shared-prefix
-        // choice whose two arms both open with `/::?/` reports it TWICE. The
-        // deduped union silently collapsed that to one.
+        // It is the pure-dispatch-miss and empty-dynamic fallback, where source
+        // order and duplicates remain observable. `deriveExpected` would dedupe.
         this.code[head + 3] = this.expected(arms.flatMap(a => deriveExpected(a)))
         for (let i = 0; i < kids.length; i++) {
           this.code[head + 4 + i] = kids[i]!

package/src/table/exec.ts

@@ -952,9 +952,8 @@ function makeDriver(
         const d = code[ip + 1]!
         const base = ip + 4
         const choiceFx = fx[code[ip + 3]!] as string[]
-        // Report the union, at the choice's own position, on every exit that
-        // fails — matching both engines and, more importantly, never handing a
-        // user an empty expected set.
+        // A pure dispatch miss has no attempted arm to rank. Report the static
+        // opener union at the choice's own position so the result is meaningful.
         const failChoice = (): typeof FAIL => {
           ctx._fe = pos
           ctx._fx = choiceFx
@@ -1003,12 +1002,9 @@ function makeDriver(
           // union IS that flatMap's answer, without running seven parsers to
           // rediscover it.
           //
-          // NOT furthest-failure merging, which no engine on the `expected` path
-          // performs. `failAt` (combinators/probe.ts:13-24) and its compiled mirror
-          // `probeUpdate` (codegen.ts:692) are the only positional merges in the
-          // library, they are gated on `_ctx._probe` and they surface as
-          // `RunResult.furthestFail` under `{recover:true}` — a different field.
-          // Every `_fe`/`_fx` site in all three drivers is last-write-wins.
+          // There is only one selected arm on this path, so ordered-arm depth
+          // ranking does not apply. `furthestFail` under `{recover:true}` remains
+          // a separate probe result.
           //
           // A residual JSON divergence survives this and is NOT a failure-reporting
           // bug: on `{"a":]` this driver reports `["}"]` (the Obj arm's own
@@ -1034,18 +1030,15 @@ function makeDriver(
         const mEr = need ? ctx._errors?.length ?? 0 : 0
         const mLog = need ? ctx._triviaLog?.length ?? 0 : 0
         const mRoot = need ? ctx._rootTriviaLog?.length ?? 0 : 0
-        // THE ORDERED PATH REPORTS THE ARMS THAT ACTUALLY RAN, accumulated in
-        // order — `choice.ts:167`'s `expected.push(...result.expected)` per failed
-        // arm, reported at the choice's own position. The static `choiceFx` union
-        // is a set of OPENERS, so a left-factored or shared-prefix choice whose
-        // arms all failed PAST their common opener reported that opener instead of
-        // the tokens the arms were actually waiting for: `['/::?/']` where the
-        // interpreter says `['"before"', '"hover"']`.
+        // The ordered path keeps only arms at the deepest failure offset. Exact
+        // ties merge in source order. The final failure is still anchored at the
+        // choice's own position; the deeper offset ranks diagnostics only.
         //
         // `choiceFx` is still the answer when nothing ran or every arm reported
         // nothing — the char gate can skip arms the interpreter would have entered,
         // and the union is what those arms' start-failures would have contributed.
         let acc: string[] | undefined
+        let best = pos
         const push = (ax: readonly string[] | undefined): void => {
           if (ax === undefined || ax.length === 0) return
           if (acc === undefined) acc = ax.slice()
@@ -1060,7 +1053,7 @@ function makeDriver(
             // enters the arm, the arm's opener fails, and its static set is what
             // lands in the accumulation. Declining to enter must not also decline
             // to say what the arm wanted.
-            push(fx[code[armFx + i]!] as string[])
+            if (best === pos) push(fx[code[armFx + i]!] as string[])
             continue
           }
           ctx._fc = false
@@ -1069,7 +1062,9 @@ function makeDriver(
           const v = exec(code[base + i]!, input, pos, ctx)
           if (v !== FAIL) return v
           if (COUNT) { tableCounters.ungatedFails++; tableCounters.ungatedFailRows += tableCounters.rows - rows0 }
-          push(ctx._fx)
+          const at = ctx._fe ?? pos
+          if (at > best) { best = at; acc = undefined }
+          if (at === best) push(ctx._fx)
           // A committed arm cuts, and the interpreter reports the accumulation at
           // the arm's OWN span (`choice.ts:170`), not at the choice's position.
           if (committed(ctx)) { if (acc !== undefined) ctx._fx = acc; return FAIL }