parseman 0.52.0 → 0.53.0

package/dist/combinators/parser.d.ts

@@ -94,5 +94,39 @@ type RuleMapNodeTag<T extends Record<string, Combinator<unknown>>> = {
 type RulesResult<T extends Record<string, Combinator<unknown>>> = T & GrammarWithReflection<RuleMapNodeType<T>, RuleMapNodeTag<T>>;
 export declare function rules<T extends Record<string, Combinator<unknown>>>(factory: (self: any) => T): RulesResult<T>;
 export declare function rules<T extends Record<string, Combinator<unknown>>>(options: RulesOptions, factory: (self: any) => T): RulesResult<T>;
+/**
+ * The recipe a `rules()` result was built from — its factory and options —
+ * non-enumerable, in piece order. Runtime `compose()` links grammars by running
+ * these again against ONE shared namespace (`linkRules`), which is what makes a
+ * composition the same graph as one `rules()` written over every piece. A
+ * composed result carries the concatenated list, so it composes again.
+ */
+export declare const RULES_RECIPE: unique symbol;
+export type RulesRecipe = {
+    readonly factory: (self: Record<string, Combinator<unknown>>) => Record<string, Combinator<unknown>>;
+    readonly options: RulesOptions | undefined;
+};
+/**
+ * How a composition overrides its pieces' own options: the composing grammar's
+ * trivia governs every rule (composing-wins), and an explicit host mode wins
+ * over each piece's.
+ */
+export type LinkOptions = {
+    readonly trivia?: Combinator<unknown> | undefined;
+    readonly hostMode?: HostMode | undefined;
+};
+/**
+ * Build ONE rule map from one or more recipes, run in order against a single
+ * shared namespace, a later recipe's definition winning per rule name.
+ *
+ * `rules()` is the one-recipe case. Runtime `compose()` passes every piece's
+ * recipe plus `link`: each `g.X` in every factory then resolves to the one
+ * composed slot for X, so an override reroutes a base piece's own calls (open
+ * recursion) and every choice computes its first-set dispatch against the
+ * winners. The graph is built fresh, so no shared rule of any piece is touched;
+ * under `link` a winner is always held in a fresh slot, so the stamps below never
+ * land on a combinator a factory returned from module scope either.
+ */
+export declare function linkRules(recipes: readonly RulesRecipe[], link?: LinkOptions): Record<string, Combinator<unknown>>;
 export {};
 //# sourceMappingURL=parser.d.ts.map

package/dist/combinators/parser.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"parser.d.ts","sourceRoot":"","sources":["../../src/combinators/parser.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,aAAa,CAAA;AAC7C,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,qBAAqB,CAAA;AAInD,OAAO,EAA4B,QAAQ,EAAE,SAAS,EAAE,KAAK,qBAAqB,EAAE,MAAM,sBAAsB,CAAA;AAGhH;;;;GAIG;AACH,eAAO,MAAM,UAAU,wBAAwB,CAAA;AA0B/C;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH;;;;;;GAMG;AACH,MAAM,MAAM,YAAY,GAAG;IACzB;8EAC0E;IAC1E,MAAM,CAAC,EAAE,UAAU,CAAC,OAAO,CAAC,GAAG,IAAI,CAAA;IACnC;;;;;OAKG;IACH,QAAQ,CAAC,EAAE,UAAU,CAAC,OAAO,CAAC,EAAE,GAAG,IAAI,CAAA;IACvC;;;;;;;;;;;;;;;;;;;;;;;OAuBG;IACH,QAAQ,CAAC,EAAE,QAAQ,CAAA;IACnB;;;;OAIG;IACH,UAAU,CAAC,EAAE,OAAO,CAAA;CACrB,CAAA;AAKD,KAAK,YAAY,CAAC,CAAC,SAAS,MAAM,EAAE,CAAC,IACnC,CAAC,SAAS;IAAE,QAAQ,CAAC,CAAC,SAAS,CAAC,CAAC,EAAE,MAAM,CAAC,SAAS,MAAM,CAAA;CAAE,GACvD,CAAC,CAAC,CAAC,SAAS,CAAC,KAAK,CAAC,GAAG,CAAC,GAAG,CAAC,GAC3B,CAAC,CAAA;AAEP,KAAK,WAAW,CAAC,CAAC,IAChB,CAAC,SAAS;IAAE,QAAQ,CAAC,CAAC,QAAQ,CAAC,CAAC,EAAE,MAAM,GAAG,SAAS,MAAM,CAAA;CAAE,GAAG,GAAG,GAAG,KAAK,CAAA;AAE5E,KAAK,eAAe,CAAC,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,UAAU,CAAC,OAAO,CAAC,CAAC,IAAI;KACnE,CAAC,IAAI,MAAM,CAAC,GAAG,MAAM,GAAG,YAAY,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC;CAC/C,CAAC,MAAM,CAAC,GAAG,MAAM,CAAC,CAAA;AAEnB,KAAK,cAAc,CAAC,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,UAAU,CAAC,OAAO,CAAC,CAAC,IAAI;KAClE,CAAC,IAAI,MAAM,CAAC,GAAG,MAAM,GAAG,WAAW,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;CAC3C,CAAC,MAAM,CAAC,GAAG,MAAM,CAAC,CAAA;AAEnB,KAAK,WAAW,CAAC,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,UAAU,CAAC,OAAO,CAAC,CAAC,IAC5D,CAAC,GAAG,qBAAqB,CAAC,eAAe,CAAC,CAAC,CAAC,EAAE,cAAc,CAAC,CAAC,CAAC,CAAC,CAAA;AAElE,wBAAgB,KAAK,CAAC,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,UAAU,CAAC,OAAO,CAAC,CAAC,EAAE,OAAO,EAAE,CAAC,IAAI,EAAE,GAAG,KAAK,CAAC,GAAG,WAAW,CAAC,CAAC,CAAC,CAAA;AAC/G,wBAAgB,KAAK,CAAC,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,UAAU,CAAC,OAAO,CAAC,CAAC,EAAE,OAAO,EAAE,YAAY,EAAE,OAAO,EAAE,CAAC,IAAI,EAAE,GAAG,KAAK,CAAC,GAAG,WAAW,CAAC,CAAC,CAAC,CAAA"}
+{"version":3,"file":"parser.d.ts","sourceRoot":"","sources":["../../src/combinators/parser.ts"],"names":[],"mappings":"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"}

package/dist/combinators/ref.d.ts

@@ -1,17 +1,4 @@
 import type { Combinator } from '../types.ts';
-/**
- * Create a forward-declared parser slot for mutually recursive grammars.
- *
- * Because JS evaluates arguments eagerly, you can't reference a variable
- * before it's declared. ref() creates a placeholder you fill in later:
- *
- *   const value = ref<JSONValue>()
- *   const array  = transform(sequence(literal('['), sepBy(value, literal(',')), literal(']')), ...)
- *   const object = transform(sequence(literal('{'), sepBy(pair, literal(',')), literal('}')), ...)
- *   value.define(choice(object, array, string, number, bool, nullVal))
- *
- * Unlike lazy(() => x), you use the ref directly — no wrapping at each call site.
- */
 export declare function ref<T>(): Combinator<T> & {
     define(p: Combinator<T>): void;
 };

package/dist/combinators/ref.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ref.d.ts","sourceRoot":"","sources":["../../src/combinators/ref.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAyC,MAAM,aAAa,CAAA;AAepF;;;;;;;;;;;;GAYG;AACH,wBAAgB,GAAG,CAAC,CAAC,KAAK,UAAU,CAAC,CAAC,CAAC,GAAG;IAAE,MAAM,CAAC,CAAC,EAAE,UAAU,CAAC,CAAC,CAAC,GAAG,IAAI,CAAA;CAAE,CAmG3E"}
+{"version":3,"file":"ref.d.ts","sourceRoot":"","sources":["../../src/combinators/ref.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAyC,MAAM,aAAa,CAAA;AAqCpF,wBAAgB,GAAG,CAAC,CAAC,KAAK,UAAU,CAAC,CAAC,CAAC,GAAG;IAAE,MAAM,CAAC,CAAC,EAAE,UAAU,CAAC,CAAC,CAAC,GAAG,IAAI,CAAA;CAAE,CAmG3E"}

package/dist/compiler/borrowed-rules.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Where the interpreter and a compiled table would bind one reference differently.
+ *
+ * A rule reference (`g.X`) is a slot object. The interpreter follows the slot it
+ * holds. The table encoder binds a reference to the map's rule of the same NAME
+ * (`encode.ts`, `winners`). Within one linked map the two are the same rule. They
+ * differ only for a rule object BORROWED from another grammar (`Entry: base.Entry`):
+ * its graph holds `base`'s own slots, so the interpreter keeps `base`'s `Atom` while
+ * the encoder binds this map's `Atom`. Both parse, and they accept different input.
+ *
+ * ponytail: refuses the pattern instead of rebinding borrowed graphs, which is the
+ * planned follow-up that lets both engines agree.
+ */
+import type { Combinator } from '../types.ts';
+type Comb = Combinator<unknown>;
+/**
+ * The first rule of `map` whose graph reaches another grammar's slot for a rule
+ * `map` also defines — the rule, and the name it references — or `undefined`.
+ */
+export declare function borrowedRuleReference(map: Readonly<Record<string, Comb>>): {
+    rule: string;
+    reference: string;
+} | undefined;
+/** The refusal, worded for the API that refused. */
+export declare function borrowedRuleMessage(api: string, hit: {
+    rule: string;
+    reference: string;
+}): string;
+export {};
+//# sourceMappingURL=borrowed-rules.d.ts.map

package/dist/compiler/borrowed-rules.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"borrowed-rules.d.ts","sourceRoot":"","sources":["../../src/compiler/borrowed-rules.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AACH,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,aAAa,CAAA;AAI7C,KAAK,IAAI,GAAG,UAAU,CAAC,OAAO,CAAC,CAAA;AAe/B;;;GAGG;AACH,wBAAgB,qBAAqB,CACnC,GAAG,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,IAAI,CAAC,CAAC,GAClC;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,SAAS,EAAE,MAAM,CAAA;CAAE,GAAG,SAAS,CAwCjD;AAED,oDAAoD;AACpD,wBAAgB,mBAAmB,CAAC,GAAG,EAAE,MAAM,EAAE,GAAG,EAAE;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,SAAS,EAAE,MAAM,CAAA;CAAE,GAAG,MAAM,CAMjG"}

package/dist/compiler/compile-linkable-table.d.ts

@@ -26,7 +26,7 @@ import type { TableProgram, TableRule } from '../table/program.ts';
  *                       composable half, and it is NOT new machinery: the plugin
  *                       already carries pieces as IR (`plugin/index.ts:1772`) and
  *                       the linker already re-lowers them (`linker.ts:640`,
- *                       `compileLinkable(evalRuleMapIR(p.ir), …)`).
+ *                       `compileLinkable(evalRuleMapIR(p.ir), …)` at build time).
  *
  * ── WHY THAT MAKES COMPOSITION THE EASY KIND ─────────────────────────────────
  * The open question was whether table-to-table composition has to merge two

package/dist/compiler/grammar-coverage-ids.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"grammar-coverage-ids.d.ts","sourceRoot":"","sources":["../../src/compiler/grammar-coverage-ids.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAa,MAAM,aAAa,CAAA;AAGxD,MAAM,MAAM,yBAAyB,GAAG;IAAE,EAAE,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,GAAG,YAAY,GAAG,cAAc,GAAG,OAAO,CAAA;CAAE,CAAA;AAC9G,MAAM,MAAM,mBAAmB,GAAG;IAChC,WAAW,EAAE,SAAS,yBAAyB,EAAE,CAAA;IACjD,OAAO,EAAE,GAAG,CAAC,UAAU,CAAC,OAAO,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC,CAAA;IACpD,UAAU,EAAE,GAAG,CAAC,UAAU,CAAC,OAAO,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC,CAAA;IACvD;gFAC4E;IAC5E,QAAQ,EAAE,GAAG,CAAC,UAAU,CAAC,OAAO,CAAC,EAAE,MAAM,CAAC,CAAA;IAC1C,MAAM,EAAE,GAAG,CAAC,UAAU,CAAC,OAAO,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC,CAAA;IACnD,KAAK,EAAE,GAAG,CAAC,UAAU,CAAC,OAAO,CAAC,EAAE,MAAM,CAAC,CAAA;CACxC,CAAA;AAuDD;;yCAEyC;AACzC,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,UAAU,CAAC,OAAO,CAAC,GAAG,SAAS,UAAU,CAAC,OAAO,CAAC,EAAE,EAAE,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,UAAU,CAAC,OAAO,CAAC,CAAC,GAAG,mBAAmB,CA8DhK"}
+{"version":3,"file":"grammar-coverage-ids.d.ts","sourceRoot":"","sources":["../../src/compiler/grammar-coverage-ids.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAa,MAAM,aAAa,CAAA;AAGxD,MAAM,MAAM,yBAAyB,GAAG;IAAE,EAAE,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,GAAG,YAAY,GAAG,cAAc,GAAG,OAAO,CAAA;CAAE,CAAA;AAC9G,MAAM,MAAM,mBAAmB,GAAG;IAChC,WAAW,EAAE,SAAS,yBAAyB,EAAE,CAAA;IACjD,OAAO,EAAE,GAAG,CAAC,UAAU,CAAC,OAAO,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC,CAAA;IACpD,UAAU,EAAE,GAAG,CAAC,UAAU,CAAC,OAAO,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC,CAAA;IACvD;gFAC4E;IAC5E,QAAQ,EAAE,GAAG,CAAC,UAAU,CAAC,OAAO,CAAC,EAAE,MAAM,CAAC,CAAA;IAC1C,MAAM,EAAE,GAAG,CAAC,UAAU,CAAC,OAAO,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC,CAAA;IACnD,KAAK,EAAE,GAAG,CAAC,UAAU,CAAC,OAAO,CAAC,EAAE,MAAM,CAAC,CAAA;CACxC,CAAA;AA0DD;;yCAEyC;AACzC,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,UAAU,CAAC,OAAO,CAAC,GAAG,SAAS,UAAU,CAAC,OAAO,CAAC,EAAE,EAAE,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,UAAU,CAAC,OAAO,CAAC,CAAC,GAAG,mBAAmB,CAwFhK"}

package/dist/compiler/ir-serialize.d.ts

@@ -20,9 +20,15 @@
 import type { Combinator } from '../types.ts';
 type Comb = Combinator<unknown>;
 export declare function serializeRuleMap(ruleMap: ReadonlyArray<readonly [string, Comb]>, scanSkip?: readonly Comb[] | null): string | null;
-/** Reconstruct a rule map from serialized IR (the inverse of `serializeRuleMap`) —
- * evaluate the combinator-construction expression with every constructor in scope.
- * Used at fuse time (runtime linker + build-time plugin) to re-lower carried IR. */
-export declare function evalRuleMapIR(ir: string): Array<[string, Comb]>;
+/**
+ * ONE plain combinator as IR — what a compiled module carries on an exported terminal
+ * so another module can import it into a grammar (the macro evaluates grammars, and a
+ * compiled parser function is not a combinator it can evaluate).
+ *
+ * No new format: it is `serializeRuleMap`'s `scanSkip` channel over an empty map, which
+ * already serializes rule-free terminals OUTSIDE any factory — exactly this shape. Its
+ * inverse, `evalCombinatorIR`, evaluates source and so lives in `src/plugin/ir-eval.ts`.
+ */
+export declare function serializeCombinator(c: Comb): string | null;
 export {};
 //# sourceMappingURL=ir-serialize.d.ts.map

package/dist/compiler/ir-serialize.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ir-serialize.d.ts","sourceRoot":"","sources":["../../src/compiler/ir-serialize.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AACH,OAAO,KAAK,EAAE,UAAU,EAAkC,MAAM,aAAa,CAAA;AAuB7E,KAAK,IAAI,GAAG,UAAU,CAAC,OAAO,CAAC,CAAA;AAsG/B,wBAAgB,gBAAgB,CAC9B,OAAO,EAAE,aAAa,CAAC,SAAS,CAAC,MAAM,EAAE,IAAI,CAAC,CAAC,EAC/C,QAAQ,CAAC,EAAE,SAAS,IAAI,EAAE,GAAG,IAAI,GAChC,MAAM,GAAG,IAAI,CAUf;AAED;;oFAEoF;AACpF,wBAAgB,aAAa,CAAC,EAAE,EAAE,MAAM,GAAG,KAAK,CAAC,CAAC,MAAM,EAAE,IAAI,CAAC,CAAC,CAkH/D"}
+{"version":3,"file":"ir-serialize.d.ts","sourceRoot":"","sources":["../../src/compiler/ir-serialize.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AACH,OAAO,KAAK,EAAE,UAAU,EAAkC,MAAM,aAAa,CAAA;AAuB7E,KAAK,IAAI,GAAG,UAAU,CAAC,OAAO,CAAC,CAAA;AAsG/B,wBAAgB,gBAAgB,CAC9B,OAAO,EAAE,aAAa,CAAC,SAAS,CAAC,MAAM,EAAE,IAAI,CAAC,CAAC,EAC/C,QAAQ,CAAC,EAAE,SAAS,IAAI,EAAE,GAAG,IAAI,GAChC,MAAM,GAAG,IAAI,CAUf;AAED;;;;;;;;GAQG;AACH,wBAAgB,mBAAmB,CAAC,CAAC,EAAE,IAAI,GAAG,MAAM,GAAG,IAAI,CAE1D"}

package/dist/compiler/linker.d.ts

@@ -48,30 +48,15 @@ export { FUSED_HOST_MODE, FUSED_HOST_ELIDED } from '../cst/host-mode.ts';
 export declare function fusedHostModeOf(registry: object): HostMode;
 /** Whether a fused/composed rule map dropped any direct builder's CST branch. */
 export declare function fusedHostElidedOf(registry: object): boolean;
-/**
- * Compose grammars/artifacts into a runnable parser map — the ONLY public
- * composition entry point. `compose([base, ext, …])`: later entries override
- * earlier ones by rule name, and because fusion re-binds every reference in one
- * shared scope, an override reroutes the base's OWN calls too (open recursion).
- *
- * Each entry may be a **grammar** (a `rules()` result — a map of combinators,
- * linkable-ified here) OR an already-compiled **linkable artifact** (what the
- * macro emits and a package ships). So a package needs no opt-in wrapper to be
- * composable — `compose([importedGrammar, myRules])` just works.
- *
- * The macro compiles `compose([...])` to STATIC fused source (no `new Function`).
- * Called at runtime (no macro, like `compile()`) it fuses via `new Function`.
- */
-/** A composed parser carries its flattened source pieces (non-enumerable) so it
- * can be composed AGAIN — `compose([lessGrammar, delta])` where `lessGrammar` is
- * itself a `compose([...])` result. */
+/** The carried pieces a BUILD-compiled (`compose()` under the macro) grammar
+ * holds: its pieces as serialized IR, re-lowered by the macro plugin at build
+ * time. A runtime composition carries recipes instead (`RULES_RECIPE`). */
 export declare const COMPOSED_PIECES: unique symbol;
-/** The carried pieces a `compose()`/`composeLeaf()` result holds, or `undefined` when
- * the value is not a composed grammar. This is what makes a fused grammar analysable:
- * the pieces are re-lowerable IR even though the fused map itself is only functions. */
+/** The carried pieces a build-compiled composed grammar holds, or `undefined`
+ * when the value is not one. */
 export declare function composedPiecesOf(grammar: Record<string, unknown>): ReadonlyArray<LinkableTable | IRPiece> | undefined;
-/** The compact IR form a grammar carries instead of its lowered rule source: the
- * combinator-construction expression, re-lowered here at fuse time. */
+/** The compact IR form a build-compiled grammar carries: the combinator-construction
+ * expression, re-lowered by the macro plugin at build time. */
 export type IRPiece = {
     ns: string;
     ir: string;
@@ -90,7 +75,7 @@ export declare function once<T>(fn: () => T): () => T;
  * where the skip must be REPORTED — a diagnostic that drops part of the grammar and
  * then returns a clean result is indistinguishable from one that verified it. */
 export declare function carriedRuleMaps(carried: ReadonlyArray<LinkableTable | IRPiece>): Array<Array<[string, Combinator<unknown>]>>;
-/** `carriedRuleMaps` plus the pieces it could NOT re-lower, named by namespace and
+/** `carriedRuleMaps` plus the pieces it could NOT recover, named by namespace and
  * rule count, so a caller can report exactly how much of the grammar went unseen. */
 export declare function carriedRuleMapsDetailed(carried: ReadonlyArray<LinkableTable | IRPiece>): {
     maps: Array<Array<[string, Combinator<unknown>]>>;
@@ -100,16 +85,10 @@ export declare function carriedRuleMapsDetailed(carried: ReadonlyArray<LinkableT
     }>;
 };
 /**
- * Recover the override-winner COMBINATOR map behind a `compose()` result, plus the
- * pieces that could not be recovered.
- *
- * A fused map holds rule functions, so any consumer that walks a combinator graph
- * (gating analysis, the spec/EBNF/railroad model) cannot read it directly. The graph
- * is not lost, though — `compose()` retains re-lowerable IR — so this is the single
- * shared recovery both consumers use. Sharing it is the point: two copies of this
- * logic is how one walker gets fixed and the other silently keeps failing.
- *
- * Returns `undefined` when `grammar` is not a composed result.
+ * Recover the override-winner COMBINATOR map behind a BUILD-compiled composed
+ * grammar, plus the pieces that could not be recovered. A runtime composition is
+ * already a combinator map, so this returns `undefined` for it, exactly as for a
+ * plain `rules()` map: walk it directly.
  */
 export declare function recoverComposedRules(grammar: Record<string, unknown>): {
     rules: Map<string, Combinator<unknown>>;
@@ -118,76 +97,54 @@ export declare function recoverComposedRules(grammar: Record<string, unknown>):
         ruleNames: string[];
     }>;
 } | undefined;
-/** Return the final override-winner combinator map carried by runtime
- * `compose()`, or `undefined` when a precompiled opaque artifact participated.
- * This is intentionally internal: callers must not treat it as a parser API. */
+/** The final override-winner combinator map of a runtime composition, or
+ * `undefined` for anything else. INTERNAL: coverage tooling only. */
 export declare function composedCoverageRules(grammar: Record<string, unknown>): Record<string, Combinator<unknown>> | undefined;
+/** The linked winner map a runtime composition's rule belongs to, or `undefined`.
+ * Lets a coverage run over ONE composed rule name its choices exactly as
+ * `composedGrammarCoverageDefinitions` does. INTERNAL: coverage tooling only. */
+export declare function linkedWinnersOf(rule: Combinator<unknown>): Record<string, Combinator<unknown>> | undefined;
+/**
+ * Compose grammars into ONE parser map — the only public composition entry point.
+ * `compose([base, ext, …])`: a later entry's rule WINS by name, and because every
+ * piece is linked against one namespace, an override reroutes the base's OWN calls
+ * too (open recursion).
+ *
+ * UNDER THE MACRO, `compose([...])` is lowered at BUILD time to a static table.
+ *
+ * AT RUNTIME it only links (docs/design/runtime-and-size-contract.md, rule 2):
+ * every piece's `rules()` factory runs again against one shared namespace, so the
+ * result is exactly the interpreter grammar one `rules()` over all the pieces would
+ * build. It builds no table, evaluates no source and mutates no piece. Linking is
+ * LAZY — the first read of a rule links the whole map once — so `compose()` itself
+ * costs a walk of the items' declared names. For speed, `compile()` a rule of it;
+ * `compile()` specialises when the environment allows and falls back under CSP.
+ */
 export declare function compose(items: Array<LinkableTable | Record<string, unknown>>, 
 /**
- * Compile-time host mode for the fused artifact, same meaning as
- * `compile(g, { hostMode })`. Omit (or `'ast'`) for the eval driver — the fused rules
- * build through the grammar's own `build` callbacks and carry no positioned-CST
- * branch. Pass `'cst'` to fuse a SECOND artifact from the same pieces for the linter /
- * IDE / language-service driver. Two compilations of one grammar, decided here, rather
- * than one artifact deciding per node on every parse.
+ * Host mode for the composed grammar, same meaning as `compile(g, { hostMode })`.
+ * The interpreter routes by host at parse time; this records `'cst'` on every rule
+ * so `run()` can refuse a mismatched host instead of building the wrong tree.
  */
 opts?: {
     hostMode?: HostMode;
-}): Record<string, FusedRule>;
+}): Record<string, Runnable>;
 /**
- * Compose a terminal grammar. This is for a leaf parser that overlays local
- * semantic reductions on reusable recognition rules.
- *
- * Under the macro this lowers to STATIC fused source (functions), exactly like
- * `compose()`. It is still macro-only as a *compiled* artifact: without macro
- * lowering there is no safe way to keep lexical builders out of carried IR, so it
- * never falls back to runtime CODEGEN composition.
- *
- * Called at runtime (no macro) it returns the INTERPRETED fuse of the same items —
- * a combinator map, not a map of compiled functions (`fuseInterpreted`), fused lazily
- * per rule name.
+ * Compose a TERMINAL grammar: a leaf parser that overlays local semantic reductions
+ * on reusable recognition rules. Under the macro it lowers to a static table exactly
+ * like `compose()` and must: there is no runtime codegen fallback.
  *
- * THE RETURN TYPE IS `Runnable`, NOT `FusedRule`, BECAUSE BOTH PATHS ARE REAL. A macro
- * build yields fused functions; an un-macro'd call yields combinators. `Runnable` is
- * already the library's name for "either of those" — it is what `run()` and
- * `parseDoc()` take — so the declared type is TRUE on both paths and a caller needs no
- * narrowing to use the result. This used to declare `Record<string, FusedRule>` and
- * launder the runtime path through an `as unknown as`, which let a caller hold a
- * combinator map while the type promised compiled functions.
- *
- * Do NOT "fix" this by deleting the runtime path. It is load-bearing: the `bench/jess`
- * harness family and two differential-gate legs (`emit-identity-one`,
- * `scan-shape-oracle-one`) import un-macro'd grammar modules and depend on this lazy
- * interpreted fuse, one dialect per process. Whether an un-macro'd `composeLeaf()`
- * should exist at all is a separate, open owner question — but while the gates depend
- * on it, it exists, and the type says so.
+ * At runtime it is the same lazy link as `compose()`, marked terminal. The bench and
+ * differential harnesses import un-macro'd grammar modules and run this path.
  */
 export declare function composeLeaf(items: Array<LinkableTable | Record<string, unknown>>): Record<string, Runnable>;
-/** Whether `map` is an interpreted fuse (a combinator map) rather than a compiled
- * `compose()` result (a map of fused functions). INTERNAL — not re-exported from
- * `src/index.ts`. A consumer never has to ask this question: what it holds is
- * whatever the macro built. Diagnostics that fuse interpreted on purpose do. */
+/** Whether `map` is a runtime composition (a combinator map) rather than a
+ * build-compiled one (a table). INTERNAL — diagnostics only. */
 export declare function isInterpretedFuse(map: object): boolean;
 /**
- * Materialize a composition as a RUNNABLE INTERPRETED rule map — the interpreted
- * counterpart of `compose()`, with identical fuse semantics (later piece wins,
- * override reroutes the base's own calls, composing trivia governs every rule).
- * No codegen, no `new Function`, no macro build step: the result is a plain map of
- * combinators that `run()` / `parseDoc()` accept exactly like a fused map.
- *
- * This is what diagnostics and profiling run against — they must stay in
- * interpreted mode, and before this they could not see a composed grammar at all.
- *
- * Items are the SAME items `compose()`/`composeLeaf()` take: `rules()` maps
- * (the intended input), a prior `fuseInterpreted()` result, or a runtime
- * `compose()` result (re-lowered from its carried IR — note that carried IR cannot
- * materialize direct `node()` builders, so prefer the source maps). A precompiled
- * `linkable()` artifact is rejected: it has no combinator graph.
- *
- * MUTATION: binding a cross-piece hole rewrites the shared placeholder object every
- * call site already holds — that IS how an override reaches a base piece's own
- * calls. A second, DIFFERENT fusion over the same piece objects therefore throws
- * rather than silently rewriting the first one's parser.
+ * The linked interpreter map for a composition, as plain combinators — what
+ * diagnostics and profiling walk. The same link `compose()` makes, forced now.
+ * INTERNAL: not re-exported from `src/index.ts`.
  */
 export declare function fuseInterpreted(items: Array<LinkableTable | Record<string, unknown>>, opts?: {
     hostMode?: HostMode;

package/dist/compiler/linker.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"linker.d.ts","sourceRoot":"","sources":["../../src/compiler/linker.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"linker.d.ts","sourceRoot":"","sources":["../../src/compiler/linker.ts"],"names":[],"mappings":"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"}

package/dist/coverage.d.ts

@@ -68,7 +68,7 @@ export declare function createGrammarTraceSink(options: {
 export declare function createGrammarCoverageCollector(definitions: readonly GrammarCoverageDefinition[]): GrammarCoverageCollector;
 export declare function grammarCoverageDefinitions(entry: Combinator<unknown>, winners?: Record<string, Combinator<unknown>>): readonly GrammarCoverageDefinition[];
 /** Definitions for a runtime `compose()` result, normalized through its final
- * IR winner map. Opaque precompiled pieces intentionally fail rather than
+ * winner map. Anything else — a compiled table, a plain map — fails rather than
  * reporting source-piece identities as though they were final grammar IDs. */
 export declare function composedGrammarCoverageDefinitions(grammar: Record<string, unknown>, startRule: string): readonly GrammarCoverageDefinition[];
 export declare function runWithGrammarCoverage(entry: Runnable, input: string, options?: RunOptions & {

package/dist/coverage.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"coverage.d.ts","sourceRoot":"","sources":["../src/coverage.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"coverage.d.ts","sourceRoot":"","sources":["../src/coverage.ts"],"names":[],"mappings":"AAAA,OAAO,EAAO,KAAK,UAAU,EAAE,KAAK,SAAS,EAAE,KAAK,QAAQ,EAAE,MAAM,qBAAqB,CAAA;AAEzF,OAAO,EAAE,4BAA4B,EAAE,MAAM,uBAAuB,CAAA;AACpE,OAAO,KAAK,EAAE,UAAU,EAAqC,YAAY,EAAe,MAAM,YAAY,CAAA;AAkB1G,OAAO,EAAoB,KAAK,yBAAyB,EAA4B,MAAM,oCAAoC,CAAA;AAE/H,YAAY,EAAE,yBAAyB,EAAE,MAAM,oCAAoC,CAAA;AAcnF,MAAM,MAAM,uBAAuB,GAAG;IACpC,WAAW,EAAE,SAAS,yBAAyB,EAAE,CAAA;IACjD,IAAI,EAAE,SAAS,MAAM,EAAE,CAAA;IACvB,KAAK,EAAE,SAAS,MAAM,EAAE,CAAA;IACxB;;;;;;;;;;OAUG;IACH,KAAK,EAAE,MAAM,CAAA;IACb,kFAAkF;IAClF,UAAU,EAAE,OAAO,CAAA;CACpB,CAAA;AAED,MAAM,MAAM,wBAAwB,GAAG;IACrC,GAAG,CAAC,EAAE,EAAE,MAAM,GAAG,IAAI,CAAA;IACrB,QAAQ,IAAI,uBAAuB,CAAA;IACnC,KAAK,IAAI,IAAI,CAAA;CACd,CAAA;AAED;;2DAE2D;AAC3D,wBAAgB,kCAAkC,CAAC,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,SAAS,yBAAyB,EAAE,CAezH;AAED,MAAM,MAAM,iBAAiB,GAAG,OAAO,GAAG,SAAS,GAAG,UAAU,GAAG,SAAS,GAAG,SAAS,GAAG,WAAW,GAAG,UAAU,CAAA;AACnH,MAAM,MAAM,iBAAiB,GAAG;IAAE,EAAE,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,iBAAiB,CAAC;IAAC,MAAM,EAAE,MAAM,CAAC;IAAC,GAAG,CAAC,EAAE,MAAM,CAAA;CAAE,CAAA;AACtG,MAAM,MAAM,oBAAoB,GAAG;IAAE,MAAM,EAAE,SAAS,iBAAiB,EAAE,CAAC;IAAC,SAAS,EAAE,OAAO,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAAE,CAAA;AAChH,MAAM,MAAM,gBAAgB,GAAG;IAAE,KAAK,CAAC,KAAK,EAAE,iBAAiB,GAAG,IAAI,CAAC;IAAC,QAAQ,IAAI,oBAAoB,CAAA;CAAE,CAAA;AAC1G,+EAA+E;AAC/E,MAAM,MAAM,6BAA6B,GAAG,YAAY,GAAG;IACzD,gBAAgB,CAAC,EAAE,CAAC,EAAE,EAAE,MAAM,KAAK,IAAI,CAAA;IACvC,aAAa,CAAC,EAAE,gBAAgB,CAAA;CACjC,CAAA;AAED,8EAA8E;AAC9E,wBAAgB,mCAAmC,CAAC,OAAO,GAAE;IAC3D,SAAS,CAAC,EAAE,wBAAwB,CAAA;IACpC,KAAK,CAAC,EAAE,gBAAgB,CAAA;IACxB,UAAU,CAAC,EAAE,OAAO,CAAA;IACpB,KAAK,CAAC,EAAE,OAAO,CAAA;CACX,GAAG,6BAA6B,CAOrC;AAED;mEACmE;AACnE,wBAAgB,sBAAsB,CAAC,OAAO,EAAE;IAAE,QAAQ,EAAE,MAAM,CAAC;IAAC,KAAK,CAAC,EAAE,CAAC,KAAK,EAAE,iBAAiB,KAAK,OAAO,GAAG,IAAI,CAAA;CAAE,GAAG,gBAAgB,CAkB5I;AAED,wBAAgB,8BAA8B,CAAC,WAAW,EAAE,SAAS,yBAAyB,EAAE,GAAG,wBAAwB,CAqB1H;AAED,wBAAgB,0BAA0B,CAAC,KAAK,EAAE,UAAU,CAAC,OAAO,CAAC,EAAE,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,UAAU,CAAC,OAAO,CAAC,CAAC,GAAG,SAAS,yBAAyB,EAAE,CAE1J;AAED;;8EAE8E;AAC9E,wBAAgB,kCAAkC,CAAC,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,SAAS,EAAE,MAAM,GAAG,SAAS,yBAAyB,EAAE,CAM5I;AAsND,wBAAgB,sBAAsB,CAAC,KAAK,EAAE,QAAQ,EAAE,KAAK,EAAE,MAAM,EAAE,OAAO,GAAE,UAAU,GAAG;IAAE,SAAS,CAAC,EAAE,wBAAwB,CAAC;IAAC,KAAK,CAAC,EAAE,gBAAgB,CAAA;CAAO,GAAG;IAAE,MAAM,EAAE,SAAS,CAAC;IAAC,QAAQ,EAAE,uBAAuB,CAAA;CAAE,CAS9N"}

package/dist/cst/reflection.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"reflection.d.ts","sourceRoot":"","sources":["../../src/cst/reflection.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAa,MAAM,aAAa,CAAA;AACxD,OAAO,EAAE,kBAAkB,EAAE,QAAQ,EAAE,SAAS,EAAE,MAAM,yBAAyB,CAAA;AAEjF,OAAO,EAAE,kBAAkB,EAAE,SAAS,EAAE,QAAQ,EAAE,MAAM,yBAAyB,CAAA;AAEjF,MAAM,MAAM,qBAAqB,GAAG;IAClC,IAAI,EAAE,MAAM,CAAA;IACZ,IAAI,EAAE,SAAS,MAAM,EAAE,CAAA;CACxB,CAAA;AAED,MAAM,MAAM,iBAAiB,GAAG;IAC9B,KAAK,EAAE,SAAS,qBAAqB,EAAE,CAAA;CACxC,CAAA;AAED,MAAM,MAAM,qBAAqB,CAC/B,QAAQ,SAAS,MAAM,GAAG,MAAM,EAChC,OAAO,SAAS,MAAM,GAAG,MAAM,IAC7B;IACF,QAAQ,CAAC,CAAC,kBAAkB,CAAC,CAAC,EAAE,iBAAiB,CAAA;IACjD,QAAQ,CAAC,CAAC,SAAS,CAAC,CAAC,EAAE,QAAQ,CAAA;IAC/B,QAAQ,CAAC,CAAC,QAAQ,CAAC,CAAC,EAAE,OAAO,CAAA;CAC9B,CAAA;AA0FD,wBAAgB,wBAAwB,CACtC,OAAO,EAAE,aAAa,CAAC,SAAS,CAAC,MAAM,EAAE,UAAU,CAAC,OAAO,CAAC,CAAC,CAAC,EAC9D,IAAI,CAAC,EAAE;IAAE,UAAU,CAAC,EAAE,OAAO,CAAA;CAAE,GAC9B,iBAAiB,CAcnB;AAED,wBAAgB,uBAAuB,CAAC,WAAW,EAAE,SAAS,iBAAiB,EAAE,GAAG,iBAAiB,CAepG;AAED,wBAAgB,mBAAmB,CAAC,OAAO,EAAE,MAAM,GAAG,iBAAiB,GAAG,SAAS,CAElF;AAED,wBAAgB,uBAAuB,CAAC,UAAU,EAAE,iBAAiB,GAAG,MAAM,CAE7E"}
+{"version":3,"file":"reflection.d.ts","sourceRoot":"","sources":["../../src/cst/reflection.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAa,MAAM,aAAa,CAAA;AACxD,OAAO,EAAE,kBAAkB,EAAE,QAAQ,EAAE,SAAS,EAAE,MAAM,yBAAyB,CAAA;AAEjF,OAAO,EAAE,kBAAkB,EAAE,SAAS,EAAE,QAAQ,EAAE,MAAM,yBAAyB,CAAA;AAEjF,MAAM,MAAM,qBAAqB,GAAG;IAClC,IAAI,EAAE,MAAM,CAAA;IACZ,IAAI,EAAE,SAAS,MAAM,EAAE,CAAA;CACxB,CAAA;AAED,MAAM,MAAM,iBAAiB,GAAG;IAC9B,KAAK,EAAE,SAAS,qBAAqB,EAAE,CAAA;CACxC,CAAA;AAED,MAAM,MAAM,qBAAqB,CAC/B,QAAQ,SAAS,MAAM,GAAG,MAAM,EAChC,OAAO,SAAS,MAAM,GAAG,MAAM,IAC7B;IACF,QAAQ,CAAC,CAAC,kBAAkB,CAAC,CAAC,EAAE,iBAAiB,CAAA;IACjD,QAAQ,CAAC,CAAC,SAAS,CAAC,CAAC,EAAE,QAAQ,CAAA;IAC/B,QAAQ,CAAC,CAAC,QAAQ,CAAC,CAAC,EAAE,OAAO,CAAA;CAC9B,CAAA;AA0FD,wBAAgB,wBAAwB,CACtC,OAAO,EAAE,aAAa,CAAC,SAAS,CAAC,MAAM,EAAE,UAAU,CAAC,OAAO,CAAC,CAAC,CAAC,EAC9D,IAAI,CAAC,EAAE;IAAE,UAAU,CAAC,EAAE,OAAO,CAAA;CAAE,GAC9B,iBAAiB,CAmBnB;AAED,wBAAgB,uBAAuB,CAAC,WAAW,EAAE,SAAS,iBAAiB,EAAE,GAAG,iBAAiB,CAepG;AAED,wBAAgB,mBAAmB,CAAC,OAAO,EAAE,MAAM,GAAG,iBAAiB,GAAG,SAAS,CAElF;AAED,wBAAgB,uBAAuB,CAAC,UAAU,EAAE,iBAAiB,GAAG,MAAM,CAE7E"}