parseman 0.51.2 → 0.53.0

package/dist/plugin/index.js

@@ -265,6 +265,10 @@ function firstSetBody(p, seen, resolve3, 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 fs3(d.parser);
     case "grammar":
       return firstSetOf(
@@ -363,6 +367,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;
@@ -378,7 +383,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;
       }
     },
@@ -1404,6 +1409,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;
@@ -1802,6 +1811,7 @@ function collectFromCombinator(parser2, 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 {
@@ -1811,7 +1821,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 })) };
 }
@@ -1842,9 +1852,26 @@ function isNamedRuleRefForAnotherRule(r, key) {
   const name = r._def.tag === "lazy" ? ruleNameOf(r) : void 0;
   return name !== void 0 && name !== key;
 }
+var claimedRules = /* @__PURE__ */ new WeakSet();
+function ownRule(p, copies) {
+  if (!claimedRules.has(p) || p._meta.isTrivia) return p;
+  let own = copies.get(p);
+  if (own === void 0) {
+    const { grammarTrivia: _t, grammarScanSkip: _s, grammarHostMode: _h, grammarTrackLines: _l, ...meta } = p._meta;
+    copies.set(p, own = { ...p, _meta: meta });
+  }
+  return own;
+}
 function rules(a, b) {
   const factory = typeof a === "function" ? a : b;
   const options = typeof a === "function" ? b : a;
+  const recipe = { factory, options };
+  const map = linkRules([recipe]);
+  Object.defineProperty(map, RULES_RECIPE, { value: [recipe], enumerable: false });
+  return map;
+}
+var RULES_RECIPE = /* @__PURE__ */ Symbol.for("parseman.rulesRecipe");
+function linkRules(recipes, link) {
   const cache = {};
   const proxy = new Proxy(cache, {
     get(target, key) {
@@ -1858,10 +1885,18 @@ function rules(a, b) {
       return record[key];
     }
   });
-  const definitions = factory(proxy);
-  for (const key of Object.keys(definitions)) {
+  const winners = /* @__PURE__ */ new Map();
+  for (const recipe of recipes) {
+    const definitions = recipe.factory(proxy);
+    for (const key of Object.keys(definitions)) {
+      winners.set(key, { parser: definitions[key], options: recipe.options });
+    }
+  }
+  const keys = [...winners.keys()];
+  const copies = /* @__PURE__ */ new Map();
+  for (const [key, { parser: defined }] of winners) {
     const placeholder = cache[key];
-    const parser2 = definitions[key];
+    const parser2 = ownRule(defined, copies);
     if (placeholder === parser2) {
       throw new Error(`rules(): rule "${key}" cannot be a direct alias to itself`);
     }
@@ -1870,7 +1905,8 @@ function rules(a, b) {
       placeholder.define(parser2);
       placeholder._meta.firstSet = parser2._meta.firstSet;
       placeholder._meta.canMatchNewline = parser2._meta.canMatchNewline;
-    } else if (isNamedRuleRefForAnotherRule(parser2, key)) {
+    } else if (isNamedRuleRefForAnotherRule(parser2, key) || link !== void 0) {
+      if (!isNamedRuleRefForAnotherRule(parser2, key)) tagRule(parser2, key);
       const alias = ref();
       tagRule(alias, key);
       alias.define(parser2);
@@ -1882,48 +1918,34 @@ function rules(a, b) {
       cache[key] = parser2;
     }
   }
-  if (options?.trivia != null) {
-    for (const key of Object.keys(definitions)) {
-      const rule = cache[key];
-      if (rule && !rule._meta.isTrivia) rule._meta.grammarTrivia = options.trivia;
-    }
-  }
-  if (options?.scanSkip != null) {
-    for (const key of Object.keys(definitions)) {
-      const rule = cache[key];
-      if (rule && !rule._meta.isTrivia) rule._meta.grammarScanSkip = options.scanSkip;
-    }
-  }
-  if (options?.hostMode === "cst") {
-    for (const key of Object.keys(definitions)) {
-      const rule = cache[key];
-      if (rule && !rule._meta.isTrivia) rule._meta.grammarHostMode = "cst";
-    }
-  }
-  if (options?.trackLines === true) {
-    for (const key of Object.keys(definitions)) {
-      const rule = cache[key];
-      if (rule && !rule._meta.isTrivia) rule._meta.grammarTrackLines = true;
-    }
-    for (const key of Object.keys(definitions)) {
-      const rule = cache[key];
-      if (rule && !rule._meta.isTrivia && rule._def.tag !== "grammar") {
-        const wrapped = parser({ trackLines: true }, rule);
-        tagRule(wrapped, key);
-        wrapped._meta.grammarTrackLines = true;
-        cache[key] = wrapped;
+  for (const key of keys) {
+    const options = winners.get(key).options;
+    let rule = cache[key];
+    if (!rule._meta.isTrivia) {
+      const meta = rule._meta;
+      const trivia2 = link !== void 0 ? link.trivia : options?.trivia;
+      if (trivia2 != null) meta.grammarTrivia = trivia2;
+      if (options?.scanSkip != null) meta.grammarScanSkip = options.scanSkip;
+      if ((link?.hostMode ?? options?.hostMode) === "cst") meta.grammarHostMode = "cst";
+      if (options?.trackLines === true) {
+        meta.grammarTrackLines = true;
+        if (rule._def.tag !== "grammar") {
+          rule = parser({ trackLines: true }, rule);
+          tagRule(rule, key);
+          rule._meta.grammarTrackLines = true;
+          cache[key] = rule;
+        }
       }
     }
-  }
-  for (const key of Object.keys(definitions)) {
-    markUnusedValues(cache[key]);
+    markUnusedValues(rule);
+    claimedRules.add(winners.get(key).parser).add(rule);
   }
   Object.defineProperty(cache, RULE_ORDER, {
-    value: Object.keys(definitions),
+    value: keys,
     enumerable: false,
     configurable: true
   });
-  attachGrammarReflection(cache, collectGrammarReflection(Object.keys(definitions).map((key) => [key, cache[key]])));
+  attachGrammarReflection(cache, collectGrammarReflection(keys.map((key) => [key, cache[key]])));
   return cache;
 }
 
@@ -4061,13 +4083,24 @@ function dispatch(selector, ...arms) {
 }
 
 // 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) {
@@ -4084,7 +4117,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 } };
     }
   };
@@ -4939,7 +4972,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);
@@ -5053,13 +5086,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 },
@@ -5592,10 +5629,12 @@ function mayCommitFailure(p, seen = /* @__PURE__ */ new Set(), resolve3) {
     case "choice":
     case "sequence":
       return d.parsers.some((x) => mayCommitFailure(x, seen, resolve3));
+    // A contained transaction reports every failure uncommitted.
+    case "attempt":
+      return d.contain !== true && mayCommitFailure(d.parser, seen, resolve3);
     case "many":
     case "oneOrMore":
     case "optional":
-    case "attempt":
     case "transform":
     case "label":
     case "field":
@@ -7704,7 +7743,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),
@@ -7830,7 +7869,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 fs3 = d.parser._def.tag === "lazy" ? firstSetOf(d.parser, /* @__PURE__ */ new Set(), this.refResolver(), this.activeTrivia) : d.parser._meta.firstSet;
         if (fs3.kind === "any" || matchesEmpty(d.parser)) return inner;
@@ -9223,7 +9262,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 };
     }
@@ -10427,7 +10466,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
 }`;
@@ -11016,7 +11055,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){
@@ -11061,7 +11101,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
@@ -11681,7 +11722,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;
@@ -11699,6 +11740,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;
@@ -11726,7 +11768,7 @@ function assemble(t, prog, cfg) {
     while (first < children3.length && children3[first] === void 0) first++;
     return first === children3.length ? EMPTY_CH : children3.slice(first);
   }
-  function childrenOnlyBuildNode(child, build) {
+  function childrenOnlyBuildNode(child, build, trailing) {
     return (input, pos, ctx) => {
       const sCh = ctx._cstChildren;
       const sLv = ctx._cstLeaves;
@@ -11744,6 +11786,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;
@@ -12768,6 +12811,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;
@@ -12780,7 +12824,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;
         };
@@ -14231,11 +14278,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);
@@ -14987,7 +15034,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 [];
@@ -15012,16 +15060,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 ownRule2 = (parser2, rule) => {
+    const id = `rule:${rule}`;
+    definitions.set(id, { id, kind: "rule" });
+    rules2.set(parser2, id);
+  };
   const seen = /* @__PURE__ */ new Set();
   const visit = (parser2, path3) => {
     if (seen.has(parser2)) return;
     seen.add(parser2);
     const rule = winnerNames.get(parser2) ?? parser2._ruleName;
-    if (rule && (winnerNames.has(parser2) || parser2._def.tag !== "lazy")) {
-      const id = `rule:${rule}`;
-      definitions.set(id, { id, kind: "rule" });
-      rules2.set(parser2, id);
+    const body = selfWinnerBody(parser2);
+    if (rule && body === void 0 && !sharedBody(parser2) && (winnerNames.has(parser2) || parser2._def.tag !== "lazy")) {
+      ownRule2(parser2, rule);
     }
+    if (rule && body !== void 0 && sharedBody(body)) ownRule2(parser2, rule);
     if (parser2._def.tag === "choice") {
       const ids = parser2._def.parsers.map((_, index) => `choice:${path3}/arm:${index}`);
       choices.set(parser2, ids);
@@ -15042,7 +15113,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);
+      ownRule2(root, name);
+    }
+    visit(body ?? root, name);
   }
   return { definitions: [...definitions.values()].sort((a, b) => a.id.localeCompare(b.id)), choices, dispatches, attempts, labels, rules: rules2 };
 }
@@ -16348,6 +16425,183 @@ function runDuplicationDiagnosticRules(ruleMap, opt) {
   return reportDuplication(opt, (o) => analyzeDuplicationRules(ruleMap, o));
 }
 
+// src/table/compile-rule-map.ts
+var DEFAULT_PRECOMPILE_MIN_WORDS = 1024;
+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, rule]) => {
+    if (rule._meta.isTrivia) return [name, rule];
+    const addTrivia = opts.trivia !== void 0 && rule._meta.grammarTrivia === void 0;
+    const addScanSkip = opts.scanSkip !== void 0 && rule._meta.grammarScanSkip === void 0;
+    if (!addTrivia && !addScanSkip) return [name, rule];
+    let wrapped = wrappers.get(rule);
+    if (wrapped === void 0) {
+      wrapped = {
+        ...rule,
+        _meta: {
+          ...rule._meta,
+          ...addTrivia ? { grammarTrivia: opts.trivia } : {},
+          ...addScanSkip ? { grammarScanSkip: opts.scanSkip } : {}
+        }
+      };
+      wrappers.set(rule, 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(([, 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);
+  const plan = opts.coverage === true ? buildGrammarPlan(
+    encodeMap.map(([, rule]) => rule),
+    Object.fromEntries(encodeMap.filter(([, rule]) => rule._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;
+  }
+}
+function compileRuleMap(ruleMap, opts = {}) {
+  const encoded = encodeForRun(ruleMap, opts);
+  if (encoded === null) return null;
+  const { prog, fnSrcs, hostMode, plan } = encoded;
+  const artifact = closureArtifact(prog);
+  if (artifact.runtimeOnly !== void 0 && artifact.runtimeOnly.length > 0) {
+    opts.refusals?.push(...artifact.runtimeOnly);
+    return null;
+  }
+  const supplied = opts.fnSources;
+  const sources = fnSrcs.map((s, i) => s ?? supplied?.[i] ?? null);
+  if (sources.some((s) => s === null)) {
+    const missing = sources.flatMap((s, i) => s === null ? [i] : []);
+    opts.refusals?.push(
+      `author reducer source missing for prog.fns[${missing.join(", ")}] \u2014 printing would emit \`() => {}\` and the parse would return no value`
+    );
+    return null;
+  }
+  if (supplied !== void 0 && supplied.length > fnSrcs.length) {
+    throw new Error(
+      `compileRuleMap: got ${supplied.length} fnSources for a pool of ${fnSrcs.length}. The list is positional, in prog.fns order, so a longer one means it belongs to a different encode \u2014 and the entries would be silently misassigned.`
+    );
+  }
+  const replacementWithMetadata = (metadataSource, options = {}) => emitTableExpression(artifact, {
+    entry: null,
+    runtimeRef: opts.runtimeRef ?? "tableRules",
+    fnSources: sources,
+    ...options.precompileDefault === true && hostMode === "ast" && prog.lines !== 1 && prog.code.length >= DEFAULT_PRECOMPILE_MIN_WORDS ? { assemblies: defaultAssemblyCfgs(artifact).slice(0, 1) } : {},
+    ...metadataSource === void 0 ? {} : { metadataSource }
+  });
+  const replacement = replacementWithMetadata();
+  return {
+    keys: ruleMap.map(([key]) => key),
+    replacement,
+    replacementWithMetadata,
+    hostMode,
+    // WHAT THE FLAG MEANS is "a DIRECT BUILDER's positioned-CST branch was
+    // dropped", which is what the driver's `'ast' artifact + CST host` check keys
+    // off. `mode === 'ast'` alone over-reports it: an all-STRUCTURAL grammar has no
+    // direct builder, so there was no branch to drop and it stays usable with either
+    // host — the long-standing `node(parser)` contract. Same predicate codegen uses
+    // for its own `hasDirectBuilders` (both read `analysis/commitment.ts`), so the two
+    // lowerings stamp the same artifact rather than disagreeing about it.
+    hostBranchElided: hostMode === "ast" && ruleMap.some(([, rule]) => hasDirectBuildDef(rule)),
+    reflection: collectGrammarReflection(ruleMap),
+    ...plan === void 0 ? {} : { coverageDefinitions: plan.definitions },
+    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 childrenOf2(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) {
@@ -16357,7 +16611,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;
@@ -16427,29 +16721,6 @@ function compileImpl(combinator, mapFnSources, opts = {}) {
   };
 }
 
-// src/combinators/withCtx.ts
-function withCtx(extra, combinator) {
-  const meta = {
-    firstSet: combinator._meta.firstSet,
-    canMatchNewline: combinator._meta.canMatchNewline,
-    isTrivia: false
-  };
-  return {
-    _tag: "withCtx",
-    _meta: meta,
-    _def: { tag: "withCtx", extra, parser: combinator },
-    parse(input, pos, ctx) {
-      const saved = ctx.state;
-      ctx.state = extra;
-      try {
-        return combinator.parse(input, pos, ctx);
-      } finally {
-        ctx.state = saved;
-      }
-    }
-  };
-}
-
 // src/compiler/ir-serialize.ts
 function childrenOf3(def) {
   switch (def.tag) {
@@ -16546,195 +16817,28 @@ function serializeRuleMap(ruleMap, scanSkip) {
     throw e;
   }
 }
-function evalRuleMapIR(ir) {
-  const _tf = (child, src, recognitionOnly = false) => {
-    let fn2;
-    try {
-      fn2 = (0, eval)(`(${src})`);
-    } catch {
-      fn2 = () => {
-        throw new Error("IR transform fn not materialized");
-      };
-    }
-    const t = transform(child, fn2);
-    t._def.fnSrc = src;
-    if (recognitionOnly) t._def.recognitionOnly = true;
-    return t;
-  };
-  const _lf = (child, src, source = false) => {
-    let fn2;
-    try {
-      fn2 = (0, eval)(`(${src})`);
-    } catch {
-      fn2 = () => {
-        throw new Error("IR leaf fn not materialized");
-      };
-    }
-    const l = source ? sourceLeaf(child, fn2) : leaf(child, fn2);
-    l._def.fnSrc = src;
-    return l;
-  };
-  const _nd = (type, child, src, opts, staticError, sigSrc, buildImports, rawUnused) => {
-    if (staticError !== void 0 && staticError.length > 0) {
-      throw new Error(`IR direct node builder for ${type} must be macro-static and self-contained; unsupported binding(s): ${staticError.join(", ")}`);
-    }
-    const n = node(type, child, (() => {
-      throw new Error("IR node build requires static re-lowering");
-    }), opts);
-    n._def.buildSrc = src;
-    if (staticError !== void 0) n._def.buildStaticError = staticError;
-    if (sigSrc !== void 0) n._def.buildSigSrc = sigSrc;
-    if (rawUnused === true) n._def.buildRawUnused = true;
-    if (buildImports !== void 0) n._def.buildImports = buildImports;
-    return n;
-  };
-  const _gch = (items) => {
-    const gateSrcs = [];
-    const arms = items.map((it) => {
-      if (Array.isArray(it)) {
-        const [src, comb] = it;
-        gateSrcs.push(src);
-        let gate2;
-        try {
-          gate2 = (0, eval)(`(${src})`);
-        } catch {
-          gate2 = () => {
-            throw new Error("IR gate fn not materialized");
-          };
-        }
-        return { gate: gate2, combinator: comb };
-      }
-      gateSrcs.push(null);
-      return it;
-    });
-    const c = choice(...arms);
-    const gates = c._def.gates;
-    if (gates && gates.length !== gateSrcs.length) {
-      throw new Error(`_gch: gateSrcs length ${gateSrcs.length} != choice gates length ${gates.length}`);
-    }
-    ;
-    c._def.gateSrcs = gateSrcs;
-    return c;
-  };
-  const _wc = (src, inner) => {
-    let extra;
-    try {
-      extra = (0, eval)(`(${src})`);
-    } catch {
-      extra = void 0;
-    }
-    const w = withCtx(extra, inner);
-    w._def.extraSrc = src;
-    return w;
-  };
-  const fn = new Function(
-    "rules",
-    "ref",
-    "regex",
-    "literal",
-    "keywords",
-    "sequence",
-    "choice",
-    "dispatch",
-    "when",
-    "startsWith",
-    "endsWith",
-    "matches",
-    "otherwise",
-    "routed",
-    "attempt",
-    "many",
-    "oneOrMore",
-    "optional",
-    "sepBy",
-    "keepSeparator",
-    "not",
-    "peek",
-    "node",
-    "parser",
-    "scanTo",
-    "balanced",
-    "token",
-    "leaf",
-    "transform",
-    "trivia",
-    "classifiedTrivia",
-    "label",
-    "field",
-    "expect",
-    "adjacent",
-    "notAdjacent",
-    "_tf",
-    "_lf",
-    "_nd",
-    "_gch",
-    "_wc",
-    `return (${ir})`
-  );
-  const map = fn(
-    rules,
-    ref,
-    regex,
-    literal,
-    keywords,
-    sequence,
-    choice,
-    dispatch,
-    when,
-    startsWith,
-    endsWith,
-    matches,
-    otherwise,
-    routed,
-    attempt,
-    many,
-    oneOrMore,
-    optional,
-    sepBy,
-    keepSeparator,
-    not,
-    peek,
-    node,
-    parser,
-    scanTo,
-    balanced,
-    token,
-    leaf,
-    transform,
-    trivia,
-    classifiedTrivia,
-    label,
-    field,
-    expect,
-    adjacent,
-    notAdjacent,
-    _tf,
-    _lf,
-    _nd,
-    _gch,
-    _wc
-  );
-  return Object.entries(map);
-}
-var Serializer = class {
-  counts = /* @__PURE__ */ new Map();
-  selfRef = /* @__PURE__ */ new Set();
-  // combinators reached by an unnamed lazy pointing back into their own subtree
-  cycleInterior = /* @__PURE__ */ new Set();
-  // combinators lying ON a self-reference cycle (strictly below its target)
-  constName = /* @__PURE__ */ new Map();
-  emitted = /* @__PURE__ */ new Set();
-  decls = [];
-  ruleValues = /* @__PURE__ */ new Set();
-  localRuleNames = /* @__PURE__ */ new Map();
-  ruleMap;
-  scanSkip;
-  constructor(ruleMap, scanSkip = []) {
-    this.ruleMap = ruleMap;
-    this.scanSkip = scanSkip;
-    for (const [name, c] of ruleMap) {
-      this.localRuleNames.set(c, name);
-      this.ruleValues.add(this.body(c));
+function serializeCombinator(c) {
+  return serializeRuleMap([], [c]);
+}
+var Serializer = class {
+  counts = /* @__PURE__ */ new Map();
+  selfRef = /* @__PURE__ */ new Set();
+  // combinators reached by an unnamed lazy pointing back into their own subtree
+  cycleInterior = /* @__PURE__ */ new Set();
+  // combinators lying ON a self-reference cycle (strictly below its target)
+  constName = /* @__PURE__ */ new Map();
+  emitted = /* @__PURE__ */ new Set();
+  decls = [];
+  ruleValues = /* @__PURE__ */ new Set();
+  localRuleNames = /* @__PURE__ */ new Map();
+  ruleMap;
+  scanSkip;
+  constructor(ruleMap, scanSkip = []) {
+    this.ruleMap = ruleMap;
+    this.scanSkip = scanSkip;
+    for (const [name, c] of ruleMap) {
+      this.localRuleNames.set(c, name);
+      this.ruleValues.add(this.body(c));
     }
   }
   /** A grammar-level `scanSkip` unit is an opaque TERMINAL (a string, a balanced
@@ -16954,7 +17058,7 @@ ${outerDecls.map((d) => "  " + d).join("\n")}
       case "optional":
         return `optional(${kid(def.parser)})`;
       case "attempt":
-        return `attempt(${kid(def.parser)})`;
+        return `attempt(${kid(def.parser)}${def.contain === true ? ", { contain: true }" : ""})`;
       // `keepSeparators` is an opt-in expressed at the SEPARATOR, not in the options
       // bag, so it must round-trip as `keepSeparator(sep)` — serializing it as an
       // option would reconstruct a grammar whose call site no longer states its own
@@ -17042,127 +17146,8 @@ ${outerDecls.map((d) => "  " + d).join("\n")}
   }
 };
 
-// src/table/compile-rule-map.ts
-var DEFAULT_PRECOMPILE_MIN_WORDS = 1024;
-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, rule]) => {
-    if (rule._meta.isTrivia) return [name, rule];
-    const addTrivia = opts.trivia !== void 0 && rule._meta.grammarTrivia === void 0;
-    const addScanSkip = opts.scanSkip !== void 0 && rule._meta.grammarScanSkip === void 0;
-    if (!addTrivia && !addScanSkip) return [name, rule];
-    let wrapped = wrappers.get(rule);
-    if (wrapped === void 0) {
-      wrapped = {
-        ...rule,
-        _meta: {
-          ...rule._meta,
-          ...addTrivia ? { grammarTrivia: opts.trivia } : {},
-          ...addScanSkip ? { grammarScanSkip: opts.scanSkip } : {}
-        }
-      };
-      wrappers.set(rule, 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);
-  return {
-    keys: ruleMap.map(([key]) => key),
-    hostMode,
-    hostBranchElided: hostMode === "ast" && ruleMap.some(([, rule]) => hasDirectBuildDef(rule)),
-    reflection: collectGrammarReflection(ruleMap),
-    ...plan === void 0 ? {} : { coverageDefinitions: plan.definitions },
-    rules: tableRules(prog),
-    prog: artifact
-  };
-}
-function encodeForRun(ruleMap, opts) {
-  runDuplicationDiagnosticRules(ruleMap, opts.duplication);
-  const encodeMap = withAmbient(ruleMap, opts);
-  const plan = opts.coverage === true ? buildGrammarPlan(
-    encodeMap.map(([, rule]) => rule),
-    Object.fromEntries(encodeMap.filter(([, rule]) => rule._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;
-  }
-}
-function compileRuleMap(ruleMap, opts = {}) {
-  const encoded = encodeForRun(ruleMap, opts);
-  if (encoded === null) return null;
-  const { prog, fnSrcs, hostMode, plan } = encoded;
-  const artifact = closureArtifact(prog);
-  if (artifact.runtimeOnly !== void 0 && artifact.runtimeOnly.length > 0) {
-    opts.refusals?.push(...artifact.runtimeOnly);
-    return null;
-  }
-  const supplied = opts.fnSources;
-  const sources = fnSrcs.map((s, i) => s ?? supplied?.[i] ?? null);
-  if (sources.some((s) => s === null)) {
-    const missing = sources.flatMap((s, i) => s === null ? [i] : []);
-    opts.refusals?.push(
-      `author reducer source missing for prog.fns[${missing.join(", ")}] \u2014 printing would emit \`() => {}\` and the parse would return no value`
-    );
-    return null;
-  }
-  if (supplied !== void 0 && supplied.length > fnSrcs.length) {
-    throw new Error(
-      `compileRuleMap: got ${supplied.length} fnSources for a pool of ${fnSrcs.length}. The list is positional, in prog.fns order, so a longer one means it belongs to a different encode \u2014 and the entries would be silently misassigned.`
-    );
-  }
-  const replacementWithMetadata = (metadataSource, options = {}) => emitTableExpression(artifact, {
-    entry: null,
-    runtimeRef: opts.runtimeRef ?? "tableRules",
-    fnSources: sources,
-    ...options.precompileDefault === true && hostMode === "ast" && prog.lines !== 1 && prog.code.length >= DEFAULT_PRECOMPILE_MIN_WORDS ? { assemblies: defaultAssemblyCfgs(artifact).slice(0, 1) } : {},
-    ...metadataSource === void 0 ? {} : { metadataSource }
-  });
-  const replacement = replacementWithMetadata();
-  return {
-    keys: ruleMap.map(([key]) => key),
-    replacement,
-    replacementWithMetadata,
-    hostMode,
-    // WHAT THE FLAG MEANS is "a DIRECT BUILDER's positioned-CST branch was
-    // dropped", which is what the driver's `'ast' artifact + CST host` check keys
-    // off. `mode === 'ast'` alone over-reports it: an all-STRUCTURAL grammar has no
-    // direct builder, so there was no branch to drop and it stays usable with either
-    // host — the long-standing `node(parser)` contract. Same predicate codegen uses
-    // for its own `hasDirectBuilders` (both read `analysis/commitment.ts`), so the two
-    // lowerings stamp the same artifact rather than disagreeing about it.
-    hostBranchElided: hostMode === "ast" && ruleMap.some(([, rule]) => hasDirectBuildDef(rule)),
-    reflection: collectGrammarReflection(ruleMap),
-    ...plan === void 0 ? {} : { coverageDefinitions: plan.definitions },
-    rules: tableRules(prog),
-    prog: artifact
-  };
-}
-
 // src/version.ts
-var PARSEMAN_VERSION = "0.51.2";
+var PARSEMAN_VERSION = "0.53.0";
 
 // src/compiler/compile-linkable-table.ts
 function isLocal(rule) {
@@ -17274,6 +17259,29 @@ function gate(predicate) {
   };
 }
 
+// src/combinators/withCtx.ts
+function withCtx(extra, combinator) {
+  const meta = {
+    firstSet: combinator._meta.firstSet,
+    canMatchNewline: combinator._meta.canMatchNewline,
+    isTrivia: false
+  };
+  return {
+    _tag: "withCtx",
+    _meta: meta,
+    _def: { tag: "withCtx", extra, parser: combinator },
+    parse(input, pos, ctx) {
+      const saved = ctx.state;
+      ctx.state = extra;
+      try {
+        return combinator.parse(input, pos, ctx);
+      } finally {
+        ctx.state = saved;
+      }
+    }
+  };
+}
+
 // src/plugin/direct-builder-static.ts
 import { parseSync } from "oxc-parser";
 var STATIC_BUILDER_GLOBALS = /* @__PURE__ */ new Set([
@@ -17559,6 +17567,41 @@ var _builderImports = null;
 function setBuilderImportResolver(r) {
   _builderImports = r;
 }
+var ModuleScope = class _ModuleScope extends Map {
+  tried = /* @__PURE__ */ new Map();
+  resolveFree;
+  unresolved;
+  constructor(resolveFree, unresolved) {
+    super();
+    this.resolveFree = resolveFree;
+    this.unresolved = unresolved;
+  }
+  has(name) {
+    return super.has(name) || this.resolve(name);
+  }
+  get(name) {
+    if (super.has(name) || this.resolve(name)) return super.get(name);
+    const why = this.tried.get(name);
+    if (why !== void 0) this.unresolved.add(`\`${name}\` ${why}`);
+    return void 0;
+  }
+  /** A child scope (a factory body) that keeps resolving this module's free names. */
+  fork() {
+    const child = new _ModuleScope(this.resolveFree, this.unresolved);
+    for (const [k, v] of super.entries()) child.set(k, v);
+    return child;
+  }
+  resolve(name) {
+    if (this.tried.has(name)) return false;
+    const r = this.resolveFree(name);
+    if (r !== null && "value" in r) {
+      super.set(name, r.value);
+      return true;
+    }
+    if (r !== null) this.tried.set(name, r.unresolved);
+    return false;
+  }
+};
 function isWordFactory(v) {
   return !!v && typeof v === "object" && v.tag === "wordFactory";
 }
@@ -17611,7 +17654,7 @@ var SUPPORTED = {
   word: (...a) => word(a[0], a[1], a[2]),
   sequence: (...a) => sequence(...a),
   choice: (...a) => choice(...a),
-  attempt: (...a) => attempt(a[0]),
+  attempt: (...a) => attempt(a[0], a[1]),
   optional: (...a) => optional(a[0]),
   trivia: (...a) => trivia(a[0]),
   classifiedTrivia: (...a) => classifiedTrivia(
@@ -17682,7 +17725,7 @@ function dispatchArmValue(node2, scope, code, mfs) {
     if (!keyArg || !parserArg || extraArg !== void 0 || keyArg.type === "SpreadElement" || parserArg.type === "SpreadElement") return null;
     const key = anyValue(keyArg, scope, code, mfs);
     const parserValue = anyValue(parserArg, scope, code, mfs);
-    if (!isCombinator(parserValue)) return null;
+    if (!isCombinator2(parserValue)) return null;
     const opts = { caseInsensitive: factory.caseInsensitive };
     if (typeof key === "string") return when(key, parserValue, opts);
     if (Array.isArray(key) && key.every((item) => typeof item === "string")) return when(key, parserValue, opts);
@@ -17693,7 +17736,7 @@ function dispatchArmValue(node2, scope, code, mfs) {
     const [parserArg] = node2.arguments;
     if (!parserArg || parserArg.type === "SpreadElement") return null;
     const parserValue = anyValue(parserArg, scope, code, mfs);
-    if (!isCombinator(parserValue)) return null;
+    if (!isCombinator2(parserValue)) return null;
     return otherwise(parserValue);
   }
   if (callee.name === "when") {
@@ -17703,24 +17746,24 @@ function dispatchArmValue(node2, scope, code, mfs) {
     const parserValue = anyValue(parserArg, scope, code, mfs);
     const opts = dispatchWhenOptions(optsArg === void 0 ? void 0 : anyValue(optsArg, scope, code, mfs));
     if (opts === null) return null;
-    if (!isCombinator(parserValue)) return null;
+    if (!isCombinator2(parserValue)) return null;
     if (typeof key === "string") return when(key, parserValue, opts);
     if (Array.isArray(key) && key.every((item) => typeof item === "string")) return when(key, parserValue, opts);
     if (isDispatchMatcher(key)) return when(key, parserValue, opts);
   }
   return null;
 }
-function isCombinator(v) {
+function isCombinator2(v) {
   return !!v && typeof v === "object" && "_def" in v;
 }
 function isDispatchArm(v) {
   if (!v || typeof v !== "object") return false;
   const rec = v;
-  if (rec.kind === "otherwise") return isCombinator(rec.parser);
+  if (rec.kind === "otherwise") return isCombinator2(rec.parser);
   if (rec.kind === "whenMatcher") {
-    return isDispatchMatcher(rec.matcher) && typeof rec.caseInsensitive === "boolean" && isCombinator(rec.parser);
+    return isDispatchMatcher(rec.matcher) && typeof rec.caseInsensitive === "boolean" && isCombinator2(rec.parser);
   }
-  return rec.kind === "when" && Array.isArray(rec.keys) && rec.keys.every((key) => typeof key === "string") && typeof rec.caseInsensitive === "boolean" && isCombinator(rec.parser);
+  return rec.kind === "when" && Array.isArray(rec.keys) && rec.keys.every((key) => typeof key === "string") && typeof rec.caseInsensitive === "boolean" && isCombinator2(rec.parser);
 }
 function isDispatchMatcher(v) {
   if (!v || typeof v !== "object") return false;
@@ -17735,7 +17778,7 @@ function scopeGet(scope, name, mfs) {
     if (mfs && entry.mfSrcs.length > 0) mfs.push(...entry.mfSrcs);
     return entry.combi;
   }
-  if (isCombinator(entry)) return entry;
+  if (isCombinator2(entry)) return entry;
   return null;
 }
 function unwrapStaticExpr(expr) {
@@ -17787,7 +17830,7 @@ function scopedStaticValue(expr, scope) {
   return { found: true, value };
 }
 function staticNodeOptionsFromValue(value) {
-  if (value === null || typeof value !== "object" || Array.isArray(value) || isCombinator(value)) return STATIC_NODE_OPTIONS_NOT_OPTIONS;
+  if (value === null || typeof value !== "object" || Array.isArray(value) || isCombinator2(value)) return STATIC_NODE_OPTIONS_NOT_OPTIONS;
   const opts = {};
   const rec = value;
   for (const name of Object.keys(rec)) {
@@ -17839,6 +17882,13 @@ function staticNodeOptions(expr, scope) {
   }
   return opts.unwrap || opts.collapse || opts.project !== void 0 || opts.captureTrivia || opts.trailingTrivia || opts.tags !== void 0 || opts.buildArity !== void 0 ? opts : void 0;
 }
+var UNKNOWN_OPTIONS = /* @__PURE__ */ Symbol("parseman.unknownOptions");
+function scanOptions(optsArg, scope, code) {
+  if (optsArg === void 0) return void 0;
+  if (optsArg.type === "SpreadElement") return UNKNOWN_OPTIONS;
+  const opts = anyValue(optsArg, scope, code, []);
+  return isHole(optsArg, opts, scope) ? UNKNOWN_OPTIONS : opts;
+}
 function exprToCombi(node2, scope, code, mfs) {
   if (node2.type === "Identifier") return scopeGet(scope, node2.name, mfs);
   if (node2.type !== "CallExpression") return null;
@@ -17874,7 +17924,7 @@ function exprToCombi(node2, scope, code, mfs) {
     const [parserArg, fnArg] = node2.arguments;
     if (!parserArg || !fnArg || parserArg.type === "SpreadElement" || fnArg.type === "SpreadElement") return null;
     const inner = anyValue(parserArg, scope, code, mfs);
-    if (!isCombinator(inner)) return null;
+    if (!isCombinator2(inner)) return null;
     const fnSrc = stripTsFromSource(fnArg, code);
     mfs.push(fnSrc);
     try {
@@ -17889,7 +17939,7 @@ function exprToCombi(node2, scope, code, mfs) {
     const [parserArg, fnArg] = node2.arguments;
     if (!parserArg || !fnArg || parserArg.type === "SpreadElement" || fnArg.type === "SpreadElement") return null;
     const inner = anyValue(parserArg, scope, code, mfs);
-    if (!isCombinator(inner)) return null;
+    if (!isCombinator2(inner)) return null;
     const fnSrc = stripTsFromSource(fnArg, code);
     mfs.push(fnSrc);
     try {
@@ -17910,7 +17960,7 @@ function exprToCombi(node2, scope, code, mfs) {
     const optsArg = explicitType !== void 0 ? fourthArg : thirdArg;
     if (!parserArg || parserArg.type === "SpreadElement") return null;
     const inner = anyValue(parserArg, scope, code, mfs);
-    if (!isCombinator(inner)) return null;
+    if (!isCombinator2(inner)) return null;
     const be = buildArg;
     const buildExpr = be === void 0 || be.type === "SpreadElement" ? void 0 : unwrapStaticExpr(be);
     const buildArgOptions = be !== void 0 && be.type !== "SpreadElement" ? staticNodeOptions(buildArg, scope) : STATIC_NODE_OPTIONS_NOT_OPTIONS;
@@ -17984,7 +18034,7 @@ function exprToCombi(node2, scope, code, mfs) {
     const opts = anyValue(optsArg, scope, code, []);
     if (!opts || typeof opts !== "object") return null;
     const root = anyValue(rootArg, scope, code, mfs);
-    if (!isCombinator(root)) return null;
+    if (!isCombinator2(root)) return null;
     try {
       return parser(opts, root);
     } catch {
@@ -17996,10 +18046,10 @@ function exprToCombi(node2, scope, code, mfs) {
     if (!itemArg || !sepArg || itemArg.type === "SpreadElement" || sepArg.type === "SpreadElement") return null;
     const itemMfs = [];
     const itemCombi = anyValue(itemArg, scope, code, itemMfs);
-    if (!isCombinator(itemCombi)) return null;
+    if (!isCombinator2(itemCombi)) return null;
     const sepMfs = [];
     const sepCombi = anyValue(sepArg, scope, code, sepMfs);
-    if (!isCombinator(sepCombi)) return null;
+    if (!isCombinator2(sepCombi)) return null;
     let opts;
     if (optsArg) {
       if (optsArg.type === "SpreadElement") return null;
@@ -18019,7 +18069,7 @@ function exprToCombi(node2, scope, code, mfs) {
     if (!itemArg || itemArg.type === "SpreadElement") return null;
     const itemMfs = [];
     const itemCombi = anyValue(itemArg, scope, code, itemMfs);
-    if (!isCombinator(itemCombi)) return null;
+    if (!isCombinator2(itemCombi)) return null;
     let opts;
     if (optsArg) {
       if (optsArg.type === "SpreadElement") return null;
@@ -18041,7 +18091,7 @@ function exprToCombi(node2, scope, code, mfs) {
     const [innerArg] = node2.arguments;
     if (!innerArg || innerArg.type === "SpreadElement") return null;
     const inner = anyValue(innerArg, scope, code, mfs);
-    if (!isCombinator(inner)) return null;
+    if (!isCombinator2(inner)) return null;
     try {
       return not(inner);
     } catch {
@@ -18052,7 +18102,7 @@ function exprToCombi(node2, scope, code, mfs) {
     const [innerArg] = node2.arguments;
     if (!innerArg || innerArg.type === "SpreadElement") return null;
     const inner = anyValue(innerArg, scope, code, mfs);
-    if (!isCombinator(inner)) return null;
+    if (!isCombinator2(inner)) return null;
     try {
       return peek(inner);
     } catch {
@@ -18065,7 +18115,8 @@ function exprToCombi(node2, scope, code, mfs) {
     const open = anyValue(openArg, scope, code, []);
     const close = anyValue(closeArg, scope, code, []);
     if (typeof open !== "string" || typeof close !== "string") return null;
-    const opts = optsArg && optsArg.type !== "SpreadElement" ? anyValue(optsArg, scope, code, []) : void 0;
+    const opts = scanOptions(optsArg, scope, code);
+    if (opts === UNKNOWN_OPTIONS) return null;
     try {
       return balanced(open, close, opts);
     } catch {
@@ -18076,8 +18127,9 @@ function exprToCombi(node2, scope, code, mfs) {
     const [sentinelArg, optsArg] = node2.arguments;
     if (!sentinelArg || sentinelArg.type === "SpreadElement") return null;
     const sentinel = anyValue(sentinelArg, scope, code, []);
-    if (!isCombinator(sentinel)) return null;
-    const opts = optsArg && optsArg.type !== "SpreadElement" ? anyValue(optsArg, scope, code, []) : void 0;
+    if (!isCombinator2(sentinel)) return null;
+    const opts = scanOptions(optsArg, scope, code);
+    if (opts === UNKNOWN_OPTIONS) return null;
     try {
       return scanTo(sentinel, opts);
     } catch {
@@ -18106,7 +18158,7 @@ function exprToCombi(node2, scope, code, mfs) {
     const extraSrc = stripTsFromSource(extraArg, code);
     mfs.push(extraSrc);
     const inner = anyValue(innerArg, scope, code, mfs);
-    if (!isCombinator(inner)) return null;
+    if (!isCombinator2(inner)) return null;
     try {
       const evaluated = anyValue(extraArg, scope, code, []);
       const usable = typeof evaluated === "object" && evaluated !== null && !Array.isArray(evaluated) && Object.getPrototypeOf(evaluated) === Object.prototype;
@@ -18122,7 +18174,7 @@ function exprToCombi(node2, scope, code, mfs) {
     const [selectorArg, ...armArgs] = node2.arguments;
     if (!selectorArg || selectorArg.type === "SpreadElement") return null;
     const selector = anyValue(selectorArg, scope, code, mfs);
-    if (!isCombinator(selector)) return null;
+    if (!isCombinator2(selector)) return null;
     const arms = [];
     for (const arg of armArgs) {
       if (arg.type === "SpreadElement") return null;
@@ -18149,12 +18201,12 @@ function exprToCombi(node2, scope, code, mfs) {
         const gateSrc = stripTsFromSource(parts.gate, code);
         mfs.push(gateSrc);
         const combi = anyValue(parts.combinator, scope, code, mfs);
-        if (!isCombinator(combi)) return null;
+        if (!isCombinator2(combi)) return null;
         arms.push({ gate: () => true, combinator: combi });
         gateSrcs.push(gateSrc);
       } else {
         const combi = anyValue(argNode, scope, code, mfs);
-        if (!isCombinator(combi)) return null;
+        if (!isCombinator2(combi)) return null;
         arms.push(combi);
         gateSrcs.push(null);
       }
@@ -18184,6 +18236,12 @@ function exprToCombi(node2, scope, code, mfs) {
     return null;
   }
 }
+function isHole(node2, value, scope) {
+  if (value !== null) return false;
+  const n = unwrapStaticExpr(node2);
+  if (n.type === "Identifier") return !scope.has(n.name);
+  return !(n.type === "Literal" && n.value === null) && n.type !== "ArrowFunctionExpression" && n.type !== "FunctionExpression";
+}
 function anyValue(node2, scope, code, mfs) {
   if (node2.type === "TSAsExpression" || node2.type === "TSSatisfiesExpression" || node2.type === "TSNonNullExpression" || node2.type === "TSTypeAssertion" || node2.type === "TSInstantiationExpression" || node2.type === "ParenthesizedExpression") {
     const inner = node2.expression;
@@ -18204,7 +18262,9 @@ function anyValue(node2, scope, code, mfs) {
         continue;
       }
       if (el.type === "SpreadElement") return null;
-      out.push(anyValue(el, scope, code, mfs));
+      const v = anyValue(el, scope, code, mfs);
+      if (isHole(el, v, scope)) return null;
+      out.push(v);
     }
     return out;
   }
@@ -18213,7 +18273,10 @@ function anyValue(node2, scope, code, mfs) {
     for (const prop of node2.properties) {
       const key = propName(prop);
       if (key === null) return null;
-      obj[key] = anyValue(prop.value, scope, code, mfs);
+      const valueNode = prop.value;
+      const v = anyValue(valueNode, scope, code, mfs);
+      if (isHole(valueNode, v, scope)) return null;
+      obj[key] = v;
     }
     return obj;
   }
@@ -18289,10 +18352,9 @@ function evaluateExpr(node2, scope, code, mapFnSources) {
   return exprToCombi(node2, scope, code, mapFnSources);
 }
 function evaluateCombinatorArray(node2, scope, code) {
-  if (node2.type !== "ArrayExpression") return null;
   const val = anyValue(node2, scope, code, []);
   if (!Array.isArray(val) || val.length === 0) return null;
-  if (!val.every(isCombinator)) return null;
+  if (!val.every(isCombinator2)) return null;
   return val;
 }
 function collectRuleKeys(retObj) {
@@ -18370,7 +18432,7 @@ function evalBodyStatements(statements, scope, code, out) {
         return false;
       }
       const thisDeclMfSrcs = bodyMfs.slice(before);
-      if (isCombinator(val)) scope.set(name, { combi: val, mfSrcs: thisDeclMfSrcs });
+      if (isCombinator2(val)) scope.set(name, { combi: val, mfSrcs: thisDeclMfSrcs });
       else if (isDispatchArm(val)) scope.set(name, { value: val, mfSrcs: thisDeclMfSrcs });
       else scope.set(name, val);
     }
@@ -18415,7 +18477,7 @@ function evaluateParserFactory(factoryNode, scope, code, mapFnSources, out, opti
   let built;
   try {
     built = rules(options ?? {}, (g) => {
-      const localScope = new Map(scope);
+      const localScope = scope instanceof ModuleScope ? scope.fork() : new Map(scope);
       localScope.set(proxyName, g);
       if (!evalBodyStatements(statements, localScope, code, out)) throw ABORT;
       const entries = flattenRuleEntries(retObj, localScope, code);
@@ -18425,7 +18487,7 @@ function evaluateParserFactory(factoryNode, scope, code, mapFnSources, out, opti
       const definitions = {};
       for (const [key, e] of finalByKey) {
         const val = anyValue(e.value, e.scope, e.code, mapFnSources);
-        if (!isCombinator(val)) throw ABORT;
+        if (!isCombinator2(val)) throw ABORT;
         definitions[key] = val;
       }
       return definitions;
@@ -18440,7 +18502,7 @@ function evaluateParserFactory(factoryNode, scope, code, mapFnSources, out, opti
   return map;
 }
 function isDefinableRef2(v) {
-  return isCombinator(v) && typeof v.define === "function" && v._def.tag === "lazy";
+  return isCombinator2(v) && typeof v.define === "function" && v._def.tag === "lazy";
 }
 function evaluateRefDeclaration(init, name, scope) {
   if (init.type !== "CallExpression") return null;
@@ -18460,12 +18522,12 @@ function applyDefineStatement(callExpr, scope, code) {
   if (mem.property.type !== "Identifier" || mem.property.name !== "define") return false;
   if (mem.object.type !== "Identifier" || !mem.object.name) return false;
   const target = scope.get(mem.object.name);
-  const refCombi = isScopeEntry(target) ? target.combi : isCombinator(target) ? target : null;
+  const refCombi = isScopeEntry(target) ? target.combi : isCombinator2(target) ? target : null;
   if (!refCombi || !isDefinableRef2(refCombi)) return false;
   const args = callExpr.arguments;
   if (args.length !== 1 || args[0].type === "SpreadElement") return false;
   const inner = anyValue(args[0], scope, code, []);
-  if (!isCombinator(inner)) return false;
+  if (!isCombinator2(inner)) return false;
   try {
     refCombi.define(inner);
   } catch {
@@ -18475,7 +18537,7 @@ function applyDefineStatement(callExpr, scope, code) {
 }
 function referencesAny(node2, names, scope) {
   if (node2.type === "Identifier") {
-    return names.has(node2.name) || scope.has(node2.name);
+    return names.has(node2.name) || Map.prototype.has.call(scope, node2.name);
   }
   for (const key of Object.keys(node2)) {
     const child = node2[key];
@@ -18536,7 +18598,9 @@ function patternNames(pat, out) {
   }
 }
 function declare(scope, name, b) {
-  if (!scope.bindings.has(name)) scope.bindings.set(name, b);
+  const prev = scope.bindings.get(name);
+  if (prev) prev.reassigned = true;
+  else scope.bindings.set(name, b);
 }
 function functionScope(scope) {
   let s = scope;
@@ -18636,7 +18700,8 @@ function markReassignments(body, root) {
     }
     const node2 = n;
     if (typeof node2.type !== "string") return;
-    if (node2.type === "AssignmentExpression" || node2.type === "UpdateExpression") {
+    const loopWrite = (node2.type === "ForOfStatement" || node2.type === "ForInStatement") && node2.left?.type !== "VariableDeclaration";
+    if (node2.type === "AssignmentExpression" || node2.type === "UpdateExpression" || loopWrite) {
       const target = node2.type === "UpdateExpression" ? node2.argument : node2.left;
       const names = [];
       if (target) patternNames(target, names);
@@ -18652,6 +18717,11 @@ function markReassignments(body, root) {
   };
   for (const stmt of body) walk(stmt);
 }
+function topLevelIsStable(body, moduleEnd) {
+  const root = buildScopeTree(body, moduleEnd);
+  markReassignments(body, root);
+  return (name) => root.bindings.get(name)?.reassigned !== true;
+}
 function functionArity(fn) {
   const params = fn.params ?? [];
   let count = 0;
@@ -19104,7 +19174,7 @@ function ast(value) {
 function nodes(value) {
   return Array.isArray(value) ? value.filter((v) => ast(v) !== void 0) : [];
 }
-function nameOf(node2) {
+function nameOf2(node2) {
   return node2?.type === "Identifier" && typeof node2.name === "string" ? node2.name : void 0;
 }
 function range(node2) {
@@ -19137,7 +19207,7 @@ function isDirectCallUse(call, parent, statement) {
     return declarations.length === 1 && declarations[0] === parent && parent.init === call;
   }
   if (parent.type === "AssignmentExpression") {
-    return statement.type === "ExpressionStatement" && statement.expression === parent && nameOf(ast(parent.left)) !== void 0 && parent.right === call && parent.operator === "=";
+    return statement.type === "ExpressionStatement" && statement.expression === parent && nameOf2(ast(parent.left)) !== void 0 && parent.right === call && parent.operator === "=";
   }
   if (parent.type === "ReturnStatement") return statement === parent && parent.argument === call;
   return false;
@@ -19155,7 +19225,7 @@ function hasInlineScopeHazard(fn) {
     if (node2.type === "Identifier" && node2.name === "arguments") hazard = true;
     else if (node2.type === "ThisExpression") hazard = true;
     else if (node2.type === "VariableDeclaration" && node2.kind === "var") hazard = true;
-    else if (node2.type === "MetaProperty" && nameOf(ast(node2.meta)) === "new" && nameOf(ast(node2.property)) === "target") hazard = true;
+    else if (node2.type === "MetaProperty" && nameOf2(ast(node2.meta)) === "new" && nameOf2(ast(node2.property)) === "target") hazard = true;
     else for (const child of children2(node2)) walk(child);
   };
   walk(fn.body);
@@ -19163,7 +19233,7 @@ function hasInlineScopeHazard(fn) {
 }
 function hasInlineSignature(fn) {
   const params = nodes(fn.node.params);
-  return params.length === 3 && nameOf(params[0]) === "input" && nameOf(params[1]) === "pos" && nameOf(params[2]) === "ctx";
+  return params.length === 3 && nameOf2(params[0]) === "input" && nameOf2(params[1]) === "pos" && nameOf2(params[2]) === "ctx";
 }
 function render2(source, start, end, edits) {
   const ordered = [...edits].sort((a, b) => a.start - b.start || a.end - b.end);
@@ -19256,7 +19326,7 @@ function supercompileRuleMapReplacement(prog, replacement) {
   const call = ast(declarator?.init);
   const table = nodes(call?.arguments)[0];
   if (declaration?.type !== "VariableDeclaration" || declarator?.type !== "VariableDeclarator" || call?.type !== "CallExpression" || table?.type !== "ObjectExpression") return replacement;
-  const property = (object, key) => nodes(object.properties).find((prop) => prop.type === "Property" && nameOf(ast(prop.key)) === key);
+  const property = (object, key) => nodes(object.properties).find((prop) => prop.type === "Property" && nameOf2(ast(prop.key)) === key);
   const assembliesProp = property(table, "a");
   const assemblies = nodes(ast(assembliesProp?.value)?.elements);
   if (assembliesProp === void 0 || assemblies.length !== 1 || assemblies[0]?.type !== "ObjectExpression") return replacement;
@@ -19289,7 +19359,7 @@ function supercompileEmittedAssembly(prog, _cfg, extraIps, emitted) {
   const fns = /* @__PURE__ */ new Map();
   for (const statement of nodes(wrapperBody.body)) {
     if (statement.type !== "FunctionDeclaration") continue;
-    const name = nameOf(ast(statement.id));
+    const name = nameOf2(ast(statement.id));
     const hit = name === void 0 ? void 0 : PIECE.exec(name);
     const body = ast(statement.body);
     if (hit !== void 0 && hit !== null && body?.type === "BlockStatement") {
@@ -19302,7 +19372,7 @@ function supercompileEmittedAssembly(prog, _cfg, extraIps, emitted) {
   const allCalls = [];
   const walk = (node2, current, parent, statement, statementParent) => {
     if (isFunction(node2) && node2 !== current?.node) {
-      const own = node2.type === "FunctionDeclaration" ? nameOf(ast(node2.id)) : void 0;
+      const own = node2.type === "FunctionDeclaration" ? nameOf2(ast(node2.id)) : void 0;
       const hit = own === void 0 ? void 0 : PIECE.exec(own);
       if (hit !== void 0 && hit !== null) {
         const fn = fns.get(Number(hit[1]));
@@ -19326,12 +19396,12 @@ function supercompileEmittedAssembly(prog, _cfg, extraIps, emitted) {
       ownerParent = parent;
     }
     if (node2.type === "CallExpression") {
-      const calleeName = nameOf(ast(node2.callee));
+      const calleeName = nameOf2(ast(node2.callee));
       const hit = calleeName === void 0 ? void 0 : PIECE.exec(calleeName);
       if (hit !== void 0 && hit !== null) {
         const callee = Number(hit[1]);
         const args = nodes(node2.arguments);
-        const transformable = current !== void 0 && owner2 !== void 0 && args.length === 3 && nameOf(args[0]) === "input" && nameOf(args[2]) === "ctx" && isDirectCallUse(node2, parent, owner2) && isListStatement(owner2, ownerParent);
+        const transformable = current !== void 0 && owner2 !== void 0 && args.length === 3 && nameOf2(args[0]) === "input" && nameOf2(args[2]) === "ctx" && isDirectCallUse(node2, parent, owner2) && isListStatement(owner2, ownerParent);
         if (current === void 0 || owner2 === void 0) externalRefs.add(callee);
         else {
           const call = { caller: current.ip, callee, node: node2, statement: owner2, args, transformable };
@@ -19506,7 +19576,7 @@ ${nested}
   const referenced = /* @__PURE__ */ new Set();
   const checkRefs = (node2, parent) => {
     if (node2.type === "FunctionDeclaration") {
-      const name = nameOf(ast(node2.id));
+      const name = nameOf2(ast(node2.id));
       if (name !== void 0 && PIECE.test(name)) declared.add(name);
     }
     if (node2.type === "Identifier" && typeof node2.name === "string" && PIECE.test(node2.name)) {
@@ -19515,32 +19585,210 @@ ${nested}
     }
     for (const child of children2(node2)) checkRefs(child, node2);
   };
-  checkRefs(checked.program);
-  if (declared.size !== functionsAfter || [...referenced].some((name) => !declared.has(name))) {
-    return fallback(emitted, "deleted piece body remains reachable after structured relinking", before);
-  }
-  const largestRegion = [...regionSizes].sort((a, b) => b[1] - a[1])[0];
-  const protocolRegions = {
-    node: [...regionProtocol.values()].filter((bits) => (bits & 1) !== 0).length,
-    repv: [...regionProtocol.values()].filter((bits) => (bits & 2) !== 0).length,
-    nodeAndRepv: [...regionProtocol.values()].filter((bits) => bits === 3).length
+  checkRefs(checked.program);
+  if (declared.size !== functionsAfter || [...referenced].some((name) => !declared.has(name))) {
+    return fallback(emitted, "deleted piece body remains reachable after structured relinking", before);
+  }
+  const largestRegion = [...regionSizes].sort((a, b) => b[1] - a[1])[0];
+  const protocolRegions = {
+    node: [...regionProtocol.values()].filter((bits) => (bits & 1) !== 0).length,
+    repv: [...regionProtocol.values()].filter((bits) => (bits & 2) !== 0).length,
+    nodeAndRepv: [...regionProtocol.values()].filter((bits) => bits === 3).length
+  };
+  return {
+    ...emitted,
+    source: candidate,
+    supercompile: {
+      ...before,
+      activated: removed > 0,
+      ...removed > 0 ? {} : { reason: "no uniquely-owned region bodies" },
+      functionsAfter,
+      pieceCallsAfter: pieceCallsBefore - removed,
+      sourceAfter: candidate.length,
+      regions: roots.length,
+      largestRegionSource: Math.max(0, ...regionSizes.values()),
+      ...largestRegion === void 0 ? {} : { largestRegionIp: largestRegion[0] },
+      protocolRegions
+    }
+  };
+}
+
+// src/plugin/ir-eval.ts
+function evalRulesIR(ir) {
+  return evalIR(ir, rules);
+}
+function evalCombinatorIR(ir) {
+  const units = evalIR(ir, (opts) => opts.scanSkip);
+  return units?.length === 1 ? units[0] : null;
+}
+function evalIR(ir, rulesImpl) {
+  const _tf = (child, src, recognitionOnly = false) => {
+    let fn2;
+    try {
+      fn2 = (0, eval)(`(${src})`);
+    } catch {
+      fn2 = () => {
+        throw new Error("IR transform fn not materialized");
+      };
+    }
+    const t = transform(child, fn2);
+    t._def.fnSrc = src;
+    if (recognitionOnly) t._def.recognitionOnly = true;
+    return t;
+  };
+  const _lf = (child, src, source = false) => {
+    let fn2;
+    try {
+      fn2 = (0, eval)(`(${src})`);
+    } catch {
+      fn2 = () => {
+        throw new Error("IR leaf fn not materialized");
+      };
+    }
+    const l = source ? sourceLeaf(child, fn2) : leaf(child, fn2);
+    l._def.fnSrc = src;
+    return l;
+  };
+  const _nd = (type, child, src, opts, staticError, sigSrc, buildImports, rawUnused) => {
+    if (staticError !== void 0 && staticError.length > 0) {
+      throw new Error(`IR direct node builder for ${type} must be macro-static and self-contained; unsupported binding(s): ${staticError.join(", ")}`);
+    }
+    const n = node(type, child, (() => {
+      throw new Error("IR node build requires static re-lowering");
+    }), opts);
+    n._def.buildSrc = src;
+    if (staticError !== void 0) n._def.buildStaticError = staticError;
+    if (sigSrc !== void 0) n._def.buildSigSrc = sigSrc;
+    if (rawUnused === true) n._def.buildRawUnused = true;
+    if (buildImports !== void 0) n._def.buildImports = buildImports;
+    return n;
+  };
+  const _gch = (items) => {
+    const gateSrcs = [];
+    const arms = items.map((it) => {
+      if (Array.isArray(it)) {
+        const [src, comb] = it;
+        gateSrcs.push(src);
+        let gate2;
+        try {
+          gate2 = (0, eval)(`(${src})`);
+        } catch {
+          gate2 = () => {
+            throw new Error("IR gate fn not materialized");
+          };
+        }
+        return { gate: gate2, combinator: comb };
+      }
+      gateSrcs.push(null);
+      return it;
+    });
+    const c = choice(...arms);
+    const gates = c._def.gates;
+    if (gates && gates.length !== gateSrcs.length) {
+      throw new Error(`_gch: gateSrcs length ${gateSrcs.length} != choice gates length ${gates.length}`);
+    }
+    ;
+    c._def.gateSrcs = gateSrcs;
+    return c;
   };
-  return {
-    ...emitted,
-    source: candidate,
-    supercompile: {
-      ...before,
-      activated: removed > 0,
-      ...removed > 0 ? {} : { reason: "no uniquely-owned region bodies" },
-      functionsAfter,
-      pieceCallsAfter: pieceCallsBefore - removed,
-      sourceAfter: candidate.length,
-      regions: roots.length,
-      largestRegionSource: Math.max(0, ...regionSizes.values()),
-      ...largestRegion === void 0 ? {} : { largestRegionIp: largestRegion[0] },
-      protocolRegions
+  const _wc = (src, inner) => {
+    let extra;
+    try {
+      extra = (0, eval)(`(${src})`);
+    } catch {
+      extra = void 0;
     }
+    const w = withCtx(extra, inner);
+    w._def.extraSrc = src;
+    return w;
   };
+  const fn = new Function(
+    "rules",
+    "ref",
+    "regex",
+    "literal",
+    "keywords",
+    "sequence",
+    "choice",
+    "dispatch",
+    "when",
+    "startsWith",
+    "endsWith",
+    "matches",
+    "otherwise",
+    "routed",
+    "attempt",
+    "many",
+    "oneOrMore",
+    "optional",
+    "sepBy",
+    "keepSeparator",
+    "not",
+    "peek",
+    "node",
+    "parser",
+    "scanTo",
+    "balanced",
+    "token",
+    "leaf",
+    "transform",
+    "trivia",
+    "classifiedTrivia",
+    "label",
+    "field",
+    "expect",
+    "adjacent",
+    "notAdjacent",
+    "_tf",
+    "_lf",
+    "_nd",
+    "_gch",
+    "_wc",
+    `return (${ir})`
+  );
+  return fn(
+    rulesImpl,
+    ref,
+    regex,
+    literal,
+    keywords,
+    sequence,
+    choice,
+    dispatch,
+    when,
+    startsWith,
+    endsWith,
+    matches,
+    otherwise,
+    routed,
+    attempt,
+    many,
+    oneOrMore,
+    optional,
+    sepBy,
+    keepSeparator,
+    not,
+    peek,
+    node,
+    parser,
+    scanTo,
+    balanced,
+    token,
+    leaf,
+    transform,
+    trivia,
+    classifiedTrivia,
+    label,
+    field,
+    expect,
+    adjacent,
+    notAdjacent,
+    _tf,
+    _lf,
+    _nd,
+    _gch,
+    _wc
+  );
 }
 
 // src/plugin/index.ts
@@ -19705,13 +19953,30 @@ function topLevelInit(body, name) {
   }
   return null;
 }
-function isComposedPiecesSymbol(n) {
+function isSymbolFor(n, key) {
   if (!n || n.type !== "CallExpression") return false;
   const callee = n.callee;
   const obj = callee?.object?.name;
   const prop = callee?.property?.name;
   const arg0 = n.arguments?.[0];
-  return obj === "Symbol" && prop === "for" && arg0?.value === "parseman.composedPieces";
+  return obj === "Symbol" && prop === "for" && arg0?.value === key;
+}
+var isComposedPiecesSymbol = (n) => isSymbolFor(n, "parseman.composedPieces");
+var COMBINATOR_IR_KEY = "parseman.combinatorIR";
+function carriedCombinatorIR(init) {
+  let n = init;
+  while (n.type === "ParenthesizedExpression") n = n.expression;
+  if (n.type !== "CallExpression") return null;
+  const callee = n.callee;
+  const args = n.arguments;
+  if (callee.object?.name !== "Object" || callee.property?.name !== "defineProperty" || !isSymbolFor(args[1], COMBINATOR_IR_KEY)) return null;
+  for (const p of args[2]?.properties ?? []) {
+    const v = p.value;
+    if (propName(p) !== "value") continue;
+    if (v?.type === "Literal" && typeof v.value === "string") return v.value;
+    if (v?.type === "TemplateLiteral" && v.expressions?.length === 0) return v.quasis?.[0]?.value.cooked ?? null;
+  }
+  return null;
 }
 function findCarriedPiecesLiteral(root) {
   let found = null;
@@ -19727,7 +19992,7 @@ function findCarriedPiecesLiteral(root) {
       const obj = callee?.object?.name;
       const prop = callee?.property?.name;
       const args = node2.arguments;
-      if (callee?.type === "Identifier" && callee.name === "tableRules" && args?.[1]?.type === "ObjectExpression") {
+      if (callee?.type === "Identifier" && args?.[1]?.type === "ObjectExpression") {
         for (const p of args[1].properties ?? []) {
           if (p.computed && isComposedPiecesSymbol(p.key) && p.value) {
             found = { start: p.value.start, end: p.value.end };
@@ -19827,13 +20092,14 @@ function transformMacroImpl(code, id, moduleAliases, warnUnloweredRegex, recover
   const allNames = /* @__PURE__ */ new Set();
   const importBindings = /* @__PURE__ */ new Map();
   const ordinaryImports = [];
+  const isMacroImport = (s) => s.attributes.some((a) => {
+    const key = a.key.type === "Identifier" ? a.key.name : String(a.key.value);
+    return key === "type" && a.value.value === "macro";
+  });
   for (const stmt of body) {
     if (stmt.type !== "ImportDeclaration") continue;
     const s = stmt;
-    const isMacro = moduleAliases.has(s.source.value) && s.attributes.some((a) => {
-      const key = a.key.type === "Identifier" ? a.key.name : String(a.key.value);
-      return key === "type" && a.value.value === "macro";
-    });
+    const isMacro = moduleAliases.has(s.source.value) && isMacroImport(s);
     if (!isMacro) {
       const specifiers = [];
       for (const spec of s.specifiers) {
@@ -19876,7 +20142,209 @@ function transformMacroImpl(code, id, moduleAliases, warnUnloweredRegex, recover
   }
   const reducerResolver = createReducerResolver(id, body, code);
   setReducerResolver(reducerResolver, code);
-  setBuilderImportResolver((name) => importBindings.get(name) ?? null);
+  let builderImports = (name) => importBindings.get(name) ?? null;
+  setBuilderImportResolver((name) => builderImports(name));
+  const ownRoot = nearestPackageRoot(id);
+  let ownDir = path2.dirname(id);
+  try {
+    ownDir = fs2.realpathSync(ownDir);
+  } catch {
+  }
+  const rebaseSpecifier = (from, spec) => {
+    if (!spec.startsWith(".")) return spec;
+    const target = path2.resolve(path2.dirname(from), spec);
+    if (ownRoot === null || nearestPackageRoot(target) !== ownRoot) return null;
+    const rel = path2.relative(ownDir, target).split(path2.sep).join("/");
+    return rel.startsWith("../") ? rel : `./${rel}`;
+  };
+  const unresolvedImports = /* @__PURE__ */ new Set();
+  const valueModules = /* @__PURE__ */ new Map();
+  const OPAQUE_IMPORT = "is a default or namespace import, which the macro does not resolve \u2014 import the binding by name";
+  const opaqueImportsOf = (moduleBody) => {
+    const out = /* @__PURE__ */ new Set();
+    for (const st of moduleBody) {
+      if (st.type !== "ImportDeclaration") continue;
+      for (const sp of st.specifiers) {
+        if (sp.type !== "ImportSpecifier") out.add(sp.local.name);
+      }
+    }
+    return out;
+  };
+  const valueModule = (file) => {
+    if (valueModules.has(file)) return valueModules.get(file);
+    const mod = parseModuleCached(file);
+    let out = null;
+    if (mod) {
+      const consts = /* @__PURE__ */ new Map();
+      let stable;
+      for (const st of mod.body) {
+        const vd = unwrapVd(st);
+        if (!vd) continue;
+        const isConst = vd.kind === "const";
+        for (const d of vd.declarations) {
+          const idn = d.id;
+          if (idn.type !== "Identifier" || !idn.name || !d.init) continue;
+          if (isConst || (stable ??= topLevelIsStable(mod.body, mod.src.length))(idn.name)) consts.set(idn.name, d.init);
+        }
+      }
+      out = {
+        file,
+        src: mod.src,
+        body: mod.body,
+        consts,
+        imports: extractImportBindings(mod.body),
+        opaqueImports: opaqueImportsOf(mod.body)
+      };
+    }
+    valueModules.set(file, out);
+    return out;
+  };
+  const resolveValueFile = (from, specifier) => {
+    const source = resolvePrivateSourceModule(from, specifier);
+    if (source) return source;
+    try {
+      return getCompiledResolver().resolveFileSync(from, specifier).path ?? null;
+    } catch {
+      return null;
+    }
+  };
+  const evaluatingConsts = /* @__PURE__ */ new Set();
+  const rebaseCarriedBuilderImports = (combi, from) => {
+    const seen = /* @__PURE__ */ new Set();
+    const walk = (v) => {
+      if (v === null || typeof v !== "object" || seen.has(v)) return null;
+      seen.add(v);
+      const def = v._def;
+      if (def?.buildImports) {
+        const out = [];
+        for (const bi of def.buildImports) {
+          const source = rebaseSpecifier(from, bi.source);
+          if (source === null) return bi;
+          out.push({ ...bi, source });
+        }
+        def.buildImports = out;
+      }
+      for (const child of Object.values(v)) {
+        for (const c of Array.isArray(child) ? child : [child]) {
+          const stuck = walk(c);
+          if (stuck) return stuck;
+        }
+      }
+      return null;
+    };
+    return walk(combi);
+  };
+  const moduleConstValue = (m, name) => {
+    const key = `${m.file}\0${name}`;
+    if (evaluatingConsts.has(key)) return { unresolved: `is part of a declaration cycle in ${m.file}` };
+    evaluatingConsts.add(key);
+    const outerBuilderImports = builderImports;
+    try {
+      const init = m.consts.get(name);
+      const ir = carriedCombinatorIR(init);
+      if (ir !== null) {
+        let combi2 = null;
+        let why = "";
+        try {
+          combi2 = evalCombinatorIR(ir);
+        } catch (e) {
+          why = `: ${e.message}`;
+        }
+        if (!combi2) return { unresolved: `carries combinator IR that does not evaluate (${m.file})${why}` };
+        const stuck = rebaseCarriedBuilderImports(combi2, m.file);
+        return stuck ? { unresolved: `has a node() builder reading \`${stuck.local}\` from '${stuck.source}' inside ${m.file}, which this module cannot import \u2014 import it there by package name` } : { value: { combi: combi2, mfSrcs: [] } };
+      }
+      const scope2 = moduleValueScope(m);
+      reducerResolver.register(m.file);
+      builderImports = (name2) => {
+        const b = m.imports.get(name2);
+        const source = b ? rebaseSpecifier(m.file, b.source) : null;
+        return b && source !== null ? { source, imported: b.imported } : null;
+      };
+      const mfs = [];
+      const combi = evaluateExpr(init, scope2, m.src, mfs);
+      if (combi) return { value: { combi, mfSrcs: mfs } };
+      const factory = evaluateWordFactory(init, scope2, m.src) ?? evaluateWhenFactory(init, scope2, m.src);
+      if (factory) return { value: factory };
+      const value = evaluateStaticValue(init, scope2, m.src);
+      if (value !== null && value !== void 0 || isStaticNullishExpression(init)) return { value };
+      return {
+        unresolved: /\btableRules\b/.test(m.src.slice(init.start, init.end)) ? `is a compiled parser in ${m.file} that carries no combinator IR \u2014 rebuild that module with parseman v${PARSEMAN_VERSION}` : `is not a statically-known combinator or value (${m.file})`
+      };
+    } finally {
+      evaluatingConsts.delete(key);
+      builderImports = outerBuilderImports;
+    }
+  };
+  const moduleValueScope = (m) => m.scope ??= new ModuleScope((name) => {
+    if (m.consts.has(name)) return moduleConstValue(m, name);
+    const binding = m.imports.get(name);
+    if (binding) return importedValue(m.file, binding);
+    return m.opaqueImports.has(name) ? { unresolved: OPAQUE_IMPORT } : null;
+  }, unresolvedImports);
+  const exportedValue = (m, name, depth) => {
+    for (const st of m.body) {
+      if (st.type !== "ExportNamedDeclaration" || !st.source) continue;
+      for (const sp of st.specifiers ?? []) {
+        if (sp.exported.name !== name) continue;
+        const source = st.source.value;
+        const file = depth < 16 ? resolveValueFile(m.file, source) : null;
+        const next = file ? valueModule(file) : null;
+        if (!next) return { unresolved: `is re-exported from '${source}', which does not resolve from ${m.file}` };
+        return exportedValue(next, sp.local.name, depth + 1);
+      }
+    }
+    const local = exportLocalName(m.body, name);
+    if (local === null) {
+      for (const st of m.body) {
+        if (st.type !== "ExportAllDeclaration" || st.exported) continue;
+        const file = depth < 16 ? resolveValueFile(m.file, st.source.value) : null;
+        const next = file ? valueModule(file) : null;
+        if (!next) continue;
+        const r = exportedValue(next, name, depth + 1);
+        if (r !== null && "unresolved" in r && r.unresolved.startsWith("is not exported by ")) continue;
+        return r;
+      }
+      return { unresolved: `is not exported by ${m.file}` };
+    }
+    const scope2 = moduleValueScope(m);
+    if (!scope2.has(local)) {
+      scope2.get(local);
+      return { unresolved: `could not be resolved in ${m.file}` };
+    }
+    return { value: scope2.get(local) };
+  };
+  const importedValue = (from, binding) => {
+    const file = resolveValueFile(from, binding.source);
+    const m = file ? valueModule(file) : null;
+    if (!m) return { unresolved: `is imported from '${binding.source}', which does not resolve from ${from}` };
+    return exportedValue(m, binding.imported, 0);
+  };
+  const deferredLocals = /* @__PURE__ */ new Map();
+  const deferredResults = /* @__PURE__ */ new Map();
+  const mainOpaqueImports = opaqueImportsOf(body);
+  const resolveMainFree = (name) => {
+    const done = deferredResults.get(name);
+    if (done !== void 0) return done;
+    const deferred = deferredLocals.get(name);
+    if (deferred !== void 0) {
+      deferredLocals.delete(name);
+      const outer = [...unresolvedImports];
+      unresolvedImports.clear();
+      const value = evaluateStaticValue(deferred, scope, code);
+      const why = [...unresolvedImports];
+      unresolvedImports.clear();
+      for (const n of outer) unresolvedImports.add(n);
+      const result2 = value !== null && value !== void 0 || isStaticNullishExpression(deferred) ? { value } : why.length > 0 ? { unresolved: `could not be evaluated at build time, because: ${why.join("; ")}` } : null;
+      deferredResults.set(name, result2);
+      return result2;
+    }
+    const binding = importBindings.get(name);
+    if (!binding) return mainOpaqueImports.has(name) ? { unresolved: OPAQUE_IMPORT } : null;
+    const resolved = importedValue(id, binding);
+    if (resolved !== null && "value" in resolved) usedImportedFactories.add(name);
+    return resolved;
+  };
   const topLevelFunction = (moduleBody, name) => {
     for (const st of moduleBody) {
       const decl = st.type === "ExportNamedDeclaration" ? st.declaration : st;
@@ -19885,19 +20353,17 @@ function transformMacroImpl(code, id, moduleAliases, warnUnloweredRegex, recover
     }
     return null;
   };
-  const isParsemanMacroImport = (stmt) => {
-    if (stmt.type !== "ImportDeclaration") return false;
-    const s = stmt;
-    return moduleAliases.has(s.source.value) && s.attributes.some((a) => {
-      const key = a.key.type === "Identifier" ? a.key.name : String(a.key.value);
-      return key === "type" && a.value.value === "macro";
-    });
-  };
-  const sourceScopeUntil = (moduleBody, source, until) => {
-    const out = /* @__PURE__ */ new Map();
+  const sourceScopeUntil = (file, moduleBody, source, until) => {
+    const imports = extractImportBindings(moduleBody);
+    const opaque = opaqueImportsOf(moduleBody);
+    const out = new ModuleScope((name) => {
+      const binding = imports.get(name);
+      if (binding) return importedValue(file, binding);
+      return opaque.has(name) ? { unresolved: OPAQUE_IMPORT } : null;
+    }, unresolvedImports);
     for (const stmt of moduleBody) {
       if (stmt.type === "ImportDeclaration") {
-        if (!isParsemanMacroImport(stmt)) return null;
+        if (moduleAliases.has(stmt.source.value) && !isMacroImport(stmt)) return null;
         continue;
       }
       if (stmt.type === "FunctionDeclaration") continue;
@@ -19950,6 +20416,7 @@ function transformMacroImpl(code, id, moduleAliases, warnUnloweredRegex, recover
     }
     return out;
   };
+  const factoryFailures = /* @__PURE__ */ new Map();
   const usedImportedFactories = /* @__PURE__ */ new Set();
   const markUsedImportedFactories = (names) => {
     for (const name of names ?? []) usedImportedFactories.add(name);
@@ -19962,8 +20429,13 @@ function transformMacroImpl(code, id, moduleAliases, warnUnloweredRegex, recover
     const localFor = exportLocalName(mod.body, binding.imported);
     const init = localFor ? topLevelInit(mod.body, localFor) ?? topLevelFunction(mod.body, localFor) : null;
     if (!init || init.type !== "ArrowFunctionExpression" && init.type !== "FunctionExpression" && init.type !== "FunctionDeclaration") continue;
-    const factoryScope = sourceScopeUntil(mod.body, mod.src, init.start);
-    if (!factoryScope) continue;
+    unresolvedImports.clear();
+    const factoryScope = sourceScopeUntil(file, mod.body, mod.src, init.start);
+    if (!factoryScope) {
+      if (unresolvedImports.size > 0) factoryFailures.set(localName, [...unresolvedImports]);
+      unresolvedImports.clear();
+      continue;
+    }
     factoryDecls.set(localName, {
       fn: init,
       declaredAt: -1,
@@ -19973,7 +20445,7 @@ function transformMacroImpl(code, id, moduleAliases, warnUnloweredRegex, recover
     });
     reducerResolver.register(file);
   }
-  const scope = /* @__PURE__ */ new Map();
+  const scope = new ModuleScope(resolveMainFree, unresolvedImports);
   const replacements = [];
   const warnings = [];
   beginDegradationCapture();
@@ -19993,6 +20465,12 @@ function transformMacroImpl(code, id, moduleAliases, warnUnloweredRegex, recover
           m = /* @__PURE__ */ new Map();
           pendingBuilderImports.set(bi.source, m);
         }
+        const prev = m.get(bi.local);
+        if (prev !== void 0 && prev !== bi.imported) {
+          throw new Error(
+            `${id} \u2014 parseman will not emit this module: inlined builders read \`${bi.local}\` as both \`${prev}\` and \`${bi.imported}\` from ${JSON.stringify(bi.source)}. The builder source names \`${bi.local}\` verbatim, so one import cannot bind both; import them under different names.`
+          );
+        }
         m.set(bi.local, bi.imported);
       }
       if (def?.tag === "lazy" && v._ruleName === void 0 && typeof def.thunk === "function") {
@@ -20034,6 +20512,41 @@ function transformMacroImpl(code, id, moduleAliases, warnUnloweredRegex, recover
     anyUnresolved = true;
     warnings.push(`${id}:${lineOf(pos)} \u2014 ${msg} (running via the interpreter; add the plugin or simplify the declaration to compile it)`);
   };
+  const unevaluable = (pos, what) => {
+    const names = [...unresolvedImports];
+    unresolvedImports.clear();
+    throw new Error(
+      `${id}:${lineOf(pos)} \u2014 ${what} can't be evaluated at build time` + (names.length > 0 ? `; unresolved binding(s):
+${names.map((n) => `  - ${n}`).join("\n")}` : " (it is not a static combinator/value expression)") + `
+  parseman will not emit this module rather than drop it silently.`
+    );
+  };
+  const requiredOption = (label2, name, value, evaluate) => {
+    if (value === void 0 || isStaticNullishExpression(value)) return void 0;
+    unresolvedImports.clear();
+    const out = evaluate(value);
+    if (out === null) {
+      const id2 = value.type === "Identifier" ? value.name : null;
+      if (id2 !== null && scope.has(id2) && scope.get(id2) == null) return void 0;
+      return unevaluable(value.start, `${label2}: rules({ ${name} })`);
+    }
+    unresolvedImports.clear();
+    return out;
+  };
+  const RULES_OPTIONS = /* @__PURE__ */ new Set(["trivia", "scanSkip", "hostMode", "trackLines"]);
+  const assertPlainOptions = (optExpr, label2) => {
+    for (const p of optExpr?.type === "ObjectExpression" ? optExpr.properties : []) {
+      if (propName(p) !== null) continue;
+      const key = p.type === "Property" ? evaluateStaticValue(p.key, scope, code) : null;
+      if (typeof key !== "string" || RULES_OPTIONS.has(key)) {
+        unevaluable(p.start, `${label2}: an options ${p.type === "Property" ? "computed key" : "spread"}`);
+      }
+    }
+  };
+  const triviaOption = (optExpr, label2) => {
+    assertPlainOptions(optExpr, label2);
+    return requiredOption(label2, "trivia", optionProp(optExpr, "trivia"), (v) => evaluateExpr(v, scope, code, []));
+  };
   const evaluateRulesFactory = (init, label2) => {
     const args = init.arguments;
     const arg0 = args[0];
@@ -20049,7 +20562,15 @@ function transformMacroImpl(code, id, moduleAliases, warnUnloweredRegex, recover
     const factoryScope = namedFactory?.scope ?? scope;
     const factoryCode = namedFactory?.code ?? code;
     const importedFactory = namedFactory?.imported === true && factoryArg === namedFactory.fn ? factoryArgRaw.name : void 0;
+    const failedFactory = factoryArgRaw.type === "Identifier" ? factoryFailures.get(factoryArgRaw.name) : void 0;
+    if (failedFactory) {
+      for (const n of failedFactory) unresolvedImports.add(n);
+      unevaluable(init.start, `${label2}: the imported rules() factory \`${factoryArgRaw.name}\``);
+    }
     const optionsArg = optionsFirst ? arg0 : arg1;
+    if (optionsArg !== void 0 && optionsArg.type !== "ObjectExpression" && !isStaticNullishExpression(optionsArg)) {
+      unevaluable(optionsArg.start, `${label2}: rules() options`);
+    }
     const optionValue = (name) => optionProp(optionsArg, name);
     const hostModeValue = optionValue("hostMode");
     const gHostMode = hostModeValue?.type === "Literal" ? hostModeValue.value : void 0;
@@ -20063,11 +20584,16 @@ function transformMacroImpl(code, id, moduleAliases, warnUnloweredRegex, recover
       warn(init.start, `${label2}: rules({ trackLines }) must be a boolean literal`);
       return null;
     }
-    const triviaValue = optionValue("trivia");
-    const gTrivia = triviaValue ? evaluateExpr(triviaValue, scope, code, []) : void 0;
-    const scanSkipValue = optionValue("scanSkip");
-    const gScanSkip = scanSkipValue ? evaluateCombinatorArray(scanSkipValue, scope, code) ?? void 0 : void 0;
+    const gTrivia = triviaOption(optionsArg, label2);
+    const scanSkipArray = requiredOption(label2, "scanSkip", optionValue("scanSkip"), (v) => {
+      const units = evaluateCombinatorArray(v, scope, code);
+      if (units) return units;
+      const value = evaluateStaticValue(v, scope, code);
+      return Array.isArray(value) && value.length === 0 ? [] : null;
+    });
+    const gScanSkip = scanSkipArray?.length ? scanSkipArray : void 0;
     const why = {};
+    unresolvedImports.clear();
     const ruleMap = evaluateParserFactory(factoryArg, factoryScope, factoryCode, [], why, {
       ...gTrivia ? { trivia: gTrivia } : {},
       ...gScanSkip ? { scanSkip: gScanSkip } : {},
@@ -20075,6 +20601,7 @@ function transformMacroImpl(code, id, moduleAliases, warnUnloweredRegex, recover
       ...gTrackLines === true ? { trackLines: true } : {}
     });
     if (!ruleMap) {
+      if (unresolvedImports.size > 0) unevaluable(init.start, `${label2}: rules(...) factory`);
       warn(init.start, why.reason === void 0 ? `${label2}: rules(...) factory isn't statically evaluable` : `${label2}: rules(...) factory isn't statically evaluable \u2014 ${why.reason}`);
       return null;
     }
@@ -20091,6 +20618,7 @@ function transformMacroImpl(code, id, moduleAliases, warnUnloweredRegex, recover
     if (!evaluated) return null;
     const refusals = [];
     const compiled = compileRuleMap([...evaluated.ruleMap], { ...evaluated.trivia ? { trivia: evaluated.trivia } : {}, ...evaluated.scanSkip ? { scanSkip: evaluated.scanSkip } : {}, ...evaluated.trackLines ? { trackLines: true } : {}, recovery, coverage: grammarCoverage, refusals });
+    if (compiled !== null) collectBuilderImports([...evaluated.ruleMap]);
     if (compiled !== null) usedTableRuntime = true;
     return {
       replacement: compiled?.replacement ?? null,
@@ -20152,49 +20680,63 @@ function transformMacroImpl(code, id, moduleAliases, warnUnloweredRegex, recover
   };
   const localComposedCarried = /* @__PURE__ */ new Map();
   const importedPiecesCache = /* @__PURE__ */ new Map();
-  const resolveModulePieces = (module, exportName, seen) => {
+  const resolveModulePieces = (module, exportName, seen, unresolved, local = false) => {
     const { file } = module;
     const mod = module.source ? lowerPrivateSourceModule(file, moduleAliases, warnUnloweredRegex, recovery) : parseModuleCached(file);
     if (!mod) return null;
-    const localFor = exportLocalName(mod.body, exportName);
+    const localFor = local ? exportName : exportLocalName(mod.body, exportName);
     const initNode = localFor ? topLevelInit(mod.body, localFor) : null;
     const literalRange = initNode ? findCarriedPiecesLiteral(initNode) : null;
     if (!literalRange) return null;
     const literal2 = mod.src.slice(literalRange.start, literalRange.end);
+    const fail = (why) => {
+      unresolved.why ??= `${exportName} in ${file}: ${why}`;
+      return null;
+    };
     const imports = extractImportBindings(mod.body);
     const stubNames = [];
     const stubVals = [];
-    const spreadRe = /\.\.\.\s*\(?\s*([A-Za-z_$][\w$]*)\s*\[\s*Symbol\s*\.\s*for\s*\(\s*['"]parseman\.composedPieces['"]/g;
+    const spreadRe = /\.\.\.\s*\(?\s*([A-Za-z_$][\w$]*)\s*\[\s*(?:\/\*[^]*?\*\/\s*)*Symbol\s*\.\s*for\s*\(\s*['"]parseman\.composedPieces['"]/g;
     const done = /* @__PURE__ */ new Set();
     for (let m; m = spreadRe.exec(literal2); ) {
-      const local = m[1];
-      if (done.has(local)) continue;
-      done.add(local);
-      const b = imports.get(local);
+      const local2 = m[1];
+      if (done.has(local2)) continue;
+      done.add(local2);
+      const b = imports.get(local2);
       let subPieces = [];
       if (b) {
         const subModule = resolveGrammarModule(file, b.source);
-        if (subModule && !seen.has(subModule.file)) {
-          subPieces = resolveModulePieces(subModule, b.imported, new Set(seen).add(subModule.file)) ?? [];
+        if (subModule === null) return fail(`its carried pieces spread \`${local2}\` from '${b.source}', a module that could not be found`);
+        if (!seen.has(subModule.file)) {
+          subPieces = resolveModulePieces(subModule, b.imported, new Set(seen).add(subModule.file), unresolved);
+          if (subPieces === null) return fail(`its carried pieces spread \`${local2}\` from '${b.source}', which could not be resolved`);
         }
+      } else if (topLevelInit(mod.body, local2) !== null && !seen.has(`${file}#${local2}`)) {
+        subPieces = resolveModulePieces(module, local2, new Set(seen).add(`${file}#${local2}`), unresolved, true);
+        if (subPieces === null) return fail(`its carried pieces spread the inlined binding \`${local2}\`, which carries none`);
+      } else {
+        return fail(`its carried pieces spread \`${local2}\`, which is neither an import nor a top-level binding of the module`);
       }
-      stubNames.push(local);
+      stubNames.push(local2);
       stubVals.push({ [COMPOSED_PIECES]: subPieces });
     }
     try {
       const list = new Function(...stubNames, `return (${literal2})`)(...stubVals);
       return list;
-    } catch {
-      return null;
+    } catch (e) {
+      return fail(`its carried pieces literal did not evaluate (${e.message})`);
     }
   };
+  const unresolvedCompiled = /* @__PURE__ */ new Map();
   const importedPieces = (localName) => {
     if (importedPiecesCache.has(localName)) return importedPiecesCache.get(localName);
     let result2 = null;
     const binding = importBindings.get(localName);
     if (binding) {
       const module = resolveGrammarModule(id, binding.source);
-      result2 = module ? resolveModulePieces(module, binding.imported, /* @__PURE__ */ new Set([module.file])) : null;
+      const unresolved = {};
+      result2 = module ? resolveModulePieces(module, binding.imported, /* @__PURE__ */ new Set([module.file]), unresolved) : null;
+      if (result2 === null && unresolved.why !== void 0) unresolvedCompiled.set(localName, unresolved.why);
     }
     importedPiecesCache.set(localName, result2);
     return result2;
@@ -20205,7 +20747,8 @@ function transformMacroImpl(code, id, moduleAliases, warnUnloweredRegex, recover
     const add = (item) => {
       if (!isIR(item)) return false;
       if (item.trackLines === true) trackLines = true;
-      pieces.push({ ns: item.ns, rules: evalRuleMapIR(item.ir) });
+      const map = evalRulesIR(item.ir);
+      pieces.push({ ns: item.ns, rules: Object.entries(map), recipes: map[RULES_RECIPE] });
       return true;
     };
     for (const item of items) {
@@ -20232,10 +20775,20 @@ function transformMacroImpl(code, id, moduleAliases, warnUnloweredRegex, recover
     }
     return [...winners];
   };
-  const mergedCarriedRules = (items) => {
+  const mergedCarriedRules = (items, link) => {
     const carriedMaps = carriedRuleMaps(items);
     if (carriedMaps === null) return null;
-    return { rules: mergeRuleMaps(carriedMaps.pieces.map((p) => p.rules)), trackLines: carriedMaps.trackLines };
+    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 applyComposingTrivia = (ruleMap, composing) => {
     for (const [, rule] of ruleMap) {
@@ -20275,9 +20828,7 @@ function transformMacroImpl(code, id, moduleAliases, warnUnloweredRegex, recover
     const a0 = rulesArgs[0];
     const a1 = rulesArgs[1];
     const optExpr = a0?.type === "ObjectExpression" ? a0 : a1?.type === "ObjectExpression" ? a1 : void 0;
-    const triviaValue = optionProp(optExpr, "trivia");
-    if (!triviaValue) return void 0;
-    return evaluateExpr(triviaValue, scope, code, []) ?? void 0;
+    return triviaOption(optExpr, "compose() element");
   };
   const composingTrivia = (elements) => {
     for (let i = elements.length - 1; i >= 0; i--) {
@@ -20304,6 +20855,8 @@ function transformMacroImpl(code, id, moduleAliases, warnUnloweredRegex, recover
     }
     const elements = arr.elements;
     const cOptions = init.arguments[1];
+    if (cOptions !== void 0 && cOptions.type !== "ObjectExpression") unevaluable(cOptions.start, "compose() options");
+    assertPlainOptions(cOptions, "compose()");
     const cHostModeValue = optionProp(cOptions, "hostMode");
     const cHostMode = cHostModeValue?.type === "Literal" ? cHostModeValue.value : void 0;
     if (cHostModeValue !== void 0 && cHostMode !== "ast" && cHostMode !== "cst") {
@@ -20316,15 +20869,25 @@ function transformMacroImpl(code, id, moduleAliases, warnUnloweredRegex, recover
     for (let i = 0; i < elements.length; i++) {
       const r = argPieces(elements[i], `compose${init.start}_${i}`, composing);
       if (!r) {
+        const el = elements[i];
+        const name = el.type === "Identifier" ? el.name : void 0;
+        const why = name === void 0 ? void 0 : unresolvedCompiled.get(name);
+        if (why !== void 0) {
+          throw new Error(
+            `${id}:${lineOf(init.start)} \u2014 compose(): argument ${i} (\`${name}\` from '${importBindings.get(name)?.source}') is a build-compiled grammar whose carried pieces could not be resolved: ${why}. A runtime compose() cannot link a build-compiled grammar, so this would throw at import. The usual cause is a bundler rewriting the upstream module (inlining or renaming an ancestor grammar it composes, or reprinting its carried-pieces literal); keep upstream grammar packages external to the bundle.`
+          );
+        }
         warn(init.start, `compose(): argument ${i} isn't a build-resolvable grammar; falling back to runtime`);
         return null;
       }
       carried.push(...r.carried);
       importedFactories.push(...r.importedFactories ?? []);
     }
-    const merged = mergedCarriedRules(carried);
+    const merged = mergedCarriedRules(carried, {
+      trivia: composing,
+      ...cHostMode ? { hostMode: cHostMode } : {}
+    });
     if (merged !== null) {
-      if (composing) applyComposingTrivia(merged.rules, composing);
       collectBuilderImports(merged.rules);
       const refusals = [];
       const compiled = compileRuleMap(merged.rules, {
@@ -20519,11 +21082,7 @@ function transformMacroImpl(code, id, moduleAliases, warnUnloweredRegex, recover
       if (d.id.type === "Identifier") {
         const varName = d.id.name;
         if (!referencesAny(init, allNames, scope)) {
-          const staticValue = evaluateStaticValue(init, scope, code);
-          if (staticValue !== null && staticValue !== void 0 || isStaticNullishExpression(init)) {
-            ;
-            scope.set(varName, staticValue);
-          }
+          deferredLocals.set(varName, init);
           continue;
         }
         if (refNames.has(varName)) {
@@ -20610,6 +21169,7 @@ function transformMacroImpl(code, id, moduleAliases, warnUnloweredRegex, recover
           continue;
         }
         const mapFnSources = [];
+        unresolvedImports.clear();
         const parser2 = evaluateExpr(init, scope, code, mapFnSources);
         if (parser2 === null) {
           const wordFactory = evaluateWordFactory(init, scope, code);
@@ -20642,6 +21202,7 @@ function transformMacroImpl(code, id, moduleAliases, warnUnloweredRegex, recover
             if (exportPrefix) exportedFactories.push({ name: varName, pos: init.start });
             continue;
           }
+          if (unresolvedImports.size > 0) unevaluable(init.start, `"${varName}"`);
           warn(init.start, `"${varName}" references a parseman macro import but isn't a statically-evaluable combinator`);
           continue;
         }
@@ -20654,7 +21215,8 @@ function transformMacroImpl(code, id, moduleAliases, warnUnloweredRegex, recover
         replacements.push({
           start: init.start,
           end: init.end,
-          replacement: compiled.inlineExpression
+          replacement: compiled.inlineExpression,
+          carry: { name: varName, combi: parser2, exported: exportPrefix !== "" }
         });
         scope.set(varName, { combi: parser2, mfSrcs: mapFnSources });
       } else if (d.id.type === "ObjectPattern") {
@@ -20721,37 +21283,58 @@ ${which}
   Drop the \`export\`. The factory is macro-only; \`rules(${exportedFactories[0].name})\` is lowered in place and needs no runtime value.`
     );
   }
+  const withCombinatorIR = (r) => {
+    if (!r.carry || !r.carry.exported && !referencedNames().live.has(r.carry.name)) return r;
+    let ir = null;
+    try {
+      ir = serializeCombinator(r.carry.combi);
+    } catch {
+    }
+    return ir === null ? r : {
+      ...r,
+      replacement: `/* @__PURE__ */ Object.defineProperty(${r.replacement}, Symbol.for('${COMBINATOR_IR_KEY}'), { value: ${JSON.stringify(ir)}, enumerable: false })`
+    };
+  };
   const ms = new MagicString(code);
   const replacementRanges = runtimeComposeFallback ? [] : replacements.map(({ start, end }) => ({ start, end }));
   const isInsideReplacement = (start, end) => replacementRanges.some((r) => start >= r.start && end <= r.end);
-  const importedBindingStillReferenced = (local) => {
-    const walk = (node2, parent, parentKey) => {
-      if (!node2 || typeof node2 !== "object") return false;
+  let referenced = null;
+  const referencedNames = () => {
+    if (referenced !== null) return referenced;
+    const all = /* @__PURE__ */ new Set();
+    const live = /* @__PURE__ */ new Set();
+    const deadRanges = [...[...factoryDecls.values()].filter((f) => !f.imported).map((f) => f.fn), ...anyUnresolved ? [] : defineRemovals];
+    const walk = (node2, inFactory, parent, parentKey) => {
+      if (!node2 || typeof node2 !== "object") return;
       const rec = node2;
-      if (rec.type === "ImportDeclaration") return false;
-      if (typeof rec.start === "number" && typeof rec.end === "number" && isInsideReplacement(rec.start, rec.end)) return false;
-      if ((rec.type === "Identifier" || rec.type === "BindingIdentifier") && rec.name === local) {
-        if (parentKey === "key" && (parent?.type === "ObjectProperty" || parent?.type === "Property" || parent?.type === "PropertyDefinition") && parent.computed !== true) return false;
-        if (parentKey === "property" && parent?.type === "StaticMemberExpression") return false;
-        if (parentKey === "property" && parent?.type === "MemberExpression" && parent.computed !== true) return false;
-        return true;
+      if (rec.type === "ImportDeclaration") return;
+      if (typeof rec.start === "number" && typeof rec.end === "number") {
+        if (isInsideReplacement(rec.start, rec.end)) return;
+        inFactory ||= deadRanges.some((f) => rec.start >= f.start && rec.end <= f.end);
+      }
+      if (rec.type === "Identifier" || rec.type === "BindingIdentifier") {
+        const isKey = parentKey === "key" && (parent?.type === "ObjectProperty" || parent?.type === "Property" || parent?.type === "PropertyDefinition") && parent.computed !== true;
+        const isMember = parentKey === "property" && (parent?.type === "StaticMemberExpression" || parent?.type === "MemberExpression" && parent.computed !== true);
+        const isDeclared = parentKey === "id" && parent?.type === "VariableDeclarator";
+        if (!isKey && !isMember && !isDeclared) {
+          all.add(rec.name);
+          if (!inFactory) live.add(rec.name);
+        }
+        return;
       }
       for (const key of Object.keys(rec)) {
         if (key === "type" || key === "start" || key === "end") continue;
         const value = rec[key];
-        if (Array.isArray(value)) {
-          if (value.some((child) => walk(child, rec, key))) return true;
-        } else if (walk(value, rec, key)) {
-          return true;
-        }
+        if (Array.isArray(value)) for (const child of value) walk(child, inFactory, rec, key);
+        else walk(value, inFactory, rec, key);
       }
-      return false;
     };
-    return body.some((stmt) => walk(stmt));
+    for (const stmt of body) walk(stmt, false);
+    return referenced = { all, live };
   };
   for (const imp of ordinaryImports) {
     if (!runtimeComposeFallback && imp.specifiers.length > 0 && imp.specifiers.every(
-      (spec) => spec.type === "ImportSpecifier" && usedImportedFactories.has(spec.local) && !importedBindingStillReferenced(spec.local)
+      (spec) => spec.type === "ImportSpecifier" && usedImportedFactories.has(spec.local) && !referencedNames().all.has(spec.local)
     )) {
       ms.remove(imp.start, imp.end);
     }
@@ -20768,7 +21351,7 @@ ${which}
       ms.overwrite(imp.start, imp.end, stripped);
     }
   }
-  const applied = runtimeComposeFallback ? [] : replacements;
+  const applied = runtimeComposeFallback ? [] : replacements.map((r) => withCombinatorIR(r));
   for (const { start, end, replacement } of applied.slice().sort((a, b) => b.start - a.start)) {
     ms.overwrite(start, end, replacement);
   }