parseman 0.60.2 → 0.60.3

package/dist/cli/index.js

@@ -3780,7 +3780,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;
@@ -3805,17 +3805,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.
@@ -3857,7 +3866,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;
@@ -3869,12 +3878,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;
       }
@@ -5810,7 +5819,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
     }
   };
 }
@@ -5823,6 +5834,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) {
@@ -7383,6 +7400,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
@@ -7957,11 +8000,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
@@ -8583,13 +8634,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);
@@ -8601,9 +8650,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":
@@ -8639,7 +8698,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": {
@@ -8810,7 +8869,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 fs = this.gateFirstSet(d.parser, d.guarded === true, false);
         if (fs.kind === "any" || matchesEmpty(d.parser, /* @__PURE__ */ new Set(), this.refResolver())) return inner;
         const cls = this.charClass(fs);
@@ -8974,6 +9033,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,
@@ -8998,6 +9058,8 @@ var Encoder = class {
     }, void 0, {
       choiceRollbackMasks: this.choiceRollbackMasks,
       failureRollbackCleanSites: this.failureRollbackCleanSites,
+      choiceLogRollbackMasks: this.choiceLogRollbackMasks,
+      failureLogRollbackSites: this.failureLogRollbackSites,
       nonCommittingChoiceSites: this.nonCommittingChoiceSites
     });
   }
@@ -10884,6 +10946,13 @@ if(ctx._errors!==undefined&&ctx._errors.length!==${t2}er)ctx._errors.length=${t2
   if (!s.fd && !s.er) return `if(${t2}n)rollbackTriviaAt(ctx,${t2}raw,${t2}tl,${t2}lv,undefined,undefined,${t2}lg,${t2}rt)`;
   return `if(${t2}n){rollbackTriviaAt(ctx,${t2}raw,${t2}tl,${t2}lv,${s.fd ? `${t2}fd` : "undefined"},${s.er ? `${t2}er` : "undefined"},${t2}lg,${t2}rt)}`;
 }
+function emitLogMark(t2) {
+  return `const ${t2}lg=ctx._triviaLog!==undefined?ctx._triviaLog.length:0,${t2}rt=ctx._rootTriviaLog!==undefined?ctx._rootTriviaLog.length:0`;
+}
+function emitLogRollback(t2) {
+  return `{const g=ctx._triviaLog;if(g!==undefined)while(g.length>${t2}lg)g.pop()}
+{const r=ctx._rootTriviaLog;if(r!==undefined)while(r.length>${t2}rt)r.pop()}`;
+}
 function emitTerm(callee, dst, t2, l, skip, miss) {
   const fast = `const ${t2}v=${callee}(input,cur,ctx)
 if(${t2}v===FAIL)return FAIL
@@ -10967,6 +11036,7 @@ function emitAssemblySource(t2, prog, cfg, extraIps = [], staticBuild = false, s
   const { code, k, fx, disp, dsp, triviaLabelled } = t2;
   const swapLegal = !cfg.trackLines;
   const hostCst = cfg.hostCst;
+  const LOGS = (prog.triviaSpecs?.length ?? 0) > 0 || cfg.inheritedTrivia === true;
   const REC = prog.rec === 1 && cfg.tolerant;
   if (cfg.coverage) throw new Unemittable("a coverage assembly");
   const roots = [...Object.values(prog.rules), ...extraIps];
@@ -11735,12 +11805,13 @@ return v
       case OP_ATTEMPT: {
         const child = link(code[ip + 1]);
         const clean = !REC && 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
@@ -11766,6 +11837,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}
@@ -11790,6 +11862,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
@@ -11798,14 +11871,15 @@ return null
       case OP_OPT: {
         const child = link(code[ip + 1]);
         const clean = !REC && 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
 }
@@ -11955,6 +12029,10 @@ return FAIL
           const encodedRollbackMask = choiceRollbackMask(prog, ip) ?? -1;
           const rollbackMask = REC ? -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;
@@ -11966,7 +12044,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());
@@ -11992,7 +12070,7 @@ ${remember2(i, "at", pretest.sequence.expected.map((value, at) => `${decision}==
 }`;
               return `${decision === "" ? "" : `let ${decision}=${pretest?.sequence === void 0 ? -1 : 0}
 `}if(${gate}){
-ctx._fc=false
+${armMark(i)}ctx._fc=false
 {const v=${arm}(input,pos,ctx)
 if(v!==FAIL)return v}
 {const at=ctx._fe??pos
@@ -12011,7 +12089,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"}]
@@ -12058,7 +12136,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)
@@ -12089,7 +12167,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
@@ -12101,7 +12179,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){
@@ -13337,7 +13415,7 @@ function clearOf(ranges, input, from, to) {
 }
 
 // src/version.ts
-var PARSEMAN_VERSION = "0.60.2";
+var PARSEMAN_VERSION = "0.60.3";
 
 // src/table/assemble.ts
 import { PlainBuf as PlainBuf2, PlainField, PlainLeaf as PlainLeaf9, PlainNode as PlainNode2, PlainSpan as PlainSpan10 } from "../cst/plain.js";
@@ -13592,11 +13670,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;
@@ -14971,6 +15049,7 @@ function assemble(t2, 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;
@@ -15016,6 +15095,7 @@ function assemble(t2, 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;
@@ -16874,7 +16954,7 @@ function assemble(t2, 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)");
@@ -17073,7 +17153,9 @@ function countedPiece(piece, ip) {
 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
@@ -17086,6 +17168,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);
@@ -17149,13 +17232,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;
       }
@@ -17169,7 +17253,8 @@ var AssemblyCache = class {
       trackLines,
       tolerant,
       coverage,
-      probe
+      probe,
+      inheritedTrivia
     });
     cache[key] = made;
     return made;