parseman 0.45.0 → 0.47.0

package/dist/combinators/trivia-skip.d.ts

@@ -1,4 +1,4 @@
-import type { ParseContext, ParseFail } from '../types.ts';
+import type { Combinator, ParseContext, ParseFail } from '../types.ts';
 /**
  * Result of scanning trivia: the position after it, plus a `commit()` that
  * records the matched trivia tokens into the active rawChildren collector.
@@ -20,9 +20,17 @@ export type TriviaRollbackMark = {
     log: number;
     rootLog: number;
 };
+export type FastTriviaScanner = (input: string, cur: number) => number;
 /** True when trivia recording must be deferred until the following term commits. */
 export declare function needsDeferredTriviaCommit(ctx: ParseContext): boolean;
 export declare function saveTriviaMark(ctx: ParseContext): TriviaRollbackMark;
+/**
+ * Trivia rollback from SCALAR marks — the allocation-free twin of
+ * `rollbackTrivia`. See `rollbackCstCaptureAt`; `saveTriviaMark` allocates twice
+ * (this wrapper plus the CST mark it delegates to) and the table driver took one
+ * per sequence term and per repetition item.
+ */
+export declare function rollbackTriviaAt(ctx: ParseContext, raw: number, tlog: number, leaves: number, fields: number, errors: number, log: number, rootLog: number): void;
 export declare function rollbackTrivia(ctx: ParseContext, mark: TriviaRollbackMark): void;
 /**
  * A ZERO-WIDTH LOOKAHEAD's mark: everything `saveTriviaMark` covers, plus the
@@ -56,9 +64,40 @@ export declare function advanceTrivia(input: string, cur: number, ctx: ParseCont
  * position after the trivia (or `cur` if none) and a `commit()` to record it.
  */
 export declare function scanTrivia(input: string, cur: number, ctx: ParseContext): TriviaScan;
+/**
+ * Skip trivia at `cur` through an INSTALLED scanner, recording it immediately.
+ *
+ * The table drivers install a scanner only for UNLABELLED trivia with
+ * `trackLines` off, and that is exactly the case where the deferred path's whole
+ * commit is the single row `(cur, end)` — so there is nothing to defer, and the
+ * `{ end, commit }` pair plus its closure that `scanTrivia(…).commit()` allocated
+ * on EVERY sequence term of EVERY capturing grammar buy nothing. This is that
+ * branch with the allocations removed, kept here so recording has one home.
+ */
+export declare function skipTriviaScanned(s: FastTriviaScanner, input: string, cur: number, ctx: ParseContext): number;
 /**
  * Consume trivia at `cur`, recording it immediately. For callers that always
  * accept the trivia between two committed terms (e.g. sequence/sepBy).
  */
 export declare function consumeTrivia(input: string, cur: number, ctx: ParseContext): number;
+/**
+ * End of the trivia run at `cur`, WITHOUT recording any of it.
+ *
+ * The read-only twin of `consumeTrivia`, for a zero-width ASSERTION that wants the
+ * adjacency fact and must leave no trace: the deferred path returns a scan whose
+ * `commit()` is simply never called, so nothing lands in any buffer and there is
+ * nothing to roll back. The following term re-scans the same gap and owns the
+ * commit/rewind decision exactly as if the assertion were not there.
+ */
+export declare function probeTriviaEnd(input: string, cur: number, ctx: ParseContext): number;
+/**
+ * The specialised scanner for a trivia combinator, or null when its shape has no
+ * lowering. Memoized on the combinator.
+ *
+ * EXPORTED because G5's leaf swap needs it at TABLE-BUILD time: the table driver
+ * resolves the scanner once, per trivia entry, and installs the closure at scope
+ * entry — where the generic path called this (a WeakMap lookup) plus a chain of
+ * option branches on EVERY sequence term.
+ */
+export declare function fastTriviaScanner(trivia: Combinator<unknown>): FastTriviaScanner | null;
 //# sourceMappingURL=trivia-skip.d.ts.map

package/dist/combinators/trivia-skip.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"trivia-skip.d.ts","sourceRoot":"","sources":["../../src/combinators/trivia-skip.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAc,YAAY,EAAE,SAAS,EAAe,MAAM,aAAa,CAAA;AAiBnF;;;;;;GAMG;AACH,MAAM,MAAM,UAAU,GAAG;IAAE,GAAG,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,IAAI,CAAA;CAAE,CAAA;AAE5D,iEAAiE;AACjE,MAAM,MAAM,kBAAkB,GAAG;IAAE,GAAG,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAC;IAAC,GAAG,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAAE,CAAA;AAM5I,oFAAoF;AACpF,wBAAgB,yBAAyB,CAAC,GAAG,EAAE,YAAY,GAAG,OAAO,CAEpE;AAED,wBAAgB,cAAc,CAAC,GAAG,EAAE,YAAY,GAAG,kBAAkB,CAWpE;AAED,wBAAgB,cAAc,CAAC,GAAG,EAAE,YAAY,EAAE,IAAI,EAAE,kBAAkB,GAAG,IAAI,CAKhF;AAoBD;;;;;;;;;;;;;;;;GAgBG;AACH,MAAM,MAAM,aAAa,GAAG,kBAAkB,GAAG;IAAE,SAAS,EAAE,SAAS,GAAG,IAAI,CAAA;CAAE,CAAA;AAEhF,wBAAgB,iBAAiB,CAAC,GAAG,EAAE,YAAY,GAAG,aAAa,CAElE;AAED,wBAAgB,iBAAiB,CAAC,GAAG,EAAE,YAAY,EAAE,IAAI,EAAE,aAAa,GAAG,IAAI,CAG9E;AA8DD;;;GAGG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,EAAE,GAAG,EAAE,YAAY,GAAG,MAAM,CAwBnF;AAED;;;GAGG;AACH,wBAAgB,UAAU,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,EAAE,GAAG,EAAE,YAAY,GAAG,UAAU,CA0EpF;AAED;;;GAGG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,EAAE,GAAG,EAAE,YAAY,GAAG,MAAM,CAKnF"}
+{"version":3,"file":"trivia-skip.d.ts","sourceRoot":"","sources":["../../src/combinators/trivia-skip.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,YAAY,EAAE,SAAS,EAAe,MAAM,aAAa,CAAA;AAmBnF;;;;;;GAMG;AACH,MAAM,MAAM,UAAU,GAAG;IAAE,GAAG,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,IAAI,CAAA;CAAE,CAAA;AAE5D,iEAAiE;AACjE,MAAM,MAAM,kBAAkB,GAAG;IAAE,GAAG,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAC;IAAC,GAAG,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAAE,CAAA;AAG5I,MAAM,MAAM,iBAAiB,GAAG,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,KAAK,MAAM,CAAA;AAmBtE,oFAAoF;AACpF,wBAAgB,yBAAyB,CAAC,GAAG,EAAE,YAAY,GAAG,OAAO,CAEpE;AAED,wBAAgB,cAAc,CAAC,GAAG,EAAE,YAAY,GAAG,kBAAkB,CAWpE;AAED;;;;;GAKG;AACH,wBAAgB,gBAAgB,CAC9B,GAAG,EAAE,YAAY,EACjB,GAAG,EAAE,MAAM,EACX,IAAI,EAAE,MAAM,EACZ,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,MAAM,EACd,GAAG,EAAE,MAAM,EACX,OAAO,EAAE,MAAM,GACd,IAAI,CAIN;AAED,wBAAgB,cAAc,CAAC,GAAG,EAAE,YAAY,EAAE,IAAI,EAAE,kBAAkB,GAAG,IAAI,CAKhF;AAiBD;;;;;;;;;;;;;;;;GAgBG;AACH,MAAM,MAAM,aAAa,GAAG,kBAAkB,GAAG;IAAE,SAAS,EAAE,SAAS,GAAG,IAAI,CAAA;CAAE,CAAA;AAEhF,wBAAgB,iBAAiB,CAAC,GAAG,EAAE,YAAY,GAAG,aAAa,CAElE;AAED,wBAAgB,iBAAiB,CAAC,GAAG,EAAE,YAAY,EAAE,IAAI,EAAE,aAAa,GAAG,IAAI,CAG9E;AA0ED;;;GAGG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,EAAE,GAAG,EAAE,YAAY,GAAG,MAAM,CAwBnF;AAED;;;GAGG;AACH,wBAAgB,UAAU,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,EAAE,GAAG,EAAE,YAAY,GAAG,UAAU,CAoGpF;AAED;;;;;;;;;GASG;AACH,wBAAgB,iBAAiB,CAC/B,CAAC,EAAE,iBAAiB,EACpB,KAAK,EAAE,MAAM,EACb,GAAG,EAAE,MAAM,EACX,GAAG,EAAE,YAAY,GAChB,MAAM,CAUR;AAED;;;GAGG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,EAAE,GAAG,EAAE,YAAY,GAAG,MAAM,CAKnF;AAED;;;;;;;;GAQG;AACH,wBAAgB,cAAc,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,EAAE,GAAG,EAAE,YAAY,GAAG,MAAM,CAcpF;AAED;;;;;;;;GAQG;AACH,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,UAAU,CAAC,OAAO,CAAC,GAAG,iBAAiB,GAAG,IAAI,CAevF"}

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

@@ -1 +1 @@
-{"version":3,"file":"withCtx.d.ts","sourceRoot":"","sources":["../../src/combinators/withCtx.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAyC,MAAM,aAAa,CAAA;AAEpF;;;;;;;;;GASG;AACH,wBAAgB,OAAO,CAAC,CAAC,EAAE,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,UAAU,EAAE,UAAU,CAAC,CAAC,CAAC,GAAG,UAAU,CAAC,CAAC,CAAC,CAchF"}
+{"version":3,"file":"withCtx.d.ts","sourceRoot":"","sources":["../../src/combinators/withCtx.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAyC,MAAM,aAAa,CAAA;AAEpF;;;;;;;;;GASG;AACH,wBAAgB,OAAO,CAAC,CAAC,EAAE,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,UAAU,EAAE,UAAU,CAAC,CAAC,CAAC,GAAG,UAAU,CAAC,CAAC,CAAC,CAgChF"}

package/dist/compiler/build-arity.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"build-arity.d.ts","sourceRoot":"","sources":["../../src/compiler/build-arity.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,aAAa,CAAA;AAG5C;;;;;;;;;;GAUG;AAEH,KAAK,OAAO,GAAG,OAAO,CAAC,SAAS,EAAE;IAAE,GAAG,EAAE,MAAM,CAAA;CAAE,CAAC,CAAA;AAElD;;;;;;;;;;GAUG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,OAAO,GAAG,OAAO,CAErD;AAgCD;;;GAGG;AACH,wBAAgB,mBAAmB,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAgC9D;AAoHD;;;;;;;;;;GAUG;AACH,wBAAgB,gBAAgB,CAAC,GAAG,EAAE,OAAO,GAAG,MAAM,CAErD;AAmCD;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,oBAAoB,CAAC,GAAG,EAAE,OAAO,GAAG,MAAM,GAAG,IAAI,CAkBhE;AAED,uFAAuF;AACvF,wBAAgB,kBAAkB,CAAC,GAAG,EAAE,OAAO,GAAG,OAAO,CAKxD;AAED,0FAA0F;AAC1F,wBAAgB,aAAa,CAAC,GAAG,EAAE,OAAO,GAAG,OAAO,CAKnD;AAED,sFAAsF;AACtF,wBAAgB,gBAAgB,CAAC,GAAG,EAAE,OAAO,GAAG,OAAO,CAKtD;AAED,sFAAsF;AACtF,wBAAgB,eAAe,CAAC,GAAG,EAAE,OAAO,GAAG,OAAO,CAKrD"}
+{"version":3,"file":"build-arity.d.ts","sourceRoot":"","sources":["../../src/compiler/build-arity.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,aAAa,CAAA;AAG5C;;;;;;;;;;GAUG;AAEH,KAAK,OAAO,GAAG,OAAO,CAAC,SAAS,EAAE;IAAE,GAAG,EAAE,MAAM,CAAA;CAAE,CAAC,CAAA;AAElD;;;;;;;;;;GAUG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,OAAO,GAAG,OAAO,CAErD;AAgCD;;;GAGG;AACH,wBAAgB,mBAAmB,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAgC9D;AAoHD;;;;;;;;;;GAUG;AACH,wBAAgB,gBAAgB,CAAC,GAAG,EAAE,OAAO,GAAG,MAAM,CAErD;AAqCD;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,oBAAoB,CAAC,GAAG,EAAE,OAAO,GAAG,MAAM,GAAG,IAAI,CAkBhE;AAED,uFAAuF;AACvF,wBAAgB,kBAAkB,CAAC,GAAG,EAAE,OAAO,GAAG,OAAO,CAKxD;AAED,0FAA0F;AAC1F,wBAAgB,aAAa,CAAC,GAAG,EAAE,OAAO,GAAG,OAAO,CAKnD;AAED,sFAAsF;AACtF,wBAAgB,gBAAgB,CAAC,GAAG,EAAE,OAAO,GAAG,OAAO,CAKtD;AAED,sFAAsF;AACtF,wBAAgB,eAAe,CAAC,GAAG,EAAE,OAAO,GAAG,OAAO,CAKrD"}

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

@@ -0,0 +1,104 @@
+import type { Combinator } from '../types.ts';
+import type { HostMode } from '../cst/host-mode.ts';
+import { type GrammarReflection } from '../cst/reflection.ts';
+import { type TableRuleMapOptions } from '../table/compile-rule-map.ts';
+import type { TableProgram, TableRule } from '../table/program.ts';
+/**
+ * `compileLinkable()` FOR THE TABLE LOWERING — `linkable()` produces TABLES too.
+ *
+ * ── WHAT `compileLinkable` ACTUALLY RETURNS, AND WHY NONE OF IT TRANSFERS ─────
+ * `LinkablePieces` is `prelude` / `ruleFns` / `wrappers` / `firstSets` /
+ * `firstSetRecipes` / `nullable` / `deps` / `needsEmptyTl` — every field of it is
+ * SOURCE TEXT or an input to resolving source text. It exists because
+ * source-lowering composition is a TEXTUAL splice: `fusedBody()` concatenates
+ * namespaced preludes, picks a winning `_r_<Name>` per name, and substitutes
+ * `@FS:` dispatch placeholders with the winner's first-set condition. A table has
+ * no text to splice and no placeholders to resolve, so porting those fields would
+ * be porting the mechanism rather than the capability.
+ *
+ * The capability is: a piece must be RUNNABLE on its own, and COMPOSABLE with
+ * other pieces. This artifact carries exactly those two things.
+ *
+ *   `prog` / `rules`  — the piece AS A TABLE. Present whenever the piece is
+ *                       self-contained. This is the ruling: a `linkable()`
+ *                       artifact is a table, not a bag of compiled functions.
+ *   `ir`              — the piece's combinator graph, serialized. This is the
+ *                       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), …)`).
+ *
+ * ── WHY THAT MAKES COMPOSITION THE EASY KIND ─────────────────────────────────
+ * The open question was whether table-to-table composition has to merge two
+ * ALREADY-ENCODED programs — relocating code offsets and merging const, fn,
+ * class, expected and dispatch pools. It does not, as long as every piece
+ * carries its IR: the composer evaluates each piece's IR back to a rule map,
+ * merges the maps (later pieces overriding earlier names, which is what
+ * `compose()` means), and calls `encodeTable` ONCE over the merged map. One
+ * encode, no relocation, and the result is byte-for-byte the table the merged
+ * grammar would have produced if it had been written as one `rules()` call.
+ *
+ * The relocation route is only forced for a piece with NO IR, which is why `ir`
+ * being null is reported here as a first-class fact rather than folded into a
+ * bare `null` return.
+ *
+ * ── THE HOLE CASE IS NOT REFUSED ─────────────────────────────────────────────
+ * A piece that references a rule it does not define (`g.Value` with no
+ * `.define()` — `hasExternalRuleRef`'s SHARED-SHAPE signature) cannot be encoded
+ * standalone: `encodeTable` resolves a `lazy` by calling its thunk, and that
+ * thunk throws. Such a piece gets `prog: null` and `rules: null` and keeps its
+ * `ir`, which is the correct answer rather than a refusal: a shape with a hole
+ * is not a parser in ANY lowering, and it composes through the merge above,
+ * where the hole is filled by whichever piece supplies the name.
+ */
+export type LinkableTableOptions = Omit<TableRuleMapOptions, 'runtimeRef'>;
+export type LinkableTable = {
+    /**
+     * The parseman version that produced this artifact — the same ARTIFACT VERSION
+     * LOCK `LinkablePieces.v` carries, for the same reason: artifacts are
+     * version-locked and the format has no back-compat read path.
+     */
+    v: string;
+    ns: string;
+    /** Local rule names, external (undefined) entries already dropped. */
+    keys: string[];
+    /** Rule names this piece REFERENCES but does not define. */
+    external: string[];
+    /** The piece as a table — null when it has holes (see `external`). */
+    prog: TableProgram | null;
+    /** The runnable form of `prog` — null for the same reason. */
+    rules: Record<string, TableRule> | null;
+    /** The emitted expression for `prog`, or null when there is no `prog`. */
+    replacement: string | null;
+    /**
+     * The piece's combinator graph, serialized — the COMPOSABLE half. Null when
+     * the map cannot be faithfully serialized (a callback with no captured
+     * source); a null here is what would force composition to merge encoded
+     * programs instead of merging rule maps.
+     */
+    ir: string | null;
+    /**
+     * The piece's rule map as LIVE COMBINATORS — present only for an in-process
+     * artifact, never serialized.
+     *
+     * `ir` is the portable composable half, and a grammar BUILT AT RUNTIME often has no
+     * `ir` at all (a live callback has no recoverable source). Such a piece still has to
+     * compose, and in-process it can: the combinators themselves are right there. Without
+     * this the runtime `compose([linkable(g)])` refused a grammar the source lowering
+     * composed happily.
+     */
+    ruleMap: ReadonlyArray<readonly [string, Combinator<unknown>]>;
+    hostMode: HostMode;
+    hostBranchElided: boolean;
+    /**
+     * Whether any rule carries a DIRECT builder, and whether the piece is free of
+     * semantic reduction. `composeLeaf` gates on both, and they are predicates over the
+     * combinator graph rather than products of lowering it — so they belong on the
+     * artifact regardless of which lowering produced it.
+     */
+    hasDirectBuilders: boolean;
+    isRecognitionOnly: boolean;
+    reflection: GrammarReflection;
+};
+export declare function compileLinkableTable(ruleMapArg: ReadonlyArray<readonly [string, Combinator<unknown>]>, ns: string, opts?: LinkableTableOptions): LinkableTable | null;
+//# sourceMappingURL=compile-linkable-table.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"compile-linkable-table.d.ts","sourceRoot":"","sources":["../../src/compiler/compile-linkable-table.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,aAAa,CAAA;AAC7C,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,qBAAqB,CAAA;AAEnD,OAAO,EAA4B,KAAK,iBAAiB,EAAE,MAAM,sBAAsB,CAAA;AAGvF,OAAO,EAA0C,KAAK,mBAAmB,EAAE,MAAM,8BAA8B,CAAA;AAC/G,OAAO,KAAK,EAAE,YAAY,EAAE,SAAS,EAAE,MAAM,qBAAqB,CAAA;AAGlE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+CG;AACH,MAAM,MAAM,oBAAoB,GAAG,IAAI,CAAC,mBAAmB,EAAE,YAAY,CAAC,CAAA;AAE1E,MAAM,MAAM,aAAa,GAAG;IAC1B;;;;OAIG;IACH,CAAC,EAAE,MAAM,CAAA;IACT,EAAE,EAAE,MAAM,CAAA;IACV,sEAAsE;IACtE,IAAI,EAAE,MAAM,EAAE,CAAA;IACd,4DAA4D;IAC5D,QAAQ,EAAE,MAAM,EAAE,CAAA;IAClB,sEAAsE;IACtE,IAAI,EAAE,YAAY,GAAG,IAAI,CAAA;IACzB,8DAA8D;IAC9D,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,SAAS,CAAC,GAAG,IAAI,CAAA;IACvC,0EAA0E;IAC1E,WAAW,EAAE,MAAM,GAAG,IAAI,CAAA;IAC1B;;;;;OAKG;IACH,EAAE,EAAE,MAAM,GAAG,IAAI,CAAA;IACjB;;;;;;;;;OASG;IACH,OAAO,EAAE,aAAa,CAAC,SAAS,CAAC,MAAM,EAAE,UAAU,CAAC,OAAO,CAAC,CAAC,CAAC,CAAA;IAC9D,QAAQ,EAAE,QAAQ,CAAA;IAClB,gBAAgB,EAAE,OAAO,CAAA;IACzB;;;;;OAKG;IACH,iBAAiB,EAAE,OAAO,CAAA;IAC1B,iBAAiB,EAAE,OAAO,CAAA;IAC1B,UAAU,EAAE,iBAAiB,CAAA;CAC9B,CAAA;AAyCD,wBAAgB,oBAAoB,CAClC,UAAU,EAAE,aAAa,CAAC,SAAS,CAAC,MAAM,EAAE,UAAU,CAAC,OAAO,CAAC,CAAC,CAAC,EACjE,EAAE,EAAE,MAAM,EACV,IAAI,GAAE,oBAAyB,GAC9B,aAAa,GAAG,IAAI,CAwDtB"}

package/dist/compiler/degradation.d.ts

@@ -27,8 +27,6 @@ export type DegradationLevel = 'off' | 'warn' | 'error';
 export type DegradationCode = 
 /** A node build's formal parameter list could not be read → all capture tiers kept. */
 'build-arity-unconfirmed'
-/** A node build looks like an `mk(...)` wrapper but did not match → no inline-mk. */
- | 'mk-inline-missed'
 /** A composed/carried piece is an opaque artifact → its rules were not analysed. */
  | 'opaque-artifact'
 /** A coverage-definition request could not read the grammar → empty is NOT a zero. */

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

@@ -1 +1 @@
-{"version":3,"file":"degradation.d.ts","sourceRoot":"","sources":["../../src/compiler/degradation.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AAEH,2BAA2B;AAC3B,MAAM,MAAM,gBAAgB,GAAG,KAAK,GAAG,MAAM,GAAG,OAAO,CAAA;AAEvD,oDAAoD;AACpD,MAAM,MAAM,eAAe;AACzB,uFAAuF;AACrF,yBAAyB;AAC3B,qFAAqF;GACnF,kBAAkB;AACpB,oFAAoF;GAClF,iBAAiB;AACnB,sFAAsF;GACpF,kCAAkC,CAAA;AAEtC;;;;GAIG;AACH,MAAM,MAAM,mBAAmB,GAAG,MAAM,GAAG,MAAM,CAAA;AAEjD,MAAM,MAAM,WAAW,GAAG;IACxB,IAAI,EAAE,eAAe,CAAA;IACrB,QAAQ,EAAE,mBAAmB,CAAA;IAC7B,4FAA4F;IAC5F,KAAK,EAAE,MAAM,CAAA;IACb,oEAAoE;IACpE,OAAO,EAAE,MAAM,CAAA;IACf,iCAAiC;IACjC,UAAU,EAAE,MAAM,CAAA;IAClB,6DAA6D;IAC7D,SAAS,EAAE,MAAM,CAAA;CAClB,CAAA;AAED,+DAA+D;AAC/D,wBAAgB,iBAAiB,CAAC,CAAC,EAAE,WAAW,GAAG,MAAM,CAExD;AAUD,sFAAsF;AACtF,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,SAAS,WAAW,EAAE,GAAG,MAAM,EAAE,CAkBzE;AAkBD,8DAA8D;AAC9D,wBAAgB,uBAAuB,IAAI,IAAI,CAE9C;AAED,4EAA4E;AAC5E,wBAAgB,qBAAqB,IAAI,WAAW,EAAE,CAGrD;AAED,6EAA6E;AAC7E,wBAAgB,uBAAuB,IAAI,MAAM,CAEhD;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,wBAAwB,CAAC,KAAK,EAAE,MAAM,GAAG,WAAW,EAAE,CAOrE;AAED;;;;GAIG;AACH,wBAAgB,uBAAuB,CAAC,QAAQ,CAAC,EAAE,gBAAgB,GAAG,gBAAgB,CAKrF;AA2BD;;;;;;;;;;;;GAYG;AACH,wBAAgB,iBAAiB,CAAC,CAAC,EAAE,WAAW,GAAG,IAAI,CAatD;AAKD;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,4BAA4B,IAAI,CAAC,MAAM,EAAE,OAAO,KAAK,IAAI,CAsBxE;AAED,kDAAkD;AAClD,wBAAgB,oBAAoB,IAAI,IAAI,CAE3C;AAED,qFAAqF;AACrF,wBAAgB,sBAAsB,IAAI,OAAO,CAEhD"}
+{"version":3,"file":"degradation.d.ts","sourceRoot":"","sources":["../../src/compiler/degradation.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AAEH,2BAA2B;AAC3B,MAAM,MAAM,gBAAgB,GAAG,KAAK,GAAG,MAAM,GAAG,OAAO,CAAA;AAEvD,oDAAoD;AACpD,MAAM,MAAM,eAAe;AACzB,uFAAuF;AACrF,yBAAyB;AAC3B,oFAAoF;GAClF,iBAAiB;AACnB,sFAAsF;GACpF,kCAAkC,CAAA;AAEtC;;;;GAIG;AACH,MAAM,MAAM,mBAAmB,GAAG,MAAM,GAAG,MAAM,CAAA;AAEjD,MAAM,MAAM,WAAW,GAAG;IACxB,IAAI,EAAE,eAAe,CAAA;IACrB,QAAQ,EAAE,mBAAmB,CAAA;IAC7B,4FAA4F;IAC5F,KAAK,EAAE,MAAM,CAAA;IACb,oEAAoE;IACpE,OAAO,EAAE,MAAM,CAAA;IACf,iCAAiC;IACjC,UAAU,EAAE,MAAM,CAAA;IAClB,6DAA6D;IAC7D,SAAS,EAAE,MAAM,CAAA;CAClB,CAAA;AAED,+DAA+D;AAC/D,wBAAgB,iBAAiB,CAAC,CAAC,EAAE,WAAW,GAAG,MAAM,CAExD;AAUD,sFAAsF;AACtF,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,SAAS,WAAW,EAAE,GAAG,MAAM,EAAE,CAkBzE;AAkBD,8DAA8D;AAC9D,wBAAgB,uBAAuB,IAAI,IAAI,CAE9C;AAED,4EAA4E;AAC5E,wBAAgB,qBAAqB,IAAI,WAAW,EAAE,CAGrD;AAED,6EAA6E;AAC7E,wBAAgB,uBAAuB,IAAI,MAAM,CAEhD;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,wBAAwB,CAAC,KAAK,EAAE,MAAM,GAAG,WAAW,EAAE,CAOrE;AAED;;;;GAIG;AACH,wBAAgB,uBAAuB,CAAC,QAAQ,CAAC,EAAE,gBAAgB,GAAG,gBAAgB,CAKrF;AA2BD;;;;;;;;;;;;GAYG;AACH,wBAAgB,iBAAiB,CAAC,CAAC,EAAE,WAAW,GAAG,IAAI,CAatD;AAKD;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,4BAA4B,IAAI,CAAC,MAAM,EAAE,OAAO,KAAK,IAAI,CAsBxE;AAED,kDAAkD;AAClD,wBAAgB,oBAAoB,IAAI,IAAI,CAE3C;AAED,qFAAqF;AACrF,wBAAgB,sBAAsB,IAAI,OAAO,CAEhD"}

package/dist/compiler/fields.d.ts

@@ -17,6 +17,19 @@ export declare function parserHasOwnFields(p: Combinator<unknown>, seen?: Set<Co
  * shape returns `true` (keep the frame) — we only elide when provably safe.
  */
 export declare function parserHasTriviaSite(p: Combinator<unknown>, seen?: Set<Combinator<unknown>>): boolean;
+/**
+ * The same question asked of the ROOT trivia log (`_ctx._rootTriviaLog`) instead
+ * of the current node's frame.
+ *
+ * The two differ in exactly one case, and it is the case that matters: a nested
+ * `node()` manages its own FRAME, so nothing inside it reaches the enclosing
+ * frame's log — but the root log is not a frame, and every trivia run inside that
+ * node still lands in it. Reusing `parserHasTriviaSite` for the root sink
+ * therefore under-reports: it dropped the mark on `node()` arms whose trivia does
+ * accumulate, and a parse-tree diff caught it as trivia entries that were no
+ * longer rewound on a failed choice arm (`length: 3` becoming `length: 6`).
+ */
+export declare function parserHasRootTriviaSite(p: Combinator<unknown>, seen?: Set<Combinator<unknown>>): boolean;
 /**
  * Can this node's inner grammar explicitly enable trivia capture? A surrounding
  * node owns the collector, so a nested `parser({ captureTrivia: true })` must

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

@@ -1 +1 @@
-{"version":3,"file":"fields.d.ts","sourceRoot":"","sources":["../../src/compiler/fields.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,QAAQ,EAAE,SAAS,EAAE,MAAM,aAAa,CAAA;AAGlE,KAAK,OAAO,GAAG,OAAO,CAAC,SAAS,EAAE;IAAE,GAAG,EAAE,MAAM,CAAA;CAAE,CAAC,CAAA;AAElD,wBAAgB,gBAAgB,CAAC,GAAG,EAAE,OAAO,GAAG,OAAO,CAKtD;AAED,wBAAgB,kBAAkB,CAAC,CAAC,EAAE,UAAU,CAAC,OAAO,CAAC,EAAE,IAAI,GAAE,GAAG,CAAC,UAAU,CAAC,OAAO,CAAC,CAAa,GAAG,OAAO,CAmC9G;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,mBAAmB,CAAC,CAAC,EAAE,UAAU,CAAC,OAAO,CAAC,EAAE,IAAI,GAAE,GAAG,CAAC,UAAU,CAAC,OAAO,CAAC,CAAa,GAAG,OAAO,CA4C/G;AAED;;;;;GAKG;AACH,wBAAgB,0BAA0B,CAAC,CAAC,EAAE,UAAU,CAAC,OAAO,CAAC,EAAE,IAAI,GAAE,GAAG,CAAC,UAAU,CAAC,OAAO,CAAC,CAAa,GAAG,OAAO,CAmCtH;AAED,wBAAgB,aAAa,CAAC,QAAQ,EAAE,aAAa,CAAC;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,OAAO,CAAC;IAAC,IAAI,EAAE;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,GAAG,EAAE,MAAM,CAAA;KAAE,CAAA;CAAE,CAAC,GAAG,SAAS,GAAG,QAAQ,GAAG,SAAS,CAW/J"}
+{"version":3,"file":"fields.d.ts","sourceRoot":"","sources":["../../src/compiler/fields.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,QAAQ,EAAE,SAAS,EAAE,MAAM,aAAa,CAAA;AAGlE,KAAK,OAAO,GAAG,OAAO,CAAC,SAAS,EAAE;IAAE,GAAG,EAAE,MAAM,CAAA;CAAE,CAAC,CAAA;AAElD,wBAAgB,gBAAgB,CAAC,GAAG,EAAE,OAAO,GAAG,OAAO,CAKtD;AAED,wBAAgB,kBAAkB,CAAC,CAAC,EAAE,UAAU,CAAC,OAAO,CAAC,EAAE,IAAI,GAAE,GAAG,CAAC,UAAU,CAAC,OAAO,CAAC,CAAa,GAAG,OAAO,CAmC9G;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,mBAAmB,CAAC,CAAC,EAAE,UAAU,CAAC,OAAO,CAAC,EAAE,IAAI,GAAE,GAAG,CAAC,UAAU,CAAC,OAAO,CAAC,CAAa,GAAG,OAAO,CAE/G;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,uBAAuB,CAAC,CAAC,EAAE,UAAU,CAAC,OAAO,CAAC,EAAE,IAAI,GAAE,GAAG,CAAC,UAAU,CAAC,OAAO,CAAC,CAAa,GAAG,OAAO,CAEnH;AAyDD;;;;;GAKG;AACH,wBAAgB,0BAA0B,CAAC,CAAC,EAAE,UAAU,CAAC,OAAO,CAAC,EAAE,IAAI,GAAE,GAAG,CAAC,UAAU,CAAC,OAAO,CAAC,CAAa,GAAG,OAAO,CAmCtH;AAED,wBAAgB,aAAa,CAAC,QAAQ,EAAE,aAAa,CAAC;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,OAAO,CAAC;IAAC,IAAI,EAAE;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,GAAG,EAAE,MAAM,CAAA;KAAE,CAAA;CAAE,CAAC,GAAG,SAAS,GAAG,QAAQ,GAAG,SAAS,CAW/J"}

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

@@ -5,13 +5,13 @@ export type GrammarCoverageDefinition = {
 };
 export type GrammarCoveragePlan = {
     definitions: readonly GrammarCoverageDefinition[];
-    choices: WeakMap<Combinator<unknown>, readonly string[]>;
-    dispatches: WeakMap<Combinator<unknown>, readonly string[]>;
+    choices: Map<Combinator<unknown>, readonly string[]>;
+    dispatches: Map<Combinator<unknown>, readonly string[]>;
     /** Trace-only transaction identity. Attempts are not coverage definitions: a
      * rejected transaction must not create a semantic winner or denominator. */
-    attempts: WeakMap<Combinator<unknown>, string>;
-    labels: WeakMap<Combinator<unknown>, readonly string[]>;
-    rules: WeakMap<Combinator<unknown>, string>;
+    attempts: Map<Combinator<unknown>, string>;
+    labels: Map<Combinator<unknown>, readonly string[]>;
+    rules: Map<Combinator<unknown>, string>;
 };
 /** Canonical deterministic IDs for one explicit entry closure, or every public
  * entry in a `rules()` map. Multiple roots share identity maps so a shared

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,OAAO,CAAC,UAAU,CAAC,OAAO,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC,CAAA;IACxD,UAAU,EAAE,OAAO,CAAC,UAAU,CAAC,OAAO,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC,CAAA;IAC3D;gFAC4E;IAC5E,QAAQ,EAAE,OAAO,CAAC,UAAU,CAAC,OAAO,CAAC,EAAE,MAAM,CAAC,CAAA;IAC9C,MAAM,EAAE,OAAO,CAAC,UAAU,CAAC,OAAO,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC,CAAA;IACvD,KAAK,EAAE,OAAO,CAAC,UAAU,CAAC,OAAO,CAAC,EAAE,MAAM,CAAC,CAAA;CAC5C,CAAA;AAmDD;;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,CA2DhK"}
+{"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;AAkDD;;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"}

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;AAsB7E,KAAK,IAAI,GAAG,UAAU,CAAC,OAAO,CAAC,CAAA;AA+E/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,CAyG/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;AAiG/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,CAyG/D"}

package/dist/compiler/linker.d.ts

@@ -1,6 +1,8 @@
-import type { LinkablePieces, HostMode } from './codegen.ts';
+import { type HostMode } from '../cst/host-mode.ts';
+import { type LinkableTable } from './compile-linkable-table.ts';
 import type { BuildHost, Combinator, CstCollapsePredicate, ParseContext, ParseResult } from '../types.ts';
-export declare function linkable(rulesMap: Record<string, Combinator<unknown>>, ns?: string, trivia?: Combinator<unknown>, hostMode?: HostMode): LinkablePieces;
+import type { Runnable } from '../functional/run.ts';
+export declare function linkable(rulesMap: Record<string, Combinator<unknown>>, ns?: string, trivia?: Combinator<unknown>, hostMode?: HostMode): LinkableTable;
 export type CstBuildHostOptions = {
     /**
      * Collapse transparent one-child CST wrapper nodes at build time.
@@ -41,51 +43,33 @@ export declare function cstBuildHost(type: string, children: ReadonlyArray<unkno
 export type FusedRule = (input: string, pos: number, ctx: ParseContext | Record<string, unknown>) => ParseResult<unknown> & {
     readonly value?: unknown;
 };
-/**
- * Restrict a grammar/artifact to `names` plus their transitive rule-dependency
- * closure (à la carte selection) — e.g. Jess taking parts of Less and parts of
- * Sass: `compose([pick(less, ['MixinCall']), pick(sass, ['EachFor']), css])`. A
- * picked rule pulls in every rule name it references, so the result is always
- * self-consistent within the artifact. Accepts a grammar (`rules()` result) or a
- * compiled artifact; returns an artifact for `compose()`.
- */
-export declare function pick(grammar: LinkablePieces | Record<string, Combinator<unknown>>, names: string[]): LinkablePieces;
-/** Restrict a set of linkable pieces to `names` + their transitive dep closure,
- * keeping each surviving rule in the piece that WINS it (later piece wins, matching
- * compose override order). Shared by `pick()` (runtime) and the macro's build-time
- * `pick(...)` handling, so à-la-carte selection is identical on both paths. */
-export declare function pickPieces(pieces: LinkablePieces[], names: string[]): LinkablePieces[];
-/**
- * Build the fused-closure body (shared by the runtime `fuseRules` and the
- * build-time `emitFusedSource`). Returns the closure body (which reads `_env`
- * for any non-inlined callbacks) and the `_env` to bind. In macro mode callbacks
- * are inlined from source, so `_env` is empty and the body is fully static.
- */
-export declare function fusedBody(pieces: LinkablePieces[]): {
-    body: string;
-    env: Record<string, unknown>;
-};
-/** Fuse at RUNTIME (via `new Function`) — used by `compose()` when not compiled
- * by the macro (like `compile()`). The macro path uses `emitFusedSource` instead.
- * Both stamp the host mode from inside `fusedBody`; see `hostModeOfPieces`. */
-export declare function fuseRules(pieces: LinkablePieces[]): Record<string, FusedRule>;
 export { FUSED_HOST_MODE, FUSED_HOST_ELIDED } from '../cst/host-mode.ts';
 /** The host mode a fused/composed rule map was built for. Defaults to 'ast'. */
 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;
 /**
- * Fuse at BUILD time — emit the fused closure as a self-contained SOURCE
- * expression (`(() => { … })()`), with **no `new Function`**. This is what the
- * macro splices in for a `compose([...])` call, so macro output stays eval-free.
- * Requires every callback to be inlined from source (macro mode); throws if any
- * artifact carries runtime-only callback functions.
+ * 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`.
  */
-export declare function emitFusedSource(pieces: LinkablePieces[]): string;
+/** 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. */
+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. */
-export declare function composedPiecesOf(grammar: Record<string, unknown>): ReadonlyArray<LinkablePieces | IRPiece> | undefined;
+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. */
 export type IRPiece = {
@@ -105,10 +89,10 @@ export declare function once<T>(fn: () => T): () => T;
  * Skipping is not the same as having nothing to say. Use `carriedRuleMapsDetailed`
  * 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<LinkablePieces | IRPiece>): Array<Array<[string, Combinator<unknown>]>>;
+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
  * rule count, so a caller can report exactly how much of the grammar went unseen. */
-export declare function carriedRuleMapsDetailed(carried: ReadonlyArray<LinkablePieces | IRPiece>): {
+export declare function carriedRuleMapsDetailed(carried: ReadonlyArray<LinkableTable | IRPiece>): {
     maps: Array<Array<[string, Combinator<unknown>]>>;
     opaque: Array<{
         ns: string;
@@ -138,10 +122,7 @@ export declare function recoverComposedRules(grammar: Record<string, unknown>):
  * `compose()`, or `undefined` when a precompiled opaque artifact participated.
  * This is intentionally internal: callers must not treat it as a parser API. */
 export declare function composedCoverageRules(grammar: Record<string, unknown>): Record<string, Combinator<unknown>> | undefined;
-/** Materialize a carried item to full `LinkablePieces`: an IR piece is evaluated
- * back to a rule map and re-lowered; a full piece passes through. */
-export declare function materializePiece(p: LinkablePieces | IRPiece, trivia?: Combinator<unknown>, captureTerminals?: boolean, hostMode?: HostMode): LinkablePieces;
-export declare function compose(items: Array<LinkablePieces | Record<string, unknown>>, 
+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
@@ -155,9 +136,60 @@ opts?: {
 }): Record<string, FusedRule>;
 /**
  * Compose a terminal grammar. This is for a leaf parser that overlays local
- * semantic reductions on reusable recognition rules. It is macro-only: without
- * macro lowering there is no safe way to keep lexical builders out of carried
- * IR, so it fails rather than falling back to runtime composition.
+ * 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.
+ *
+ * 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.
+ */
+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. */
+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.
  */
-export declare function composeLeaf(_items: Array<LinkablePieces | Record<string, unknown>>): Record<string, FusedRule>;
+export declare function fuseInterpreted(items: Array<LinkableTable | Record<string, unknown>>, opts?: {
+    hostMode?: HostMode;
+}): Record<string, Combinator<unknown>>;
 //# sourceMappingURL=linker.d.ts.map

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/compiler/token-alphabet.d.ts

@@ -0,0 +1,81 @@
+/**
+ * Derived tokenization, part 1: the terminal ALPHABET.
+ *
+ * Parseman knows every terminal in the composed grammar at macro time — every
+ * `literal`, `keywords`, and `regex`. This module walks the combinator graph
+ * and assigns each distinct terminal a small integer TOKEN ID.
+ *
+ * Two things are deliberately separated, because conflating them is what makes
+ * a naive derived scanner useless:
+ *
+ *  - The token ID SPACE is GLOBAL. One id per distinct terminal across the whole
+ *    grammar, so an id can be compared, switched on, and indexed with.
+ *  - The CANDIDATE SET is LOCAL, per decision point. Global maximal munch over
+ *    the whole alphabet is wrong: a css alphabet contains construct-local
+ *    long-run terminals (`[^()]+`, `[^{}/]+`, the `scanTo` raw-prelude runs)
+ *    that swallow the document. Measured: global munch yields SEVEN tokens for a
+ *    123 KB stylesheet. A decision point consults only the terminals that can
+ *    actually start one of its arms.
+ *
+ * Nothing here decides HOW a token is recognized (see `token-scanner.ts`); this
+ * module only decides WHAT the tokens are and WHICH ones each site may see.
+ */
+import type { Combinator } from '../types.ts';
+/** A terminal in the derived alphabet, with its globally assigned id. */
+export type TokenTerminal = {
+    kind: 'literal';
+    id: number;
+    value: string;
+    caseInsensitive: boolean;
+} | {
+    kind: 'keywords';
+    id: number;
+    words: readonly string[];
+    caseInsensitive: boolean;
+    boundary: string | undefined;
+} | {
+    kind: 'regex';
+    id: number;
+    source: string;
+    flags: string;
+};
+/** Reserved ids. Real terminals start at `FIRST_TERMINAL_ID`. */
+export declare const TOK_EOF = 0;
+export declare const TOK_UNKNOWN = 1;
+export declare const TOK_WS = 2;
+export declare const FIRST_TERMINAL_ID = 3;
+export type Alphabet = {
+    terminals: TokenTerminal[];
+    /** Dedup key → id, so the same terminal spelled twice gets ONE id. */
+    byKey: Map<string, number>;
+    /** The combinator that contributed each id (first one wins), for candidate sets. */
+    originOf: Map<number, Combinator<unknown>>;
+};
+/** Direct sub-parsers of a def, resolving a lazy through `resolve` when its own thunk is a hole. */
+export declare function tokenChildren(p: Combinator<unknown>, resolve?: (name: string) => Combinator<unknown> | undefined): Combinator<unknown>[];
+/**
+ * Collect the alphabet over `roots`. Ids are assigned in first-encounter order,
+ * which is stable for a given grammar and therefore safe to switch on.
+ */
+export declare function collectAlphabet(roots: ReadonlyArray<Combinator<unknown>>, resolve?: (name: string) => Combinator<unknown> | undefined): Alphabet;
+/** The id already assigned to this terminal, if it is one. */
+export declare function terminalId(alphabet: Alphabet, p: Combinator<unknown>): number | undefined;
+/**
+ * The LEADING terminal of an arm — the one a decision point would consult. Walks
+ * through the wrappers that do not consume input, and through a sequence's
+ * nullable/zero-width prefix. Returns undefined when the lead is not a single
+ * derived terminal, which is the signal to stay scannerless at that site.
+ */
+export declare function leadTerminal(p: Combinator<unknown>, alphabet: Alphabet, resolve?: (name: string) => Combinator<unknown> | undefined, depth?: number): number | undefined;
+/**
+ * The CANDIDATE SET for one decision point: the leading terminals of its arms.
+ * `complete` is false when any arm's lead is not a derived terminal — that site
+ * must stay scannerless, per-construct, exactly as `scanSkip` and first-set
+ * gating already apply per region rather than globally.
+ */
+export type CandidateSet = {
+    ids: number[];
+    complete: boolean;
+};
+export declare function candidateSet(arms: ReadonlyArray<Combinator<unknown>>, alphabet: Alphabet, resolve?: (name: string) => Combinator<unknown> | undefined): CandidateSet;
+//# sourceMappingURL=token-alphabet.d.ts.map

package/dist/compiler/token-alphabet.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"token-alphabet.d.ts","sourceRoot":"","sources":["../../src/compiler/token-alphabet.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,OAAO,KAAK,EAAE,UAAU,EAAa,MAAM,aAAa,CAAA;AAExD,yEAAyE;AACzE,MAAM,MAAM,aAAa,GACrB;IAAE,IAAI,EAAE,SAAS,CAAC;IAAC,EAAE,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAC;IAAC,eAAe,EAAE,OAAO,CAAA;CAAE,GACxE;IAAE,IAAI,EAAE,UAAU,CAAC;IAAC,EAAE,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,SAAS,MAAM,EAAE,CAAC;IAAC,eAAe,EAAE,OAAO,CAAC;IAAC,QAAQ,EAAE,MAAM,GAAG,SAAS,CAAA;CAAE,GAClH;IAAE,IAAI,EAAE,OAAO,CAAC;IAAC,EAAE,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,CAAA;AAEhE,iEAAiE;AACjE,eAAO,MAAM,OAAO,IAAI,CAAA;AACxB,eAAO,MAAM,WAAW,IAAI,CAAA;AAC5B,eAAO,MAAM,MAAM,IAAI,CAAA;AACvB,eAAO,MAAM,iBAAiB,IAAI,CAAA;AAElC,MAAM,MAAM,QAAQ,GAAG;IACrB,SAAS,EAAE,aAAa,EAAE,CAAA;IAC1B,sEAAsE;IACtE,KAAK,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;IAC1B,oFAAoF;IACpF,QAAQ,EAAE,GAAG,CAAC,MAAM,EAAE,UAAU,CAAC,OAAO,CAAC,CAAC,CAAA;CAC3C,CAAA;AAoBD,oGAAoG;AACpG,wBAAgB,aAAa,CAC3B,CAAC,EAAE,UAAU,CAAC,OAAO,CAAC,EACtB,OAAO,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,UAAU,CAAC,OAAO,CAAC,GAAG,SAAS,GAC1D,UAAU,CAAC,OAAO,CAAC,EAAE,CAuBvB;AAED;;;GAGG;AACH,wBAAgB,eAAe,CAC7B,KAAK,EAAE,aAAa,CAAC,UAAU,CAAC,OAAO,CAAC,CAAC,EACzC,OAAO,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,UAAU,CAAC,OAAO,CAAC,GAAG,SAAS,GAC1D,QAAQ,CAuBV;AAED,8DAA8D;AAC9D,wBAAgB,UAAU,CAAC,QAAQ,EAAE,QAAQ,EAAE,CAAC,EAAE,UAAU,CAAC,OAAO,CAAC,GAAG,MAAM,GAAG,SAAS,CAGzF;AAED;;;;;GAKG;AACH,wBAAgB,YAAY,CAC1B,CAAC,EAAE,UAAU,CAAC,OAAO,CAAC,EACtB,QAAQ,EAAE,QAAQ,EAClB,OAAO,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,UAAU,CAAC,OAAO,CAAC,GAAG,SAAS,EAC3D,KAAK,SAAI,GACR,MAAM,GAAG,SAAS,CA6CpB;AAED;;;;;GAKG;AACH,MAAM,MAAM,YAAY,GAAG;IAAE,GAAG,EAAE,MAAM,EAAE,CAAC;IAAC,QAAQ,EAAE,OAAO,CAAA;CAAE,CAAA;AAE/D,wBAAgB,YAAY,CAC1B,IAAI,EAAE,aAAa,CAAC,UAAU,CAAC,OAAO,CAAC,CAAC,EACxC,QAAQ,EAAE,QAAQ,EAClB,OAAO,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,UAAU,CAAC,OAAO,CAAC,GAAG,SAAS,GAC1D,YAAY,CASd"}