parseman 0.52.0 → 0.54.0

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

@@ -1,7 +1,7 @@
 import type { Combinator } from '../types.ts'
 import { hasDirectBuildDef } from '../analysis/commitment.ts'
 import type { HostMode } from '../cst/host-mode.ts'
-import { collectGrammarReflection, type GrammarReflection } from '../cst/reflection.ts'
+import { collectGrammarReflection, GRAMMAR_REFLECTION, type GrammarReflection } from '../cst/reflection.ts'
 import { encodeTableProgram, type TableSettings } from './encode.ts'
 import { defaultAssemblyCfgs, emitTableExpression } from './emit.ts'
 import { tableRules } from './assemble.ts'
@@ -54,6 +54,12 @@ const DEFAULT_PRECOMPILE_MIN_WORDS = 1_024
 export type TableRuleMapOptions = {
   /** Grammar-level ambient trivia, as `rules({ trivia }, …)` declares it. */
   readonly trivia?: Combinator<unknown>
+  /**
+   * `compileRuleMapRunnable` only: specialise the runnable table once with generated
+   * code (falling back to closures under CSP). `compile()` alone passes it — no other
+   * runtime path may construct code.
+   */
+  readonly specialise?: boolean
   /** Grammar-level ambient scan-skip, as `rules({ scanSkip }, …)` declares it. */
   readonly scanSkip?: Combinator<unknown>[]
   readonly recovery?: boolean
@@ -120,10 +126,11 @@ export type CompiledRuleMapTable = {
    * 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.
-   * 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.
+   * It runs the CLOSURE artifact — the engine printed output runs — so building
+   * it never constructs code: only `compile()` specialises (`specialise`), per
+   * docs/design/runtime-and-size-contract.md, rule 1. 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 closure-stamped wire program, for a caller that wants to fold or inspect it. */
@@ -232,13 +239,16 @@ export function compileRuleMapRunnable(
   if (encoded === null) return null
   const { prog, hostMode, plan } = encoded
   const artifact = closureArtifact(prog)
+  const reflection = collectGrammarReflection(ruleMap)
   return {
     keys: ruleMap.map(([key]) => key),
     hostMode,
     hostBranchElided: hostMode === 'ast' && ruleMap.some(([, rule]) => hasDirectBuildDef(rule)),
-    reflection: collectGrammarReflection(ruleMap),
+    reflection,
     ...(plan === undefined ? {} : { coverageDefinitions: plan.definitions }),
-    rules: tableRules(prog),
+    // Reflection rides on the map's metadata prototype from birth. Only `compile()`
+    // asks to specialise; every other caller runs the closure artifact.
+    rules: tableRules(opts.specialise === true ? prog : artifact, { [GRAMMAR_REFLECTION]: reflection }),
     prog: artifact,
   }
 }
@@ -349,7 +359,7 @@ export function compileRuleMap(
     hostBranchElided: hostMode === 'ast' && ruleMap.some(([, rule]) => hasDirectBuildDef(rule)),
     reflection: collectGrammarReflection(ruleMap),
     ...(plan === undefined ? {} : { coverageDefinitions: plan.definitions }),
-    rules: tableRules(prog),
+    rules: tableRules(artifact),
     prog: artifact,
   }
 }

package/src/table/compile.ts

@@ -8,6 +8,9 @@ import { closureArtifact } from './program.ts'
 import { buildGrammarPlan } from '../compiler/grammar-coverage-ids.ts'
 import { runDuplicationDiagnostic, type DuplicationOption } from './duplication-hook.ts'
 import { beginCompileDegradationDrain } from '../compiler/degradation.ts'
+import { compileRuleMapRunnable } from './compile-rule-map.ts'
+import { borrowedRuleMessage, borrowedRuleReference } from '../compiler/borrowed-rules.ts'
+import type { TableRule } from './program.ts'
 
 /**
  * `compile()` FOR THE TABLE LOWERING — same contract, different artifact.
@@ -110,7 +113,65 @@ export type TableCompileOptions = {
   readonly fnSources?: readonly string[]
 }
 
+/**
+ * Compile a whole RULE MAP — a `rules()` grammar or a runtime `compose()` result —
+ * into a map of runnable rules that `run()` / `parseDoc()` take like any other.
+ *
+ * This is how a caller opts a runtime composition into speed: `compose()` only
+ * links an interpreter grammar, and `compile()` encodes it to one table and
+ * specialises that table once. Where the environment forbids generated code (a
+ * Content-Security-Policy without `'unsafe-eval'`) the specialisation throws
+ * `EvalError` and the same table runs on the closure assembler instead.
+ */
+export function compile<T>(combinator: Combinator<T>, mapFnSources?: readonly string[], opts?: TableCompileOptions): CompiledParser<T>
+export function compile(grammar: Record<string, unknown> & { readonly _def?: never }, opts?: { readonly hostMode?: HostMode }): Record<string, TableRule>
 export function compile<T>(
+  target: Combinator<T> | Record<string, unknown>,
+  second?: readonly string[] | { readonly hostMode?: HostMode },
+  third?: TableCompileOptions,
+): CompiledParser<T> | Record<string, TableRule> {
+  if (!isCombinator(target)) return compileMap(target, second as { readonly hostMode?: HostMode } | undefined)
+  return compileRoot(target as Combinator<T>, second as readonly string[] | undefined, third)
+}
+
+function isCombinator(x: unknown): x is Combinator<unknown> {
+  return typeof x === 'object' && x !== null
+    && typeof (x as { parse?: unknown }).parse === 'function' && '_def' in x
+}
+
+function compileMap(grammar: Record<string, unknown>, opts: { readonly hostMode?: HostMode } = {}): Record<string, TableRule> {
+  const entries: Array<[string, Combinator<unknown>]> = []
+  for (const [key, value] of Object.entries(grammar)) {
+    if (!isCombinator(value)) throw new TypeError(`compile: grammar entry "${key}" is not a parser`)
+    // A referenced-but-undefined `g.X` is a hole, not a rule: it has nothing to encode.
+    if (value._def.tag === 'lazy') {
+      try { value._def.thunk() } catch { continue }
+    }
+    entries.push([key, value])
+  }
+  // A runtime composition was already checked when it linked; a plain map is checked
+  // here, because this encoder binds references by name.
+  const borrowed = borrowedRuleReference(Object.fromEntries(entries))
+  if (borrowed !== undefined) throw new Error(borrowedRuleMessage('compile', borrowed))
+  // One aggregated degradation block per compile, exactly as `compileRoot` drains it.
+  const drain = beginCompileDegradationDrain()
+  let done = false
+  try {
+    const refusals: string[] = []
+    const compiled = compileRuleMapRunnable(entries, {
+      ...(opts.hostMode ? { hostMode: opts.hostMode } : {}),
+      refusals,
+      specialise: true,
+    })
+    if (compiled === null) {
+      throw new Error(`compile: this grammar could not be encoded to a table${refusals.length ? ` — ${refusals.join('; ')}` : ''}`)
+    }
+    done = true
+    return compiled.rules
+  } finally { drain(done) }
+}
+
+function compileRoot<T>(
   combinator: Combinator<T>,
   mapFnSources?: readonly string[],
   opts: TableCompileOptions = {},

package/src/table/emit-assembly.ts

@@ -63,10 +63,12 @@ import {
   computeSiteLabels, reachableSites, type SiteLabel,
 } from './site-labels.ts'
 import {
-  leadingLiteralFamily, leadingScalarSequence, leadingScalarTerminal,
+  largeChoiceLiteralPretest, leadingScalarSequence, leadingScalarTerminal,
   scalarTerminalNodeChild, scalarTerminalNotChild, type LeadingScalarSequence,
 } from './scalar-terminal.ts'
 import { childSlots } from './child-slots.ts'
+import { fieldSpec, leadingTriviaFieldAt } from './field-spec.ts'
+import { FIELD_LEADING_TRIVIA, FIELD_TRAILING_TRIVIA } from '../combinators/field-trivia.ts'
 
 /** What the compiled factory hands back — the emitted twin of `Assembly`. */
 export type EmittedPiece = (input: string, pos: number, ctx: ParseContext) => unknown
@@ -122,6 +124,9 @@ export const EMITTED_PARAMS = [
   'adjacencyHolds',
   // Appended for selected composite lexical programs; old factories ignore it.
   'LEXPROG',
+  // Appended for trivia-attributing fields (`field(…, { leadingTrivia })`);
+  // old factories ignore them.
+  'LEAD', 'triviaFieldCapture',
 ] as const
 
 /**
@@ -607,20 +612,12 @@ export function emitAssemblySource(
           if (child >= 0) scalarSpecs.add(code[child + 1]!)
           continue
         }
-        if (child >= 0) {
-          const spec = k[code[child + 1]!]
-          if (code[child] === OP_LIT && typeof spec === 'string' && spec.length >= 2) {
-            largeChoiceScalarSpecs.add(code[child + 1]!)
-            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
-        })) {
-          largeChoiceLiteralFamilies.set(armIp, family)
+        const literals = largeChoiceLiteralPretest(code, k, armIp)
+        if (literals !== undefined && literals.length === 1 && literals[0] === child) {
+          largeChoiceScalarSpecs.add(code[child + 1]!)
+          continue
         }
+        if (literals !== undefined) largeChoiceLiteralFamilies.set(armIp, literals)
         const sequence = leadingScalarSequence(code, armIp)
         // A labelled trivia scanner is still recognition authority here. This
         // pretest is pure: on a miss the ordinary arm's trivia log would have
@@ -1307,17 +1304,34 @@ return v
       }
 
       case OP_FIELD: {
-        const name = q(k[code[ip + 1]!] as string)
+        const spec = fieldSpec(k[code[ip + 1]!])
+        const name = q(spec.name)
         const child = link(code[ip + 2]!)
         // `ctx._fields?.push(…)` — conditional on a field-reading node being
         // open, exactly as `map.ts` has it, so a field outside one costs a load
         // and a branch. The ARRAY is what `OP_NODE` hands to `buildFieldMap`.
-        return `${head}
+        if (spec.bits === 0) {
+          return `${head}
 const v=${child}(input,pos,ctx)
 if(v===FAIL)return FAIL
 const f=ctx._fields
 if(f!==undefined)f.push({name:${name},value:v,span:{start:pos,end:EC.e}})
 return v
+}`
+        }
+        const leading = (spec.bits & FIELD_LEADING_TRIVIA) !== 0
+        const trailing = (spec.bits & FIELD_TRAILING_TRIVIA) !== 0
+        return `${head}
+const lf=${leading ? 'LEAD.at' : '-1'}
+LEAD.at=-1
+const v=${child}(input,pos,ctx)
+if(v===FAIL)return FAIL
+const e=EC.e
+const te=${trailing ? 'ctx.trivia!==undefined?consumeTrivia(input,e,ctx):e' : 'e'}
+const f=ctx._fields
+if(f!==undefined)f.push(triviaFieldCapture(${name},v,input,pos,e,lf,te))
+EC.e=te
+return v
 }`
       }
 
@@ -1687,7 +1701,13 @@ return v
               `if(!adjacencyHolds(input,cur,ctx,${negated ? 'true' : 'false'},${kinds})){ctx._fe=cur;ctx._fx=${expected};return FAIL}`,
               `${vn}=null`,
             )
-          } else parts.push(emitTerm(kids[i]!, vn, tmp(), L, skipFor(L)))
+          } else {
+            // A leading-trivia field reads the cursor from before the term's scan.
+            // The callee expression hands it over AFTER the scan statement, right
+            // before the call, so a field inside the trivia grammar cannot take it.
+            const callee = leadingTriviaFieldAt(code, k, childIp) ? `(LEAD.at=cur,${kids[i]!})` : kids[i]!
+            parts.push(emitTerm(callee, vn, tmp(), L, skipFor(L)))
+          }
           names.push(vn)
         }
         parts.push('EC.e=cur')
@@ -2232,7 +2252,7 @@ ${sep !== undefined ? `if(count>0){
 const lb=cstLeavesLen(ctx)
 let sp=cur
 ${hasTrivia === 'false' ? '' : hasTrivia === 'true' ? `sp=${skip}(input,sp,ctx)\n` : `if(hasTrivia)sp=${skip}(input,sp,ctx)\n`}ctx._fc=false
-const sv=${sep}(input,sp,ctx)
+${sepIp >= 0 && leadingTriviaFieldAt(code, k, sepIp) ? 'LEAD.at=cur\n' : ''}const sv=${sep}(input,sp,ctx)
 if(sv===FAIL){
 ${rb}
 if(ctx._fc===true)return FAIL

package/src/table/emit.ts

@@ -352,12 +352,16 @@ export type ExpressionEmitOptions = EmitOptions & {
    *
    * `null` is what a `rules()` call site needs: its initialiser evaluates to the
    * `{ name: fn, … }` object, exactly what `tableRules(…)` already returns, so
-   * the map form is the expression WITHOUT the trailing index — not a second
+   * the map form is the expression WITHOUT the entry argument — not a second
    * emitter. `compileRuleMap`'s replacement has the same shape and the same
    * splice point, which is what makes the two lowerings interchangeable there.
    */
   readonly entry?: string | null
-  /** Static metadata object passed to `tableRules` as its second argument. */
+  /**
+   * Static metadata object passed to `tableRules` as its second argument. Only
+   * the rule-map form (`entry: null`) takes it; with an entry, that argument is
+   * the entry's name.
+   */
   readonly metadataSource?: string
 }
 
@@ -379,11 +383,18 @@ export function emitTableExpression(prog: TableProgram, opts: ExpressionEmitOpti
   const entry = opts.entry === undefined ? 'grammar' : opts.entry
   const ref = opts.runtimeRef ?? 'tableRules'
   const fns = opts.fnSources ?? prog.fns.map(() => '() => {}')
-  const close = `}${opts.metadataSource === undefined ? '' : `,${opts.metadataSource}`})`
+  // The entry is an ARGUMENT, never a trailing `[entry]`: `@__PURE__` covers the
+  // call and not a property read after it, so `tableRules({…})["Entry"]` left an
+  // unreferenced terminal's whole table in every bundle.
+  const meta = opts.metadataSource
+  if (entry !== null && meta !== undefined) {
+    throw new Error('emitTableExpression: metadataSource is for the rule-map form (entry: null); a single entry carries none')
+  }
+  const tail = entry !== null ? `,${jsString(entry)}` : meta === undefined ? '' : `,${meta}`
   return [
     `/* @__PURE__ */ ${ref}({`,
     ...programFields(prog, fns, opts),
-    entry === null ? close : `${close}[${jsString(entry)}]`,
+    `}${tail})`,
   ].join('\n')
 }
 

package/src/table/encode.ts

@@ -7,6 +7,7 @@ import { deriveExpected } from '../combinators/expect.ts'
 import { assertionFailureExpected, directTerminalFailureExpected } from '../combinators/expected.ts'
 import { buildReadsRaw, buildReadsState, buildReadsTrivia } from '../compiler/build-arity.ts'
 import { buildReadsFields, parserHasOwnFields } from '../compiler/fields.ts'
+import { FIELD_LEADING_TRIVIA, FIELD_TRAILING_TRIVIA } from '../combinators/field-trivia.ts'
 import { asciiFoldKey, branchUsesRouted, parserUsesRouted } from '../combinators/dispatch.ts'
 import {
   OP_CHOICE, OP_EMPTY, OP_GATE, OP_LEAF, OP_SOURCE_LEAF, OP_LIT, OP_NODE, OP_NOT, OP_OPT,
@@ -555,6 +556,17 @@ class Encoder {
     return i
   }
 
+  private fieldSpecIndex = new Map<string, number>()
+  private fieldSpecSlot(name: string, bits: number): number {
+    const key = JSON.stringify([name, bits])
+    const hit = this.fieldSpecIndex.get(key)
+    if (hit !== undefined) return hit
+    const i = this.k.length
+    this.k.push([name, bits])
+    this.fieldSpecIndex.set(key, i)
+    return i
+  }
+
   /**
    * A `notAdjacent({ kinds })` filter, pooled by its CONTENTS.
    *
@@ -1518,8 +1530,12 @@ class Encoder {
         for (let i = 0; i < arms.length; i++) this.code[head + 6 + i] = arms[i]!
         return head
       }
-      case 'field':
-        return this.emit(OP_FIELD, this.constant(d.name), this.node(d.parser).ip)
+      case 'field': {
+        // A trivia-attributing field carries `[name, bits]` in the name slot
+        // (`FIELD_LEADING_TRIVIA`/`FIELD_TRAILING_TRIVIA`); a plain one the name.
+        const bits = (d.leadingTrivia === true ? FIELD_LEADING_TRIVIA : 0) | (d.trailingTrivia === true ? FIELD_TRAILING_TRIVIA : 0)
+        return this.emit(OP_FIELD, bits === 0 ? this.constant(d.name) : this.fieldSpecSlot(d.name, bits), this.node(d.parser).ip)
+      }
       case 'lazy': {
         // A named reference is not a hop: it resolves to the target's row.
         // Emitting a trampoline here cost one dispatch per reference for nothing.

package/src/table/exec.ts

@@ -72,6 +72,8 @@ import { scalarTerminalNotChild } from './scalar-terminal.ts'
  * a successful match to the other engine.
  */
 import { FAIL, newEndCell, type EndCell } from './cell.ts'
+import { fieldSpec, leadingTriviaFieldAt } from './field-spec.ts'
+import { FIELD_LEADING_TRIVIA, FIELD_TRAILING_TRIVIA, LEAD, triviaFieldCapture } from '../combinators/field-trivia.ts'
 
 /**
  * DIAGNOSTIC ROW COUNTER — off unless `PM_TABLE_COUNT=1` at process start.
@@ -645,11 +647,21 @@ function makeDriver(
       }
 
       case OP_FIELD: {
+        const spec = fieldSpec(k[code[ip + 1]!])
+        const leadFrom = LEAD.at
+        if (spec.bits !== 0) LEAD.at = -1
         const v = exec(code[ip + 2]!, input, pos, ctx)
         if (v === FAIL) return FAIL
         // Conditional on a live sink, exactly as src/combinators/map.ts has it:
         // a `field()` outside any field-reading node costs nothing.
-        ctx._fields?.push({ name: k[code[ip + 1]!] as string, value: v, span: { start: pos, end: EC.e } })
+        if (spec.bits === 0) {
+          ctx._fields?.push({ name: spec.name, value: v, span: { start: pos, end: EC.e } })
+          return v
+        }
+        const end = EC.e
+        const trailEnd = (spec.bits & FIELD_TRAILING_TRIVIA) !== 0 && ctx.trivia !== undefined ? consumeTrivia(input, end, ctx) : end
+        ctx._fields?.push(triviaFieldCapture(spec.name, v, input, pos, end, (spec.bits & FIELD_LEADING_TRIVIA) !== 0 ? leadFrom : -1, trailEnd))
+        EC.e = trailEnd
         return v
       }
 
@@ -885,6 +897,7 @@ function makeDriver(
             const scanTl = need ? cstTlLen(ctx) : 0
             const scanLog = need ? ctx._triviaLog?.length ?? 0 : 0
             const scanRoot = need ? ctx._rootTriviaLog?.length ?? 0 : 0
+            if (leadingTriviaFieldAt(code, k, child)) LEAD.at = cur
             const v = exec(child, input, scanEnd, ctx)
             if (v === FAIL) { if (REC) ctx._sync = inheritedSync; return FAIL }
             if (EC.e > scanEnd) cur = EC.e
@@ -1256,6 +1269,7 @@ function makeDriver(
             let sp = cur
             if (hasTrivia) sp = skipTrivia(input, sp, ctx)
             ctx._fc = false
+            if (leadingTriviaFieldAt(code, k, sep)) LEAD.at = cur
             const sv = exec(sep, input, sp, ctx)
             if (sv === FAIL) {
               if (needMark) rollbackTriviaAt(ctx, mRaw, mTl, mLv, mFl, mEr, mLog, mRoot)

package/src/table/field-spec.ts

@@ -0,0 +1,17 @@
+import { OP_FIELD } from './ops.ts'
+import { FIELD_LEADING_TRIVIA } from '../combinators/field-trivia.ts'
+
+/**
+ * An `OP_FIELD` name slot: the name, or `[name, bits]` for a field that
+ * attributes trivia (`FIELD_LEADING_TRIVIA` / `FIELD_TRAILING_TRIVIA`). A
+ * program printed before those options existed carries only names, and reads
+ * as bits 0.
+ */
+export function fieldSpec(slot: unknown): { readonly name: string; readonly bits: number } {
+  return Array.isArray(slot) ? { name: slot[0] as string, bits: slot[1] as number } : { name: slot as string, bits: 0 }
+}
+
+/** Is the instruction at `ip` a `field(…, { leadingTrivia: true })`? */
+export function leadingTriviaFieldAt(code: ArrayLike<number>, k: readonly unknown[], ip: number): boolean {
+  return code[ip] === OP_FIELD && (fieldSpec(k[code[ip + 1]!]).bits & FIELD_LEADING_TRIVIA) !== 0
+}

package/src/table/scalar-terminal.ts

@@ -261,3 +261,28 @@ export function leadingLiteralFamily(
 
   return walk(ip, 0)
 }
+
+/**
+ * The literal terminals an arm of a LARGE ordered choice (more than three arms)
+ * may be pretested on before it is entered, or `undefined` when it has none.
+ *
+ * A pretest runs again when the arm then matches, so a large choice only takes
+ * literals of two or more characters: one `startsWith` is the price of skipping an
+ * arm that first-char dispatch could not exclude (`@{` and `@@` beside `@name`).
+ * A one-character literal is exactly what the dispatch mask already decided.
+ * The emitted and the closure engines both select through this function.
+ */
+export function largeChoiceLiteralPretest(
+  code: ArrayLike<number>, constants: readonly unknown[], armIp: number,
+): readonly number[] | undefined {
+  const child = leadingScalarTerminal(code, armIp, 2, true, true)
+  if (child >= 0) {
+    const spec = constants[code[child + 1]!]
+    if (code[child] === OP_LIT && typeof spec === 'string' && spec.length >= 2) return [child]
+  }
+  const family = leadingLiteralFamily(code, constants, armIp)
+  return family !== undefined && family.length >= 2 && family.every(terminal => {
+    const value = constants[code[terminal + 1]!]
+    return typeof value === 'string' && value.length >= 2
+  }) ? family : undefined
+}

package/src/types.ts

@@ -83,7 +83,7 @@ export type ParserDef =
   | { tag: 'routed';    fallback?: Combinator<unknown> }
   | { 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: 'field';     name: string; parser: Combinator<unknown>; leadingTrivia?: true; trailingTrivia?: true }
   | { tag: 'grammar';   parser: Combinator<unknown>; triviaParser: Combinator<unknown> | undefined; clearTrivia?: boolean; captureTrivia?: boolean; rootCapture?: 'opaque'; trackLines: boolean; constructionTrackLines?: 'on' | 'off' | 'inherit'; constructionCaptureTriviaKinds?: readonly string[] }
   | { tag: 'lazy';     thunk: () => Combinator<unknown> }
   | { tag: 'not';      parser: Combinator<unknown> }
@@ -203,6 +203,16 @@ export type BuildHost = ((
 export type FieldCapture<T = unknown> = {
   value: T
   span: Span
+  /**
+   * `field(…, { leadingTrivia: true })` only: the source text of the trivia the
+   * enclosing sequence or separated list skipped right before this field, or `''`.
+   */
+  leading?: string
+  /**
+   * `field(…, { trailingTrivia: true })` only: the source text of the trivia the
+   * field consumed after its match, or `''`.
+   */
+  trailing?: string
 }
 
 export type FieldMap = Record<string, FieldCapture | FieldCapture[]>
@@ -382,7 +392,7 @@ export type ParseContext = {
    */
   _cstTriviaLog?: number[] | undefined
   /** Framework-internal: active node() field captures, enabled only when needed. */
-  _fields?: Array<{ name: string; value: unknown; span: Span }> | undefined
+  _fields?: Array<{ name: string; value: unknown; span: Span; leading?: string; trailing?: string }> | undefined
   /** Framework-internal: lazy capture buffer for active node() parse. */
   _cstBuf?: CstCaptureBuf | undefined
   /** Framework-internal: value/span already consumed by an enclosing dispatch(). */

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.52.0'
+export const PARSEMAN_VERSION = '0.54.0'