parseman 0.60.5 → 0.60.6

package/dist/table/ops.d.ts

@@ -210,6 +210,12 @@ export declare const OP_TOKEN = 29;
  * is why this restores the saved value rather than writing `false`.
  */
 export declare const OP_SCOPE_CAP = 30;
+/**
+ * `k` of a `SCOPE_CAP` row whose `parser({ captureTrivia: true })` names no trivia.
+ * It raises capture and leaves the trivia the scope was entered with in force,
+ * where `k = -1` clears it (`trivia: null`).
+ */
+export declare const SCOPE_INHERIT = -2;
 /**
  * `WITHCTX k c` — `withCtx(extra, c)`. `k >= 0` is `extra` in the const pool
  * (the replace form); `k < 0` is the derive form, `~k` indexing the author's

package/dist/table/ops.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ops.d.ts","sourceRoot":"","sources":["../../src/table/ops.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"ops.d.ts","sourceRoot":"","sources":["../../src/table/ops.ts"],"names":[],"mappings":"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"}

package/dist/version.d.ts

@@ -13,5 +13,5 @@
  * 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 declare const PARSEMAN_VERSION = "0.60.5";
+export declare const PARSEMAN_VERSION = "0.60.6";
 //# sourceMappingURL=version.d.ts.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "parseman",
-  "version": "0.60.5",
+  "version": "0.60.6",
   "packageManager": "pnpm@10.15.1",
   "engines": {
     "node": "^20.19.0 || >=22.13.0"

package/src/combinators/grammar.ts

@@ -215,7 +215,7 @@ export function parser<T>(opts: ParserOptions, root: Combinator<T>): ParsemanPar
         ctx.triviaKindLabels = undefined
       } else if (scopeTrivia !== undefined) {
         ctx.trivia = scopeTrivia
-        if (scopeLabels) ctx.triviaKindLabels = scopeLabels
+        ctx.triviaKindLabels = scopeLabels
       }
       if (forceCaptureTrivia || _ctx?.captureTrivia) ctx.captureTrivia = true
       // Kind-filter for per-node capture. Resolve against this scope's trivia

package/src/combinators/trivia-boundary.ts

@@ -20,9 +20,11 @@ const MAX_DEPTH = 12
  *
  * `lazy` is deliberately false and is never followed: a reference is the
  * delegation this question is about, so following it would both loop and answer
- * for a different rule. `grammar` is false because it declares its own scope, so
- * an outer install never reaches its body. `dispatch` is false because it is a
- * ROUTE: its arms re-enter from the routed token and spell their own padding.
+ * for a different rule. A `grammar` that names or clears trivia declares its own
+ * scope, so an outer install never reaches its body and the answer is false; one
+ * that does not (`parser({ trackLines: true }, …)`, which `rules({ trackLines })`
+ * wraps every rule in) inherits, so it is transparent. `dispatch` is false because
+ * it is a ROUTE: its arms re-enter from the routed token and spell their own padding.
  *
  * Structural and pure — callers resolve it ONCE, not per parse.
  */
@@ -35,6 +37,12 @@ export function hasOwnTriviaBoundary(p: Combinator<unknown>, depth: number = MAX
     // Multi-term forms: the gaps BETWEEN terms are the ambient-trivia positions.
     case 'sequence': return d.parsers.length > 1
     case 'many': case 'oneOrMore': case 'sepBy': return true
+    // A scope that names or clears trivia keeps an outer install out of its body.
+    // Any other inherits, so it falls through at no cost in depth: line tracking
+    // wraps every rule in one, and must not change what this walk sees.
+    case 'grammar':
+      if (d.triviaParser || d.clearTrivia) return false
+      depth++
     // Transparent wrappers — they add no position, so ask what they wrap.
     case 'node': case 'transform': case 'leaf': case 'label': case 'field':
     case 'token': case 'attempt': case 'optional': case 'expect': case 'withCtx':

package/src/index.ts

@@ -141,7 +141,7 @@ export type {
 // back to `FusedRule`, `isInterpretedFuse` would have to be re-exported in the same
 // change — a dual shape with no way to detect it is the worse of the two.
 export { compose, composeLeaf, cstBuildHost } from './compiler/linker.ts'
-export type { CstBuildHostOptions, FusedRule } from './compiler/linker.ts'
+export type { ComposedRules, CstBuildHostOptions, FusedRule } from './compiler/linker.ts'
 
 export { buildLineIndex, createLineIndex, recordLineRange, normalizeLineIndex, offsetToLineCol, annotateSpan, annotateTreeSpans } from './line-index.ts'
 export type { LineIndex } from './line-index.ts'

package/src/table/assemble.ts

@@ -88,7 +88,7 @@ import { PlainBuf, PlainField, PlainLeaf, PlainNode, PlainSpan } from '../cst/pl
 import {
   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_LIT_TRACK, OP_RX_TRACK, OP_NODE_TRACK, OP_SCOPE, OP_SCOPE_CAP, OP_SCOPE_PLAIN, SCOPE_INHERIT, OP_EXPECT, OP_SEQX, OP_SCAN,
   OP_LIVE,
   OP_FIELD, OP_DISPATCH, OP_ROUTED, OP_LIT_CI, OP_LIT_CI_TRACK, OP_TOKEN, OP_WITHCTX, OP_GUARD, OP_ATTEMPT, OP_LABEL,
   OP_COV, OP_GAPGATE, OP_STRICT,
@@ -2109,6 +2109,16 @@ export function assemble(t: ResolvedTable, prog: TableProgram, cfg: RunCfg): Ass
       case OP_SCOPE_CAP:
       case OP_SCOPE_PLAIN: {
         const ki = code[ip + 1]!
+        if (ki === SCOPE_INHERIT) {
+          const body = link(code[ip + 2]!)
+          return (input, pos, ctx) => {
+            const savedCap = ctx.captureTrivia
+            ctx.captureTrivia = true
+            const v = body(input, pos, ctx)
+            ctx.captureTrivia = savedCap
+            return v
+          }
+        }
         const scopeTrivia = ki < 0 ? undefined : (trivia[ki] as ParseContext['trivia'])
         const scopeLabels = scopeTrivia?._meta.triviaKindLabels
         // THE SWAP, RESOLVED AT ASSEMBLY. `exec.ts` computed

package/src/table/emit-assembly.ts

@@ -50,7 +50,7 @@ import {
   OP_ADJ, OP_ARMGATE, OP_RGATE, OP_RGATE2, OP_ATTEMPT, OP_CHOICE, OP_DISPATCH, OP_EMPTY, OP_EXPECT, OP_FIELD, OP_GATE,
   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_WITHCTX, OP_XFORM,
+  OP_RX_TRACK, OP_SCAN, OP_SCOPE, OP_SCOPE_CAP, OP_SCOPE_PLAIN, SCOPE_INHERIT, OP_SEQ, OP_SEQV, OP_SEQX, OP_TOKEN, OP_WITHCTX, OP_XFORM,
   OP_LEX_BODY, OP_LEX_PROGRAM, OP_GAPGATE, OP_STRICT,
 } from './ops.ts'
 import {
@@ -1625,6 +1625,15 @@ return r.value
         const cap = op === OP_SCOPE_CAP
         const flags = op === OP_SCOPE_PLAIN ? 0 : code[ip + 3]!
         const child = link(code[ip + 2]!)
+        if (ki === SCOPE_INHERIT) {
+          return `${head}
+const sC=ctx.captureTrivia
+ctx.captureTrivia=true
+const v=${child}(input,pos,ctx)
+ctx.captureTrivia=sC
+return v
+}`
+        }
         // THE SWAP, RESOLVED AT EMIT. `swapLegal` is `!trackLines`, an option;
         // the other two are table data. All three are known here, so the body
         // holds the scanner it installs as a hoisted const.

package/src/table/encode.ts

@@ -15,7 +15,7 @@ import { asciiFoldKey, branchUsesRouted, parserUsesRouted } from '../combinators
 import {
   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_LIT_TRACK, OP_RX_TRACK, OP_NODE_TRACK, OP_SCOPE, OP_SCOPE_CAP, OP_SCOPE_PLAIN, SCOPE_INHERIT, OP_EXPECT, OP_SEQX, OP_SCAN,
   OP_LIVE, OP_ATTEMPT, OP_LABEL,
   OP_FIELD, OP_DISPATCH, OP_ROUTED, OP_LIT_CI, OP_LIT_CI_TRACK, OP_TOKEN, OP_WITHCTX, OP_GUARD,
   OP_ADJ, OP_GREEDY, OP_REJECT, OP_ARMGATE, OP_RGATE, OP_COV, OP_GAPGATE, OP_RGATE2, OP_STRICT,
@@ -2182,13 +2182,19 @@ class Encoder {
         // this scope's trivia is opaque to root capture, which `run()` consumes.
         // Nothing in the parse changes, so there is nothing for the table to
         // lower — accepting it is not a gap, it is the correct lowering.
-        // ONLY `true` IS MEANINGFUL HERE. `grammar.ts:94` stores
-        // `opts.trackLines ?? false`, so an UNSET scope and an explicitly-false
-        // one are the same value on the def — the distinction is lost. At parse
-        // time `:103` reads `opts.trackLines ?? _ctx?.trackLines ?? false`, i.e.
-        // unset INHERITS. So stored-false cannot be read as "force off", and
-        // comparing it against the setting refused every inner scope of a
-        // trackLines:true grammar — all four `*PositionsGrammar`s.
+        // ONLY `true` IS MEANINGFUL HERE. `def.trackLines` is `opts.trackLines ??
+        // false`, so an unset scope and an explicitly-false one read the same on that
+        // field (`def.constructionTrackLines` keeps the difference, and the encoder
+        // does not read it). An unset scope inherits, so stored-false cannot be read
+        // as "force off", and comparing it against the setting refused every inner
+        // scope of a trackLines:true grammar — all four `*PositionsGrammar`s.
+        //
+        // THIS IS NOT THE INTERPRETER'S SCOPING, AND A REDUCER CAN SEE IT (#258). A
+        // table has one line setting. A node outside a `trackLines: true` scope gets
+        // line fields from the table and none from the interpreter; a
+        // `trackLines: false` scope under a tracked grammar keeps them in the table
+        // and drops them in the interpreter; and a `trackLines: true` scope in a rule
+        // the entry cannot reach still turns them on for `encodeTable`.
         //
         // A SCOPE THAT ASKS FOR TRACKING NO LONGER REFUSES. `encodeTable` folds
         // every such scope into the table's own `track` before encoding begins
@@ -2237,8 +2243,9 @@ class Encoder {
         this.activeTrivia = savedTrivia
         this.triviaKnown = savedKnown
         if (d.clearTrivia === true) return this.emit(op, -1, bodyIp, flags)
+        // No trivia named: `flags` is zero (`rootCapture: 'opaque'` requires one).
         if (d.triviaParser === undefined) {
-          return cap || flags !== 0 ? this.emit(op, -1, bodyIp, flags) : bodyIp
+          return cap ? this.emit(op, SCOPE_INHERIT, bodyIp, flags) : bodyIp
         }
         return this.emit(op, this.triviaSlot(d.triviaParser), bodyIp, flags)
       }

package/src/table/exec.ts

@@ -18,7 +18,7 @@ import {
 import {
   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_LIT_TRACK, OP_RX_TRACK, OP_NODE_TRACK, OP_SCOPE, OP_SCOPE_CAP, OP_SCOPE_PLAIN, SCOPE_INHERIT, OP_EXPECT, OP_SEQX, OP_SCAN,
   OP_LIVE,
   OP_FIELD, OP_DISPATCH, OP_ROUTED, OP_LIT_CI, OP_LIT_CI_TRACK, OP_TOKEN, OP_WITHCTX, OP_GUARD, OP_ATTEMPT, OP_LABEL,
   OP_COV, OP_GAPGATE, OP_STRICT,
@@ -779,14 +779,16 @@ function makeDriver(
         // labelled trivia is excluded here rather than tested later: `scanTrivia`
         // suppresses its own fast path when labels are present, so a swap there
         // would drop the labelled records silently.
-        SCAN = FAST && ki >= 0 && !triviaLabelled[ki]! ? triviaScan[ki]! : null
-        ctx.trivia = scopeTrivia
-        // A scope installs its trivia's KIND LABELS too. Root-trivia rows are
-        // only ever written on the labelled scan path (trivia-skip.ts:212) — the
-        // unlabelled fast scanner returns before any root logging and does not
-        // even test `_rootTriviaLog` — so a scope that sets trivia without its
-        // labels captures NOTHING at the root, silently.
-        ctx.triviaKindLabels = scopeTrivia?._meta.triviaKindLabels
+        if (ki !== SCOPE_INHERIT) {
+          SCAN = FAST && ki >= 0 && !triviaLabelled[ki]! ? triviaScan[ki]! : null
+          ctx.trivia = scopeTrivia
+          // A scope installs its trivia's KIND LABELS too. Root-trivia rows are
+          // only ever written on the labelled scan path (trivia-skip.ts:212) — the
+          // unlabelled fast scanner returns before any root logging and does not
+          // even test `_rootTriviaLog` — so a scope that sets trivia without its
+          // labels captures NOTHING at the root, silently.
+          ctx.triviaKindLabels = scopeTrivia?._meta.triviaKindLabels
+        }
         // SCOPE_CAP additionally turns capture ON for the child. It is an OR with
         // whatever the enclosing context already asked for (`grammar.ts:129`), so
         // the RESTORE puts the saved value back rather than writing `false` — an

package/src/table/ops.ts

@@ -211,6 +211,12 @@ export const OP_TOKEN = 29
  * is why this restores the saved value rather than writing `false`.
  */
 export const OP_SCOPE_CAP = 30
+/**
+ * `k` of a `SCOPE_CAP` row whose `parser({ captureTrivia: true })` names no trivia.
+ * It raises capture and leaves the trivia the scope was entered with in force,
+ * where `k = -1` clears it (`trivia: null`).
+ */
+export const SCOPE_INHERIT = -2
 /**
  * `WITHCTX k c` — `withCtx(extra, c)`. `k >= 0` is `extra` in the const pool
  * (the replace form); `k < 0` is the derive form, `~k` indexing the author's

package/src/table/site-labels.ts

@@ -62,7 +62,7 @@
 import {
   OP_ATTEMPT, OP_CHOICE, OP_DISPATCH, OP_EXPECT, OP_FIELD, OP_GATE, OP_LABEL, OP_LEAF, OP_LIT, OP_SOURCE_LEAF,
   OP_NODE, OP_NODE_TRACK, OP_NOT, OP_OPT, OP_PEEK, OP_REP, OP_REPV, OP_ROUTED, OP_RULE,
-  OP_SCAN, OP_SCOPE, OP_SCOPE_CAP, OP_SCOPE_PLAIN, OP_SEQ, OP_SEQV, OP_SEQX, OP_TOKEN, OP_XFORM,
+  OP_SCAN, OP_SCOPE, OP_SCOPE_CAP, OP_SCOPE_PLAIN, SCOPE_INHERIT, OP_SEQ, OP_SEQV, OP_SEQX, OP_TOKEN, OP_XFORM,
 } from './ops.ts'
 import { childSlots } from './child-slots.ts'
 import { leadRanges } from '../lead-ranges.ts'
@@ -206,7 +206,7 @@ function transfer(code: Int32Array, ip: number, at: SiteLabel, hostCst: boolean)
   const op = code[ip]
   if (op === OP_SCOPE || op === OP_SCOPE_CAP || op === OP_SCOPE_PLAIN) {
     const ki = code[ip + 1]!
-    const tri = ki < 0 ? TRI_NONE : ki
+    const tri = ki === SCOPE_INHERIT ? at.tri : ki < 0 ? TRI_NONE : ki
     // `OP_SCOPE_CAP` is an OR with the inherited context, never a switch-off
     // (`encode.ts:1153-1158`), so it can only ever raise `cap` to `CAP_ON`.
     const cap = op === OP_SCOPE_CAP ? CAP_ON : at.cap
@@ -358,7 +358,7 @@ export function scanHandoffNeeded(code: Int32Array, ip: number, labels: SiteLabe
     const op = code[at]
     // A scan runs interpreted combinators that reach pieces through `prog.scans`.
     if (op === OP_SCAN) return true
-    if (op === OP_TOKEN || op === OP_SCOPE_CAP) continue
+    if (op === OP_TOKEN || (op === OP_SCOPE_CAP && code[at + 1] !== SCOPE_INHERIT)) continue
     if ((op === OP_SCOPE_PLAIN || op === OP_SCOPE) && !(code[at + 1]! >= 0 && l.tri === code[at + 1]!
       && (op === OP_SCOPE_PLAIN || code[at + 3]! === 0))) continue
     kids.length = 0

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.60.5'
+export const PARSEMAN_VERSION = '0.60.6'