Go modules · #2371

github.com/odvcencio/gotreesitter

v0.51.0odvcencio/gotreesitter ↗

Last release 2 days ago
26 Aug 2026
Ships on a steady schedule
a new release about every 9 days
Nearly every release is documented
notes for 59 of the last 60 stable releases
Nothing withdrawn
no release was ever pulled
6 months old
640 releases · first in 2026

Release timeline

640 releases since 2026

2026

Releases

v0.47.2-0.20260729172403-b0273ea0815d29 Jul 2026pre-release
Nothing published for this version
v0.47.2-0.20260729162255-eb15d4c0c2da29 Jul 2026pre-release
Nothing published for this version
v0.47.2-0.20260729151918-b34cc797401f29 Jul 2026pre-release
Nothing published for this version
v0.47.2-0.20260729133306-c5730b2c4e3129 Jul 2026pre-release
Nothing published for this version
v0.47.2-0.20260729124010-4f077315d3aa29 Jul 2026pre-release
Nothing published for this version
v0.47.2-0.20260729113843-715fc1e89da929 Jul 2026pre-release
Nothing published for this version
v0.47.2-0.20260729104240-a3dc23ed053b29 Jul 2026pre-release
Nothing published for this version
v0.47.2-0.20260729090234-d2faa94bd9e229 Jul 2026pre-release
Nothing published for this version
v0.47.2-0.20260729073016-2226fcc3916d29 Jul 2026pre-release
Nothing published for this version
v0.47.2-0.20260729060524-2ef4802f2dbb29 Jul 2026pre-release
Nothing published for this version
v0.47.2-0.20260729043947-f2d9b9e64c8829 Jul 2026pre-release
Nothing published for this version
v0.47.2-0.20260729013312-36c9a359ccb929 Jul 2026pre-release
Nothing published for this version
v0.47.2-0.20260729005802-40189696238629 Jul 2026pre-release
Nothing published for this version
v0.47.2-0.20260728225741-c00635cc8d1128 Jul 2026pre-release
Nothing published for this version
v0.47.2-0.20260728222825-f65819dc58fd28 Jul 2026pre-release
Nothing published for this version
v0.47.2-0.20260728205438-3340fad0a21d28 Jul 2026pre-release
Nothing published for this version
v0.47.2-0.20260728203121-12e2e2dfbea628 Jul 2026pre-release
Nothing published for this version
v0.47.128 Jul 2026
Release notes
Fixed
- Recovery reductions preserve deferred parent links during fresh parses.
  Valid Go files remain complete during final result materialization.
  The invariant guard still rejects invalid transient replacements.
Open source →
Additional notes2 sources agree
Fixed
- Recovery reductions preserve deferred parent links during fresh parses. Valid Go files remain complete during final result materialization. The invariant guard still rejects invalid transient replacements.
Open source →
v0.47.1-0.20260728190739-e5ac093c4a5128 Jul 2026pre-release
Nothing published for this version
v0.47.1-0.20260728160649-61cb2c38b20d28 Jul 2026pre-release
Nothing published for this version
v0.47.1-0.20260728153316-9cf969cc5aa328 Jul 2026pre-release
Nothing published for this version
v0.47.1-0.20260728141838-b8f61b59234628 Jul 2026pre-release
Nothing published for this version
v0.47.1-0.20260728002733-f639fbaa2fab28 Jul 2026pre-release
Nothing published for this version
v0.47.1-0.20260727214440-51a13671cb1527 Jul 2026pre-release
Nothing published for this version
v0.47.1-0.20260727194930-a53341670ecf27 Jul 2026pre-release
Nothing published for this version
v0.47.1-0.20260727184754-eef96dcbf3a627 Jul 2026pre-release
Nothing published for this version
v0.47.1-0.20260727154701-5fa395baacc727 Jul 2026pre-release
Nothing published for this version
v0.47.1-0.20260727144309-5ad6e29cb09027 Jul 2026pre-release
Nothing published for this version
v0.47.1-0.20260727133549-ac1de11fcdcb27 Jul 2026pre-release
Nothing published for this version
v0.47.1-0.20260727123815-00b3bebe168827 Jul 2026pre-release
Nothing published for this version
v0.47.1-0.20260727111802-36261cd8c4db27 Jul 2026pre-release
Nothing published for this version
v0.47.1-0.20260727082420-e48baa42d0ac27 Jul 2026pre-release
Nothing published for this version
v0.47.1-0.20260727060829-18080c91d6da27 Jul 2026pre-release
Nothing published for this version
v0.47.1-0.20260727043931-14a9701a472727 Jul 2026pre-release
Nothing published for this version
v0.47.1-0.20260726214746-330d7c68634a26 Jul 2026pre-release
Nothing published for this version
v0.47.1-0.20260726204211-72556520032426 Jul 2026pre-release
Nothing published for this version
v0.47.1-0.20260726092233-ede12f6e42a126 Jul 2026pre-release
Nothing published for this version
v0.47.1-0.20260726044557-f590db193f2726 Jul 2026pre-release
Nothing published for this version
v0.47.1-0.20260725101228-f074df8d69f825 Jul 2026pre-release
Nothing published for this version
v0.47.023 Jul 2026
Release notes
This release closes the generalized incremental-correctness campaign: capability-based scanner admission, exact checkpoint receipts for stateful GSS forest reuse, strict ownership and fail-closed boundaries, JavaScript/TypeScript incremental scheduling work, and broader stateless-scanner admission. It also refreshes repository and release hygiene. See CHANGELOG.md for the complete evidence and residuals. This is the final planned off-cadence minor; planned minor releases move to Thursdays in America/Los_Angeles.
Open source →
Additional notes2 sources agree
Changed
- Stateful GSS forest trees now enter incremental reuse through exact checkpoint receipts. Admission requires the scanner's generic checkpoint and incremental-reuse capabilities, then authenticates non-empty start and end snapshots at every reachable token boundary. A missing endpoint declines the forest as scanner_checkpoint_unavailable instead of letting distinct unrepresentable states collide as empty snapshots. A length-changing stateful witness requires actual subtree reuse and deep fresh-tree equality; a synthetic absent-checkpoint scanner locks the fail-closed path.
- GSS forest trees now use capability-based incremental admission. Forest construction records exact pre-goto ownership for every reusable subtree, and the reuse cursor requires that ownership before transferring top-level nodes. Languages without an external scanner, plus scanners with an explicit stateless/failure-preserving proof, can therefore reuse forest-built trees without a language-name allowlist. AWK, KDL, Nix, Squirrel, and Uxntal are newly admitted through a shared multi-position and 137 KiB fresh-tree differential.
- JavaScript, TypeScript, and TSX leading incremental reuse is admitted. The generic byte-identity, fragility, and scanner gates now govern unchanged leading siblings without a language-name holdback. Exhaustive clean byte-edit sweeps compare the complete incremental tree directly with a fresh parse, and the 20 KiB/137 KiB latency gate plus its opt-in 1 MiB tier lock middle and end edits to small, size-independent work counters. Transient-error insert/delete/replace edits retain separate recovery and memory bounds.
- TypeScript and TSX now parse import-type queries in generic call type arguments. Forms such as foo<typeof import("module")>() and foo<import("module").Name>() use a pinned upstream grammar overlay that is applied identically during ts2go generation and C-oracle parity builds. Ordinary dynamic import() expressions remain call expressions.
- Eight additional stateless scanners are certified for changed-edit reuse: Comment, Dhall, DTD, Foam, Godot Resource, Kconfig, Odin, and RON. Each passes the shared multi-position 4 KiB edit matrix and a 137 KiB changed-length fresh-tree differential with actual subtree reuse. Kconfig's deliberately small 16-byte macro floor keeps its parser-level ownership residual visible without treating performance as a correctness gate.
- Twelve more stateless scanners are certified for changed-edit reuse: EditorConfig, Fennel, Fish, GN, Janet, Julia, Less, Liquid, Pkl, Racket, TableGen, and Yuck. The shared fresh-tree matrix enforces real reuse across edit classes and positions, with measured 137 KiB floors that preserve low ownership-reuse cases as visible performance residuals.
- The stateless-scanner admission matrix now also covers Gleam, Move, Tcl, and WGSL. Each scanner passes the shared 4 KiB multi-position edit matrix and 137 KiB fresh-tree differential with a measured reuse floor. AWK and Squirrel remain fail-closed because their old trees use the GSS forest fast path; scanner statelessness alone does not bypass that parser-level gate.
- Stateless external-scanner reuse now covers Cue, D, Elixir, and Erlang. Capability markers replace language-name admission, while a strict recorded pre-goto ownership check prevents stale whole-sibling transfer for the certified stateless class. A shared differential matrix covers insert/delete/replace edits across 4 KiB fixtures and a 137 KiB macro lane, requiring real reuse and exact fresh-tree identity. Checkpointed reuse also authenticates scanner state at the current lookahead's start rather than its post-lex live state. Stateful scanners without a complete proof remain fail-closed.
- HTML external-scanner reuse is checkpoint-certified for clean old trees. The complete open-tag stack now serializes exactly or returns an absent checkpoint; oversized depth, custom names, and buffer exhaustion can no longer truncate or alias state. Malformed checkpoint bytes are rejected, failed scans preserve state, and token relexing rejects absent start or live checkpoints. Changed-length edit witnesses at three positions plus a 137 KiB lane require real reuse and fresh-tree equality. Error-bearing old HTML trees remain an explicit fresh-parse fallback while recovery ownership is still uncertified.
- SQL external-scanner reuse is now checkpoint-certified. The runtime's checkpoint and checkpointless-reuse gates are capability based rather than language-name allowlists. SQL records a complete dollar-quote-tag state whenever it fits the checkpoint buffer (including an explicit empty-state checkpoint), preserves that state on failed scans, and fails closed only for incremental reuse when a valid tag is too large to restore exactly; full parsing continues to accept the tag, matching C semantics. Svelte remains opted out of changed-edit reuse pending certification of its scanner-wide raw-text and expression-block behavior. Clean and recovered insert/delete/replace witnesses at the start, middle, and end of roughly 20 KiB and 137 KiB files enforce fresh-tree equality, full-span coverage, deterministic work, and bounded memory; an opt-in tier repeats the matrix at 1 MiB. This is a correctness/admission certification, not an O(edit) claim: the 1 MiB lane is catastrophe-bounded and its measured allocation/RSS scaling remains an explicit performance residual.
- Collapsed named-leaf ownership now covers exact adapted artifacts. The 23 registered parent/raw-child pairs compile into the native reduction, alias, forest, and compact-materialization policy for exact built-ins as well as true adapted clones retaining the exact-profile receipt and exact named parent/raw-child metadata identities; display-name or pair-level metadata matches do not admit arbitrary custom grammars. Focused adapted incremental/fresh witnesses require exact deep-tree equality and zero safety-net rewrites. A quantified synthetic lost-identity residual remains unsupported because its live construction provenance is unknown. No language-specific normalizer was added.
Open source →
v0.46.022 Jul 2026
Release notes
Highlights
- Compact parser admission is ratcheted at 166 byte-exact routes out of 206 fixtures, with 35 fail-closed fallbacks and 5 token-source skips.
- Certified collapsed named leaves now materialize natively; compatibility passes have explicit ownership, witnesses, and retirement criteria.
- The editor gate now covers Go, JavaScript, TypeScript, Python, and CSS across insert, delete, and replace edits at start, middle, and end for roughly 20 KiB and 137 KiB sources, plus a manual 1 MiB tier.
- JavaScript and TypeScript transient-error deletes have deterministic parser-work, retry, stack, node, and memory bounds while remaining structurally equal to fresh parses.
- All 119 registered external scanners have a published, drift-tested incremental-reuse contract. SQL, HTML, and Markdown explicitly fail closed to the production full-parse path after the narrow token-invariant leaf exception declines.
- Incremental documentation now states the measured cost model: cheap edited-region parse work plus linear coordinate maintenance for affected trailing siblings, not an absolute O(edit) guarantee.
Evidence
- PR #428: #428
- Final-SHA CI, including root race and exhaustive cgo parity: https://github.com/odvcencio/gotreesitter/actions/runs/29892883776
- Manual full editor gate, 20 KiB / 137 KiB / 1 MiB: https://github.com/odvcencio/gotreesitter/actions/runs/29892922471/job/88836872560
Known limits
- Uncertified or explicitly opted-out external scanners retain the documented production full-parse fallback.
- JavaScript and TypeScript leading-prefix splice proof remains conservative for some middle and end edits; the new gates bound this behavior rather than claiming it is eliminated.
- Performance improvement beyond the ratcheted correctness and memory band remains ongoing work rather than a release gate.
Open source →
Additional notes2 sources agree
Added
- Phase-3 admission switch (PR #417). A per-parser option, a global option, and the GTS_ADMISSION_CANDIDATE environment variable route eligible full parses through the compact parser core. Internal sub-parsers stay suppressed. A 206-language scorecard guards the route: 48 languages parse byte-exact, 153 fall back fail-closed, 5 skip, 0 diverge. It initially landed off by default; the Changed entry below records its promotion after the admission evidence was sealed.
- Compact-route coverage census (PR #419). docs/compact-route-coverage-census.md classifies the 153 fallback languages into five scheduler-capability classes. The census found no multi-derivation blockers.
- Oracle v3 parity tools in cgo_harness (PR #413). The root library module is unchanged by that PR.
- The W5 editor-latency matrix now covers five languages. Go, JavaScript, TypeScript, Python, and CSS run insert, delete, and replace edits at the start, middle, and end of roughly 20 KiB and 137 KiB inputs; the manual full sweep adds 1 MiB. JavaScript and TypeScript also carry a transient-error delete lane with deterministic ceilings for parser work, retries, stack width, and allocator memory, while retaining fresh-parse structural equality as the correctness oracle.
- External-scanner incremental-reuse contracts are now published per language. The 119-language matrix distinguishes certified, bounded, explicit-opt-out, and uncertified scanners. SQL, HTML, and Markdown now document their fail-closed production full-parse fallback for changed edits after the narrow token-invariant leaf exception declines.
Changed
- Result compatibility cleanup. A source-of-truth ownership registry, supporting documentation, and a CI guard now track compatibility passes and their retirement criteria. The dead terminal-normalization wrapper was removed, along with the unreferenced walkResultTreePostorderUntil and rewriteResultTreeChildrenPostorderWithStats traversal helpers. Recovered-tree cycle repair was replaced by an always-on, non-mutating validator that fails closed with the public ParseStopInvariantViolation reason. The roadmap now puts repository maintenance, explainability, documentation, ownership receipts, and upstream retirement of normalization shims before the next major performance milestone; performance gates remain advisory during this cleanup. All 23 collapsed named-leaf rows for six exact-profile built-in languages now materialize natively across their admitted routes. The generic compatibility walk and its synthetic reconstruction helpers are retired; exact-profile adapted artifacts retain the native route, while unregistered custom artifacts fail closed instead of inferring children from display names.
- Compact admission now ratchets breadth, depth, and edit reuse. The shared production clean-tail proof admits compact roots that stop immediately before trailing parser padding, raising the 206-language smoke scorecard from 48 to 166 byte-exact routes (35 fail-closed fallbacks, 5 token-source skips, 0 divergences). Representative multi-line fixtures freeze production and candidate digests, while CI enforces both the breadth floor and routed depth. Admission materialization now carries a per-tree parser-state replay proof: grammars with complete required states and proven scanner quiescence retain incremental subtree reuse; unproven/stateful scanners remain barred, apart from independently re-lexed token-invariant single-leaf edits. Certified or explicitly requested forest routes retain precedence unless the caller explicitly forces the compact candidate.
- The compact parser core is now the default full-parse route for eligible languages (Phase-3 admission flip). Parser.Parse routes a fresh, full, production-DFA parse of an eligible grammar through the compact internal/parsercorephase0 engine, then materializes a public tree. The tree is byte-exact with the production engine on the routed, verified surface: the 166 byte-exact scorecard routes and the canonical fixtures. The runner's strict acceptance gate fails closed to production on any input it cannot reproduce byte-for-byte. The compact engine promotes from the gts_parsercorephase0 opt-in tag into the default build; the emergency opt-out tag gts_no_parsercorephase0 compiles it back out.
  
  Evidence for the admission:
  - Correctness. 206 of 206 curated parity fixtures pass. The deep-tree digest is 100 percent exact on the canonical fixtures. The 206-language scorecard through the switch reports 166 byte-exact routes, 0 divergences, 35 fail-closed fallbacks, and 5 token-source skips.
  - Fail-closed generic-call conflict class. On the ambiguous Go construct Foo[int](a), production and the tree-sitter-go C oracle select type_conversion_expression(generic_type). The compact scheduler cannot yet rank that conflict by dynamic precedence, so it declines the unauthorized tie fold and falls back to production. The returned tree stays byte-exact while TestAdmissionCandidateGoTypeConversionFailsClosed keeps the route/fallback behavior explicit.
  - Timing. The quiet-host publication run (lane strictboundary-20260720T231334Z-v6 phase3, n2d-standard-4, 5 ABBA cycles) measured a production-over-candidate geomean speedup of 1.8321 (gate is at or above 1.0204) on the warm direct-runner path (BenchmarkParserCoreFreshFullCanonical). The worst fixture ran 1.526 times faster. Peak resident set size fell on all four fixtures (grammargen_lr 94 MB against 206 MB). The deep C-oracle parity preflight passed in the same run.
  - Adapter Parse-path reconciliation. The 1.8321 geomean was measured on the direct-runner path, not on Parser.Parse. The initial adapter regressed time and allocations, because it rebuilt the compact action tables on every fresh Parser and did not pool the materialization scratch. Two adapter fixes removed that tax:
    
    a per-*Language table cache builds the converted action and reduction tables once per language (about 95 KiB retained) instead of once per parse; and
    
    a per-Parser runner reuses the materialization scratch, the public-tree node buffers, and the Go-compatibility walk stack across parses.
    
    After the fixes, warm route-ON allocations on BenchmarkGoParseFullDFA fall from about 71 to about 24 per operation, and bytes per operation from about 99 KiB to about 17 KiB. On the human-authored Go fixtures (BenchmarkGoParseWarmRealDFA) the routed parses now run about 1.45 to 1.66 times faster than production through Parser.Parse (geomean of the routed fixtures about 1.57 times). The remaining gap to the 1.8321 direct-runner number is the production Parse tail the adapter still runs. On the synthetic, highly repetitive BenchmarkGoParseFullDFA source the routed parse stays slower than production, because the compact scheduler dominates that input; the speedup holds on the human-authored fixtures the sealed number measured.
  - Sealed epoch (v0.45.0). The compact route measured 2.9975 times the C reference against the production route at 5.526 times, hardware-attested and verified. Allocation levels sit at 92 to 316 allocations per operation against 14 to 200 for production, admission-compatible per the 2026-07-20 owner ruling.
  - Known gap. The candidate retained-heap column reported NA in the phase3 environment; resident set size is the resource evidence.
  Escape hatch: set GTS_ADMISSION_CANDIDATE=0 (or false, off, no) to force every parse back onto the production route. Any other value, or an unset variable, keeps the compact route on. (*Parser).SetAdmissionCandidateRoute overrides the process default per parser.
  
  Dual-route statement: ParseIncremental and every reuse-consuming parser operation stay on the production engine. A compact old tree may now supply reusable subtrees only when its materialization attached the required replay states and its scanner is provably quiescent; otherwise reuse fails closed to a full production parse. Token-invariant single-leaf edits are separately re-lexed and admitted only on exact symbol/span identity.
  
  Memory-budget contract: the compact scheduler does not poll the automatic large-input memory budget. The switch declines every input at or above the source-length floor where the production route arms that budget (64 KiB), so such inputs stay on production and honor ParseStopMemoryBudget. Adding scheduler-level budget polling to the compact route is the follow-on campaign.
- The GLR steady-state merge now compares structure before score (PR #416). The TypeScript and TSX steady-state merge budget widens from one survivor to two. The wider budget activates the structural comparison at the merge site. This is the structural cure for the detector class behind issue #389 and issue #402.
- Admitted clean top-level edits now reuse both leading and trailing sibling runs (PR #418, PR #421, campaign O(edit)). PR #418 bounds arena normalization to the edited range. A 1MB clean-Go near-top keystroke drops from about 356ms to about 53ms. PR #421 splices the leading run of unchanged top-level items, the mirror of the trailing block-splice. A 1MB mid-file keystroke drops from about 269ms to about 67ms for Go, and from about 168ms to about 45ms for CSS. At 137KB, mid-file reuse rejects fall from 16,450 to 10. Length- or point-changing Tree.Edit calls still maintain coordinates through affected trailing sibling subtrees, so this is not an absolute whole-call O(edit) claim. JavaScript, TypeScript, and TSX keep their previous leading-run behavior until the T2c scanner proofs land. The W5 latency gate locks these counters per edit position.
Removed
- The four TypeScript merge-width source-text detectors (PR #422). The structure-before-score cap-two steady state from PR #416 subsumes all four detector shapes, so the detector functions, their wrapper gates, their helpers, and the test seam are deleted. A byte-match test proves cap-two produces trees identical to the old cap-six widening on the destructured shape, at 300KB scale. One behavioral change: an accepted-error incremental retry for the destructured-arrow shape now runs one base-cap retry pass. The strict retry-preference gate keeps the selected tree the same or strictly better.
Open source →
v0.45.1-0.20260721212242-44df7c64be8521 Jul 2026pre-release
Nothing published for this version
v0.45.020 Jul 2026
Release notes
Fixed
- TypeScript arrow functions with a return-type annotation no longer
  collapse to ERROR as a const/let initializer (issue #402, PR
  #409). Example: const f = (a: A): B => { ... }. The typed-arrow and
  destructured-arrow-return-type detectors added in PR #389 did not
  cover this shape. Neither required the arrow to be immediately
  preceded by ). A typed, non-destructured parameter list combined
  with an explicit return-type annotation fell through both. This fix
  adds a dedicated detector for that shape. It widens the merge budget
  to two survivors, matching the typed-arrow and default-parameter
  cases. TSX was unaffected; its wider JSX conflict set already kept a
  second survivor alive. The detector also covers parenthesized return
  types: (a: A): (B) => a, (a: A): (string | number) => a, and
  (a: A): (() => B) => a. Its backward colon scan now balances
  parentheses, so a colon nested inside the return type is not mistaken
  for the top-level boundary. This is the third source-heuristic
  merge-width detector guarding the same root cause as the PR #389
  default-parameter fix. That root cause: the GLR engine's steady-state
  merge budget discards a live fork by score before any structural
  comparison runs.
  The structural cure — comparing candidate forks structurally before
  falling back to score at the merge site — remains tracked, in active
  development on codex/glr-structure-before-score. Like its
  siblings, this detector's backward scan is bounded to a
  512/2048-byte window; a return-type expression whose own top-level
  colon sits past that window silently misses the widening.
- Go new(pkg.Type), new(*T), new(**T), and parenthesized type
  arguments now byte-match the C oracle (issue #375 class, valid
  forms; PR #408). The parser previously parsed these structured type
  arguments as expressions, breaking node-for-node parity.
  new/make selector, unary, and parenthesized arguments now
  relabel to the C grammar's type shapes. Byte spans and tree
  structure are preserved. A composite-literal guard suite locks the
  boundary: this fix does not touch composite-literal type positions,
  which already matched.
Added
- A per-boundary scanner-quiescence classifier replaces the
  external-scanner reuse allowlist. It proves reuse soundness for
  stateless scanners, refutes stateful opt-out scanners, and defers to
  the checkpoint match for checkpoint-based scanners (PR #407,
  campaign O(edit) workstream W4). A new exported
  StatelessExternalScanner interface, in language.go, lets a
  scanner declare itself stateless. GoExternalScanner now implements
  it, under five documented proof obligations that block cross-token
  state from leaking into reuse boundaries. A new
  ReuseRejectScannerUnquiescent counter, on IncrementalParseProfile,
  tracks boundaries the classifier rejects. An adversarial oracle
  sweep proves byte-identical incremental and fresh Go parses across
  newlines, raw strings, and comments; the classifier never blocks Go
  reuse on that sweep. This change is behavior-neutral groundwork: it
  does not itself change any parse output.
- A new editor-latency CI gate enforces deterministic incremental
  counters. It sweeps insert, delete, and replace edits at three
  file positions, across roughly 20KB, 137KB, and 1MB fixtures in four
  languages (PR #405, campaign O(edit) workstream W5). The gate checks
  counter ceilings, byte-reuse floors, and structural parity against a
  fresh parse, on every default go test run. A determinism check
  runs fresh parsers on identical inputs and asserts the counters
  match exactly. A manual-dispatch CI job covers the slower 137KB and
  1MB tiers.
- A query silent-wrong witness suite locks four query tranches
  against the C oracle (PR #410). D1 range queries, D4 MISSING
  alternation patterns, and D8 #is? predicates now match the oracle
  under committed tests. D3 supertype patterns and D5 quantified
  captures are tracked, not fixed: their tests are skip-guarded, with
  the query-engine-scope limitation documented inline.
Improved
- Unchanged top-level siblings now splice back as a single block,
  inside one parse-loop iteration, instead of one sibling at a time
  (PR #411, campaign O(edit) workstream W1 block-splice composition).
  A new scanner-quiescence check lets a quiescent, non-checkpoint
  external scanner skip re-lexing an unchanged span in O(1), instead
  of token by token. A new BlockSpliceSteps profiling counter tracks
  block-splice activations. On a clean-Go, near-top, single-byte
  insert, a 1MB file measures about 148ms on the prior release and
  about 82-88ms on this one. CSS near-top edits re-lex only 2 tokens.
  Honest note: the campaign's 60ms target for the 1MB fixture is not
  met. The residual cost is dominated by O(nodes) result
  materialization outside the splice path — the Go-compatibility
  normalization walk, EOF result-selection, and incremental arena
  zeroing. Threading the edited range through that walk is the
  tracked next lever.
- The diagnostic compact-route materializer allocates far less per
  operation (PR #412). Cohort processing, frontier dropping, and
  election-state tracking now reuse scratch buffers and compact
  in-place, instead of allocating maps and slices per operation.
  Measured allocations drop from 1,931-91,341 to 92-316 allocs/op
  across the fixture set, a 98.5% geomean reduction. The work graph is
  provably unchanged. This is a diagnostic/candidate-route
  improvement, not a change to the shipping default parse path.
Docs
- Publish the sealed run6 benchmark epoch as authoritative in
  BENCH.md, superseding the v0.40.0 baseline receipt (PR #403).
- Correct README claims about ParseIncremental's reuse scope, and
  document the grammargen real-corpus parity floor (PR #404).
- Add a Phase-3 admission timing runbook, with locked fixtures, host
  selection paths, and statistical thresholds (PR #406).
- Sweep remaining documentation prose to the ASD-STE100 style guide
  (PR #414).
Known Issues
- The 1MB near-top edit still misses the campaign's 60ms target, at
  about 82-88ms (PR #411). Threading the edited range through Go's
  compatibility-normalization walk is the tracked next lever.
- GLR-heavy files with genuine ambiguity still see little wall-time
  change from the O(edit) work, because settling and block-splice run
  on a single stack only (PR #398, PR #411).
- Query-engine tranches D3 (supertype patterns) and D5 (quantified
  captures) remain silently wrong against the C oracle. Both are
  tracked outside query-engine scope, with skip-guarded witness tests
  (PR #410).
- The structural merge-policy fix for TypeScript/TSX GLR fork discard
  is still tracked, in development on
  codex/glr-structure-before-score. This release's arrow-return-type
  fix (PR #409) is a third source-heuristic detector, not the
  structural cure.
Open source →
Additional notes2 sources agree
Fixed
- TypeScript arrow functions with a return-type annotation no longer collapse to ERROR as a const/let initializer (issue #402, PR #409). Example: const f = (a: A): B => { ... }. The typed-arrow and destructured-arrow-return-type detectors added in PR #389 did not cover this shape. Neither required the arrow to be immediately preceded by ). A typed, non-destructured parameter list combined with an explicit return-type annotation fell through both. This fix adds a dedicated detector for that shape. It widens the merge budget to two survivors, matching the typed-arrow and default-parameter cases. TSX was unaffected; its wider JSX conflict set already kept a second survivor alive. The detector also covers parenthesized return types: (a: A): (B) => a, (a: A): (string | number) => a, and (a: A): (() => B) => a. Its backward colon scan now balances parentheses, so a colon nested inside the return type is not mistaken for the top-level boundary. This is the third source-heuristic merge-width detector guarding the same root cause as the PR #389 default-parameter fix. That root cause: the GLR engine's steady-state merge budget discards a live fork by score before any structural comparison runs. The structural cure — comparing candidate forks structurally before falling back to score at the merge site — remains tracked, in active development on codex/glr-structure-before-score. Like its siblings, this detector's backward scan is bounded to a 512/2048-byte window; a return-type expression whose own top-level colon sits past that window silently misses the widening.
- Go new(pkg.Type), new(*T), new(**T), and parenthesized type arguments now byte-match the C oracle (issue #375 class, valid forms; PR #408). The parser previously parsed these structured type arguments as expressions, breaking node-for-node parity. new/make selector, unary, and parenthesized arguments now relabel to the C grammar's type shapes. Byte spans and tree structure are preserved. A composite-literal guard suite locks the boundary: this fix does not touch composite-literal type positions, which already matched.
Added
- A per-boundary scanner-quiescence classifier replaces the external-scanner reuse allowlist. It proves reuse soundness for stateless scanners, refutes stateful opt-out scanners, and defers to the checkpoint match for checkpoint-based scanners (PR #407, campaign O(edit) workstream W4). A new exported StatelessExternalScanner interface, in language.go, lets a scanner declare itself stateless. GoExternalScanner now implements it, under five documented proof obligations that block cross-token state from leaking into reuse boundaries. A new ReuseRejectScannerUnquiescent counter, on IncrementalParseProfile, tracks boundaries the classifier rejects. An adversarial oracle sweep proves byte-identical incremental and fresh Go parses across newlines, raw strings, and comments; the classifier never blocks Go reuse on that sweep. This change is behavior-neutral groundwork: it does not itself change any parse output.
- A new editor-latency CI gate enforces deterministic incremental counters. It sweeps insert, delete, and replace edits at three file positions, across roughly 20KB, 137KB, and 1MB fixtures in four languages (PR #405, campaign O(edit) workstream W5). The gate checks counter ceilings, byte-reuse floors, and structural parity against a fresh parse, on every default go test run. A determinism check runs fresh parsers on identical inputs and asserts the counters match exactly. A manual-dispatch CI job covers the slower 137KB and 1MB tiers.
- A query silent-wrong witness suite locks four query tranches against the C oracle (PR #410). D1 range queries, D4 MISSING alternation patterns, and D8 #is? predicates now match the oracle under committed tests. D3 supertype patterns and D5 quantified captures are tracked, not fixed: their tests are skip-guarded, with the query-engine-scope limitation documented inline.
Improved
- Unchanged top-level siblings now splice back as a single block, inside one parse-loop iteration, instead of one sibling at a time (PR #411, campaign O(edit) workstream W1 block-splice composition). A new scanner-quiescence check lets a quiescent, non-checkpoint external scanner skip re-lexing an unchanged span in O(1), instead of token by token. A new BlockSpliceSteps profiling counter tracks block-splice activations. On a clean-Go, near-top, single-byte insert, a 1MB file measures about 148ms on the prior release and about 82-88ms on this one. CSS near-top edits re-lex only 2 tokens. Honest note: the campaign's 60ms target for the 1MB fixture is not met. The residual cost is dominated by O(nodes) result materialization outside the splice path — the Go-compatibility normalization walk, EOF result-selection, and incremental arena zeroing. Threading the edited range through that walk is the tracked next lever.
- The diagnostic compact-route materializer allocates far less per operation (PR #412). Cohort processing, frontier dropping, and election-state tracking now reuse scratch buffers and compact in-place, instead of allocating maps and slices per operation. Measured allocations drop from 1,931-91,341 to 92-316 allocs/op across the fixture set, a 98.5% geomean reduction. The work graph is provably unchanged. This is a diagnostic/candidate-route improvement, not a change to the shipping default parse path.
Docs
- Publish the sealed run6 benchmark epoch as authoritative in BENCH.md, superseding the v0.40.0 baseline receipt (PR #403).
- Correct README claims about ParseIncremental's reuse scope, and document the grammargen real-corpus parity floor (PR #404).
- Add a Phase-3 admission timing runbook, with locked fixtures, host selection paths, and statistical thresholds (PR #406).
- Sweep remaining documentation prose to the ASD-STE100 style guide (PR #414).
Known Issues
- The 1MB near-top edit still misses the campaign's 60ms target, at about 82-88ms (PR #411). Threading the edited range through Go's compatibility-normalization walk is the tracked next lever.
- GLR-heavy files with genuine ambiguity still see little wall-time change from the O(edit) work, because settling and block-splice run on a single stack only (PR #398, PR #411).
- Query-engine tranches D3 (supertype patterns) and D5 (quantified captures) remain silently wrong against the C oracle. Both are tracked outside query-engine scope, with skip-guarded witness tests (PR #410).
- The structural merge-policy fix for TypeScript/TSX GLR fork discard is still tracked, in development on codex/glr-structure-before-score. This release's arrow-return-type fix (PR #409) is a third source-heuristic detector, not the structural cure.
Open source →
v0.44.2-0.20260720212750-0fcaa92629d420 Jul 2026pre-release
Nothing published for this version
v0.44.120 Jul 2026
Release notes2 sources agree
Fixed
- Swift's certified runtime profile now attaches again. PR #396's swift.bin regeneration (the DFA-minimization fix, v0.44.0) did not update the profile's pinned blob digest in grammars/runtime_profiles.go. The stale digest silently dropped Swift's external-scanner skip-repeat policy and its accepted-error retry-skip policy (PR #400). The impact was performance-only. Error-bearing Swift parses ran redundant retry ladders. Clean Swift parses, and the v0.44.0 memory win, were unaffected. This release updates the pinned digest to match the regenerated blob. No other grammar's profile carries a stale digest.
Improved
- Go clean-file incremental parses now reuse the top-level suffix instead of reparsing it. This closes, for clean top-level edits, the Go reuse gap that v0.44.0 listed as a known issue. It is not an absolute whole-call O(edit) claim: length- or point-changing Tree.Edit calls still maintain coordinates through affected trailing sibling subtrees. Before dispatch reaches the reuse check, the parser now applies any pending eager-default reduce chain to the live stack. This is campaign O(edit) workstream W1b (PR #398), and it closes the settling gap that blocked the W1 splice (PR #395) for Go. ReuseRejectRootNonLeafChanged now holds at a small constant, 9, regardless of file size. Node allocations drop 11 to 16 times. A 137KB near-top insert now takes about 22ms, down from about 47ms. A 1MB file takes about 162ms, down from about 356ms.
- Incremental parses over a provably clean old tree start the C-parity cost-competition flag false, matching fresh-parse behavior (PR #399, campaign O(edit) workstream W3). Previously every incremental parse started this flag conservatively true, even when the old tree carried no errors. Outputs are proven unchanged: a differential over 8,361 edits is byte-identical to the prior behavior. The effect on wall time is small today. It grows as reuse rates rise, particularly once W1b's Go localization compounds with it.
Known Issues
- The 1MB near-top edit still misses the campaign's 60ms target, at about 162ms (PR #398). Composing the W1b settling fix with the W1 block-splice is the tracked follow-up.
- GLR-heavy files with genuine ambiguity see little wall-time change from W1b (PR #398), because settling runs on a single stack only.
Open source →
v0.44.020 Jul 2026
Release notes2 sources agree
Fixed
- Swift's Language() call no longer exceeds the 256 MB CI memory ceiling. This closes the known issue noted in v0.43.1. grammargen's buildLexDFA rebuilt an independent lexer DFA per lex mode, with no sharing across modes. Swift's about 331 lex modes each rebuilt the same about 190-state identifier, operator, and comment automaton from scratch. A new post-construction minimization pass, grammargen/dfa_minimize.go, merges observationally-equivalent DFA states across lex-mode boundaries (PR #396). Swift's LexStates table drops from 63,150 to 2,067 entries. Its Language() call now retains about 25 MB, down from about 490 MB. swift.bin is regenerated and recertified against the Swift regression suite and corpus, shrinking from 7,474,360 to 373,401 bytes. Byte-identical lexing is proven across a 10-grammar parity corpus. The blob format is unchanged. The known-exception entry for Swift is removed from the CI memory-ceiling gate.
- grammargen's C code emitter had several defects. This release fixes:
  - duplicate C identifiers for anonymous tokens, a compile error;
  - infinite lexer loops at EOF on negated character classes;
  - wrong re-lex targets for multi-character skips (CRLF, backslash-newline);
  - an alias-stride bound sized from the wrong table, causing out-of-bounds reads.
  A new C-runtime parity harness compiles the emitted parser.c against the tree-sitter v0.25.0 runtime (PR #391). It byte-compares the resulting AST against the pure-Go oracle.
- Incremental memo-cache growth is now input-deterministic. Growth used to depend on prior parser history, not only the current parse. Identical (source, edit) pairs could take different growth paths depending on earlier use. A new adaptive trigger, driven by the cNodeMemoThrash collision count of the current parse alone, now controls growth (PR #392, issue #380 follow-up). Clean, non-pathological parses still stay at the small 128-entry default.
- Incremental reuse is now barred for trees built by the phase-zero compact parser. This closes reuse holes on three entry points:
  - the DFA entry point;
  - the custom-token-source entry point;
  - the token-invariant-leaf-fastpath entry point.
  ParseIncremental now forces a full fresh parse when the old tree is compact-materialized (PR #393). A new top-down ParseState table-replay mechanism reconstructs parser states over the full compact derivation. It runs before hidden-node elision and grammar aliasing. It falls back to a sentinel state when a state cannot be reliably reconstructed, for example for extra or comment leaves.
Improved
- CSS editor-style incremental edits now reuse far more of the unchanged tree. A fragility-gated top-level sibling block-splice replaces the old cmake/css name allowlist (PR #395, campaign O(edit) workstream W1). Admission is now per node: a fragility bit plus byte equality, not a language name. On a CSS editor-edit measurement, rootNonLeafChanged rejections near the top of the tree drop from 1,379 to 14. Node reuse rises from 63.8% to 99.5%. Go incremental node reuse does not improve in this release. A deeper, pre-existing engine gap blocks it: the reuse check runs before the eager reduce chain settles state. Work on that gap continues.
Added
- A rollback safety valve: the GTS_GRAMMARGEN_DISABLE_LEX_MINIMIZE environment flag falls back to the raw, per-mode lexer tables. Use it only if a correctness question comes up (PR #396).
Docs
- Refresh documentation prose to the ASD-STE100 style guide across README.md, BENCH.md, AGENTS.md, and the authoring-languages and external-scanners guides (PR #385).
- Clarify the GLR stack cap default in AGENTS.md (PR #394). This release also corrects the stale release-status paragraph in README.md.
Known Issues
- Go incremental node reuse is unchanged by the W1 fragility-gated splice (PR #395). The reuse check runs before the eager reduce chain settles state, blocking admission. A fix is tracked.
Open source →
v0.43.2-0.20260720100704-049788c3b17520 Jul 2026pre-release
Nothing published for this version
v0.43.120 Jul 2026
Release notes2 sources agree
Fixed
- TypeScript/TSX bare default parameters (function f(a = 1) {}) no longer collapse to ERROR. The fix widens the GLR merge budget when a default-parameter shape is present. It covers plain, array-element ([a = 1]), renamed-property ({a: b = 1}), unicode-identifier, and comment-adjacent forms, in both TypeScript and TSX (PR #389). The root cause: the cap-one merge budget discarded the correct derivation by score before any structural comparison.
- Destructuring declarations with defaults (const [a = 1] = arr) now parse correctly. This fix is incidental coverage from the same change.
Improved
- Grammar blob decoding pre-sizes its buffer from the gzip size hint. This change cuts total allocation churn about 32 percent and peak memory about 11 percent across all 206 grammars.
Added
- A CI memory-ceiling test sweeps all 206 grammars. It fails any Language() load above 256 MB. Swift is a documented exception.
- Environment-gated diagnostic tests characterize the incremental insert-retry timing nondeterminism from issue #380 (PR #388).
Known Issues
- Swift's Language() call still retains about 491 MB. The root cause is upstream in grammargen: the lexer DFA rebuilds once per lex mode. A full fix is tracked.
Open source →
v0.43.020 Jul 2026
Release notes2 sources agree
Fixed
- Incremental length-changing edits now reuse the unchanged suffix instead of re-lexing the whole tail to EOF (issue #380, step 1). The reuse byte-guard previously sliced the pre-edit source at post-edit (shifted) coordinates, so any insert/delete rejected every suffix subtree as ancestor-dirty and reparsed the entire suffix; it now reverse-maps coordinates through the recorded edits. A follow-up guard prevents a clamped, edit-overlapping node from being reused when its text actually changed (previously a silent-corruption path on length-changing replace/insert edits). Interior/non-leaf subtree reuse across such edits remains limited — a tracked follow-up.
- Restore F# external-scanner checkpoints to the locked grammar's byte layout, keeping incremental scanner state compatible with the reference runtime.
- Apply the upstream-C repetition-skip conflict fold while dispatching around incrementally reusable syntax. Python deletion edits that previously returned a complete but structurally divergent tree now match fresh parsing and the locked C oracle across a systematic minimal-witness sweep.
- Fail closed to a fresh parse for Python-derived external scanners (Python, Mojo, and Starlark) when edits require checkpoint reuse, until each indentation-state restoration path is certified exact. Same-length token-invariant leaf validation still reuses the complete old tree without reparsing. Included-range token-source wrappers preserve the underlying scanner's fallback reason in incremental profiles.
- Go new(T)/make(T) now retags a sole bare-identifier argument to type_identifier, matching the locked C oracle for that shape. This is a targeted partial fix: qualified (new(pkg.Type)), pointer (new(*T)), and parenthesized type arguments still differ from C and require a parser-table-level fix (tracked).
Added
- Incremental-invariant correctness gate (default-on). It sweeps a curated real-world corpus applying single-byte delete/insert/replace edits and asserts ParseIncremental is structurally identical to a fresh Parse wherever the fresh parse is genuinely clean — turning previously-silent incremental corruption into explicit CI failures. Cleanliness is checked by a recursive IsError()/IsMissing() walk (not HasError()), governed by a tracked allowlist with a staleness ratchet.
- Gated one-pass selected-store builder (build-tagged, off by default) — a diagnostic parser-core materialization candidate that does not touch the production parse path and is admitted only when it produces byte-identical deep trees to the staged builder across the canonical fixtures.
Tooling
- Extend the authenticated work-count board with direct main-DFA callable-entry and resolved action-cell diagnostics for Go and locked static C, while keeping Go union-frontier elections and C per-version lex requests explicitly unavailable for cross-engine comparison.
Open source →
v0.42.019 Jul 2026
Release notes2 sources agree
Performance
- Refresh the opt-in Go build-time PGO artifact with a hash-verified composite of the established production profile and authenticated selected, clean, and accepted-error parsing profiles. On the pinned quiet host, the composite is 4.01% faster than the previous profile by equal-fixture geomean across the four selected-store fixtures, with every fixture faster, while preserving the existing five-grammar production workload (statistically indistinguishable, with a -0.14% median point estimate) and improving it by 5.37% versus PGO-off. Production allocation medians move by +0.43% B/op and +0.07% allocs/op. Exact selected-store admission and the production corpus digest remain unchanged; checked-in inputs and a deterministic composition script make the artifact reproducible.
- Keep compact-scheduler dispatch and reduction scratch cleanup panic-safe in small wrappers so their large action bodies no longer register three runtime defers per reduction-bearing pass. On the pinned quiet host, the authenticated four-fixture BenchmarkDiagnosticParserCoreCanonicalTotal lane—compact canonical parsing plus public-node materialization—improves by 4.19% by equal-fixture geomean, with every fixture 3.73-5.28% faster, unchanged allocations, exact work and deep-tree digests, and zero fallback. The route remains build-tagged and diagnostic-only.
- Return BibTeX, CSS, Yuck, Bash, SCSS, C#, Agda, Ledger, Authzed, Make, and TLA+ automatic forest routing to explicit-only experiments after an authenticated full-manifest audit. The exact BibTeX, CSS, SCSS, and Yuck routes were 32.7%, 32.3%, 4.8%, and 46.2% slower than production. Ledger and Make dispatched 0/1 and 0/19 files. Bash routed 1.3% slower and differed from direct C on 61/1,263 dispatches; C# routed 9.3% faster but differed on 212/1,427; Agda routed 7.5% slower and differed on 1,444/2,070; Authzed routed 3.9x slower and differed on 27/35; TLA+ routed 3.2x slower and differed on 105/267. Explicit Language.WantsForest, recovery, incremental, and direct forest experiments remain available.
- Avoid repeating the complete external-scanner full-parse retry ladder for the exact built-in Crystal and Matlab grammar artifacts, while retaining the entire accepted-error widening and final-merge ladder once. In the exact-head certification at c6de0991, the locked 2,380-file Crystal corpus preserves every deep tree and C admission relation, reduces attempts from 13,445 to 8,120, lowers aggregate parse wall time by 24.62%, and lowers allocated bytes by 10.19%. On the locked 1,434-file Matlab corpus, attempts fall from 7,866 to 4,650, wall time by 40.99%, and allocated bytes by 32.67%, again with exact output and oracle relation preservation on every file.
- Execute Go highlight queries directly over the build-tagged compact selected store through value node handles, without constructing public-node proxies. All four locked real-Go fixtures preserve exact ordered query captures, directives, and final highlight ranges; unsupported missing-node queries decline explicitly. On the exact rebased revision, selected-store query time improves by 8.51% and B/op by 14.18% against the public-tree control by equal-fixture geomean. End-to-end selected parse plus highlight improves by 12.90% with 26.38% fewer B/op, and every fixture median is faster. A balanced two-order public Query.Execute control preserves wall time while reducing B/op and allocations by 14.50%; direct streaming-cursor allocations remain unchanged. The selected route remains diagnostic-only.
- Move Faust, CMake, and Erlang automatic forest routing back to explicit-only experiments after full locked-corpus recertification superseded their earlier small-corpus receipts. Faust remained exact across 706 files but routed in 9.94 seconds versus 6.52 seconds for production; CMake remained exact across 11,506 files but routed in 35.03 seconds versus 23.36 seconds. Erlang's route improved 4,114 files from 213.14 to 183.94 seconds, but 175 routed trees differed from production and 125 forest trees differed from the direct C oracle. Explicit Language.WantsForest experiments remain available for all three while route overhead and Erlang result selection are improved.
- Keep Common Lisp on the production parser unless callers explicitly request the forest path. On the locked 1,357-file corpus, the routed parser took 173.6 seconds versus 46.0 seconds for production, dispatched one file, fell back on 1,356, and diverged on the sole dispatched result. A separate direct C-oracle audit rejected that result as well. On the authenticated largest-eight static-C board, disabling automatic routing completed all eight files instead of timing out on two, cut the six matched files by 58.3%, reduced isolated sweep wall time by 19.9%, and lowered max RSS from 2.14 GB to 746 MB. Explicit forest and recovery experiments remain available.
- Add an opt-in, build-tagged selected-tree backing store at the compact parser/consumer boundary. Accepted payloads are sealed only for the direct consumer; the public-node control remains store-free. The store preserves occurrence identity and authenticated visible metadata across compact-core resets, polls cancellation and resource limits, enforces occurrence and retained-byte caps before growth, builds its quadratic unary policy only on demand, and returns each atomic record/child backing pair through an explicit synchronized release lifecycle. On the exact reviewed revision, the direct consumer improves the same-revision public-node boundary by 13.27% across the four locked fixtures, with every fixture 11.18-15.58% faster, B/op down 56.42%, lower RSS, exact work, and zero fallback. Its strict locked-static-C publication measures 2.685181x C by equal-fixture geomean, 2.676794x by fixed-suite sum, and 2.791974x on the worst fixture. The route remains diagnostic-only and intentionally omits parser-state metadata.
Tooling
- Extend the locked static-C publication driver with an authenticated selected-store backend and retain selected-store bytes alongside total allocation, work, fallback, and RSS metrics.
- Add an opt-in retry-profile corpus certifier that compares the duplicated external-scanner retry ladder with an exact-blob candidate file by file while preserving accepted-error widening and recording the locked C-oracle admission relation without treating pre-existing corpus gaps as candidate regressions. Its success and counterexample receipts include deep-tree digests, stop/full-span state, attempt rungs, allocation totals, clean/error splits, and locked-corpus source identities. Schema-v2 journals fail closed on unknown or dirty candidate revisions, mixed schemas, oracle or parser configuration drift, duplicate or unselected paths, and any resumed row that no longer revalidates exactly; fresh rows are validated before publication.
Fixed
- Keep compact-parser arena and selected-root cap arithmetic portable on 32-bit targets by widening lengths before uint32-bound checks and additions.
Open source →
v0.41.018 Jul 2026
Release notes2 sources agree
Performance
- Run the authenticated fresh compact scheduler as one fail-closed session, resetting the entire compact core after any error or panic instead of taking a rollback checkpoint for every successful operation. Its clean pinned-host publication measures 3.118130x static C by equal-fixture geomean, 3.169740x by fixed-suite sum, and 3.185522x on the worst fixture, with exact static-C admission and zero fallback. The compact route remains build-tagged and diagnostic-only.
- Bypass general graph enumeration when a compact-parser reduction follows a single-link stack path, while retaining the existing enumerator for branched paths and preserving its resource-limit checks. On the pinned quiet host, the authenticated query_compile candidate improves total time by 2.51% with unchanged parser work, bytes, and allocations. The compact route remains build-tagged and diagnostic-only.
- Skip redundant production-metadata remapping while materializing a compact tree whose terminals and reductions were already authenticated at construction. Generic diagnostic publication retains the full validation path. A balanced two-order quiet-host board improves the authenticated four-fixture fresh-full geomean by 3.44%, with every fixture improving by 2.36-4.50%, materialization improving by 13.20%, unchanged compact work, and zero fallback. The compact route remains build-tagged and diagnostic-only.
- Preclassify immutable compact-parser action rows and route singleton shift, reduce, and extra actions without repeatedly interpreting or copying the row. Two reverse-order quiet-host runs improve the authenticated four-fixture candidate Total geomean by 4.13-4.26%, with every fixture improving by 3.42-5.00%, unchanged parser work and fallback counts, and a worst candidate/static-C ratio below 3.90x. The candidate remains build-tagged and diagnostic-only.
- Cache exact source points in a bounded, allocation-free materialization-local table for the build-tagged compact parser. The four authenticated fixtures reuse 59.02-62.17% of point lookups; two reverse-order quiet-host boards improve equal-fixture candidate time by 2.14-2.35%, with every fixture faster, unchanged parser work, and unchanged fallback counts. This route remains diagnostic-only.
Documentation
- Publish the authenticated v0.40.0 fresh, materialized real-Go receipt: 4.851050x static C by equal-fixture geomean, 5.472406x by fixed-suite sum, and 5.608320x on the worst fixture. The 0.716% geomean improvement over v0.39.0 is below the reproducible 2% win threshold, so this is a baseline refresh rather than a banked performance win.
Fixed
- Scheduler transaction token misuse on a different diagnostic core now poisons and rolls back only the called core, without mutating the token owner.
- Deferred result-compatibility finalization stays lazy while trees are owned by parser retry/selection code, then synchronizes every public read that can observe normalized nodes or diagnostics, including pooled tree values.
- Query byte and point ranges now match the locked C runtime for half-open boundaries, zero-width nodes at the range start, reversed range updates, and zero-valued unbounded-end sentinels.
- DFA token-source seeks clamp past-EOF offsets before integer narrowing and preserve exact EOF coordinates across both skip APIs, including 32-bit builds.
- Query string literals now decode control, quote, and backslash escapes through execution and reject unescaped newlines like the locked C query parser.
- Grammar imports now decode C string and Unicode escapes without losing the reversible question-mark spelling shared with grammargen; refreshed Agda and Dhall blobs expose their Unicode symbols correctly. Generated C now uses the ABI-appropriate lexer-mode layout, emits flattened parse-action offsets, and validates complete ABI-15 supertype metadata before emission. Lowercase keyword leaves are classified from parser-reachable ownership like tree-sitter.
- Query MISSING patterns now test missing nodes, and inert #is?/#is-not? properties are available through public metadata accessors. Descendant range walks now match upstream behavior for reversed ranges and zero-width missing children.
- Highlight queries now resolve supported built-in inheritance chains across registration order and same-name replacements without duplicating cyclic queries. Incompatible locked grammar/query pairs remain fail-closed.
- Incremental parses that accept a full-span ERROR tree under a wider merge policy may retry once with the corresponding fresh-parse policy and adopt only a strictly better result. Runtime and profile diagnostics report the retry attempt, selection, cap, cause, and whether old-tree reuse was active.
- Token-invariant single-leaf edits stay outside accepted-error retry routing, avoiding a whole-tree error scan on the one-token validation path.
Tooling
- Add a bounded, build-tagged parser trace that separates lookup cells from execution-time cell reconstruction and retains whole-parse aggregates after its chronological event prefix fills. Scanner checkpoints bind their cached state to the current event token span and remain distinct from unavailable state after relexing. Collision keys have explicit memory caps; reaching a cap exposes unaudited counts, marks the audit incomplete, and blocks claims that require complete collision evidence. A base-pinned content manifest and fail-closed paired receipt identify which production, compact, and locked-C observations can actually be compared. Observer equality and untagged assembly tests keep the trace diagnostic-only.
- Add the four-fixture authenticated Go/static-C work-count board with direct counters at their exact hook boundaries, Go-only representation rows marked incomparable, and missing mandatory instrumentation reported separately from out-of-band work-ratio audit findings.
- Add the build-tagged compact parser-core candidate and a work-board backend that authenticates its exact EOF acceptance, selected tree digest, ranges, fields, selected-node census, and repeat-identical work counts on four locked real-Go fixtures. The candidate remains diagnostic-only and fail-closed: its materializer does not preserve ParseState or PreGotoState, so this admission is not a production-routing, incremental, recovery, or exact public node-API compatibility claim.
- Add a bounded, build-tagged selected-occurrence capability for the compact parser candidate. It preserves repeated physical occurrences, construction states, and checked subtree spans without copying the observer proof; its borrowed immutable windows allow read-only re-entry and block lifecycle mutation until released. Exact admissions and isolated race coverage remain green, with no measured performance-regression claim.
- Bank a paired quiet-host receipt against the locked static -O2 C oracle. At the exact post-fusion revision, public Parser.Parse measures 4.813350x C by equal-fixture geomean and 5.419730x C by fixed-suite sum of medians. The build-tagged compact candidate measures 3.847233x C and 3.988613x C, respectively, with a 4.018193x worst fixture and zero fallback in every timed sample. These branch-only candidate numbers apply only to its authenticated clean fresh-full surface; they do not replace the public parser claim.
- Fuse nested transaction checkpoints across the build-tagged compact scheduler while preserving standalone rollback and capability semantics. The authenticated four-fixture Total geomean improves by 8.25%, every fixture improves by 7.21-8.96%, and allocation counts remain unchanged.
- Add a versioned, locked incremental admission matrix that separates identity, leaf-validation, real-code GLR, recovery, and stateful-scanner behavior using runtime evidence. It rejects full-parse fallback, authenticates both edit directions against fresh Go and C trees, and atomically publishes a machine-readable closure receipt only after every row passes.
- Real-corpus grammar parity can use a durable configurable corpus root and split-grammar corpus layouts without silently losing colliding basenames. Eligible-sample caps now apply on every generated-result path, committed floors reject over-cap rows, and the aggressive runner and floor share the same 30-sample limit.
Open source →
v0.40.017 Jul 2026
Release notes2 sources agree
Performance
- Build-time PGO. Ships a default profile (pgo/default.pgo) and a repdriver tool; the parity_report build compiles with it. About 7% wall-clock reduction, byte-identical across all 206 grammars.
- Forest-index allocation overhaul. The forest alternative index is now pooled across parses and the per-compare throwaway comparison slices are eliminated. On the forest-path grammars (C#, Bash, CMake) allocation bytes drop 86–96% and GC-cycle CPU 48–90%, with byte-identical trees.
- GLR result-comparator copy elimination. The forest disambiguation comparator chain now takes stack pointers instead of copying a 104-byte stack value per call, removing about twelve runtime.duffcopy calls per compare. About 14% wall-clock reduction on the forest-path grammars, byte-identical.
- Forest reducer pooling. The per-parse forest reducer is now pooled, cutting C# parse allocation a further ~51% by bytes, byte-identical.
Security
- Query matcher work budget. The -All quantifier matchers now charge a per-execution work budget, bounding worst-case combinatorial blow-up on adversarial query/source pairs. Exposed via Cursor.DidExceedMatchLimit and configurable with SetMatchWorkBudget (default 1,000,000).
Fixed
- Incremental parsing no longer reuses a stale subtree when an edit shifts a token boundary that abuts a reused node's right edge. Both the leaf and the non-leaf (wrapped-token) reuse paths now reject reuse when the freshly lexed token's end byte disagrees with the stored boundary, preventing spurious ERROR nodes on common edits such as deleting the whitespace between two identifiers (e.g. Clojure (a b) → (ab)). Verified byte-identical to a fresh parse across the C-oracle incremental parity harness.
Documentation
- Label the authenticated 2c702656 parser receipt as the v0.39.0 production-code baseline rather than implying that its revision is current main after the documentation-only release commits.
Open source →
v0.39.017 Jul 2026
Release notes2 sources agree
Correctness-and-evidence release. Query ranges, literals, missing-node patterns, property metadata, highlight inheritance, lazy tree finalization, DFA EOF seeking, grammar imports, and generated C metadata now match their locked contracts more closely. Locked incremental and work-count receipts authenticate the exercised behavior, while durable corpus roots, split-grammar layouts, and bounded floors make real-corpus checks reproducible. The authenticated production receipt at 2c702656 measures public Parser.Parse at 4.886056x C by equal-fixture geomean, 5.517602x C by fixed-suite sum, and 5.648204x C on the worst fixture against the locked static -O2 C oracle.

Fixed
- Deferred result-compatibility finalization stays lazy while trees are owned by parser retry/selection code, then synchronizes every public read that can observe normalized nodes or diagnostics, including pooled tree values.
- Query byte and point ranges now match the locked C runtime for half-open boundaries, zero-width nodes at the range start, reversed range updates, and zero-valued unbounded-end sentinels.
- DFA token-source seeks clamp past-EOF offsets before integer narrowing and preserve exact EOF coordinates across both skip APIs, including 32-bit builds.
- Query string literals now decode control, quote, and backslash escapes through execution and reject unescaped newlines like the locked C query parser.
- Grammar imports now decode C string and Unicode escapes without losing the reversible question-mark spelling shared with grammargen; refreshed Agda and Dhall blobs expose their Unicode symbols correctly. Generated C now uses the ABI-appropriate lexer-mode layout, emits flattened parse-action offsets, and validates complete ABI-15 supertype metadata before emission. Lowercase keyword leaves are classified from parser-reachable ownership like tree-sitter.
- Query MISSING patterns now test missing nodes, and inert #is?/#is-not? properties are available through public metadata accessors. Descendant range walks now match upstream behavior for reversed ranges and zero-width missing children.
- Highlight queries now resolve supported built-in inheritance chains across registration order and same-name replacements without duplicating cyclic queries. Incompatible locked grammar/query pairs remain fail-closed.
- Incremental parses that accept a full-span ERROR tree under a wider merge policy may retry once with the corresponding fresh-parse policy and adopt only a strictly better result. Runtime and profile diagnostics report the retry attempt, selection, cap, cause, and whether old-tree reuse was active.
- Token-invariant single-leaf edits stay outside accepted-error retry routing, avoiding a whole-tree error scan on the one-token validation path.
Tooling
- Bank an authenticated quiet-host production receipt against the locked static -O2 C oracle. At the v0.39.0 production-code baseline 2c702656, public Parser.Parse measures 4.886056x C by equal-fixture geomean and 5.517602x C by fixed-suite sum of medians, with a 5.648204x worst fixture.
- Add a bounded, build-tagged parser trace that separates lookup cells from execution-time cell reconstruction and retains whole-parse aggregates after its chronological event prefix fills. Scanner checkpoints bind their cached state to the current event token span and remain distinct from unavailable state after relexing. Collision keys have explicit memory caps; reaching a cap exposes unaudited counts, marks the audit incomplete, and blocks claims that require complete collision evidence. A base-pinned content manifest and fail-closed paired receipt identify which production, compact, and locked-C observations can actually be compared. Observer equality and untagged assembly tests keep the trace diagnostic-only.
- Add the four-fixture authenticated Go/static-C work-count board with direct counters at their exact hook boundaries, Go-only representation rows marked incomparable, and missing mandatory instrumentation reported separately from out-of-band work-ratio audit findings.
- Add a versioned, locked incremental admission matrix that separates identity, leaf-validation, real-code GLR, recovery, and stateful-scanner behavior using runtime evidence. It rejects full-parse fallback, authenticates both edit directions against fresh Go and C trees, and atomically publishes a machine-readable closure receipt only after every row passes.
- Real-corpus grammar parity can use a durable configurable corpus root and split-grammar corpus layouts without silently losing colliding basenames. Eligible-sample caps now apply on every generated-result path, committed floors reject over-cap rows, and the aggressive runner and floor share the same 30-sample limit.
Open source →
v0.38.016 Jul 2026
Release notes2 sources agree
Incremental-correctness, full-parse-efficiency, and benchmark-hardening release. Incremental parsing now preserves fresh-parse selection across GLR reuse, score, cull, and retry edges; terminal materialization stops and multiline edits report accurately; evidence-gated arena and merge policies reduce full-parse cost; and authenticated static-C, fleet, and forest measurements are stricter.

Performance
- The exact locked Odin grammar now caps first-pass arena preallocation for large ASCII token-sparse sources using a complete structural-density scan. This cuts arena allocation by 72% and full-parse time by 6% on the locked 6.2 MB Odin test-vector witness with a byte-identical tree. Non-ASCII input fails open, while custom, same-name, stale-blob, and other fleet grammars retain the baseline policy.
- GLR boundary merging now rejects candidates with unequal cumulative scores before recovery-cost and graph-equivalence work. The order-balanced canonical real-Go benchmark improved by 4.3% geomean with unchanged parser work, tree identity, arena use, and stack maxima.
Fixed
- Incremental parsing now preserves the configured bounded GLR width and rejects reused leaves whose stored parser state conflicts with the current shift. This prevents stale leaf context and over-aggressive two-stack pruning from changing selected trees on token-class and recovery edits.
- An incremental parse whose full-parse retry produces no strictly better tree now keeps its first-pass result instead of replacing it with a quality-tied fresh tree. This stops spurious incremental_parse_full_retry reporting on grammars whose intended trees contain ERROR productions and legitimately use the full GLR width.
- Reused subtrees now credit their cumulative dynamic precedence to the GLR stack score, so score-sensitive merge, cull, and result-selection decisions in an incremental parse match a fresh parse of the same structure.
- The GLR stack-cull trigger no longer depends on the arena class: incremental parses keep the same cull slack window as fresh parses, which previously pruned disambiguating forks early and changed selected trees on the early-newline canonical witness.
- A parse whose result materialization stops on a terminal condition (for example the memory budget tripping while the tree is being built) after the parser loop already accepted now reports that condition through Tree.ParseStopReason instead of accepted. Previously such a parse could return a sentinel full-span ERROR root labeled as a successful parse.
- Multiline tree edits now keep node byte and point ranges aligned with the C runtime across insertions, deletions, and replacements.
- Rewriter edits now reject reversed and out-of-source byte ranges instead of panicking while applying them.
Tooling
- Report-mode fleet reduction now preserves closed-vocabulary no_static_c_oracle, no_corpus, and no_corpus_files shards as fatal closure findings in the combined artifact. Certification remains fail-closed, and report mode still rejects untyped, contradictory, or mixed oracle evidence.
- Add a diagnostic-only, authenticated Go/static-C GLR work-count contract for the locked real-Go query_compile fixture. A separate ordinary untagged Go child performs admission before tagged Go and fully static C diagnostic children report saturating direct action/pop/selected-tree counters and explicitly labeled representation proxies. Go counters attribute each parseInternal attempt to a logical retry rung, resolved cap mode, parser loop, and finalization; accept_actions is explicitly an action count, and aggregate counters must equal attempts plus the outside-attempt residual. Frozen retry-active and straight-LR witnesses pin the attribution semantics; a Go-only v3 supplement now records a bounded, attempt-local convergence frontier across reduction selection, post-reduce packing, boundary merge and cull, pending work, terminal acceptance, packed-root expansion, and final selection. It retains the first 256 events plus first rejection evidence, uses attempt-local decision IDs for target/candidate pairs, records scanner checkpoint identity at the current token election, detects partial merge mutations from exact semantic GSS writes, separates saturation from truncation, serializes no pointer identities, and leaves the shared v2 Go/static-C counter semantics unchanged. Authenticated v4 receipts bind both manifests and fail closed on malformed convergence payloads. Authoritative receipts require a clean Git source identity; compile from sealed private Go and C input snapshots; bind sanitized build/runtime environments; independently verify fixture, grammar, GLR-regime, span, and deep-tree identities; contain the complete cold static-C admission plus all repository, compiler, linker, identity, and linkage-verifier descendants in wall-bounded process groups; and publish atomically only after all rechecks pass.
- The static C oracle now recognizes locked grammar entry points declared with either C's empty () or (void) parameter spelling, restoring artifact construction for SCSS while rejecting genuinely parameterized near misses.
- The authenticated fleet scoreboard now times fresh full parses against a per-language, fully static executable built from the locked upstream runtime and grammar sources. Every selected file requires matching static/cgo deep tree digests, and reduction fails closed on missing or mixed oracle identity, dynamic linkage, source/flag drift, or legacy incremental axes. Deep dumps and cgo admissions use iterative cursors with independent wall bounds; C failures retain bounded Go evidence without fabricating ratios. Each file measures one whole Go block and one whole static-C block, alternating their order across file ordinals; compiler/linker absolute paths and executable hashes are part of the serialized protocol. The reducer preserves complete, typed C-oracle failures as authenticated closure failures while rejecting untyped, generic, or incomplete evidence. Admission, parser, transport, digest, measurement, and protocol failures now have a closed serialized status vocabulary. Content-keyed static executables are atomically installed with build-key/artifact-hash manifests only after a post-link recheck of the captured compiler, linker, pinned source trees, and every compiled source hash; cache hits repeat that check before use, and unstable inputs are recaptured once before failing. Shards execute a reverified private artifact snapshot, and per-language wall/RSS stops kill the entire child process group. The budget and status tools read both schema generations while keeping v1 historical ratchets separate from v2 full-only hard-gate verdicts.
- Forest-routing performance screens now require fresh order-balanced confirmation before promotion. Immutable content-addressed trial, run-config, cohort, and index receipts bind the selected head to the recorded host fingerprint, image, and single-CPU resource configuration. Failed or drifting attempts remain unpublished: the runner executes the recorded image digest, verifies the created container identity, and reauthenticates every corpus read by manifest size and SHA-256 before timing. The reducer requires locked-C coverage for every routed path, emits explicit A+B or A-B-B-A plans, pools reverse-order evidence, and keeps possible C-oracle corrections review-required. Repeated trials release every tree on success and negative paths, complete the full corpus before the next sweep, and remain isolated to one language per container.
Open source →
v0.37.1-0.20260715193059-a340d23e3b8e15 Jul 2026pre-release
Nothing published for this version
v0.37.1-0.20260715011939-12bae2cb531c15 Jul 2026pre-release
Nothing published for this version
v0.37.014 Jul 2026
Release notes2 sources agree
Full-parse benchmark-integrity, forest-certification, and GLR-performance release. Publication now uses one locked static C oracle and authenticated, forking real-Go fixtures; authenticated C-first fleet evidence gates automatic forest routes; general multi-stack work is reduced; and high-level highlight and tag parsing can be bounded. The 206-grammar curated structural-parity milestone remains banked.

Added
- Highlighter and tagger construction now accept parser timeout options, and their byte-oriented incremental APIs have strict variants that return the partial tree with ErrParseStoppedEarly while skipping query execution.
Changed
- ParseForestExperimental now reports only a tree produced by the experimental forest parser. A forest decline returns nil, false with ForestDeclineInfo diagnostics instead of silently substituting a production-parser result, so callers can measure and certify forest routing without mistaking fallback work for a forest success.
Tooling
- Canonical real-Go benchmark admission now ratchets each fixture's multi-stack runtime regime and required syntax coverage across Go, cgo, and static-C preflights. Publication samples fail closed if a fixture drifts back toward a straight-LR control workload.
- The authenticated real-corpus source for Git rebase fixtures now uses the grammar repository's committed highlight corpus, so performance and forest audit manifests cover all 206 languages.
- One-language forest audit shards now revalidate only their selected corpus checkout and files while retaining the complete manifest identity, avoiding a repeated fleet-wide authentication pass for every isolated container.
- Forest eligibility sweeps now share an authenticated, revision-pinned corpus manifest between production and C-oracle lanes. Per-language Docker runs verify source checkout identity and exact file hashes, compare complete trees including anonymous children, points, flags, and fields, and emit strict resumable result shards for deterministic fleet reduction. Generated corpus files may be untracked only beneath the lock-declared .gts-extracted/<language> directory; tracked changes and untracked files elsewhere still fail authentication. The production lane separately times and verifies the actual forest-enabled automatic route on every file, so promotion requires exact routed parity and a net wall-time improvement after production fallbacks, not merely a fast forest attempt.
- C-first forest screening now terminally records no_forest_coverage when a complete authenticated C-oracle shard declines every file without timing out. The reducer skips the potentially expensive production lane for that non-promotable class while leaving missing and timeout-ambiguous evidence incomplete.
- Forest manifests, real-corpus benchmarks, and corpus inventory now share one file-selection policy for lock matchers, registry extensions, and canonical extensionless filenames such as go.mod. This lets authenticated manifests cover every lock entry that has an eligible source while keeping explicit lock matchers authoritative.
Performance
- Automatic forest routing now covers the exact checked-in AWK, KDL, and Uxntal grammar artifacts after authenticated corpus gates found zero forest/C-oracle divergence on accepted forest files, zero routed/production divergence on every file, and an aggregate route wall-time win. The opt-in is attached through blob-identity runtime profiles, so same-name custom and adapted grammars remain on the conservative production path.
- Multi-stack DFA token elections now scan each unique active parser state once and reuse that result while scoring candidates, instead of rescanning the state for every candidate. The authenticated real-Go matrix avoided 80-84% of those repeated scans and improved full parse by 3.5-9.8% across four fixtures, with unchanged parser shape, arena bytes, allocations, and exact 25/25 strict Go parity.
- GLR merge, hashing, shape, equivalence, and recovery-trace helpers now pass stack descriptors by pointer instead of repeatedly copying the 104-byte values. The authenticated real-Go matrix improved by 3.54% geomean, with every fixture improved or statistically unchanged and identical arena, token, stack, iteration, node, depth, and normalization counters.
- Fresh full parses now share the parser's existing no-error-payload proof with GSS merge and C-recovery cost selection, avoiding recursive graph and subtree walks until an ERROR, MISSING, or inherited error is actually constructed. Paired runs of a 148 KiB clean Java witness improved by 43-47% with unchanged full-span acceptance; isolated Go, Python, and Swift corpus parity remained exact, and incremental/reuse parses retain the conservative path.
- Conflict-reduction frontiers now reuse one fixed-table lookup when reading and updating the forked and seen flags for a reduction key. Paired runs of a 707 KiB clean Dart witness improved by a further 6-13%, with fresh and incremental C parity unchanged.
- Automatic forest dispatch for the exact built-in JavaScript grammar now limits the speculative forest phase to 128 MiB while preserving the caller's full budget for the production fallback and for explicit forest parsing. A 20,784-file locked-corpus comparison preserved every tree, byte range, span, error, and stop outcome while reducing aggregate parse time by 3.09%, allocated bytes by 2.96%, and peak RSS by 19.02%. Caller-provided, modified, and same-name grammars retain the existing full-budget behavior.
Fixed
- Accept pinned C-oracle checkouts whose raw tracked bytes match the locked commit even when an upstream .gitattributes rule makes Git report a fresh clone as modified, while continuing to reject real byte, mode, and untracked changes.
- Real-Go benchmark fixture admission now drains its arena-pool state after validation, and the arena GC-retention regression establishes its own clean pool boundary instead of measuring memory retained by earlier tests.
- C-oracle forest audits now compare wide syntax nodes with a linear tree cursor, avoiding quadratic indexed-child walks while retaining exact fields, spans, flags, anonymous children, and child order.
- Forest audit timeouts now stop the parser synchronously instead of leaving abandoned parse goroutines to contend with later files in the same shard.
- Go/C benchmark admission now uses the same locked upstream runtime and Go grammar as structural parity, fingerprints the -O2 C artifact, and times immutable, clean, forking real-Go fixtures with symmetric tree lifecycles. The generated 500-function source remains a straight-LR regression control; its former 1.895x headline and 29% materialization decomposition are withdrawn because the C lane used a different grammar and the source never exercised the multi-stack path. A checked-in strict receipt driver now reproduces the pinned-core Go-C-C-Go schedule; both C transports reject dirty pinned-source caches, and the static lane snapshots each input once before identity, parity, and timing checks. The first complete publication receipt establishes the corrected full-parse baseline at 5.481673x C by equal-fixture geomean and 6.313799x C for the fixed-suite sum of medians, with per-fixture ratios from 4.639849x to 6.513909x.
Open source →
v0.36.1-0.20260714045751-a5df0aa5b3c514 Jul 2026pre-release
Nothing published for this version
v0.36.014 Jul 2026
Release notes2 sources agree
Parser recovery, recurring-work, grammar-contract, and browser-runtime release. C-recovery elections and retained memo invalidation reduce fixed overhead; retry selection and generated-language provenance are stricter; and the browser runtime gains persistent incremental documents plus reproducible selected- language bundles for Go and TinyGo.

This release supersedes v0.35.0. That tag was published from incomplete ancestry; its browser-runtime changes have been reconciled here with every change on the current main line. The v0.35.0 tag remains immutable so existing Go module downloads continue to identify one source revision.

Added
- The browser runtime now supports persistent UTF-16 documents through open, update, close, and queryDocument. Updates compute a surrogate-safe minimal edit, reuse the prior parse tree, and run highlights, tags, and bounded queries over the same retained tree while leaving the existing stateless parse, query, and highlight APIs intact.
- cmd/wasmassets now emits reproducible single-language browser bundles for either the Go or TinyGo WebAssembly compiler. Bundles contain the external grammar blob, highlight and optional tags queries, the matching compiler bootstrap, and a manifest with compiler identity and SHA-256 digests; the runtime build is restricted to the selected grammar's tables, registry, and scanner support instead of embedding the full grammar fleet.
Performance
- Linearized C-recovery strategy-1 elections with reusable cursor and dedupe scratch. Against exact current main on the pinned quiet core, KDL recovery improved 19.26% with 29.39% fewer bytes and 30.83% fewer allocations, while the tiny-clean control remained statistically unchanged.
- Reused C-recovery node memos now use generation invalidation instead of clearing a retained 16K-entry cache on every parse. On the pinned quiet host, recovery-primed KDL tiny-clean parses fell from 31.98 microseconds to 13.46 microseconds (57.93%), while alternating error/clean parses improved by 3.06%, with unchanged bytes and allocations per operation.
- The exact built-in Meson grammar now skips the redundant accepted-error retry ladder only for sources of at least 2 KiB. A locked 1,549-file corpus certification preserved complete and structural trees across all 28 eligible error-bearing files and cut their aggregate one-pass parse time by 78.04% (1.410s to 0.310s). Smaller inputs keep the generic retry ladder, including seven witnesses where retrying changes the selected tree.
- The exact built-in Enforce grammar now reuses a certified complete accepted-error widened result instead of repeating it with recovery enabled on sources of at least 128 KiB. Locked full-tree, structural, and semantic runtime checks remained exact; count-10 runs cut playerbase time by 28.01% and itembase time by 7.31%, with corresponding allocation reductions and an unchanged clean control.
Fixed
- Browser runtime results are now assembled as explicit JavaScript objects and arrays, avoiding TinyGo's primitive-only syscall/js.ValueOf path while preserving the richer structured-tree and bounded-query wire formats.
- The real-corpus Docker runner now forwards REAL_CORPUS_ONLY, allowing a reproducible single-language run without switching to a different wrapper.
- HTML range normalization no longer extends already-closed child elements across trailing trivia to an enclosing end tag; genuinely unclosed recovered element chains retain their C-compatible range extension.
- Full-parse retry selection now preserves an accepted error tree when a later retry stops early, instead of replacing it with a farther provisional tree.
- Grammargen-owned Go, Regex, and Swift blobs now share one registry provenance contract, and ts2go's Go regeneration hint uses the safe grammargen emit go command without LR splitting.
- Fleet scoreboard reduction now canonicalizes hard-gate finding order and records clean reducer provenance separately from immutable measurement provenance, allowing later reducer fixes to authenticate historical shards without weakening tamper checks.
Open source →
v0.35.013 Jul 2026
Nothing published for this version

github.com/odvcencio/gotreesitter

Release timeline

Releases

Fixed

Fixed

Changed

Highlights

Evidence

Known limits

Added

Changed

Removed

Fixed

Added

Improved

Docs

Known Issues

Fixed

Added

Improved

Docs

Known Issues

Fixed

Improved

Known Issues

Fixed

Improved

Added

Docs

Known Issues

Fixed

Improved

Added

Known Issues

Fixed

Added

Tooling

Performance

Tooling

Fixed

Performance

Documentation

Fixed

Tooling

Performance

Security

Fixed

Documentation

Fixed

Tooling

Performance

Fixed

Tooling

Added

Changed

Tooling

Performance

Fixed

Added

Performance

Fixed