parseman 0.52.0 → 0.54.0

package/dist/index.js

@@ -1659,65 +1659,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) {
@@ -1833,12 +1785,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;
@@ -1868,7 +1824,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;
@@ -1886,9 +1842,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;
@@ -1955,7 +1911,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;
@@ -2739,6 +2695,23 @@ function scalarRootOf(combinator) {
   return scalar !== void 0 && def.tag === "grammar" && scalarTree(def.parser, /* @__PURE__ */ new Set()) ? scalar : void 0;
 }
 
+// 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;
@@ -2754,6 +2727,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
@@ -2801,7 +2778,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) {
@@ -2835,6 +2812,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);
@@ -3816,6 +3794,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 = {
@@ -3880,7 +3859,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 = [];
@@ -3912,6 +3891,7 @@ function sepBy(combinator, separatorArg, opts = {}) {
             sepPos = advanceTrivia(input, cur, ctx);
           }
         }
+        if (separatorLeads) LEAD.at = cur;
         const sep = separator.parse(input, sepPos, ctx);
         if (!sep.ok) {
           rollbackTrivia(ctx, loopMark);
@@ -4005,6 +3985,7 @@ function withRuleTrivia(trivia2, ctx, run3) {
     ctx.triviaKindLabels = savedLabels;
   }
 }
+var UNDEFINED_REF = new Error("ref<T>() used before .define() was called");
 function ref() {
   let resolved = null;
   let resolvedScalar = null;
@@ -4020,7 +4001,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;
       }
     },
@@ -4410,6 +4391,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 {
@@ -4419,7 +4401,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 })) };
 }
@@ -4450,9 +4432,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) {
@@ -4466,10 +4465,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`);
     }
@@ -4478,7 +4485,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);
@@ -4490,48 +4498,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;
 }
 
@@ -4914,7 +4908,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);
@@ -5146,16 +5140,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 } };
     }
   };
 }
@@ -5676,15 +5695,15 @@ function formatGatingWarnings(report) {
   return lines;
 }
 function ruleDependencies(ruleMap) {
-  const nameOf = /* @__PURE__ */ new Map();
-  for (const [name, comb] of ruleMap) nameOf.set(comb, name);
+  const nameOf2 = /* @__PURE__ */ new Map();
+  for (const [name, comb] of ruleMap) nameOf2.set(comb, name);
   const deps = /* @__PURE__ */ new Map();
   for (const [name, comb] of ruleMap) {
     const found = /* @__PURE__ */ new Set();
     const seen = /* @__PURE__ */ new Set();
     const walk = (p, isRoot) => {
       const def = p._def;
-      const boundary = def.tag === "lazy" ? nameOf.get(p) ?? p._ruleName : nameOf.get(p);
+      const boundary = def.tag === "lazy" ? nameOf2.get(p) ?? p._ruleName : nameOf2.get(p);
       if (!isRoot && boundary !== void 0) {
         found.add(boundary);
         return;
@@ -7593,6 +7612,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.
    *
@@ -8213,8 +8242,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];
@@ -9890,6 +9921,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 {
@@ -9964,7 +10015,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
@@ -10224,20 +10279,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);
@@ -10661,14 +10708,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: {
@@ -10964,7 +11028,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");
@@ -11364,7 +11431,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=${sep}(input,sp,ctx)
+${sepIp >= 0 && leadingTriviaFieldAt(code, k, sepIp) ? "LEAD.at=cur\n" : ""}const sv=${sep}(input,sp,ctx)
 if(sv===FAIL){
 ${rb}
 if(ctx._fc===true)return FAIL
@@ -12474,6 +12541,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;
   }
@@ -13111,12 +13184,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;
         };
       }
@@ -13550,6 +13638,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);
@@ -13627,9 +13721,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]);
@@ -13637,6 +13734,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;
@@ -13999,7 +14099,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 && !REC2 && !cfg.probe && !cfg.coverage && !cfg.trackLines;
+          const predecide = !REC2 && !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;
@@ -14222,6 +14322,75 @@ function assemble(t, prog, cfg) {
             );
           };
           const masked = bindMasked(0, EMPTY_EXPECTED_PREFIX);
+          const pBit = [];
+          const pRec = [];
+          if (!REC2 && !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);
@@ -14383,6 +14552,7 @@ function assemble(t, prog, cfg) {
         const max = code[ip + 3];
         const sepIp = code[ip + 4];
         const sep = 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;
@@ -14422,6 +14592,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 = sep(input, sp, ctx);
                 if (sv === FAIL) {
                   if (needMark) rollbackTriviaAt(ctx, mRaw, mTl, mLv, mFl, mEr, mLog, mRoot);
@@ -14511,6 +14682,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 = sep(input, sp, ctx);
               if (sv === FAIL) {
                 if (needMark) rollbackTriviaAt(ctx, mRaw, mTl, mLv, mFl, mEr, mLog, mRoot);
@@ -14833,20 +15005,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);
@@ -14912,7 +15073,9 @@ function assemble(t, prog, cfg) {
         scanTriviaCompact,
         t.lex,
         adjacencyHolds,
-        t.lexPrograms
+        t.lexPrograms,
+        LEAD,
+        triviaFieldCapture
       );
       emitReached = new Set(pre.reached);
     }
@@ -14994,7 +15157,9 @@ function assemble(t, prog, cfg) {
         scanTriviaCompact,
         t.lex,
         adjacencyHolds,
-        t.lexPrograms
+        t.lexPrograms,
+        LEAD,
+        triviaFieldCapture
       );
       emitReached = em.reached;
     } catch (e) {
@@ -15170,7 +15335,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);
@@ -15178,7 +15345,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;
@@ -15199,6 +15366,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
@@ -15364,11 +15534,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");
 }
 
@@ -15437,7 +15611,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 [];
@@ -15462,16 +15637,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, path) => {
     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:${path}/arm:${index}`);
       choices.set(parser2, ids);
@@ -15492,7 +15690,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 };
 }
@@ -15516,7 +15720,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":
@@ -16798,104 +17002,298 @@ 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 runOnce2 = (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 runOnce2(input, pos, createParseContext());
-    },
-    parseWithContext(input, parseCtx, pos = 0) {
-      return runOnce2(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 = runOnce2(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
-  };
-  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;
+function encodeForRun(ruleMap, opts) {
+  runDuplicationDiagnosticRules(ruleMap, opts.duplication);
+  const encodeMap = withAmbient(ruleMap, opts);
+  const plan = opts.coverage === true ? buildGrammarPlan(
+    encodeMap.map(([, rule]) => rule),
+    Object.fromEntries(encodeMap.filter(([, rule]) => rule._def.tag !== "lazy"))
+  ) : void 0;
+  const hostMode = resolveHostMode(ruleMap, opts.hostMode);
+  const settings = {
+    hostMode,
+    ...resolveTrackLines(ruleMap, opts.trackLines) ? { trackLines: true } : {},
+    ...opts.recovery === true ? { recovery: true } : {},
+    ...plan === void 0 ? {} : { coverage: plan }
+  };
+  try {
+    const { prog, fnSrcs } = encodeTableProgram(Object.fromEntries(encodeMap), settings);
+    return { prog, fnSrcs, hostMode, plan };
+  } catch (e) {
+    opts.refusals?.push(e instanceof Error ? e.message : String(e));
+    return null;
+  }
+}
+function compileRuleMap(ruleMap, opts = {}) {
+  const encoded = encodeForRun(ruleMap, opts);
+  if (encoded === null) return null;
+  const { prog, fnSrcs, hostMode, plan } = encoded;
+  const artifact = closureArtifact(prog);
+  if (artifact.runtimeOnly !== void 0 && artifact.runtimeOnly.length > 0) {
+    opts.refusals?.push(...artifact.runtimeOnly);
+    return null;
+  }
+  const supplied = opts.fnSources;
+  const sources = fnSrcs.map((s, i) => s ?? supplied?.[i] ?? null);
+  if (sources.some((s) => s === null)) {
+    const missing = sources.flatMap((s, i) => s === null ? [i] : []);
+    opts.refusals?.push(
+      `author reducer source missing for prog.fns[${missing.join(", ")}] \u2014 printing would emit \`() => {}\` and the parse would return no value`
+    );
+    return null;
+  }
+  if (supplied !== void 0 && supplied.length > fnSrcs.length) {
+    throw new Error(
+      `compileRuleMap: got ${supplied.length} fnSources for a pool of ${fnSrcs.length}. The list is positional, in prog.fns order, so a longer one means it belongs to a different encode \u2014 and the entries would be silently misassigned.`
+    );
+  }
+  const replacementWithMetadata = (metadataSource, options = {}) => emitTableExpression(artifact, {
+    entry: null,
+    runtimeRef: opts.runtimeRef ?? "tableRules",
+    fnSources: sources,
+    ...options.precompileDefault === true && hostMode === "ast" && prog.lines !== 1 && prog.code.length >= DEFAULT_PRECOMPILE_MIN_WORDS ? { assemblies: defaultAssemblyCfgs(artifact).slice(0, 1) } : {},
+    ...metadataSource === void 0 ? {} : { metadataSource }
+  });
+  const replacement = replacementWithMetadata();
+  return {
+    keys: ruleMap.map(([key]) => key),
+    replacement,
+    replacementWithMetadata,
+    hostMode,
+    // WHAT THE FLAG MEANS is "a DIRECT BUILDER's positioned-CST branch was
+    // dropped", which is what the driver's `'ast' artifact + CST host` check keys
+    // off. `mode === 'ast'` alone over-reports it: an all-STRUCTURAL grammar has no
+    // direct builder, so there was no branch to drop and it stays usable with either
+    // host — the long-standing `node(parser)` contract. Same predicate codegen uses
+    // for its own `hasDirectBuilders` (both read `analysis/commitment.ts`), so the two
+    // lowerings stamp the same artifact rather than disagreeing about it.
+    hostBranchElided: hostMode === "ast" && ruleMap.some(([, rule]) => hasDirectBuildDef(rule)),
+    reflection: collectGrammarReflection(ruleMap),
+    ...plan === void 0 ? {} : { coverageDefinitions: plan.definitions },
+    rules: tableRules(artifact),
+    prog: artifact
+  };
+}
+
+// src/compiler/borrowed-rules.ts
+var nameOf = (c) => c._ruleName;
+function deref(c) {
+  const seen = /* @__PURE__ */ new Set();
+  let current = c;
+  while (current._def.tag === "lazy" && !seen.has(current)) {
+    seen.add(current);
+    try {
+      current = current._def.thunk();
+    } catch {
+      return void 0;
+    }
+  }
+  return current;
+}
+function borrowedRuleReference(map) {
+  const seen = /* @__PURE__ */ new Set();
+  for (const [rule, self] of Object.entries(map)) {
+    let found;
+    const visit = (c) => {
+      if (found !== void 0) return;
+      if (c._def.tag === "lazy") {
+        if (!winnerWrapsReference(self, c)) {
+          const name = nameOf(c);
+          const winner = name !== void 0 && Object.hasOwn(map, name) ? map[name] : void 0;
+          if (winner !== void 0) {
+            if (winnerWrapsReference(winner, c) || deref(c) === deref(winner)) return;
+            found = name;
+            return;
+          }
+        }
+        if (seen.has(c)) return;
+        seen.add(c);
+        let body;
+        try {
+          body = c._def.thunk();
+        } catch {
+          return;
+        }
+        visit(body);
+        return;
       }
+      if (seen.has(c)) return;
+      seen.add(c);
+      for (const child of childrenOf2(c._def)) visit(child);
+    };
+    visit(self);
+    if (found !== void 0) return { rule, reference: found };
+  }
+  return void 0;
+}
+function borrowedRuleMessage(api, hit) {
+  return `${api}: rule "${hit.rule}" is a rule object borrowed from another grammar, and its graph references "${hit.reference}", which this grammar also defines. The interpreter would keep the other grammar's "${hit.reference}" while a compiled table binds this grammar's, so the two would accept different input. Compose the grammar that defines "${hit.rule}" instead of borrowing its rule object, so its references resolve to this grammar's rules.`;
+}
+
+// src/table/compile.ts
+var ENTRY = "Entry";
+function ownSource(fn) {
+  if (typeof fn !== "function") return null;
+  const text = Function.prototype.toString.call(fn);
+  if (!text.includes("[native code]")) return text;
+  const name = fn.name;
+  return typeof name === "string" && name.length > 0 && globalThis[name] === fn ? name : null;
+}
+function compile(target, second, third) {
+  if (!isCombinator(target)) return compileMap(target, second);
+  return compileRoot(target, second, third);
+}
+function isCombinator(x) {
+  return typeof x === "object" && x !== null && typeof x.parse === "function" && "_def" in x;
+}
+function compileMap(grammar, opts = {}) {
+  const entries = [];
+  for (const [key, value] of Object.entries(grammar)) {
+    if (!isCombinator(value)) throw new TypeError(`compile: grammar entry "${key}" is not a parser`);
+    if (value._def.tag === "lazy") {
+      try {
+        value._def.thunk();
+      } catch {
+        continue;
+      }
+    }
+    entries.push([key, value]);
+  }
+  const borrowed = borrowedRuleReference(Object.fromEntries(entries));
+  if (borrowed !== void 0) throw new Error(borrowedRuleMessage("compile", borrowed));
+  const drain = beginCompileDegradationDrain();
+  let done = false;
+  try {
+    const refusals = [];
+    const compiled = compileRuleMapRunnable(entries, {
+      ...opts.hostMode ? { hostMode: opts.hostMode } : {},
+      refusals,
+      specialise: true
+    });
+    if (compiled === null) {
+      throw new Error(`compile: this grammar could not be encoded to a table${refusals.length ? ` \u2014 ${refusals.join("; ")}` : ""}`);
+    }
+    done = true;
+    return compiled.rules;
+  } finally {
+    drain(done);
+  }
+}
+function compileRoot(combinator, mapFnSources, opts = {}) {
+  runDuplicationDiagnostic(combinator, opts.duplication);
+  const drain = beginCompileDegradationDrain();
+  let compiled = false;
+  try {
+    const out = compileImpl(combinator, mapFnSources, opts);
+    compiled = true;
+    return out;
+  } finally {
+    drain(compiled);
+  }
+}
+function compileImpl(combinator, mapFnSources, opts = {}) {
+  const plan = opts.coverage === true ? buildGrammarPlan(combinator) : void 0;
+  const settings = {
+    ...opts.hostMode === void 0 ? {} : { hostMode: opts.hostMode },
+    ...opts.trackLines === void 0 ? {} : { trackLines: opts.trackLines },
+    ...plan === void 0 ? {} : { coverage: plan }
+  };
+  const { prog, fnSrcs } = encodeTableProgram({ [ENTRY]: combinator }, settings);
+  const artifact = closureArtifact(prog);
+  const entry = tableRules(prog)[ENTRY];
+  const offered = opts.fnSources ?? mapFnSources;
+  const supplied = offered !== void 0 && offered.length === fnSrcs.length ? offered : void 0;
+  const sources = fnSrcs.map((s, i) => s ?? supplied?.[i] ?? ownSource(prog.fns[i]));
+  const unsourced = sources.reduce((acc, s, i) => s === null ? [...acc, i] : acc, []);
+  const runtimeOnly = [
+    ...prog.runtimeOnly ?? [],
+    ...unsourced.length === 0 ? [] : [`author reducer source missing for prog.fns[${unsourced.join(", ")}] \u2014 printing would emit \`() => {}\` and the parse would return no value`]
+  ];
+  const printable = runtimeOnly.length === 0;
+  const emitOpts = { fnSources: sources };
+  const source = printable ? emitTableModule(artifact, { name: "grammar", ...emitOpts }) : "";
+  const inlineExpression = printable ? emitTableExpression(artifact, { entry: ENTRY, runtimeRef: opts.runtimeRef ?? "tableRules", ...emitOpts }) : null;
+  const runOnce2 = (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 runOnce2(input, pos, createParseContext());
+    },
+    parseWithContext(input, parseCtx, pos = 0) {
+      return runOnce2(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 = runOnce2(input, pos, ctx);
+      return { ...r, errors };
     }
   };
 }
@@ -16996,176 +17394,6 @@ function serializeRuleMap(ruleMap, scanSkip) {
     throw e;
   }
 }
-function evalRuleMapIR(ir) {
-  const _tf = (child, src, recognitionOnly = false) => {
-    let fn2;
-    try {
-      fn2 = (0, eval)(`(${src})`);
-    } catch {
-      fn2 = () => {
-        throw new Error("IR transform fn not materialized");
-      };
-    }
-    const t = transform(child, fn2);
-    t._def.fnSrc = src;
-    if (recognitionOnly) t._def.recognitionOnly = true;
-    return t;
-  };
-  const _lf = (child, src, source = false) => {
-    let fn2;
-    try {
-      fn2 = (0, eval)(`(${src})`);
-    } catch {
-      fn2 = () => {
-        throw new Error("IR leaf fn not materialized");
-      };
-    }
-    const l = source ? sourceLeaf(child, fn2) : leaf(child, fn2);
-    l._def.fnSrc = src;
-    return l;
-  };
-  const _nd = (type, child, src, opts, staticError, sigSrc, buildImports, rawUnused) => {
-    if (staticError !== void 0 && staticError.length > 0) {
-      throw new Error(`IR direct node builder for ${type} must be macro-static and self-contained; unsupported binding(s): ${staticError.join(", ")}`);
-    }
-    const n = node(type, child, (() => {
-      throw new Error("IR node build requires static re-lowering");
-    }), opts);
-    n._def.buildSrc = src;
-    if (staticError !== void 0) n._def.buildStaticError = staticError;
-    if (sigSrc !== void 0) n._def.buildSigSrc = sigSrc;
-    if (rawUnused === true) n._def.buildRawUnused = true;
-    if (buildImports !== void 0) n._def.buildImports = buildImports;
-    return n;
-  };
-  const _gch = (items) => {
-    const gateSrcs = [];
-    const arms = items.map((it) => {
-      if (Array.isArray(it)) {
-        const [src, comb] = it;
-        gateSrcs.push(src);
-        let gate2;
-        try {
-          gate2 = (0, eval)(`(${src})`);
-        } catch {
-          gate2 = () => {
-            throw new Error("IR gate fn not materialized");
-          };
-        }
-        return { gate: gate2, combinator: comb };
-      }
-      gateSrcs.push(null);
-      return it;
-    });
-    const c = choice(...arms);
-    const gates = c._def.gates;
-    if (gates && gates.length !== gateSrcs.length) {
-      throw new Error(`_gch: gateSrcs length ${gateSrcs.length} != choice gates length ${gates.length}`);
-    }
-    ;
-    c._def.gateSrcs = gateSrcs;
-    return c;
-  };
-  const _wc = (src, inner) => {
-    let extra;
-    try {
-      extra = (0, eval)(`(${src})`);
-    } catch {
-      extra = void 0;
-    }
-    const w = withCtx(extra, inner);
-    w._def.extraSrc = src;
-    return w;
-  };
-  const fn = new Function(
-    "rules",
-    "ref",
-    "regex",
-    "literal",
-    "keywords",
-    "sequence",
-    "choice",
-    "dispatch",
-    "when",
-    "startsWith",
-    "endsWith",
-    "matches",
-    "otherwise",
-    "routed",
-    "attempt",
-    "many",
-    "oneOrMore",
-    "optional",
-    "sepBy",
-    "keepSeparator",
-    "not",
-    "peek",
-    "node",
-    "parser",
-    "scanTo",
-    "balanced",
-    "token",
-    "leaf",
-    "transform",
-    "trivia",
-    "classifiedTrivia",
-    "label",
-    "field",
-    "expect",
-    "adjacent",
-    "notAdjacent",
-    "_tf",
-    "_lf",
-    "_nd",
-    "_gch",
-    "_wc",
-    `return (${ir})`
-  );
-  const map = fn(
-    rules,
-    ref,
-    regex,
-    literal,
-    keywords,
-    sequence,
-    choice,
-    dispatch,
-    when,
-    startsWith,
-    endsWith,
-    matches,
-    otherwise,
-    routed,
-    attempt,
-    many,
-    oneOrMore,
-    optional,
-    sepBy,
-    keepSeparator,
-    not,
-    peek,
-    node,
-    parser,
-    scanTo,
-    balanced,
-    token,
-    leaf,
-    transform,
-    trivia,
-    classifiedTrivia,
-    label,
-    field,
-    expect,
-    adjacent,
-    notAdjacent,
-    _tf,
-    _lf,
-    _nd,
-    _gch,
-    _wc
-  );
-  return Object.entries(map);
-}
 var Serializer = class {
   counts = /* @__PURE__ */ new Map();
   selfRef = /* @__PURE__ */ new Set();
@@ -17428,7 +17656,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":
@@ -17491,128 +17719,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) {
@@ -17680,16 +17793,6 @@ function compileLinkableTable(ruleMapArg, ns, opts = {}) {
 }
 
 // src/compiler/linker.ts
-var _nsCounter = 0;
-function linkable(rulesMap, ns, trivia2, hostMode) {
-  const piece = compileLinkableTable(
-    Object.entries(rulesMap),
-    ns ?? `_lk${_nsCounter++}_`,
-    { ...trivia2 ? { trivia: trivia2 } : {}, ...hostMode ? { hostMode } : {} }
-  );
-  if (!piece) throw new Error("linkable(): this grammar cannot be compiled to a linkable artifact (contains a runtime-only parser fallback)");
-  return piece;
-}
 function normalizeCstCollapse(collapse) {
   if (collapse === true) return () => true;
   if (Array.isArray(collapse)) {
@@ -17713,107 +17816,6 @@ function cstBuildHost(typeOrOptions, children2, _fields, span, rawChildren, triv
   return host;
 }
 cstBuildHost._parsemanCstOutput = true;
-function fuseCarried(carried, trivia2, hostMode) {
-  const maps = [];
-  for (const p of carried) {
-    if (!isIRPiece(p)) {
-      if (typeof p.v !== "string") {
-        throw new Error(
-          `parseman: artifact "${p.ns}" is UNSTAMPED (compiled before the version-lock invariant). Recompile the grammar with parseman ${PARSEMAN_VERSION}; parseman does not fuse unversioned or cross-version artifacts.`
-        );
-      }
-      if (p.v !== PARSEMAN_VERSION) {
-        throw new Error(
-          `parseman: artifact "${p.ns}" was compiled with parseman ${p.v}, but is being fused with parseman ${PARSEMAN_VERSION}. Compiled grammar artifacts are version-locked \u2014 recompile the grammar with parseman ${PARSEMAN_VERSION}; parseman does not fuse across versions.`
-        );
-      }
-    }
-    const rules2 = ruleMapOfCarried(p);
-    if (rules2 === void 0) {
-      throw new Error(`compose: carried piece "${p.ns}" has no re-lowerable IR and cannot be fused`);
-    }
-    maps.push(rules2);
-  }
-  const merged = mergeCarriedRuleMaps(maps);
-  materializeDirectBuilders(merged);
-  if (trivia2) {
-    for (const [, rule] of merged) {
-      if (rule._meta.isTrivia) continue;
-      rule._meta.grammarTrivia = trivia2;
-    }
-  }
-  const refusals = [];
-  const compiled = compileRuleMapRunnable(merged, {
-    ...trivia2 ? { trivia: trivia2 } : {},
-    ...hostMode ? { hostMode } : {},
-    refusals
-  });
-  if (compiled === null) {
-    throw new Error(`compose: the merged grammar could not be encoded to a table${refusals.length ? ` \u2014 ${refusals.join("; ")}` : ""}`);
-  }
-  const map = tableRules(compiled.prog);
-  for (const k of Object.keys(map)) {
-    Object.defineProperty(map[k], FUSED_HOST_MODE, { value: compiled.hostMode, enumerable: false });
-    Object.defineProperty(map[k], FUSED_HOST_ELIDED, { value: compiled.hostBranchElided, enumerable: false });
-  }
-  Object.defineProperty(map, FUSED_HOST_MODE, { value: compiled.hostMode, enumerable: false });
-  Object.defineProperty(map, FUSED_HOST_ELIDED, { value: compiled.hostBranchElided, enumerable: false });
-  Object.defineProperty(map, GRAMMAR_REFLECTION, { value: compiled.reflection, enumerable: false });
-  return map;
-}
-function materializeDirectBuilders(ruleMap) {
-  const seen = /* @__PURE__ */ new Set();
-  const visit = (p) => {
-    if (seen.has(p)) return;
-    seen.add(p);
-    const d = p._def;
-    if (d.tag === "node" && typeof d.buildSrc === "string") {
-      if (d.buildImports !== void 0 && d.buildImports.length > 0) {
-        throw new Error(
-          `IR direct node builder for ${d.type ?? "<anonymous>"} references module import(s) ${d.buildImports.map((bi) => bi.local).join(", ")} that a runtime compose() cannot supply; compose at build time via the parseman macro plugin, which re-emits the imports.`
-        );
-      }
-      try {
-        const fn = (0, eval)(`(${d.buildSrc})`);
-        if (typeof fn === "function") d.build = fn;
-      } catch {
-      }
-    }
-    if (d.tag === "lazy") {
-      let resolved;
-      try {
-        resolved = d.thunk();
-      } catch {
-        return;
-      }
-      if (resolved) visit(resolved);
-      return;
-    }
-    for (const child of childrenOf2(p._def)) visit(child);
-  };
-  for (const [, rule] of ruleMap) visit(rule);
-}
-function ruleMapOfCarried(p) {
-  if (isIRPiece(p)) return evalRuleMapIR(p.ir);
-  if (p.ir !== null) return evalRuleMapIR(p.ir);
-  return p.ruleMap.length > 0 ? p.ruleMap.map(([k, v]) => [k, v]) : void 0;
-}
-function mergeCarriedRuleMaps(maps) {
-  const winners = /* @__PURE__ */ new Map();
-  for (const map of maps) {
-    for (const [name, rule] of map) {
-      if (rule._def.tag === "lazy") {
-        try {
-          rule._def.thunk();
-        } catch {
-          continue;
-        }
-      }
-      winners.set(name, rule);
-    }
-  }
-  return [...winners];
-}
 function fusedHostModeOf(registry) {
   const m = registry[FUSED_HOST_MODE];
   return m === "cst" ? "cst" : "ast";
@@ -17828,13 +17830,17 @@ function composedPiecesOf(grammar) {
 }
 var LEAF_COMPOSED = /* @__PURE__ */ Symbol.for("parseman.leafComposed");
 var COMPOSED_TRIVIA = /* @__PURE__ */ Symbol.for("parseman.composedTrivia");
-var COMPOSED_COVERAGE_RULES = /* @__PURE__ */ Symbol.for("parseman.composedCoverageRules");
+var LINKED = /* @__PURE__ */ Symbol.for("parseman.linkedComposition");
 function isIRPiece(p) {
   return !!p && typeof p === "object" && typeof p.ir === "string" && typeof p.ns === "string" && !("keys" in p);
 }
 function isLinkableTable(p) {
   return !!p && typeof p === "object" && typeof p.ns === "string" && Array.isArray(p.keys);
 }
+function ruleMapOfCarried(p) {
+  if (isIRPiece(p)) return void 0;
+  return p.ruleMap.length > 0 ? p.ruleMap.map(([k, v]) => [k, v]) : void 0;
+}
 function carriedRuleMapsDetailed(carried) {
   const maps = [];
   const opaque = [];
@@ -17865,250 +17871,97 @@ function recoverComposedRules(grammar) {
   }
   return { rules: rules2, opaque };
 }
-function coverageRulesOf(carried) {
-  const winners = {};
-  for (const piece of carried) {
-    if (!isIRPiece(piece)) return void 0;
-    const map = evalRuleMapIR(piece.ir);
-    for (const [name, rule] of map) {
-      if (rule._def.tag === "lazy") {
-        try {
-          rule._def.thunk();
-        } catch {
-          continue;
-        }
-      }
-      winners[name] = rule;
-    }
-  }
-  return winners;
-}
 function composedCoverageRules(grammar) {
-  return grammar[COMPOSED_COVERAGE_RULES];
-}
-function nextComposeNs(used) {
-  let ns;
-  do {
-    ns = `_lk${_nsCounter++}_`;
-  } while (used.has(ns));
-  used.add(ns);
-  return ns;
-}
-function itemCarried(item, used, trivia2, hostMode) {
-  const carried = item[COMPOSED_PIECES];
-  if (Array.isArray(carried)) {
-    const items = carried;
-    for (const p of items) used.add(p.ns);
-    return items;
-  }
-  if (isLinkableTable(item)) {
-    used.add(item.ns);
-    return [item];
-  }
-  const map = item;
-  const ns = nextComposeNs(used);
-  const entries = Object.entries(map).filter(([, val]) => {
-    const d = val._def;
-    if (d.tag !== "lazy") return true;
-    try {
-      d.thunk();
-      return true;
-    } catch {
-      return false;
-    }
-  });
-  const scanSkip = entries.map(([, val]) => val._meta.grammarScanSkip).find(Boolean);
-  const ir = serializeRuleMap(entries, scanSkip);
-  return ir ? [{ ns, ir }] : [linkable(map, ns, trivia2, hostMode)];
+  const link = grammar[LINKED];
+  return link?.();
+}
+var LINKED_WINNERS = /* @__PURE__ */ new WeakMap();
+function linkedWinnersOf(rule) {
+  return LINKED_WINNERS.get(rule);
+}
+function recipesOf(item) {
+  const recipes = item[RULES_RECIPE];
+  if (Array.isArray(recipes)) return recipes;
+  const what = isLinkableTable(item) ? `the table artifact "${item.ns}"` : composedPiecesOf(item) !== void 0 ? "a build-compiled compose() result" : "a value that is not a rules() grammar";
+  throw new Error(
+    `compose: ${what} has no live rules to link. At runtime compose() links interpreter grammars \u2014 rules() maps and runtime compose() results \u2014 and never evaluates carried IR or source text. Compose compiled grammars at build time (the parseman macro does), or compose the interpreter builds of both.`
+  );
 }
 function composingTriviaOf(items) {
   for (let i = items.length - 1; i >= 0; i--) {
     const item = items[i];
-    if (!item || isLinkableTable(item)) continue;
-    const stamped = item[COMPOSED_TRIVIA];
-    if (stamped) return stamped;
-    if (item[COMPOSED_PIECES]) continue;
-    for (const v of Object.values(item)) {
-      const t = v?._meta?.grammarTrivia;
-      if (t) return t;
+    if (item[LINKED] !== void 0) {
+      const stamped = item[COMPOSED_TRIVIA];
+      if (stamped) return stamped;
+      continue;
     }
+    const recipes = item[RULES_RECIPE];
+    const trivia2 = recipes?.[recipes.length - 1]?.options?.trivia;
+    if (trivia2 != null) return trivia2;
   }
   return void 0;
 }
-function compose(items, opts) {
-  if (items.some((item) => item[LEAF_COMPOSED] === true)) {
-    throw new Error("compose: a composeLeaf() result is terminal and cannot be composed again");
-  }
-  const used = /* @__PURE__ */ new Set();
-  const trivia2 = composingTriviaOf(items);
-  const carried = items.flatMap((item) => itemCarried(item, used, trivia2, opts?.hostMode));
-  const map = fuseCarried(carried, trivia2, opts?.hostMode);
-  Object.defineProperty(map, COMPOSED_PIECES, { value: carried, enumerable: false });
-  if (trivia2) Object.defineProperty(map, COMPOSED_TRIVIA, { value: trivia2, enumerable: false });
-  const coverageRules = coverageRulesOf(carried);
-  if (coverageRules) Object.defineProperty(map, COMPOSED_COVERAGE_RULES, { value: coverageRules, enumerable: false });
-  return map;
-}
-function composeLeaf(items) {
-  const pieces = items.flatMap(interpretedPieces);
-  let fused;
-  const map = {};
-  for (const name of ruleNamesOf(pieces)) {
-    Object.defineProperty(map, name, {
-      enumerable: true,
-      configurable: true,
-      get: () => (fused ??= fusePieces(pieces))[name]
-    });
-  }
-  Object.defineProperty(map, LEAF_COMPOSED, { value: true, enumerable: false });
-  Object.defineProperty(map, INTERPRETED_PIECES, {
-    value: pieces.filter((p) => p.plain).map((p) => p.entries),
-    enumerable: false
-  });
-  return map;
-}
-function isRefSlot(c) {
-  return c._def.tag === "lazy" && typeof c.define === "function";
-}
-var FUSE_ORIGINAL = /* @__PURE__ */ Symbol.for("parseman.interpretedFuseOriginal");
-var FUSE_TARGET = /* @__PURE__ */ Symbol.for("parseman.interpretedFuseTarget");
-var INTERPRETED_PIECES = /* @__PURE__ */ Symbol.for("parseman.interpretedPieces");
-function definitionOf(entry) {
-  if (isRefSlot(entry)) {
-    const original = entry[FUSE_ORIGINAL];
-    if (original !== void 0) return original ?? void 0;
-    try {
-      return entry._def.thunk();
-    } catch {
-      return void 0;
-    }
-  }
-  if (entry._def.tag === "lazy") {
-    try {
-      entry._def.thunk();
-    } catch {
-      return void 0;
-    }
+function declaredNamesOf(items) {
+  const names = /* @__PURE__ */ new Set();
+  for (const item of items) {
+    const linked = item[LINKED] !== void 0;
+    const order = linked ? Object.keys(item) : isLinkableTable(item) ? item.keys : item[RULE_ORDER];
+    for (const name of order ?? Object.keys(item)) names.add(name);
   }
-  return entry;
+  return [...names];
 }
-function repointRef(slot, target, name) {
-  const tagged = slot;
-  const bound = tagged[FUSE_TARGET];
-  const original = FUSE_ORIGINAL in tagged ? tagged[FUSE_ORIGINAL] : (() => {
+function linkComposition(recipes, link) {
+  const map = linkRules(recipes, link);
+  const missing = [];
+  for (const [name, rule] of Object.entries(map)) {
+    if (rule._def.tag !== "lazy") continue;
     try {
-      return slot._def.thunk();
+      rule._def.thunk();
     } catch {
-      return null;
-    }
-  })();
-  if ((bound ?? original) === target) return;
-  if (bound !== void 0) {
-    throw new Error(
-      `fuseInterpreted: rule "${name}" is already bound by a DIFFERENT interpreted fusion of the same grammar piece. An interpreted fuse binds the shared placeholder objects in place, so two fusions cannot share a piece \u2014 build a fresh instance of the piece (call its rules() factory again, or import the module under a distinct specifier) for the second fusion.`
-    );
-  }
-  if (!(FUSE_ORIGINAL in tagged)) Object.defineProperty(slot, FUSE_ORIGINAL, { value: original, enumerable: false });
-  Object.defineProperty(slot, FUSE_TARGET, { value: target, enumerable: false });
-  slot._def.thunk = () => target;
-  slot.parse = (input, pos, ctx) => target.parse(input, pos, ctx);
-  const meta = slot._meta;
-  meta.firstSet = target._meta.firstSet;
-  meta.canMatchNewline = target._meta.canMatchNewline;
-  meta.isTrivia = target._meta.isTrivia;
-  if (target._meta.triviaKindLabels !== void 0) meta.triviaKindLabels = target._meta.triviaKindLabels;
-  else meta.triviaKindLabels = void 0;
-  if (target._meta.disjoint !== void 0) meta.disjoint = target._meta.disjoint;
-  else meta.disjoint = void 0;
-}
-function interpretedPieces(item) {
-  const fused = item[INTERPRETED_PIECES];
-  if (Array.isArray(fused)) return fused.map((entries) => ({ entries, plain: false }));
-  const carried = composedPiecesOf(item);
-  if (carried !== void 0) {
-    const { maps, opaque } = carriedRuleMapsDetailed(carried);
-    if (opaque.length > 0) {
-      throw new Error(
-        `fuseInterpreted: cannot interpret a composed grammar containing precompiled artifact(s) ${opaque.map((o) => `"${o.ns}" (${o.ruleNames.length} rules)`).join(", ")} \u2014 they carry compiled functions, not a combinator graph. Pass the source grammars (the same items you passed to compose()) instead.`
-      );
+      missing.push(name);
     }
-    return maps.map((entries) => ({ entries, plain: false }));
   }
-  if (isLinkableTable(item)) {
-    const rules2 = ruleMapOfCarried(item);
-    if (rules2 === void 0) {
-      throw new Error("fuseInterpreted: a precompiled linkable artifact with no carried IR has no combinator graph to interpret; pass the source grammar (a rules() map) instead");
+  if (missing.length > 0) {
+    const holes = new Set(missing);
+    for (const [name, deps] of ruleDependencies(Object.entries(map).filter(([n]) => !holes.has(n)))) {
+      for (const dep of deps) if (holes.has(dep)) throw new Error(`compose: rule "${name}" references missing rule "${dep}"`);
     }
-    return [{ entries: rules2, plain: false }];
+    throw new Error(`compose: rule(s) ${missing.map((n) => `"${n}"`).join(", ")} are referenced but defined by no composed grammar`);
   }
-  return [{ entries: Object.entries(item), plain: true }];
+  const borrowed = borrowedRuleReference(map);
+  if (borrowed !== void 0) throw new Error(borrowedRuleMessage("compose", borrowed));
+  for (const rule of Object.values(map)) LINKED_WINNERS.set(rule, map);
+  Object.defineProperty(map, RULES_RECIPE, { value: recipes, enumerable: false });
+  Object.defineProperty(map, LINKED, { value: () => map, enumerable: false });
+  if (link.trivia) Object.defineProperty(map, COMPOSED_TRIVIA, { value: link.trivia, enumerable: false });
+  return map;
 }
-function ruleNamesOf(pieces) {
-  const names = /* @__PURE__ */ new Set();
-  for (const piece of pieces) {
-    for (const [name, value] of piece.entries) if (definitionOf(value) !== void 0) names.add(name);
+function compose(items, opts) {
+  if (items.some((item) => item[LEAF_COMPOSED] === true)) {
+    throw new Error("compose: a composeLeaf() result is terminal and cannot be composed again");
   }
-  return [...names];
+  return linkedMap(items, opts, false);
 }
-function fusePieces(pieces, opts) {
-  let trivia2;
-  for (let i = pieces.length - 1; i >= 0 && trivia2 === void 0; i--) {
-    if (!pieces[i].plain) continue;
-    for (const [, rule] of pieces[i].entries) {
-      const t = rule._meta.grammarTrivia;
-      if (t) {
-        trivia2 = t;
-        break;
-      }
-    }
-  }
-  const winner = /* @__PURE__ */ new Map();
-  const entry = /* @__PURE__ */ new Map();
-  for (const piece of pieces) {
-    for (const [name, value] of piece.entries) {
-      const def = definitionOf(value);
-      if (def === void 0) continue;
-      winner.set(name, def);
-      entry.set(name, value);
-    }
-  }
-  const missing = /* @__PURE__ */ new Set();
-  for (const piece of pieces) {
-    for (const [name, value] of piece.entries) {
-      if (!isRefSlot(value)) continue;
-      const target = winner.get(name);
-      if (target === void 0) {
-        missing.add(name);
-        continue;
-      }
-      repointRef(value, target, name);
-    }
+function linkedMap(items, opts, leaf2) {
+  const recipes = items.flatMap(recipesOf);
+  const trivia2 = composingTriviaOf(items);
+  const names = declaredNamesOf(items);
+  let linked;
+  const link = () => linked ??= linkComposition(recipes, { trivia: trivia2, ...opts?.hostMode === void 0 ? {} : { hostMode: opts.hostMode } });
+  const map = {};
+  for (const name of names) {
+    Object.defineProperty(map, name, { enumerable: true, configurable: true, get: () => link()[name] });
   }
-  if (missing.size > 0) throw new Error(missingRuleMessage(pieces, missing));
-  const out = {};
-  for (const [name, value] of entry) {
-    out[name] = value;
-    const meta = value._meta;
-    if (trivia2 !== void 0 && !meta.isTrivia) meta.grammarTrivia = trivia2;
-    if (opts?.hostMode !== void 0 && !meta.isTrivia) {
-      if (opts.hostMode === "cst") meta.grammarHostMode = "cst";
-      else meta.grammarHostMode = void 0;
-    }
-  }
-  Object.defineProperty(out, INTERPRETED_PIECES, {
-    value: pieces.filter((p) => p.plain).map((p) => p.entries),
-    enumerable: false
-  });
-  return out;
+  Object.defineProperty(map, RULES_RECIPE, { value: recipes, enumerable: false });
+  Object.defineProperty(map, RULE_ORDER, { value: names, enumerable: false });
+  Object.defineProperty(map, LINKED, { value: link, enumerable: false });
+  Object.defineProperty(map, GRAMMAR_REFLECTION, { enumerable: false, configurable: true, get: () => link()[GRAMMAR_REFLECTION] });
+  if (trivia2) Object.defineProperty(map, COMPOSED_TRIVIA, { value: trivia2, enumerable: false });
+  if (leaf2) Object.defineProperty(map, LEAF_COMPOSED, { value: true, enumerable: false });
+  return map;
 }
-function missingRuleMessage(pieces, missing) {
-  for (const piece of pieces) {
-    const deps = ruleDependencies(piece.entries.filter(([, v]) => definitionOf(v) !== void 0));
-    for (const [name, ds] of deps) {
-      for (const d of ds) if (missing.has(d)) return `fuseInterpreted: rule "${name}" references missing rule "${d}"`;
-    }
-  }
-  return `fuseInterpreted: missing rule(s) ${[...missing].map((n) => `"${n}"`).join(", ")}`;
+function composeLeaf(items) {
+  return linkedMap(items, void 0, true);
 }
 
 // src/analysis/grammar.ts
@@ -18141,7 +17994,7 @@ function analyzeGrammarGating(grammar, opts) {
 }
 
 // src/analysis/diagnose.ts
-var isCombinator = (g) => typeof g === "object" && g !== null && "_def" in g;
+var isCombinator2 = (g) => typeof g === "object" && g !== null && "_def" in g;
 var isRuleEntries = (g) => Array.isArray(g);
 function diagnoseGrammar(grammar, opts) {
   const depth = degradationCaptureDepth();
@@ -18185,7 +18038,7 @@ function formatGrammarDiagnosis(d) {
   return lines;
 }
 function runAnalysis(grammar, opts) {
-  if (isCombinator(grammar)) return analyzeGating(grammar, opts);
+  if (isCombinator2(grammar)) return analyzeGating(grammar, opts);
   if (isRuleEntries(grammar)) return analyzeGatingRules(grammar, opts);
   return analyzeGrammarGating(grammar, opts);
 }
@@ -19453,6 +19306,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/combinators/completions.ts
 function completionsAt(target, input, offset, options = {}) {
   const probe = { offset, best: null };
@@ -20135,7 +20011,7 @@ function grammarCoverageDefinitions(entry, winners) {
 }
 function composedGrammarCoverageDefinitions(grammar, startRule) {
   const winners = composedCoverageRules(grammar);
-  if (!winners) throw new TypeError("semantic coverage needs re-lowerable composed IR; this composition contains an opaque artifact");
+  if (!winners) throw new TypeError("semantic coverage needs a runtime compose() result (a linked interpreter grammar); this is not one");
   const entry = winners[startRule];
   if (!entry) throw new TypeError(`semantic coverage start rule ${JSON.stringify(startRule)} is not a final winner`);
   return grammarCoverageDefinitions(entry, winners);
@@ -20327,7 +20203,7 @@ function coverageEntry(entry, collector, maps, trace) {
         case "leaf":
           return def.cstValue === "source" ? sourceLeaf(build(def.parser), def.fn) : leaf(build(def.parser), def.fn);
         case "field":
-          return field(def.name, build(def.parser));
+          return field(def.name, build(def.parser), { leadingTrivia: def.leadingTrivia === true, trailingTrivia: def.trailingTrivia === true });
         case "grammar":
           return parser({
             ...def.triviaParser === void 0 ? def.clearTrivia ? { trivia: null } : {} : { trivia: build(def.triviaParser) },
@@ -20377,7 +20253,7 @@ function coverageEntry(entry, collector, maps, trace) {
 }
 function runWithGrammarCoverage(entry, input, options = {}) {
   if (typeof entry === "function") throw new TypeError("runWithGrammarCoverage currently requires an interpreter combinator entry");
-  const plan = buildGrammarPlan(entry);
+  const plan = buildGrammarPlan(entry, linkedWinnersOf(entry));
   const definitions = plan.definitions;
   const collector = options.collector ?? createGrammarCoverageCollector(definitions);
   const { collector: _collector, trace, ...runOptions } = options;
@@ -20451,13 +20327,13 @@ function buildTriviaIndex(root, input = "", opts) {
 }
 
 // src/cst/walk.ts
-function isCombinator2(value) {
+function isCombinator3(value) {
   return !!value && typeof value === "object" && "_def" in value && "_meta" in value && typeof value.parse === "function";
 }
 function reflectionFor(grammar) {
   const stamped = grammarReflectionOf(grammar);
   if (stamped) return stamped;
-  const entries = Object.entries(grammar).filter((entry) => isCombinator2(entry[1]));
+  const entries = Object.entries(grammar).filter((entry) => isCombinator3(entry[1]));
   return collectGrammarReflection(entries);
 }
 function createVisitor(grammar, spec) {