parseman 0.34.0 → 0.36.0

package/README.md

@@ -6,29 +6,17 @@
 
 Write parsers as TypeScript functions. Ship them like hand-written parsers.
 
-Parséman is a TypeScript parser-combinator library with an optional compiler/macro path that turns your grammar into flat JavaScript. Use the same grammar interpreted in tests and REPLs, macro-compiled at build time in production, or compiled on demand at runtime with `compile()`.
+Parser combinators are pleasant to write and usually slow. Parser generators are fast and
+usually mean grammar files, generated code, and extra tooling. Parséman is a TypeScript
+combinator library with an optional compiler: write ordinary TypeScript, and a build-time
+macro turns it into flat JavaScript that behaves like a parser you wrote by hand.
 
-Use Parséman when you want:
-
-- normal TypeScript instead of grammar files
-- parser-combinator ergonomics without parser-combinator slowness
-- CST/AST nodes with spans and trivia
-- error recovery for editor tooling
-- incremental re-parsing
-- fast parsers for DSLs, config languages, formatters, linters, and language servers
+Reach for it when you want normal TypeScript instead of grammar files, CST/AST nodes with
+spans and trivia, error recovery and incremental re-parsing for editor tooling, or simply
+a fast parser for a DSL, config language, formatter, or linter.
 
 > **📖 Full documentation: [matthew-dean.github.io/parseman](https://matthew-dean.github.io/parseman/)**
 
-## Why Parséman?
-
-Most parser tools make you choose between ergonomics and performance.
-
-Parser combinators are pleasant to write, but often slow. Parser generators can be fast, but usually involve grammar files, generated code, and extra tooling. Hand-written parsers are fast, but expensive to design and maintain.
-
-Parséman aims for the useful middle: write your parser as ordinary TypeScript, then compile it into code that behaves more like a hand-written parser.
-
----
-
 ## Install
 
 ```bash
@@ -36,8 +24,8 @@ npm install parseman
 # pnpm add parseman
 ```
 
-Parseman is pre-1.0. Minor versions may include breaking changes; check the
-[changelog](./CHANGELOG.md) before upgrading.
+Pre-1.0: minor versions may carry breaking changes — check the [changelog](./CHANGELOG.md)
+before upgrading. Requires Node `^20.19.0 || >=22.12.0`.
 
 ## Quick start
 
@@ -57,64 +45,95 @@ parse(requestLine, 'GET /api/v1 HTTP/1.1')
 // { ok: true, value: { verb: 'GET', path: '/api/v1', version: 'HTTP/1.1' }, span: ... }
 ```
 
+New here? **[What is Parséman?](https://matthew-dean.github.io/parseman/guide/getting-started)**
+walks the same ground more slowly.
+
 ## Three modes, one grammar
 
 The same combinator code runs three ways, with identical results:
 
 - **Interpreter** — zero setup, works anywhere (tests, REPLs, dynamic grammars).
-- **Macro build** — a [bundler plugin](https://matthew-dean.github.io/parseman/guide/macro-mode) evaluates your grammar at build time and replaces it with inline JS. Zero runtime cost; the `parseman` import disappears from the bundle.
-- **`compile()`** — the same optimizer, run on demand at runtime.
+- **Macro build** — a [bundler plugin](https://matthew-dean.github.io/parseman/guide/macro-mode)
+  evaluates your grammar at build time and inlines the result. The combinator import you
+  mark `with { type: 'macro' }` disappears entirely; what ships is flat JavaScript with no
+  parseman import in it. (Executing that parser still goes through `run()`/`parse()`, so an
+  app keeps parseman as an ordinary dependency — see
+  [the three modes](https://matthew-dean.github.io/parseman/guide/modes).)
+- **`compile()`** — the same optimizer, on demand at runtime.
 
 ```ts
 // Add the plugin (vite.config.ts) and one import attribute — that's the whole change:
 import { literal, sequence, choice } from 'parseman' with { type: 'macro' }
 ```
 
-See **[The three modes](https://matthew-dean.github.io/parseman/guide/modes)** for the full story.
+See **[The three modes](https://matthew-dean.github.io/parseman/guide/modes)**.
 
 ## What's in the box
 
-- **[Combinators](https://matthew-dean.github.io/parseman/guide/combinators)** — `literal`, `regex`, `sequence`, `choice`, `many`, `sepBy`, `token`, `not`, and more.
-- **[Whitespace & trivia](https://matthew-dean.github.io/parseman/guide/trivia)** — grammar-defined filler skipping, with per-chunk kind capture.
-- **[Recursive rules](https://matthew-dean.github.io/parseman/guide/recursive-rules)** — `rules()` for mutually recursive grammars; fully macro-compilable.
-- **[CST / AST nodes](https://matthew-dean.github.io/parseman/guide/ast)** — `node()` captures terminals, named `field()` values, and trivia for you, with `unwrap` for AST/value wrappers, `collapse` for grammar-local CST wrappers, and `cstBuildHost({ collapse })` for public CST policies.
-- **[Incremental re-parsing](https://matthew-dean.github.io/parseman/guide/incremental)** — `parseDoc` re-parses just the edited subtree on each keystroke.
-- **[Error recovery](https://matthew-dean.github.io/parseman/guide/error-recovery)** — `recover`, `expect`, and a `{ recover: true }` channel keep parsing broken input and report every error.
-- **[Context-sensitive parsing](https://matthew-dean.github.io/parseman/guide/context)** — `withCtx` / `guard` without mutating shared state.
-
-Full API in the **[reference](https://matthew-dean.github.io/parseman/reference/api)**.
-
----
-
-## Compared to other parser tools
-
-Wondering how Parséman compares to Peggy, Chevrotain, Lezer, tree-sitter, Parsimmon, Nearley, or hand-written parsers?
-
-See the full comparison: **[How Parséman compares](https://matthew-dean.github.io/parseman/guide/comparison)**
-
-## Real grammar example: GraphQL
-
-Parséman includes a [GraphQL grammar](./examples/graphql/parser.ts) used in the benchmark suite. It parses executable GraphQL documents (queries, mutations, subscriptions, fragments, directives, variables, all value types) into typed AST nodes — not just syntax-validating them.
-
-This is a real-world example of Parséman on a non-trivial, spec-shaped language, not a toy grammar.
-
-- Source: [`examples/graphql/parser.ts`](./examples/graphql/parser.ts)
-- Benchmark results: [GraphQL benchmarks](https://matthew-dean.github.io/parseman/guide/benchmarks#graphql)
-- Benchmark runner: [`bench/run.ts`](./bench/run.ts)
-
----
+**✍️ Writing grammars**
+
+- 🧩 **[Combinators](https://matthew-dean.github.io/parseman/guide/combinators)** — `literal`,
+  `regex`, `sequence`, `choice`, `many`, `sepBy`, `token`, `peek`, `not`, and more.
+- 🌀 **[Recursive rules](https://matthew-dean.github.io/parseman/guide/recursive-rules)** —
+  `rules()` for mutually recursive grammars; fully macro-compilable.
+- 🫧 **[Whitespace & trivia](https://matthew-dean.github.io/parseman/guide/trivia)** —
+  grammar-defined filler skipping, with per-chunk kind capture.
+- 🎯 **[Ordered choice, done right](https://matthew-dean.github.io/parseman/guide/keywords)** —
+  PEG semantics you control by ordering, with keyword boundaries that don't bite.
+- 🪶 **[Grammars the way you write them](https://matthew-dean.github.io/parseman/guide/natural-grammars)** —
+  no FIRST/FOLLOW sets to compute, no left-factoring `choice(a·x, a·y)` into `a·(x | y)`
+  to satisfy the tool. The compiler does that for you.
+- 🧬 **[Extending grammars](https://matthew-dean.github.io/parseman/guide/extending)** —
+  `compose()` a dialect onto a base grammar instead of forking it.
+- 🎛️ **[Context-sensitive parsing](https://matthew-dean.github.io/parseman/guide/context)** —
+  `withCtx` / `gate` without mutating shared state.
+
+**🌳 Getting structure out**
+
+- 🌲 **[CST / AST nodes](https://matthew-dean.github.io/parseman/guide/ast)** — `node()`
+  captures terminals, named fields, and trivia, with policies for wrapping and collapsing.
+- 🩹 **[Error recovery](https://matthew-dean.github.io/parseman/guide/error-recovery)** —
+  keep parsing broken input and report every error.
+- ⚡ **[Incremental re-parsing](https://matthew-dean.github.io/parseman/guide/incremental)** —
+  `parseDoc` re-parses just the edited subtree on each keystroke.
+- 💡 **[Editor / LSP integration](https://matthew-dean.github.io/parseman/guide/editor-integration)** —
+  completions and lint keyed by rule name; the grammar stays pure structure.
+
+**🔬 Seeing what your grammar does**
+
+- 🚂 **[Railroad diagrams & EBNF](https://matthew-dean.github.io/parseman/guide/spec-generation)** —
+  `toRailroadHtml()` and `toEBNF()` generate the grammar reference *from the parser*, so
+  the spec can't drift from what actually parses.
+- 🔎 **[Grammar observability](https://matthew-dean.github.io/parseman/guide/grammar-observability)** —
+  coverage ("which rules and choice arms ran?") and trace ("what did it try, select, and
+  backtrack through?").
+- 🚦 **[First-char gating diagnostics](https://matthew-dean.github.io/parseman/guide/first-char-gating)** —
+  the build tells you which `choice` lost its O(1) dispatch, names the overlapping arms,
+  and says how to fix it.
+- 📈 **[Performance guide](https://matthew-dean.github.io/parseman/guide/performance)** —
+  the levers that actually move a grammar, and [how regexes lower](https://matthew-dean.github.io/parseman/guide/regex-lowering).
+
+Full API in the **[reference](https://matthew-dean.github.io/parseman/reference/api)**; how
+it stacks up against Peggy, Chevrotain, Lezer, tree-sitter, Parsimmon, Nearley and
+hand-written parsers in
+**[How Parséman compares](https://matthew-dean.github.io/parseman/guide/comparison)**.
 
 ## Benchmarks
 
-Parséman includes benchmarks against several JavaScript/TypeScript parser libraries across JSON, CSV, and GraphQL fixtures. Benchmarks are not universal truth tablets — results depend on grammar shape, input size, runtime, and what each parser is asked to produce. The benchmark suite is included so results can be inspected and reproduced (see [Reproducing the numbers](https://matthew-dean.github.io/parseman/guide/benchmarks#reproducing-the-numbers)).
-
-**When parsing to JS values** — objects, row arrays, AST nodes — **Parséman's macro build is the fastest general-purpose JS parser we benchmark**, beating [Peggy](https://peggyjs.org/), [Parsimmon](https://github.com/jneen/parsimmon), [Chevrotain](https://chevrotain.io/), [Nearley](https://nearley.js.org/), and [Jison](https://github.com/zaach/jison) at every grammar and size. The only thing that edges it out is a purpose-built native like `JSON.parse`; for anything that *doesn't* have a built-in, Parséman is the one to beat.
-
-For **syntax tree building**, the compiled CST path (macro build) beats [Lezer](https://lezer.codemirror.net/) on the JSON CST fixture too — while producing a richer object tree with spans and trivia. For **incremental re-parse**, Parséman's `parseDoc` stores parent-relative spans so in-place value edits are ~110× faster than a full reparse and ~20× ahead of Lezer; structural edits (inserting/removing a whole list element) reuse the collection's untouched tail and land within a few × of Lezer's buffer reuse rather than at full-reparse cost. Full breakdown in the [benchmarks guide](https://matthew-dean.github.io/parseman/guide/benchmarks).
+Benchmarked against [Peggy](https://peggyjs.org/),
+[Parsimmon](https://github.com/jneen/parsimmon), [Chevrotain](https://chevrotain.io/),
+[Nearley](https://nearley.js.org/), [Jison](https://github.com/zaach/jison) and
+[Lezer](https://lezer.codemirror.net/) on JSON, CSV and GraphQL — each building real output
+(objects, row arrays, AST nodes), not validating syntax.
 
-Measured on Apple M4 Pro. Bars show µs per parse — shorter is faster. Refresh: `pnpm bench:svg` (benchmarks chart parsers and updates `assets/bench-*.svg`).
+**Parsing to JS values, the macro build is the fastest general-purpose JS parser in the
+suite** — ahead of every library above at every grammar and size (GraphQL large: **142 µs**
+vs Peggy's 339 µs). Only a purpose-built native edges it out, `JSON.parse` on JSON.
 
-Compared parsers: **Parséman**, [Peggy](https://peggyjs.org/), [Parsimmon](https://github.com/jneen/parsimmon), [Chevrotain](https://chevrotain.io/), [Nearley](https://nearley.js.org/), and [Jison](https://github.com/zaach/jison) (plus `JSON.parse` on JSON). Each implements the same parsing work on the bench fixtures — building JS values / row arrays / GraphQL AST nodes, not syntax-only validation. Peggy grammars in `bench/*.pegjs` are the reference; Nearley JSON uses [kach/nearley `examples/json.ne`](https://github.com/kach/nearley/blob/master/examples/json.ne); other Nearley and Jison grammars are ports of those Peggy files (`bench/vendor/`).
+Two more results worth calling out: the compiled CST path beats Lezer on the JSON CST
+fixture while producing a richer tree carrying spans and trivia, and `parseDoc` stores
+parent-relative spans so an in-place edit costs a fraction of a full reparse rather than a
+multiple of it.
 
 ![JSON parsing benchmarks](https://raw.githubusercontent.com/matthew-dean/parseman/main/assets/bench-json.svg)
 
@@ -124,26 +143,29 @@ Compared parsers: **Parséman**, [Peggy](https://peggyjs.org/), [Parsimmon](http
 
 ![JSON CST parsing benchmarks](https://raw.githubusercontent.com/matthew-dean/parseman/main/assets/bench-cst-json.svg)
 
-Parséman has three modes — **interpreter** (zero setup, works anywhere), **macro build** (compiled by the bundler plugin at build time, zero runtime cost), and **`compile()`** (optional runtime JIT). Most production use lands on one of the first two. The initialization section only shows parsers with a nonzero setup cost: `compile()` costs 75–650 µs depending on grammar size; Chevrotain always costs 840–1,400 µs. Parsers not listed there start for free. (Init numbers are pinned on the charts — they're noisy run-to-run; warm-parse bars are the meaningful comparison.)
+Per-fixture figures, initialization costs, hardware, grammar provenance and how to reproduce
+any of it: **[benchmarks guide](https://matthew-dean.github.io/parseman/guide/benchmarks)**.
+Results move with grammar shape, input size and runtime — which is why the suite ships with
+the library rather than only its conclusions. Speed levers for your own grammars:
+[performance guide](https://matthew-dean.github.io/parseman/guide/performance).
 
-On JSON, CSV, and GraphQL, Parséman macro beats every other library at every fixture size in the charts above — e.g. GraphQL large **142 µs** vs Peggy **339 µs**, JSON large **141 µs** vs Peggy **466 µs** / Chevrotain **250 µs**. Native `JSON.parse` is the one thing faster on JSON (**54.6 µs** large). Even the zero-setup interpreter is highly competitive: on JSON and CSV it's the fastest option after the macro build — ahead of Peggy and every other generator — with Peggy edging it out only on GraphQL. On the CST chart, macro build beats Lezer at every size (**172 µs** vs **619 µs** large, parse-only). Full write-up and how to refresh the charts: **[benchmarks guide](https://matthew-dean.github.io/parseman/guide/benchmarks)**. Grammar-level speed levers: [performance guide](https://matthew-dean.github.io/parseman/guide/performance); library-level codegen: [PERF_IDEAS.md](./notes/PERF_IDEAS.md).
-
----
+The GraphQL fixture is a [real grammar](./examples/graphql/parser.ts), parsing executable
+documents — queries, mutations, fragments, directives, every value type — into typed AST
+nodes, so the numbers come from a spec-shaped language rather than a toy.
 
 ## Developing
 
 ```bash
 pnpm install
-pnpm test                   # Vitest — interpreter + compiler parity + ordered-choice semantics
-pnpm typecheck              # TypeScript 7
-pnpm build                  # ESM + CJS + .d.ts → dist/
-pnpm bench                  # parser-to-parser comparison
-pnpm bench:parseman         # Parseman interpreted vs compiled regression report
-pnpm bench:svg              # chart-only benchmarks + refresh assets/bench-*.svg
-pnpm bench:compile-grammars # regenerate Peggy / Nearley / Jison parser output in bench/
-pnpm docs:dev               # run this documentation site locally
+pnpm test         # interpreter + compiled parity, ordered-choice semantics
+pnpm typecheck
+pnpm build        # ESM + CJS + .d.ts → dist/
+pnpm docs:dev     # this documentation site, locally
 ```
 
+Benchmark and chart tasks (`pnpm bench`, `bench:svg`, `bench:parseman`, …) are described in
+the [benchmarks guide](https://matthew-dean.github.io/parseman/guide/benchmarks#reproducing-the-numbers).
+
 ## License
 
 MIT © [Matthew Dean](https://github.com/matthew-dean)

package/dist/combinators/expect.d.ts

@@ -7,12 +7,24 @@ export type { ParseError };
  *   literal('}')        -> ['"}"']
  *   keywords(['a','b']) -> ['"a"', '"b"']
  *   choice(x, y)        -> expected(x) ++ expected(y)   (all alternatives)
- *   sequence(a, b, …)   -> expected(a)                  (only the first term can fail first)
+ *   sequence(a, b, …)   -> expected(a) ++ … through the NULLABLE prefix
  *   label('s', x)       -> ['s']                        (an explicit name wins)
  *
  * This is what lets expect() report a meaningful, IDENTICAL expectation in both
  * the interpreter and the compiled output (the compiled path does not rebuild the
  * runtime `expected` array, so it reads this precomputed set instead).
+ *
+ * The result is DEDUPLICATED. Deriving through a nullable prefix re-reaches the
+ * same token from several terms — a value grammar whose leading terms are all
+ * optional names its value-start set once per term — and an expectation list that
+ * offers `"@{"` five times is wrong for a reader and expensive for a parser: a
+ * choice that loses every arm materializes `[...arm0, ...arm1, …]` at runtime, and
+ * those arrays feed the enclosing choice's concat in turn, so duplicates compound
+ * multiplicatively up the nesting. On jess's Less grammar the un-deduped sets cost
+ * 32% of parse time on `benchmark.less` (medians 20.7 → 14.2 ms over 100
+ * interleaved pairs, 99/100 wins, min 19.1 → 13.0), which is the whole of the Less
+ * regression 0.35.0 shipped. Dedup is not an optimisation bolted onto the
+ * derivation — a SET is what the derivation always meant.
  */
 export declare function deriveExpected(c: Combinator<unknown>): string[];
 /**

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

@@ -1 +1 @@
-{"version":3,"file":"expect.d.ts","sourceRoot":"","sources":["../../src/combinators/expect.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAyC,UAAU,EAAE,MAAM,aAAa,CAAA;AAGhG,YAAY,EAAE,UAAU,EAAE,CAAA;AAE1B;;;;;;;;;;;;;GAaG;AACH,wBAAgB,cAAc,CAAC,CAAC,EAAE,UAAU,CAAC,OAAO,CAAC,GAAG,MAAM,EAAE,CAuC/D;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,MAAM,CAAC,CAAC,EAAE,UAAU,EAAE,UAAU,CAAC,CAAC,CAAC,EAAE,KAAK,CAAC,EAAE,MAAM,GAAG,UAAU,CAAC,CAAC,GAAG,UAAU,CAAC,CA2B/F;AAED,+DAA+D;AAC/D,wBAAgB,YAAY,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,UAAU,CAEhE"}
+{"version":3,"file":"expect.d.ts","sourceRoot":"","sources":["../../src/combinators/expect.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAyC,UAAU,EAAE,MAAM,aAAa,CAAA;AAIhG,YAAY,EAAE,UAAU,EAAE,CAAA;AAE1B;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,wBAAgB,cAAc,CAAC,CAAC,EAAE,UAAU,CAAC,OAAO,CAAC,GAAG,MAAM,EAAE,CAE/D;AAkED;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,MAAM,CAAC,CAAC,EAAE,UAAU,EAAE,UAAU,CAAC,CAAC,CAAC,EAAE,KAAK,CAAC,EAAE,MAAM,GAAG,UAAU,CAAC,CAAC,GAAG,UAAU,CAAC,CA2B/F;AAED,+DAA+D;AAC/D,wBAAgB,YAAY,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,UAAU,CAEhE"}

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;AAetE;;;;;;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,CAAA;CAAE,CAAA;AAM3H,oFAAoF;AACpF,wBAAgB,yBAAyB,CAAC,GAAG,EAAE,YAAY,GAAG,OAAO,CAEpE;AAED,wBAAgB,cAAc,CAAC,GAAG,EAAE,YAAY,GAAG,kBAAkB,CAGpE;AAED,wBAAgB,cAAc,CAAC,GAAG,EAAE,YAAY,EAAE,IAAI,EAAE,kBAAkB,GAAG,IAAI,CAGhF;AAED;;;;;;;;;;;;;;;;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;AAiBD;;;GAGG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,EAAE,GAAG,EAAE,YAAY,GAAG,MAAM,CAWnF;AAED;;;GAGG;AACH,wBAAgB,UAAU,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,EAAE,GAAG,EAAE,YAAY,GAAG,UAAU,CAkCpF;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,EAAc,YAAY,EAAE,SAAS,EAAE,MAAM,aAAa,CAAA;AAetE;;;;;;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,CAAA;CAAE,CAAA;AAM3H,oFAAoF;AACpF,wBAAgB,yBAAyB,CAAC,GAAG,EAAE,YAAY,GAAG,OAAO,CAEpE;AAED,wBAAgB,cAAc,CAAC,GAAG,EAAE,YAAY,GAAG,kBAAkB,CAGpE;AAED,wBAAgB,cAAc,CAAC,GAAG,EAAE,YAAY,EAAE,IAAI,EAAE,kBAAkB,GAAG,IAAI,CAIhF;AAED;;;;;;;;;;;;;;;;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;AAiBD;;;GAGG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,EAAE,GAAG,EAAE,YAAY,GAAG,MAAM,CAWnF;AAED;;;GAGG;AACH,wBAAgB,UAAU,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,EAAE,GAAG,EAAE,YAAY,GAAG,UAAU,CAkCpF;AAED;;;GAGG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,EAAE,GAAG,EAAE,YAAY,GAAG,MAAM,CAKnF"}

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

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

package/dist/cst/capture-buffer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"capture-buffer.d.ts","sourceRoot":"","sources":["../../src/cst/capture-buffer.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,aAAa,CAAA;AAE/C,uEAAuE;AACvE,MAAM,MAAM,aAAa,GAAG;IAC1B,MAAM,CAAC,EAAE,OAAO,GAAG,SAAS,CAAA;IAC5B,EAAE,CAAC,EAAE,OAAO,EAAE,GAAG,SAAS,CAAA;IAC1B,SAAS,CAAC,EAAE,OAAO,GAAG,SAAS,CAAA;IAC/B,GAAG,CAAC,EAAE,OAAO,EAAE,GAAG,SAAS,CAAA;IAC3B,EAAE,CAAC,EAAE,MAAM,EAAE,GAAG,SAAS,CAAA;CAC1B,CAAA;AAKD,wBAAgB,gBAAgB,CAAC,GAAG,EAAE,YAAY,GAAG,OAAO,CAE3D;AAED,MAAM,MAAM,mBAAmB,GAAG;IAChC,EAAE,EAAE,YAAY,CAAC,cAAc,CAAC,CAAA;IAChC,EAAE,EAAE,YAAY,CAAC,YAAY,CAAC,CAAA;IAC9B,GAAG,EAAE,YAAY,CAAC,iBAAiB,CAAC,CAAA;IACpC,EAAE,EAAE,YAAY,CAAC,eAAe,CAAC,CAAA;IACjC,GAAG,EAAE,OAAO,GAAG,SAAS,CAAA;IACxB,GAAG,EAAE,aAAa,GAAG,SAAS,CAAA;CAC/B,CAAA;AAED,wBAAgB,mBAAmB,CAAC,GAAG,EAAE,YAAY,GAAG,mBAAmB,CAgB1E;AAED,wBAAgB,YAAY,CAAC,GAAG,EAAE,aAAa,GAAG,SAAS,GAAG;IAC5D,QAAQ,EAAE,OAAO,EAAE,CAAA;IACnB,WAAW,EAAE,OAAO,EAAE,CAAA;IACtB,SAAS,EAAE,MAAM,EAAE,CAAA;CACpB,CAMA;AAED,wBAAgB,iBAAiB,CAC/B,GAAG,EAAE,YAAY,EACjB,KAAK,EAAE,mBAAmB,GACzB;IAAE,QAAQ,EAAE,OAAO,EAAE,CAAC;IAAC,WAAW,EAAE,OAAO,EAAE,CAAC;IAAC,SAAS,EAAE,MAAM,EAAE,CAAA;CAAE,CAStE;AAED,wBAAgB,WAAW,CAAC,GAAG,EAAE,YAAY,EAAE,IAAI,EAAE,OAAO,GAAG,IAAI,CAElE;AAED,8FAA8F;AAC9F,wBAAgB,YAAY,CAAC,GAAG,EAAE,YAAY,EAAE,KAAK,EAAE,OAAO,EAAE,QAAQ,EAAE,OAAO,GAAG,IAAI,CAevF;AAED,wBAAgB,SAAS,CAAC,GAAG,EAAE,YAAY,GAAG,MAAM,CAOnD;AAED,wBAAgB,YAAY,CAAC,GAAG,EAAE,YAAY,GAAG,MAAM,CAOtD;AAED,wBAAgB,QAAQ,CAAC,GAAG,EAAE,YAAY,GAAG,MAAM,CAIlD;AAED,MAAM,MAAM,eAAe,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,CAAA;CAAE,CAAA;AAE3G,wBAAgB,WAAW,CAAC,GAAG,EAAE,YAAY,GAAG,eAAe,CAa9D;AAkBD,wBAAgB,kBAAkB,CAAC,GAAG,EAAE,YAAY,EAAE,IAAI,EAAE,eAAe,GAAG,IAAI,CAoBjF;AAED,wBAAgB,kBAAkB,CAChC,GAAG,EAAE,YAAY,EACjB,KAAK,EAAE,MAAM,EACb,GAAG,EAAE,MAAM,EACX,SAAS,CAAC,EAAE,MAAM,GACjB,IAAI,CAkBN;AAED,wBAAgB,kBAAkB,CAChC,GAAG,EAAE,YAAY,EACjB,KAAK,EAAE,MAAM,EACb,GAAG,EAAE,MAAM,EACX,SAAS,CAAC,EAAE,MAAM,GACjB,IAAI,CAON;AAED,wBAAgB,uBAAuB,CAAC,GAAG,EAAE,YAAY,GAAG,OAAO,CAElE"}
+{"version":3,"file":"capture-buffer.d.ts","sourceRoot":"","sources":["../../src/cst/capture-buffer.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,aAAa,CAAA;AAE/C,uEAAuE;AACvE,MAAM,MAAM,aAAa,GAAG;IAC1B,MAAM,CAAC,EAAE,OAAO,GAAG,SAAS,CAAA;IAC5B,EAAE,CAAC,EAAE,OAAO,EAAE,GAAG,SAAS,CAAA;IAC1B,SAAS,CAAC,EAAE,OAAO,GAAG,SAAS,CAAA;IAC/B,GAAG,CAAC,EAAE,OAAO,EAAE,GAAG,SAAS,CAAA;IAC3B,EAAE,CAAC,EAAE,MAAM,EAAE,GAAG,SAAS,CAAA;CAC1B,CAAA;AAKD,wBAAgB,gBAAgB,CAAC,GAAG,EAAE,YAAY,GAAG,OAAO,CAE3D;AAED,MAAM,MAAM,mBAAmB,GAAG;IAChC,EAAE,EAAE,YAAY,CAAC,cAAc,CAAC,CAAA;IAChC,EAAE,EAAE,YAAY,CAAC,YAAY,CAAC,CAAA;IAC9B,GAAG,EAAE,YAAY,CAAC,iBAAiB,CAAC,CAAA;IACpC,EAAE,EAAE,YAAY,CAAC,eAAe,CAAC,CAAA;IACjC,GAAG,EAAE,OAAO,GAAG,SAAS,CAAA;IACxB,GAAG,EAAE,aAAa,GAAG,SAAS,CAAA;CAC/B,CAAA;AAED,wBAAgB,mBAAmB,CAAC,GAAG,EAAE,YAAY,GAAG,mBAAmB,CAgB1E;AAED,wBAAgB,YAAY,CAAC,GAAG,EAAE,aAAa,GAAG,SAAS,GAAG;IAC5D,QAAQ,EAAE,OAAO,EAAE,CAAA;IACnB,WAAW,EAAE,OAAO,EAAE,CAAA;IACtB,SAAS,EAAE,MAAM,EAAE,CAAA;CACpB,CAMA;AAED,wBAAgB,iBAAiB,CAC/B,GAAG,EAAE,YAAY,EACjB,KAAK,EAAE,mBAAmB,GACzB;IAAE,QAAQ,EAAE,OAAO,EAAE,CAAC;IAAC,WAAW,EAAE,OAAO,EAAE,CAAC;IAAC,SAAS,EAAE,MAAM,EAAE,CAAA;CAAE,CAStE;AAED,wBAAgB,WAAW,CAAC,GAAG,EAAE,YAAY,EAAE,IAAI,EAAE,OAAO,GAAG,IAAI,CAElE;AAED,8FAA8F;AAC9F,wBAAgB,YAAY,CAAC,GAAG,EAAE,YAAY,EAAE,KAAK,EAAE,OAAO,EAAE,QAAQ,EAAE,OAAO,GAAG,IAAI,CAevF;AAED,wBAAgB,SAAS,CAAC,GAAG,EAAE,YAAY,GAAG,MAAM,CAOnD;AAED,wBAAgB,YAAY,CAAC,GAAG,EAAE,YAAY,GAAG,MAAM,CAOtD;AAED,wBAAgB,QAAQ,CAAC,GAAG,EAAE,YAAY,GAAG,MAAM,CAIlD;AAED,MAAM,MAAM,eAAe,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,CAAA;CAAE,CAAA;AAE3G,wBAAgB,WAAW,CAAC,GAAG,EAAE,YAAY,GAAG,eAAe,CAa9D;AAwBD,wBAAgB,kBAAkB,CAAC,GAAG,EAAE,YAAY,EAAE,IAAI,EAAE,eAAe,GAAG,IAAI,CA4BjF;AAED,wBAAgB,kBAAkB,CAChC,GAAG,EAAE,YAAY,EACjB,KAAK,EAAE,MAAM,EACb,GAAG,EAAE,MAAM,EACX,SAAS,CAAC,EAAE,MAAM,GACjB,IAAI,CAkBN;AAED,wBAAgB,kBAAkB,CAChC,GAAG,EAAE,YAAY,EACjB,KAAK,EAAE,MAAM,EACb,GAAG,EAAE,MAAM,EACX,SAAS,CAAC,EAAE,MAAM,GACjB,IAAI,CAON;AAED,wBAAgB,uBAAuB,CAAC,GAAG,EAAE,YAAY,GAAG,OAAO,CAElE"}

package/dist/index.cjs

@@ -441,28 +441,28 @@ function rollbackBufList(b, keyMulti, keySingle, len) {
     else if (len === 1) {
       b[keySingle] = arr[0];
       b[keyMulti] = void 0;
-    } else arr.length = len;
+    } else if (arr.length !== len) arr.length = len;
     return;
   }
   if (len === 0) b[keySingle] = void 0;
 }
 function rollbackCstCapture(ctx, mark) {
-  if (ctx._errors && mark.errors !== void 0) ctx._errors.length = mark.errors;
+  if (ctx._errors && mark.errors !== void 0 && ctx._errors.length !== mark.errors) ctx._errors.length = mark.errors;
   const b = ctx._cstBuf;
   if (b) {
     rollbackBufList(b, "raw", "rawSingle", mark.raw);
     rollbackBufList(b, "ch", "single", mark.leaves);
     if (b.tl) {
       if (mark.tlog === 0) b.tl = void 0;
-      else b.tl.length = mark.tlog;
+      else if (b.tl.length !== mark.tlog) b.tl.length = mark.tlog;
     }
-    if (ctx._fields) ctx._fields.length = mark.fields;
+    if (ctx._fields && ctx._fields.length !== mark.fields) ctx._fields.length = mark.fields;
     return;
   }
-  if (ctx._cstRawChildren) ctx._cstRawChildren.length = mark.raw;
-  if (ctx._cstTriviaLog) ctx._cstTriviaLog.length = mark.tlog;
-  if (ctx._cstLeaves) ctx._cstLeaves.length = mark.leaves;
-  if (ctx._fields) ctx._fields.length = mark.fields;
+  if (ctx._cstRawChildren && ctx._cstRawChildren.length !== mark.raw) ctx._cstRawChildren.length = mark.raw;
+  if (ctx._cstTriviaLog && ctx._cstTriviaLog.length !== mark.tlog) ctx._cstTriviaLog.length = mark.tlog;
+  if (ctx._cstLeaves && ctx._cstLeaves.length !== mark.leaves) ctx._cstLeaves.length = mark.leaves;
+  if (ctx._fields && ctx._fields.length !== mark.fields) ctx._fields.length = mark.fields;
 }
 function pushCstTriviaEntry(ctx, start, end, kindIndex) {
   const insertIdx = cstRawLen(ctx);
@@ -1155,6 +1155,10 @@ var REC = { scan: recoverScan, at: matchesAt, or: orSentinel, sentinel: firstSet
 
 // src/combinators/expect.ts
 function deriveExpected(c) {
+  return [...new Set(derive(c, /* @__PURE__ */ new Set()))];
+}
+function derive(c, seen) {
+  const deriveExpected2 = (p) => derive(p, seen);
   const def = c._def;
   switch (def.tag) {
     case "literal":
@@ -1166,20 +1170,32 @@ function deriveExpected(c) {
     case "label":
       return [def.label];
     case "choice":
-      return def.parsers.flatMap(deriveExpected);
-    case "sequence":
-      return def.parsers.length > 0 ? deriveExpected(def.parsers[0]) : [];
+      return def.parsers.flatMap(deriveExpected2);
+    // Union through the NULLABLE prefix, mirroring `sequenceFirstSet`. A leading
+    // `optional(…)`/`many(…)` can match nothing, so the term after it is equally
+    // able to fail first — deriving from term 0 alone named a token the parse
+    // never actually required. A leading `not(…)` is zero-width and contributes
+    // nothing (its own expectation is about what must NOT be here), but it is
+    // nullable, so keep scanning past it. Stop at the first term that must match.
+    case "sequence": {
+      const out = [];
+      for (const term of def.parsers) {
+        if (!isZeroWidthAssertion(term)) out.push(...deriveExpected2(term));
+        if (!matchesEmpty(term)) break;
+      }
+      return out;
+    }
     case "attempt":
-      return deriveExpected(def.parser);
+      return deriveExpected2(def.parser);
     // Delegating wrappers whose first-token failure is their inner parser's — must
     // pass through so a start-failure (and the first-set-miss fast-path in attempt/
     // node, which reads this) names the real expected token, not the wrapper tag.
     case "field":
     case "withCtx":
     case "recover":
-      return deriveExpected(def.parser);
+      return deriveExpected2(def.parser);
     case "skip":
-      return deriveExpected(def.main);
+      return deriveExpected2(def.main);
     case "expect":
       return def.expected;
     case "node":
@@ -1193,13 +1209,17 @@ function deriveExpected(c) {
     case "transform":
     case "not":
     case "peek":
-      return deriveExpected(def.parser);
+      return deriveExpected2(def.parser);
     case "lazy": {
       const name = c._ruleName;
+      if (seen.has(c)) return name ? [name] : [];
+      seen.add(c);
       try {
-        return deriveExpected(def.thunk());
+        return deriveExpected2(def.thunk());
       } catch {
         return name ? [name] : [];
+      } finally {
+        seen.delete(c);
       }
     }
     default:
@@ -1330,14 +1350,14 @@ function choice(...args) {
         const result = parsers[i].parse(input, pos, ctx);
         if (!result.ok) {
           rollbackCstCapture(ctx, mark);
-          if (logLen !== void 0 && ctx._triviaLog) ctx._triviaLog.length = logLen;
+          if (logLen !== void 0 && ctx._triviaLog && ctx._triviaLog.length !== logLen) ctx._triviaLog.length = logLen;
           expected.push(...result.expected);
           continue;
         }
         const checks = autoNot[i];
         if (checks && autoNotFires(input, result.span.end, checks)) {
           rollbackCstCapture(ctx, mark);
-          if (logLen !== void 0 && ctx._triviaLog) ctx._triviaLog.length = logLen;
+          if (logLen !== void 0 && ctx._triviaLog && ctx._triviaLog.length !== logLen) ctx._triviaLog.length = logLen;
           continue;
         }
         return result;
@@ -1664,7 +1684,7 @@ function saveTriviaMark(ctx) {
 }
 function rollbackTrivia(ctx, mark) {
   rollbackCstCapture(ctx, { raw: mark.raw, tlog: mark.tlog, leaves: mark.leaves, fields: mark.fields, errors: mark.errors });
-  if (ctx._triviaLog) ctx._triviaLog.length = mark.log;
+  if (ctx._triviaLog && ctx._triviaLog.length !== mark.log) ctx._triviaLog.length = mark.log;
 }
 function saveLookaheadMark(ctx) {
   return { ...saveTriviaMark(ctx), probeBest: ctx._probe ? ctx._probe.best : null };
@@ -2032,7 +2052,7 @@ function attempt(parser2) {
       const result = parser2.parse(input, pos, ctx);
       if (result.ok) return result;
       rollbackCstCapture(ctx, mark);
-      if (log !== void 0 && ctx._triviaLog) ctx._triviaLog.length = log;
+      if (log !== void 0 && ctx._triviaLog && ctx._triviaLog.length !== log) ctx._triviaLog.length = log;
       return { ok: false, expected: result.expected, span: { start: pos, end: pos } };
     }
   };
@@ -3106,7 +3126,7 @@ function leaf(root, fn) {
 }
 
 // src/version.ts
-var PARSEMAN_VERSION = "0.34.0";
+var PARSEMAN_VERSION = "0.36.0";
 
 // src/analysis/gating.ts
 var isAny = (fs) => fs.kind === "any";
@@ -5297,9 +5317,9 @@ function planDisjointDispatch(parsers) {
   return total >= SWITCH_MIN_CASES ? { kind: "switch", cases } : { kind: "if" };
 }
 function captureRestoreBody(mL, mR, mTl, mLg, mF = null) {
-  const fieldRestore = mF ? `; if (_ctx._fields) _ctx._fields.length = ${mF}` : "";
-  const base = `if (_ctx._cstLeaves) _ctx._cstLeaves.length = ${mL}; if (_ctx._cstRawChildren) _ctx._cstRawChildren.length = ${mR}; if (_ctx._cstTriviaLog) _ctx._cstTriviaLog.length = ${mTl}${fieldRestore}`;
-  return mLg ? `${base}; if (_ctx._triviaLog) _ctx._triviaLog.length = ${mLg}` : base;
+  const fieldRestore = mF ? `; if (_ctx._fields && _ctx._fields.length !== ${mF}) _ctx._fields.length = ${mF}` : "";
+  const base = `if (_ctx._cstLeaves && _ctx._cstLeaves.length !== ${mL}) _ctx._cstLeaves.length = ${mL}; if (_ctx._cstRawChildren && _ctx._cstRawChildren.length !== ${mR}) _ctx._cstRawChildren.length = ${mR}; if (_ctx._cstTriviaLog && _ctx._cstTriviaLog.length !== ${mTl}) _ctx._cstTriviaLog.length = ${mTl}${fieldRestore}`;
+  return mLg ? `${base}; if (_ctx._triviaLog && _ctx._triviaLog.length !== ${mLg}) _ctx._triviaLog.length = ${mLg}` : base;
 }
 function mayLeavePartialCapture(p, seen = /* @__PURE__ */ new Set()) {
   if (seen.has(p)) return false;
@@ -5661,7 +5681,7 @@ function emitSeqValues(def, ctx, pos) {
         const endAfterV = v(ctx, "_sea");
         stmts.push(
           `${ind(ctx)}const ${endAfterV} = ${r2.endVar}`,
-          `${ind(ctx)}if (${endAfterV} > ${scanEndV}) { ${curV} = ${endAfterV} } else { if (_ctx._cstRawChildren) _ctx._cstRawChildren.length = ${markV}; if (_ctx._cstTriviaLog) _ctx._cstTriviaLog.length = ${markTl}; if (_ctx._triviaLog) _ctx._triviaLog.length = ${markLog}; }`
+          `${ind(ctx)}if (${endAfterV} > ${scanEndV}) { ${curV} = ${endAfterV} } else { if (_ctx._cstRawChildren && _ctx._cstRawChildren.length !== ${markV}) _ctx._cstRawChildren.length = ${markV}; if (_ctx._cstTriviaLog && _ctx._cstTriviaLog.length !== ${markTl}) _ctx._cstTriviaLog.length = ${markTl}; if (_ctx._triviaLog && _ctx._triviaLog.length !== ${markLog}) _ctx._triviaLog.length = ${markLog}; }`
         );
         valueVars.push(r2.valueVar);
         continue;
@@ -6148,7 +6168,7 @@ function emitMany(def, ctx, pos) {
         `${ind(ctx)}const ${npV} = ${capFn}(input, ${curV}, _ctx, 1)`
       );
       itemPos = npV;
-      rollback = `if (_ctx._cstRawChildren) _ctx._cstRawChildren.length = ${markV}; if (_ctx._cstTriviaLog) _ctx._cstTriviaLog.length = ${markTl}; if (_ctx._triviaLog) _ctx._triviaLog.length = ${markLog}; `;
+      rollback = `if (_ctx._cstRawChildren && _ctx._cstRawChildren.length !== ${markV}) _ctx._cstRawChildren.length = ${markV}; if (_ctx._cstTriviaLog && _ctx._cstTriviaLog.length !== ${markTl}) _ctx._cstTriviaLog.length = ${markTl}; if (_ctx._triviaLog && _ctx._triviaLog.length !== ${markLog}) _ctx._triviaLog.length = ${markLog}; `;
     } else {
       const trivFn = ensureTriviaFn(ctx);
       const npV = v(ctx, "_np");
@@ -6211,7 +6231,7 @@ function emitAttempt(p, def, ctx, pos) {
   const log = v(ctx, "_atg");
   const fields = v(ctx, "_atf");
   const errors = v(ctx, "_ate");
-  const rollback = `if (_ctx._cstLeaves) _ctx._cstLeaves.length = ${leaves}; if (_ctx._cstRawChildren) _ctx._cstRawChildren.length = ${raw}; if (_ctx._cstTriviaLog) _ctx._cstTriviaLog.length = ${trivia2}; if (_ctx._triviaLog) _ctx._triviaLog.length = ${log}; if (_ctx._fields) _ctx._fields.length = ${fields}; if (_ctx._errors) _ctx._errors.length = ${errors}`;
+  const rollback = `if (_ctx._cstLeaves && _ctx._cstLeaves.length !== ${leaves}) _ctx._cstLeaves.length = ${leaves}; if (_ctx._cstRawChildren && _ctx._cstRawChildren.length !== ${raw}) _ctx._cstRawChildren.length = ${raw}; if (_ctx._cstTriviaLog && _ctx._cstTriviaLog.length !== ${trivia2}) _ctx._cstTriviaLog.length = ${trivia2}; if (_ctx._triviaLog && _ctx._triviaLog.length !== ${log}) _ctx._triviaLog.length = ${log}; if (_ctx._fields && _ctx._fields.length !== ${fields}) _ctx._fields.length = ${fields}; if (_ctx._errors && _ctx._errors.length !== ${errors}) _ctx._errors.length = ${errors}`;
   const traceId = ctx.coverage?.plan.attempts.get(p);
   const traceRollback = traceId === void 0 ? "" : ` _ctx._grammarTrace?.write({ id: ${JSON.stringify(traceId)}, phase: 'rollback', offset: ${pos} });`;
   const preGuard = [];
@@ -6274,7 +6294,7 @@ function emitSepBy(_p, def, ctx, pos) {
         `${ind(ctx)}const ${tl} = _ctx._cstTriviaLog ? _ctx._cstTriviaLog.length : 0`,
         `${ind(ctx)}const ${lg} = _ctx._triviaLog ? _ctx._triviaLog.length : 0`
       ],
-      rb: `if (_ctx._cstLeaves) _ctx._cstLeaves.length = ${lv}; if (_ctx._cstRawChildren) _ctx._cstRawChildren.length = ${rw}; if (_ctx._cstTriviaLog) _ctx._cstTriviaLog.length = ${tl}; if (_ctx._triviaLog) _ctx._triviaLog.length = ${lg}; `
+      rb: `if (_ctx._cstLeaves && _ctx._cstLeaves.length !== ${lv}) _ctx._cstLeaves.length = ${lv}; if (_ctx._cstRawChildren && _ctx._cstRawChildren.length !== ${rw}) _ctx._cstRawChildren.length = ${rw}; if (_ctx._cstTriviaLog && _ctx._cstTriviaLog.length !== ${tl}) _ctx._cstTriviaLog.length = ${tl}; if (_ctx._triviaLog && _ctx._triviaLog.length !== ${lg}) _ctx._triviaLog.length = ${lg}; `
     };
   };
   if (rec) {
@@ -6320,7 +6340,7 @@ function emitSepBy(_p, def, ctx, pos) {
         `${ind(ctx)}const ${spV} = ${capFn}(input, ${curV}, _ctx, 1)`
       );
       sepAtPos = spV;
-      const rollbackToSep = `if (_ctx._cstLeaves) _ctx._cstLeaves.length = ${markLv}; if (_ctx._cstRawChildren) _ctx._cstRawChildren.length = ${markV}; if (_ctx._cstTriviaLog) _ctx._cstTriviaLog.length = ${markTl}; if (_ctx._triviaLog) _ctx._triviaLog.length = ${markLog}; `;
+      const rollbackToSep = `if (_ctx._cstLeaves && _ctx._cstLeaves.length !== ${markLv}) _ctx._cstLeaves.length = ${markLv}; if (_ctx._cstRawChildren && _ctx._cstRawChildren.length !== ${markV}) _ctx._cstRawChildren.length = ${markV}; if (_ctx._cstTriviaLog && _ctx._cstTriviaLog.length !== ${markTl}) _ctx._cstTriviaLog.length = ${markTl}; if (_ctx._triviaLog && _ctx._triviaLog.length !== ${markLog}) _ctx._triviaLog.length = ${markLog}; `;
       const { stmts: sepStmts, okVar: sepOk, endVar: sepEnd } = emitFallible(def.separator, ctx, sepAtPos, true);
       stmts.push(...sepStmts, `${ind(ctx)}if (!${sepOk}) { ${rollbackToSep}break }`);
       const post = postSepMarks();
@@ -6362,7 +6382,7 @@ function emitSepBy(_p, def, ctx, pos) {
     }
     const { stmts: sepStmts, okVar: sepOk, endVar: sepEnd } = emitFallible(def.separator, ctx, sepAtPos, true);
     stmts.push(...sepStmts, `${ind(ctx)}if (!${sepOk}) break`);
-    const nextRb = markLv ? `if (_ctx._cstLeaves) _ctx._cstLeaves.length = ${markLv}; if (_ctx._cstRawChildren) _ctx._cstRawChildren.length = ${markRw}; ` : "";
+    const nextRb = markLv ? `if (_ctx._cstLeaves && _ctx._cstLeaves.length !== ${markLv}) _ctx._cstLeaves.length = ${markLv}; if (_ctx._cstRawChildren && _ctx._cstRawChildren.length !== ${markRw}) _ctx._cstRawChildren.length = ${markRw}; ` : "";
     const post = postSepMarks();
     stmts.push(...post.decl);
     const { stmts: nextStmts, okVar: nextOk, valVar: nextVal, endVar: nextEnd } = emitFallible(def.parser, ctx, sepEnd, true);
@@ -6447,7 +6467,7 @@ function emitNot(def, ctx, pos) {
       ] : [],
       ...stmts,
       ...sinksLive ? [
-        `${ind(ctx)}if (_ctx._cstLeaves) _ctx._cstLeaves.length = ${leaves}; if (_ctx._cstRawChildren) _ctx._cstRawChildren.length = ${raw}; if (_ctx._cstTriviaLog) _ctx._cstTriviaLog.length = ${tl}; if (_ctx._triviaLog) _ctx._triviaLog.length = ${log}; if (_ctx._fields) _ctx._fields.length = ${fields}; if (_ctx._errors) _ctx._errors.length = ${errors}`
+        `${ind(ctx)}if (_ctx._cstLeaves && _ctx._cstLeaves.length !== ${leaves}) _ctx._cstLeaves.length = ${leaves}; if (_ctx._cstRawChildren && _ctx._cstRawChildren.length !== ${raw}) _ctx._cstRawChildren.length = ${raw}; if (_ctx._cstTriviaLog && _ctx._cstTriviaLog.length !== ${tl}) _ctx._cstTriviaLog.length = ${tl}; if (_ctx._triviaLog && _ctx._triviaLog.length !== ${log}) _ctx._triviaLog.length = ${log}; if (_ctx._fields && _ctx._fields.length !== ${fields}) _ctx._fields.length = ${fields}; if (_ctx._errors && _ctx._errors.length !== ${errors}) _ctx._errors.length = ${errors}`
       ] : [],
       ...emitIfFail(ctx, okVar, failBody(ctx, label2, pos))
     ],