parseman 0.51.2 → 0.53.0

package/dist/table/emit-assembly.d.ts.map

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

package/dist/table/encode-baseline.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"encode-baseline.d.ts","sourceRoot":"","sources":["../../src/table/encode-baseline.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAuB,MAAM,aAAa,CAAA;AASlE,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,cAAc,CAAA;AAQhD,8EAA8E;AAC9E,MAAM,MAAM,aAAa,GAAG;IAC1B,QAAQ,CAAC,QAAQ,CAAC,EAAE,KAAK,GAAG,KAAK,CAAA;IACjC,QAAQ,CAAC,UAAU,CAAC,EAAE,OAAO,CAAA;CAC9B,CAAA;AAiTD;;;;;;GAMG;AACH,wBAAgB,mBAAmB,CACjC,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,UAAU,CAAC,OAAO,CAAC,CAAC,EAC5C,QAAQ,GAAE,aAAkB,GAC3B,YAAY,CAId"}
+{"version":3,"file":"encode-baseline.d.ts","sourceRoot":"","sources":["../../src/table/encode-baseline.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAuB,MAAM,aAAa,CAAA;AASlE,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,cAAc,CAAA;AAQhD,8EAA8E;AAC9E,MAAM,MAAM,aAAa,GAAG;IAC1B,QAAQ,CAAC,QAAQ,CAAC,EAAE,KAAK,GAAG,KAAK,CAAA;IACjC,QAAQ,CAAC,UAAU,CAAC,EAAE,OAAO,CAAA;CAC9B,CAAA;AAqTD;;;;;;GAMG;AACH,wBAAgB,mBAAmB,CACjC,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,UAAU,CAAC,OAAO,CAAC,CAAC,EAC5C,QAAQ,GAAE,aAAkB,GAC3B,YAAY,CAId"}

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

@@ -1 +1 @@
-{"version":3,"file":"exec.d.ts","sourceRoot":"","sources":["../../src/table/exec.ts"],"names":[],"mappings":"AA6CA,OAAO,EAEL,KAAK,cAAc,EACF,KAAK,YAAY,EAAE,KAAK,SAAS,EACnD,MAAM,cAAc,CAAA;AA0BrB;;;;;;;;GAQG;AACH,eAAO,MAAM,aAAa,EAAE;IAC1B,IAAI,EAAE,MAAM,CAAA;IACZ,IAAI,EAAE,UAAU,CAAA;IAChB,+EAA+E;IAC/E,KAAK,EAAE,GAAG,CAAC,MAAM,EAAE,GAAG,CAAC,OAAO,CAAC,CAAC,CAAA;IAChC;;;;;;;;;;;OAWG;IACH,cAAc,EAAE,MAAM,CAAA;IACtB,YAAY,EAAE,MAAM,CAAA;IACpB,sFAAsF;IACtF,eAAe,EAAE,MAAM,CAAA;IACvB,YAAY,EAAE,MAAM,CAAA;IACpB,qFAAqF;IACrF,YAAY,EAAE,MAAM,CAAA;CAC+H,CAAA;AAUrJ,wBAAgB,kBAAkB,IAAI,IAAI,CASzC;AAukDD;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,SAAS,CACvB,MAAM,EAAE,YAAY,GAAG,cAAc;AACrC;;;;;;;;GAQG;AACH,IAAI,GAAE;IAAE,QAAQ,CAAC,EAAE,OAAO,CAAA;CAAO,EACjC,gBAAgB,GAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAM,GACvD,MAAM,CAAC,MAAM,EAAE,SAAS,CAAC,CA8B3B"}
+{"version":3,"file":"exec.d.ts","sourceRoot":"","sources":["../../src/table/exec.ts"],"names":[],"mappings":"AA6CA,OAAO,EAEL,KAAK,cAAc,EACF,KAAK,YAAY,EAAE,KAAK,SAAS,EACnD,MAAM,cAAc,CAAA;AA0BrB;;;;;;;;GAQG;AACH,eAAO,MAAM,aAAa,EAAE;IAC1B,IAAI,EAAE,MAAM,CAAA;IACZ,IAAI,EAAE,UAAU,CAAA;IAChB,+EAA+E;IAC/E,KAAK,EAAE,GAAG,CAAC,MAAM,EAAE,GAAG,CAAC,OAAO,CAAC,CAAC,CAAA;IAChC;;;;;;;;;;;OAWG;IACH,cAAc,EAAE,MAAM,CAAA;IACtB,YAAY,EAAE,MAAM,CAAA;IACpB,sFAAsF;IACtF,eAAe,EAAE,MAAM,CAAA;IACvB,YAAY,EAAE,MAAM,CAAA;IACpB,qFAAqF;IACrF,YAAY,EAAE,MAAM,CAAA;CAC+H,CAAA;AAUrJ,wBAAgB,kBAAkB,IAAI,IAAI,CASzC;AA2kDD;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,SAAS,CACvB,MAAM,EAAE,YAAY,GAAG,cAAc;AACrC;;;;;;;;GAQG;AACH,IAAI,GAAE;IAAE,QAAQ,CAAC,EAAE,OAAO,CAAA;CAAO,EACjC,gBAAgB,GAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAM,GACvD,MAAM,CAAC,MAAM,EAAE,SAAS,CAAC,CA8B3B"}

package/dist/table/index.js

@@ -257,6 +257,10 @@ function firstSetBody(p, seen, resolve, activeTrivia) {
     case "node":
     case "sepBy":
     case "expect":
+    // A transaction accepts exactly what its inner accepts. Its own `_meta` is
+    // the inner's construction-time set, which reads `any` when the inner opens
+    // with a rule reference — resolve through it like any other wrapper.
+    case "attempt":
       return fs(d.parser);
     case "grammar":
       return firstSetOf(
@@ -1621,6 +1625,10 @@ function peelLabel(p) {
   return null;
 }
 function analyzeLabeledTrivia(trivia2) {
+  if (trivia2._def.tag === "trivia") {
+    const own = trivia2._meta.labeledTriviaSpec;
+    if (own !== void 0) return own;
+  }
   if (trivia2 === labeledTrivia0) return labeledSpec0;
   if (trivia2 === labeledTrivia1) return labeledSpec1;
   if (trivia2 === labeledTrivia2) return labeledSpec2;
@@ -3286,13 +3294,17 @@ function transform(combinator, fn) {
   };
 }
 function trivia(combinator) {
-  const kindLabels = analyzeLabeledTrivia(combinator)?.labels;
+  const labeled = analyzeLabeledTrivia(combinator);
+  const kindLabels = labeled?.labels;
   return {
     _tag: combinator._tag,
     _meta: {
       ...combinator._meta,
       isTrivia: true,
       triviaScanner: fastTriviaScanner(combinator),
+      // Every labeled scan of this trivia reads its spec; the module's four-slot
+      // memo alone thrashes on a grammar with more than four trivia tables.
+      labeledTriviaSpec: labeled,
       ...kindLabels ? { triviaKindLabels: kindLabels } : {}
     },
     _def: { tag: "trivia", parser: combinator },
@@ -3380,6 +3392,7 @@ function withRuleTrivia(trivia2, ctx, run) {
     ctx.triviaKindLabels = savedLabels;
   }
 }
+var UNDEFINED_REF = new Error("ref<T>() used before .define() was called");
 function ref() {
   let resolved = null;
   let resolvedScalar = null;
@@ -3395,7 +3408,7 @@ function ref() {
     _def: {
       tag: "lazy",
       thunk: () => {
-        if (!resolved) throw new Error("ref<T>() used before .define() was called");
+        if (!resolved) throw UNDEFINED_REF;
         return resolved;
       }
     },
@@ -6145,7 +6158,7 @@ function transfer(code, ip, at, hostCst) {
   }
   if (op === OP_NODE || op === OP_NODE_TRACK) {
     const flags = code[ip + 3];
-    const directChildren = !hostCst && op === OP_NODE && code[ip + 1] >= 0 && code[ip + 4] < 0 && (flags === 2 || flags === 18 || flags === 34);
+    const directChildren = !hostCst && op === OP_NODE && code[ip + 1] >= 0 && code[ip + 4] < 0 && ((flags & ~128) === 2 || flags === 18 || flags === 34);
     if (directChildren) {
       return { tri: at.tri, buf: false, raw: RAW_UNKNOWN, cap: CAP_OFF };
     }
@@ -7349,7 +7362,7 @@ ${clean ? "" : 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)}
-if(ctx._fc===true)return FAIL
+${code[ip + 2] === 1 ? "ctx._fc=false" : "if(ctx._fc===true)return FAIL"}
 ctx._fe=pos
 return FAIL
 }`;
@@ -7938,7 +7951,8 @@ return nd
         const unwrap = (flags & 64) !== 0;
         const trailingTrivia = (flags & 128) !== 0;
         const build = buildIdx >= 0 ? fnRef(buildIdx) : void 0;
-        if (!hostCst && !tracked && build !== void 0 && proj < 0 && (flags === 2 || flags === 18 || flags === 34)) {
+        const leanFlags = flags & ~128;
+        if (!hostCst && !tracked && build !== void 0 && proj < 0 && (leanFlags === 2 || (flags === 18 || flags === 34))) {
           const fields = flags === 18;
           const collapseChildren = flags === 34;
           const publish = L.buf && L.raw === RAW_OMIT ? "_pushNodeNoRawBuf(ctx,nd)" : L.buf && L.raw === RAW_CAPTURE ? `if(sBuf!==undefined){
@@ -7983,7 +7997,8 @@ ctx._cstTriviaLog=undefined
 ctx.captureTrivia=false
 ctx._fields=${fields ? "[]" : "undefined"}
 const v=${child}(input,pos,ctx)
-const captured=_capturedFlatChildren(flat)
+${trailingTrivia && L.tri !== TRI_NONE ? `if(v!==FAIL${L.tri === TRI_UNKNOWN ? "&&ctx.trivia!==undefined" : ""})EC.e=consumeTrivia(input,EC.e,ctx)
+` : ""}const captured=_capturedFlatChildren(flat)
 ${fields ? "const fieldMap=buildFieldMap(ctx._fields)\n" : ""}ctx._fields=sFields
 ctx._cstBuf=sBuf
 ctx._cstChildren=sCh
@@ -8379,7 +8394,7 @@ function assemble(t, prog, cfg) {
     const lf = { _tag: "leaf", value, span: { start: s, end: e } };
     pushCstLeaf(ctx, lf);
   }
-  function plainBuildNode(child, build) {
+  function plainBuildNode(child, build, trailing) {
     return (input, pos, ctx) => {
       const sCh = ctx._cstChildren;
       const sLv = ctx._cstLeaves;
@@ -8397,6 +8412,7 @@ function assemble(t, prog, cfg) {
       ctx.captureTrivia = false;
       ctx._fields = void 0;
       const value = child(input, pos, ctx);
+      if (trailing && value !== FAIL && ctx.trivia !== void 0) EC.e = consumeTrivia(input, EC.e, ctx);
       const kids = buf.ch ?? (buf.single !== void 0 ? [buf.single] : EMPTY_CH);
       const rawKids = buf.raw ?? (buf.rawSingle !== void 0 ? [buf.rawSingle] : EMPTY_CH);
       ctx._fields = savedFields;
@@ -8424,7 +8440,7 @@ function assemble(t, prog, cfg) {
     while (first < children2.length && children2[first] === void 0) first++;
     return first === children2.length ? EMPTY_CH : children2.slice(first);
   }
-  function childrenOnlyBuildNode(child, build) {
+  function childrenOnlyBuildNode(child, build, trailing) {
     return (input, pos, ctx) => {
       const sCh = ctx._cstChildren;
       const sLv = ctx._cstLeaves;
@@ -8442,6 +8458,7 @@ function assemble(t, prog, cfg) {
       ctx.captureTrivia = false;
       ctx._fields = void 0;
       const value = child(input, pos, ctx);
+      if (trailing && value !== FAIL && ctx.trivia !== void 0) EC.e = consumeTrivia(input, EC.e, ctx);
       const captured = capturedFlatChildren(kids);
       ctx._fields = savedFields;
       ctx._cstBuf = sBuf;
@@ -9466,6 +9483,7 @@ function assemble(t, prog, cfg) {
       /* ── transaction ─────────────────────────────────────────────────────── */
       case OP_ATTEMPT: {
         const child = link(code[ip + 1]);
+        const contain = code[ip + 2] === 1;
         return (input, pos, ctx) => {
           const need = markCst(ctx);
           const mRaw = MRAW;
@@ -9478,7 +9496,10 @@ function assemble(t, prog, cfg) {
           const v = child(input, pos, ctx);
           if (v !== FAIL) return v;
           if (need) rollbackTriviaAt(ctx, mRaw, mTl, mLv, mFl, mEr, mLog, mRoot);
-          if (committed3(ctx)) return FAIL;
+          if (committed3(ctx)) {
+            if (!contain) return FAIL;
+            ctx._fc = false;
+          }
           ctx._fe = pos;
           return FAIL;
         };
@@ -10929,11 +10950,11 @@ function assemble(t, prog, cfg) {
         const trailingTrivia = (flags & 128) !== 0;
         const build = buildIdx >= 0 ? fns[buildIdx] : void 0;
         if (!hostCst && !tracked) {
-          if (build !== void 0 && proj < 0 && flags === 0) {
-            return plainBuildNode(child, build);
+          if (build !== void 0 && proj < 0 && (flags & ~128) === 0) {
+            return plainBuildNode(child, build, trailingTrivia);
           }
-          if (build !== void 0 && proj < 0 && flags === 2) {
-            return childrenOnlyBuildNode(child, build);
+          if (build !== void 0 && proj < 0 && (flags & ~128) === 2) {
+            return childrenOnlyBuildNode(child, build, trailingTrivia);
           }
           if (build !== void 0 && proj < 0 && flags === 18) {
             return childrenOnlyFieldsBuildNode(child, build);
@@ -11811,10 +11832,12 @@ function mayCommitFailure(p, seen = /* @__PURE__ */ new Set(), resolve) {
     case "choice":
     case "sequence":
       return d.parsers.some((x) => mayCommitFailure(x, seen, resolve));
+    // A contained transaction reports every failure uncommitted.
+    case "attempt":
+      return d.contain !== true && mayCommitFailure(d.parser, seen, resolve);
     case "many":
     case "oneOrMore":
     case "optional":
-    case "attempt":
     case "transform":
     case "label":
     case "field":
@@ -13158,7 +13181,7 @@ var Encoder = class {
         const derivedState = d.build !== void 0 ? buildReadsState(d) : noBuildCaptures;
         const derivedFields = d.build !== void 0 ? buildReadsFields(d) : noBuildCaptures;
         const wantsFields = parserHasOwnFields(d.parser) && (cstOut || derivedFields);
-        const flags = (cstOut || d.captureTrivia === true || d.trailingTrivia === true || derivedTrivia ? 4 : 0) | (!cstOut && omitsRaw ? 2 : 0) | (cstOut || derivedState ? 8 : 0) | (wantsFields ? 16 : 0) | (d.collapse === true ? 32 : 0) | (d.unwrap === true ? 64 : 0) | (d.trailingTrivia === true ? 128 : 0) | (d.captureTrivia === true ? 1 : 0);
+        const flags = (cstOut || d.captureTrivia === true || derivedTrivia ? 4 : 0) | (!cstOut && omitsRaw ? 2 : 0) | (cstOut || derivedState ? 8 : 0) | (wantsFields ? 16 : 0) | (d.collapse === true ? 32 : 0) | (d.unwrap === true ? 64 : 0) | (d.trailingTrivia === true ? 128 : 0) | (d.captureTrivia === true ? 1 : 0);
         const body = this.emit(
           this.track ? OP_NODE_TRACK : OP_NODE,
           d.build === void 0 ? -1 : this.fn(d.build, d.buildSrc ?? null),
@@ -13284,7 +13307,7 @@ var Encoder = class {
       // A TRANSACTION IS A ROW. See `OP_ATTEMPT` for why the transparent
       // lowering was correct only for a choice arm.
       case "attempt": {
-        const inner = this.emit(OP_ATTEMPT, this.node(d.parser).ip);
+        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);
         const fs = d.parser._def.tag === "lazy" ? firstSetOf(d.parser, /* @__PURE__ */ new Set(), this.refResolver(), this.activeTrivia) : d.parser._meta.firstSet;
         if (fs.kind === "any" || matchesEmpty(d.parser)) return inner;
@@ -13779,7 +13802,8 @@ function children(def, winners) {
         return [];
       }
       const name = resolved._ruleName;
-      return name && winners?.[name] ? [winners[name]] : [resolved];
+      const winner = name ? winners?.[name] : void 0;
+      return winner !== void 0 && winner._def !== def ? [winner] : [resolved];
     }
     default:
       return [];
@@ -13804,16 +13828,39 @@ function buildGrammarPlan(entry, winners) {
       }
     }
   }
+  const selfWinnerBody = (parser) => {
+    if (parser._def.tag !== "lazy" || winners === void 0) return void 0;
+    const name = winnerNames.get(parser);
+    if (name === void 0 || winners[name] !== parser) return void 0;
+    try {
+      return parser._def.thunk();
+    } catch {
+      return void 0;
+    }
+  };
+  const slotsPerBody = /* @__PURE__ */ new Map();
+  if (winners) {
+    for (const winner of Object.values(winners)) {
+      const body = selfWinnerBody(winner);
+      if (body !== void 0) slotsPerBody.set(body, (slotsPerBody.get(body) ?? 0) + 1);
+    }
+  }
+  const sharedBody = (parser) => (slotsPerBody.get(parser) ?? 0) > 1;
+  const ownRule = (parser, rule) => {
+    const id = `rule:${rule}`;
+    definitions.set(id, { id, kind: "rule" });
+    rules.set(parser, id);
+  };
   const seen = /* @__PURE__ */ new Set();
   const visit = (parser, path) => {
     if (seen.has(parser)) return;
     seen.add(parser);
     const rule = winnerNames.get(parser) ?? parser._ruleName;
-    if (rule && (winnerNames.has(parser) || parser._def.tag !== "lazy")) {
-      const id = `rule:${rule}`;
-      definitions.set(id, { id, kind: "rule" });
-      rules.set(parser, id);
+    const body = selfWinnerBody(parser);
+    if (rule && body === void 0 && !sharedBody(parser) && (winnerNames.has(parser) || parser._def.tag !== "lazy")) {
+      ownRule(parser, rule);
     }
+    if (rule && body !== void 0 && sharedBody(body)) ownRule(parser, rule);
     if (parser._def.tag === "choice") {
       const ids = parser._def.parsers.map((_, index) => `choice:${path}/arm:${index}`);
       choices.set(parser, ids);
@@ -13834,7 +13881,13 @@ function buildGrammarPlan(entry, winners) {
   };
   const roots = Array.isArray(entry) ? entry : [entry];
   for (const root of roots) {
-    visit(root, winnerNames.get(root) ?? root._ruleName ?? "entry");
+    const name = winnerNames.get(root) ?? root._ruleName ?? "entry";
+    const body = selfWinnerBody(root);
+    if (body !== void 0 && sharedBody(body) && !seen.has(root)) {
+      seen.add(root);
+      ownRule(root, name);
+    }
+    visit(body ?? root, name);
   }
   return { definitions: [...definitions.values()].sort((a, b) => a.id.localeCompare(b.id)), choices, dispatches, attempts, labels, rules };
 }
@@ -15140,84 +15193,8 @@ function runDuplicationDiagnosticRules(ruleMap, opt) {
   return reportDuplication(opt, (o) => analyzeDuplicationRules(ruleMap, o));
 }
 
-// src/table/compile.ts
-var ENTRY = "Entry";
-function ownSource(fn) {
-  if (typeof fn !== "function") return null;
-  const text = Function.prototype.toString.call(fn);
-  if (!text.includes("[native code]")) return text;
-  const name = fn.name;
-  return typeof name === "string" && name.length > 0 && globalThis[name] === fn ? name : null;
-}
-function compile(combinator, mapFnSources, opts = {}) {
-  runDuplicationDiagnostic(combinator, opts.duplication);
-  const drain = beginCompileDegradationDrain();
-  let compiled = false;
-  try {
-    const out = compileImpl(combinator, mapFnSources, opts);
-    compiled = true;
-    return out;
-  } finally {
-    drain(compiled);
-  }
-}
-function compileImpl(combinator, mapFnSources, opts = {}) {
-  const plan = opts.coverage === true ? buildGrammarPlan(combinator) : void 0;
-  const settings = {
-    ...opts.hostMode === void 0 ? {} : { hostMode: opts.hostMode },
-    ...opts.trackLines === void 0 ? {} : { trackLines: opts.trackLines },
-    ...plan === void 0 ? {} : { coverage: plan }
-  };
-  const { prog, fnSrcs } = encodeTableProgram({ [ENTRY]: combinator }, settings);
-  const artifact = closureArtifact(prog);
-  const entry = tableRules(prog)[ENTRY];
-  const offered = opts.fnSources ?? mapFnSources;
-  const supplied = offered !== void 0 && offered.length === fnSrcs.length ? offered : void 0;
-  const sources = fnSrcs.map((s, i) => s ?? supplied?.[i] ?? ownSource(prog.fns[i]));
-  const unsourced = sources.reduce((acc, s, i) => s === null ? [...acc, i] : acc, []);
-  const runtimeOnly = [
-    ...prog.runtimeOnly ?? [],
-    ...unsourced.length === 0 ? [] : [`author reducer source missing for prog.fns[${unsourced.join(", ")}] \u2014 printing would emit \`() => {}\` and the parse would return no value`]
-  ];
-  const printable = runtimeOnly.length === 0;
-  const emitOpts = { fnSources: sources };
-  const source = printable ? emitTableModule(artifact, { name: "grammar", ...emitOpts }) : "";
-  const inlineExpression = printable ? emitTableExpression(artifact, { entry: ENTRY, runtimeRef: opts.runtimeRef ?? "tableRules", ...emitOpts }) : null;
-  const runOnce = (input, pos, ctx) => entry(input, pos, ctx);
-  return {
-    source,
-    inlineExpression,
-    ...printable ? {} : { runtimeOnly },
-    // The DENOMINATOR, handed back rather than scraped out of the emitted text.
-    // `plugin/index.ts` prefers a compiler-supplied `coverageDefinitions` and only
-    // falls back to regex-scanning generated hooks; a table has no hooks to scan,
-    // so this is the channel.
-    ...plan === void 0 ? {} : { coverageDefinitions: plan.definitions },
-    parse(input, pos = 0) {
-      return runOnce(input, pos, createParseContext());
-    },
-    parseWithContext(input, parseCtx, pos = 0) {
-      return runOnce(input, pos, parseCtx);
-    },
-    /**
-     * NO LONGER REFUSES. It used to throw unless the caller passed
-     * `{ recovery: true }`, because setting `_tolerant` on a table with no
-     * recovery rows would report a clean parse with an empty error list whatever
-     * the input — refusing was the right answer to that, and OPTIONAL RECOVERY
-     * was the wrong question. `compile()` requires no such flag, so the refusal
-     * was a `CompiledParser` contract break; recovery is now always lowered and
-     * there is nothing left to refuse.
-     */
-    parseWithErrors(input, pos = 0) {
-      const ctx = createParseContext();
-      const errors = [];
-      ctx._errors = errors;
-      ctx._tolerant = true;
-      const r = runOnce(input, pos, ctx);
-      return { ...r, errors };
-    }
-  };
-}
+// src/cst/reflection-symbols.ts
+var GRAMMAR_REFLECTION = /* @__PURE__ */ Symbol.for("parseman.grammarReflection");
 
 // src/cst/reflection.ts
 function childrenOf2(def) {
@@ -15304,6 +15281,7 @@ function collectFromCombinator(parser, out, seen, followLazy = true) {
 function collectGrammarReflection(ruleMap, opts) {
   const byType = /* @__PURE__ */ new Map();
   const followLazy = opts?.followLazy !== false;
+  const seen = /* @__PURE__ */ new Set();
   for (const [, rule] of ruleMap) {
     if (!followLazy && rule._def.tag === "lazy") {
       try {
@@ -15313,7 +15291,7 @@ function collectGrammarReflection(ruleMap, opts) {
       }
       continue;
     }
-    collectFromCombinator(rule, byType, /* @__PURE__ */ new Set(), followLazy);
+    collectFromCombinator(rule, byType, seen, followLazy);
   }
   return { nodes: [...byType].map(([type, tags]) => ({ type, tags })) };
 }
@@ -15349,6 +15327,24 @@ function withAmbient(ruleMap, opts) {
     return [name, wrapped];
   });
 }
+function compileRuleMapRunnable(ruleMap, opts = {}) {
+  const encoded = encodeForRun(ruleMap, opts);
+  if (encoded === null) return null;
+  const { prog, hostMode, plan } = encoded;
+  const artifact = closureArtifact(prog);
+  const reflection = collectGrammarReflection(ruleMap);
+  return {
+    keys: ruleMap.map(([key]) => key),
+    hostMode,
+    hostBranchElided: hostMode === "ast" && ruleMap.some(([, rule]) => hasDirectBuildDef(rule)),
+    reflection,
+    ...plan === void 0 ? {} : { coverageDefinitions: plan.definitions },
+    // Reflection rides on the map's metadata prototype from birth. Only `compile()`
+    // asks to specialise; every other caller runs the closure artifact.
+    rules: tableRules(opts.specialise === true ? prog : artifact, { [GRAMMAR_REFLECTION]: reflection }),
+    prog: artifact
+  };
+}
 function encodeForRun(ruleMap, opts) {
   runDuplicationDiagnosticRules(ruleMap, opts.duplication);
   const encodeMap = withAmbient(ruleMap, opts);
@@ -15417,11 +15413,185 @@ function compileRuleMap(ruleMap, opts = {}) {
     hostBranchElided: hostMode === "ast" && ruleMap.some(([, rule]) => hasDirectBuildDef(rule)),
     reflection: collectGrammarReflection(ruleMap),
     ...plan === void 0 ? {} : { coverageDefinitions: plan.definitions },
-    rules: tableRules(prog),
+    rules: tableRules(artifact),
     prog: artifact
   };
 }
 
+// src/compiler/borrowed-rules.ts
+var nameOf = (c) => c._ruleName;
+function deref(c) {
+  const seen = /* @__PURE__ */ new Set();
+  let current = c;
+  while (current._def.tag === "lazy" && !seen.has(current)) {
+    seen.add(current);
+    try {
+      current = current._def.thunk();
+    } catch {
+      return void 0;
+    }
+  }
+  return current;
+}
+function borrowedRuleReference(map) {
+  const seen = /* @__PURE__ */ new Set();
+  for (const [rule, self] of Object.entries(map)) {
+    let found;
+    const visit = (c) => {
+      if (found !== void 0) return;
+      if (c._def.tag === "lazy") {
+        if (!winnerWrapsReference(self, c)) {
+          const name = nameOf(c);
+          const winner = name !== void 0 && Object.hasOwn(map, name) ? map[name] : void 0;
+          if (winner !== void 0) {
+            if (winnerWrapsReference(winner, c) || deref(c) === deref(winner)) return;
+            found = name;
+            return;
+          }
+        }
+        if (seen.has(c)) return;
+        seen.add(c);
+        let body;
+        try {
+          body = c._def.thunk();
+        } catch {
+          return;
+        }
+        visit(body);
+        return;
+      }
+      if (seen.has(c)) return;
+      seen.add(c);
+      for (const child of childrenOf(c._def)) visit(child);
+    };
+    visit(self);
+    if (found !== void 0) return { rule, reference: found };
+  }
+  return void 0;
+}
+function borrowedRuleMessage(api, hit) {
+  return `${api}: rule "${hit.rule}" is a rule object borrowed from another grammar, and its graph references "${hit.reference}", which this grammar also defines. The interpreter would keep the other grammar's "${hit.reference}" while a compiled table binds this grammar's, so the two would accept different input. Compose the grammar that defines "${hit.rule}" instead of borrowing its rule object, so its references resolve to this grammar's rules.`;
+}
+
+// src/table/compile.ts
+var ENTRY = "Entry";
+function ownSource(fn) {
+  if (typeof fn !== "function") return null;
+  const text = Function.prototype.toString.call(fn);
+  if (!text.includes("[native code]")) return text;
+  const name = fn.name;
+  return typeof name === "string" && name.length > 0 && globalThis[name] === fn ? name : null;
+}
+function compile(target, second, third) {
+  if (!isCombinator(target)) return compileMap(target, second);
+  return compileRoot(target, second, third);
+}
+function isCombinator(x) {
+  return typeof x === "object" && x !== null && typeof x.parse === "function" && "_def" in x;
+}
+function compileMap(grammar, opts = {}) {
+  const entries = [];
+  for (const [key, value] of Object.entries(grammar)) {
+    if (!isCombinator(value)) throw new TypeError(`compile: grammar entry "${key}" is not a parser`);
+    if (value._def.tag === "lazy") {
+      try {
+        value._def.thunk();
+      } catch {
+        continue;
+      }
+    }
+    entries.push([key, value]);
+  }
+  const borrowed = borrowedRuleReference(Object.fromEntries(entries));
+  if (borrowed !== void 0) throw new Error(borrowedRuleMessage("compile", borrowed));
+  const drain = beginCompileDegradationDrain();
+  let done = false;
+  try {
+    const refusals = [];
+    const compiled = compileRuleMapRunnable(entries, {
+      ...opts.hostMode ? { hostMode: opts.hostMode } : {},
+      refusals,
+      specialise: true
+    });
+    if (compiled === null) {
+      throw new Error(`compile: this grammar could not be encoded to a table${refusals.length ? ` \u2014 ${refusals.join("; ")}` : ""}`);
+    }
+    done = true;
+    return compiled.rules;
+  } finally {
+    drain(done);
+  }
+}
+function compileRoot(combinator, mapFnSources, opts = {}) {
+  runDuplicationDiagnostic(combinator, opts.duplication);
+  const drain = beginCompileDegradationDrain();
+  let compiled = false;
+  try {
+    const out = compileImpl(combinator, mapFnSources, opts);
+    compiled = true;
+    return out;
+  } finally {
+    drain(compiled);
+  }
+}
+function compileImpl(combinator, mapFnSources, opts = {}) {
+  const plan = opts.coverage === true ? buildGrammarPlan(combinator) : void 0;
+  const settings = {
+    ...opts.hostMode === void 0 ? {} : { hostMode: opts.hostMode },
+    ...opts.trackLines === void 0 ? {} : { trackLines: opts.trackLines },
+    ...plan === void 0 ? {} : { coverage: plan }
+  };
+  const { prog, fnSrcs } = encodeTableProgram({ [ENTRY]: combinator }, settings);
+  const artifact = closureArtifact(prog);
+  const entry = tableRules(prog)[ENTRY];
+  const offered = opts.fnSources ?? mapFnSources;
+  const supplied = offered !== void 0 && offered.length === fnSrcs.length ? offered : void 0;
+  const sources = fnSrcs.map((s, i) => s ?? supplied?.[i] ?? ownSource(prog.fns[i]));
+  const unsourced = sources.reduce((acc, s, i) => s === null ? [...acc, i] : acc, []);
+  const runtimeOnly = [
+    ...prog.runtimeOnly ?? [],
+    ...unsourced.length === 0 ? [] : [`author reducer source missing for prog.fns[${unsourced.join(", ")}] \u2014 printing would emit \`() => {}\` and the parse would return no value`]
+  ];
+  const printable = runtimeOnly.length === 0;
+  const emitOpts = { fnSources: sources };
+  const source = printable ? emitTableModule(artifact, { name: "grammar", ...emitOpts }) : "";
+  const inlineExpression = printable ? emitTableExpression(artifact, { entry: ENTRY, runtimeRef: opts.runtimeRef ?? "tableRules", ...emitOpts }) : null;
+  const runOnce = (input, pos, ctx) => entry(input, pos, ctx);
+  return {
+    source,
+    inlineExpression,
+    ...printable ? {} : { runtimeOnly },
+    // The DENOMINATOR, handed back rather than scraped out of the emitted text.
+    // `plugin/index.ts` prefers a compiler-supplied `coverageDefinitions` and only
+    // falls back to regex-scanning generated hooks; a table has no hooks to scan,
+    // so this is the channel.
+    ...plan === void 0 ? {} : { coverageDefinitions: plan.definitions },
+    parse(input, pos = 0) {
+      return runOnce(input, pos, createParseContext());
+    },
+    parseWithContext(input, parseCtx, pos = 0) {
+      return runOnce(input, pos, parseCtx);
+    },
+    /**
+     * NO LONGER REFUSES. It used to throw unless the caller passed
+     * `{ recovery: true }`, because setting `_tolerant` on a table with no
+     * recovery rows would report a clean parse with an empty error list whatever
+     * the input — refusing was the right answer to that, and OPTIONAL RECOVERY
+     * was the wrong question. `compile()` requires no such flag, so the refusal
+     * was a `CompiledParser` contract break; recovery is now always lowered and
+     * there is nothing left to refuse.
+     */
+    parseWithErrors(input, pos = 0) {
+      const ctx = createParseContext();
+      const errors = [];
+      ctx._errors = errors;
+      ctx._tolerant = true;
+      const r = runOnce(input, pos, ctx);
+      return { ...r, errors };
+    }
+  };
+}
+
 // src/table/fold.ts
 function tableVariants(source, name) {
   const folded = "base" in source ? source : expandCompactFolded(source);