parseman 0.51.1 → 0.52.0

package/src/table/assemble.ts

@@ -80,7 +80,7 @@ import {
   type CstCaptureBuf,
 } from '../cst/capture-buffer.ts'
 import {
-  OP_CHOICE, OP_EMPTY, OP_GATE, OP_LEAF, OP_LIT, OP_NODE, OP_NOT, OP_OPT,
+  OP_CHOICE, OP_EMPTY, OP_GATE, OP_LEAF, OP_SOURCE_LEAF, OP_LIT, OP_NODE, OP_NOT, OP_OPT,
   OP_PEEK, OP_REP, OP_REPV, OP_RULE, OP_RX, OP_SEQ, OP_SEQV, OP_XFORM,
   OP_LIT_TRACK, OP_RX_TRACK, OP_NODE_TRACK, OP_SCOPE, OP_SCOPE_CAP, OP_SCOPE_PLAIN, OP_EXPECT, OP_SEQX, OP_SCAN,
   OP_LIVE,
@@ -523,8 +523,13 @@ export function assemble(t: ResolvedTable, prog: TableProgram, cfg: RunCfg): Ass
    * exact AST workloads execute the three shapes below 42k/66k/205k times per
    * CSS/Less/generated parse. Keep their bodies scalar and keep every other
    * shape on the generic oracle below.
+   *
+   * `trailing` is the node's `trailingTrivia` bit: consume the active trivia
+   * after a successful body, inside the node's span, exactly where the generic
+   * body does. It opens no capture: these shapes are the reducers that read no
+   * trivia log.
    */
-  function plainBuildNode(child: Piece, build: NodeBuilder): Piece {
+  function plainBuildNode(child: Piece, build: NodeBuilder, trailing: boolean): Piece {
     return (input, pos, ctx) => {
       const sCh = ctx._cstChildren
       const sLv = ctx._cstLeaves
@@ -542,6 +547,7 @@ export function assemble(t: ResolvedTable, prog: TableProgram, cfg: RunCfg): Ass
       ctx.captureTrivia = false
       ctx._fields = undefined
       const value = child(input, pos, ctx)
+      if (trailing && value !== FAIL && ctx.trivia !== undefined) EC.e = consumeTrivia(input, EC.e, ctx)
       const kids = buf.ch ?? (buf.single !== undefined ? [buf.single] : EMPTY_CH)
       const rawKids = buf.raw ?? (buf.rawSingle !== undefined ? [buf.rawSingle] : EMPTY_CH)
       ctx._fields = savedFields
@@ -578,7 +584,7 @@ export function assemble(t: ResolvedTable, prog: TableProgram, cfg: RunCfg): Ass
   /** Direct reducer whose declared arity proves `rawChildren` is unobservable.
    * Use the existing split children/leaves collector instead of opening a
    * duplicate raw capture buffer. The body shape is selected while linking. */
-  function childrenOnlyBuildNode(child: Piece, build: NodeBuilder): Piece {
+  function childrenOnlyBuildNode(child: Piece, build: NodeBuilder, trailing: boolean): Piece {
     return (input, pos, ctx) => {
       const sCh = ctx._cstChildren
       const sLv = ctx._cstLeaves
@@ -596,6 +602,7 @@ export function assemble(t: ResolvedTable, prog: TableProgram, cfg: RunCfg): Ass
       ctx.captureTrivia = false
       ctx._fields = undefined
       const value = child(input, pos, ctx)
+      if (trailing && value !== FAIL && ctx.trivia !== undefined) EC.e = consumeTrivia(input, EC.e, ctx)
       const captured = capturedFlatChildren(kids)
       ctx._fields = savedFields
       ctx._cstBuf = sBuf
@@ -1912,6 +1919,7 @@ export function assemble(t: ResolvedTable, prog: TableProgram, cfg: RunCfg): Ass
 
       case OP_ATTEMPT: {
         const child = link(code[ip + 1]!)
+        const contain = code[ip + 2] === 1
         return (input, pos, ctx) => {
           const need = markCst(ctx)
           const mRaw = MRAW
@@ -1924,8 +1932,12 @@ export function assemble(t: ResolvedTable, prog: TableProgram, cfg: RunCfg): Ass
           const v = child(input, pos, ctx)
           if (v !== FAIL) return v
           if (need) rollbackTriviaAt(ctx, mRaw, mTl, mLv, mFl, mEr, mLog, mRoot)
-          // A committed failure propagates VERBATIM — rolled back, not re-anchored.
-          if (committed(ctx)) return FAIL
+          // A committed failure propagates VERBATIM — rolled back, not re-anchored —
+          // unless the row contains commitment, where it is reported like any other.
+          if (committed(ctx)) {
+            if (!contain) return FAIL
+            ctx._fc = false
+          }
           ctx._fe = pos
           return FAIL
         }
@@ -2149,7 +2161,8 @@ export function assemble(t: ResolvedTable, prog: TableProgram, cfg: RunCfg): Ass
         }
       }
 
-      case OP_LEAF: {
+      case OP_LEAF:
+      case OP_SOURCE_LEAF: {
         const fn = fns[code[ip + 1]!] as (value: unknown, span: { start: number; end: number }) => unknown
         const child = link(code[ip + 2]!)
         return (input, pos, ctx) => {
@@ -2179,7 +2192,11 @@ export function assemble(t: ResolvedTable, prog: TableProgram, cfg: RunCfg): Ass
           if (v === FAIL) return FAIL
           const end = EC.e
           const out = fn(v, { start: pos, end })
-          if (wasCapturing) pushCstLeaf(ctx, { _tag: 'leaf', value: out, span: { start: pos, end } })
+          if (wasCapturing) pushCstLeaf(ctx, {
+            _tag: 'leaf',
+            value: op === OP_SOURCE_LEAF && hostCst ? input.slice(pos, end) : out,
+            span: { start: pos, end },
+          })
           EC.e = end
           return out
         }
@@ -3457,11 +3474,13 @@ export function assemble(t: ResolvedTable, prog: TableProgram, cfg: RunCfg): Ass
         // data plus this assembly's fixed option set; direct/custom contexts and
         // every richer node shape retain the generic implementation below.
         if (!hostCst && !tracked) {
-          if (build !== undefined && proj < 0 && flags === 0) {
-            return plainBuildNode(child, build)
+          // The trailing-trivia bit (128) rides on the two leanest shapes; it adds
+          // a consume, not a capture.
+          if (build !== undefined && proj < 0 && (flags & ~128) === 0) {
+            return plainBuildNode(child, build, trailingTrivia)
           }
-          if (build !== undefined && proj < 0 && flags === 2) {
-            return childrenOnlyBuildNode(child, build)
+          if (build !== undefined && proj < 0 && (flags & ~128) === 2) {
+            return childrenOnlyBuildNode(child, build, trailingTrivia)
           }
           if (build !== undefined && proj < 0 && flags === 18) {
             return childrenOnlyFieldsBuildNode(child, build)

package/src/table/child-slots.ts

@@ -1,6 +1,6 @@
 import {
   OP_ADJ, OP_ARMGATE, OP_ATTEMPT, OP_CHOICE, OP_COV, OP_DISPATCH, OP_EMPTY, OP_EXPECT,
-  OP_FIELD, OP_GATE, OP_GREEDY, OP_GUARD, OP_LABEL, OP_LEAF, OP_LIT, OP_LIT_CI,
+  OP_FIELD, OP_GATE, OP_GREEDY, OP_GUARD, OP_LABEL, OP_LEAF, OP_SOURCE_LEAF, OP_LIT, OP_LIT_CI,
   OP_LIT_CI_TRACK, OP_LIT_TRACK, OP_LIVE, OP_NODE, OP_NODE_TRACK, OP_NOT, OP_OPT,
   OP_PEEK, OP_REJECT, OP_REP, OP_REPV, OP_ROUTED, OP_RULE, OP_RX, OP_RX_TRACK, OP_SCAN,
   OP_SCOPE, OP_SCOPE_CAP, OP_SCOPE_PLAIN, OP_SEQ, OP_SEQV, OP_SEQX, OP_TOKEN, OP_WITHCTX, OP_XFORM,
@@ -55,7 +55,7 @@ export function childSlots(code: ArrayLike<number>, ip: number, out: number[]):
 
     // Single child at `ip + 2`.
     case OP_GATE: case OP_SCOPE: case OP_SCOPE_CAP: case OP_SCOPE_PLAIN: case OP_WITHCTX: case OP_XFORM:
-    case OP_NODE: case OP_NODE_TRACK: case OP_FIELD: case OP_LEAF: case OP_ARMGATE:
+    case OP_NODE: case OP_NODE_TRACK: case OP_FIELD: case OP_LEAF: case OP_SOURCE_LEAF: case OP_ARMGATE:
       out.push(code[ip + 2]!)
       return true
 

package/src/table/emit-assembly.ts

@@ -48,7 +48,7 @@ import type { ParseContext } from '../types.ts'
 import { regexCanMatchEmpty } from '../regex/first-set.ts'
 import {
   OP_ADJ, OP_ATTEMPT, OP_CHOICE, OP_DISPATCH, OP_EMPTY, OP_EXPECT, OP_FIELD, OP_GATE,
-  OP_LABEL, OP_LEAF, OP_LIT, OP_LIT_CI, OP_LIT_CI_TRACK, OP_LIT_TRACK, OP_NAMES,
+  OP_LABEL, OP_LEAF, OP_SOURCE_LEAF, OP_LIT, OP_LIT_CI, OP_LIT_CI_TRACK, OP_LIT_TRACK, OP_NAMES,
   OP_NODE, OP_NODE_TRACK, OP_NOT, OP_OPT, OP_PEEK, OP_REP, OP_REPV, OP_ROUTED, OP_RULE, OP_RX,
   OP_RX_TRACK, OP_SCAN, OP_SCOPE, OP_SCOPE_CAP, OP_SCOPE_PLAIN, OP_SEQ, OP_SEQV, OP_SEQX, OP_TOKEN, OP_XFORM,
   OP_LEX_BODY, OP_LEX_PROGRAM,
@@ -1411,8 +1411,10 @@ ${rootCap ? 'ctx._rootTriviaCapture=sR\n' : ''}return v
       /* ── boundaries ──────────────────────────────────────────────────────── */
 
       case OP_TOKEN:
-      case OP_LEAF: {
+      case OP_LEAF:
+      case OP_SOURCE_LEAF: {
         const isToken = op === OP_TOKEN
+        const capturesSource = isToken || (op === OP_SOURCE_LEAF && hostCst)
         const fn = isToken ? undefined : fnRef(code[ip + 1]!)
         const child = link(isToken ? code[ip + 1]! : code[ip + 2]!)
         // `try`/`finally`, AS `assemble.ts` HAS IT. `OP_SCOPE` restores linearly
@@ -1460,7 +1462,7 @@ ctx._triviaLog=sOtl
 if(v===FAIL)return FAIL
 const e=EC.e
 const out=${isToken ? 'input.slice(pos,e)' : `${fn}(v,{start:pos,end:e})`}
-if(wasCap)pushCstLeaf(ctx,{_tag:'leaf',value:out,span:{start:pos,end:e}})
+if(wasCap)pushCstLeaf(ctx,{_tag:'leaf',value:${capturesSource ? 'input.slice(pos,e)' : 'out'},span:{start:pos,end:e}})
 EC.e=e
 return out
 }`
@@ -1550,7 +1552,7 @@ ${clean ? '' : emitMark(p, L.buf, L.raw, sinks)}
 const v=${child}(input,pos,ctx)
 if(v!==FAIL)return v
 ${clean ? '' : emitRollback(p, L.buf, L.raw, sinks)}
-if(ctx._fc===true)return FAIL
+${code[ip + 2] === 1 ? 'ctx._fc=false' : 'if(ctx._fc===true)return FAIL'}
 ctx._fe=pos
 return FAIL
 }`
@@ -2332,8 +2334,11 @@ return nd
         // not closure-only semantics. Print the same body for a precompiled
         // assembly so a large composeLeaf artifact does not fall back to opening
         // the generic raw/trivia buffer that its reducer arity proved unread.
+        // The trailing-trivia bit (128) rides on the children-only shape as it
+        // does in the closure assembler: a consume after the body, no capture.
+        const leanFlags = flags & ~128
         if (!hostCst && !tracked && build !== undefined && proj < 0
-          && (flags === 2 || flags === 18 || flags === 34)) {
+          && (leanFlags === 2 || (flags === 18 || flags === 34))) {
           const fields = flags === 18
           const collapseChildren = flags === 34
           const publish = L.buf && L.raw === RAW_OMIT
@@ -2380,7 +2385,9 @@ ctx._cstTriviaLog=undefined
 ctx.captureTrivia=false
 ctx._fields=${fields ? '[]' : 'undefined'}
 const v=${child}(input,pos,ctx)
-const captured=_capturedFlatChildren(flat)
+${trailingTrivia && L.tri !== TRI_NONE
+  ? `if(v!==FAIL${L.tri === TRI_UNKNOWN ? '&&ctx.trivia!==undefined' : ''})EC.e=consumeTrivia(input,EC.e,ctx)\n`
+  : ''}const captured=_capturedFlatChildren(flat)
 ${fields ? 'const fieldMap=buildFieldMap(ctx._fields)\n' : ''}ctx._fields=sFields
 ctx._cstBuf=sBuf
 ctx._cstChildren=sCh

package/src/table/encode-baseline.ts

@@ -3,7 +3,7 @@ import { firstSetOf, matchesEmpty } from '../combinators/first-set.ts'
 import { deriveExpected } from '../combinators/expect.ts'
 import { buildReadsState, buildReadsTrivia } from '../compiler/build-arity.ts'
 import {
-  OP_CHOICE, OP_EMPTY, OP_GATE, OP_LEAF, OP_LIT, OP_NODE, OP_NOT, OP_OPT,
+  OP_CHOICE, OP_EMPTY, OP_GATE, OP_LEAF, OP_SOURCE_LEAF, OP_LIT, OP_NODE, OP_NOT, OP_OPT,
   OP_PEEK, OP_REP, OP_REPV, OP_RULE, OP_RX, OP_SEQ, OP_SEQV, OP_XFORM,
   OP_LIT_TRACK, OP_RX_TRACK, OP_NODE_TRACK, OP_SCOPE, OP_EXPECT,
 } from './ops.ts'
@@ -265,7 +265,7 @@ class Encoder {
       }
       case 'leaf': {
         const child = this.node(d.parser).ip
-        return this.emit(OP_LEAF, this.fn(d.fn), child)
+        return this.emit(d.cstValue === 'source' ? OP_SOURCE_LEAF : OP_LEAF, this.fn(d.fn), child)
       }
       case 'node': {
         if (d.unwrap || d.collapse || d.project !== undefined) throw new UnsupportedConstructBaseline('node(unwrap|collapse|project)')
@@ -295,9 +295,13 @@ class Encoder {
         return this.emit(OP_NOT, this.node(d.parser).ip)
       case 'peek':
         return this.emit(OP_PEEK, this.node(d.parser).ip)
+      // A contained transaction changes what an enclosing choice does next, so
+      // it cannot be transparent.
+      case 'attempt':
+        if (d.contain === true) throw new UnsupportedConstructBaseline('attempt(contain)')
+        return this.node(d.parser).ip
       // Transparent wrappers: no row of their own, no dispatch at run time.
       case 'token':
-      case 'attempt':
       case 'label':
       case 'trivia':
         return this.node(d.parser).ip
@@ -319,6 +323,7 @@ class Encoder {
       code: this.code, k: this.k, fns: this.fns, cc: this.cc,
       fx: this.fx, disp: this.disp, dsp: [], rules: this.rules,
       lines: this.track ? 1 : 0,
+      ...(this.settings.hostMode === undefined ? {} : { hostMode: this.settings.hostMode }),
     }
   }
 }

package/src/table/encode.ts

@@ -9,7 +9,7 @@ import { buildReadsRaw, buildReadsState, buildReadsTrivia } from '../compiler/bu
 import { buildReadsFields, parserHasOwnFields } from '../compiler/fields.ts'
 import { asciiFoldKey, branchUsesRouted, parserUsesRouted } from '../combinators/dispatch.ts'
 import {
-  OP_CHOICE, OP_EMPTY, OP_GATE, OP_LEAF, OP_LIT, OP_NODE, OP_NOT, OP_OPT,
+  OP_CHOICE, OP_EMPTY, OP_GATE, OP_LEAF, OP_SOURCE_LEAF, OP_LIT, OP_NODE, OP_NOT, OP_OPT,
   OP_PEEK, OP_REP, OP_REPV, OP_RULE, OP_RX, OP_SEQ, OP_SEQV, OP_XFORM,
   OP_LIT_TRACK, OP_RX_TRACK, OP_NODE_TRACK, OP_SCOPE, OP_SCOPE_CAP, OP_SCOPE_PLAIN, OP_EXPECT, OP_SEQX, OP_SCAN,
   OP_LIVE, OP_ATTEMPT, OP_LABEL,
@@ -1322,7 +1322,7 @@ class Encoder {
       }
       case 'leaf': {
         const child = this.node(d.parser).ip
-        return this.emit(OP_LEAF, this.fn(d.fn, d.fnSrc ?? null), child)
+        return this.emit(d.cstValue === 'source' ? OP_SOURCE_LEAF : OP_LEAF, this.fn(d.fn, d.fnSrc ?? null), child)
       }
       case 'node': {
         // A node legally has NO builder when its value comes from a selection:
@@ -1344,24 +1344,24 @@ class Encoder {
         // 'cst'` forces them on, exactly as the emitted `cstOut` path does. The
         // driver reads a bit; it re-derives nothing and sees no setting.
         const cstOut = this.settings.hostMode === 'cst'
-        // THE THREE DERIVED CAPTURE BITS, mirroring `node.ts:215` term for term:
+        // THE THREE DERIVED CAPTURE BITS, mirroring `node.ts` term for term:
         //
-        //   capturesTrivia = captureTrivia || trailingTrivia
+        //   capturesTrivia = captureTrivia
         //                    || (build ? buildReadsTrivia(def) : project === undefined)
         //
         // `cstOut` is the static stand-in for "a CST host is coming", which the
         // interpreter reaches dynamically off `ctx.build`.
         //
-        // Two of these terms were MISSING and each was a real divergence:
+        // `captureTrivia` was once MISSING here and was a real divergence: an
+        // explicit request the arity analysis cannot express (an author can ask
+        // for capture on a 3-argument reducer). This used to REFUSE rather than
+        // lower, so a documented option no grammar could use through the table.
         //
-        //   `captureTrivia` — an explicit request the arity analysis cannot
-        //     express (an author can ask for capture on a 3-argument reducer).
-        //     This used to REFUSE rather than lower, so a documented option no
-        //     grammar could use through the table.
-        //   `trailingTrivia` — trivia consumed INSIDE the node's capture scope
-        //     lands in THIS node's log. The interpreter counts it; the table did
-        //     not, so a node with `trailingTrivia` and a non-trivia-reading
-        //     reducer captured under the interpreter and dropped under the table.
+        // `trailingTrivia` is NOT a capture term (bit 128 only). It moves the
+        // node's end past the trivia after the body; that trivia reaches the root
+        // table with or without a node log, and only a log the reducer reads is
+        // worth opening. Forcing bit 4 for it put every match of a
+        // non-trivia-reading node on the generic capture path.
         //
         // The `build ? … : project === undefined` split matters now that a
         // STRUCTURAL node lowers: with no builder the interpreter captures unless
@@ -1374,7 +1374,7 @@ class Encoder {
         // Field capture additionally requires the body to CONTAIN `field()`
         // captures: a node that reads fields but has none allocates nothing.
         const wantsFields = parserHasOwnFields(d.parser) && (cstOut || derivedFields)
-        const flags = (cstOut || d.captureTrivia === true || d.trailingTrivia === true || derivedTrivia ? 4 : 0)
+        const flags = (cstOut || d.captureTrivia === true || derivedTrivia ? 4 : 0)
           | (!cstOut && omitsRaw ? 2 : 0)
           | (cstOut || derivedState ? 8 : 0)
           | (wantsFields ? 16 : 0)
@@ -1596,7 +1596,7 @@ class Encoder {
       // A TRANSACTION IS A ROW. See `OP_ATTEMPT` for why the transparent
       // lowering was correct only for a choice arm.
       case 'attempt': {
-        const inner = this.emit(OP_ATTEMPT, this.node(d.parser).ip)
+        const inner = this.emit(OP_ATTEMPT, this.node(d.parser).ip, d.contain === true ? 1 : 0)
         if (!this.failureNeedsRollback(d.parser, undefined)) this.failureRollbackCleanSites.add(inner)
         // THE FIRST-SET FAIL-FAST GUARD, lowered as the `OP_GATE` row the `node()`
         // case already uses — it is the same guard, written twice in the
@@ -1737,7 +1737,7 @@ class Encoder {
       switch (this.code[ip]) {
         case OP_GATE: return [ip + 2]
         case OP_RULE: case OP_OPT: case OP_NOT: case OP_PEEK: case OP_EXPECT: case OP_ATTEMPT: case OP_LABEL: case OP_COV: return [ip + 1]
-        case OP_SCOPE: case OP_SCOPE_CAP: case OP_SCOPE_PLAIN: case OP_WITHCTX: case OP_XFORM: case OP_LEAF: case OP_NODE: case OP_NODE_TRACK: return [ip + 2]
+        case OP_SCOPE: case OP_SCOPE_CAP: case OP_SCOPE_PLAIN: case OP_WITHCTX: case OP_XFORM: case OP_LEAF: case OP_SOURCE_LEAF: case OP_NODE: case OP_NODE_TRACK: return [ip + 2]
         case OP_SEQ: case OP_SEQV: return Array.from({ length: this.code[ip + 1]! }, (_, i) => ip + 2 + i)
         case OP_SEQX: return Array.from({ length: this.code[ip + 2]! }, (_, i) => ip + 3 + i)
         // ARMS START AT ip+4. `ip+3` is the choice's own EXPECTED-SET index, and

package/src/table/exec-baseline.ts

@@ -5,7 +5,7 @@ import {
   pushCstLeaf, rollbackCstCapture, saveCstMark, type CstRollbackMark,
 } from '../cst/capture-buffer.ts'
 import {
-  OP_CHOICE, OP_EMPTY, OP_GATE, OP_LEAF, OP_LIT, OP_NODE, OP_NOT, OP_OPT,
+  OP_CHOICE, OP_EMPTY, OP_GATE, OP_LEAF, OP_SOURCE_LEAF, OP_LIT, OP_NODE, OP_NOT, OP_OPT,
   OP_PEEK, OP_REP, OP_REPV, OP_RULE, OP_RX, OP_SEQ, OP_SEQV, OP_XFORM,
   OP_LIT_TRACK, OP_RX_TRACK, OP_NODE_TRACK, OP_SCOPE, OP_EXPECT,
 } from './ops.ts'
@@ -94,6 +94,7 @@ function makeDriver(
   cc: readonly ResolvedClass[],
   fx: readonly (readonly string[])[],
   disp: readonly ResolvedDispatch[],
+  hostCst: boolean,
 ): Driver {
   /** Shared end-position out-parameter (`_pfEnd` in emitted code). */
   let END = 0
@@ -434,12 +435,37 @@ function makeDriver(
         return fn(v, { start: pos, end: END })
       }
 
-      case OP_LEAF: {
-        const v = exec(code[ip + 2]!, input, pos, ctx)
+      case OP_LEAF:
+      case OP_SOURCE_LEAF: {
+        const sBuf = ctx._cstBuf, sChildren = ctx._cstChildren, sLeaves = ctx._cstLeaves
+        const sRaw = ctx._cstRawChildren, sTl = ctx._cstTriviaLog
+        const sOuterTl = ctx._triviaLog
+        const wasCapturing = cstCaptureActive(ctx)
+        ctx._cstBuf = undefined
+        ctx._cstChildren = undefined
+        ctx._cstLeaves = undefined
+        ctx._cstRawChildren = undefined
+        ctx._cstTriviaLog = undefined
+        ctx._triviaLog = undefined
+        let v: unknown
+        try { v = exec(code[ip + 2]!, input, pos, ctx) }
+        finally {
+          ctx._cstBuf = sBuf
+          ctx._cstChildren = sChildren
+          ctx._cstLeaves = sLeaves
+          ctx._cstRawChildren = sRaw
+          ctx._cstTriviaLog = sTl
+          ctx._triviaLog = sOuterTl
+        }
         if (v === FAIL) return FAIL
         const end = END
         const fn = fns[code[ip + 1]!] as (value: unknown, span: { start: number; end: number }) => unknown
         const out = fn(v, { start: pos, end })
+        if (wasCapturing) pushCstLeaf(ctx, {
+          _tag: 'leaf',
+          value: code[ip] === OP_SOURCE_LEAF && hostCst ? input.slice(pos, end) : out,
+          span: { start: pos, end },
+        })
         END = end
         return out
       }
@@ -509,7 +535,7 @@ function makeDriver(
 export function execRulesBaseline(source: TableProgram | CompactProgram): Record<string, TableRule> {
   const prog = expandCompact(source)
   const t = resolveTable(prog)
-  const d = makeDriver(t.code, t.k, t.fns, t.cc, t.fx, t.disp)
+  const d = makeDriver(t.code, t.k, t.fns, t.cc, t.fx, t.disp, prog.hostMode === 'cst')
   const out: Record<string, TableRule> = {}
   // Chosen ONCE, from table data, at rule-map construction. Not a per-parse
   // branch on an option: a plain table never has this wrapper at all.

package/src/table/exec.ts

@@ -15,7 +15,7 @@ import {
   demoteCapturedToRaw, endCstNodeCapture, pushCstChild, pushCstLeaf,
 } from '../cst/capture-buffer.ts'
 import {
-  OP_CHOICE, OP_EMPTY, OP_GATE, OP_LEAF, OP_LIT, OP_NODE, OP_NOT, OP_OPT,
+  OP_CHOICE, OP_EMPTY, OP_GATE, OP_LEAF, OP_SOURCE_LEAF, OP_LIT, OP_NODE, OP_NOT, OP_OPT,
   OP_PEEK, OP_REP, OP_REPV, OP_RULE, OP_RX, OP_SEQ, OP_SEQV, OP_XFORM,
   OP_LIT_TRACK, OP_RX_TRACK, OP_NODE_TRACK, OP_SCOPE, OP_SCOPE_CAP, OP_SCOPE_PLAIN, OP_EXPECT, OP_SEQX, OP_SCAN,
   OP_LIVE,
@@ -1371,7 +1371,8 @@ function makeDriver(
         return fn(v, { start: pos, end: EC.e })
       }
 
-      case OP_LEAF: {
+      case OP_LEAF:
+      case OP_SOURCE_LEAF: {
         // Mirrors src/combinators/token.ts:89-127. `leaf()` is a CAPTURE
         // BOUNDARY: it suppresses the interior's own CST captures and exposes
         // exactly ONE leaf carrying the reducer's value. Running the interior
@@ -1410,7 +1411,11 @@ function makeDriver(
         const fn = fns[code[ip + 1]!] as (value: unknown, span: { start: number; end: number }) => unknown
         if (COUNT) siteFn('LEAF fn()', fn)
         const out = fn(v, { start: pos, end })
-        if (wasCapturing) pushCstLeaf(ctx, { _tag: 'leaf', value: out, span: { start: pos, end } })
+        if (wasCapturing) pushCstLeaf(ctx, {
+          _tag: 'leaf',
+          value: code[ip] === OP_SOURCE_LEAF && HOSTCST ? input.slice(pos, end) : out,
+          span: { start: pos, end },
+        })
         EC.e = end
         return out
       }
@@ -1530,7 +1535,8 @@ function makeDriver(
         // `attempt()` verbatim: mark, run, and on failure restore every capture
         // sink and re-anchor the report at the transaction's entry. A COMMITTED
         // failure is still rolled back and then propagated untouched — the
-        // interpreter returns `result` itself on that branch.
+        // interpreter returns `result` itself on that branch — unless the row
+        // contains commitment (`k`), where it is reported like any other failure.
         const need = rollbackNeeded(ctx)
         const mRaw = need ? cstRawLen(ctx) : 0
         const mTl = need ? cstTlLen(ctx) : 0
@@ -1542,7 +1548,10 @@ function makeDriver(
         const v = exec(code[ip + 1]!, input, pos, ctx)
         if (v !== FAIL) return v
         if (need) rollbackTriviaAt(ctx, mRaw, mTl, mLv, mFl, mEr, mLog, mRoot)
-        if (ctx._fc === true) return FAIL
+        if (ctx._fc === true) {
+          if (code[ip + 2] !== 1) return FAIL
+          ctx._fc = false
+        }
         ctx._fe = pos
         return FAIL
       }

package/src/table/ops.ts

@@ -378,7 +378,9 @@ export const OP_ARMGATE = 36
  */
 export const OP_LIVE = 37
 /**
- * `ATTEMPT c` — `attempt()`, the transactional ordered-choice arm.
+ * `ATTEMPT c k` — `attempt()`, the transactional ordered-choice arm. `k` is 1
+ * for `attempt(p, { contain: true })`: a committed inner failure is reported
+ * uncommitted — `_fc` cleared and `_fe` re-anchored, like any other failure.
  *
  * WAS A TRANSPARENT WRAPPER (`case 'attempt': return this.node(d.parser).ip`),
  * which is correct for exactly one placement — an arm of an `OP_CHOICE`, whose
@@ -389,10 +391,10 @@ export const OP_LIVE = 37
  * re-anchored at the transaction's entry. Both are `attempt()`'s whole contract
  * (`combinators/attempt.ts`), not a choice-arm detail.
  *
- * One child operand and no expected-set operand: on a non-committed inner
- * failure the row keeps the inner's `_fx` VERBATIM and only re-anchors `_fe` to
- * `pos`, exactly as `attempt.ts` returns `{ expected: result.expected, span:
- * { start: pos, end: pos } }`. A committed failure propagates untouched — the
+ * No expected-set operand: on a non-committed inner failure the row keeps the
+ * inner's `_fx` VERBATIM and only re-anchors `_fe` to `pos`, exactly as
+ * `attempt.ts` returns `{ expected: result.expected, span: { start: pos, end:
+ * pos } }`. A committed failure propagates untouched when `k` is 0 — the
  * rollback still happens, the re-anchor does not.
  *
  * The interpreter's first-set fail-fast guard is NOT lowered. It is an
@@ -469,6 +471,8 @@ export const OP_SCOPE_PLAIN = 41
 export const OP_LEX_BODY = 42
 /** `LEX_PROGRAM p` — selected fixed composite lexical body, childless. */
 export const OP_LEX_PROGRAM = 43
+/** `SOURCE_LEAF f c` — `sourceLeaf()`: reduce semantically, capture source text. */
+export const OP_SOURCE_LEAF = 44
 /**
  * `DISPATCH sel d other otherRouted n a1 … an` — `dispatch()`.
  *
@@ -492,7 +496,7 @@ export const OP_NAMES: Record<number, string> = {
   [OP_LIT]: 'LIT', [OP_RX]: 'RX', [OP_SEQ]: 'SEQ', [OP_SEQV]: 'SEQV',
   [OP_CHOICE]: 'CHOICE', [OP_REP]: 'REP', [OP_REPV]: 'REPV', [OP_OPT]: 'OPT',
   [OP_XFORM]: 'XFORM', [OP_NODE]: 'NODE', [OP_RULE]: 'RULE', [OP_GATE]: 'GATE',
-  [OP_NOT]: 'NOT', [OP_PEEK]: 'PEEK', [OP_LEAF]: 'LEAF', [OP_EMPTY]: 'EMPTY',
+  [OP_NOT]: 'NOT', [OP_PEEK]: 'PEEK', [OP_LEAF]: 'LEAF', [OP_SOURCE_LEAF]: 'SOURCE_LEAF', [OP_EMPTY]: 'EMPTY',
   [OP_LIT_TRACK]: 'LIT_TRACK', [OP_RX_TRACK]: 'RX_TRACK', [OP_NODE_TRACK]: 'NODE_TRACK',
   [OP_SCOPE]: 'SCOPE', [OP_EXPECT]: 'EXPECT', [OP_SEQX]: 'SEQX', [OP_SCAN]: 'SCAN',
   [OP_FIELD]: 'FIELD', [OP_LIT_CI]: 'LIT_CI', [OP_LIT_CI_TRACK]: 'LIT_CI_TRACK', [OP_DISPATCH]: 'DISPATCH', [OP_ROUTED]: 'ROUTED',

package/src/table/scalar-terminal.ts

@@ -1,5 +1,5 @@
 import {
-  OP_ATTEMPT, OP_CHOICE, OP_FIELD, OP_GATE, OP_LABEL, OP_LEAF, OP_LIT, OP_NODE, OP_NOT,
+  OP_ATTEMPT, OP_CHOICE, OP_FIELD, OP_GATE, OP_LABEL, OP_LEAF, OP_SOURCE_LEAF, OP_LIT, OP_NODE, OP_NOT,
   OP_PEEK, OP_RULE, OP_RX, OP_SCOPE, OP_SCOPE_CAP, OP_SCOPE_PLAIN, OP_SEQ, OP_SEQV,
   OP_SEQX, OP_TOKEN, OP_XFORM,
 } from './ops.ts'
@@ -86,7 +86,7 @@ export function leadingScalarTerminal(
       continue
     }
     if (op === OP_GATE || op === OP_SCOPE || op === OP_SCOPE_CAP || op === OP_SCOPE_PLAIN
-      || op === OP_XFORM || op === OP_NODE || op === OP_FIELD || op === OP_LEAF) {
+      || op === OP_XFORM || op === OP_NODE || op === OP_FIELD || (op === OP_LEAF || op === OP_SOURCE_LEAF)) {
       at = code[at + 2]!
       depth++
       continue
@@ -139,7 +139,7 @@ export function leadingScalarSequence(
         continue
       }
       if (op === OP_GATE || op === OP_SCOPE_PLAIN
-        || op === OP_XFORM || op === OP_NODE || op === OP_FIELD || op === OP_LEAF) {
+        || op === OP_XFORM || op === OP_NODE || op === OP_FIELD || (op === OP_LEAF || op === OP_SOURCE_LEAF)) {
         at = code[at + 2]!
         continue
       }
@@ -173,7 +173,7 @@ export function leadingScalarSequence(
       at = code[at + 2]!
       continue
     }
-    if (op === OP_GATE || op === OP_XFORM || op === OP_NODE || op === OP_FIELD || op === OP_LEAF) {
+    if (op === OP_GATE || op === OP_XFORM || op === OP_NODE || op === OP_FIELD || (op === OP_LEAF || op === OP_SOURCE_LEAF)) {
       at = code[at + 2]!
       continue
     }
@@ -220,7 +220,7 @@ export function leadingLiteralFamily(
         return walk(code[at + 1]!, depth + 1)
       }
       if (op === OP_GATE || op === OP_SCOPE || op === OP_SCOPE_CAP || op === OP_SCOPE_PLAIN
-        || op === OP_XFORM || op === OP_NODE || op === OP_FIELD || op === OP_LEAF) {
+        || op === OP_XFORM || op === OP_NODE || op === OP_FIELD || (op === OP_LEAF || op === OP_SOURCE_LEAF)) {
         return walk(code[at + 2]!, depth + 1)
       }
       if (op === OP_SEQ || op === OP_SEQV) {

package/src/table/site-labels.ts

@@ -60,7 +60,7 @@
  * label licenses at a leaf is dropping the TEST — never the capture.
  */
 import {
-  OP_ATTEMPT, OP_CHOICE, OP_DISPATCH, OP_EXPECT, OP_FIELD, OP_GATE, OP_LABEL, OP_LEAF,
+  OP_ATTEMPT, OP_CHOICE, OP_DISPATCH, OP_EXPECT, OP_FIELD, OP_GATE, OP_LABEL, OP_LEAF, OP_SOURCE_LEAF,
   OP_NODE, OP_NODE_TRACK, OP_NOT, OP_OPT, OP_PEEK, OP_REP, OP_REPV, OP_ROUTED, OP_RULE,
   OP_SCOPE, OP_SCOPE_CAP, OP_SCOPE_PLAIN, OP_SEQ, OP_SEQV, OP_SEQX, OP_TOKEN, OP_XFORM,
 } from './ops.ts'
@@ -159,8 +159,10 @@ function transfer(code: Int32Array, ip: number, at: SiteLabel, hostCst: boolean)
   }
   if (op === OP_NODE || op === OP_NODE_TRACK) {
     const flags = code[ip + 3]!
+    // The same selection `emit-assembly.ts` makes: the trailing-trivia bit (128)
+    // keeps the children-only shape.
     const directChildren = !hostCst && op === OP_NODE && code[ip + 1]! >= 0 && code[ip + 4]! < 0
-      && (flags === 2 || flags === 18 || flags === 34)
+      && ((flags & ~128) === 2 || flags === 18 || flags === 34)
     if (directChildren) {
       // The confirmed low-arity builder projection installs split child/leaf
       // arrays instead of a CstCaptureBuf. Descendants still capture, but they
@@ -193,7 +195,7 @@ function transfer(code: Int32Array, ip: number, at: SiteLabel, hostCst: boolean)
     if (at.tri === TRI_NONE && !at.buf) return at
     return { tri: TRI_NONE, buf: false, raw: RAW_UNKNOWN, cap: at.cap }
   }
-  if (op === OP_LEAF) {
+  if (op === OP_LEAF || op === OP_SOURCE_LEAF) {
     if (!at.buf) return at
     return { tri: at.tri, buf: false, raw: RAW_UNKNOWN, cap: at.cap }
   }

package/src/types.ts

@@ -1,3 +1,5 @@
+import type { LabeledTriviaSpec } from './cst/trivia-kinds.ts'
+
 export type Span = {
   start: number
   end: number
@@ -56,7 +58,7 @@ export type ParserDef =
   // closures live in `gates`.
   | { tag: 'choice';    parsers: Combinator<unknown>[]; gates: (((state: unknown) => boolean) | null)[]; gateSrcs?: (string | null)[]; disjoint: boolean; strategy: ChoiceStrategy; autoNot: (AutoNotCheck[] | null)[] }
   | { tag: 'dispatch';  selector: Combinator<string>; cases: readonly DispatchCase[]; matchers?: readonly DispatchMatcherCase[] | undefined; otherwise?: Combinator<unknown> | undefined; otherwiseUsesRouted?: boolean | undefined }
-  | { tag: 'attempt';   parser: Combinator<unknown> }
+  | { tag: 'attempt';   parser: Combinator<unknown>; /** `attempt(p, { contain: true })`: a committed failure inside is reported uncommitted. */ contain?: true }
   // The TAG carries NULLABILITY (what every downstream switch keys on): `many` is
   // the nullable min-0 repeat, `oneOrMore` the non-nullable min>=1 one. `min`/`max`
   // carry the actual ITEM bounds (`many(x, { min: 3, max: 8 })` is a `oneOrMore`
@@ -79,7 +81,7 @@ export type ParserDef =
   // selector matched). It exists so ONE production can serve both contexts instead of
   // being spelled twice — a `routed()` twin and a concrete-lead original.
   | { tag: 'routed';    fallback?: Combinator<unknown> }
-  | { tag: 'leaf';      parser: Combinator<unknown>; fn: (v: unknown, span: { start: number; end: number }) => unknown; fnSrc?: string }
+  | { tag: 'leaf';      parser: Combinator<unknown>; fn: (v: unknown, span: { start: number; end: number }) => unknown; fnSrc?: string; cstValue?: 'source' }
   | { tag: 'label';     label: string; parser: Combinator<unknown> }
   | { tag: 'field';     name: string; parser: Combinator<unknown> }
   | { tag: 'grammar';   parser: Combinator<unknown>; triviaParser: Combinator<unknown> | undefined; clearTrivia?: boolean; captureTrivia?: boolean; rootCapture?: 'opaque'; trackLines: boolean; constructionTrackLines?: 'on' | 'off' | 'inherit'; constructionCaptureTriviaKinds?: readonly string[] }
@@ -433,6 +435,11 @@ export type ParserMeta = {
   isTrivia: boolean
   /** User-defined labels for labeled trivia arms (`label(name, parser)`). */
   triviaKindLabels?: readonly string[]
+  /**
+   * Set only by `trivia()`: the labeled-arm spec of this trivia (`null` when it is
+   * not labeled), built once so a labeled scan never re-derives it.
+   */
+  labeledTriviaSpec?: LabeledTriviaSpec | null
   /** Preclassified lightweight trivia scanner for the ordinary skip path. */
   triviaScanner?: ((input: string, cur: number) => number) | null
   /** Set only by `classifiedTrivia()`: each root-visible category is a separate

package/src/version.ts

@@ -13,4 +13,4 @@
  * Kept in sync with `package.json` by `test/unit/version-sync.test.ts`, which fails
  * the build if this constant drifts from the published version.
  */
-export const PARSEMAN_VERSION = '0.51.1'
+export const PARSEMAN_VERSION = '0.52.0'