parseman 0.60.2 → 0.60.4

package/dist/plugin/index.js

@@ -6217,7 +6217,9 @@ function ownTableProgram(prog, resolved, caches = {}) {
       resolved,
       choiceRollbackMasks: caches.choiceRollbackMasks ?? runtime?.choiceRollbackMasks,
       nonCommittingChoiceSites: caches.nonCommittingChoiceSites ?? runtime?.nonCommittingChoiceSites,
-      failureRollbackCleanSites: caches.failureRollbackCleanSites ?? runtime?.failureRollbackCleanSites
+      failureRollbackCleanSites: caches.failureRollbackCleanSites ?? runtime?.failureRollbackCleanSites,
+      choiceLogRollbackMasks: caches.choiceLogRollbackMasks ?? runtime?.choiceLogRollbackMasks,
+      failureLogRollbackSites: caches.failureLogRollbackSites ?? runtime?.failureLogRollbackSites
     }
   };
 }
@@ -6230,6 +6232,12 @@ function choiceCannotCommit(prog, ip) {
 function failureRollbackClean(prog, ip) {
   return prog[TABLE_RUNTIME]?.failureRollbackCleanSites?.has(ip) === true;
 }
+function choiceLogRollbackMask(prog, ip) {
+  return prog[TABLE_RUNTIME]?.choiceLogRollbackMasks?.get(ip) ?? 0;
+}
+function failureLogRollback(prog, ip) {
+  return prog[TABLE_RUNTIME]?.failureLogRollbackSites?.has(ip) === true;
+}
 var WIDE_CLASS_PREFIX_LO = 65535;
 var WIDE_CLASS_PREFIX_HI = 0;
 function validateClassRange(lo, hi) {
@@ -6439,6 +6447,39 @@ function firstSetToString(fs3) {
   if (fs3.kind === "empty") return "(empty)";
   return fs3.ranges.map((r) => r.lo === r.hi ? ch(r.lo) : `${ch(r.lo)}-${ch(r.hi)}`).join(",");
 }
+function ruleDependencies(ruleMap) {
+  const nameOf3 = /* @__PURE__ */ new Map();
+  for (const [name, comb] of ruleMap) nameOf3.set(comb, name);
+  const deps = /* @__PURE__ */ new Map();
+  for (const [name, comb] of ruleMap) {
+    const found = /* @__PURE__ */ new Set();
+    const seen = /* @__PURE__ */ new Set();
+    const walk = (p, isRoot) => {
+      const def = p._def;
+      const boundary = def.tag === "lazy" ? nameOf3.get(p) ?? p._ruleName : nameOf3.get(p);
+      if (!isRoot && boundary !== void 0) {
+        found.add(boundary);
+        return;
+      }
+      if (seen.has(p)) return;
+      seen.add(p);
+      if (def.tag === "lazy") {
+        let resolved;
+        try {
+          resolved = def.thunk();
+        } catch {
+          return;
+        }
+        walk(resolved, false);
+        return;
+      }
+      for (const child of childrenOf2(def)) walk(child, false);
+    };
+    walk(comb, true);
+    deps.set(name, [...found]);
+  }
+  return deps;
+}
 
 // src/analysis/commitment.ts
 function mayFail(p, seen = /* @__PURE__ */ new Set()) {
@@ -6492,7 +6533,7 @@ function mayFail(p, seen = /* @__PURE__ */ new Set()) {
       return true;
   }
 }
-function mayLeavePartialCapture(p, seen = /* @__PURE__ */ new Set(), triviaActive = true) {
+function mayLeavePartialCapture(p, seen = /* @__PURE__ */ new Set(), triviaActive = true, throughNodes = false) {
   if (seen.has(p)) return false;
   seen.add(p);
   const d = p._def;
@@ -6517,17 +6558,26 @@ function mayLeavePartialCapture(p, seen = /* @__PURE__ */ new Set(), triviaActiv
       return false;
     // A run's prefixes are probed detached; only its body can capture.
     case "lines":
-      return mayLeavePartialCapture(d.body, seen, triviaActive);
-    // node() captures into its own private buffers and rolls them back on
-    // failure (emitNode restores _ctx.* and never pushes on the !ok path).
+      return mayLeavePartialCapture(d.body, seen, triviaActive, throughNodes);
+    // node() captures its children into a frame of its own and drops it on
+    // failure. The trivia logs (`_triviaLog`, `_rootTriviaLog`) are not part of
+    // that frame: trivia its body scanned before failing stays recorded. With
+    // `throughNodes` (a program that installs trivia somewhere) a node leaves
+    // what its body leaves; without, it leaves nothing.
     case "node":
-      return false;
-    // choice/firstMatch already roll back each failed arm; on overall failure
-    // nothing committed remains.
+      return throughNodes && mayLeavePartialCapture(d.parser, seen, triviaActive, throughNodes);
+    // choice/firstMatch already roll back each failed arm's captures; on overall
+    // failure nothing committed remains. The trivia logs are the exception: a
+    // choice the table lowers as an exclusive dispatch runs its one selected arm
+    // with no mark of its own (`emit-assembly.ts`, `table.exclusive`), so the
+    // rows that arm's trivia scans recorded stay when it fails. With
+    // `throughNodes` a choice leaves what one of its arms leaves, unless
+    // `throughNodes` is the encoder's answer that this choice marks and restores
+    // each arm it enters.
     case "choice":
-      return false;
+      return throughNodes !== false && !(typeof throughNodes === "function" && throughNodes(p)) && d.parsers.some((arm) => mayLeavePartialCapture(arm, new Set(seen), triviaActive, throughNodes));
     case "dispatch":
-      return capturesLeaf(d.selector, new Set(seen)) || d.cases.some((x) => mayLeavePartialCapture(x.parser, new Set(seen), triviaActive) || capturesLeaf(x.parser, new Set(seen))) || (d.matchers ? d.matchers.some((x) => mayLeavePartialCapture(x.parser, new Set(seen), triviaActive) || capturesLeaf(x.parser, new Set(seen))) : false) || (d.otherwise ? mayLeavePartialCapture(d.otherwise, new Set(seen), triviaActive) || capturesLeaf(d.otherwise, new Set(seen)) : false);
+      return capturesLeaf(d.selector, new Set(seen)) || d.cases.some((x) => mayLeavePartialCapture(x.parser, new Set(seen), triviaActive, throughNodes) || capturesLeaf(x.parser, new Set(seen))) || (d.matchers ? d.matchers.some((x) => mayLeavePartialCapture(x.parser, new Set(seen), triviaActive, throughNodes) || capturesLeaf(x.parser, new Set(seen))) : false) || (d.otherwise ? mayLeavePartialCapture(d.otherwise, new Set(seen), triviaActive, throughNodes) || capturesLeaf(d.otherwise, new Set(seen)) : false);
     case "attempt":
       return false;
     // optional never fails; many/oneOrMore only "fail" with zero captured items.
@@ -6569,7 +6619,7 @@ function mayLeavePartialCapture(p, seen = /* @__PURE__ */ new Set(), triviaActiv
         const part = parts[i];
         if (i > 0 && triviaActive) captured = true;
         if (captured && mayFail(part)) return true;
-        if (mayLeavePartialCapture(part, seen, triviaActive)) return true;
+        if (mayLeavePartialCapture(part, seen, triviaActive, throughNodes)) return true;
         if (capturesLeaf(part) || hasNodeDef(part)) captured = true;
       }
       return false;
@@ -6581,12 +6631,12 @@ function mayLeavePartialCapture(p, seen = /* @__PURE__ */ new Set(), triviaActiv
     case "expect":
     case "withCtx":
     case "grammar":
-      return mayLeavePartialCapture(d.parser, seen, triviaActive);
+      return mayLeavePartialCapture(d.parser, seen, triviaActive, throughNodes);
     case "recover":
-      return mayLeavePartialCapture(d.parser, seen, triviaActive);
+      return mayLeavePartialCapture(d.parser, seen, triviaActive, throughNodes);
     case "lazy": {
       try {
-        return mayLeavePartialCapture(d.thunk(), seen, triviaActive);
+        return mayLeavePartialCapture(d.thunk(), seen, triviaActive, throughNodes);
       } catch {
         return true;
       }
@@ -7589,6 +7639,32 @@ var Encoder = class {
   choiceRollbackMasks = /* @__PURE__ */ new Map();
   nonCommittingChoiceSites = /* @__PURE__ */ new Set();
   failureRollbackCleanSites = /* @__PURE__ */ new Set();
+  /**
+   * THE TRIVIA LOGS A FAILED NODE LEAVES. A node drops its own capture frame when
+   * it fails, but the trivia its body recorded into `_triviaLog`/`_rootTriviaLog`
+   * is not part of that frame. So a child the census above counts as clean can
+   * still leave trivia rows when it reaches a node whose body can fail after a
+   * trivia scan (`mayLeavePartialCapture`'s `throughNodes`). These are the arms
+   * and sites that need only the two logs restored. A program with no trivia of
+   * its own records rows only under trivia its caller supplies, so its emitted
+   * assembly takes these marks only for such a parse (`RunCfg.inheritedTrivia`).
+   */
+  choiceLogRollbackMasks = /* @__PURE__ */ new Map();
+  failureLogRollbackSites = /* @__PURE__ */ new Set();
+  /**
+   * HOW EACH CHOICE WAS LOWERED, for the census above. A choice on the ordered
+   * path whose arms cannot commit a failure restores the logs after every arm
+   * it enters (its full mark, or its own two-log mark), so it leaves no rows.
+   * An exclusive dispatch runs its one arm with no mark, and an ordered choice
+   * returns a committed arm's failure before restoring, so either leaves what an
+   * arm leaves. A choice in neither set, or in both, is taken to leave rows. Both
+   * sets are complete only once every rule is encoded, so the trivia-log census
+   * runs then (`logCensus`).
+   */
+  restoringChoices = /* @__PURE__ */ new Set();
+  leakingChoices = /* @__PURE__ */ new Set();
+  logCensus = [];
+  restoresArms = (choice2) => this.restoringChoices.has(choice2) && !this.leakingChoices.has(choice2);
   /**
    * `reachesSideWriter`'s answers, shared by every `failureNeedsRollback` call
    * for the lifetime of this `Encoder`. Every entry is exact — it depends only on
@@ -8163,11 +8239,19 @@ var Encoder = class {
    * not run repeat recovery, but these rows can still publish through a caller's
    * context.
    */
-  failureNeedsRollback(p, autoNot) {
+  failureNeedsRollback(p, autoNot, throughNodes) {
     const refName = p._ruleName;
     const winner = refName === void 0 ? void 0 : this.winners?.[refName];
     const root = winner !== void 0 && !winnerWrapsReference2(winner, p) ? winner : p;
-    return mayLeavePartialCapture(root, /* @__PURE__ */ new Set(), true) || this.reachesSideWriter(root) || (autoNot?.length ?? 0) > 0 && capturesLeaf(root);
+    return mayLeavePartialCapture(root, /* @__PURE__ */ new Set(), true, throughNodes) || this.reachesSideWriter(root) || (autoNot?.length ?? 0) > 0 && capturesLeaf(root);
+  }
+  /** The rollback census of an `optional()` or `attempt()` row at `ip` over `child`. */
+  censusTransaction(child, ip) {
+    if (this.failureNeedsRollback(child, void 0, false)) return;
+    this.failureRollbackCleanSites.add(ip);
+    this.logCensus.push(() => {
+      if (this.failureNeedsRollback(child, void 0, this.restoresArms)) this.failureLogRollbackSites.add(ip);
+    });
   }
   /**
    * Whether a field, recovered error, interpreted scanner or unresolvable shape
@@ -8789,13 +8873,11 @@ var Encoder = class {
         }
         const dispIdx = this.disp.length;
         this.disp.push(classes);
+        const exclusive = dispatchIsExclusive(classes, this.cc);
         let rollbackMask = kids.length > 31 ? -1 : 0;
         if (rollbackMask === 0) {
           for (let i = 0; i < arms.length; i++) {
-            const src = order[i];
-            if (this.failureNeedsRollback(arms[i], d.autoNot[src])) {
-              rollbackMask |= 1 << i;
-            }
+            if (this.failureNeedsRollback(arms[i], d.autoNot[order[i]], false)) rollbackMask |= 1 << i;
           }
         }
         const head = this.emitHead(OP_CHOICE, 3 + 2 * kids.length);
@@ -8807,9 +8889,19 @@ var Encoder = class {
           this.code[head + 4 + kids.length + i] = this.expected(deriveExpected(arms[i]));
         }
         this.choiceRollbackMasks.set(head, rollbackMask);
-        if (arms.every((arm) => !mayCommitFailure(arm, rr, this.commitFailureMemo))) {
-          this.nonCommittingChoiceSites.add(head);
+        if (rollbackMask !== -1) {
+          const full = rollbackMask;
+          this.logCensus.push(() => {
+            let logMask = 0;
+            for (let i = 0; i < arms.length; i++) {
+              if ((full & 1 << i) === 0 && this.failureNeedsRollback(arms[i], d.autoNot[order[i]], this.restoresArms)) logMask |= 1 << i;
+            }
+            if (logMask !== 0) this.choiceLogRollbackMasks.set(head, logMask);
+          });
         }
+        const nonCommitting = arms.every((arm) => !mayCommitFailure(arm, rr, this.commitFailureMemo));
+        if (nonCommitting) this.nonCommittingChoiceSites.add(head);
+        (!exclusive && nonCommitting ? this.restoringChoices : this.leakingChoices).add(p);
         return head;
       }
       case "many":
@@ -8845,7 +8937,7 @@ var Encoder = class {
       }
       case "optional": {
         const head = this.emit(OP_OPT, this.lookaheadGate(d.parser, this.node(d.parser).ip));
-        if (!this.failureNeedsRollback(d.parser, void 0)) this.failureRollbackCleanSites.add(head);
+        this.censusTransaction(d.parser, head);
         return head;
       }
       case "transform": {
@@ -9016,7 +9108,7 @@ var Encoder = class {
       // lowering was correct only for a choice arm.
       case "attempt": {
         const inner = this.emit(OP_ATTEMPT, this.node(d.parser).ip, d.contain === true ? 1 : 0);
-        if (!this.failureNeedsRollback(d.parser, void 0)) this.failureRollbackCleanSites.add(inner);
+        this.censusTransaction(d.parser, inner);
         const fs3 = this.gateFirstSet(d.parser, d.guarded === true, false);
         if (fs3.kind === "any" || matchesEmpty(d.parser, /* @__PURE__ */ new Set(), this.refResolver())) return inner;
         const cls = this.charClass(fs3);
@@ -9180,6 +9272,7 @@ var Encoder = class {
   finish() {
     if (this.code.length === 0) this.emit(OP_EMPTY);
     this.collapseIndirection();
+    for (const census of this.logCensus) census();
     return ownTableProgram({
       code: this.code,
       k: this.k,
@@ -9204,6 +9297,8 @@ var Encoder = class {
     }, void 0, {
       choiceRollbackMasks: this.choiceRollbackMasks,
       failureRollbackCleanSites: this.failureRollbackCleanSites,
+      choiceLogRollbackMasks: this.choiceLogRollbackMasks,
+      failureLogRollbackSites: this.failureLogRollbackSites,
       nonCommittingChoiceSites: this.nonCommittingChoiceSites
     });
   }
@@ -11090,6 +11185,13 @@ if(ctx._errors!==undefined&&ctx._errors.length!==${t}er)ctx._errors.length=${t}e
   if (!s.fd && !s.er) return `if(${t}n)rollbackTriviaAt(ctx,${t}raw,${t}tl,${t}lv,undefined,undefined,${t}lg,${t}rt)`;
   return `if(${t}n){rollbackTriviaAt(ctx,${t}raw,${t}tl,${t}lv,${s.fd ? `${t}fd` : "undefined"},${s.er ? `${t}er` : "undefined"},${t}lg,${t}rt)}`;
 }
+function emitLogMark(t) {
+  return `const ${t}lg=ctx._triviaLog!==undefined?ctx._triviaLog.length:0,${t}rt=ctx._rootTriviaLog!==undefined?ctx._rootTriviaLog.length:0`;
+}
+function emitLogRollback(t) {
+  return `{const g=ctx._triviaLog;if(g!==undefined)while(g.length>${t}lg)g.pop()}
+{const r=ctx._rootTriviaLog;if(r!==undefined)while(r.length>${t}rt)r.pop()}`;
+}
 function emitTerm(callee, dst, t, l, skip, miss) {
   const fast = `const ${t}v=${callee}(input,cur,ctx)
 if(${t}v===FAIL)return FAIL
@@ -11173,6 +11275,7 @@ function emitAssemblySource(t, prog, cfg, extraIps = [], staticBuild = false, se
   const { code, k, fx, disp, dsp, triviaLabelled } = t;
   const swapLegal = !cfg.trackLines;
   const hostCst = cfg.hostCst;
+  const LOGS = (prog.triviaSpecs?.length ?? 0) > 0 || cfg.inheritedTrivia === true;
   const REC2 = prog.rec === 1 && cfg.tolerant;
   if (cfg.coverage) throw new Unemittable("a coverage assembly");
   const roots = [...Object.values(prog.rules), ...extraIps];
@@ -11941,12 +12044,13 @@ return v
       case OP_ATTEMPT: {
         const child = link(code[ip + 1]);
         const clean = !REC2 && failureRollbackClean(prog, ip);
+        const logs = clean && LOGS && failureLogRollback(prog, ip);
         const p = tmp();
         return `${head}
-${clean ? "" : emitMark(p, L.buf, L.raw, sinks)}
+${clean ? logs ? emitLogMark(p) : "" : 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)}
+${clean ? logs ? emitLogRollback(p) : "" : emitRollback(p, L.buf, L.raw, sinks)}
 ${code[ip + 2] === 1 ? "ctx._fc=false" : "if(ctx._fc===true)return FAIL"}
 ctx._fe=pos
 return FAIL
@@ -11972,6 +12076,7 @@ return FAIL
 ${lookaheadMiss(code[ip + 1], "EC.e=pos;return null")}${emitMark(p, L.buf, L.raw, sinks)}
 ${cfg.probe ? "const pb=ctx._probe?.best\n" : ""}const v=${child}(input,pos,ctx)
 ${emitRollback(p, L.buf, L.raw, sinks)}
+ctx._fc=false
 ${cfg.probe ? "if(ctx._probe!==undefined)ctx._probe.best=pb??null\n" : ""}if(v===FAIL){EC.e=pos;return null}
 ctx._fe=pos
 ctx._fx=${xf}
@@ -11996,6 +12101,7 @@ return null
 ${lookaheadMiss(code[ip + 1], `ctx._fe=pos;ctx._fx=${xf};return FAIL`)}${emitMark(p, L.buf, L.raw, sinks)}
 ${cfg.probe ? "const pb=ctx._probe?.best\n" : ""}const v=${child}(input,pos,ctx)
 ${emitRollback(p, L.buf, L.raw, sinks)}
+ctx._fc=false
 ${cfg.probe ? "if(ctx._probe!==undefined)ctx._probe.best=pb??null\n" : ""}if(v===FAIL){ctx._fe=pos;ctx._fx=${xf};return FAIL}
 EC.e=pos
 return null
@@ -12004,14 +12110,15 @@ return null
       case OP_OPT: {
         const child = link(code[ip + 1]);
         const clean = !REC2 && failureRollbackClean(prog, ip);
+        const logs = clean && LOGS && failureLogRollback(prog, ip);
         const p = tmp();
         return `${head}
-${lookaheadMiss(code[ip + 1], "EC.e=pos;return null")}${clean ? "" : emitMark(p, L.buf, L.raw, sinks)}
+${lookaheadMiss(code[ip + 1], "EC.e=pos;return null")}${clean ? logs ? emitLogMark(p) : "" : emitMark(p, L.buf, L.raw, sinks)}
 ctx._fc=false
 const v=${child}(input,pos,ctx)
 if(v===FAIL){
 if(ctx._fc===true)return FAIL
-${clean ? "" : emitRollback(p, L.buf, L.raw, sinks)}
+${clean ? logs ? emitLogRollback(p) : "" : emitRollback(p, L.buf, L.raw, sinks)}
 EC.e=pos
 return null
 }
@@ -12161,6 +12268,10 @@ return FAIL
           const encodedRollbackMask = choiceRollbackMask(prog, ip) ?? -1;
           const rollbackMask = REC2 ? -1 : encodedRollbackMask;
           const hasRollback = rollbackMask !== 0;
+          const logMask = rollbackMask === -1 || !LOGS ? 0 : choiceLogRollbackMask(prog, ip);
+          const choiceMark = hasRollback ? emitMark(p, L.buf, L.raw, sinks) : "";
+          const armMark = (i) => !hasRollback && (logMask & 1 << i) !== 0 ? `${emitLogMark(p)}
+` : "";
           const startFailureExact = arms.every((_arm, i) => {
             const terminal = leadingScalarTerminal(code, code[base + i], 0, false);
             if (terminal < 0) return false;
@@ -12172,7 +12283,7 @@ return FAIL
             if (op2 === OP_LIT) return typeof spec === "string" && spec.length > 0;
             return op2 === OP_RX && spec instanceof RegExp && !regexCanMatchEmpty(spec.source);
           });
-          const rollbackFor = (i) => rollbackMask === -1 || (rollbackMask & 1 << i) !== 0 ? emitRollback(p, L.buf, L.raw, sinks) : "";
+          const rollbackFor = (i) => rollbackMask === -1 || (rollbackMask & 1 << i) !== 0 ? emitRollback(p, L.buf, L.raw, sinks) : (logMask & 1 << i) === 0 ? "" : hasRollback ? emitRollback(p, L.buf, L.raw, sinks) : emitLogRollback(p);
           if (choiceCannotCommit(prog, ip) && !startFailureExact) {
             const deepAt = Array.from({ length: n }, () => tmp());
             const deepFx = Array.from({ length: n }, () => tmp());
@@ -12198,7 +12309,7 @@ ${remember2(i, "at", pretest.sequence.expected.map((value, at) => `${decision}==
 }`;
               return `${decision === "" ? "" : `let ${decision}=${pretest?.sequence === void 0 ? -1 : 0}
 `}if(${gate2}){
-ctx._fc=false
+${armMark(i)}ctx._fc=false
 {const v=${arm}(input,pos,ctx)
 if(v!==FAIL)return v}
 {const at=ctx._fe??pos
@@ -12217,7 +12328,7 @@ ctx._fe=pos;ctx._fx=acc??${choiceFx}
 return FAIL`;
             return `${head}
 const c=${directAsciiMask ? "input.charCodeAt(pos)" : "lead(input,pos)"}
-${hasRollback ? emitMark(p, L.buf, L.raw, sinks) : ""}
+${choiceMark}
 ${deepAt.map((at, i) => `let ${at},${deepFx[i]}`).join("\n")}
 ${maskable ? `if(c<128){
 const bits=${maskName}[${directAsciiMask ? "c" : "c<0?128:c"}]
@@ -12264,7 +12375,7 @@ if(at===best${startFailureExact ? "&&at>pos" : ""})acc=_accSet(${pretest.sequenc
 }`;
             return `${decision === "" ? "" : `let ${decision}=${pretest?.sequence === void 0 ? -1 : 0}
 `}if((bits&${1 << i})!==0${condition}){
-ctx._fc=false
+${armMark(i)}ctx._fc=false
 {const v=${arm}(input,pos,ctx)
 if(v!==FAIL)return v}
 ${startFailureExact ? "" : `if(best===pos)acc=${catchName}(${i},prev,acc)
@@ -12295,7 +12406,7 @@ if(at===best${startFailureExact ? "&&at>pos" : ""})acc=_accSet(${pretest.token.e
 }${startFailureExact ? "" : `else if(best===pos)acc=_accSet(${expected[i]},acc)`}`;
             return `${decision === "" ? "" : `let ${decision}=${pretest?.sequence === void 0 ? -1 : 0}
 `}if((${gateRefs[i]}===null||classHas(${gateRefs[i]},c))${condition}){
-ctx._fc=false
+${armMark(i)}ctx._fc=false
 {const v=${arm}(input,pos,ctx)
 if(v!==FAIL)return v}
 {const at=ctx._fe??pos
@@ -12307,7 +12418,7 @@ ${rollbackFor(i)}
           }).join("\n");
           return `${head}
 const c=${directAsciiMask ? "input.charCodeAt(pos)" : "lead(input,pos)"}
-${hasRollback ? emitMark(p, L.buf, L.raw, sinks) : ""}
+${choiceMark}
 let acc
 let best=pos
 ${maskable ? `if(c<128){
@@ -13387,7 +13498,7 @@ function clearOf(ranges, input, from, to) {
 }
 
 // src/version.ts
-var PARSEMAN_VERSION = "0.60.2";
+var PARSEMAN_VERSION = "0.60.4";
 
 // src/table/assemble.ts
 import { PlainBuf as PlainBuf2, PlainField, PlainLeaf as PlainLeaf9, PlainNode as PlainNode2, PlainSpan as PlainSpan10 } from "../cst/plain.js";
@@ -13659,11 +13770,11 @@ function linkMatcher(m) {
 }
 var NO_COVERAGE = (_id) => {
 };
-function cfgKeyOf(hostCst, trackLines, tolerant, coverage, probe, hostReadsChildren = true) {
-  return (hostCst ? 1 : 0) | (trackLines ? 2 : 0) | (tolerant ? 4 : 0) | (coverage ? 8 : 0) | (probe ? 16 : 0) | (hostReadsChildren ? 0 : 32);
+function cfgKeyOf(hostCst, trackLines, tolerant, coverage, probe, hostReadsChildren = true, inheritedTrivia = false) {
+  return (hostCst ? 1 : 0) | (trackLines ? 2 : 0) | (tolerant ? 4 : 0) | (coverage ? 8 : 0) | (probe ? 16 : 0) | (hostReadsChildren ? 0 : 32) | (inheritedTrivia ? 64 : 0);
 }
 function cfgKey(c) {
-  return cfgKeyOf(c.hostCst, c.trackLines, c.tolerant, c.coverage, c.probe, c.hostReadsChildren);
+  return cfgKeyOf(c.hostCst, c.trackLines, c.tolerant, c.coverage, c.probe, c.hostReadsChildren, c.inheritedTrivia);
 }
 function assertFactoryArity(pre) {
   if (pre.arity === EMITTED_PARAMS.length) return;
@@ -15038,6 +15149,7 @@ function assemble(t, prog, cfg) {
           const probeBest = PROBE ? ctx._probe?.best : void 0;
           const v = child(input, pos, ctx);
           if (need) rollbackTriviaAt(ctx, mRaw, mTl, mLv, mFl, mEr, mLog, mRoot);
+          ctx._fc = false;
           if (PROBE && ctx._probe !== void 0) ctx._probe.best = probeBest ?? null;
           if (v === FAIL) {
             EC.e = pos;
@@ -15083,6 +15195,7 @@ function assemble(t, prog, cfg) {
           const probeBest = PROBE ? ctx._probe?.best : void 0;
           const v = child(input, pos, ctx);
           if (need) rollbackTriviaAt(ctx, mRaw, mTl, mLv, mFl, mEr, mLog, mRoot);
+          ctx._fc = false;
           if (PROBE && ctx._probe !== void 0) ctx._probe.best = probeBest ?? null;
           if (v === FAIL) {
             ctx._fe = pos;
@@ -16941,7 +17054,7 @@ function assemble(t, prog, cfg) {
       if (emitted !== void 0) throw new ServedByBuild();
       if (prog.asm !== void 0) {
         throw new Unemittable(
-          `option set ${cfgKey(cfg)} (hostCst=${cfg.hostCst} trackLines=${cfg.trackLines} tolerant=${cfg.tolerant} coverage=${cfg.coverage} probe=${cfg.probe}), which this build did not pre-compile. The Function constructor is NOT used for an artifact that carries assemblies \u2014 see \`EmitOptions.assemblies\` to add this option set to the build`
+          `option set ${cfgKey(cfg)} (hostCst=${cfg.hostCst} trackLines=${cfg.trackLines} tolerant=${cfg.tolerant} coverage=${cfg.coverage} probe=${cfg.probe} inheritedTrivia=${cfg.inheritedTrivia === true}), which this build did not pre-compile. The Function constructor is NOT used for an artifact that carries assemblies \u2014 see \`EmitOptions.assemblies\` to add this option set to the build`
         );
       }
       if (!EMIT_ENABLED) throw new Unemittable("PM_TABLE_EMIT=0 (measurement toggle)");
@@ -17151,7 +17264,9 @@ function countSiteVisits(prog, parse2, fns = prog.fns) {
 var AssemblyCache = class {
   t;
   prog;
-  byCfg = Array.from({ length: 64 });
+  byCfg = Array.from({ length: 128 });
+  /** Whether this program installs no trivia of its own (`RunCfg.inheritedTrivia`). */
+  noOwnTrivia;
   /**
    * Monomorphic predicate inline cache. An assembly depends on the predicate
    * FUNCTION and the scalar cfg key, not on the host object that carries it, so
@@ -17164,6 +17279,7 @@ var AssemblyCache = class {
   constructor(prog, resolved = resolveTable(prog)) {
     this.prog = prog;
     this.t = resolved;
+    this.noOwnTrivia = prog.triviaSpecs === void 0 || prog.triviaSpecs.length === 0;
   }
   for(cfg) {
     const key = cfgKey(cfg);
@@ -17227,13 +17343,14 @@ var AssemblyCache = class {
     const tolerant = ctx._tolerant === true;
     const coverage = ctx._grammarCoverage !== void 0;
     const probe = ctx._probe !== void 0;
-    const key = cfgKeyOf(hostCst, trackLines, tolerant, coverage, probe, hostReadsChildren);
+    const inheritedTrivia = this.noOwnTrivia && ctx.trivia !== void 0;
+    const key = cfgKeyOf(hostCst, trackLines, tolerant, coverage, probe, hostReadsChildren, inheritedTrivia);
     let cache = this.byCfg;
     if (hostCaptureTrivia !== void 0) {
       if (this.hostPredicate === hostCaptureTrivia) {
         cache = this.hostAssemblies;
       } else {
-        cache = Array.from({ length: 64 });
+        cache = Array.from({ length: 128 });
         this.hostPredicate = hostCaptureTrivia;
         this.hostAssemblies = cache;
       }
@@ -17247,7 +17364,8 @@ var AssemblyCache = class {
       trackLines,
       tolerant,
       coverage,
-      probe
+      probe,
+      inheritedTrivia
     });
     cache[key] = made;
     return made;
@@ -19387,9 +19505,9 @@ function matcherExpr(entry) {
       return `matches(${new RegExp(entry.value, entry.flags ?? "").toString()})`;
   }
 }
-function serializeRuleMap(ruleMap, scanSkip) {
+function serializeRuleMap(ruleMap, scanSkip, accessed) {
   try {
-    return new Serializer(ruleMap, scanSkip ?? []).run();
+    return new Serializer(ruleMap, scanSkip ?? [], accessed ?? []).run();
   } catch (e) {
     if (e instanceof Unserializable) {
       if (typeof process !== "undefined" && process.env?.PARSEMAN_IR_DEBUG) console.error(`[ir] fallback: ${e.message}`);
@@ -19414,9 +19532,12 @@ var Serializer = class {
   localRuleNames = /* @__PURE__ */ new Map();
   ruleMap;
   scanSkip;
-  constructor(ruleMap, scanSkip = []) {
+  accessed;
+  referenced = /* @__PURE__ */ new Set();
+  constructor(ruleMap, scanSkip = [], accessed = []) {
     this.ruleMap = ruleMap;
     this.scanSkip = scanSkip;
+    this.accessed = accessed;
     for (const [name, c] of ruleMap) {
       this.localRuleNames.set(c, name);
       this.ruleValues.add(this.body(c));
@@ -19492,6 +19613,9 @@ var Serializer = class {
     }
     this.decls = innerDecls;
     const body = this.ruleMap.map(([name, c]) => `  ${JSON.stringify(name)}: ${this.wrap(this.body(c), [])}`).join(",\n");
+    for (const name of this.accessed) {
+      if (!this.referenced.has(name)) innerDecls.push(`void g[${JSON.stringify(name)}]`);
+    }
     const factory = innerDecls.length === 0 ? `(g) => ({
 ${body}
 })` : `(g) => {
@@ -19590,7 +19714,10 @@ ${outerDecls.map((d) => "  " + d).join("\n")}
     switch (def.tag) {
       case "lazy": {
         const name = this.localRuleNames.get(c) ?? ruleNameOf3(c);
-        if (name !== void 0) return `g[${JSON.stringify(name)}]`;
+        if (name !== void 0) {
+          this.referenced.add(name);
+          return `g[${JSON.stringify(name)}]`;
+        }
         const target = lazyTarget(c);
         for (let i = frames.length - 1; i >= 0; i--) {
           const f = frames[i];
@@ -19831,6 +19958,24 @@ function cstBuildHost(typeOrOptions, children3, _fields, span, rawChildren, triv
 }
 cstBuildHost._parsemanCstOutput = true;
 var COMPOSED_PIECES = /* @__PURE__ */ Symbol.for("parseman.composedPieces");
+function danglingReference(map, accessed = []) {
+  const holes = /* @__PURE__ */ new Set();
+  for (const [name, rule] of Object.entries(map)) {
+    if (rule._def.tag !== "lazy") continue;
+    try {
+      rule._def.thunk();
+    } catch {
+      holes.add(name);
+    }
+  }
+  for (const name of accessed) if (!Object.hasOwn(map, name)) holes.add(name);
+  if (holes.size === 0) return void 0;
+  const missing = [...holes];
+  for (const [name, deps] of ruleDependencies(Object.entries(map).filter(([n]) => !holes.has(n)))) {
+    for (const dep of deps) if (holes.has(dep)) return `rule "${name}" references missing rule "${dep}"`;
+  }
+  return `rule(s) ${missing.map((n) => `"${n}"`).join(", ")} are referenced but defined by no composed grammar`;
+}
 
 // src/cst/trivia-entries.ts
 var EMPTY_INDICES = Object.freeze([]);
@@ -21443,8 +21588,11 @@ function evaluateParserFactory(factoryNode, scope, code, mapFnSources, out, opti
   }
   const map = /* @__PURE__ */ new Map();
   for (const key of keys) map.set(key, built[key]);
+  const declared = new Set(keys);
+  externalAccesses.set(map, Object.keys(built).filter((name) => !declared.has(name)));
   return map;
 }
+var externalAccesses = /* @__PURE__ */ new WeakMap();
 function isDefinableRef2(v) {
   return isCombinator3(v) && typeof v.define === "function" && v._def.tag === "lazy";
 }
@@ -22785,6 +22933,17 @@ function corpusTexts(profile) {
 }
 var PARSEMAN_MODULE = "parseman";
 var DEFAULT_ASSEMBLY_BUDGET = 0.25;
+var LinkRefusal = class extends Error {
+};
+function isResolved(rule) {
+  if (rule._def.tag !== "lazy") return true;
+  try {
+    rule._def.thunk();
+    return true;
+  } catch {
+    return false;
+  }
+}
 function reasonSuffix(runtimeOnly) {
   return runtimeOnly === void 0 || runtimeOnly.length === 0 ? "" : ` \u2014 ${runtimeOnly.join("; ")}`;
 }
@@ -23937,16 +24096,8 @@ ${names.map((n) => `  - ${n}`).join("\n")}` : " (it is not a static combinator/v
     const carriedMaps = carriedRuleMaps(items);
     if (carriedMaps === null) return null;
     const linked = linkRules(carriedMaps.pieces.flatMap((p) => p.recipes), link);
-    const rules2 = Object.entries(linked).filter(([, rule]) => {
-      if (rule._def.tag !== "lazy") return true;
-      try {
-        rule._def.thunk();
-        return true;
-      } catch {
-        return false;
-      }
-    });
-    return { rules: rules2, trackLines: carriedMaps.trackLines };
+    const dangling = danglingReference(linked);
+    return { rules: Object.entries(linked), trackLines: carriedMaps.trackLines, dangling };
   };
   const applyComposingTrivia = (ruleMap, composing) => {
     for (const [, rule] of ruleMap) {
@@ -23958,7 +24109,7 @@ ${names.map((n) => `  - ${n}`).join("\n")}` : " (it is not a static combinator/v
     const entries = [...rm];
     const ns = nsFor(label2);
     const trackLines = entries.some(([, rule]) => rule?._meta?.grammarTrackLines === true);
-    const ir = serializeRuleMap(entries, scanSkip);
+    const ir = serializeRuleMap(entries, scanSkip, rm instanceof Map ? externalAccesses.get(rm) : void 0);
     if (ir) return { carried: [{ ns, ir, ...trackLines ? { trackLines: true } : {} }] };
     warn(0, `${label2}: rule map could not be serialized to IR, so it cannot be carried for composition. Re-run with PARSEMAN_IR_DEBUG=1 to print the exact combinator that blocked serialization.`);
     return null;
@@ -24045,6 +24196,7 @@ ${names.map((n) => `  - ${n}`).join("\n")}` : " (it is not a static combinator/v
       trivia: composing,
       ...cHostMode ? { hostMode: cHostMode } : {}
     });
+    if (merged?.dangling !== void 0) throw new Error(`${id}:${lineOf(init.start)} \u2014 compose: ${merged.dangling}`);
     if (merged !== null) {
       collectBuilderImports(merged.rules);
       const refusals = [];
@@ -24181,6 +24333,12 @@ ${names.map((n) => `  - ${n}`).join("\n")}` : " (it is not a static combinator/v
           }
         }
         const leafMerged = mergeRuleMaps([...carriedMaps.pieces.map((p) => p.rules), localEntries]);
+        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);
+        if (dangling !== void 0) throw new LinkRefusal(`${id}:${lineOf(init.start)} \u2014 composeLeaf: ${dangling}`);
         if (composing) applyComposingTrivia(carriedMaps.pieces.flatMap((p) => p.rules), composing);
         const refusals = [];
         const compiled = compileRuleMap(
@@ -24210,6 +24368,7 @@ ${names.map((n) => `  - ${n}`).join("\n")}` : " (it is not a static combinator/v
       warn(init.start, "composeLeaf(): a recognition piece has no re-lowerable IR");
       return null;
     } catch (e) {
+      if (e instanceof LinkRefusal) throw e;
       warn(init.start, `composeLeaf(): ${e.message}`);
       return null;
     }
@@ -24315,7 +24474,7 @@ ${names.map((n) => `  - ${n}`).join("\n")}` : " (it is not a static combinator/v
           const source = compiledRules.replacement ?? code.slice(init.start, init.end);
           let carriedMetadata;
           if (exportPrefix && pieces) {
-            const ir = serializeRuleMap([...compiledRules.ruleMap], compiledRules.scanSkip);
+            const ir = serializeRuleMap([...compiledRules.ruleMap], compiledRules.scanSkip, externalAccesses.get(compiledRules.ruleMap));
             if (ir) carriedMetadata = [{ ns, ir, ...compiledRules.trackLines ? { trackLines: true } : {} }];
             else warn(init.start, `${varName}: exported grammar could not be serialized to IR, so it carries no composable pieces \u2014 a downstream compose() of this grammar will fall back to runtime. Re-run with PARSEMAN_IR_DEBUG=1 to print the combinator that blocked serialization.`);
             if (carriedMetadata !== void 0 && sinkCarried(varName, carriedMetadata)) carriedMetadata = void 0;