parseman 0.48.1 → 0.50.0

package/src/plugin/index.ts

@@ -23,13 +23,14 @@ 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'
 import { compileLinkableTable } from '../compiler/compile-linkable-table.ts'
 import { createReducerResolver } from './reducer-resolver.ts'
 import { findFreeIdentifiers } from './free-identifiers.ts'
+import { supercompileRuleMapReplacement } from './entry-supercompiler.ts'
 import {
   beginDegradationCapture, endDegradationCapture, formatDegradation, formatDegradations,
   resolveDegradationLevel, recordDegradation, degradationCaptureDepth, unwindDegradationCapture,
@@ -516,6 +517,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 +668,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 +803,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 +1526,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 } : {}),
@@ -1625,9 +1697,12 @@ function transformMacroImpl(
         if (compiled !== null) {
           usedTableRuntime = true
           return {
-            replacement: compiled.replacementWithMetadata(
-              staticTableMetadataSource({ reflection: compiled.reflection, leaf: true }),
-              { precompileDefault: true },
+            replacement: supercompileRuleMapReplacement(
+              compiled.prog,
+              compiled.replacementWithMetadata(
+                staticTableMetadataSource({ reflection: compiled.reflection, leaf: true }),
+                { precompileDefault: true },
+              ),
             ),
             ...(importedFactories.length ? { importedFactories } : {}),
           }
@@ -2186,6 +2261,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 +2401,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

@@ -125,11 +125,12 @@ import {
   type SubtreeRef, type TableProgram, type TableRule,
 } from './program.ts'
 import { stampRuleMap } from './stamp.ts'
-import { reachableSites } from './site-labels.ts'
+import { computeSiteLabels, reachableSites } from './site-labels.ts'
 import { refuseUnclassifiedRootScope } from '../cst/root-trivia-scope.ts'
 import { captureError, firstSetSentinel, matchesAt, orSentinel, recoverScan } from '../recovery/scan.ts'
 import {
-  makeScalarRecognizer, scalarTerminalNodeChild, scalarTerminalNotChild, type ScalarRecognizer,
+  leadingLiteralFamily, leadingScalarSequence, leadingScalarTerminal, makeScalarRecognizer, scalarTerminalNodeChild,
+  scalarTerminalNotChild, type ScalarRecognizer,
 } from './scalar-terminal.ts'
 
 /**
@@ -482,6 +483,16 @@ export function assemble(t: ResolvedTable, prog: TableProgram, cfg: RunCfg): Ass
     return recognize
   }
 
+  const labelExtraIps: number[] = []
+  for (const s of prog.scans ?? []) {
+    for (const r of s.skip) labelExtraIps.push(r[0])
+    if (s.sentinel !== undefined) labelExtraIps.push(s.sentinel[0])
+  }
+  for (const set of prog.scanSkip ?? []) for (const r of set) labelExtraIps.push(r[0])
+  const closureLabels = computeSiteLabels(
+    code, [...Object.values(prog.rules), ...labelExtraIps], hostCst,
+  )
+
   /**
    * The INSTALLED trivia scanner for the scope currently running.
    *
@@ -818,7 +829,9 @@ export function assemble(t: ResolvedTable, prog: TableProgram, cfg: RunCfg): Ass
       // has no single form. `rollbackNeeded` short-circuits true on a live buffer,
       // so the other seven sinks are not consulted — as before.
       const raw = b.raw
-      MRAW = raw !== undefined ? raw.length : b.rawSingle !== undefined ? 1 : 0
+      MRAW = b.noRaw === true
+        ? b.rawLen ?? 0
+        : raw !== undefined ? raw.length : b.rawSingle !== undefined ? 1 : 0
       const ch = b.ch
       MLV = ch !== undefined ? ch.length : b.single !== undefined ? 1 : 0
       const tl = b.tl
@@ -1004,6 +1017,33 @@ export function assemble(t: ResolvedTable, prog: TableProgram, cfg: RunCfg): Ass
     return cur
   }
 
+  /** A non-first term at a site proven to run under an open node capture buffer. */
+  function nextTermBuffered(child: Piece, input: string, cur: number, ctx: ParseContext): number {
+    if (ctx.trivia === undefined) {
+      const v = child(input, cur, ctx)
+      if (v === FAIL) return -1
+      TERMV = v
+      return EC.e
+    }
+    const before = ctx._cstBuf!
+    const beforeTl = before.tl
+    const mTl = beforeTl === undefined ? 0 : beforeTl.length
+    const mLog = ctx._triviaLog?.length ?? 0
+    const mRoot = ctx._rootTriviaLog?.length ?? 0
+    const scanEnd = skipTrivia(input, cur, ctx)
+    const scanned = ctx._cstBuf!
+    const scannedTl = scanned.tl
+    const scanTl = scannedTl === undefined ? 0 : scannedTl.length
+    const scanLog = ctx._triviaLog?.length ?? 0
+    const scanRoot = ctx._rootTriviaLog?.length ?? 0
+    const v = child(input, scanEnd, ctx)
+    if (v === FAIL) return -1
+    TERMV = v
+    if (EC.e > scanEnd) return EC.e
+    rollbackScannedTriviaAt(ctx, mTl, scanTl, mLog, scanLog, mRoot, scanRoot)
+    return cur
+  }
+
   function committed(c: ParseContext): boolean {
     return c._fc === true
   }
@@ -1288,7 +1328,16 @@ export function assemble(t: ResolvedTable, prog: TableProgram, cfg: RunCfg): Ass
     const holder = { fwd, set: (p: Piece) => { target = p } }
     inFlight.set(ip, holder)
 
-    const piece = lower(ip)
+    const op = code[ip]
+    // Match the emitted assembly's label-proven scope alias: rule entries in a
+    // single ambient trivia scope otherwise reinstall and restore the exact
+    // same trivia, labels and scanner on every call. Install the forwarding
+    // holder first so a recursive child can still link back through this site.
+    const piece = (op === OP_SCOPE_PLAIN || (op === OP_SCOPE && code[ip + 3]! === 0))
+      && code[ip + 1]! >= 0
+      && closureLabels.at(ip).tri === code[ip + 1]!
+      ? link(code[ip + 2]!)
+      : lower(ip)
 
     inFlight.delete(ip)
     holder.set(piece)
@@ -2148,6 +2197,7 @@ export function assemble(t: ResolvedTable, prog: TableProgram, cfg: RunCfg): Ass
         const fn = fused && projection < 0
           ? fns[reducer] as (value: unknown, span: { start: number; end: number }) => unknown
           : undefined
+        const step = closureLabels.at(ip).buf ? nextTermBuffered : nextTerm
 
         const runnerBlock = (
           count: number,
@@ -2255,7 +2305,7 @@ export function assemble(t: ResolvedTable, prog: TableProgram, cfg: RunCfg): Ass
               const kid = link(kidIp)
               return (input, cur, ctx, inherited) => {
                 ctx._sync = sync ?? inherited
-                return nextTerm(kid, input, cur, ctx)
+                return step(kid, input, cur, ctx)
               }
             }
             const negated = code[kidIp + 1] === 1
@@ -2328,7 +2378,7 @@ export function assemble(t: ResolvedTable, prog: TableProgram, cfg: RunCfg): Ass
             const kidIp = code[base + i]!
             if (code[kidIp] !== OP_ADJ) {
               const kid = link(kidIp)
-              return (input, cur, ctx) => nextTerm(kid, input, cur, ctx)
+              return (input, cur, ctx) => step(kid, input, cur, ctx)
             }
             const negated = code[kidIp + 1] === 1
             const ki = code[kidIp + 2]!
@@ -2436,7 +2486,7 @@ export function assemble(t: ResolvedTable, prog: TableProgram, cfg: RunCfg): Ass
             return (input, pos, ctx) => {
               const v0 = k0(input, pos, ctx)
               if (v0 === FAIL) return FAIL
-              const cur = nextTerm(k1, input, EC.e, ctx)
+              const cur = step(k1, input, EC.e, ctx)
               if (cur < 0) return FAIL
               EC.e = cur
               return projection === 0 ? v0
@@ -2448,7 +2498,7 @@ export function assemble(t: ResolvedTable, prog: TableProgram, cfg: RunCfg): Ass
             return (input, pos, ctx) => {
               const v0 = k0(input, pos, ctx)
               if (v0 === FAIL) return FAIL
-              const cur = nextTerm(k1, input, EC.e, ctx)
+              const cur = step(k1, input, EC.e, ctx)
               if (cur < 0) return FAIL
               EC.e = cur
               return [v0, TERMV]
@@ -2457,7 +2507,7 @@ export function assemble(t: ResolvedTable, prog: TableProgram, cfg: RunCfg): Ass
           return (input, pos, ctx) => {
             const v0 = k0(input, pos, ctx)
             if (v0 === FAIL) return FAIL
-            const cur = nextTerm(k1, input, EC.e, ctx)
+            const cur = step(k1, input, EC.e, ctx)
             if (cur < 0) return FAIL
             EC.e = cur
             return undefined
@@ -2470,10 +2520,10 @@ export function assemble(t: ResolvedTable, prog: TableProgram, cfg: RunCfg): Ass
             return (input, pos, ctx) => {
               const v0 = k0(input, pos, ctx)
               if (v0 === FAIL) return FAIL
-              let cur = nextTerm(k1, input, EC.e, ctx)
+              let cur = step(k1, input, EC.e, ctx)
               if (cur < 0) return FAIL
               const v1 = TERMV
-              cur = nextTerm(k2, input, cur, ctx)
+              cur = step(k2, input, cur, ctx)
               if (cur < 0) return FAIL
               EC.e = cur
               return projection === 0 ? v0
@@ -2486,10 +2536,10 @@ export function assemble(t: ResolvedTable, prog: TableProgram, cfg: RunCfg): Ass
             return (input, pos, ctx) => {
               const v0 = k0(input, pos, ctx)
               if (v0 === FAIL) return FAIL
-              let cur = nextTerm(k1, input, EC.e, ctx)
+              let cur = step(k1, input, EC.e, ctx)
               if (cur < 0) return FAIL
               const v1 = TERMV
-              cur = nextTerm(k2, input, cur, ctx)
+              cur = step(k2, input, cur, ctx)
               if (cur < 0) return FAIL
               EC.e = cur
               return [v0, v1, TERMV]
@@ -2498,9 +2548,9 @@ export function assemble(t: ResolvedTable, prog: TableProgram, cfg: RunCfg): Ass
           return (input, pos, ctx) => {
             const v0 = k0(input, pos, ctx)
             if (v0 === FAIL) return FAIL
-            let cur = nextTerm(k1, input, EC.e, ctx)
+            let cur = step(k1, input, EC.e, ctx)
             if (cur < 0) return FAIL
-            cur = nextTerm(k2, input, cur, ctx)
+            cur = step(k2, input, cur, ctx)
             if (cur < 0) return FAIL
             EC.e = cur
             return undefined
@@ -2516,43 +2566,43 @@ export function assemble(t: ResolvedTable, prog: TableProgram, cfg: RunCfg): Ass
           next: SequenceTermBlock | undefined,
         ): SequenceTermBlock => {
           if (count === 1) return (input, cur, ctx, values) => {
-            cur = nextTerm(k0, input, cur, ctx)
+            cur = step(k0, input, cur, ctx)
             if (cur < 0) return -1
             if (values !== undefined) values.push(TERMV)
             return next === undefined ? cur : next(input, cur, ctx, values)
           }
           if (count === 2) return (input, cur, ctx, values) => {
-            cur = nextTerm(k0, input, cur, ctx)
+            cur = step(k0, input, cur, ctx)
             if (cur < 0) return -1
             if (values !== undefined) values.push(TERMV)
-            cur = nextTerm(k1, input, cur, ctx)
+            cur = step(k1, input, cur, ctx)
             if (cur < 0) return -1
             if (values !== undefined) values.push(TERMV)
             return next === undefined ? cur : next(input, cur, ctx, values)
           }
           if (count === 3) return (input, cur, ctx, values) => {
-            cur = nextTerm(k0, input, cur, ctx)
+            cur = step(k0, input, cur, ctx)
             if (cur < 0) return -1
             if (values !== undefined) values.push(TERMV)
-            cur = nextTerm(k1, input, cur, ctx)
+            cur = step(k1, input, cur, ctx)
             if (cur < 0) return -1
             if (values !== undefined) values.push(TERMV)
-            cur = nextTerm(k2, input, cur, ctx)
+            cur = step(k2, input, cur, ctx)
             if (cur < 0) return -1
             if (values !== undefined) values.push(TERMV)
             return next === undefined ? cur : next(input, cur, ctx, values)
           }
           return (input, cur, ctx, values) => {
-            cur = nextTerm(k0, input, cur, ctx)
+            cur = step(k0, input, cur, ctx)
             if (cur < 0) return -1
             if (values !== undefined) values.push(TERMV)
-            cur = nextTerm(k1, input, cur, ctx)
+            cur = step(k1, input, cur, ctx)
             if (cur < 0) return -1
             if (values !== undefined) values.push(TERMV)
-            cur = nextTerm(k2, input, cur, ctx)
+            cur = step(k2, input, cur, ctx)
             if (cur < 0) return -1
             if (values !== undefined) values.push(TERMV)
-            cur = nextTerm(k3, input, cur, ctx)
+            cur = step(k3, input, cur, ctx)
             if (cur < 0) return -1
             if (values !== undefined) values.push(TERMV)
             return next === undefined ? cur : next(input, cur, ctx, values)
@@ -2722,6 +2772,13 @@ export function assemble(t: ResolvedTable, prog: TableProgram, cfg: RunCfg): Ass
         if (n === 2 || n === 3) {
           const a0 = link(code[base]!), a1 = link(code[base + 1]!)
           const a2 = n === 3 ? link(code[base + 2]!) : undefined
+          const predecide = !hostCst && !REC && !cfg.probe && !cfg.coverage && !cfg.trackLines
+          const p0ip = predecide ? leadingScalarTerminal(code, code[base]!, 2, true, true) : -1
+          const p1ip = predecide ? leadingScalarTerminal(code, code[base + 1]!, 2, true, true) : -1
+          const p2ip = predecide && n === 3 ? leadingScalarTerminal(code, code[base + 2]!, 2, true, true) : -1
+          const p0 = p0ip < 0 ? undefined : scalarFor(p0ip)
+          const p1 = p1ip < 0 ? undefined : scalarFor(p1ip)
+          const p2 = p2ip < 0 ? undefined : scalarFor(p2ip)
           const e0 = fx[code[base + n]!] as string[]
           const e1 = fx[code[base + n + 1]!] as string[]
           const e2 = n === 3 ? fx[code[base + n + 2]!] as string[] : undefined
@@ -2751,7 +2808,10 @@ export function assemble(t: ResolvedTable, prog: TableProgram, cfg: RunCfg): Ass
             let acc: string[] | undefined
             let best = pos
             if (c < 128) {
-              const bits = mask[c < 0 ? 128 : c]!
+              let bits = mask[c < 0 ? 128 : c]!
+              if ((bits & 1) !== 0 && p0 !== undefined && p0(input, pos) < 0) bits &= ~1
+              if ((bits & 2) !== 0 && p1 !== undefined && p1(input, pos) < 0) bits &= ~2
+              if ((bits & 4) !== 0 && p2 !== undefined && p2(input, pos) < 0) bits &= ~4
               let prev = 0
               if ((bits & 1) !== 0) {
                 ctx._fc = false
@@ -2796,7 +2856,7 @@ export function assemble(t: ResolvedTable, prog: TableProgram, cfg: RunCfg): Ass
               return FAIL
             }
 
-            if (g0 === null || classHas(g0, c)) {
+            if ((g0 === null || classHas(g0, c)) && (p0 === undefined || p0(input, pos) >= 0)) {
               ctx._fc = false
               const v = a0(input, pos, ctx)
               if (v !== FAIL) return v
@@ -2806,7 +2866,7 @@ export function assemble(t: ResolvedTable, prog: TableProgram, cfg: RunCfg): Ass
               if (committed(ctx)) { if (acc !== undefined) ctx._fx = acc; return FAIL }
               if (need) rollbackTriviaAt(ctx, mRaw, mTl, mLv, mFl, mEr, mLog, mRoot)
             } else if (best === pos) acc = accSet(e0, acc)
-            if (g1 === null || classHas(g1, c)) {
+            if ((g1 === null || classHas(g1, c)) && (p1 === undefined || p1(input, pos) >= 0)) {
               ctx._fc = false
               const v = a1(input, pos, ctx)
               if (v !== FAIL) return v
@@ -2817,7 +2877,7 @@ export function assemble(t: ResolvedTable, prog: TableProgram, cfg: RunCfg): Ass
               if (need) rollbackTriviaAt(ctx, mRaw, mTl, mLv, mFl, mEr, mLog, mRoot)
             } else if (best === pos) acc = accSet(e1, acc)
             if (n === 3) {
-              if (g2 === null || classHas(g2, c)) {
+              if ((g2 === null || classHas(g2, c)) && (p2 === undefined || p2(input, pos) >= 0)) {
                 ctx._fc = false
                 const v = a2!(input, pos, ctx)
                 if (v !== FAIL) return v
@@ -3432,6 +3492,7 @@ export function assemble(t: ResolvedTable, prog: TableProgram, cfg: RunCfg): Ass
         // grammar collapse form and the host collapse predicate.
         const keepChildren = !structural || cfg.hostReadsChildren !== false || collapse || unwrap
         const rawOnly = !keepChildren
+        const omitsRaw = !hostCst && build !== undefined && proj < 0 && (flags & 2) !== 0
         return (input, pos, ctx) => {
           const host = HOST
           // `beginCstNodeCapture`/`endCstNodeCapture` INLINED, and the two objects
@@ -3444,17 +3505,12 @@ export function assemble(t: ResolvedTable, prog: TableProgram, cfg: RunCfg): Ass
           // allocations a parse that the compiled engine (which inlines its own
           // capture prologue and epilogue) never makes.
           const sCh = ctx._cstChildren
-          const sLv = ctx._cstLeaves
-          const sRaw = ctx._cstRawChildren
-          const sTl = ctx._cstTriviaLog
           const sCap = ctx.captureTrivia
           const sBuf = ctx._cstBuf
-          const buf: CstCaptureBuf = rawOnly ? { rawOnly: true } : {}
+          const buf: CstCaptureBuf = rawOnly
+            ? { rawOnly: true }
+            : omitsRaw ? { noRaw: true, rawLen: 0 } : {}
           ctx._cstBuf = buf
-          ctx._cstChildren = undefined
-          ctx._cstLeaves = undefined
-          ctx._cstRawChildren = undefined
-          ctx._cstTriviaLog = undefined
           // `begin` sets this true and the caller immediately cleared it when the
           // node does not capture wide. Net: the flag IS `captureWide`, a const.
           ctx.captureTrivia = captureWide
@@ -3476,13 +3532,11 @@ export function assemble(t: ResolvedTable, prog: TableProgram, cfg: RunCfg): Ass
           if (structural) ctx._triviaCaptureMask = savedMask
           const kids = rawOnly ? EMPTY_CH : buf.ch ?? (buf.single !== undefined ? [buf.single] : EMPTY_CH)
           const hostKids = kids
-          const rawKids = buf.raw ?? (buf.rawSingle !== undefined ? [buf.rawSingle] : EMPTY_CH)
+          const rawKids = omitsRaw
+            ? EMPTY_CH
+            : buf.raw ?? (buf.rawSingle !== undefined ? [buf.rawSingle] : EMPTY_CH)
           const tlog = buf.tl ?? EMPTY_TLOG
           ctx._cstBuf = sBuf
-          ctx._cstChildren = sCh
-          ctx._cstLeaves = sLv
-          ctx._cstRawChildren = sRaw
-          ctx._cstTriviaLog = sTl
           ctx.captureTrivia = sCap
           if (v === FAIL) return FAIL
           const end = EC.e
@@ -3620,6 +3674,35 @@ export function assemble(t: ResolvedTable, prog: TableProgram, cfg: RunCfg): Ass
             rawScalarSpecs.add(code[child + 1]!)
             scalarFor(child)
           }
+        } else if (code[ip] === OP_CHOICE && !disp[code[ip + 1]!]!.exclusive) {
+          const n = code[ip + 2]!
+          for (let i = 0; i < n; i++) {
+            const armIp = code[ip + 4 + i]!
+            const child = leadingScalarTerminal(code, armIp, 2, true, true)
+            if (n === 2 || n === 3) {
+              if (child >= 0) scalarFor(child)
+              continue
+            }
+            if (child >= 0) {
+              const spec = k[code[child + 1]!]
+              if (code[child] === OP_LIT && typeof spec === 'string' && spec.length >= 2) {
+                scalarFor(child)
+                continue
+              }
+            }
+            const family = leadingLiteralFamily(code, k, armIp)
+            if (family !== undefined && family.length >= 2 && family.every(terminal => {
+              const value = k[code[terminal + 1]!]
+              return typeof value === 'string' && value.length >= 2
+            })) {
+              for (const terminal of family) scalarFor(terminal)
+            }
+            const sequence = leadingScalarSequence(code, armIp)
+            if (sequence !== undefined && (sequence.trivia < 0
+              || triviaScan[sequence.trivia] != null)) {
+              for (const terminal of sequence.terminals) scalarFor(terminal)
+            }
+          }
         }
       }
       const notChild = scalarTerminalNotChild(code, ip)

package/src/table/compile-rule-map.ts

@@ -116,16 +116,17 @@ export type CompiledRuleMapTable = {
   hostBranchElided: boolean
   reflection: GrammarReflection
   /**
-   * The RUNNABLE map, which the source lowering has no counterpart for — it
+   * The LIVE RUNNABLE map, which the source lowering has no counterpart for — it
    * hands back text and nothing else, because its artifact only exists once the
    * emitted source is evaluated. A table exists as data before it is printed, so
    * the same call that produces the replacement can also hand back the parser.
-   * That is what makes a differential against the interpreter possible without
-   * `eval`, and it is why the table-vs-interpreter test can compare `expected`
-   * sets rather than only accept/reject.
+   * It may use runtime assembly specialisation; `prog` and `replacement` remain
+   * serialized closure artifacts. That is what makes a differential against the
+   * interpreter possible without `eval`, and it is why the table-vs-interpreter
+   * test can compare `expected` sets rather than only accept/reject.
    */
   rules: Record<string, TableRule>
-  /** The encoded program, for a caller that wants to fold or inspect it. */
+  /** The closure-stamped wire program, for a caller that wants to fold or inspect it. */
   prog: TableProgram
   /**
    * The coverage DENOMINATOR — every id this map can hit — present only under
@@ -237,7 +238,7 @@ export function compileRuleMapRunnable(
     hostBranchElided: hostMode === 'ast' && ruleMap.some(([, rule]) => hasDirectBuildDef(rule)),
     reflection: collectGrammarReflection(ruleMap),
     ...(plan === undefined ? {} : { coverageDefinitions: plan.definitions }),
-    rules: tableRules(artifact),
+    rules: tableRules(prog),
     prog: artifact,
   }
 }
@@ -348,7 +349,7 @@ export function compileRuleMap(
     hostBranchElided: hostMode === 'ast' && ruleMap.some(([, rule]) => hasDirectBuildDef(rule)),
     reflection: collectGrammarReflection(ruleMap),
     ...(plan === undefined ? {} : { coverageDefinitions: plan.definitions }),
-    rules: tableRules(artifact),
+    rules: tableRules(prog),
     prog: artifact,
   }
 }

package/src/table/compile.ts

@@ -156,17 +156,16 @@ function compileImpl<T>(
   // this is the same guard on the single-root entry point.
   const { prog, fnSrcs } = encodeTableProgram({ [ENTRY]: combinator as Combinator<unknown> }, settings)
   /**
-   * `compile()` and the macro must hand the driver the SAME artifact shape.
+   * LIVE parsers may assemble the encoded program into specialised functions.
+   * `tableRules` falls back to closure assembly when dynamic construction is not
+   * available, so this remains runnable under a restrictive CSP.
    *
-   * An absent `asm` previously selected runtime `new Function` emission while
-   * macro output printed `a:[]` and selected closure assembly. That made one
-   * grammar have two normal execution paths. The compact table artifact is now
-   * canonical: both paths carry an explicit empty inventory and use the shared
-   * closure assembler. Static factories remain an opt-in experiment until they
-   * can satisfy both semantic identity and the size budget.
+   * PRINTED artifacts are different: they must not require `new Function` after
+   * import. Give the emitters the canonical explicit-empty assembly inventory,
+   * while the parser returned by this call runs the raw program's fast path.
    */
   const artifact = closureArtifact(prog)
-  const entry = tableRules(artifact)[ENTRY]!
+  const entry = tableRules(prog)[ENTRY]!
 
   // Captured-first, supplied-as-fill-in. The encoder records a source per author
   // callback from the def (`fnSrc` / `buildSrc` / `predSrc` / `gateSrcs`), which the