parseman 0.60.0 → 0.60.1

package/dist/table/ops.d.ts

@@ -73,13 +73,7 @@ export declare const OP_XFORM = 9;
  * from the reducer's declared arity by the same analysis codegen runs, and
  * forced on under `hostMode: 'cst'`. The driver reads the bits and re-derives
  * nothing.
- *
- * TWO ENCODERS SHARE THIS OPCODE and they do NOT agree on its length. The layout
- * above is `encode.ts` / `exec.ts`. `encode-baseline.ts` / `exec-baseline.ts` emit
- * the FOUR-word form `NODE b c flags` with bits 2 and 3 only, and refuse
- * `collapse` / `unwrap` / `project` outright. Neither driver walks the stream by
- * instruction length, so the divergence is contained — but read the pair you are
- * in, not this comment alone. */
+ */
 export declare const OP_NODE = 10;
 /** `RULE r` — `r` indexes `prog.rules`. */
 export declare const OP_RULE = 11;
@@ -92,9 +86,6 @@ export declare const OP_NOT = 13;
  * `['peek(<child tag>)']`, because `peek.ts:60` DISCARDS the body's expectation:
  * a lookahead's failure is "the guard did not hold", not a request for whatever
  * token the body happened to stop on.
- *
- * `encode-baseline.ts` / `exec-baseline.ts` emit and read the two-word form and
- * are internally consistent; read the pair you are in.
  */
 export declare const OP_PEEK = 14;
 /** `LEAF f c` — `leaf()`: reduce, then record as a spanned leaf. */

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

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

package/dist/version.d.ts

@@ -13,5 +13,5 @@
  * Kept in sync with `package.json` by `test/unit/version-sync.test.ts`, which fails
  * the build if this constant drifts from the published version.
  */
-export declare const PARSEMAN_VERSION = "0.60.0";
+export declare const PARSEMAN_VERSION = "0.60.1";
 //# sourceMappingURL=version.d.ts.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "parseman",
-  "version": "0.60.0",
+  "version": "0.60.1",
   "packageManager": "pnpm@10.15.1",
   "engines": {
     "node": "^20.19.0 || >=22.13.0"
@@ -84,13 +84,10 @@
     "bench": "node --import tsx/esm bench/run.ts",
     "bench:parseman": "node --import tsx/esm bench/parseman.ts",
     "bench:closure-json": "node --import tsx/esm bench/closure-json-path.ts",
-    "bench:composeleaf": "node --import tsx/esm bench/composeleaf-firstset.ts",
     "bench:incremental": "node --import tsx/esm bench/incremental-run.ts",
     "bench:literal": "node --import tsx/esm bench/literal-match.ts",
     "bench:dispatch": "node --import tsx/esm bench/dispatch-vs-choice.ts",
-    "bench:codegen": "node --import tsx/esm bench/codegen-ab.ts",
     "bench:treeidentity": "node --import tsx/esm bench/tree-identity.ts",
-    "bench:sharedprefix": "node --import tsx/esm bench/shared-prefix-ab.ts",
     "bench:baseline": "node --import tsx/esm bench/update-parseman-baseline.ts",
     "perf:guard": "node --import tsx/esm bench/perf-guard.ts",
     "perf:guard:grammars": "node --import tsx/esm bench/grammar-perf-guard.ts",
@@ -109,6 +106,7 @@
     "bench:release-compare-svg": "node --import tsx/esm bench/gen-release-compare-svg.ts",
     "bench:size": "node --import tsx/esm bench/measure-expansion.ts",
     "docs:favicons": "node scripts/gen-favicons.mjs",
+    "docs:railroad": "node --import tsx/esm scripts/gen-railroad-svg.ts",
     "build:chevrotain-bench": "node --import tsx/esm scripts/build-chevrotain-bench.mjs",
     "bench:compile-grammars": "peggy --format es -o bench/json-parser.js bench/json.pegjs && peggy --format es -o bench/csv-parser.js bench/csv.pegjs && peggy --format es -o bench/graphql-parser.js bench/graphql.pegjs && nearleyc bench/vendor/nearley/json.ne -o bench/json-nearley.cjs && nearleyc bench/vendor/nearley/csv.ne -o bench/csv-nearley.cjs && nearleyc bench/vendor/nearley/graphql.ne -o bench/graphql-nearley.cjs && node bench/compile-jison.mjs",
     "perf:workloads": "node --import tsx/esm bench/workload-perf-guard.ts",

package/src/table/assemble.ts

@@ -5,7 +5,7 @@
  * making the swaps on rules / sub-rules (leaves) at that point, then run with NO
  * logic branching for that option input"*. `exec.ts` builds the same table and
  * then interprets it: one `switch (code[ip])` over every opcode (29 then), executed ONCE PER
- * ROW — 497,360 rows for `benchmark.less` (`bench/jess/g5-rows.ts`) — each
+ * ROW — 497,360 rows for `benchmark.less` (measured with a one-off `g5-rows` bench, last at `4a5d0341`) — each
  * re-reading its opcode and re-decoding its operands from the `Int32Array`, and
  * re-testing the same per-parse options. That is the per-node branching the
  * design exists to remove.
@@ -20,13 +20,13 @@
  *
  * The numbers that make this obviously the right trade, measured not assumed:
  *
- *   2,241  distinct reachable sites in the less table (`bench/jess/g5-sites.ts`)
+ *   2,241  distinct reachable sites in the less table (`g5-sites`)
  * 497,360  rows executed for one parse of `benchmark.less`
  *
  * Pieces are GRAMMAR-sized; rows are INPUT-sized. Assembly allocates ~2.2k
  * closures once per process and removes a dispatch plus an operand decode from
  * ~497k executions — a 222x ratio. Assembly cost is paid once and is not the
- * metric; it is measured anyway (`bench/jess/g5-ms.ts`, `bench/jess/g5-profile.ts`).
+ * metric; it is measured anyway (`g5-ms`, `g5-profile`).
  *
  * ## Why this is not "just tuning the switch"
  *
@@ -4298,7 +4298,7 @@ export function assemble(t: ResolvedTable, prog: TableProgram, cfg: RunCfg): Ass
       // Two engines that can only be compared across two checkouts cannot be
       // compared at all: the bench harness's own guidance is that a
       // cross-worktree measurement carries a bias no repetition removes. Same
-      // spelling as `PM_TABLE_COUNT` (`bench/table-opcode-gaps.ts`).
+      // spelling as the removed `PM_TABLE_COUNT` counters.
       if (!EMIT_ENABLED) throw new Unemittable('PM_TABLE_EMIT=0 (measurement toggle)')
       const em = emitAssemblySource(t, prog, cfg, extraIps)
       /**
@@ -4569,7 +4569,7 @@ export class AssemblyCache {
    * That is not a hole in G5, it is G5's own first clause: "quickly building the
    * grammar reference ON RUN START, making some swaps on rules or sub-rules, and
    * then the run actually runs with no logic branching for that option input"
-   * (`notes/TABLE-DRIVER.md`). This IS the run-start step. What the criterion
+   * (`notes/history/TABLE-DRIVER.md`). This IS the run-start step. What the criterion
    * forbids is the second sentence, and past this call there is no option read
    * anywhere — `scripts/check-invariants.mjs` INV-6 decides that mechanically.
    *

package/src/table/compile-rule-map.ts

@@ -68,7 +68,7 @@ export type TableRuleMapOptions = {
    * `coverage: grammarCoverage` here for every `rules()` grammar — so this is what
    * makes `{ grammarCoverage: true }` a working build under the table lowering.
    *
-   * COUNTERS ONLY, per the owner ruling recorded in `notes/RELEASE-0.48-TARGET.md`
+   * COUNTERS ONLY, per the owner ruling recorded in `notes/history/RELEASE-0.48-TARGET.md`
    * §1; `_grammarTrace` parity is 0.48 work. The plugin's coverage path needs the
    * DEFINITIONS STAMP and the HITS, and both are here.
    */

package/src/table/compile.ts

@@ -90,7 +90,7 @@ export type TableCompileOptions = {
    *
    * COUNTERS ONLY — owner ruling. `_grammarTrace`'s six phases are emitted at
    * ~40 fine-grained sites by codegen and are deferred to 0.48
-   * (`notes/RELEASE-0.48-TARGET.md` §1). A table entry rejects a context carrying
+   * (`notes/history/RELEASE-0.48-TARGET.md` §1). A table entry rejects a context carrying
    * a trace sink before parsing: silently returning an empty trace would look
    * exactly like a real trace whose grammar sites were never visited. The
    * plugin's coverage path reads `_grammarCoverage` and the definitions stamp,

package/src/table/emit-assembly.ts

@@ -1400,8 +1400,8 @@ ${cfg.probe ? `failAt(ctx,${xf},pos)\n` : ''}return FAIL
       }
 
       case OP_EMPTY:
-        // `''`, not `null` — the zero-width match's value. The other three engines
-        // (exec.ts, exec-baseline.ts, assemble.ts) all return `''`; this one returned
+        // `''`, not `null` — the zero-width match's value. The other engines
+        // (exec.ts, assemble.ts) both return `''`; this one returned
         // `null`, so the SAME program yielded a different `value` depending only on
         // which engine ran. Unreached from the combinator API today — `OP_EMPTY` is
         // emitted only as `finish()` padding for an EMPTY rule map, which then has no

package/src/table/encode.ts

@@ -783,7 +783,7 @@ class Encoder {
    * simply parses it with the gate switched off at every choice arm that reaches
    * a hole.
    *
-   * Measured on jess's less grammar (`bench/jess/macro-program-diff.ts`): 195 of
+   * Measured on jess's less grammar (with the one-off `macro-program-diff` bench, last at `4a5d0341`): 195 of
    * 562 reachable choice arms carried NO first set in the shipped artifact
    * against 103 of 540 in the runtime encode, and 10 dispatch sites lost the O(1)
    * `exclusive` piece (`assemble.ts:1758`) for the candidate-mask loop. With this

package/src/table/exec.ts

@@ -75,60 +75,6 @@ import { FAIL, newEndCell, type EndCell } from './cell.ts'
 import { fieldSpec, leadingTriviaFieldAt } from './field-spec.ts'
 import { FIELD_LEADING_TRIVIA, FIELD_TRAILING_TRIVIA, LEAD, triviaFieldCapture } from '../combinators/field-trivia.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 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
-} = { rows: 0, byOp: new Int32Array(64), sites: new Map(), ungatedEntries: 0, ungatedFails: 0, ungatedFailRows: 0, gatedEntries: 0, armGateSkips: 0 }
-
-const COUNT = process.env.PM_TABLE_COUNT === '1'
-
-function siteFn(site: string, fn: unknown): void {
-  let s = tableCounters.sites.get(site)
-  if (s === undefined) { s = new Set(); tableCounters.sites.set(site, s) }
-  s.add(fn)
-}
-
-export function resetTableCounters(): void {
-  tableCounters.rows = 0
-  tableCounters.byOp = new Int32Array(64)
-  tableCounters.sites = new Map()
-  tableCounters.ungatedEntries = 0
-  tableCounters.ungatedFails = 0
-  tableCounters.ungatedFailRows = 0
-  tableCounters.gatedEntries = 0
-  tableCounters.armGateSkips = 0
-}
-
 const EMPTY_TL: readonly number[] = Object.freeze([])
 const EMPTY_FX: string[] = []
 const ROUTED_FX: string[] = ['routed()']
@@ -380,7 +326,6 @@ function makeDriver(
     // recursing, so the reference driver's stack grows with the grammar's
     // nesting, not with its gate rows.
     rows: for (;;) {
-    if (COUNT) { tableCounters.rows++; tableCounters.byOp[code[ip]!]!++ }
     switch (code[ip]) {
       case OP_LIT: {
         const s = k[code[ip + 1]!] as string
@@ -891,7 +836,6 @@ function makeDriver(
           // Running it through `exec` at the POST-scan position would find the gap
           // already consumed and answer "adjacent" unconditionally.
           if (code[child] === OP_ADJ) {
-            if (COUNT) { tableCounters.rows++; tableCounters.byOp[OP_ADJ]!++ }
             const ki = code[child + 2]!
             if (!adjacencyHolds(input, cur, ctx, code[child + 1] === 1, ki < 0 ? undefined : k[ki] as readonly string[])) {
               ctx._fe = cur; ctx._fx = fx[code[child + 3]!] as string[]
@@ -927,10 +871,6 @@ function makeDriver(
           // LIT/RX in place removes both. The duplication is in the DRIVER,
           // which ships once for every grammar — the cost this design trades on.
           const cop = code[child]
-          // The two inline terminals below execute a ROW without going through
-          // `exec`, so the counter has to see them or the row count understates
-          // exactly where the driver already won.
-          if (COUNT && (cop === OP_LIT || cop === OP_RX)) { tableCounters.rows++; tableCounters.byOp[cop]!++ }
           if (cop === OP_LIT) {
             const lit = k[code[child + 1]!] as string
             if (!input.startsWith(lit, cur)) {
@@ -971,7 +911,6 @@ function makeDriver(
           const reducer = code[ip + 1]!
           if (reducer < 0) return values![~reducer]
           const fn = fns[reducer] as (value: unknown, span: { start: number; end: number }) => unknown
-          if (COUNT) siteFn('SEQX fn()', fn)
           return fn(values, { start: pos, end: cur })
         }
         return values
@@ -1003,7 +942,6 @@ function makeDriver(
           }
           if (arm >= 0) {
             ctx._fc = false
-            if (COUNT) tableCounters.gatedEntries++
             const v = exec(code[base + arm]!, input, pos, ctx)
             if (v !== FAIL) return v
             // THE CUT. `dispatch()` is the library's one true cut: once its
@@ -1085,7 +1023,6 @@ function makeDriver(
           // Under a completion probe every arm is entered, as the interpreter's
           // `firstMatch` enters it: its opener then reaches the probe (`failAt`).
           if (ctx._probe === undefined && cls !== undefined && cls !== null && !classHas(cls, c)) {
-            if (COUNT) tableCounters.armGateSkips++
             // THE GATED ARM STILL REPORTS. The interpreter has no char gate: it
             // enters the arm, the arm's opener fails, and its static set is what
             // lands in the accumulation. Declining to enter must not also decline
@@ -1094,11 +1031,8 @@ function makeDriver(
             continue
           }
           ctx._fc = false
-          if (COUNT) tableCounters.ungatedEntries++
-          const rows0 = COUNT ? tableCounters.rows : 0
           const v = exec(code[base + i]!, input, pos, ctx)
           if (v !== FAIL) return v
-          if (COUNT) { tableCounters.ungatedFails++; tableCounters.ungatedFailRows += tableCounters.rows - rows0 }
           const at = ctx._fe ?? pos
           if (at > best) { best = at; acc = undefined }
           if (at === best) push(ctx._fx)
@@ -1421,7 +1355,6 @@ function makeDriver(
         const v = exec(code[ip + 2]!, input, pos, ctx)
         if (v === FAIL) return FAIL
         const fn = fns[code[ip + 1]!] as (value: unknown, span: { start: number; end: number }) => unknown
-        if (COUNT) siteFn('XFORM fn()', fn)
         return fn(v, { start: pos, end: EC.e })
       }
 
@@ -1463,7 +1396,6 @@ function makeDriver(
         if (v === FAIL) return FAIL
         const end = EC.e
         const fn = fns[code[ip + 1]!] as (value: unknown, span: { start: number; end: number }) => unknown
-        if (COUNT) siteFn('LEAF fn()', fn)
         const out = fn(v, { start: pos, end })
         if (wasCapturing) pushCstLeaf(ctx, {
           _tag: 'leaf',
@@ -1566,7 +1498,6 @@ function makeDriver(
               children: readonly unknown[], fields: FieldMap | undefined, span: { start: number; end: number },
               rawChildren: readonly unknown[], triviaLog: readonly number[], state: unknown,
             ) => unknown
-            if (COUNT) siteFn('NODE build()', build)
             nd = build(kids, fieldMap, span, cap.rawChildren, (flags & 4) !== 0 || hostCst ? cap.triviaLog : EMPTY_TL, st)
           }
         } else if (host !== undefined) {

package/src/table/ops.ts

@@ -74,13 +74,7 @@ export const OP_XFORM = 9
  * from the reducer's declared arity by the same analysis codegen runs, and
  * forced on under `hostMode: 'cst'`. The driver reads the bits and re-derives
  * nothing.
- *
- * TWO ENCODERS SHARE THIS OPCODE and they do NOT agree on its length. The layout
- * above is `encode.ts` / `exec.ts`. `encode-baseline.ts` / `exec-baseline.ts` emit
- * the FOUR-word form `NODE b c flags` with bits 2 and 3 only, and refuse
- * `collapse` / `unwrap` / `project` outright. Neither driver walks the stream by
- * instruction length, so the divergence is contained — but read the pair you are
- * in, not this comment alone. */
+ */
 export const OP_NODE = 10
 /** `RULE r` — `r` indexes `prog.rules`. */
 export const OP_RULE = 11
@@ -93,9 +87,6 @@ export const OP_NOT = 13
  * `['peek(<child tag>)']`, because `peek.ts:60` DISCARDS the body's expectation:
  * a lookahead's failure is "the guard did not hold", not a request for whatever
  * token the body happened to stop on.
- *
- * `encode-baseline.ts` / `exec-baseline.ts` emit and read the two-word form and
- * are internally consistent; read the pair you are in.
  */
 export const OP_PEEK = 14
 /** `LEAF f c` — `leaf()`: reduce, then record as a spanned leaf. */

package/src/version.ts

@@ -13,4 +13,4 @@
  * Kept in sync with `package.json` by `test/unit/version-sync.test.ts`, which fails
  * the build if this constant drifts from the published version.
  */
-export const PARSEMAN_VERSION = '0.60.0'
+export const PARSEMAN_VERSION = '0.60.1'

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

@@ -1,16 +0,0 @@
-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

@@ -1 +0,0 @@
-{"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;AAUlE,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;AAqTD;;;;;;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/exec-baseline.d.ts

@@ -1,9 +0,0 @@
-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

@@ -1 +0,0 @@
-{"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;AAggBrB;;;;;GAKG;AACH,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,YAAY,GAAG,cAAc,GAAG,MAAM,CAAC,MAAM,EAAE,SAAS,CAAC,CAwBlG"}