parseman 0.52.0 → 0.53.0

package/dist/index.js

@@ -4005,6 +4005,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 +4021,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 +4411,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 +4421,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 +4452,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 +4485,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 +4505,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 +4518,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;
 }
 
@@ -5676,15 +5690,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;
@@ -15437,7 +15451,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 +15477,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 +15530,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 };
 }
@@ -16798,6 +16842,183 @@ function runDuplicationDiagnosticRules(ruleMap, opt) {
   return reportDuplication(opt, (o) => analyzeDuplicationRules(ruleMap, o));
 }
 
+// src/table/compile-rule-map.ts
+var DEFAULT_PRECOMPILE_MIN_WORDS = 1024;
+function resolveHostMode(ruleMap, explicit) {
+  return explicit ?? ruleMap.map(([, r]) => r._meta.grammarHostMode).find(Boolean) ?? "ast";
+}
+function resolveTrackLines(ruleMap, explicit) {
+  return explicit === true || ruleMap.some(([, r]) => r._meta.grammarTrackLines === true);
+}
+function withAmbient(ruleMap, opts) {
+  if (opts.trivia === void 0 && opts.scanSkip === void 0) return ruleMap;
+  const wrappers = /* @__PURE__ */ new Map();
+  return ruleMap.map(([name, rule]) => {
+    if (rule._meta.isTrivia) return [name, rule];
+    const addTrivia = opts.trivia !== void 0 && rule._meta.grammarTrivia === void 0;
+    const addScanSkip = opts.scanSkip !== void 0 && rule._meta.grammarScanSkip === void 0;
+    if (!addTrivia && !addScanSkip) return [name, rule];
+    let wrapped = wrappers.get(rule);
+    if (wrapped === void 0) {
+      wrapped = {
+        ...rule,
+        _meta: {
+          ...rule._meta,
+          ...addTrivia ? { grammarTrivia: opts.trivia } : {},
+          ...addScanSkip ? { grammarScanSkip: opts.scanSkip } : {}
+        }
+      };
+      wrappers.set(rule, wrapped);
+    }
+    return [name, wrapped];
+  });
+}
+function compileRuleMapRunnable(ruleMap, opts = {}) {
+  const encoded = encodeForRun(ruleMap, opts);
+  if (encoded === null) return null;
+  const { prog, hostMode, plan } = encoded;
+  const artifact = closureArtifact(prog);
+  const reflection = collectGrammarReflection(ruleMap);
+  return {
+    keys: ruleMap.map(([key]) => key),
+    hostMode,
+    hostBranchElided: hostMode === "ast" && ruleMap.some(([, rule]) => hasDirectBuildDef(rule)),
+    reflection,
+    ...plan === void 0 ? {} : { coverageDefinitions: plan.definitions },
+    // Reflection rides on the map's metadata prototype from birth. Only `compile()`
+    // asks to specialise; every other caller runs the closure artifact.
+    rules: tableRules(opts.specialise === true ? prog : artifact, { [GRAMMAR_REFLECTION]: reflection }),
+    prog: artifact
+  };
+}
+function encodeForRun(ruleMap, opts) {
+  runDuplicationDiagnosticRules(ruleMap, opts.duplication);
+  const encodeMap = withAmbient(ruleMap, opts);
+  const plan = opts.coverage === true ? buildGrammarPlan(
+    encodeMap.map(([, rule]) => rule),
+    Object.fromEntries(encodeMap.filter(([, rule]) => rule._def.tag !== "lazy"))
+  ) : void 0;
+  const hostMode = resolveHostMode(ruleMap, opts.hostMode);
+  const settings = {
+    hostMode,
+    ...resolveTrackLines(ruleMap, opts.trackLines) ? { trackLines: true } : {},
+    ...opts.recovery === true ? { recovery: true } : {},
+    ...plan === void 0 ? {} : { coverage: plan }
+  };
+  try {
+    const { prog, fnSrcs } = encodeTableProgram(Object.fromEntries(encodeMap), settings);
+    return { prog, fnSrcs, hostMode, plan };
+  } catch (e) {
+    opts.refusals?.push(e instanceof Error ? e.message : String(e));
+    return null;
+  }
+}
+function compileRuleMap(ruleMap, opts = {}) {
+  const encoded = encodeForRun(ruleMap, opts);
+  if (encoded === null) return null;
+  const { prog, fnSrcs, hostMode, plan } = encoded;
+  const artifact = closureArtifact(prog);
+  if (artifact.runtimeOnly !== void 0 && artifact.runtimeOnly.length > 0) {
+    opts.refusals?.push(...artifact.runtimeOnly);
+    return null;
+  }
+  const supplied = opts.fnSources;
+  const sources = fnSrcs.map((s, i) => s ?? supplied?.[i] ?? null);
+  if (sources.some((s) => s === null)) {
+    const missing = sources.flatMap((s, i) => s === null ? [i] : []);
+    opts.refusals?.push(
+      `author reducer source missing for prog.fns[${missing.join(", ")}] \u2014 printing would emit \`() => {}\` and the parse would return no value`
+    );
+    return null;
+  }
+  if (supplied !== void 0 && supplied.length > fnSrcs.length) {
+    throw new Error(
+      `compileRuleMap: got ${supplied.length} fnSources for a pool of ${fnSrcs.length}. The list is positional, in prog.fns order, so a longer one means it belongs to a different encode \u2014 and the entries would be silently misassigned.`
+    );
+  }
+  const replacementWithMetadata = (metadataSource, options = {}) => emitTableExpression(artifact, {
+    entry: null,
+    runtimeRef: opts.runtimeRef ?? "tableRules",
+    fnSources: sources,
+    ...options.precompileDefault === true && hostMode === "ast" && prog.lines !== 1 && prog.code.length >= DEFAULT_PRECOMPILE_MIN_WORDS ? { assemblies: defaultAssemblyCfgs(artifact).slice(0, 1) } : {},
+    ...metadataSource === void 0 ? {} : { metadataSource }
+  });
+  const replacement = replacementWithMetadata();
+  return {
+    keys: ruleMap.map(([key]) => key),
+    replacement,
+    replacementWithMetadata,
+    hostMode,
+    // WHAT THE FLAG MEANS is "a DIRECT BUILDER's positioned-CST branch was
+    // dropped", which is what the driver's `'ast' artifact + CST host` check keys
+    // off. `mode === 'ast'` alone over-reports it: an all-STRUCTURAL grammar has no
+    // direct builder, so there was no branch to drop and it stays usable with either
+    // host — the long-standing `node(parser)` contract. Same predicate codegen uses
+    // for its own `hasDirectBuilders` (both read `analysis/commitment.ts`), so the two
+    // lowerings stamp the same artifact rather than disagreeing about it.
+    hostBranchElided: hostMode === "ast" && ruleMap.some(([, rule]) => hasDirectBuildDef(rule)),
+    reflection: collectGrammarReflection(ruleMap),
+    ...plan === void 0 ? {} : { coverageDefinitions: plan.definitions },
+    rules: tableRules(artifact),
+    prog: artifact
+  };
+}
+
+// src/compiler/borrowed-rules.ts
+var nameOf = (c) => c._ruleName;
+function deref(c) {
+  const seen = /* @__PURE__ */ new Set();
+  let current = c;
+  while (current._def.tag === "lazy" && !seen.has(current)) {
+    seen.add(current);
+    try {
+      current = current._def.thunk();
+    } catch {
+      return void 0;
+    }
+  }
+  return current;
+}
+function borrowedRuleReference(map) {
+  const seen = /* @__PURE__ */ new Set();
+  for (const [rule, self] of Object.entries(map)) {
+    let found;
+    const visit = (c) => {
+      if (found !== void 0) return;
+      if (c._def.tag === "lazy") {
+        if (!winnerWrapsReference(self, c)) {
+          const name = nameOf(c);
+          const winner = name !== void 0 && Object.hasOwn(map, name) ? map[name] : void 0;
+          if (winner !== void 0) {
+            if (winnerWrapsReference(winner, c) || deref(c) === deref(winner)) return;
+            found = name;
+            return;
+          }
+        }
+        if (seen.has(c)) return;
+        seen.add(c);
+        let body;
+        try {
+          body = c._def.thunk();
+        } catch {
+          return;
+        }
+        visit(body);
+        return;
+      }
+      if (seen.has(c)) return;
+      seen.add(c);
+      for (const child of childrenOf2(c._def)) visit(child);
+    };
+    visit(self);
+    if (found !== void 0) return { rule, reference: found };
+  }
+  return void 0;
+}
+function borrowedRuleMessage(api, hit) {
+  return `${api}: rule "${hit.rule}" is a rule object borrowed from another grammar, and its graph references "${hit.reference}", which this grammar also defines. The interpreter would keep the other grammar's "${hit.reference}" while a compiled table binds this grammar's, so the two would accept different input. Compose the grammar that defines "${hit.rule}" instead of borrowing its rule object, so its references resolve to this grammar's rules.`;
+}
+
 // src/table/compile.ts
 var ENTRY = "Entry";
 function ownSource(fn) {
@@ -16807,7 +17028,47 @@ function ownSource(fn) {
   const name = fn.name;
   return typeof name === "string" && name.length > 0 && globalThis[name] === fn ? name : null;
 }
-function compile(combinator, mapFnSources, opts = {}) {
+function compile(target, second, third) {
+  if (!isCombinator(target)) return compileMap(target, second);
+  return compileRoot(target, second, third);
+}
+function isCombinator(x) {
+  return typeof x === "object" && x !== null && typeof x.parse === "function" && "_def" in x;
+}
+function compileMap(grammar, opts = {}) {
+  const entries = [];
+  for (const [key, value] of Object.entries(grammar)) {
+    if (!isCombinator(value)) throw new TypeError(`compile: grammar entry "${key}" is not a parser`);
+    if (value._def.tag === "lazy") {
+      try {
+        value._def.thunk();
+      } catch {
+        continue;
+      }
+    }
+    entries.push([key, value]);
+  }
+  const borrowed = borrowedRuleReference(Object.fromEntries(entries));
+  if (borrowed !== void 0) throw new Error(borrowedRuleMessage("compile", borrowed));
+  const drain = beginCompileDegradationDrain();
+  let done = false;
+  try {
+    const refusals = [];
+    const compiled = compileRuleMapRunnable(entries, {
+      ...opts.hostMode ? { hostMode: opts.hostMode } : {},
+      refusals,
+      specialise: true
+    });
+    if (compiled === null) {
+      throw new Error(`compile: this grammar could not be encoded to a table${refusals.length ? ` \u2014 ${refusals.join("; ")}` : ""}`);
+    }
+    done = true;
+    return compiled.rules;
+  } finally {
+    drain(done);
+  }
+}
+function compileRoot(combinator, mapFnSources, opts = {}) {
   runDuplicationDiagnostic(combinator, opts.duplication);
   const drain = beginCompileDegradationDrain();
   let compiled = false;
@@ -16877,29 +17138,6 @@ function compileImpl(combinator, mapFnSources, opts = {}) {
   };
 }
 
-// src/combinators/withCtx.ts
-function withCtx(extra, combinator) {
-  const meta = {
-    firstSet: combinator._meta.firstSet,
-    canMatchNewline: combinator._meta.canMatchNewline,
-    isTrivia: false
-  };
-  return {
-    _tag: "withCtx",
-    _meta: meta,
-    _def: { tag: "withCtx", extra, parser: combinator },
-    parse(input, pos, ctx) {
-      const saved = ctx.state;
-      ctx.state = extra;
-      try {
-        return combinator.parse(input, pos, ctx);
-      } finally {
-        ctx.state = saved;
-      }
-    }
-  };
-}
-
 // src/compiler/ir-serialize.ts
 function childrenOf3(def) {
   switch (def.tag) {
@@ -16996,176 +17234,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();
@@ -17492,127 +17560,8 @@ ${outerDecls.map((d) => "  " + d).join("\n")}
   }
 };
 
-// src/table/compile-rule-map.ts
-var DEFAULT_PRECOMPILE_MIN_WORDS = 1024;
-function resolveHostMode(ruleMap, explicit) {
-  return explicit ?? ruleMap.map(([, r]) => r._meta.grammarHostMode).find(Boolean) ?? "ast";
-}
-function resolveTrackLines(ruleMap, explicit) {
-  return explicit === true || ruleMap.some(([, r]) => r._meta.grammarTrackLines === true);
-}
-function withAmbient(ruleMap, opts) {
-  if (opts.trivia === void 0 && opts.scanSkip === void 0) return ruleMap;
-  const wrappers = /* @__PURE__ */ new Map();
-  return ruleMap.map(([name, rule]) => {
-    if (rule._meta.isTrivia) return [name, rule];
-    const addTrivia = opts.trivia !== void 0 && rule._meta.grammarTrivia === void 0;
-    const addScanSkip = opts.scanSkip !== void 0 && rule._meta.grammarScanSkip === void 0;
-    if (!addTrivia && !addScanSkip) return [name, rule];
-    let wrapped = wrappers.get(rule);
-    if (wrapped === void 0) {
-      wrapped = {
-        ...rule,
-        _meta: {
-          ...rule._meta,
-          ...addTrivia ? { grammarTrivia: opts.trivia } : {},
-          ...addScanSkip ? { grammarScanSkip: opts.scanSkip } : {}
-        }
-      };
-      wrappers.set(rule, wrapped);
-    }
-    return [name, wrapped];
-  });
-}
-function compileRuleMapRunnable(ruleMap, opts = {}) {
-  const encoded = encodeForRun(ruleMap, opts);
-  if (encoded === null) return null;
-  const { prog, hostMode, plan } = encoded;
-  const artifact = closureArtifact(prog);
-  return {
-    keys: ruleMap.map(([key]) => key),
-    hostMode,
-    hostBranchElided: hostMode === "ast" && ruleMap.some(([, rule]) => hasDirectBuildDef(rule)),
-    reflection: collectGrammarReflection(ruleMap),
-    ...plan === void 0 ? {} : { coverageDefinitions: plan.definitions },
-    rules: tableRules(prog),
-    prog: artifact
-  };
-}
-function encodeForRun(ruleMap, opts) {
-  runDuplicationDiagnosticRules(ruleMap, opts.duplication);
-  const encodeMap = withAmbient(ruleMap, opts);
-  const plan = opts.coverage === true ? buildGrammarPlan(
-    encodeMap.map(([, rule]) => rule),
-    Object.fromEntries(encodeMap.filter(([, rule]) => rule._def.tag !== "lazy"))
-  ) : void 0;
-  const hostMode = resolveHostMode(ruleMap, opts.hostMode);
-  const settings = {
-    hostMode,
-    ...resolveTrackLines(ruleMap, opts.trackLines) ? { trackLines: true } : {},
-    ...opts.recovery === true ? { recovery: true } : {},
-    ...plan === void 0 ? {} : { coverage: plan }
-  };
-  try {
-    const { prog, fnSrcs } = encodeTableProgram(Object.fromEntries(encodeMap), settings);
-    return { prog, fnSrcs, hostMode, plan };
-  } catch (e) {
-    opts.refusals?.push(e instanceof Error ? e.message : String(e));
-    return null;
-  }
-}
-function compileRuleMap(ruleMap, opts = {}) {
-  const encoded = encodeForRun(ruleMap, opts);
-  if (encoded === null) return null;
-  const { prog, fnSrcs, hostMode, plan } = encoded;
-  const artifact = closureArtifact(prog);
-  if (artifact.runtimeOnly !== void 0 && artifact.runtimeOnly.length > 0) {
-    opts.refusals?.push(...artifact.runtimeOnly);
-    return null;
-  }
-  const supplied = opts.fnSources;
-  const sources = fnSrcs.map((s, i) => s ?? supplied?.[i] ?? null);
-  if (sources.some((s) => s === null)) {
-    const missing = sources.flatMap((s, i) => s === null ? [i] : []);
-    opts.refusals?.push(
-      `author reducer source missing for prog.fns[${missing.join(", ")}] \u2014 printing would emit \`() => {}\` and the parse would return no value`
-    );
-    return null;
-  }
-  if (supplied !== void 0 && supplied.length > fnSrcs.length) {
-    throw new Error(
-      `compileRuleMap: got ${supplied.length} fnSources for a pool of ${fnSrcs.length}. The list is positional, in prog.fns order, so a longer one means it belongs to a different encode \u2014 and the entries would be silently misassigned.`
-    );
-  }
-  const replacementWithMetadata = (metadataSource, options = {}) => emitTableExpression(artifact, {
-    entry: null,
-    runtimeRef: opts.runtimeRef ?? "tableRules",
-    fnSources: sources,
-    ...options.precompileDefault === true && hostMode === "ast" && prog.lines !== 1 && prog.code.length >= DEFAULT_PRECOMPILE_MIN_WORDS ? { assemblies: defaultAssemblyCfgs(artifact).slice(0, 1) } : {},
-    ...metadataSource === void 0 ? {} : { metadataSource }
-  });
-  const replacement = replacementWithMetadata();
-  return {
-    keys: ruleMap.map(([key]) => key),
-    replacement,
-    replacementWithMetadata,
-    hostMode,
-    // WHAT THE FLAG MEANS is "a DIRECT BUILDER's positioned-CST branch was
-    // dropped", which is what the driver's `'ast' artifact + CST host` check keys
-    // off. `mode === 'ast'` alone over-reports it: an all-STRUCTURAL grammar has no
-    // direct builder, so there was no branch to drop and it stays usable with either
-    // host — the long-standing `node(parser)` contract. Same predicate codegen uses
-    // for its own `hasDirectBuilders` (both read `analysis/commitment.ts`), so the two
-    // lowerings stamp the same artifact rather than disagreeing about it.
-    hostBranchElided: hostMode === "ast" && ruleMap.some(([, rule]) => hasDirectBuildDef(rule)),
-    reflection: collectGrammarReflection(ruleMap),
-    ...plan === void 0 ? {} : { coverageDefinitions: plan.definitions },
-    rules: tableRules(prog),
-    prog: artifact
-  };
-}
-
 // src/version.ts
-var PARSEMAN_VERSION = "0.52.0";
+var PARSEMAN_VERSION = "0.53.0";
 
 // src/compiler/compile-linkable-table.ts
 function isLocal(rule) {
@@ -17680,16 +17629,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 +17652,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 +17666,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 +17707,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 +17830,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 +17874,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 +19142,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 +19847,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);
@@ -20377,7 +20089,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 +20163,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) {