[renovate]

This PR contains the following updates:

Package	Change	Age	Confidence
github.com/odvcencio/gotreesitter	v0.53.0 → v0.57.0

---

Release Notes

odvcencio/gotreesitter (github.com/odvcencio/gotreesitter)

v0.57.0: gotreesitter v0.57.0

Compare Source

Highlights

• Add a pure-Go command for parsing, queries, highlights, symbols and corpus tests.
• Correct highlight priorities and inheritance, with explicit upgrade notes for changed captures.
• On pinned fixtures, legacy YAML parse time fell 5.39% over 20 paired runs;
  a compact 1 MiB Go parse allocated 17.52% fewer bytes (#​1486, #​1504).

Upgrade notes

• grammars.JSONTokenSource, NewJSONTokenSource and NewJSONTokenSourceOrEOF
  are removed, and the registry no longer routes json through a token source.
  To upgrade, call parser.Parse(src) where you called
  ParseWithTokenSource(src, grammars.NewJSONTokenSourceOrEOF(src, lang)), and
  parser.ParseIncremental(src, old) for incremental parses. Drop
  WithTokenSourceFactory from highlighters and taggers for JSON. Code that
  calls entry.TokenSourceFactory(...) without a nil check must check for nil
  and fall back to Parse. Trees differ from the old ones on 6 JSON files in the
  test corpus, and in each of them only the DFA tree matched C.

• Highlight and its incremental and UTF-16 variants no longer return a range
  for a spell, nospell, conceal, none, underscore-prefixed or
  locals-directive capture. Code that reads a spell, none or underscore
  capture from Highlight no longer receives it.

• Injected child layers keep their own pattern order on identical spans, as a
  standalone file does. Before, a layer lost its pattern indexes and the order of
  the matches decided. In a Markdown fence of starlark, { changes from
  punctuation.bracket to punctuation.special.

• On a span that an injected language and its host both capture, the injected
  capture now wins. Before, the host's capture won unless it came from the first
  pattern of the host's query.

• Queries that set (#set! priority N) now resolve overlaps by priority. Before,
  the directive had no effect and the narrower capture won. Sixteen shipped
  queries set a priority. In the diff query, the ---, +++, - and +
  markers now take diff.minus or diff.plus instead of punctuation.special.
  In hare, :outer in break :outer; is one label range where it was a
  punctuation.delimiter range and a variable range, and in tablegen, !add is
  one function range where it was a punctuation.special range and a
  function range.

• ExternalVM scanner APIs are removed. Implement a Go
  gotreesitter.ExternalScanner instead (#​1536).

• The grammars facade drops per-language scanner aliases and unused helpers,
  including DecodeAndCertifyLanguageBlob. Import grammars/runtime for the
  equivalents exported there (#​1536).

• Replace corpuscheck.RunLanguageLimited with RunLanguageWithOptions and
  RunOptions{MaxCases: n} (#​1536).

• The tsquery command now requires -lang. Supply the registered grammar
  name so the query is compiled and validated before code generation
  (#​1537).

• Use gotreesitter test in place of the standalone corpuscheck command.
  Corpus mismatches return exit status 1; an empty selection or a requested
  language that cannot run returns status 2 (#​1524).

• Callers can no longer use a nil root to recognize an accepted parse with no
  syntax nodes. Check the input itself for an empty byte slice and inspect
  HasError() for parse errors (#​1543).

• Curated and inherited highlight queries change some capture names. Check
  themes that map built-in captures to colors (#​1539).

Added

• Add cmd/scannercert, a report-only tool that replays external scanner calls
  from saved state and reports any difference from the live result. It grants no
  incremental-reuse approval and changes no scanner capability flag
  (#​1518).

• Add the pure-Go gotreesitter command for parsing, querying, highlighting,
  tags, outlines, code patterns and corpus tests. It accepts files or standard
  input and supports JSON output (#​1524).

• Add LangEntry.Parse, NewParser and NewHighlighter helpers that use the
  entry's registered token source when one is available (#​1537).

Changed

• Make the highlighter return only captures that name a color. It no longer
  returns private captures (a leading underscore), @spell, @nospell,
  @conceal, or the directives of a locals query (@local.scope,
  @local.reference, @local.definition, @local.definition-value and
  @local.definition.*); predicates and directives still read them. @none
  clears the colors of its own priority beneath it, including the color of an
  enclosing capture of that priority, and is not returned. It does not clear a
  capture of a lower priority, so the reset that the Markdown query puts on a
  fence leaves the injected language's own colors, such as zig's strings at
  priority 95. This follows the convention nvim-treesitter documents for
  @none; tree-sitter-highlight and Neovim's own highlighter keep the enclosing
  color under an inner @none node. (#set! priority N) sets the priority of a
  pattern's captures, with a default of 100. Injected child queries follow the
  same rules, and at equal priority an injected capture wins over the host's
  capture on the same span. A VHDL comment keeps its @comment color, and a
  private capture such as @_key no longer hides the color of its node
  (#​454).

• Remove the BitBake, Corn, DTD, Templ, and Wolfram result-compatibility
  arms. None of them rewrote a node on any registered witness, and the trees
  on the production, compact, forest, and incremental routes are the same with
  the arms removed. ParseRuntime().NormalizationPasses and the
  GTS_DISPATCHER_CENSUS output no longer list a dispatch.<language> pass
  for these five languages. The five languages are now eligible for
  compact-tail elision. The Perl arm stays: it still regroups push @a => ...
  arguments the way locked C does.

• Reduce YAML parse time and allocation. The YAML scanner caches the current
  rune within each request (#​1486), prepares its scanner bindings once
  (#​1491) and keeps indentation type and width in one frame stack (#​1514).
  The cached-rune change cut legacy YAML parse time by 5.39% (p=.004, 20 pairs);
  the prepared bindings cut ordinary YAML parse time by 2.60% (p=.028).

• Reduce memory on the compact parse route. Allocated bytes for a fresh 1 MiB
  Go parse fall 17.52% (453,602,488 to 374,143,160 B/op, p<.001) because public
  subtrees now live in 64K-record blocks (#​1504). Graph nodes shrink from 24
  to 16 bytes (#​1500) and no longer copy the whole arena when it grows
  (#​1502). Dependency and lexer-history allocations also shrink (#​1480);
  allocation for a 20 KB query compile falls from 140,563 to 10,512 B. Timing
  differences were inconclusive. The compact route is not the default for every
  language.

• Parse JSON with the grammar's own DFA lexer, and delete its hand-written token
  source (grammars/runtime/json_lexer.go). Both paths were compared with the
  locked C parser on 303 JSON files: the DFA path matched C on 303 files, and the
  token source on 297. No file matched C only through the token source.
  LangEntry.TokenSourceFactory is now nil for JSON, so ParseFile,
  ParseFilePooled and the other registry helpers use Parser.Parse. The Java
  token source stays: it is the only implementation of the end-of-file comment
  append proof, and without it typing at the end of a trailing comment in a
  Java file runs a hidden fresh parse on every keystroke. C, C++ and authzed
  also keep their token sources: C matched C on 4 corpus files where the DFA path
  did not, and the C++ token source matches C on a malformed class body that the
  DFA path parses without an error.

• Compose highlight queries from first-line ; inherits: directives and add
  curated query coverage, including Apex, Vue, V, Typst and HLSL. Imported
  queries carry source and license attribution (#​1539).

• Scan YAML comment content in batches (#​1567).

• Reduce DFA, publication and read-history overhead in certified Go incremental
  parsing. Unsupported or unproven reuse retains fresh verification
  (#​1570).

• Publish compact parse results through owned node views and preserve recovery
  and scanner-history checks (#​1569).

• Page compact compatibility snapshots and cap the scrubbed workspace retained
  between calls. On the qualified roughly 2 KiB TypeScript fixture, allocated
  bytes fell from 167.425 to 3.139 KiB per parse; the separate 1 MiB probe's peak
  RSS fell from 294,732 to 165,056 KiB (#​1577).

Fixed

• Go: make compact recovery return (source_file (ERROR)) for ,, as the C
  parser does. Reuse completed Scala snippet roots, which removes about 17 MB of
  allocation for malformed 24-30 byte Scala inputs (#​1452).

• TypeScript and TSX: parse an async generic arrow such as
  async <T>(v: T): Promise<T> => v correctly instead of as a
  binary_expression (#​1483).

• TypeScript and TSX: parse generic tagged template calls such as
  tag<string[]>`text` instead of reading them as comparisons or failing
  (#​1515). This regenerates typescript.bin and tsx.bin.

• Generated grammars: keep the span of a consumed hidden newline when a
  newline-or-NUL terminator follows (#​1513). None of the 206 shipped grammars
  takes the changed branch.

• 32-bit builds: fix a panic when a parser state with the high bit set became a
  negative int in a bounds check (#​1485).

• Compact projection: publish hidden-supertype ancestry and synthetic-root
  metadata exactly. The Go supertype query failed before this fix (#​1484).

• Make: accept builtin names such as $(file) and ${dir} as variable
  references, including nested expressions, while preserving function calls
  (#​1561).

• Kotlin: preserve queued reduction alternatives for the certified shipped
  grammar, including the generic-call regression cases (#​1568).

• Accepted parses with no syntax nodes now return a zero-width ERROR root
  instead of a nil root, matching locked C on the affected cases (#​1543).

• Generated C exports for pre-ABI-15 grammars compile against the pinned runtime
  headers while retaining the older lexer-mode table layout (#​1579).

• PowerShell: update the pinned grammar and scanner so native arguments such
  as comma lists, bare -- and -, attached option values and trailing &
  parse cleanly. The replay preserves the original contributor's work
  (#​1576, #​1574).

• Keep trailing comments outside recovered ERROR nodes when an ancestor
  recovery path contains a discontinuity (#​1580).

Evidence

• Validation and measurement scope are recorded in the linked pull requests,
  including the qualified Go incremental run,
  #​1569 and #​1579. The release receipt binds the final commit and its full manual CI run.

v0.56.0: gotreesitter v0.56.0

Compare Source

Added

• Add opt-in Python, JavaScript, TypeScript and TSX declaration, signature and
  call-argument facts through the existing grammar-owned options. Share symbol
  sets, binding selectors and parameter extraction while preserving Go and
  legacy outputs. Include Python unpacking and keyword arguments, JavaScript
  named function bindings, TypeScript optional parameters and typed members,
  and standalone constructor arguments in JavaScript, TypeScript and TSX.
  Type shapes remain types-only; defaults and member modifiers are omitted
  (#​1435).

• Complete opt-in Go declaration facts with embedded fields, interface embeddings
  and dotted anonymous-struct containers. Add FactSignatures and
  FactCallArguments through parallel grammar-owned rule options, preserving
  exact parameter type text and argument order/ranges. Function literals and
  function types have no signature facts; other languages remain out of scope
  (#​1435).

• Add opt-in Go declaration facts through NewFactProgramWithOptions,
  FactDeclarations, and WithDeclarationRules(grammars.DeclarationRules(entry)).
  FactSet.Declarations contains separate package variable and constant names,
  named struct fields, explicit interface methods, aliases, type shapes, and
  member containers. NewFactProgram, DefinitionSpan, Definitions, and
  FactAll retain their existing contracts
  (#​1435).

Changed

• Add bounded lexer-read certificates for incremental subtree reuse. Keep fresh
  verification when scanner history, recovery, or ownership remains unproven
  (#​1402).
• Extend certified incremental reuse to Go, Java, JavaScript, TypeScript,
  Python, Rust, C, and C++
  (#​1413).
• Reuse certified ASCII run edits in Lua, Nickel, Starlark, Properties, and
  FIRRTL; keep fresh parsing for unsupported edits
  (#​1412).
• Bound external-scanner checkpoint memory growth
  (#​1410).
• Retain certified subtree reuse for large edits without a redundant fresh
  parse. Keep fresh verification for unproven histories and recovery results
  (#​1421).
• Reduce compact-route runtime and acceptance costs, including end-of-file
  completion for owned YAML document streams
  (#​1434).
• Reuse authenticated private scanner checkpoint copies, share immutable
  owned-lexer metadata, and validate each checkpoint with one retained-record
  lookup. Owned YAML parses allocate less and run faster
  (#​1446,
  #​1447,
  #​1448).

Fixed

• Keep an earlier TSX generic call intact when a typed function is appended
  after it, instead of reparsing the call as a binary expression
  (#​1443).
• Retain reduction alternatives for incomplete scanner histories, so the Go
  input Foo[int](Foo[int](a)) matches locked C again
  (#​1434).
• Keep a new blended-lineage marker when the same alternative-set members are
  republished, and invalidate stale reused-lineage proofs
  (#​1447).
• Record every discarded live alternative in the parse-wide pruning state,
  independently of diagnostic counters, so pruned parses never publish an
  incremental-reuse certificate. Pruned large recovery edits now receive fresh
  verification, and the GSS eight-link cap regression is fixed. Six large-edit
  token-work cells carry exact exemptions that expire with certificate v2
  (#​1440).
• Include Go type declarations, aliases, parenthesized types and explicit
  interface methods in inferred Go tags and outlines
  (#​1438).
• Preserve YAML syntax errors and recovered nodes during result compatibility
  normalization (#​1400).
• Include ERROR roots and children in Node.SExpr even when recovery leaves
  their named flag unset (#​1400).
• Preserve C recovery state across edit sessions and complete long EOF
  reductions without a false iteration-limit stop
  (#​1416).
• Match locked C's AWK scanner token boundaries and recovered histories
  (#​1420).
• Correct conflict ordering, scanner behavior, and missing-token recovery for
  TypeScript, Bash, C++, C#, Swift, Dart, and SQL
  (#​1414).
• Preserve verified fresh results when a large-edit retry would discard them
  (#​1408).
• Require incremental verification to match fresh stop reasons and preserve
  recovery results across edit sessions
  (#​1409).
• Preserve operation deadlines, propagate verifier errors, and authenticate
  the concrete lexer before trusting EOF reuse proofs
  (#​1426).
• Preserve recovered YAML mappings after unclosed flow sequences followed by
  comments or single-quoted scalars
  (#​1424).
• Preserve HasError() when hidden missing tokens are removed from the
  public tree, including malformed COBOL program names
  (#​1419).

Maintenance

• Distinguish historical AWK raw-tree receipts from current parser results
  (#​1422,
  #​1424).
• Extend required locked-C CI coverage for scanner and lexer regressions and
  JavaScript/TypeScript edit sessions
  (#​1425).

Publication exception

On 2026-10-04, the owner authorized the v0.56.0-only tag-creation exception.
The exception permits publication without a workflow-only tag-creation actor rule.
All other gates remain mandatory under
the release process.
This standard minor release still requires full CI and performance evidence for
the exact candidate, a signed receipt, and protected release environment approval.

v0.55.1: gotreesitter v0.55.1

Compare Source

Fixed

• Restore the Python initial stack cap of two when the source has no possible unpacking expression.
  Keep eight stacks for possible unpacking and preserve explicit stack overrides
  (#​1290).
  The report's inline generator builds 371,146 work nodes instead of 623,912.
  Production fresh parsing fell from 267.331 to 161.811 ms; the tree retains 59,105 nodes.
  The seven list-splat fixtures still match locked C. Django retains six differences across 2,932 files.
• Preserve conflict forks beyond stack depth 4,096 and reset the dispatch guard when reductions reach a new minimum depth
  (#​1291).
  C now returns clean, complete trees for 4,091 functions and up to 65,536 string calls in one function.
  Both lexers pass fresh, incremental, and locked C comparisons at the tested counts.
  At 8,192 calls, TokenSource parsing fell from 2,445.8 to 115.7 ms.
  The deterministic finite automaton (DFA) lexer fell from 2,425.1 to 123.7 ms.
• Remove a duplicate clone during hidden-node alias materialization
  (#​1292).
  Scala work nodes fell from 168,685 to 149,592 on both routes; the tree retains 57,281 nodes.
  Production fresh parsing fell from 73.565 to 70.638 ms.
  Work remains 4.5% above the old grammar's 143,197 nodes.
• Extend the poor-yield reuse guard to roots with more than four children
  (#​1292).
  A Dart proxy fixture now retries fresh for expensive edits and retains profitable suffix reuse.
  Production insertion fell from 240.990 to 123.209 ms; deletion fell from 718.243 to 123.759 ms.

Documentation

• Align the roadmap, repository map, and agent workflow with the owner's v1 design
  (#​1329).
  This patch adds no public API or admission-default change.

Measurement scope

The linked pull requests contain separate correctness and performance evidence.
Each completed the randomized Go benchmark trio with 20 shuffle seeds and 750 ms per case.
The runs used one process per seed and GOMAXPROCS=1.
No primary timing change was significant; primary allocations stayed at eight, five, and zero per operation.
These Linux measurements do not establish Windows performance.
Python uses the reporter's inline generator. Dart uses a 137 KiB proxy with 45.4% baseline reuse.
The reporter measured 41.8% Dart reuse; the exact fixture remains unverified.
Scala compact timing varied, with some medians increasing despite fewer work nodes.
The standard Scala grammar importer still rejects _end_marker_named_tail; focused locked C checks pass.
C corpus results remain 23/25 clean files and 20/25 deep matches.

Publication exception

On 2026-09-26, the owner authorized the v0.55.1-only tag-creation exception.
The exception permits publication without a workflow-only tag-creation actor rule.
All other gates remain mandatory under the release process.
This urgent patch addresses the Python regression and false C errors reported in #​454.
Waiting prolongs Python keystroke delays and false errors in valid C documents.

Known gaps

• #​1280 remains open and excluded.
  Transient-error incremental trees, ERROR roots with false HasError(), and diff and LESS edit mismatches remain unresolved.
• C# still misses the sub-second target at 137 KB. This patch contains no C# merge-preflight optimization.
• Scala retains extra work from the refreshed grammar and seven existing suffix gaps.
• VHDL inner @spell captures, blank HTTP comments, and compact sibling traversal remain unresolved.
• Six Django tree differences, two CSV comma witnesses, and the PHP compact recovery winner remain open.

v0.55.0: gotreesitter v0.55.0

Compare Source

Added

• Add WithHighlighterAdmissionCandidateRoute to select the route for the
  document parser and injected parsers (#​1281).
• Add optional compact parser telemetry for peak frontier headers and derivations
  (#​1285).
  Locked C checks cover three fresh JSON trees and seven fresh CSV witnesses.
  One incremental edit per language also matches with subtree reuse.

Changed

• Give explicit process settings priority over the language admission allowlist.
  A parser override still has first priority. The allowlist now widens only
  the implicit default. This behavior change requires a minor release.
  Both SetAdmissionCandidateRouteDefault(false) and
  GTS_ADMISSION_CANDIDATE=0 keep production selected
  (#​1281).

Fixed

• Ignore Accept when the compact reduction collector checks whether a source can shift
  (#​1284).
  Four strict Scala witnesses match locked C without compact fallback.
• Elect accepted material paths inside the winning compact recovery group
  (#​1286).
  Preserve acceptance identity across grammar forks and closed error regions.
  Decline unsupported paths without publishing a guessed tree. The PHP compact request still falls back before acceptance.
• Bound end-of-file (EOF) recovery versions before allocating reduction parents
  (#​1287).
  Apply the native symbol-zero trial only to the certified Scala grammar blob.
  The Scala suffix suite records 50 exact matches and seven unchanged gaps across 57 cases.
  The 104,681-byte Swift witness completes without truncation or a memory stop.
• Prevent overlapping Python escape_sequence nodes when escaped backslashes
  precede a newline. All 18 fixtures now match the locked C tree on both routes;
  12 matched before the fix. Fixes #​1275
  (#​1276).
• Preserve Python list_splat binding for attribute and subscript suffixes
  during mixed flat and graph stack merges. Seven C fixtures match on both routes.
  Exact C tree differences across 2,932 Django files fell from 101 to 6.
  Fixes #​1274
  (#​1277).
• Reject query runs that cannot reach a required successor before enumerating
  capture combinations. Preserve highlight capture order for identical spans
  and prefer a highlight over @spell. Report quantified roots as non-rooted
  in IsPatternRooted (#​1278).
  The production query on 755 Nushell comments fell from 16,577.358 to 0.360 ms.
  Full highlighting of that 8 KB file took 20.132 ms after the change.
• Cache raw-shape error costs during generalized left-to-right (GLR) elections.
  Bound graph reachability checks and reject impossible merges earlier
  (#​1279).
  The reporter's C# fixture changed from quadratic growth to approximately linear growth.
  Production parsing at 32 KB fell from 12,662 to 900 ms.
  A separate 137 KB run measured a 3,008 ms median after the final merge precheck.
• Stop Make forest rescue at the first dead end when it cannot accept recovery.
  A reconstructed 3.5 KB fixture with an early error fell from 27,377.173 to
  13.015 ms on production (#​1282).
• Build C-certified HTTP sections directly for newline-terminated, nonblank
  # comments under the certified grammar hash. Preserve deadlines and
  memory budgets; disable incremental reuse for these direct trees
  (#​1282).
  Production parsing at 32 KB fell from 2,160.112 to 1.657 ms.
  The result now matches the complete C tree instead of returning one error node.
  Maximum resident memory fell from 2,178,624 to 12,892 KiB.
• Stop incremental reuse with low yield after bounded work and retry a fresh parse.
  The guard requires an early edit, a live graph fork, and at most four root children.
  The guard applies across grammars (#​1282).
  Production insertion in the reconstructed 137 KB Dart fixture fell from
  258.646 to 119.063 ms. Maximum resident memory fell from 220,912 to 123,796 KiB.

Measurement scope

These measurements come from the linked pull requests on Linux amd64.
They do not establish Windows performance. C# runs used the reporter's exact
fixture; Make, HTTP, and Dart used deterministic reconstructions.
Host load varied during the C# sweeps. The Nushell baseline used one repetition;
the result after the change used the median of three repetitions.

PR #​1282 completed the standard Go trio with 20 shuffle seeds and 750 ms per benchmark.
It used one process per seed, GOMAXPROCS=1, and GOWORK=off.
The benchmark comparison found no significant time change:

Benchmark	Before ns/op	After ns/op	B/op, unchanged	allocs/op, unchanged
Full parse	3,456,000	3,411,000	1.224 KiB	8
Single-byte edit	91,310	90,720	386	5
No edit	3.307	3.294	0	0

The linked pull requests contain reproduction commands and separate correctness evidence.

PRs #​1284–#​1287 each record 20-seed randomized comparisons without significant changes in the three primary parse times.
PR #​1285 shared its host with another workload; its timing evidence has that limit.
PR #​1286 measured 111,092 KiB maximum resident memory for a 512 KiB Go parse.
PR #​1287 measured warm Swift maximum resident memory of 257,440 KiB before and 257,332 KiB after the change.
Its primary allocation counts remained 8, 5, and 0.

Publication exception

On 2026-09-24, the owner approved a one-time tag-creation exception for v0.55.0.
The exception permits publication without a workflow-only tag-creation actor rule.
All other gates remain mandatory under the release process.

Known gaps

• #​1280 remains open and is excluded.
  Transient-error incremental trees and the diff and LESS edit mismatches remain unresolved.
  Its locked C gate still fails for malformed JavaScript, LESS, and TOML fixtures.
• C# still takes about three seconds at 137 KB on the measured host.
  Graph stack merges remain under investigation; the sub-second target remains open.
• Scala remains unresolved. A Linux bisect identifies grammar update 74159ec1b
  as the fresh-parse regression trigger. Linux edits did not reproduce the
  Windows slowdown. Preserve the new grammar's coverage while investigating its cost.
• Blank HTTP # comments retain the existing parser route and need a locked C regression.
• Six Django files retain separate C tree differences after the Python splat fix.
• CSV , and a,b, still differ from locked C on both parser routes.
• The PHP compact recovery winner remains open; the generated corpus records 6 of 25 exact deep matches.
• Seven Scala suffix gaps predate the EOF recovery bound. Other grammar blobs retain the exact EOF row.

v0.54.0: gotreesitter v0.54.0

Compare Source

Added

• Add FactProgram.ExtractInto to reuse caller-owned fact storage across trees.
• Add a per-language admission allowlist (empty by default) so a later change
  can graduate one language's compact route without flipping the global
  default.
• Add the admission_route_performance_sanity CI gate, comparing the compact
  route against the production route in-process, interleaved, on a fixed
  9-language corpus.

Changed

• Default the compact ("candidate") admission route to off. Buildbox's
  tamarack harness measured it 1.1x to 2.2x slower than production on typical
  files across Python, Rust, Markdown, Lua, CSS, Bash, and Go, and
  TypeScript/YAML paid for both routes on every parse (compact declines, then
  production reparses). Set GTS_ADMISSION_CANDIDATE=1 (or true/on/yes)
  to opt back in.
• Throttle the compact scheduler's memory-footprint poll: recompute the exact
  footprint on the first poll of a parse attempt, every 64th poll after it, or
  whenever a cheap, O(1) capacity-based growth proxy shows growth covering
  1/16th of the configured budget since the last exact check. This bounds
  worst-case overshoot by construction, not just by dispatch count. Measured
  peak-footprint overshoot: 1.25-2.16% over budget on an adversarial witness.
• Make ExternalLexer's read-frontier tracking lazy: skip the frontier
  recompute once the recorded values already provably cover the current
  position. This benefits every route that uses an external scanner (YAML,
  Python, Markdown, Bash, and others), not just the compact route.

Fixed

• Preserve explicit end-token acceptance when importing and minimizing C lexer
  states. Regenerate CSV from its locked C source. Older blobs retain their
  end-of-input fallback.
• grammargen gives a named token.immediate() terminal with a string body the
  same specificity bonus that an inline one gets. The lexer again accepts the
  immediate terminal instead of a plain string literal with the same text.
  Swift var opt: Int? parsed with an ERROR after a table rebuild, because the
  anonymous ? won the same-span tie over _immediate_quest. Pattern-bodied
  named immediate terminals keep their authored precedence.
• Fix parser_result_yaml.go silently clearing HasError() for a lone
  unmatched YAML flow-collection opener (for example a bare [ at end of
  input), which diverged from the C reference's (ERROR ...) shape. The
  production route now declines recovery for a bare [/{ and promotes an
  all-ERROR reduction to the ERROR root itself. This bug predates this
  release; the compact-route default flip is what exposed it.
• The scanner fuzz allocation check now measures the minimum across 5 samples
  instead of requiring every re-run to exceed budget, removing a transient
  GC-timing false failure. The byte-budget assertion is skipped under the
  race detector, where instrumentation noise swung a measured TotalAlloc delta
  for the same input from about 66KB to about 29MB (more than 400x) and could
  no longer separate noise from a real finding. The elapsed-time check and the
  parser memory budget (WithParserPoolMemoryBudgetBytes) remain the hard
  bounds under -race.
• Invalidate the GLR shape-prefix cache only when a stack merge rewrites a
  link 0, not on every successful merge. A fixed nesting depth that forks and
  merges on every token used to rewalk the whole spine on the next head hash,
  which turned the parse superlinear past depth 1600 (issue #​454). An
  extra-link-only merge now keeps its exact cached prefixes.
• Resume C and Java TokenSource scanning from the still-valid queued
  literal-tail tokens, instead of resetting and relexing, when incremental
  reuse resumes inside an already-queued string or character literal. The
  reset path used to drop the queue and misread the remaining bytes, so the
  incremental tree could differ from a fresh parse.
• Track reused bytes for plain ParseIncremental, not only for
  ParseIncrementalProfiled, so the reuse-budget stop arms on both entry
  points. ParseIncremental allocates no timing record, so a reuse-hostile
  edit taken through that entry point never armed the stop before this fix.
• Exempt extra (comment and whitespace) leaves from the compact incremental
  reuse proof. One unproven extra leaf used to disable incremental reuse for
  the whole compact tree; an ordinary leaf still requires a proof.
• Fall back to a fresh full parse when ParseIncremental receives an old
  tree with no recorded Tree.Edit call and a new source of a different
  length. The incremental path used to trust stale byte positions against
  the new source in that case, with no error or ParseStoppedEarly signal.
• Route every Groovy incremental parse through a fresh full parse. The
  Groovy grammar table derives a function-call juxtaposition only for a
  block's first statement, so spliced incremental reuse could produce a tree
  that a fresh parse of the same bytes never produces. Groovy's incremental
  performance is unchanged; parity with a fresh parse is now guaranteed
  instead of usually holding.

Known gaps

• COBOL's column-dependency edit-invalidation over-invalidates a later-line
  token after an earlier-line, non-crossing edit. This is fail-safe (extra
  reparse work, not a wrong tree); COBOL does not support incremental reuse
  today, so it has no current observable effect. Root cause is out of scope
  for this release.

Breaking Changes

• GTS_ADMISSION_CANDIDATE now defaults off; its meaning is inverted from the
  prior release. Set it to 1, true, on, or yes to keep the compact
  route on.

Performance evidence

Buildbox's tamarack harness measured the default route's in-process Go/C
ratio across three independent interleaved runs on a fixed 9-language
typical-file corpus, comparing this release's candidate code against the
prior default:

lang	before	after	speedup
go	5.97x	5.42x	1.10x
python	2.87x	1.54x	1.86x
typescript	3.17x (100% fallback)	2.31x	1.37x
rust	5.06x	2.53x	2.00x
yaml	3.56x (100% fallback)	2.34x	1.52x
bash	3.65x	2.08x	1.75x
markdown	6.36x	2.87x	2.22x
lua	4.66x	2.33x	2.00x
css	4.60x	2.36x	1.95x

The lever-2 overshoot-bound refinement (dominant-capacity growth trigger) cost
nothing measurable; the ratio table is unchanged within run-to-run noise after
it landed. Source: #​1264. A downstream #​454 report attributes its resolved
regressions to the production route becoming the default.

---

Configuration

📅 Schedule: (UTC)

• Branch creation
  • At any time (no schedule defined)
• Automerge
  • At any time (no schedule defined)

🚦 Automerge: Disabled by config. Please merge this manually once you are satisfied.

♻ Rebasing: Whenever PR becomes conflicted, or you tick the rebase/retry checkbox.

🔕 Ignore: Close this PR and you won't be reminded about this update again.

---

• If you want to rebase/retry this PR, check this box

---

This PR was generated by Mend Renovate. View the repository job log.

[coderabbitai]

Important

Review skipped

Bot user detected.

To trigger a single review, invoke the @coderabbitai review command.

Run configuration

• Source mode: Auto
• Repository: Unavailable
• Branch: Unavailable
• File: No configuration file from this repository applied
• Commit: Unavailable
• Layers: Organization UI
• Review profile: CHILL
• Plan: Advanced
• Run ID: 44290019-57e9-4b3f-b66b-f259386f6e8b

You can disable this status message by setting the reviews.review_status to false in the CodeRabbit configuration file.

Use the checkbox below for a quick retry:

• Trigger review

• Autofix · Keep fixing CodeRabbit findings and required CI, and resolving merge conflicts

[codecov]

Codecov Report

✅ All modified and coverable lines are covered by tests.
✅ Project coverage is 88.17%. Comparing base (1e7ba32) to head (890b844).

Additional details and impacted files

@@            Coverage Diff             @@
##             main     #365      +/-   ##
==========================================
- Coverage   88.17%   88.17%   -0.01%     
==========================================
  Files         362      362              
  Lines       34743    34743              
==========================================
- Hits        30636    30633       -3     
- Misses       4102     4105       +3     
  Partials        5        5              

Flag	Coverage Δ
unittests	88.17% <ø> (-0.01%)	⬇️

Flags with carried forward coverage won't be shown. Click here to find out more.

☔ View full report in Codecov by Harness.
📢 Have feedback on the report? Share it here.

🚀 New features to boost your workflow:

• ❄️ Test Analytics: Detect flaky tests, report on failures, and find test suite problems.

[sonarqubecloud]

Quality Gate passed

Issues
0 New issues
0 Accepted issues

Measures
0 Security Hotspots
0.0% Coverage on New Code
0.0% Duplication on New Code

See analysis details on SonarQube Cloud