parseman 0.45.0 → 0.47.0

package/dist/table/index.d.ts

@@ -0,0 +1,100 @@
+/**
+ * `parseman/table` — the shared driver for the TABLE lowering (ledger row G5).
+ *
+ * A grammar lowered to a table contributes only DATA to a bundle; every line of
+ * recognition logic lives here and ships once, shared by every grammar and every
+ * `(grammar, settings)` variant. An emitted module's whole runtime dependency is
+ * `tableRules` from this entry.
+ *
+ * Its own entry point for the same reason `parseman/run` is: a package that
+ * SHIPS a table parser should not drag the combinator set, `compile()` and the
+ * first-set analysis along with it.
+ */
+/**
+ * THE DRIVER (G5) — `tableRules` IS the assembler. The program is LINKED into
+ * closures at run start, so the parse path holds no opcode read, no operand
+ * decode and no option test.
+ *
+ * It replaced the bytecode interpreter here rather than shipping beside it. Two
+ * live drivers is two places for behaviour to drift, and that already happened
+ * once: the ambient `scanSkip` write had to move into the shared `stamp.ts`
+ * envelope because each driver was installing it separately. The gate for the
+ * swap was `exec === assembled` on the identity sweep, which it clears.
+ *
+ * `exec.ts` stays REFERENCE — the sweep still gates the assembler against it,
+ * and it is what a divergence gets bisected against. Nothing under `src/` binds
+ * it; only `bench/` and `test/` do, as the reference side of a differential.
+ *
+ * THAT SENTENCE WAS FALSE FOR TWO RELEASES, and the shape of the failure is
+ * worth keeping. `63666b6` made the assembler `tableRules` by editing THIS FILE
+ * and nothing else. `exec.ts` exported its own function ALSO called `tableRules`
+ * with the identical signature, so any module reaching PAST this entry bound the
+ * interpreter, type-checked clean and ran correctly — just slower. THREE modules
+ * did: `table/fold.ts` (predating the swap), `compiler/linker.ts` (added after
+ * it, in `37c57b5`), and `bench/jess/fixture.ts` — the CANONICAL fixture
+ * harness, whose column printed as `table` was the reference interpreter for the
+ * whole cycle its figures were quoted in. Between them they put the entire
+ * `compose()`/`fuse()` composition path, every folded artifact's `tableVariants`
+ * load, and the repo's headline parse-time figure on the reference engine.
+ *
+ * BOTH HALVES OF THE MECHANISM ARE GONE, AND ONLY REMOVING BOTH WAS ENOUGH.
+ *
+ * Half one: `exec.ts` now exports `execRules`. The reference driver no longer
+ * answers to the shipped engine's name.
+ *
+ * Half two, and the one that made the class EXPRESSIBLE: this line used to read
+ * `export { assembledRules as tableRules, assembledRules, … }` — ONE function
+ * published under TWO names. An `as` re-export across a boundary we own both
+ * sides of is not a compatibility shim; it is a second name for a thing that
+ * needs one, and it is exactly the seam a wrong import slips through. The
+ * function in `assemble.ts` is now NAMED `tableRules` at its declaration and
+ * re-exported unrenamed. `assembledRules` no longer exists anywhere.
+ *
+ * WHY `tableRules` WON AND `assembledRules` DIED:
+ *
+ *   1. It is the name EMITTED ARTIFACTS import. `emit.ts:emitTableModule` writes
+ *      `import { <ref> } from 'parseman/table'` with `ref` defaulting to
+ *      `tableRules`; `compile.ts` and `compile-rule-map.ts` default `runtimeRef`
+ *      to the same; `plugin/index.ts` prepends that exact import into every
+ *      consumer bundle it rewrites. Unifying on this name changes NO emitted
+ *      byte — the alternative direction would have rewritten four emit sites and
+ *      every artifact they have ever produced, for no gain.
+ *   2. It names WHAT THE THING IS at a public boundary — the rule map of a table
+ *      lowering — where `assembledRules` named HOW it is currently built.
+ *      Closure assembly is an implementation that has already replaced one
+ *      engine and may be replaced again; the boundary name has now outlived one
+ *      such swap and should outlive the next.
+ *
+ * `scripts/check-invariants.mjs` INV-11 fails any `as` rename across the two
+ * engines' vocabularies, and any renaming re-export from a `src/**` entry point,
+ * across `src/`, `test/` and `bench/`. The rule exists because the alias above
+ * was not a mistake anyone made twice — it was a shape that made the mistake
+ * available.
+ */
+export { tableRules, assemble, AssemblyCache, type Assembly, type RunCfg } from './assemble.ts';
+export { encodeTable, UnsupportedConstruct, type TableSettings } from './encode.ts';
+/**
+ * `compile()` for the table lowering — same `CompiledParser` contract, a table
+ * artifact instead of generated source. A root combinator is a one-rule map, so
+ * this is a drop-in for the source-lowering `compile()` rather than a second API.
+ */
+export { compile, type TableCompileOptions } from './compile.ts';
+export { emitTableModule, emitTableExpression, emitFoldedModule } from './emit.ts';
+/**
+ * `compileRuleMap()` for the table lowering — the MAIN macro path. `compile`
+ * only ever covered `compile()`, the single-root entry, so a `rules()` grammar had
+ * no table counterpart to point the build at at all.
+ */
+export { compileRuleMap, type TableRuleMapOptions, type CompiledRuleMapTable } from './compile-rule-map.ts';
+/**
+ * THE VARIANT FOLD (G4). One base table plus per-variant row edits, selected at
+ * load. Additive: `tableRules` and every existing entry are untouched, and the
+ * driver still reads no option on the parse path.
+ */
+export { tableVariants, variantNames } from './fold.ts';
+export { foldPrograms, unfoldVariant, expandCompactFolded } from './program.ts';
+export type { FoldedProgram, CompactFolded, TableDelta } from './program.ts';
+export { opHistogram, reachableOps } from './inspect.ts';
+export { resolveTable } from './program.ts';
+export type { CompactProgram, TableProgram, TableRule } from './program.ts';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/table/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AACH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4DG;AACH,OAAO,EAAE,UAAU,EAAE,QAAQ,EAAE,aAAa,EAAE,KAAK,QAAQ,EAAE,KAAK,MAAM,EAAE,MAAM,eAAe,CAAA;AAC/F,OAAO,EAAE,WAAW,EAAE,oBAAoB,EAAE,KAAK,aAAa,EAAE,MAAM,aAAa,CAAA;AACnF;;;;GAIG;AACH,OAAO,EAAE,OAAO,EAAE,KAAK,mBAAmB,EAAE,MAAM,cAAc,CAAA;AAChE,OAAO,EAAE,eAAe,EAAE,mBAAmB,EAAE,gBAAgB,EAAE,MAAM,WAAW,CAAA;AAClF;;;;GAIG;AACH,OAAO,EAAE,cAAc,EAAE,KAAK,mBAAmB,EAAE,KAAK,oBAAoB,EAAE,MAAM,uBAAuB,CAAA;AAC3G;;;;GAIG;AACH,OAAO,EAAE,aAAa,EAAE,YAAY,EAAE,MAAM,WAAW,CAAA;AACvD,OAAO,EAAE,YAAY,EAAE,aAAa,EAAE,mBAAmB,EAAE,MAAM,cAAc,CAAA;AAC/E,YAAY,EAAE,aAAa,EAAE,aAAa,EAAE,UAAU,EAAE,MAAM,cAAc,CAAA;AAU5E,OAAO,EAAE,WAAW,EAAE,YAAY,EAAE,MAAM,cAAc,CAAA;AACxD,OAAO,EAAE,YAAY,EAAE,MAAM,cAAc,CAAA;AAC3C,YAAY,EAAE,cAAc,EAAE,YAAY,EAAE,SAAS,EAAE,MAAM,cAAc,CAAA"}