parseman 0.60.4 → 0.60.6

package/src/plugin/index.ts

@@ -24,7 +24,7 @@ import { createUnplugin } from 'unplugin'
 import { parseSync } from 'oxc-parser'
 import { ResolverFactory } from 'oxc-resolver'
 import MagicString from 'magic-string'
-import { evaluateExpr, evaluateCombinatorArray, evaluateParserFactory, externalAccesses, evaluateStaticValue, evaluateWordFactory, evaluateWhenFactory, evaluateRefDeclaration, applyDefineStatement, referencesAny, setReducerResolver, setBuilderImportResolver, propName, ModuleScope, type FreeNameResolution, type Scope, type ScopeEntry } from './evaluator.ts'
+import { evaluateExpr, evaluateCombinatorArray, evaluateParserFactory, externalAccesses, ruleMapRecipes, evaluateStaticValue, evaluateWordFactory, evaluateWhenFactory, evaluateRefDeclaration, applyDefineStatement, referencesAny, setReducerResolver, setBuilderImportResolver, propName, ModuleScope, type FreeNameResolution, type Scope, type ScopeEntry } from './evaluator.ts'
 import { classifyRuleMap } from '../analysis/commitment.ts'
 import { compile } from '../table/compile.ts'
 import { compileRuleMap, type CompiledRuleMapTable } from '../table/compile-rule-map.ts'
@@ -223,12 +223,6 @@ const DEFAULT_ASSEMBLY_BUDGET = 0.25
 /** A build failure the lowering must not soften into a warning and a fallback. */
 class LinkRefusal extends Error {}
 
-/** Whether a rule-map entry has a definition (a `g.X` merely read does not). */
-function isResolved(rule: Combinator<unknown>): boolean {
-  if (rule._def.tag !== 'lazy') return true
-  try { rule._def.thunk(); return true } catch { return false }
-}
-
 function reasonSuffix(runtimeOnly: readonly string[] | undefined): string {
   return runtimeOnly === undefined || runtimeOnly.length === 0
     ? ''
@@ -2061,7 +2055,7 @@ function transformMacroImpl(
   /**
    * Evaluate a carried list back to combinators, one entry per piece: its rule map
    * and the `rules()` recipe it was built from. `compose()` links the recipes into
-   * one namespace (`mergedCarriedRules`); `composeLeaf()` merges the maps by name.
+   * one namespace (`mergedCarriedRules`), and `composeLeaf()` does the same.
    * Either way the merged grammar is encoded ONCE by `compileRuleMap` — no relocation
    * of code offsets and no merging of const / fn / expected pools between two
    * already-encoded programs.
@@ -2097,38 +2091,6 @@ function transformMacroImpl(
     return { pieces, trackLines }
   }
 
-  /**
-   * Fold ordered rule maps into the composed map: a later piece's name WINS, and
-   * `Map` keeps each name at its first-sighting position so the encoded rule order
-   * tracks the source lowering's rather than drifting per compose.
-   *
-   * A REFERENCE IS NOT A DEFINITION. A `rules(g => …)` cache also holds every `g.X`
-   * that was merely ACCESSED, so a delta that calls `g.Pair` carries a `Pair` entry
-   * that is an unresolved named lazy. Merged in name order that entry lands LAST and
-   * shadows the base piece which actually defines `Pair` — the encoder then finds a
-   * hole where the winner should be and refuses the whole grammar with "ref() used
-   * before .define()". The same filter guards `compileLinkableTable`'s `isLocal`
-   * (`compile-linkable-table.ts`) and `recoverComposedRules`; this site needs it
-   * for the same reason, and skipping it is why cross-piece composition looked blocked.
-   *
-   * The reference itself is not lost: it stays inside the delta's own rule bodies and
-   * `enc.winners` binds it BY NAME to whichever piece supplies the definition.
-   */
-  const mergeRuleMaps = (
-    maps: ReadonlyArray<ReadonlyArray<readonly [string, Combinator<unknown>]>>,
-  ): Array<[string, Combinator<unknown>]> => {
-    const winners = new Map<string, Combinator<unknown>>()
-    for (const map of maps) {
-      for (const [name, rule] of map) {
-        if (rule._def.tag === 'lazy') {
-          try { rule._def.thunk() } catch { continue }
-        }
-        winners.set(name, rule)
-      }
-    }
-    return [...winners]
-  }
-
   /**
    * LINK a carried list into the composed map, exactly as runtime `compose()` does:
    * every piece's carried `rules()` recipe runs again against ONE namespace
@@ -2156,25 +2118,6 @@ function transformMacroImpl(
     return { rules: Object.entries(linked), trackLines: carriedMaps.trackLines, dangling }
   }
 
-  /**
-   * COMPOSING-WINS for `composeLeaf()`'s carried pieces, as an OVERRIDE rather than
-   * a gap-fill: `compileRuleMap`'s `applyAmbient` only fills a rule that carries no
-   * trivia of its own. (`compose()` gets the same override from `linkRules`.)
-   *
-   * Safe to mutate: every rule here came from `evalRuleMapIR`, which constructs FRESH
-   * combinators per piece per compose, so this cannot leak into another compose of the
-   * same base grammar.
-   */
-  const applyComposingTrivia = (
-    ruleMap: ReadonlyArray<readonly [string, Combinator<unknown>]>,
-    composing: Combinator<unknown>,
-  ): void => {
-    for (const [, rule] of ruleMap) {
-      if (rule._meta.isTrivia) continue
-      ;(rule._meta as { grammarTrivia?: Combinator<unknown> }).grammarTrivia = composing
-    }
-  }
-
   /** Resolve one `compose([...])` argument to its RE-LOWERABLE carried items (IR
    * pieces / import spreads / baked-pieces fallback). The composing grammar's trivia
    * is applied later, uniformly, in materializeCarried — never per-piece here. */
@@ -2340,10 +2283,17 @@ function transformMacroImpl(
     // does — one encode, one `tableRules(…)` expression, no linker. `carried` is
     // unchanged either way: it is the re-lowerable IR list, not a lowering artifact,
     // so a downstream re-compose behaves identically whichever engine emitted here.
-    const merged = mergedCarriedRules(carried, {
-      trivia: composing,
-      ...(cHostMode ? { hostMode: cHostMode as HostMode } : {}),
-    })
+    let merged: ReturnType<typeof mergedCarriedRules>
+    try {
+      merged = mergedCarriedRules(carried, {
+        trivia: composing,
+        ...(cHostMode ? { hostMode: cHostMode as HostMode } : {}),
+      })
+    } catch (e) {
+      // Linking refuses the composition (a `prior.X` no earlier piece defines): a
+      // runtime `compose()` would refuse it the same way, so the build fails, here.
+      throw new Error(`${id}:${lineOf(init.start)} — ${(e as Error).message}`, { cause: e })
+    }
     if (merged?.dangling !== undefined) throw new Error(`${id}:${lineOf(init.start)} — compose: ${merged.dangling}`)
     if (merged !== null) {
       // Harvest the direct-builder import provenance carried on the merged graph so
@@ -2475,22 +2425,15 @@ function transformMacroImpl(
       return null
     }
     const localArg = elements[elements.length - 1]!
-    let localRules: Iterable<readonly [string, unknown]> | null = null
-    // The LOCAL leaf grammar's own ambient scanSkip (from its `rules({ scanSkip })`)
-    // governs the scanTo/balanced sites IT defines — unlike trivia (composing-wins),
-    // opaque units are dialect-specific, so the local declaration is threaded to the
-    // local piece's compile.
-    let localScanSkip: Combinator<unknown>[] | undefined
+    let localRules: ReadonlyMap<string, Combinator<unknown>> | null = null
     const importedFactories: string[] = []
     if (isRulesCall(localArg)) {
       const evaluated = evaluateRulesFactory(localArg, `composeLeaf${init.start}`)
       localRules = evaluated?.ruleMap ?? null
-      localScanSkip = evaluated?.scanSkip
       if (evaluated?.importedFactory) importedFactories.push(evaluated.importedFactory)
     } else if (localArg.type === 'Identifier') {
       const name = (localArg as unknown as { name: string }).name
       localRules = localRuleMaps.get(name) ?? null
-      localScanSkip = localGrammarScanSkip.get(name)
     }
     if (!localRules) {
       // Distinguish "the argument is the wrong SHAPE" from "the argument is the right
@@ -2525,13 +2468,6 @@ function transformMacroImpl(
       // may place one beneath a direct node(). Re-lower their terminals with
       // capture enabled so that node receives the imported token values in its
       // normal child collector; the pieces still contain no semantic callback.
-      const localNs = nsFor(`composeLeaf${init.start}`)
-      const localEntries = [...localRules] as Array<[string, Combinator<unknown>]>
-
-      // TABLE FIRST — same merge as `compose()`, with the local leaf map appended LAST
-      // so it wins every name and binds the imported shapes' holes (`enc.winners`
-      // resolves those by name; see `mergedCarriedRules`).
-      //
       // The recognition-only gate is preserved EXACTLY, and is the reason this path
       // needs no `compileLinkable`: `hasDirectBuilders` / `isRecognitionOnly` are
       // predicates over the combinator graph, not products of lowering it, so
@@ -2554,36 +2490,23 @@ function transformMacroImpl(
           warn(init.start, 'composeLeaf(): every pre-final grammar must explicitly prove recognition-only')
           return null
         }
-        // The local grammar's OWN ambient scanSkip is stamped onto the LOCAL entries
-        // only. Passing it as a merged-map option instead would let `applyAmbient`
-        // hand it to every imported rule that happens to carry no stamp of its own —
-        // opaque units are dialect-specific, and that is precisely the leak the
-        // per-piece threading in the source path exists to avoid.
-        if (localScanSkip) {
-          for (const [, rule] of localEntries) {
-            if (rule._meta.isTrivia) continue
-            const meta = rule._meta as { grammarScanSkip?: Combinator<unknown>[] }
-            if (meta.grammarScanSkip === undefined) meta.grammarScanSkip = localScanSkip
-          }
+        // The same link as `compose()` and runtime `composeLeaf()`: the leaf is the last
+        // recipe, so it wins every name, binds the imported shapes' holes and fills its
+        // `prior.X`. Each recipe keeps its own scanSkip; the composing trivia governs all.
+        let linked: Record<string, Combinator<unknown>>
+        try {
+          linked = linkRules(
+            [...carriedMaps.pieces.flatMap(p => p.recipes), ...ruleMapRecipes.get(localRules)!],
+            { trivia: composing },
+          )
+        } catch (e) {
+          throw new LinkRefusal(`${id}:${lineOf(init.start)} — composeLeaf: ${(e as Error).message.replace(/^compose: /, '')}`, { cause: e })
         }
-        const leafMerged = mergeRuleMaps([...carriedMaps.pieces.map(p => p.rules), localEntries])
-        // The same refusal as `compose()`, over a merge by name: a name some piece only
-        // reads (an unresolved entry of a carried map, or a local factory's external
-        // access) that no piece defines.
-        const accessed = [
-          ...carriedMaps.pieces.flatMap(p => p.rules).filter(([, rule]) => !isResolved(rule)).map(([name]) => name),
-          ...(localRules instanceof Map ? externalAccesses.get(localRules) ?? [] : []),
-        ]
-        const dangling = danglingReference(Object.fromEntries(leafMerged), accessed)
+        const dangling = danglingReference(linked)
         if (dangling !== undefined) throw new LinkRefusal(`${id}:${lineOf(init.start)} — composeLeaf: ${dangling}`)
-        // Composing-wins governs the leaf fuse too. The local entries are NOT freshly
-        // evaluated (they come from this module's own `rules()` factory), so they are
-        // excluded from the override — their declared trivia IS the composing candidate,
-        // and rewriting `_meta` on them would mutate the module-level grammar object.
-        if (composing) applyComposingTrivia(carriedMaps.pieces.flatMap(p => p.rules), composing)
         const refusals: string[] = []
         const compiled = compileRuleMap(
-          leafMerged,
+          Object.entries(linked),
           {
             ...(composing ? { trivia: composing } : {}),
             ...(carriedMaps.trackLines ? { trackLines: true } : {}),

package/src/spec/model.ts

@@ -507,7 +507,9 @@ class Builder {
 
       case 'lazy': {
         const inner = resolveLazy(self)
-        return inner ? this.walk(inner) : { kind: 'annotation', text: '?' }
+        if (inner) return this.walk(inner)
+        const prior = (self as { _priorOf?: string })._priorOf
+        return { kind: 'annotation', text: prior === undefined ? '?' : `prior.${prior}` }
       }
 
       case 'unknown':

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