parseman 0.52.0 → 0.54.0

package/dist/plugin/index.js

@@ -367,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;
@@ -382,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;
       }
     },
@@ -1268,65 +1269,17 @@ function plainRegexSource(p) {
   const d = p._def;
   return d.tag === "regex" && d.flags === "" ? d.source : null;
 }
-var visitSpec0;
-var visitSpec1;
-var visitSpec2;
-var visitSpec3;
-var visitValue0;
-var visitValue1;
-var visitValue2;
-var visitValue3;
 function commonLabeledTriviaVisitor(spec) {
-  if (spec === visitSpec0) return visitValue0;
-  if (spec === visitSpec1) return visitValue1;
-  if (spec === visitSpec2) return visitValue2;
-  if (spec === visitSpec3) return visitValue3;
-  const sources = spec.minRepeats <= 1 ? spec.arms.map((arm) => plainRegexSource(arm.parser)) : [];
-  const visitor = commonCssTriviaVisitor(sources);
-  visitSpec3 = visitSpec2;
-  visitValue3 = visitValue2;
-  visitSpec2 = visitSpec1;
-  visitValue2 = visitValue1;
-  visitSpec1 = visitSpec0;
-  visitValue1 = visitValue0;
-  visitSpec0 = spec;
-  visitValue0 = visitor;
-  return visitor;
-}
-var armSpec0;
-var armSpec1;
-var armSpec2;
-var armSpec3;
-var armValue0;
-var armValue1;
-var armValue2;
-var armValue3;
+  return commonCssTriviaVisitor(spec.minRepeats <= 1 ? spec.arms.map((arm) => plainRegexSource(arm.parser)) : []);
+}
 function charArmsFor(spec) {
-  if (spec === armSpec0) return armValue0;
-  if (spec === armSpec1) return armValue1;
-  if (spec === armSpec2) return armValue2;
-  if (spec === armSpec3) return armValue3;
-  let arms = [];
-  if (spec.minRepeats > 1) {
-    arms = null;
-  } else {
-    for (const arm of spec.arms) {
-      const c = classifyParser(arm.parser);
-      if (!c) {
-        arms = null;
-        break;
-      }
-      arms.push(c);
-    }
+  if (spec.minRepeats > 1) return null;
+  const arms = [];
+  for (const arm of spec.arms) {
+    const c = classifyParser(arm.parser);
+    if (!c) return null;
+    arms.push(c);
   }
-  armSpec3 = armSpec2;
-  armValue3 = armValue2;
-  armSpec2 = armSpec1;
-  armValue2 = armValue1;
-  armSpec1 = armSpec0;
-  armValue1 = armValue0;
-  armSpec0 = spec;
-  armValue0 = arms;
   return arms;
 }
 function charTriviaEnd(input, cur, arms) {
@@ -1442,12 +1395,16 @@ function analyzeLabeledTrivia(trivia2) {
     }
     arms.push({ label: peeled.label, kindIndex: 0, parser: peeled.parser });
   }
-  const spec = {
+  return cacheLabeledTrivia(trivia2, labeledTriviaSpec(arms, minRepeats));
+}
+function labeledTriviaSpec(arms, minRepeats) {
+  return {
     labels: arms.map((a) => a.label),
     arms,
-    minRepeats
+    minRepeats,
+    visitor: commonLabeledTriviaVisitor({ arms, minRepeats }),
+    charArms: charArmsFor({ arms, minRepeats })
   };
-  return cacheLabeledTrivia(trivia2, spec);
 }
 function matchArmAt(input, pos, arm, state) {
   if (!startsFirstSet(arm, input, pos)) return null;
@@ -1477,7 +1434,7 @@ function scanLabeledTriviaChunks(input, cur, spec, state) {
   return { end: pos, chunks };
 }
 function scanLabeledTriviaEnd(input, cur, spec, state) {
-  const chars = charArmsFor(spec);
+  const chars = spec.charArms;
   if (chars !== null) return charTriviaEnd(input, cur, chars);
   let pos = cur;
   let count = 0;
@@ -1495,9 +1452,9 @@ function scanLabeledTriviaEnd(input, cur, spec, state) {
 }
 function visitLabeledTrivia(input, cur, spec, state, visit) {
   if (spec.minRepeats > 1) return void 0;
-  const common = commonLabeledTriviaVisitor(spec);
+  const common = spec.visitor;
   if (common !== null) return common(input, cur, visit);
-  const chars = charArmsFor(spec);
+  const chars = spec.charArms;
   if (chars !== null) return charTriviaVisit(input, cur, chars, visit);
   let pos = cur;
   let count = 0;
@@ -1564,7 +1521,7 @@ function resolveAdjacencyKindMask(trivia2, kinds) {
   return mask;
 }
 function triviaKindMaskAt(input, pos, spec, state) {
-  const chars = charArmsFor(spec);
+  const chars = spec.charArms;
   if (chars !== null) return charTriviaKindMask(input, pos, chars);
   let cur = pos;
   let mask = 0;
@@ -1810,6 +1767,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 {
@@ -1819,7 +1777,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 })) };
 }
@@ -1850,9 +1808,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) {
@@ -1866,10 +1841,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`);
     }
@@ -1878,7 +1861,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);
@@ -1890,48 +1874,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;
 }
 
@@ -3265,6 +3235,23 @@ function notAdjacent(options) {
   );
 }
 
+// src/combinators/field-trivia.ts
+var LEAD = { at: -1 };
+var FIELD_LEADING_TRIVIA = 1;
+var FIELD_TRAILING_TRIVIA = 2;
+function triviaFieldCapture(name, value, input, start, end, leadFrom, trailEnd) {
+  return {
+    name,
+    value,
+    span: { start, end },
+    leading: leadFrom >= 0 && leadFrom < start ? input.slice(leadFrom, start) : "",
+    trailing: trailEnd > end ? input.slice(end, trailEnd) : ""
+  };
+}
+function leadsTrivia(p) {
+  return p._def.tag === "field" && p._def.leadingTrivia === true;
+}
+
 // src/combinators/sequence.ts
 function sequence(...parsers) {
   let adjacency = null;
@@ -3280,6 +3267,10 @@ function sequence(...parsers) {
     (adjacency ??= Array.from({ length: parsers.length }, () => null))[i] = a;
   }
   const hasAdjacency = adjacency !== null;
+  let leading = null;
+  for (let i = 1; i < parsers.length; i++) {
+    if (leadsTrivia(parsers[i])) (leading ??= Array.from({ length: parsers.length }, () => false))[i] = true;
+  }
   const strictArity = !hasAdjacency && (parsers.length === 2 && !matchesEmpty(parsers[1]) || parsers.length === 3 && parsers.every((p) => !matchesEmpty(p))) ? parsers.length : 0;
   const meta = {
     // Union through the nullable prefix — a leading optional()/many() lets a later
@@ -3327,7 +3318,7 @@ function sequence(...parsers) {
     _tag: "sequence",
     _meta: meta,
     _def: def,
-    _parseScalar: hasAdjacency ? void 0 : parseScalar,
+    _parseScalar: hasAdjacency || leading !== null ? void 0 : parseScalar,
     parse(input, pos, ctx) {
       const tolerant = ctx._tolerant === true;
       if (tolerant) {
@@ -3361,6 +3352,7 @@ function sequence(...parsers) {
           const scanTlog = deferredTrivia ? cstTlLen(ctx) : 0;
           const scanLog = deferredTrivia ? ctx._triviaLog?.length ?? 0 : 0;
           const scanRootLog = deferredTrivia ? ctx._rootTriviaLog?.length ?? 0 : 0;
+          if (leading?.[i] === true) LEAD.at = cur;
           const result = parsers[i].parse(input, termPos, ctx);
           if (!result.ok) return result;
           if (values !== void 0) values.push(result.value);
@@ -4336,6 +4328,7 @@ function unwrapSeparator(separator) {
 }
 function sepBy(combinator, separatorArg, opts = {}) {
   const { sep: separator, keep: keepSeparators } = unwrapSeparator(separatorArg);
+  const separatorLeads = leadsTrivia(separator);
   const { min, max } = resolveBounds("sepBy()", opts);
   const trailing = opts.trailing ?? "forbid";
   const meta = {
@@ -4400,7 +4393,7 @@ function sepBy(combinator, separatorArg, opts = {}) {
       // this option surface already; parity is held by test/parity, not by hope.
       ...keepSeparators ? { keepSeparators: true } : {}
     },
-    _parseScalar: keepSeparators ? void 0 : parseScalar,
+    _parseScalar: keepSeparators || separatorLeads ? void 0 : parseScalar,
     parse(input, pos, ctx) {
       const first = combinator.parse(input, pos, ctx);
       const values = [];
@@ -4432,6 +4425,7 @@ function sepBy(combinator, separatorArg, opts = {}) {
             sepPos = advanceTrivia(input, cur, ctx);
           }
         }
+        if (separatorLeads) LEAD.at = cur;
         const sep2 = separator.parse(input, sepPos, ctx);
         if (!sep2.ok) {
           rollbackTrivia(ctx, loopMark);
@@ -4889,7 +4883,7 @@ function buildFieldMap(captures) {
   if (!captures?.length) return void 0;
   const out = {};
   for (const cap of captures) {
-    const entry = { value: cap.value, span: cap.span };
+    const entry = cap.leading === void 0 ? { value: cap.value, span: cap.span } : { value: cap.value, span: cap.span, leading: cap.leading, trailing: cap.trailing };
     const current = out[cap.name];
     if (current === void 0) out[cap.name] = entry;
     else if (Array.isArray(current)) current.push(entry);
@@ -5121,16 +5115,41 @@ function label(name, combinator) {
     }
   };
 }
-function field(name, combinator) {
+function field(name, combinator, opts) {
+  const leadingTrivia = opts?.leadingTrivia === true;
+  const trailingTrivia = opts?.trailingTrivia === true;
+  if (!leadingTrivia && !trailingTrivia) {
+    return {
+      _tag: combinator._tag,
+      _meta: combinator._meta,
+      _def: { tag: "field", name, parser: combinator },
+      parse(input, pos, ctx) {
+        const result = combinator.parse(input, pos, ctx);
+        if (!result.ok) return result;
+        ctx._fields?.push({ name, value: result.value, span: result.span });
+        return result;
+      }
+    };
+  }
   return {
     _tag: combinator._tag,
     _meta: combinator._meta,
-    _def: { tag: "field", name, parser: combinator },
+    _def: {
+      tag: "field",
+      name,
+      parser: combinator,
+      ...leadingTrivia ? { leadingTrivia: true } : {},
+      ...trailingTrivia ? { trailingTrivia: true } : {}
+    },
     parse(input, pos, ctx) {
+      const leadFrom = LEAD.at;
+      LEAD.at = -1;
       const result = combinator.parse(input, pos, ctx);
       if (!result.ok) return result;
-      ctx._fields?.push({ name, value: result.value, span: result.span });
-      return result;
+      const end = result.span.end;
+      const trailEnd = trailingTrivia && ctx.trivia ? consumeTrivia(input, end, ctx) : end;
+      ctx._fields?.push(triviaFieldCapture(name, result.value, input, result.span.start, end, leadingTrivia ? leadFrom : -1, trailEnd));
+      return trailEnd === end ? result : { ok: true, value: result.value, span: { start: result.span.start, end: trailEnd } };
     }
   };
 }
@@ -7192,6 +7211,16 @@ var Encoder = class {
     this.kIndex.set(key, i);
     return i;
   }
+  fieldSpecIndex = /* @__PURE__ */ new Map();
+  fieldSpecSlot(name, bits) {
+    const key = JSON.stringify([name, bits]);
+    const hit = this.fieldSpecIndex.get(key);
+    if (hit !== void 0) return hit;
+    const i = this.k.length;
+    this.k.push([name, bits]);
+    this.fieldSpecIndex.set(key, i);
+    return i;
+  }
   /**
    * A `notAdjacent({ kinds })` filter, pooled by its CONTENTS.
    *
@@ -7812,8 +7841,10 @@ var Encoder = class {
         for (let i = 0; i < arms.length; i++) this.code[head + 6 + i] = arms[i];
         return head;
       }
-      case "field":
-        return this.emit(OP_FIELD, this.constant(d.name), this.node(d.parser).ip);
+      case "field": {
+        const bits = (d.leadingTrivia === true ? FIELD_LEADING_TRIVIA : 0) | (d.trailingTrivia === true ? FIELD_TRAILING_TRIVIA : 0);
+        return this.emit(OP_FIELD, bits === 0 ? this.constant(d.name) : this.fieldSpecSlot(d.name, bits), this.node(d.parser).ip);
+      }
       case "lazy": {
         const refName = p._ruleName;
         const winner = refName === void 0 ? void 0 : this.winners?.[refName];
@@ -9486,6 +9517,26 @@ function leadingLiteralFamily(code, constants, ip, minDepth = 2, limit = 4) {
   };
   return walk(ip, 0);
 }
+function largeChoiceLiteralPretest(code, constants, armIp) {
+  const child = leadingScalarTerminal(code, armIp, 2, true, true);
+  if (child >= 0) {
+    const spec = constants[code[child + 1]];
+    if (code[child] === OP_LIT && typeof spec === "string" && spec.length >= 2) return [child];
+  }
+  const family = leadingLiteralFamily(code, constants, armIp);
+  return family !== void 0 && family.length >= 2 && family.every((terminal) => {
+    const value = constants[code[terminal + 1]];
+    return typeof value === "string" && value.length >= 2;
+  }) ? family : void 0;
+}
+
+// src/table/field-spec.ts
+function fieldSpec(slot) {
+  return Array.isArray(slot) ? { name: slot[0], bits: slot[1] } : { name: slot, bits: 0 };
+}
+function leadingTriviaFieldAt(code, k, ip) {
+  return code[ip] === OP_FIELD && (fieldSpec(k[code[ip + 1]]).bits & FIELD_LEADING_TRIVIA) !== 0;
+}
 
 // src/table/emit-assembly.ts
 var Unemittable = class extends Error {
@@ -9560,7 +9611,11 @@ var EMITTED_PARAMS = [
   // Appended for old precompiled-factory ABI: old factories ignore it.
   "adjacencyHolds",
   // Appended for selected composite lexical programs; old factories ignore it.
-  "LEXPROG"
+  "LEXPROG",
+  // Appended for trivia-attributing fields (`field(…, { leadingTrivia })`);
+  // old factories ignore them.
+  "LEAD",
+  "triviaFieldCapture"
 ];
 var RUNTIME_PRELUDE = `
 let _pfScan=null
@@ -9820,20 +9875,12 @@ function emitAssemblySource(t, prog, cfg, extraIps = [], staticBuild = false) {
           if (child >= 0) scalarSpecs.add(code[child + 1]);
           continue;
         }
-        if (child >= 0) {
-          const spec = k[code[child + 1]];
-          if (code[child] === OP_LIT && typeof spec === "string" && spec.length >= 2) {
-            largeChoiceScalarSpecs.add(code[child + 1]);
-            continue;
-          }
-        }
-        const family = leadingLiteralFamily(code, k, armIp);
-        if (family !== void 0 && family.length >= 2 && family.every((terminal) => {
-          const value = k[code[terminal + 1]];
-          return typeof value === "string" && value.length >= 2;
-        })) {
-          largeChoiceLiteralFamilies.set(armIp, family);
+        const literals = largeChoiceLiteralPretest(code, k, armIp);
+        if (literals !== void 0 && literals.length === 1 && literals[0] === child) {
+          largeChoiceScalarSpecs.add(code[child + 1]);
+          continue;
         }
+        if (literals !== void 0) largeChoiceLiteralFamilies.set(armIp, literals);
         const sequence6 = leadingScalarSequence(code, armIp);
         if (sequence6 !== void 0 && (sequence6.trivia < 0 || swapLegal && t.triviaScan[sequence6.trivia] != null)) {
           largeChoiceScalarSequences.set(armIp, sequence6);
@@ -10257,14 +10304,31 @@ return v
 }`;
       }
       case OP_FIELD: {
-        const name = q(k[code[ip + 1]]);
+        const spec = fieldSpec(k[code[ip + 1]]);
+        const name = q(spec.name);
         const child = link(code[ip + 2]);
-        return `${head}
+        if (spec.bits === 0) {
+          return `${head}
 const v=${child}(input,pos,ctx)
 if(v===FAIL)return FAIL
 const f=ctx._fields
 if(f!==undefined)f.push({name:${name},value:v,span:{start:pos,end:EC.e}})
 return v
+}`;
+        }
+        const leading = (spec.bits & FIELD_LEADING_TRIVIA) !== 0;
+        const trailing = (spec.bits & FIELD_TRAILING_TRIVIA) !== 0;
+        return `${head}
+const lf=${leading ? "LEAD.at" : "-1"}
+LEAD.at=-1
+const v=${child}(input,pos,ctx)
+if(v===FAIL)return FAIL
+const e=EC.e
+const te=${trailing ? "ctx.trivia!==undefined?consumeTrivia(input,e,ctx):e" : "e"}
+const f=ctx._fields
+if(f!==undefined)f.push(triviaFieldCapture(${name},v,input,pos,e,lf,te))
+EC.e=te
+return v
 }`;
       }
       case OP_EXPECT: {
@@ -10560,7 +10624,10 @@ return v
               `if(!adjacencyHolds(input,cur,ctx,${negated ? "true" : "false"},${kinds})){ctx._fe=cur;ctx._fx=${expected};return FAIL}`,
               `${vn}=null`
             );
-          } else parts.push(emitTerm(kids[i], vn, tmp(), L, skipFor(L)));
+          } else {
+            const callee = leadingTriviaFieldAt(code, k, childIp) ? `(LEAD.at=cur,${kids[i]})` : kids[i];
+            parts.push(emitTerm(callee, vn, tmp(), L, skipFor(L)));
+          }
           names.push(vn);
         }
         parts.push("EC.e=cur");
@@ -10960,7 +11027,7 @@ let sp=cur
 ${hasTrivia === "false" ? "" : hasTrivia === "true" ? `sp=${skip}(input,sp,ctx)
 ` : `if(hasTrivia)sp=${skip}(input,sp,ctx)
 `}ctx._fc=false
-const sv=${sep2}(input,sp,ctx)
+${sepIp >= 0 && leadingTriviaFieldAt(code, k, sepIp) ? "LEAD.at=cur\n" : ""}const sv=${sep2}(input,sp,ctx)
 if(sv===FAIL){
 ${rb}
 if(ctx._fc===true)return FAIL
@@ -12057,6 +12124,12 @@ function assemble(t, prog, cfg) {
     rollbackScannedTriviaAt(ctx, mTl, scanTl, mLog, scanLog, mRoot, scanRoot);
     return cur;
   }
+  function leadingFieldTerm(step, child, input, cur, ctx) {
+    return step((i, p, c) => {
+      LEAD.at = cur;
+      return child(i, p, c);
+    }, input, cur, ctx);
+  }
   function committed3(c) {
     return c._fc === true;
   }
@@ -12694,12 +12767,27 @@ function assemble(t, prog, cfg) {
         };
       }
       case OP_FIELD: {
-        const name = k[code[ip + 1]];
+        const { name, bits } = fieldSpec(k[code[ip + 1]]);
         const child = link(code[ip + 2]);
+        if (bits === 0) {
+          return (input, pos, ctx) => {
+            const v = child(input, pos, ctx);
+            if (v === FAIL) return FAIL;
+            ctx._fields?.push({ name, value: v, span: { start: pos, end: EC.e } });
+            return v;
+          };
+        }
+        const leading = (bits & FIELD_LEADING_TRIVIA) !== 0;
+        const trailing = (bits & FIELD_TRAILING_TRIVIA) !== 0;
         return (input, pos, ctx) => {
+          const leadFrom = leading ? LEAD.at : -1;
+          LEAD.at = -1;
           const v = child(input, pos, ctx);
           if (v === FAIL) return FAIL;
-          ctx._fields?.push({ name, value: v, span: { start: pos, end: EC.e } });
+          const end = EC.e;
+          const trailEnd = trailing && ctx.trivia !== void 0 ? consumeTrivia(input, end, ctx) : end;
+          ctx._fields?.push(triviaFieldCapture(name, v, input, pos, end, leadFrom, trailEnd));
+          EC.e = trailEnd;
           return v;
         };
       }
@@ -13133,6 +13221,12 @@ function assemble(t, prog, cfg) {
             const kidIp = code[base + i];
             if (code[kidIp] !== OP_ADJ) {
               const kid = link(kidIp);
+              if (leadingTriviaFieldAt(code, k, kidIp)) {
+                return (input, cur, ctx, inherited) => {
+                  ctx._sync = sync ?? inherited;
+                  return leadingFieldTerm(step, kid, input, cur, ctx);
+                };
+              }
               return (input, cur, ctx, inherited) => {
                 ctx._sync = sync ?? inherited;
                 return step(kid, input, cur, ctx);
@@ -13210,9 +13304,12 @@ function assemble(t, prog, cfg) {
           };
         }
         let hasAdj = false;
-        for (let i = 1; i < n; i++) if (code[code[base + i]] === OP_ADJ) {
-          hasAdj = true;
-          break;
+        for (let i = 1; i < n; i++) {
+          const kidIp = code[base + i];
+          if (code[kidIp] === OP_ADJ || leadingTriviaFieldAt(code, k, kidIp)) {
+            hasAdj = true;
+            break;
+          }
         }
         if (hasAdj) {
           const first2 = link(code[base]);
@@ -13220,6 +13317,9 @@ function assemble(t, prog, cfg) {
             const kidIp = code[base + i];
             if (code[kidIp] !== OP_ADJ) {
               const kid = link(kidIp);
+              if (leadingTriviaFieldAt(code, k, kidIp)) {
+                return (input, cur, ctx) => leadingFieldTerm(step, kid, input, cur, ctx);
+              }
               return (input, cur, ctx) => step(kid, input, cur, ctx);
             }
             const negated = code[kidIp + 1] === 1;
@@ -13582,7 +13682,7 @@ function assemble(t, prog, cfg) {
         if (n === 2 || n === 3) {
           const a0 = link(code[base]), a1 = link(code[base + 1]);
           const a2 = n === 3 ? link(code[base + 2]) : void 0;
-          const predecide = !hostCst && !REC && !cfg.probe && !cfg.coverage && !cfg.trackLines;
+          const predecide = !REC && !cfg.probe && !cfg.coverage && !cfg.trackLines;
           const p0ip = predecide ? leadingScalarTerminal(code, code[base], 2, true, true) : -1;
           const p1ip = predecide ? leadingScalarTerminal(code, code[base + 1], 2, true, true) : -1;
           const p2ip = predecide && n === 3 ? leadingScalarTerminal(code, code[base + 2], 2, true, true) : -1;
@@ -13805,6 +13905,75 @@ function assemble(t, prog, cfg) {
             );
           };
           const masked = bindMasked(0, EMPTY_EXPECTED_PREFIX);
+          const pBit = [];
+          const pRec = [];
+          if (!REC && !cfg.probe && !cfg.coverage && !cfg.trackLines) {
+            for (let i = 0; i < n; i++) {
+              for (const terminal of largeChoiceLiteralPretest(code, k, code[base + i]) ?? []) {
+                pBit.push(1 << i);
+                pRec.push(scalarFor(terminal));
+              }
+            }
+          }
+          const pn = pBit.length;
+          if (pn !== 0) {
+            return (input, pos, ctx) => {
+              const c = lead(input, pos);
+              const need = markCst(ctx);
+              const mRaw = MRAW;
+              const mTl = MTL;
+              const mLv = MLV;
+              const mFl = need ? ctx._fields?.length ?? 0 : 0;
+              const mEr = need ? ctx._errors?.length ?? 0 : 0;
+              const mLog = need ? ctx._triviaLog?.length ?? 0 : 0;
+              const mRoot = need ? ctx._rootTriviaLog?.length ?? 0 : 0;
+              if (c < 128) {
+                const bits = mask[c < 0 ? 128 : c];
+                let tested = 0;
+                let hit = 0;
+                for (let i = 0; i < pn; i++) {
+                  const b = pBit[i];
+                  if ((bits & b) === 0 || (hit & b) !== 0) continue;
+                  tested |= b;
+                  if (pRec[i](input, pos) >= 0) hit |= b;
+                }
+                return masked(
+                  input,
+                  pos,
+                  ctx,
+                  bits & (~tested | hit),
+                  need,
+                  mRaw,
+                  mTl,
+                  mLv,
+                  mFl,
+                  mEr,
+                  mLog,
+                  mRoot,
+                  void 0,
+                  0,
+                  pos
+                );
+              }
+              return general(
+                input,
+                pos,
+                ctx,
+                c,
+                need,
+                mRaw,
+                mTl,
+                mLv,
+                mFl,
+                mEr,
+                mLog,
+                mRoot,
+                void 0,
+                0,
+                pos
+              );
+            };
+          }
           return (input, pos, ctx) => {
             const c = lead(input, pos);
             const need = markCst(ctx);
@@ -13966,6 +14135,7 @@ function assemble(t, prog, cfg) {
         const max = code[ip + 3];
         const sepIp = code[ip + 4];
         const sep2 = sepIp >= 0 ? link(sepIp) : void 0;
+        const sepLeads = sepIp >= 0 && leadingTriviaFieldAt(code, k, sepIp);
         const flags = code[ip + 5];
         const keepSeparators = (flags & 2) !== 0;
         const trailingAllowed = (flags & 1) !== 0;
@@ -14005,6 +14175,7 @@ function assemble(t, prog, cfg) {
                 let sp = cur;
                 if (hasTrivia) sp = skipTrivia(input, sp, ctx);
                 ctx._fc = false;
+                if (sepLeads) LEAD.at = cur;
                 const sv = sep2(input, sp, ctx);
                 if (sv === FAIL) {
                   if (needMark) rollbackTriviaAt(ctx, mRaw, mTl, mLv, mFl, mEr, mLog, mRoot);
@@ -14094,6 +14265,7 @@ function assemble(t, prog, cfg) {
               let sp = cur;
               if (hasTrivia) sp = skipTrivia(input, sp, ctx);
               ctx._fc = false;
+              if (sepLeads) LEAD.at = cur;
               const sv = sep2(input, sp, ctx);
               if (sv === FAIL) {
                 if (needMark) rollbackTriviaAt(ctx, mRaw, mTl, mLv, mFl, mEr, mLog, mRoot);
@@ -14416,20 +14588,9 @@ function assemble(t, prog, cfg) {
               if (child >= 0) scalarFor(child);
               continue;
             }
-            if (child >= 0) {
-              const spec = k[code[child + 1]];
-              if (code[child] === OP_LIT && typeof spec === "string" && spec.length >= 2) {
-                scalarFor(child);
-                continue;
-              }
-            }
-            const family = leadingLiteralFamily(code, k, armIp);
-            if (family !== void 0 && family.length >= 2 && family.every((terminal) => {
-              const value = k[code[terminal + 1]];
-              return typeof value === "string" && value.length >= 2;
-            })) {
-              for (const terminal of family) scalarFor(terminal);
-            }
+            const literals = largeChoiceLiteralPretest(code, k, armIp);
+            if (literals !== void 0) for (const terminal of literals) scalarFor(terminal);
+            if (literals !== void 0 && literals.length === 1 && literals[0] === child) continue;
             const sequence6 = leadingScalarSequence(code, armIp);
             if (sequence6 !== void 0 && (sequence6.trivia < 0 || triviaScan[sequence6.trivia] != null)) {
               for (const terminal of sequence6.terminals) scalarFor(terminal);
@@ -14495,7 +14656,9 @@ function assemble(t, prog, cfg) {
         scanTriviaCompact,
         t.lex,
         adjacencyHolds,
-        t.lexPrograms
+        t.lexPrograms,
+        LEAD,
+        triviaFieldCapture
       );
       emitReached = new Set(pre.reached);
     }
@@ -14577,7 +14740,9 @@ function assemble(t, prog, cfg) {
         scanTriviaCompact,
         t.lex,
         adjacencyHolds,
-        t.lexPrograms
+        t.lexPrograms,
+        LEAD,
+        triviaFieldCapture
       );
       emitReached = em.reached;
     } catch (e) {
@@ -14753,7 +14918,9 @@ var AssemblyCache = class {
     return made;
   }
 };
-function tableRules(source, artifactMetadata = {}) {
+function tableRules(source, metadataOrEntry = {}) {
+  const entry = typeof metadataOrEntry === "string" ? metadataOrEntry : void 0;
+  const artifactMetadata = typeof metadataOrEntry === "string" ? {} : metadataOrEntry;
   const prog = expandCompact(source);
   const resolved = resolveTable(prog);
   const cache = new AssemblyCache(prog, resolved);
@@ -14761,7 +14928,7 @@ function tableRules(source, artifactMetadata = {}) {
   const skipOf = prog.scanSkipOf;
   let last;
   let selected;
-  return stampRuleMap(prog, {
+  const map = stampRuleMap(prog, {
     runRule: (ri, input, pos, ctx) => {
       const a = selected ?? cache.forCtx(ctx);
       selected = void 0;
@@ -14782,6 +14949,9 @@ function tableRules(source, artifactMetadata = {}) {
       return a.scanSkip[skipOf?.[ri] ?? -1];
     }
   }, artifactMetadata, resolved);
+  if (entry === void 0) return map;
+  if (!Object.hasOwn(map, entry)) throw new Error(`tableRules: the program has no rule ${JSON.stringify(entry)}`);
+  return map[entry];
 }
 
 // src/table/emit.ts
@@ -14947,11 +15117,15 @@ function emitTableExpression(prog, opts = {}) {
   const entry = opts.entry === void 0 ? "grammar" : opts.entry;
   const ref2 = opts.runtimeRef ?? "tableRules";
   const fns = opts.fnSources ?? prog.fns.map(() => "() => {}");
-  const close = `}${opts.metadataSource === void 0 ? "" : `,${opts.metadataSource}`})`;
+  const meta = opts.metadataSource;
+  if (entry !== null && meta !== void 0) {
+    throw new Error("emitTableExpression: metadataSource is for the rule-map form (entry: null); a single entry carries none");
+  }
+  const tail = entry !== null ? `,${jsString(entry)}` : meta === void 0 ? "" : `,${meta}`;
   return [
     `/* @__PURE__ */ ${ref2}({`,
     ...programFields(prog, fns, opts),
-    entry === null ? close : `${close}[${jsString(entry)}]`
+    `}${tail})`
   ].join("\n");
 }
 
@@ -15020,7 +15194,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 [];
@@ -15045,16 +15220,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);
@@ -15075,7 +15273,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 };
 }
@@ -15099,7 +15303,7 @@ function payloadKey(p, d) {
     case "label":
       return `label\0${d.label}`;
     case "field":
-      return `field\0${d.name}`;
+      return `field\0${d.name}\0${d.leadingTrivia === true}\0${d.trailingTrivia === true}`;
     case "node":
       return `node\0${d.type ?? ""}\0${d.unwrap === true}\0${d.collapse === true}\0${fnKey(d.buildSrc, d.build)}`;
     case "transform":
@@ -16381,105 +16585,299 @@ function runDuplicationDiagnosticRules(ruleMap, opt) {
   return reportDuplication(opt, (o) => analyzeDuplicationRules(ruleMap, o));
 }
 
-// src/table/compile.ts
-var ENTRY = "Entry";
-function ownSource(fn) {
-  if (typeof fn !== "function") return null;
-  const text = Function.prototype.toString.call(fn);
-  if (!text.includes("[native code]")) return text;
-  const name = fn.name;
-  return typeof name === "string" && name.length > 0 && globalThis[name] === fn ? name : null;
+// 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 compile(combinator, mapFnSources, opts = {}) {
-  runDuplicationDiagnostic(combinator, opts.duplication);
-  const drain = beginCompileDegradationDrain();
-  let compiled = false;
-  try {
-    const out = compileImpl(combinator, mapFnSources, opts);
-    compiled = true;
-    return out;
-  } finally {
-    drain(compiled);
-  }
+function resolveTrackLines(ruleMap, explicit) {
+  return explicit === true || ruleMap.some(([, r]) => r._meta.grammarTrackLines === true);
 }
-function compileImpl(combinator, mapFnSources, opts = {}) {
-  const plan = opts.coverage === true ? buildGrammarPlan(combinator) : void 0;
-  const settings = {
-    ...opts.hostMode === void 0 ? {} : { hostMode: opts.hostMode },
-    ...opts.trackLines === void 0 ? {} : { trackLines: opts.trackLines },
-    ...plan === void 0 ? {} : { coverage: plan }
-  };
-  const { prog, fnSrcs } = encodeTableProgram({ [ENTRY]: combinator }, settings);
+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 entry = tableRules(prog)[ENTRY];
-  const offered = opts.fnSources ?? mapFnSources;
-  const supplied = offered !== void 0 && offered.length === fnSrcs.length ? offered : void 0;
-  const sources = fnSrcs.map((s, i) => s ?? supplied?.[i] ?? ownSource(prog.fns[i]));
-  const unsourced = sources.reduce((acc, s, i) => s === null ? [...acc, i] : acc, []);
-  const runtimeOnly = [
-    ...prog.runtimeOnly ?? [],
-    ...unsourced.length === 0 ? [] : [`author reducer source missing for prog.fns[${unsourced.join(", ")}] \u2014 printing would emit \`() => {}\` and the parse would return no value`]
-  ];
-  const printable = runtimeOnly.length === 0;
-  const emitOpts = { fnSources: sources };
-  const source = printable ? emitTableModule(artifact, { name: "grammar", ...emitOpts }) : "";
-  const inlineExpression = printable ? emitTableExpression(artifact, { entry: ENTRY, runtimeRef: opts.runtimeRef ?? "tableRules", ...emitOpts }) : null;
-  const runOnce = (input, pos, ctx) => entry(input, pos, ctx);
+  const reflection = collectGrammarReflection(ruleMap);
   return {
-    source,
-    inlineExpression,
-    ...printable ? {} : { runtimeOnly },
-    // The DENOMINATOR, handed back rather than scraped out of the emitted text.
-    // `plugin/index.ts` prefers a compiler-supplied `coverageDefinitions` and only
-    // falls back to regex-scanning generated hooks; a table has no hooks to scan,
-    // so this is the channel.
+    keys: ruleMap.map(([key]) => key),
+    hostMode,
+    hostBranchElided: hostMode === "ast" && ruleMap.some(([, rule]) => hasDirectBuildDef(rule)),
+    reflection,
     ...plan === void 0 ? {} : { coverageDefinitions: plan.definitions },
-    parse(input, pos = 0) {
-      return runOnce(input, pos, createParseContext());
-    },
-    parseWithContext(input, parseCtx, pos = 0) {
-      return runOnce(input, pos, parseCtx);
-    },
-    /**
-     * NO LONGER REFUSES. It used to throw unless the caller passed
-     * `{ recovery: true }`, because setting `_tolerant` on a table with no
-     * recovery rows would report a clean parse with an empty error list whatever
-     * the input — refusing was the right answer to that, and OPTIONAL RECOVERY
-     * was the wrong question. `compile()` requires no such flag, so the refusal
-     * was a `CompiledParser` contract break; recovery is now always lowered and
-     * there is nothing left to refuse.
-     */
-    parseWithErrors(input, pos = 0) {
-      const ctx = createParseContext();
-      const errors = [];
-      ctx._errors = errors;
-      ctx._tolerant = true;
-      const r = runOnce(input, pos, ctx);
-      return { ...r, errors };
-    }
+    // 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
   };
 }
-
-// src/combinators/withCtx.ts
-function withCtx(extra, combinator) {
-  const meta = {
-    firstSet: combinator._meta.firstSet,
-    canMatchNewline: combinator._meta.canMatchNewline,
-    isTrivia: false
+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 }
   };
-  return {
-    _tag: "withCtx",
-    _meta: meta,
-    _def: { tag: "withCtx", extra, parser: combinator },
-    parse(input, pos, ctx) {
-      const saved = ctx.state;
-      ctx.state = extra;
+  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) {
+  if (typeof fn !== "function") return null;
+  const text = Function.prototype.toString.call(fn);
+  if (!text.includes("[native code]")) return text;
+  const name = fn.name;
+  return typeof name === "string" && name.length > 0 && globalThis[name] === fn ? name : null;
+}
+function compile(target, second, third) {
+  if (!isCombinator(target)) return compileMap(target, second);
+  return compileRoot(target, second, third);
+}
+function isCombinator(x) {
+  return typeof x === "object" && x !== null && typeof x.parse === "function" && "_def" in x;
+}
+function compileMap(grammar, opts = {}) {
+  const entries = [];
+  for (const [key, value] of Object.entries(grammar)) {
+    if (!isCombinator(value)) throw new TypeError(`compile: grammar entry "${key}" is not a parser`);
+    if (value._def.tag === "lazy") {
       try {
-        return combinator.parse(input, pos, ctx);
-      } finally {
-        ctx.state = saved;
+        value._def.thunk();
+      } catch {
+        continue;
       }
     }
+    entries.push([key, value]);
+  }
+  const borrowed = borrowedRuleReference(Object.fromEntries(entries));
+  if (borrowed !== void 0) throw new Error(borrowedRuleMessage("compile", borrowed));
+  const drain = beginCompileDegradationDrain();
+  let done = false;
+  try {
+    const refusals = [];
+    const compiled = compileRuleMapRunnable(entries, {
+      ...opts.hostMode ? { hostMode: opts.hostMode } : {},
+      refusals,
+      specialise: true
+    });
+    if (compiled === null) {
+      throw new Error(`compile: this grammar could not be encoded to a table${refusals.length ? ` \u2014 ${refusals.join("; ")}` : ""}`);
+    }
+    done = true;
+    return compiled.rules;
+  } finally {
+    drain(done);
+  }
+}
+function compileRoot(combinator, mapFnSources, opts = {}) {
+  runDuplicationDiagnostic(combinator, opts.duplication);
+  const drain = beginCompileDegradationDrain();
+  let compiled = false;
+  try {
+    const out = compileImpl(combinator, mapFnSources, opts);
+    compiled = true;
+    return out;
+  } finally {
+    drain(compiled);
+  }
+}
+function compileImpl(combinator, mapFnSources, opts = {}) {
+  const plan = opts.coverage === true ? buildGrammarPlan(combinator) : void 0;
+  const settings = {
+    ...opts.hostMode === void 0 ? {} : { hostMode: opts.hostMode },
+    ...opts.trackLines === void 0 ? {} : { trackLines: opts.trackLines },
+    ...plan === void 0 ? {} : { coverage: plan }
+  };
+  const { prog, fnSrcs } = encodeTableProgram({ [ENTRY]: combinator }, settings);
+  const artifact = closureArtifact(prog);
+  const entry = tableRules(prog)[ENTRY];
+  const offered = opts.fnSources ?? mapFnSources;
+  const supplied = offered !== void 0 && offered.length === fnSrcs.length ? offered : void 0;
+  const sources = fnSrcs.map((s, i) => s ?? supplied?.[i] ?? ownSource(prog.fns[i]));
+  const unsourced = sources.reduce((acc, s, i) => s === null ? [...acc, i] : acc, []);
+  const runtimeOnly = [
+    ...prog.runtimeOnly ?? [],
+    ...unsourced.length === 0 ? [] : [`author reducer source missing for prog.fns[${unsourced.join(", ")}] \u2014 printing would emit \`() => {}\` and the parse would return no value`]
+  ];
+  const printable = runtimeOnly.length === 0;
+  const emitOpts = { fnSources: sources };
+  const source = printable ? emitTableModule(artifact, { name: "grammar", ...emitOpts }) : "";
+  const inlineExpression = printable ? emitTableExpression(artifact, { entry: ENTRY, runtimeRef: opts.runtimeRef ?? "tableRules", ...emitOpts }) : null;
+  const runOnce = (input, pos, ctx) => entry(input, pos, ctx);
+  return {
+    source,
+    inlineExpression,
+    ...printable ? {} : { runtimeOnly },
+    // The DENOMINATOR, handed back rather than scraped out of the emitted text.
+    // `plugin/index.ts` prefers a compiler-supplied `coverageDefinitions` and only
+    // falls back to regex-scanning generated hooks; a table has no hooks to scan,
+    // so this is the channel.
+    ...plan === void 0 ? {} : { coverageDefinitions: plan.definitions },
+    parse(input, pos = 0) {
+      return runOnce(input, pos, createParseContext());
+    },
+    parseWithContext(input, parseCtx, pos = 0) {
+      return runOnce(input, pos, parseCtx);
+    },
+    /**
+     * NO LONGER REFUSES. It used to throw unless the caller passed
+     * `{ recovery: true }`, because setting `_tolerant` on a table with no
+     * recovery rows would report a clean parse with an empty error list whatever
+     * the input — refusing was the right answer to that, and OPTIONAL RECOVERY
+     * was the wrong question. `compile()` requires no such flag, so the refusal
+     * was a `CompiledParser` contract break; recovery is now always lowered and
+     * there is nothing left to refuse.
+     */
+    parseWithErrors(input, pos = 0) {
+      const ctx = createParseContext();
+      const errors = [];
+      ctx._errors = errors;
+      ctx._tolerant = true;
+      const r = runOnce(input, pos, ctx);
+      return { ...r, errors };
+    }
   };
 }
 
@@ -16535,219 +16933,52 @@ var ruleNameOf3 = (c) => c._ruleName;
 var balancedOf = (c) => c._balancedAmbient;
 function lazyTarget(c) {
   if (c._def.tag !== "lazy") return null;
-  try {
-    return c._def.thunk();
-  } catch {
-    return null;
-  }
-}
-var Unserializable = class extends Error {
-};
-function repeatOpts(min, max, trailing) {
-  const parts = [];
-  if (min !== 0) parts.push(`min: ${min}`);
-  if (max !== void 0) parts.push(`max: ${max}`);
-  if (trailing !== void 0) parts.push(`trailing: ${JSON.stringify(trailing)}`);
-  return parts.length === 0 ? "" : `, { ${parts.join(", ")} }`;
-}
-function projectOpt(project) {
-  if (project === void 0) return void 0;
-  return `project: ${project}`;
-}
-function tagsOpt(tags) {
-  if (tags === void 0 || tags.length === 0) return void 0;
-  return `tags: ${JSON.stringify(tags)}`;
-}
-function matcherExpr(entry) {
-  switch (entry.kind) {
-    case "startsWith":
-      return `startsWith(${JSON.stringify(entry.value)})`;
-    case "endsWith":
-      return `endsWith(${JSON.stringify(entry.value)})`;
-    case "matches":
-      return `matches(${new RegExp(entry.value, entry.flags ?? "").toString()})`;
-  }
-}
-function serializeRuleMap(ruleMap, scanSkip) {
-  try {
-    return new Serializer(ruleMap, scanSkip ?? []).run();
-  } catch (e) {
-    if (e instanceof Unserializable) {
-      if (process.env.PARSEMAN_IR_DEBUG) console.error(`[ir] fallback: ${e.message}`);
-      return null;
-    }
-    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);
+  try {
+    return c._def.thunk();
+  } catch {
+    return null;
+  }
+}
+var Unserializable = class extends Error {
+};
+function repeatOpts(min, max, trailing) {
+  const parts = [];
+  if (min !== 0) parts.push(`min: ${min}`);
+  if (max !== void 0) parts.push(`max: ${max}`);
+  if (trailing !== void 0) parts.push(`trailing: ${JSON.stringify(trailing)}`);
+  return parts.length === 0 ? "" : `, { ${parts.join(", ")} }`;
+}
+function projectOpt(project) {
+  if (project === void 0) return void 0;
+  return `project: ${project}`;
+}
+function tagsOpt(tags) {
+  if (tags === void 0 || tags.length === 0) return void 0;
+  return `tags: ${JSON.stringify(tags)}`;
+}
+function matcherExpr(entry) {
+  switch (entry.kind) {
+    case "startsWith":
+      return `startsWith(${JSON.stringify(entry.value)})`;
+    case "endsWith":
+      return `endsWith(${JSON.stringify(entry.value)})`;
+    case "matches":
+      return `matches(${new RegExp(entry.value, entry.flags ?? "").toString()})`;
+  }
+}
+function serializeRuleMap(ruleMap, scanSkip) {
+  try {
+    return new Serializer(ruleMap, scanSkip ?? []).run();
+  } catch (e) {
+    if (e instanceof Unserializable) {
+      if (process.env.PARSEMAN_IR_DEBUG) console.error(`[ir] fallback: ${e.message}`);
+      return null;
+    }
+    throw e;
+  }
+}
+function serializeCombinator(c) {
+  return serializeRuleMap([], [c]);
 }
 var Serializer = class {
   counts = /* @__PURE__ */ new Map();
@@ -17011,7 +17242,7 @@ ${outerDecls.map((d) => "  " + d).join("\n")}
       case "label":
         return `label(${JSON.stringify(def.label)}, ${kid(def.parser)})`;
       case "field":
-        return `field(${JSON.stringify(def.name)}, ${kid(def.parser)})`;
+        return `field(${JSON.stringify(def.name)}, ${kid(def.parser)}${fieldOptionsSrc(def)})`;
       case "expect":
         return `expect(${kid(def.parser)}${def.label !== void 0 ? `, ${JSON.stringify(def.label)}` : ""})`;
       case "scanTo":
@@ -17074,128 +17305,13 @@ ${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
-  };
+function fieldOptionsSrc(def) {
+  if (def.leadingTrivia !== true && def.trailingTrivia !== true) return "";
+  return `, { ${[def.leadingTrivia === true ? "leadingTrivia: true" : "", def.trailingTrivia === true ? "trailingTrivia: true" : ""].filter(Boolean).join(", ")} }`;
 }
 
 // src/version.ts
-var PARSEMAN_VERSION = "0.52.0";
+var PARSEMAN_VERSION = "0.54.0";
 
 // src/compiler/compile-linkable-table.ts
 function isLocal(rule) {
@@ -17307,6 +17423,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([
@@ -17592,6 +17731,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";
 }
@@ -17651,7 +17825,7 @@ var SUPPORTED = {
     a[0]
   ),
   label: (...a) => label(a[0], a[1]),
-  field: (...a) => field(a[0], a[1]),
+  field: (...a) => field(a[0], a[1], a[2]),
   noTrivia: (...a) => noTrivia(a[0]),
   token: (...a) => token(a[0]),
   // `routed(fallback)` — the fallback must be forwarded. A zero-arg entry here read
@@ -17715,7 +17889,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);
@@ -17726,7 +17900,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") {
@@ -17736,24 +17910,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;
@@ -17768,7 +17942,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) {
@@ -17820,7 +17994,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)) {
@@ -17872,6 +18046,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;
@@ -17907,7 +18088,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 {
@@ -17922,7 +18103,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 {
@@ -17943,7 +18124,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;
@@ -18017,7 +18198,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 {
@@ -18029,10 +18210,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;
@@ -18052,7 +18233,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;
@@ -18074,7 +18255,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 {
@@ -18085,7 +18266,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 {
@@ -18098,7 +18279,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 {
@@ -18109,8 +18291,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 {
@@ -18139,7 +18322,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;
@@ -18155,7 +18338,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;
@@ -18182,12 +18365,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);
       }
@@ -18217,6 +18400,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;
@@ -18237,7 +18426,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;
   }
@@ -18246,7 +18437,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;
   }
@@ -18322,10 +18516,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) {
@@ -18403,7 +18596,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);
     }
@@ -18448,7 +18641,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);
@@ -18458,7 +18651,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;
@@ -18473,7 +18666,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;
@@ -18493,12 +18686,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 {
@@ -18508,7 +18701,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];
@@ -18569,7 +18762,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;
@@ -18669,7 +18864,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);
@@ -18685,6 +18881,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;
@@ -19137,7 +19338,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) {
@@ -19170,7 +19371,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;
@@ -19188,7 +19389,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);
@@ -19196,7 +19397,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);
@@ -19289,7 +19490,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;
@@ -19322,7 +19523,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") {
@@ -19335,7 +19536,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]));
@@ -19359,12 +19560,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 };
@@ -19539,7 +19740,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)) {
@@ -19548,32 +19749,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
@@ -19738,13 +20117,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;
@@ -19760,7 +20156,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 };
@@ -19860,13 +20256,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) {
@@ -19909,7 +20306,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;
@@ -19918,19 +20517,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;
@@ -19983,6 +20580,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);
@@ -19995,8 +20593,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,
@@ -20006,7 +20609,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();
@@ -20026,6 +20629,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") {
@@ -20067,6 +20676,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];
@@ -20082,7 +20726,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;
@@ -20096,11 +20748,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 } : {},
@@ -20108,6 +20765,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;
     }
@@ -20124,6 +20782,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,
@@ -20185,49 +20844,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;
@@ -20238,7 +20911,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) {
@@ -20265,10 +20939,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) {
@@ -20308,9 +20992,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--) {
@@ -20337,6 +21019,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") {
@@ -20349,15 +21033,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, {
@@ -20552,11 +21246,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)) {
@@ -20643,6 +21333,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);
@@ -20675,6 +21366,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;
         }
@@ -20687,7 +21379,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") {
@@ -20754,37 +21447,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);
     }
@@ -20801,7 +21515,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);
   }