parseman 0.51.2 → 0.53.0

package/dist/analysis/commitment.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"commitment.d.ts","sourceRoot":"","sources":["../../src/analysis/commitment.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AACH,OAAO,KAAK,EAAE,UAAU,EAAa,MAAM,aAAa,CAAA;AACxD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,6BAA6B,CAAA;AAI9D;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,OAAO,CAAC,CAAC,EAAE,UAAU,CAAC,OAAO,CAAC,EAAE,IAAI,GAAE,GAAG,CAAC,UAAU,CAAC,OAAO,CAAC,CAAa,GAAG,OAAO,CAqCnG;AAkCD;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,wBAAgB,cAAc,CAAC,CAAC,EAAE,UAAU,CAAC,OAAO,CAAC,EAAE,IAAI,GAAE,GAAG,CAAC,UAAU,CAAC,OAAO,CAAC,CAAa,GAAG,OAAO,CAiC1G;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,sBAAsB,CAAC,CAAC,EAAE,UAAU,CAAC,OAAO,CAAC,EAAE,IAAI,GAAE,GAAG,CAAC,UAAU,CAAC,OAAO,CAAC,CAAa,EAAE,YAAY,UAAO,GAAG,OAAO,CAwGvI;AAED,8EAA8E;AAC9E,wBAAgB,YAAY,CAAC,CAAC,EAAE,UAAU,CAAC,OAAO,CAAC,EAAE,IAAI,GAAE,GAAG,CAAC,UAAU,CAAC,OAAO,CAAC,CAAa,GAAG,OAAO,CAkDxG;AAED;;;;GAIG;AACH,wBAAgB,UAAU,CAAC,CAAC,EAAE,UAAU,CAAC,OAAO,CAAC,EAAE,IAAI,GAAE,GAAG,CAAC,UAAU,CAAC,OAAO,CAAC,CAAa,GAAG,OAAO,CAgCtG;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,iBAAiB,CAAC,CAAC,EAAE,UAAU,CAAC,OAAO,CAAC,EAAE,IAAI,GAAE,GAAG,CAAC,UAAU,CAAC,OAAO,CAAC,CAAa,GAAG,OAAO,CAqC7G;AAED,2FAA2F;AAC3F,wBAAgB,gBAAgB,CAC9B,CAAC,EAAE,UAAU,CAAC,OAAO,CAAC,EACtB,IAAI,GAAE,GAAG,CAAC,UAAU,CAAC,OAAO,CAAC,CAAa,EAC1C,OAAO,CAAC,EAAE,WAAW,GACpB,OAAO,CA6CT;AAwCD;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,eAAe,CAC7B,OAAO,EAAE,aAAa,CAAC,SAAS,CAAC,MAAM,EAAE,UAAU,CAAC,OAAO,CAAC,CAAC,CAAC,GAC7D;IAAE,iBAAiB,EAAE,OAAO,CAAC;IAAC,iBAAiB,EAAE,OAAO,CAAA;CAAE,CAwB5D"}
+{"version":3,"file":"commitment.d.ts","sourceRoot":"","sources":["../../src/analysis/commitment.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AACH,OAAO,KAAK,EAAE,UAAU,EAAa,MAAM,aAAa,CAAA;AACxD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,6BAA6B,CAAA;AAI9D;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,OAAO,CAAC,CAAC,EAAE,UAAU,CAAC,OAAO,CAAC,EAAE,IAAI,GAAE,GAAG,CAAC,UAAU,CAAC,OAAO,CAAC,CAAa,GAAG,OAAO,CAqCnG;AAkCD;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,wBAAgB,cAAc,CAAC,CAAC,EAAE,UAAU,CAAC,OAAO,CAAC,EAAE,IAAI,GAAE,GAAG,CAAC,UAAU,CAAC,OAAO,CAAC,CAAa,GAAG,OAAO,CAiC1G;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,sBAAsB,CAAC,CAAC,EAAE,UAAU,CAAC,OAAO,CAAC,EAAE,IAAI,GAAE,GAAG,CAAC,UAAU,CAAC,OAAO,CAAC,CAAa,EAAE,YAAY,UAAO,GAAG,OAAO,CAwGvI;AAED,8EAA8E;AAC9E,wBAAgB,YAAY,CAAC,CAAC,EAAE,UAAU,CAAC,OAAO,CAAC,EAAE,IAAI,GAAE,GAAG,CAAC,UAAU,CAAC,OAAO,CAAC,CAAa,GAAG,OAAO,CAkDxG;AAED;;;;GAIG;AACH,wBAAgB,UAAU,CAAC,CAAC,EAAE,UAAU,CAAC,OAAO,CAAC,EAAE,IAAI,GAAE,GAAG,CAAC,UAAU,CAAC,OAAO,CAAC,CAAa,GAAG,OAAO,CAgCtG;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,iBAAiB,CAAC,CAAC,EAAE,UAAU,CAAC,OAAO,CAAC,EAAE,IAAI,GAAE,GAAG,CAAC,UAAU,CAAC,OAAO,CAAC,CAAa,GAAG,OAAO,CAqC7G;AAED,2FAA2F;AAC3F,wBAAgB,gBAAgB,CAC9B,CAAC,EAAE,UAAU,CAAC,OAAO,CAAC,EACtB,IAAI,GAAE,GAAG,CAAC,UAAU,CAAC,OAAO,CAAC,CAAa,EAC1C,OAAO,CAAC,EAAE,WAAW,GACpB,OAAO,CA+CT;AAwCD;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,eAAe,CAC7B,OAAO,EAAE,aAAa,CAAC,SAAS,CAAC,MAAM,EAAE,UAAU,CAAC,OAAO,CAAC,CAAC,CAAC,GAC7D;IAAE,iBAAiB,EAAE,OAAO,CAAC;IAAC,iBAAiB,EAAE,OAAO,CAAA;CAAE,CAwB5D"}

package/dist/analysis/diagnostics.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(
@@ -1291,6 +1295,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;
@@ -3244,6 +3252,53 @@ function hasNodeDef(p, seen = /* @__PURE__ */ new Set()) {
       return false;
   }
 }
+function hasDirectBuildDef(p, seen = /* @__PURE__ */ new Set()) {
+  if (seen.has(p)) return false;
+  seen.add(p);
+  const d = p._def;
+  switch (d.tag) {
+    case "node":
+      return d.build !== void 0 || hasDirectBuildDef(d.parser, seen);
+    case "lazy": {
+      try {
+        return hasDirectBuildDef(d.thunk(), seen);
+      } catch {
+        return false;
+      }
+    }
+    case "grammar":
+    case "trivia":
+    case "token":
+    case "leaf":
+    case "label":
+    case "field":
+    case "optional":
+    case "many":
+    case "oneOrMore":
+    case "attempt":
+    case "not":
+    case "peek":
+    case "withCtx":
+    case "expect":
+    case "transform":
+      return hasDirectBuildDef(d.parser, seen);
+    case "sequence":
+    case "choice":
+      return d.parsers.some((x) => hasDirectBuildDef(x, seen));
+    case "dispatch":
+      return hasDirectBuildDef(d.selector, seen) || d.cases.some((x) => hasDirectBuildDef(x.parser, seen)) || (d.matchers ? d.matchers.some((x) => hasDirectBuildDef(x.parser, seen)) : false) || (d.otherwise ? hasDirectBuildDef(d.otherwise, seen) : false);
+    case "sepBy":
+      return hasDirectBuildDef(d.parser, seen) || hasDirectBuildDef(d.separator, seen);
+    case "scanTo":
+      return hasDirectBuildDef(d.sentinel, seen) || d.skip.some((x) => hasDirectBuildDef(x, seen)) || d.recoverAt !== void 0 && hasDirectBuildDef(d.recoverAt, seen) || d.stopAt !== void 0 && hasDirectBuildDef(d.stopAt, seen);
+    case "recover":
+      return hasDirectBuildDef(d.parser, seen) || hasDirectBuildDef(d.sentinel, seen);
+    case "routed":
+      return d.fallback ? hasDirectBuildDef(d.fallback, seen) : false;
+    default:
+      return false;
+  }
+}
 function mayCommitFailure(p, seen = /* @__PURE__ */ new Set(), resolve) {
   if (seen.has(p)) return false;
   seen.add(p);
@@ -3254,10 +3309,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":
@@ -4428,7 +4485,7 @@ function node(typeOrCombinator, combinatorOrBuild, buildOrOpts, maybeOpts) {
     throw new Error("node() options cannot combine project with unwrap or collapse");
   }
   const def = unwrap || collapse || project !== void 0 || captureTrivia || trailingTrivia || buildArity !== void 0 || tags !== void 0 && tags.length > 0 ? { ...baseDef, ...unwrap ? { unwrap: true } : {}, ...collapse ? { collapse: true } : {}, ...project !== void 0 ? { project } : {}, ...captureTrivia ? { captureTrivia: true } : {}, ...trailingTrivia ? { trailingTrivia: true } : {}, ...buildArity !== void 0 ? { buildArity } : {}, ...tags !== void 0 && tags.length > 0 ? { tags } : {} } : baseDef;
-  const capturesTrivia = captureTrivia || trailingTrivia || (build ? buildReadsTrivia(def) : project === void 0);
+  const capturesTrivia = captureTrivia || (build ? buildReadsTrivia(def) : project === void 0);
   const clonesState = build ? buildReadsState(def) : project === void 0;
   const hasOwnFields = parserHasOwnFields(combinator);
   const capturesFields = hasOwnFields && (build ? buildReadsFields(def) : project === void 0);
@@ -5318,13 +5375,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 },
@@ -7054,7 +7115,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),
@@ -7180,7 +7241,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;
@@ -8573,7 +8634,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 };
     }
@@ -9777,7 +9838,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
 }`;
@@ -10366,7 +10427,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){
@@ -10411,7 +10473,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
@@ -10787,6 +10850,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;
@@ -10802,7 +10866,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;
       }
     },
@@ -11428,7 +11492,7 @@ function assemble(t2, 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;
@@ -11446,6 +11510,7 @@ function assemble(t2, 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;
@@ -11473,7 +11538,7 @@ function assemble(t2, 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;
@@ -11491,6 +11556,7 @@ function assemble(t2, 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;
@@ -12515,6 +12581,7 @@ function assemble(t2, 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;
@@ -12527,7 +12594,10 @@ function assemble(t2, 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;
         };
@@ -13978,11 +14048,11 @@ function assemble(t2, 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);
@@ -14723,7 +14793,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 [];
@@ -14748,16 +14819,39 @@ function buildGrammarPlan(entry, winners) {
       }
     }
   }
+  const selfWinnerBody = (parser2) => {
+    if (parser2._def.tag !== "lazy" || winners === void 0) return void 0;
+    const name = winnerNames.get(parser2);
+    if (name === void 0 || winners[name] !== parser2) return void 0;
+    try {
+      return parser2._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 = (parser2) => (slotsPerBody.get(parser2) ?? 0) > 1;
+  const ownRule = (parser2, rule2) => {
+    const id = `rule:${rule2}`;
+    definitions.set(id, { id, kind: "rule" });
+    rules.set(parser2, id);
+  };
   const seen = /* @__PURE__ */ new Set();
   const visit = (parser2, path) => {
     if (seen.has(parser2)) return;
     seen.add(parser2);
     const rule2 = winnerNames.get(parser2) ?? parser2._ruleName;
-    if (rule2 && (winnerNames.has(parser2) || parser2._def.tag !== "lazy")) {
-      const id = `rule:${rule2}`;
-      definitions.set(id, { id, kind: "rule" });
-      rules.set(parser2, id);
+    const body = selfWinnerBody(parser2);
+    if (rule2 && body === void 0 && !sharedBody(parser2) && (winnerNames.has(parser2) || parser2._def.tag !== "lazy")) {
+      ownRule(parser2, rule2);
     }
+    if (rule2 && body !== void 0 && sharedBody(body)) ownRule(parser2, rule2);
     if (parser2._def.tag === "choice") {
       const ids = parser2._def.parsers.map((_, index) => `choice:${path}/arm:${index}`);
       choices.set(parser2, ids);
@@ -14778,7 +14872,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 };
 }
@@ -16080,6 +16180,238 @@ ${lines.join("\n")}`);
 function runDuplicationDiagnostic(combinator, opt) {
   return reportDuplication(opt, (o) => analyzeDuplication(combinator, o));
 }
+function runDuplicationDiagnosticRules(ruleMap, opt) {
+  return reportDuplication(opt, (o) => analyzeDuplicationRules(ruleMap, o));
+}
+
+// src/cst/reflection-symbols.ts
+var GRAMMAR_REFLECTION = /* @__PURE__ */ Symbol.for("parseman.grammarReflection");
+
+// src/cst/reflection.ts
+function childrenOf2(def) {
+  switch (def.tag) {
+    case "sequence":
+    case "choice":
+      return def.parsers;
+    case "dispatch":
+      return [
+        def.selector,
+        ...def.cases.map((c) => c.parser),
+        ...def.matchers ? def.matchers.map((c) => c.parser) : [],
+        ...def.otherwise ? [def.otherwise] : []
+      ];
+    case "many":
+    case "oneOrMore":
+    case "optional":
+    case "attempt":
+    case "transform":
+    case "trivia":
+    case "token":
+    case "leaf":
+    case "label":
+    case "field":
+    case "not":
+    case "peek":
+    case "node":
+    case "withCtx":
+    case "expect":
+      return [def.parser];
+    case "recover":
+      return [def.parser, def.sentinel];
+    case "grammar":
+      return def.triviaParser ? [def.parser, def.triviaParser] : [def.parser];
+    case "sepBy":
+      return [def.parser, def.separator];
+    case "scanTo":
+      return [
+        def.sentinel,
+        ...def.skip,
+        ...def.recoverAt === void 0 ? [] : [def.recoverAt],
+        ...def.stopAt === void 0 ? [] : [def.stopAt]
+      ];
+    case "routed":
+      return def.fallback ? [def.fallback] : [];
+    case "literal":
+    case "regex":
+    case "keywords":
+    case "guard":
+    case "adjacency":
+    case "lazy":
+    case "unknown":
+      return [];
+  }
+}
+function addNode(out, def) {
+  if (def.type === void 0) return;
+  const existing = out.get(def.type);
+  if (existing === void 0) {
+    out.set(def.type, def.tags === void 0 ? [] : [...def.tags]);
+    return;
+  }
+  if (def.tags === void 0) return;
+  for (const tag of def.tags) {
+    if (!existing.includes(tag)) existing.push(tag);
+  }
+}
+function collectFromCombinator(parser2, out, seen, followLazy = true) {
+  if (seen.has(parser2)) return;
+  seen.add(parser2);
+  const def = parser2._def;
+  if (def.tag === "lazy") {
+    if (followLazy) {
+      try {
+        collectFromCombinator(def.thunk(), out, seen, followLazy);
+      } catch {
+      }
+    }
+    return;
+  }
+  if (def.tag === "node") addNode(out, def);
+  for (const child of childrenOf2(def)) collectFromCombinator(child, out, seen, followLazy);
+}
+function collectGrammarReflection(ruleMap, opts) {
+  const byType = /* @__PURE__ */ new Map();
+  const followLazy = opts?.followLazy !== false;
+  const seen = /* @__PURE__ */ new Set();
+  for (const [, rule2] of ruleMap) {
+    if (!followLazy && rule2._def.tag === "lazy") {
+      try {
+        const resolved = rule2._def.thunk();
+        if (resolved._def.tag !== "lazy") collectFromCombinator(resolved, byType, /* @__PURE__ */ new Set(), false);
+      } catch {
+      }
+      continue;
+    }
+    collectFromCombinator(rule2, byType, seen, followLazy);
+  }
+  return { nodes: [...byType].map(([type, tags]) => ({ type, tags })) };
+}
+
+// src/table/compile-rule-map.ts
+function resolveHostMode(ruleMap, explicit) {
+  return explicit ?? ruleMap.map(([, r]) => r._meta.grammarHostMode).find(Boolean) ?? "ast";
+}
+function resolveTrackLines(ruleMap, explicit) {
+  return explicit === true || ruleMap.some(([, r]) => r._meta.grammarTrackLines === true);
+}
+function withAmbient(ruleMap, opts) {
+  if (opts.trivia === void 0 && opts.scanSkip === void 0) return ruleMap;
+  const wrappers = /* @__PURE__ */ new Map();
+  return ruleMap.map(([name, rule2]) => {
+    if (rule2._meta.isTrivia) return [name, rule2];
+    const addTrivia = opts.trivia !== void 0 && rule2._meta.grammarTrivia === void 0;
+    const addScanSkip = opts.scanSkip !== void 0 && rule2._meta.grammarScanSkip === void 0;
+    if (!addTrivia && !addScanSkip) return [name, rule2];
+    let wrapped = wrappers.get(rule2);
+    if (wrapped === void 0) {
+      wrapped = {
+        ...rule2,
+        _meta: {
+          ...rule2._meta,
+          ...addTrivia ? { grammarTrivia: opts.trivia } : {},
+          ...addScanSkip ? { grammarScanSkip: opts.scanSkip } : {}
+        }
+      };
+      wrappers.set(rule2, wrapped);
+    }
+    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(([, rule2]) => hasDirectBuildDef(rule2)),
+    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);
+  const plan = opts.coverage === true ? buildGrammarPlan(
+    encodeMap.map(([, rule2]) => rule2),
+    Object.fromEntries(encodeMap.filter(([, rule2]) => rule2._def.tag !== "lazy"))
+  ) : void 0;
+  const hostMode = resolveHostMode(ruleMap, opts.hostMode);
+  const settings = {
+    hostMode,
+    ...resolveTrackLines(ruleMap, opts.trackLines) ? { trackLines: true } : {},
+    ...opts.recovery === true ? { recovery: true } : {},
+    ...plan === void 0 ? {} : { coverage: plan }
+  };
+  try {
+    const { prog, fnSrcs } = encodeTableProgram(Object.fromEntries(encodeMap), settings);
+    return { prog, fnSrcs, hostMode, plan };
+  } catch (e) {
+    opts.refusals?.push(e instanceof Error ? e.message : String(e));
+    return null;
+  }
+}
+
+// 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 [rule2, 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: rule2, 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";
@@ -16090,7 +16422,47 @@ function ownSource(fn) {
   const name = fn.name;
   return typeof name === "string" && name.length > 0 && globalThis[name] === fn ? name : null;
 }
-function compile(combinator, mapFnSources, opts = {}) {
+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;
@@ -16372,13 +16744,24 @@ function digestValue(value, prefix = "", options) {
 }
 
 // src/combinators/attempt.ts
-function attempt(parser2) {
+function containOption(options) {
+  if (options === void 0) return false;
+  for (const key of Object.keys(options)) {
+    if (key !== "contain") throw new TypeError(`attempt(): unknown option ${JSON.stringify(key)}`);
+  }
+  if (options.contain !== void 0 && typeof options.contain !== "boolean") {
+    throw new TypeError("attempt(): `contain` must be a boolean");
+  }
+  return options.contain === true;
+}
+function attempt(parser2, options) {
+  const contain = containOption(options);
   const guardable = parser2._meta.firstSet.kind !== "any" && !matchesEmpty(parser2);
   let failExpected;
   return {
     _tag: "attempt",
     _meta: parser2._meta,
-    _def: { tag: "attempt", parser: parser2 },
+    _def: contain ? { tag: "attempt", parser: parser2, contain: true } : { tag: "attempt", parser: parser2 },
     parse(input, pos, ctx) {
       if (guardable && ctx._probe === void 0 && !ctx._tolerant && !startsFirstSet(parser2, input, pos)) {
         if (failExpected === void 0) {
@@ -16395,7 +16778,7 @@ function attempt(parser2) {
       rollbackCstCapture(ctx, mark);
       if (log !== void 0 && ctx._triviaLog && ctx._triviaLog.length !== log) ctx._triviaLog.length = log;
       if (rootLog !== void 0 && ctx._rootTriviaLog && ctx._rootTriviaLog.length !== rootLog) ctx._rootTriviaLog.length = rootLog;
-      if (result.committed) return result;
+      if (result.committed && !contain) return result;
       return { ok: false, expected: result.expected, span: { start: pos, end: pos } };
     }
   };
@@ -16562,7 +16945,7 @@ function rebuildCombinator(root, replacements) {
         out = d.polarity === "adjacent" ? adjacent() : d.kinds === void 0 ? notAdjacent() : notAdjacent({ kinds: d.kinds });
         break;
       case "attempt":
-        out = attempt(one(d.parser));
+        out = attempt(one(d.parser), d.contain === true ? { contain: true } : void 0);
         break;
       case "not":
         out = not(one(d.parser));