fix(deps): update module github.com/odvcencio/gotreesitter to v0.48.0

[renovate]

This PR contains the following updates:

Package	Change	Age	Confidence
github.com/odvcencio/gotreesitter	v0.47.1 → v0.48.0

---

Release Notes

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

v0.48.0: gotreesitter v0.48.0

Compare Source

Added

• A validated Swift corpus now guards real-code parsing.
  Twelve files come from swiftlang/swift 6.3 and apple/swift-algorithms 1.2.1.
  A ratcheting expectations test fails on any regression or unrecorded fix.
  Five upstream grammar gaps are recorded in issues
  #​574 through
  #​578.

• The dispatcher census now reports distinct Ada, Apex, Bash, and Cooklang
  materialization subpasses.
  Compatibility-free probes record active and inert producer behavior.

• grammargen -js-cli now resolves grammar.js with Tree-sitter 0.26 or newer.
  It imports the temporary canonical grammar.json through the existing path.
  The explicit flag warns that grammar evaluation executes JavaScript.

• grammargen -js-cli now identifies a missing JavaScript runtime when
  Tree-sitter cannot start Node. The command help and README list both
  prerequisites.

• The canonical compact real-corpus matrix now records 70 direct routes,
  30 fallbacks, exactly 10 skips, and no divergence or error.
  The bounded current receipt covers 110 rows.

Performance

• Live-header scoping reduces compact full-parse allocation counts by
  11.27 percent on the 235,626-byte Go fixture.
  Allocated bytes fall by 26.64 percent.
  Parse time remains statistically unchanged for that fixture.
  The rewrite fixture regresses by 19.99 percent.
  The query-compile fixture regresses by 15.77 percent.

• The parser now skips four redundant source reconstruction passes for
  certified isolated C# recovered roots.
  The receipt requires one one-byte error, no missing nodes, and matching raw
  top-level spans.
  The 137 KiB deletion witness still matches the pinned C parser.
  Median full-parse time falls from 8.24 seconds to 5.01 seconds.
  Median memory falls from 608 MB to 195 MB.
  Median allocation count falls from 286,009 to 9,663.
  BenchmarkIssue454CSharpRecoveredFullParse uses GOMAXPROCS=1,
  -benchmem, -benchtime=1x, and -count=5.

• The graph-structured stack shape walk now skips a duplicate cache lookup
  after a known head miss.
  The standard full-parse benchmark improves by 5.12 percent across 20 samples.
  Allocations remain at nine per parse.

• Graph-structured stack hashing now selects inline or pooled walk storage
  before it collects nodes.
  The 235,626-byte Go fixture allocates 24.84 KiB instead of 110.34 KiB.
  Allocations fall from 511 to 169 per parse.
  Parse time and maximum resident set size remain unchanged.

• Outer parser-state re-lex transactions now reuse one 4 KiB scanner-state
  buffer.
  The 235,626-byte Go fixture allocates 7.583 MiB instead of 48.073 MiB.
  Allocations fall from 10,404 to 513 per parse.
  Two stable pairs improve parse time by 9.52 to 15.46 percent.
  Maximum resident set size falls from 220,236 KiB to 185,920 KiB.

• Direct parser-state re-lex probes now use their existing outer transaction.
  This removes a redundant scanner-state snapshot.
  The 235,626-byte Go fixture allocates 48.07 MiB instead of 86.69 MiB.
  Allocations fall from 20,290 to 10,400 per parse.
  Three stable benchmark pairs improve parse time by 10.90 to 15.26 percent.

• The compact scheduler now stores its common rollback frontier inline.
  This removes one allocation from a fresh full parse.

• The fresh compact runner now reuses its scheduler storage across parses.
  Full-parse allocations fall from 15 to 14 per operation.
  Parse time and allocated bytes remain statistically unchanged.

• The parser now reuses its bound stop-check callback across compact full
  parses.
  This removes one allocation and 16 bytes per operation.
  Full-parse time and maximum resident set size remain unchanged.
  Incremental parses retain zero allocations.

• Fresh compact full parses now store the scheduler receipt inside the
  scheduler allocation.
  Full-parse allocations fall from 17 to 16 per operation.
  Parse time, allocated bytes, and maximum resident set size remain unchanged.

• The compact full-parse receipt now stores its acceptance value in the
  scheduler receipt allocation.
  Full-parse allocations fall from 18 to 17 per operation.
  Parse time and allocated bytes remain statistically unchanged.

• PR #​498 moved the single-header compact dispatch cell onto the stack.
  This removes one allocation from the common full-parse path.
  The stable Go benchmark improves full-parse time by 15.57 percent.
  Allocated bytes fall by 20.25 percent.
  The allocation count falls by 7.89 percent.

• Certified graph-structured stack convergence now merges duplicate C# full-parse
  stacks while it retains their packed alternatives.
  The 137 KiB witness improves from 1.629 seconds to 98.7 milliseconds.
  Allocated bytes fall from 135.6 MB to 50.4 MB.
  The allocation count falls from 7,820 to 1,429 per parse.
  Incremental parses retain their previous merge policy.

• The compact full-parse runner now reuses buffers during canonicalization and
  tree materialization.
  Warm materialization drops from 136,584 to 272 bytes per operation.
  Its allocation count drops from 47 to 8.
  Total warm allocation drops from 20,440 to 5,208 bytes per operation.
  Total parse time remains statistically unchanged.

• The compact scheduler stores its one-element seed frontier inside the
  scheduler allocation.
  The warm full-parse benchmark drops from 20,352 to 20,328 bytes per operation.
  Allocations drop from 66 to 65 per operation.
  Parse time remains statistically unchanged.

Fixed

• Swift now recovers an if/else whose comparison condition ends with a
  parenthesised member access in the then-branch (a call argument or a
  parenthesised negation). The then-block no longer swallows the trailing
  else as a call's trailing closure.
  This fixes #​560.

• A Swift optional generic type such as Range<Int>? now parses cleanly.
  The token source defers the closer to the DFA only when a reduce action
  closes an open type_arguments production.
  This fixes #​556.

• A Swift constrained extension with a multiline where clause now parses
  cleanly. The scanner carries the resolved previous rune across comment
  handoffs instead of re-reading a raw source byte.
  This fixes #​557.

• Swift nested if let chains inside methods now parse cleanly.
  The recovery pass brackets only the right-hand side of the binding.
  This fixes #​558.

• Three or more nested Swift generic type arguments such as A<B<C<Int>>>
  now parse cleanly. The split fires only when an unclosed < sits open, so
  custom operators such as >>> stay intact.
  This fixes #​559.

• A Swift method that contains a for loop over a range, followed by another
  method, now parses cleanly. The recovery pass also fires when the for
  statement forms with an error inside it.
  This fixes #​561.

• Raw error-cost walks now retain each captured child shape reference.
  A later mutable node update cannot create a recursive shape cycle.
  The Rust aggressive corpus completes all 25 bounded parses without a crash.

• TypeScript and TSX now parse in, out, and in out variance
  annotations on type parameters.
  The source overlay uses the semantics from upstream pull request 361.
  This fixes issue #​539.

• TypeScript and TSX now separate adjacent generic call signatures at a
  newline.
  The grammar uses the dedicated function-signature separator.
  Generic automatic-semicolon behavior remains unchanged.
  This fixes issue #​540.

• Compact reductions now merge only with live scheduler headers.
  Removed historical versions no longer consume the shared boundary link cap.
  This retires four real-corpus fallbacks without a tree divergence.

• Shared DFA token election now prefers one composable close angle over a
  wider close-angle token.
  Nested TypeScript union arguments now retain the generic-call lineage.
  This fixes issue #​541.
  Apex nested generic declarations now match the pinned C tree without a
  result rewrite.
  This retires the Apex generic local declaration compatibility pass.

• The full-parse retry ladder now retains a widened candidate until it reads
  the candidate's runtime receipt.
  This enables the existing combined stack-and-merge retry for the ZodUnion
  fixture.
  This fixes issue #​544.

• Swift optional bindings now keep the statement body separate from a trailing
  closure. The generator now uses exact advanced LR item precedence.
  Production, compact, and pinned C tests cover the correction.
  The regenerated Swift blob retains its exact runtime profile certification.
  This fixes #​542.

• The DFA lexer now splits adjacent Swift generic closers by parser state.
  It preserves >> when the active state accepts the shift operator.
  The pinned C oracle now matches without divergence.
  This fixes #​543.

• Native grammar.js import now ignores comments in semantic AST children.
  All 206 pinned grammars show import coverage increasing from 62 to 70.

• AWK recovery now captures the original splice parent before it constructs a
  replacement concatenation.
  This prevents self-parent links during recovered expression materialization.
  A locked 7,392-byte production fixture now verifies bounded completion and
  a stable tree digest.

• Compact recursive insertion now proves external token identity from exact
  scanner checkpoints.
  Mismatched or missing checkpoints fail closed.
  Locked Kotlin, OCaml, Perl, and Rust fixtures now reach their next parser gate.

• Forest result selection now preserves an existing same-symbol container.
  Its children must exactly match adjacent visible root containers.
  This removes the inert HTTP section-coalescing compatibility pass.

• The native reduction path now sets Dart switch-expression body fields.
  It now sets the target field for nested Elixir calls.
  This change removes two inert language-local field repairs.

• Inherited reduction fields now fill anonymous gaps between repeated direct
  descendants.
  They do not cross a leading separator without direct descendant evidence.
  This change removes three Scala field repairs and the SQL INTO cleanup.

• Compact graph insertion now persists exact predecessor merges across a
  bounded 16-level path.
  Non-exact nested edges and deeper paths still fail closed.
  Locked C#, Elixir, Perl, and Scala fixtures now reach their next parser gate.

• The compact admission census now separates runnable no-table-action stops
  from paused frontiers.
  The real-corpus matrix labels production error trees.
  Clean graduation coverage no longer counts recovery fixtures as parser gaps.

• Compact graph branches now re-lex one exact token span for each parser state
  when the shared symbol has no action.
  Each alternative keeps the shared byte range and scanner checkpoint.
  The medium Scala corpus now reaches compact acceptance.
  A separate proof for joined reduction paths still gates direct publication.

• Exact grammar profiles can now flatten certified same-span unary wrappers
  during reduction materialization.
  The F# profile removes its declaration-name compatibility walk.
  Expression and dotted identifiers retain their wrappers.
  Compact and forest routes retain fail-closed behavior.

• Native C-style recovery now owns Angular, BibTeX, Chatito, and Electronic Data
  Sheet materialization for every registered recovery witness.
  This removes four inert result-compatibility dispatcher arms.
  Compact and forest routes retain fail-closed behavior.

• Native parser results now retain the expected Hurl and INI root types.
  This removes both expected-root fallback compatibility arms as one class.
  Compact and forest routes retain fail-closed behavior.

• Native recovery now owns Forth and Luau recovery-action materialization.
  Forth keeps C-equivalent missing terminators and empty-definition errors.
  Luau keeps recovered end tokens as identifiers.
  This removes both result-compatibility dispatcher arms.

• Parser recovery now owns skipped error materialization for Robot variables
  and Scheme quote-family forms.
  This removes both compatibility dispatcher arms as one defect class.
  Compact and forest routes retain fail-closed behavior.

• C-style recovery now marks an absorbed ERROR token as named.
  Recovered INI trees now match the pinned C parser at this node boundary.

• The tracked dispatcher census now includes the locked JavaScript
  convergence fixture.
  The receipt exposes seven active compatibility rewrites on a direct route.

• Native Crystal scanner lookahead now skips whitespace after hash and
  named-tuple openers.
  Exact token boundaries retire the Crystal compatibility dispatcher arm.

• PRs #​497 and #​500 add locked GraphQL and Svelte direct-route fixtures.
  Each fixture records its source commit and SHA-256 digest.
  Dedicated C-oracle tests require exact trees and zero fallback.

• PR #​499 initializes the native Typst scanner indentation stack on creation.
  Native scanner semantics remove the nested-list comma artifact.
  This retires the remaining Typst compatibility dispatcher arm.

• Accepted-error C# full parses now retry with a certified merge width after
  cap-one convergence.
  Exact grammar identity gates the policy.
  Explicit environment settings keep precedence.
  This preserves recovered declarations while clean full parses remain on the
  faster path.

• Native ReScript materialization now owns value identifier path aliases.
  This change adds two small corpus fixtures.
  It removes the ReScript compatibility arm.

• Native Linker Script recovery now owns named error nodes and root spans.
  This change adds clean and recovered corpus fixtures.
  It removes the Linker Script compatibility arm.

• The parser covers every byte in each recovered EBNF source.
  This change removes the EBNF compatibility arm.

• Native visible-wrapper election now owns D storage classes.
  This retires the matching result-normalization subpass.
  Native reduction also owns D variable-type qualifiers.
  Native call targets now match C for qualified, template, and simple callees.
  This retires the D dispatcher arm.

• The Cooklang smoke fixture now uses a valid ingredient instruction.
  The previous period required production recovery and was omitted from the
  resulting tree.
  The valid fixture routes directly while the recovered form still falls back.
  The smoke scorecard reports 200 direct routes and one fallback.

• Compact admission now treats zero-width extras as progress when their token
  end advances the parser boundary.
  COBOL fixed-format padding now routes directly without weakening the
  same-byte no-progress guard.
  The smoke scorecard reports 199 direct routes and two fallbacks.

• Compact admission now supports bounded no-lookahead reductions.
  One runnable head can reduce a synthetic EOF and re-elect at the same byte.
  Transparent gotos mark the reduced node as an extra.
  A root reduction requires authenticated EOF on the next election.
  Doxygen, JSDoc, and VHDL now route directly.
  The smoke scorecard reports 198 direct routes and three fallbacks.

• Compact admission now supports two certified acceptance-frontier shapes.
  HTTP and Robot can drop EOF siblings with no actions.
  Meson can select the sole primary accepted derivation.
  Exact blob profiles and field-aware C-oracle receipts guard these choices.
  The current smoke scorecard reports 195 direct routes and no divergence.

• Compact admission now permits certified converged-path reduction split drops
  for the exact Bash, Erlang, Haskell, and JavaScript artifacts.
  Field-aware C-oracle receipts cover each selected compact tree.
  Three real-corpus files and the Haskell smoke fixture now route directly.

• Compact reduction outputs now carry their multi-pop fact directly.
  This avoids two full work snapshots on every reduction.
  The stable full-parse control improves by 8 percent against main.
  Full-parse allocation falls by 12 percent with no new allocations.

• The dispatcher census now records each live D and Objective-C subpass.
  Exact fingerprints retain spans, points, fields, flags, and parser states.
  The census does not materialize compact final-child references.

• The parser now folds raw descendant content into certified
  materializing-shape hashes.
  This prevents shallow GSS merges from discarding Objective-C method types.
  The parser now owns those identifiers before result compatibility.
  This retires a fifth Objective-C normalization subpass.

• Generic result selection preserves both valid Objective-C sizeof branches.
  It selects the C-equivalent expression branch for an unknown type name.
  This retires the final Objective-C subpass and its dispatcher arm.

• DFA keyword promotion now owns Arduino primitive types before compatibility.
  Native materialization owns Objective-C protocol type identifiers.
  This retires Arduino's dispatcher arm and the matching Objective-C subpass.

• Erlang macro replacement election now stays in the parser.
  It distinguishes function clauses from case and receive clauses.
  Reduction already emits exact top-level form spans.
  These owners retire the Erlang result-compatibility arm.

• Compact parse-state replay now visits each derivation node once.
  Its depth-first worklist retains only the active derivation path.
  The stable full-parse benchmark improves without new allocations or
  incremental regressions.

• Clean roots now keep hidden, childless whitespace extras as span coverage.
  They do not publish those extras as children.
  Visible comments and error-root evidence remain unchanged.
  Final-child filtering now preserves fields without materializing lazy ranges.

• The shared root-extra classifier now drops zero-width scanner tokens from
  child lists. The repetition-skip fold also stops the historical Typst
  comma artifact. These producer rules retire two returned-tree walks.
  Typst keeps its dispatcher arm for other repairs.

• Root spans now exclude unowned leading token padding through one shared
  materialization rule. This removes seven language-local repairs.
  Compact admission now accepts the same first-token start as the C oracle.
  Squirrel's result-compatibility dispatcher arm is retired.

• Rust dot ranges now parse without a result repair.
  The exact collapsed-child policy retains each bare .. token.
  The merged-left-side conflict rule selects chained dot-range shifts.

• The no-live-action re-lex no longer checks the grammar's name. This recovery
  step re-lexes the lookahead when no live stack has any parse action for it,
  and it was gated to JavaScript. The condition it guards is grammar
  independent: noLiveStackCanAcceptLookahead already proves that no live stack
  can consume the token, so re-lexing cannot take a token another version was
  going to use, whatever the grammar. Every grammar now gets the same recovery
  step. This retires one per-language gate from the parser core.

• Large GLR parses allocate far less. Two hot-path buffers grew without
  amortization or reuse:

  • The three merge-scratch helpers (ensureMergeResultCap,
    ensureMergeSlotCap and ensureMergeLargeSlotCap) allocated exactly the
    requested length. Every merge pass sizes them from the live-stack count, so
    a parse whose stack count climbs reallocated the whole buffer on each
    increment, which makes total allocation grow with the square of the peak
    stack count. One element of the large-slot buffer holds two 256-entry
    arrays, so this dominated wide parses. They now double.
  • gssNodeCanReach built a new fallback map each time a link graph outgrew
    its 64-entry local array. On grammars that reach that size routinely, the
    map became the largest single allocation in the parse. The fallback map is
    now pooled and reused.
  • gssNodeHash grew a fresh walk buffer on the heap whenever an unhashed
    chain was longer than its 32-entry inline array. Ordinary parses stop at
    the first already-hashed node, so this only bites where an error path
    rebuilds deep chains: a PHP edit that introduces a transient error spent
    124 MB there. The walk buffer is now pooled.

  Measured on a C# corpus of repeated method declarations, with the grammar
  loaded before measuring: allocation per source byte falls from 119,036 to
  17,207, total allocation for an 8.7 KB input falls from 989 MB to 143 MB, and
  the parse runs in 200 ms instead of 335 ms. On a 137 KiB input, allocation
  falls from 5462 MB to 1111 MB and the parse takes 4.0 s instead of 6.5 s.
  Java, C++, Go and JavaScript allocate exactly as before.

• A GLR stack that needs a different tokenization of the same bytes now gets
  one. tree-sitter C lexes once per parse version, so two versions in different
  states can receive different symbols for the same characters. This engine
  lexes one token for every stack, which is cheaper and correct while all live
  stacks accept that token. Where one stack's state required a different symbol,
  that stack found no parse action, paused, and the condense step dropped it
  because an unpaused rival was still alive. The rival then reached a dead end
  and the whole file became one ERROR node. Scala shows the failure most
  clearly, because +, -, ! and ~ are its only prefix operators: in
  if (a) c + 2 the correct derivation needs + as the generic
  operator_identifier, while the rival needs the dedicated + token that
  exists so prefix_expression can spell unary plus. while (a) c + 2 failed
  the same way, and if (a) c * 2 always worked because * is not a prefix
  operator. The parser now re-lexes at the stack's own byte offset with the
  stack's own lex mode before pausing it. It adopts the result only when the new
  token covers the same byte span, which keeps every version at the same offset,
  and only when the stack's state has a real action for the new symbol. The
  re-lex reads the internal lexer only, so no external scanner state changes.
  Clean parses are unaffected, because the probe runs only where a stack would
  otherwise pause. Any grammar whose characters lex differently by state gains
  the same protection.

• Parse results no longer depend on garbage-collection timing. The soft
  per-parse memory budget stopped a parse when runtime.MemStats.HeapAlloc or
  runtime.MemStats.Sys grew past the budget. Both values cover the whole
  process, and the garbage collector paces both, so the stopping point was not
  a function of the input. The same bytes returned a different tree on each
  run. Five parses of one 137 KiB C# file returned five different trees, of
  1, 11048, 19178, 22928 and 31928 nodes. Each tree reported
  HasError() == false over only part of the input. The budget arms at 64 KiB,
  so every language was exposed above that size. Only the absolute hard ceiling
  (GOT_PARSE_MEMORY_HARD_CEILING_MB) now stops a parse from a runtime memory
  reading, because that ceiling guards against running out of memory and is not
  a shaping decision. The arena budget, the scratch budget, and the node and
  stack limits continue to bound memory. Those layers measure what the parse
  itself allocated, so they stop the same input at the same place every time.
  A downstream user reported this behavior in issue #​454.

Changed

• v0.48.0 adds fields to FullParseAcceptedErrorRetryProfile, ParseRuntime,
  and DiagnosticParserCoreGenericWork. Change unkeyed literals to keyed
  literals before you upgrade.

Removed

• The Bash command-name concatenation repair. Native reduction now
  constructs the complete command name before result compatibility.
  The historical producer, all result routes, and the isolated C oracle match.
  The 25-case Bash corpus matches baseline 83548f55 exactly.
  Three unrelated Bash subpasses remain live.

• The D template-call type result repair. Generic result election now
  preserves a visible named unary wrapper over its direct-child alternative.
  Production, forest, incremental, and isolated C-oracle receipts match.
  Four unrelated D subpasses remain live.

• Two Objective-C result repairs. Exact stack-node equivalence preserves
  deep alternatives for generic alias-target selection.
  Native selection now owns @encode identifiers and function-pointer
  expression shapes.
  Production, incremental, and field-aware C-oracle receipts match.
  Native selection also owns single and concatenated @ strings.
  Raw-shape equivalence now preserves compound struct type specifiers.
  Two unrelated Objective-C subpasses remain live.

• The D module-bound result repair. Native reduction already excludes
  leading comments and trailing trivia from each module_def span.
  Production, compact, forest, incremental, and C-oracle routes match.
  Incremental parsing reuses the old tree.
  The D dispatcher remains live for unrelated shape repairs.

• The HCL root normalization pass. Shared root finalization now removes
  hidden whitespace extras at every root position.
  Native reduction already produces each exact HCL body span.
  Production, compact, forest, incremental, and locked C receipts match.
  The three-file census found no mismatch across 114 body nodes.
  This removes the HCL result-compatibility dispatcher arm.

• The Haskell section-span result repair. Native reduction and root
  finalization already produce the exact imports and declarations ranges.
  The real-corpus census found no remaining rewrite.
  Production, compact, incremental, and locked C receipts match.
  The forest route retains its existing section reduction-cap limit.
  This removes the remaining Haskell dispatcher arm.

• The source-driven collapsed-token repair family for HCL, CPON, C#, and
  PowerShell. Reduction now preserves each required anonymous token child.
  The same-name collapse keeps CPON null nodes childless.
  This removes the CPON dispatcher arm.
  The other three arms remain live for unrelated repairs.
  Compatibility-free, production, compact, forest, incremental, and isolated
  C-oracle receipts return the same trees.

• The CUE, Git Commit, and R alias-map result repairs. Their pinned blobs
  now carry the nonterminal alias metadata from each C parser table.
  Materialization keeps the required named child under each collapsed wrapper.
  Production, compact, forest, incremental, and locked C receipts match.
  CUE also proves nonzero old-tree reuse.
  Git Commit and R record their external scanner reuse limit.

• The trailing root and child span compatibility family. Materialization
  now owns the exact spans for Caddy, Comment, Fortran, Just, Nginx, Nim,
  Pascal, Pug, and RST. The compact scheduler admits progressing zero-width
  external extras. Forest publication omits zero-width synchronization extras
  as children while it retains their source-range ownership. Native producer,
  production, compact, forest, incremental, reuse, and isolated C-oracle
  receipts support the removal of four dispatcher arms.

• The Lua, Make, and Zig field-projection passes. Reduction now projects
  inherited and direct fields through hidden productions.
  The Zig grammar metadata emits initializer lists without field_constant.
  Compatibility-free, production, compact, forest, incremental, and locked C
  receipts return the same fields.
  Make and Zig preserve old-tree reuse.
  Lua records its external scanner reuse limitation.

• The Haskell and Erlang root field repairs. Reduction now retains each
  inherited field conflict and projects it by an exact named-symbol match.
  Root acceptance preserves producer field metadata when it absorbs trivia.
  Compatibility-free, production, incremental, and isolated C-oracle receipts
  preserve the expected root fields.

• The Scala returned-tree span repair subfamily. A language-neutral
  in-place rewrite refresh now preserves a valid producer-owned span and can
  widen it. This change deletes the Scala function-end and case-clause helpers.
  It also removes the second-pass root-end call and its duplicate case-clause
  block. Production, compact, forest, changed incremental, fresh, and
  locked C routes return the exact ranges and points. Scala incremental reuse
  remains unsupported and reports zero reuse.

• The duplicate Scala returned-tree repair calls. Recovery, field, and
  annotation repair now runs only in the canonical compatibility pass.
  Mandatory fixtures and the authenticated corpus report zero mutations when
  the deleted calls run again.

• The shared returned-tree fixpoint. The last Scala arm became inert after
  checkpoints A and B. The publication paths no longer call a repeated
  post-finalization normalizer.

• The HTML returned-tree range fixup. Materialization now extends recovered
  custom elements through each structural _implicit_end_tag child.
  Production, compact, forest, and incremental routes return the exact
  absolute ranges. The incremental route also proves nonzero old-tree reuse.
  The locked C reference parser returns the same recovered ranges and points.

• The generic terminal-leaf tree mutation. Reduction and alias
  materialization now own the terminal shape. Production, compact, forest,
  incremental, scanner-aware corpus, and locked Go C-oracle receipts find no
  retired shape. The exact retry error summary and stop polling remain as a
  read-only full-tree walk.

• Three dead per-language result-normalization dispatcher arms (R2 of
  docs/root-normalization-retirement.md). The three are OCaml's collapsed
  named-leaf restoration, Ruby's top-level module bound shrink, and HTML's
  ERROR-root nested-custom-tag reconstruction
  (normalizeHTMLRecoveredNestedCustomTags). At the R2 checkpoint, HTML's
  separate range function stayed live. The R1 item above now removes that
  function independently. A real-corpus census measured zero rewrites for all
  three dispatcher arms. Native-parse tests confirm that the reduce engine
  already produces the corrected shape without them.

  A fourth candidate, Elixir, stayed live. Its census also measured zero
  rewrites over the real corpus. A native-parse regression test found the
  cause: the corpus sample lacked the triggering construct. Two consecutive
  top-level comments — a common file-header shape — still lose their hidden
  _newline_before_comment sibling without the normalizer. The ownership
  registry keeps all four entries as historical receipts.

Changed

• JavaScript program-end finalization now has one authoritative compatibility
  owner. The redundant returned-tree second pass is retired; production,
  compact final-child-ref, forest, and incremental publication continue to use
  the canonical JavaScript compatibility pipeline before the tree is exposed.

• Clean hidden whitespace-only root tails are now owned by root finalization,
  retiring a generic compatibility pass while preserving error-root recovery
  extras and lazy compact child references.

Performance

• Same-length single-byte replacements now mark the affected path without
  recomputing unchanged spans. Other edits and compact child references keep
  the general editor. The pinned incremental benchmark improves 2.10 percent
  with zero allocations.

• Fresh parse finalization now computes the retry error summary while it wires
  parent links. This removes one complete tree traversal.
  Deferred and incremental paths retain their separate summary walk.
  Under-flagged errors and stop polling keep their existing behavior.
  The pinned Go full-parse benchmark improves 0.81 percent.

• Parser retry policy now snapshots override presence with each parsed value.
  This removes repeated environment lookups from the incremental hot path.
  The pinned edited incremental benchmark improves 1.28 percent with zero
  allocations.

---

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.

[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

[codecov]

Codecov Report

✅ All modified and coverable lines are covered by tests.
✅ Project coverage is 84.77%. Comparing base (f28ce46) to head (e081bd6).

Additional details and impacted files

@@            Coverage Diff             @@
##             main     #245      +/-   ##
==========================================
+ Coverage   84.76%   84.77%   +0.01%     
==========================================
  Files         316      316              
  Lines       29691    29691              
==========================================
+ Hits        25168    25172       +4     
+ Misses       3101     3095       -6     
- Partials     1422     1424       +2     

Flag	Coverage Δ
unittests	84.77% <ø> (+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.