parseman 0.46.0 → 0.47.0

package/dist/table/duplication-hook.d.ts

@@ -0,0 +1,32 @@
+import type { Combinator } from '../types.ts';
+import { type DuplicationReport, type DuplicationWarnLevel } from '../analysis/duplication.ts';
+/**
+ * THE DUPLICATION DIAGNOSTIC'S LOWERING HOOK.
+ *
+ * This ran inside the source lowering, so deleting that lowering would have silently
+ * taken it with it — the analysis in `analysis/duplication.ts` would survive and
+ * nothing would call it, which reads exactly like a clean grammar. It is not a
+ * property of how a grammar is lowered, so it lives with the lowering that remains.
+ */
+/**
+ * The `duplication` compile option. A bare level is shorthand for `{ level }`; the
+ * object form adds the `accept` allowlist (finding ids acknowledged as intentional)
+ * and the ranking knobs.
+ *
+ * DEFAULT IS `'off'`, unlike gating. An ungated hot choice is a cliff with no other
+ * symptom; a duplicated subtree is a maintenance cost the author may have chosen.
+ * More to the point, most findings here are CANDIDATES that need an AST check
+ * before they are applied — a diagnostic that prints "candidate, verify" on every
+ * build teaches people to stop reading it. Run it deliberately (a lint script, a
+ * review pass, `PARSEMAN_DUPLICATION=warn`), not on every compile.
+ */
+export type DuplicationOption = DuplicationWarnLevel | {
+    level?: DuplicationWarnLevel;
+    accept?: Iterable<string>;
+    minSize?: number;
+    maxFindings?: number;
+    entryName?: string;
+};
+export declare function runDuplicationDiagnostic<T>(combinator: Combinator<T>, opt: DuplicationOption | undefined): DuplicationReport | undefined;
+export declare function runDuplicationDiagnosticRules(ruleMap: ReadonlyArray<readonly [string, Combinator<unknown>]>, opt: DuplicationOption | undefined): DuplicationReport | undefined;
+//# sourceMappingURL=duplication-hook.d.ts.map

package/dist/table/duplication-hook.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"duplication-hook.d.ts","sourceRoot":"","sources":["../../src/table/duplication-hook.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,aAAa,CAAA;AAC7C,OAAO,EAAmG,KAAK,iBAAiB,EAAE,KAAK,oBAAoB,EAAE,MAAM,4BAA4B,CAAA;AAE/L;;;;;;;GAOG;AACH;;;;;;;;;;;GAWG;AACH,MAAM,MAAM,iBAAiB,GACzB,oBAAoB,GACpB;IAAE,KAAK,CAAC,EAAE,oBAAoB,CAAC;IAAC,MAAM,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,CAAC;IAAC,OAAO,CAAC,EAAE,MAAM,CAAC;IAAC,WAAW,CAAC,EAAE,MAAM,CAAC;IAAC,SAAS,CAAC,EAAE,MAAM,CAAA;CAAE,CAAA;AAsD3H,wBAAgB,wBAAwB,CAAC,CAAC,EAAE,UAAU,EAAE,UAAU,CAAC,CAAC,CAAC,EAAE,GAAG,EAAE,iBAAiB,GAAG,SAAS,GAAG,iBAAiB,GAAG,SAAS,CAExI;AAED,wBAAgB,6BAA6B,CAC3C,OAAO,EAAE,aAAa,CAAC,SAAS,CAAC,MAAM,EAAE,UAAU,CAAC,OAAO,CAAC,CAAC,CAAC,EAC9D,GAAG,EAAE,iBAAiB,GAAG,SAAS,GACjC,iBAAiB,GAAG,SAAS,CAE/B"}

package/dist/table/emit-assembly.d.ts

@@ -0,0 +1,139 @@
+/**
+ * U4 — THE ASSEMBLY, AS EMITTED SOURCE.
+ *
+ * `assemble.ts` lowers each reachable site to a closure. This file lowers the
+ * same sites to TEXT, compiled once per (grammar × option set) at run start.
+ * Semantics are `assemble.ts`'s, site for site; the identity sweep
+ * (`bench/table-lowering-identity.ts`) gates the two against each other and
+ * against the interpreter, and `expected` is inside the digest it compares.
+ *
+ * ## Why text, and not a rearrangement of `assemble.ts`
+ *
+ * V8 attaches inline-cache feedback per FUNCTION LITERAL, not per closure. The
+ * second closure minted from a `CreateClosure` site moves its `FeedbackCell` to
+ * `kManyClosures`, and the vector is shared from then on. `assemble.ts` mints 18
+ * arity-2 `SEQV` closures for `less/stylesheet` from ONE literal, so the two
+ * child call sites inside that literal see 18 unrelated callees and go
+ * megamorphic — a hash lookup in the megamorphic stub cache, no inlining, no
+ * type feedback for the callee body. No rearrangement of a file that MINTS
+ * closures can produce a distinct literal per site. Emitting one
+ * `function _pf<N>` per site can: inside `_pf12` the call `_pf7(…)` names ONE
+ * binding and stays monomorphic.
+ *
+ * ## What may be shared, and what must be emitted
+ *
+ * A body containing a call to another PIECE must be emitted per site, or the
+ * megamorphism relocates from `assemble.ts` into a shared helper and nothing
+ * changes. That is why `nextTerm` is INLINED at every sequence term here rather
+ * than called.
+ *
+ * The rule this file applies is narrower than "no helpers", and it is the whole
+ * criterion: **a shared emitted-scope helper is sound exactly when it takes no
+ * piece as an argument**, because then it has no call site whose feedback a
+ * second caller could pollute. `_skipTrivia` qualifies — it calls the installed
+ * trivia scanner, which is runtime state in either engine. `nextTerm` does not.
+ *
+ * ## Cycles
+ *
+ * `assemble.ts` needs one forwarding stub per recursive site,
+ * `const fwd = (input, pos, ctx) => target!(input, pos, ctx)` — a SINGLE
+ * function literal that every back-edge in the process funnels through.
+ * Emitted `function` declarations hoist, so a back-edge here is a direct name
+ * reference and the stub does not exist.
+ *
+ * ## Refusal
+ *
+ * Any construct not lowered raises `Unemittable`, naming it. `assemble.ts`
+ * catches that, RECORDS it on the assembly, and falls back to the closure path.
+ * The fallback is observable (`Assembly.emitRefusal`): a silent one would make
+ * a permanently slow path indistinguishable from a fast one, which is exactly
+ * what `encode.ts:1208-1213` refuses to allow for `OP_LIVE`.
+ */
+import type { ParseContext } from '../types.ts';
+import type { ResolvedClass, ResolvedTable, TableProgram } from './program.ts';
+/** What the compiled factory hands back — the emitted twin of `Assembly`. */
+export type EmittedPiece = (input: string, pos: number, ctx: ParseContext) => unknown;
+export type EmittedAssembly = {
+    readonly pieces: Record<string, EmittedPiece>;
+    /** Sites named for `subtreeComb` — the scan pool and the scan-skip sets. */
+    readonly byIp: Record<number, EmittedPiece | undefined>;
+    readonly end: () => number;
+    readonly begin: (ctx: ParseContext) => void;
+    readonly finish: () => void;
+};
+/** The `new Function` result. Its parameters are `EMITTED_PARAMS`, in order. */
+export type EmittedFactory = (...args: readonly unknown[]) => EmittedAssembly;
+/** A construct the emitter does not lower. Names the CONSTRUCT, never a type. */
+export declare class Unemittable extends Error {
+    readonly construct: string;
+    constructor(construct: string);
+}
+/**
+ * The names the emitted scope is closed over, in the order the factory takes
+ * them. ONE list, so the parameter list and the argument list cannot drift — a
+ * mismatch binds the wrong function to the wrong name and yields a parser that
+ * runs and is wrong, which no type in this file would catch.
+ */
+export declare const EMITTED_PARAMS: readonly ['EC', 'FAIL', 'K', 'FX', 'FNS', 'MASK', 'CLS', 'AFX', 'TRIVIA', 'TRIVIALABELS', 'TRIVIASCAN', 'SCANS', 'DISP', 'DSP', 'EMPTY_FX', 'EMPTY_CH', 'EMPTY_TLOG', 'EMPTY_TL', 'cstCaptureActive', 'pushCstLeaf', 'pushCstChild', 'rollbackTriviaAt', 'failAt', 'classHas', 'consumeTrivia', 'buildFieldMap', 'projectChild', 'unwrapChild', 'demoteCapturedToRaw', 'cstLeavesLen', 'skipTriviaScanned', 'needsDeferredTriviaCommit', 'scanTrivia', 'advanceTrivia', 'refuseUnclassifiedRootScope', 'spanLines', 'rawEntry', 'lead', 'asciiFoldKey', 'ROUTED_FX', 'SENTS', 'matchesAt', 'recoverScan', 'orSentinel', 'captureError'];
+/**
+ * THE THREE POOLS, SAID AS INDICES INTO THE PROGRAM.
+ *
+ * The pools themselves are `Uint32Array`s, `{ascii, hi}` class objects and
+ * string arrays — printable, but at 129 words per mask and 128 bytes per class
+ * they would dwarf the table they belong to. Every entry is already IN the
+ * program: a class is `cc[i]`, an arm's expected set is `fx[i]`, and a mask is a
+ * pure function of its class row. So the plan is three arrays of small integers,
+ * and `rebuildPools` turns it back into the pools with allocation only — no
+ * string building, and in particular no `Function` constructor.
+ *
+ * This is what lets the macro pre-compile an assembly: the FACTORY is printed as
+ * a real function literal, and its data arguments are rebuilt from this.
+ */
+export type PoolPlan = {
+    /** Per `CLS` row: the `cc` index of each entry, `-1` for a null (ungated) arm. */
+    readonly classes: readonly (readonly number[])[];
+    /** Per `AFX` row: the `fx` index of each arm's expected set. */
+    readonly armExpected: readonly (readonly number[])[];
+    /** Per `MASK` row: the `CLS` index the mask is computed from. */
+    readonly masks: readonly number[];
+};
+/** Everything the compiled factory needs bound, beside the emitted text. */
+export type EmitResult = {
+    readonly source: string;
+    /** Site offsets the emitter reached — the emitted twin of `Assembly.reached`. */
+    readonly reached: ReadonlySet<number>;
+    /** Hoisted per-choice candidate masks, in `MASK` order. */
+    readonly masks: readonly Uint32Array[];
+    /** Hoisted per-arm class gates, in `CLS` order. */
+    readonly classes: readonly (ResolvedClass | null)[][];
+    /** Hoisted per-arm expected sets, in `AFX` order. */
+    readonly armExpected: readonly (readonly string[])[][];
+    /** The same three pools as indices, for a build-time emitter. */
+    readonly plan: PoolPlan;
+};
+/**
+ * Rebuild the three pools a pre-compiled factory takes, from the resolved table
+ * and the plan the emitter printed. Allocation only.
+ */
+export declare function rebuildPools(cc: readonly ResolvedClass[], fx: readonly (readonly string[])[], plan: PoolPlan): {
+    masks: Uint32Array[];
+    classes: (ResolvedClass | null)[][];
+    armExpected: (readonly string[])[][];
+};
+/**
+ * Emit the whole assembly for one resolved table and one option set.
+ *
+ * Throws `Unemittable` for any construct not lowered. It does NOT compile the
+ * text — `assemble.ts` does — so a refusal and a compile failure stay two
+ * distinguishable outcomes at the call site.
+ */
+export declare function emitAssemblySource(t: ResolvedTable, prog: TableProgram, cfg: {
+    hostCst: boolean;
+    hostReadsChildren?: boolean;
+    hostCaptureTrivia?: ((type: string) => boolean) | undefined;
+    trackLines: boolean;
+    tolerant: boolean;
+    coverage: boolean;
+    probe: boolean;
+}, extraIps?: readonly number[]): EmitResult;
+//# sourceMappingURL=emit-assembly.d.ts.map

package/dist/table/emit-assembly.d.ts.map

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

package/dist/table/emit.d.ts

@@ -0,0 +1,113 @@
+import type { FoldedProgram, TableProgram } from './program.ts';
+import { type RunCfg } from './assemble.ts';
+/**
+ * THE OPTION SETS A BUILD PRE-COMPILES, by default.
+ *
+ * `hostCst` and `trackLines` are ENCODE settings (`TableSettings`), so a program
+ * already fixes them — a table encoded for `hostMode: 'ast'` has no CST rows to
+ * select. `tolerant` is a per-CALL option (`run({ tolerant })`), so both answers
+ * are live for one artifact and both are emitted.
+ *
+ * `coverage` is never emitted: `emitAssemblySource` refuses a coverage assembly
+ * outright, so there is nothing to pre-compile and the closure engine is the
+ * correct answer. `probe` (`completionsAt`) is not emitted by default either —
+ * it is a language-service path, cold, and doubling every artifact for it is a
+ * cost with no reader. Both fall to the closure engine, which is OBSERVABLE on
+ * `Assembly.emitRefusal` rather than silent.
+ *
+ * Overgeneration is deliberate: an emitted variant nobody selects costs bytes
+ * and zero runtime.
+ */
+export declare function defaultAssemblyCfgs(prog: TableProgram): RunCfg[];
+export type EmitOptions = {
+    /** Name of the exported binding. */
+    readonly name?: string;
+    /**
+     * Optional experimental emitted factories — see `defaultAssemblyCfgs`.
+     *
+     * The normal compiler and macro both emit `a:[]`: that is the canonical
+     * compact closure artifact and it never reaches the `Function` constructor.
+     * Supplying factories here is a low-level serialization experiment, not a
+     * second normal compilation path; it is not used by the macro plugin.
+     */
+    readonly assemblies?: readonly RunCfg[];
+    /**
+     * Sources for the author callbacks, in `prog.fns` order. A build has these
+     * from the module it is lowering; pass `undefined` to emit a placeholder and
+     * measure only the machinery.
+     */
+    readonly fnSources?: readonly string[];
+    /** Import specifier for the shared driver. */
+    readonly runtime?: string;
+    /**
+     * NAME of the driver export to import from `runtime`, defaulting to the
+     * shipped one.
+     *
+     * `runtime` alone was not enough to say which engine a module binds, and that
+     * gap was load-bearing: `parseman/table` exports the ASSEMBLER as `tableRules`
+     * while `src/table/exec.ts` exports the reference INTERPRETER under a name
+     * that used to be identical. Pointing `runtime` at `exec.ts` therefore emitted
+     * a module that read as the shipped artifact and ran the reference engine.
+     * The reference export is now `execRules`, and a differential that wants it
+     * has to SAY so here — which is the whole point of separating the names.
+     */
+    readonly runtimeRef?: string;
+};
+export declare function emitTableModule(prog: TableProgram, opts?: EmitOptions): string;
+export type ExpressionEmitOptions = EmitOptions & {
+    /**
+     * Which rule the expression evaluates to, or `null` for THE WHOLE RULE MAP.
+     *
+     * `null` is what a `rules()` call site needs: its initialiser evaluates to the
+     * `{ name: fn, … }` object, exactly what `tableRules(…)` already returns, so
+     * the map form is the expression WITHOUT the trailing index — not a second
+     * emitter. `compileRuleMap`'s replacement has the same shape and the same
+     * splice point, which is what makes the two lowerings interchangeable there.
+     */
+    readonly entry?: string | null;
+    /** Static metadata object passed to `tableRules` as its second argument. */
+    readonly metadataSource?: string;
+};
+/**
+ * The table as an EXPRESSION rather than a module — for an inliner that replaces
+ * a grammar's initialiser in place.
+ *
+ * It references `tableRules` by name instead of carrying the driver, so it is
+ * not self-contained. That is deliberate and it is not a cost: the reference
+ * resolves to `parseman/table`, a package the consumer already depends on for
+ * `run()`. The alternative — inlining the driver per grammar — is precisely the
+ * 2.10 MB that this lowering exists to replace with 0.56 MB.
+ *
+ * The caller owns the import. `emitTableModule` writes its own; an inliner
+ * splicing this into existing source must ensure the binding is in scope.
+ */
+export declare function emitTableExpression(prog: TableProgram, opts?: ExpressionEmitOptions): string;
+export type FoldedEmitOptions = EmitOptions & {
+    /**
+     * Exported binding per variant name. A variant with no entry is still carried
+     * in the table and simply not given a name of its own.
+     */
+    readonly names?: Readonly<Record<string, string>>;
+};
+/**
+ * Print a FOLDED program: one base table, plus the row edits per variant.
+ *
+ * This is G4's deliverable. The four `trackLines` x `hostMode` artifacts a
+ * dialect ships stop being four near-copies of one table and become one table
+ * and three short lists of `(offset, word)` pairs — which is what the measured
+ * difference between them actually is. The reducer pool, the const pool, the
+ * char classes, the expected sets, the dispatch tables and the rule index are
+ * printed ONCE, because they are byte-identical in every variant.
+ *
+ * The base's own `l`/`h` scalars are NOT printed: every variant, base included,
+ * carries its own on its delta, so no variant inherits the base's line-tracking
+ * or host mode by accident.
+ */
+export declare function emitFoldedModule(folded: FoldedProgram, opts?: FoldedEmitOptions): string;
+/**
+ * The part of the emitted module that is MACHINERY — the table, excluding the
+ * author's reducers, which every lowering must emit alike. This is the number
+ * that is comparable to codegen's per-rule cost.
+ */
+export declare function emitTableOnly(prog: TableProgram): string;
+//# sourceMappingURL=emit.d.ts.map

package/dist/table/emit.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"emit.d.ts","sourceRoot":"","sources":["../../src/table/emit.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,YAAY,EAAE,MAAM,cAAc,CAAA;AAG/D,OAAO,EAAU,KAAK,MAAM,EAAE,MAAM,eAAe,CAAA;AAkGnD;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,YAAY,GAAG,MAAM,EAAE,CAMhE;AAkFD,MAAM,MAAM,WAAW,GAAG;IACxB,oCAAoC;IACpC,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAA;IACtB;;;;;;;OAOG;IACH,QAAQ,CAAC,UAAU,CAAC,EAAE,SAAS,MAAM,EAAE,CAAA;IACvC;;;;OAIG;IACH,QAAQ,CAAC,SAAS,CAAC,EAAE,SAAS,MAAM,EAAE,CAAA;IACtC,8CAA8C;IAC9C,QAAQ,CAAC,OAAO,CAAC,EAAE,MAAM,CAAA;IACzB;;;;;;;;;;;OAWG;IACH,QAAQ,CAAC,UAAU,CAAC,EAAE,MAAM,CAAA;CAC7B,CAAA;AAiED,wBAAgB,eAAe,CAAC,IAAI,EAAE,YAAY,EAAE,IAAI,GAAE,WAAgB,GAAG,MAAM,CAYlF;AAED,MAAM,MAAM,qBAAqB,GAAG,WAAW,GAAG;IAChD;;;;;;;;OAQG;IACH,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;IAC9B,4EAA4E;IAC5E,QAAQ,CAAC,cAAc,CAAC,EAAE,MAAM,CAAA;CACjC,CAAA;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,YAAY,EAAE,IAAI,GAAE,qBAA0B,GAAG,MAAM,CAWhG;AAED,MAAM,MAAM,iBAAiB,GAAG,WAAW,GAAG;IAC5C;;;OAGG;IACH,QAAQ,CAAC,KAAK,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAA;CAClD,CAAA;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,aAAa,EAAE,IAAI,GAAE,iBAAsB,GAAG,MAAM,CA0B5F;AAED;;;;GAIG;AACH,wBAAgB,aAAa,CAAC,IAAI,EAAE,YAAY,GAAG,MAAM,CAExD"}

package/dist/table/encode-baseline.d.ts

@@ -0,0 +1,16 @@
+import type { Combinator } from '../types.ts';
+import type { TableProgram } from './program.ts';
+/** Settings that select the TABLE'S CONTENTS. They never reach the driver. */
+export type TableSettings = {
+    readonly hostMode?: 'ast' | 'cst';
+    readonly trackLines?: boolean;
+};
+/**
+ * Encode a rule map into ONE table for ONE settings pair.
+ *
+ * Two settings pairs give two programs and therefore two cached reference
+ * tables; the driver that reads them is the same function in both cases and
+ * never sees `settings`.
+ */
+export declare function encodeTableBaseline(ruleMap: Record<string, Combinator<unknown>>, settings?: TableSettings): TableProgram;
+//# sourceMappingURL=encode-baseline.d.ts.map

package/dist/table/encode-baseline.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"encode-baseline.d.ts","sourceRoot":"","sources":["../../src/table/encode-baseline.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAuB,MAAM,aAAa,CAAA;AASlE,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,cAAc,CAAA;AAQhD,8EAA8E;AAC9E,MAAM,MAAM,aAAa,GAAG;IAC1B,QAAQ,CAAC,QAAQ,CAAC,EAAE,KAAK,GAAG,KAAK,CAAA;IACjC,QAAQ,CAAC,UAAU,CAAC,EAAE,OAAO,CAAA;CAC9B,CAAA;AAgTD;;;;;;GAMG;AACH,wBAAgB,mBAAmB,CACjC,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,UAAU,CAAC,OAAO,CAAC,CAAC,EAC5C,QAAQ,GAAE,aAAkB,GAC3B,YAAY,CAId"}

package/dist/table/encode.d.ts

@@ -0,0 +1,71 @@
+import type { Combinator } from '../types.ts';
+import type { TableProgram } from './program.ts';
+import type { GrammarCoveragePlan } from '../compiler/grammar-coverage-ids.ts';
+/** Raised when a construct has no opcode yet. Prototype scope is explicit. */
+export declare class UnsupportedConstruct extends Error {
+    readonly tag: string;
+    constructor(tag: string);
+}
+/** Settings that select the TABLE'S CONTENTS. They never reach the driver. */
+export type TableSettings = {
+    readonly hostMode?: 'ast' | 'cst';
+    readonly trackLines?: boolean;
+    /**
+     * ACCEPTED AND IGNORED. RECOVERY IS ALWAYS LOWERED (owner ruling).
+     *
+     * It used to be opt-in because the sync sentinel a list resyncs to is derived
+     * from grammar structure and so has to be known before the table exists — a
+     * BUILD setting for the same reason `hostMode` is. The consequence was a
+     * `CompiledParser` whose `parseWithErrors()` THREW unless the caller had
+     * happened to pass a flag `compile()` does not require, which is a contract
+     * break against the source lowering, not a trade.
+     *
+     * The cost of always lowering it is the extra rows, measured on the emitted
+     * module: json 1,081 → 1,214 B (+12.3%), graphql 2,925 → 3,397 B (+16.1%).
+     * Against codegen's 15,138 B for the same json root the table is still ~12×
+     * smaller, so the size argument for making it optional no longer holds.
+     *
+     * LOWERING RECOVERY IS NOT RUNNING IT. Every recovery path stays gated on
+     * `ctx._tolerant` — the same dormancy the source lowering emits
+     * (`codegen.ts:3153`) and the interpreter tests (`repeat.ts:163`) — so a strict
+     * parse is strict, and `test/parity/table-recovery-always.test.ts` pins that.
+     *
+     * The field is kept rather than deleted so `compile` stays signature-
+     * compatible with `compile()`, whose `{ recovery: true }` is real. Passing it
+     * is harmless; passing `false` does NOT switch recovery off, and saying so here
+     * is the point — a setting that silently means nothing is the defect class this
+     * project keeps finding.
+     */
+    readonly recovery?: boolean;
+    /**
+     * THE COVERAGE PLAN, when this table is being encoded for grammar coverage.
+     *
+     * Its maps are keyed by COMBINATOR IDENTITY, which is what makes threading the
+     * plan through the encoder exact: at the moment a choice, dispatch, label or
+     * rule body is laid down, the combinator being encoded IS the key, so no code
+     * offset has to be matched back to a structural path after the fact. `OP_COV`
+     * rows go in beside those sites and the plan's definitions become `prog.cov`.
+     *
+     * A plan is a BUILD input for the same reason `hostMode` is: the rows either
+     * exist in the table or they do not, and no per-parse flag can conjure them.
+     * Which of the resulting assemblies actually counts is the separate,
+     * assembly-selected question `RunCfg.coverage` answers.
+     */
+    readonly coverage?: GrammarCoveragePlan;
+};
+export declare function encodeTable(ruleMap: Record<string, Combinator<unknown>>, settings?: TableSettings): TableProgram;
+/**
+ * `encodeTable` PLUS the reducer sources, for a caller that must PRINT the table.
+ *
+ * The sources are not on `TableProgram` because they are not data the driver
+ * reads and must never travel in an emitted artifact; they are the printer's
+ * input, in `prog.fns` order. A build that lowers macro-evaluated combinators
+ * gets a real source per entry (`fnSrc` / `buildSrc` / `predSrc` / `gateSrcs`,
+ * set by the macro evaluator); a runtime caller gets `null`s and must therefore
+ * refuse to print rather than emit `() => {}` placeholders.
+ */
+export declare function encodeTableProgram(ruleMap: Record<string, Combinator<unknown>>, settings?: TableSettings): {
+    prog: TableProgram;
+    fnSrcs: (string | null)[];
+};
+//# sourceMappingURL=encode.d.ts.map

package/dist/table/encode.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"encode.d.ts","sourceRoot":"","sources":["../../src/table/encode.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAgB,UAAU,EAAuB,MAAM,aAAa,CAAA;AAqBhF,OAAO,KAAK,EAAsC,YAAY,EAAc,MAAM,cAAc,CAAA;AAEhG,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,qCAAqC,CAAA;AAoD9E,8EAA8E;AAC9E,qBAAa,oBAAqB,SAAQ,KAAK;IAC7C,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAA;IACpB,YAAY,GAAG,EAAE,MAAM,EAAqE;CAC7F;AAED,8EAA8E;AAC9E,MAAM,MAAM,aAAa,GAAG;IAC1B,QAAQ,CAAC,QAAQ,CAAC,EAAE,KAAK,GAAG,KAAK,CAAA;IACjC,QAAQ,CAAC,UAAU,CAAC,EAAE,OAAO,CAAA;IAC7B;;;;;;;;;;;;;;;;;;;;;;;;;OAyBG;IACH,QAAQ,CAAC,QAAQ,CAAC,EAAE,OAAO,CAAA;IAC3B;;;;;;;;;;;;;OAaG;IACH,QAAQ,CAAC,QAAQ,CAAC,EAAE,mBAAmB,CAAA;CACxC,CAAA;AAm3CD,wBAAgB,WAAW,CACzB,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,UAAU,CAAC,OAAO,CAAC,CAAC,EAC5C,QAAQ,GAAE,aAAkB,GAC3B,YAAY,CAEd;AAED;;;;;;;;;GASG;AACH,wBAAgB,kBAAkB,CAChC,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,UAAU,CAAC,OAAO,CAAC,CAAC,EAC5C,QAAQ,GAAE,aAAkB,GAC3B;IAAE,IAAI,EAAE,YAAY,CAAC;IAAC,MAAM,EAAE,CAAC,MAAM,GAAG,IAAI,CAAC,EAAE,CAAA;CAAE,CA0BnD"}

package/dist/table/exec-baseline.d.ts

@@ -0,0 +1,9 @@
+import { type CompactProgram, type TableProgram, type TableRule } from './program.ts';
+/**
+ * Turn a program into the rule map a compiled artifact exports.
+ *
+ * The entries have the SAME signature as codegen rule functions, so `run()`,
+ * the linker's public wrappers and every consumer are unchanged.
+ */
+export declare function execRulesBaseline(source: TableProgram | CompactProgram): Record<string, TableRule>;
+//# sourceMappingURL=exec-baseline.d.ts.map

package/dist/table/exec-baseline.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"exec-baseline.d.ts","sourceRoot":"","sources":["../../src/table/exec-baseline.ts"],"names":[],"mappings":"AAWA,OAAO,EAEL,KAAK,cAAc,EAA6C,KAAK,YAAY,EAAE,KAAK,SAAS,EAClG,MAAM,cAAc,CAAA;AA4erB;;;;;GAKG;AACH,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,YAAY,GAAG,cAAc,GAAG,MAAM,CAAC,MAAM,EAAE,SAAS,CAAC,CAwBlG"}

package/dist/table/exec.d.ts

@@ -0,0 +1,72 @@
+import { type CompactProgram, type TableProgram, type TableRule } from './program.ts';
+/**
+ * DIAGNOSTIC ROW COUNTER — off unless `PM_TABLE_COUNT=1` at process start.
+ *
+ * Read ONCE, at module load, into a module const, so this is not the per-parse
+ * option branch G5 forbids: with the variable false the whole thing folds away
+ * after tier-up. It exists because "too many rows" and "each row too slow" are
+ * different defects with the same symptom, and only a count separates them.
+ * No timing run in this repo may set it — see `bench/jess/table-rows.ts`.
+ */
+export declare const tableCounters: {
+    rows: number;
+    byOp: Int32Array;
+    /** Distinct reducer/host functions actually reaching each shared call site. */
+    sites: Map<string, Set<unknown>>;
+    /**
+     * SPECULATION AT UNGATED CHOICES. `encode.ts:368-376` gives a choice its
+     * first-char dispatch only when NO arm is nullable, ALL arms are pairwise
+     * disjoint and ALL map to a char class; any one failure ungates every arm of
+     * the site, which then runs the linear loop below. Codegen has no such
+     * all-or-nothing rule — `emitFirstMatch` guards each arm on its OWN first set
+     * — so these counts are work the table does and the compiled engine does not.
+     *
+     * `ungatedEntries` is arms entered there; `ungatedFails` is those that then
+     * failed, which is pure waste by construction: a failing arm consumed nothing
+     * the winning arm will not scan again.
+     */
+    ungatedEntries: number;
+    ungatedFails: number;
+    /** Rows executed INSIDE failed ungated arms — the subtree each wasted entry drags. */
+    ungatedFailRows: number;
+    gatedEntries: number;
+    /** Arm entries DECLINED by the per-arm class gate — the work this change removes. */
+    armGateSkips: number;
+};
+export declare function resetTableCounters(): void;
+/**
+ * THE REFERENCE DRIVER. Turn a program into a rule map, by INTERPRETING the
+ * bytecode. Nothing ships on this — `tableRules` (`table/assemble.ts`) is
+ * what `parseman/table` exports as `tableRules`, and what every artifact binds.
+ *
+ * IT IS CALLED `execRules` AND NOT `tableRules` FOR A MEASURED REASON. Until
+ * this rename the two engines exported the SAME name with the SAME signature
+ * across a module boundary, so `import { tableRules } from '…/table/exec.ts'`
+ * and `import { tableRules } from 'parseman/table'` type-checked identically
+ * and silently selected different engines. Three modules picked the wrong one:
+ * `compiler/linker.ts` (the whole `compose()`/`fuse()` path), `table/fold.ts`
+ * (every folded artifact's variant load), and `bench/jess/fixture.ts` — the
+ * CANONICAL fixture harness, whose column printed as `table` was this function
+ * for the entire cycle it was quoted in.
+ *
+ * A name that two engines can answer to is not a naming preference; it is a
+ * defect with no diagnostic. Do not re-alias this to `tableRules` anywhere.
+ *
+ * The entries have the SAME signature as the assembler's, so `run()`, the
+ * linker's public wrappers and every consumer are unchanged — which is exactly
+ * why the substitution was invisible.
+ */
+export declare function execRules(source: TableProgram | CompactProgram, 
+/**
+ * MEASUREMENT CONTROL, not a feature. `leafSwap: false` hands the driver a
+ * `triviaScan` of all nulls, so `SCAN` is never installed and every skip takes
+ * the shared generic functions — the exact pre-swap behaviour, from the SAME
+ * driver code, differing only in TABLE DATA. That is what makes an in-process
+ * A/B of the swap possible on a machine where cross-run comparison is not, and
+ * it is G5-legal for the same reason `lines` is: it is read once, at rule-map
+ * construction, and the parse path never sees an option.
+ */
+opts?: {
+    leafSwap?: boolean;
+}, artifactMetadata?: Readonly<Record<symbol, unknown>>): Record<string, TableRule>;
+//# sourceMappingURL=exec.d.ts.map

package/dist/table/exec.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"exec.d.ts","sourceRoot":"","sources":["../../src/table/exec.ts"],"names":[],"mappings":"AAyCA,OAAO,EAEL,KAAK,cAAc,EACF,KAAK,YAAY,EAAE,KAAK,SAAS,EACnD,MAAM,cAAc,CAAA;AAyBrB;;;;;;;;GAQG;AACH,eAAO,MAAM,aAAa,EAAE;IAC1B,IAAI,EAAE,MAAM,CAAA;IACZ,IAAI,EAAE,UAAU,CAAA;IAChB,+EAA+E;IAC/E,KAAK,EAAE,GAAG,CAAC,MAAM,EAAE,GAAG,CAAC,OAAO,CAAC,CAAC,CAAA;IAChC;;;;;;;;;;;OAWG;IACH,cAAc,EAAE,MAAM,CAAA;IACtB,YAAY,EAAE,MAAM,CAAA;IACpB,sFAAsF;IACtF,eAAe,EAAE,MAAM,CAAA;IACvB,YAAY,EAAE,MAAM,CAAA;IACpB,qFAAqF;IACrF,YAAY,EAAE,MAAM,CAAA;CAC+H,CAAA;AAUrJ,wBAAgB,kBAAkB,IAAI,IAAI,CASzC;AA48CD;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,SAAS,CACvB,MAAM,EAAE,YAAY,GAAG,cAAc;AACrC;;;;;;;;GAQG;AACH,IAAI,GAAE;IAAE,QAAQ,CAAC,EAAE,OAAO,CAAA;CAAO,EACjC,gBAAgB,GAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAM,GACvD,MAAM,CAAC,MAAM,EAAE,SAAS,CAAC,CA8B3B"}

package/dist/table/fold.d.ts

@@ -0,0 +1,25 @@
+import { type CompactFolded, type FoldedProgram, type TableRule } from './program.ts';
+export { expandCompactFolded } from './program.ts';
+/**
+ * Select ONE variant of a folded table and build its rule map.
+ *
+ * This is the load-time half of G4. A folded artifact ships one table plus, per
+ * variant, the words that differ from it; this materialises the named variant
+ * and hands the driver an ordinary `TableProgram`. The driver is not told which
+ * variant it got and has no way to ask — the fold is finished before the driver
+ * sees anything, exactly as `trackLines` is resolved before it today.
+ *
+ * Its own module rather than a second export from the driver so that a bundle
+ * shipping a single-variant table does not pull the fold in, and so the driver
+ * keeps having no import of its own.
+ *
+ * IT DRIVES `tableRules`, the shipped engine. This module predates
+ * `63666b6`, which made the assembler `tableRules` by editing `table/index.ts`
+ * ALONE; `fold.ts` imports `exec.ts` directly and so kept the interpreter. Every
+ * folded artifact ships `import { tableVariants }` (`emit.ts`), so that was a
+ * product path on the reference engine. Bound by its own name now.
+ */
+export declare function tableVariants(source: FoldedProgram | CompactFolded, name: string): Record<string, TableRule>;
+/** The variant names a folded table carries, for a caller that wants to check. */
+export declare function variantNames(source: FoldedProgram | CompactFolded): string[];
+//# sourceMappingURL=fold.d.ts.map

package/dist/table/fold.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fold.d.ts","sourceRoot":"","sources":["../../src/table/fold.ts"],"names":[],"mappings":"AACA,OAAO,EAAsC,KAAK,aAAa,EAAE,KAAK,aAAa,EAAE,KAAK,SAAS,EAAE,MAAM,cAAc,CAAA;AAIzH,OAAO,EAAE,mBAAmB,EAAE,MAAM,cAAc,CAAA;AAElD;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,aAAa,CAC3B,MAAM,EAAE,aAAa,GAAG,aAAa,EACrC,IAAI,EAAE,MAAM,GACX,MAAM,CAAC,MAAM,EAAE,SAAS,CAAC,CAG3B;AAED,kFAAkF;AAClF,wBAAgB,YAAY,CAAC,MAAM,EAAE,aAAa,GAAG,aAAa,GAAG,MAAM,EAAE,CAE5E"}