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

[renovate]

ℹ️ Note

This PR body was truncated due to platform limits.

This PR contains the following updates:

Package	Change	Age	Confidence
github.com/odvcencio/gotreesitter	v0.51.0 → v0.52.0

---

Release Notes

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

v0.52.0: gotreesitter v0.52.0

Compare Source

Release overview

• Eligible fresh parses use the compact parser by default. Unsupported cases
  retain the legacy fallback. This release does not complete compact parser
  graduation.
• Compact incremental parsing now reuses authenticated unchanged subtrees.
  The bounded route includes nested nonterminals with lexer dependency proofs.
  Edits invalidate affected proofs, including dependencies on examined suffix bytes.
• The authenticated Go profile supports bounded end-of-file recovery with
  native error-tree construction. Unsupported recovery cases retain fallback.
• The detailed entries below preserve the development history, including
  rejected experiments, superseded measurements, and unresolved parity blockers.

Issue #​1087 remains open.
This release temporarily disables the unsafe same-width token-invariant shortcut.
Real edits reparse through the supported incremental or full-parse route.
Ordinary subtree reuse and no-edit reuse remain available.
Restore the shortcut only after complete lexical dependency proofs pass.
The full correction remains deferred; this mitigation does not close the issue.
The owner approved the temporary slowdown. The measured single-byte edit rises
from 1.706 us to 3,350.460 us, with 184.4 KiB and 95 allocations per operation.
Full-parse and no-edit timing changes are not significant. Full parsing reduces
allocated bytes by 42.90 percent and allocations by 99.72 percent.
See the release performance report.

Lexical error-leaf flags and TypeScript recovery divergences remain graduation work.
The attempted flag correction changed AWK recovery selection and remains deferred.

Performance tooling and optimizations

• Pull request #​1089
  restores paired performance evidence and authenticated work counts.
  The paired driver alternates execution order and rejects incomplete evidence.
• Pull request #​1090
  caches recovery visible-subtree counts and removes canonicalization callback
  allocations. The cache reduces time across four frozen Go fixtures.
  The callback change reduces allocations without a significant timing change.
  Read the recovery count report
  and canonicalization report
  for measured commits, paired results, and limits.
  These measurements precede the temporary shortcut mitigation.

The owner authorized a v0.52.0-only exception for an unsupported tag-creation
actor rule. All other publication gates remain mandatory. See
the dated exception.

Performance

• Bound temporary conflict-frontier growth with the maximum of the resolved
  stack-cull trigger and the four-stack full-parse overflow window. The
  reported pinned-file result was 250.8 seconds with an error root. The
  changed parser completes the pinned file in about 3 seconds with a clean
  root and no truncation. The raw non-API benchmark route retains its
  historical unbounded frontier search. Exact C# route and census checks pass,
  as does uniform initializer parity through 72 entries. The cap does not fix
  the separate 87-byte branch limitation.

• Reduced the temporary recovery memo tier from 262,144 entries to 131,072
  entries. The active table now uses 3 MiB on 64-bit systems. The retained
  standard table uses 384 KiB. Total memo storage is 3.375 MiB before slice
  overhead. The 20-seed C# issue #​454 benchmark reduces bytes per operation
  by 20.79%, with p<0.001. Time is 155.9 ms for base and 158.0 ms for
  the changed build, with p=0.529. Allocations are 998.5 and 998.0, with
  p=0.074. Both results are inconclusive. Two execution orders reduce
  maximum resident set size by 11,520 KiB and 4,160 KiB. The primary trio
  is order-sensitive and inconclusive. Focused C# correctness, locked-C
  parity, and memory-budget contract tests pass.

• Recorded P25aw at merged main commit
  af9ded2b77b7828b12b1d2da7c9fff8dd5ca053b. Four authenticated Swift corpus
  edits used old trees and one final-newline edit. Every profile reported
  external_scanner_unsupported, zero reused subtrees, zero reused bytes, and
  no incremental arena route. The result is NO-GO / NO WITNESS. No
  six-seed, 20-seed, or maximum resident set size (RSS) run was justified.
  See docs/perf-attribution.md for exact commands, identities, and artifacts.

• Recorded P25at at publication base b65a9c235915edc3198851cf07b0257e3caed6d6.
  Measurements used 3c2a2106102769bab891047174dbcfec15045e74; relevant
  source files are unchanged between these bases.
  nodeArena.ensureNodeCapacity ran twice for authenticated recovery.
  The exact-fit candidate improved recovery bytes per operation (B/op) by
  9.39%, but increased allocations by 4.92%. Primary full parse time
  increased by +7.95%.
  Primary full parse B/op increased by +7.88%. Primary edit time increased
  by +12.47%.
  The candidate is NO-GO / REVERTED. No 20-seed or maximum resident set
  size (RSS) run was justified.
  See docs/perf-attribution.md for exact identities, commands, and artifacts.

• Recorded P25ay at base af9ded2b77b7828b12b1d2da7c9fff8dd5ca053b.
  The probe measured hidden-field flattening across the primary trio, recovery,
  and JavaScript control.
  Recovery made 2,207 helper calls and appended 1,213 nodes.
  JavaScript made 399 helper calls and made 25 deferred field calls.
  Primary no-edit made zero helper calls.
  P25ab showed that the helper was not the dominant allocation source.
  No grammar-agnostic candidate met the proof boundary.
  The result is NO-GO / NO CANDIDATE.
  No six-seed, twenty-seed, or maximum resident set size (RSS) run was justified.
  See docs/perf-attribution.md for exact commands, artifacts, and hashes.

• Recorded P25az at main commit
  6eed698a13e7371fa978adb893e8b89ad1cd81ba. The recovery-prefix merge
  contract passed before and after the test-only contract addition. The helper
  remains a coarse synthetic-profile signal. No production candidate met the
  proof boundary. The result is NO-GO / NO CANDIDATE. No randomized
  benchmark or maximum resident set size (RSS) run was justified. See
  docs/perf-attribution.md for exact commands, artifacts, and hashes.

• Recorded P25ba at main commit
  d72987b44b76cf39aa4ad0f5fff03860eed7cd0d. Canopy selected the
  cNodeErrorCostLangWithScratch recovery-cost contract after the queued P25az
  prefix aggregate arm. Focused recovery-cost and memo tests passed in Docker.
  No authenticated issue #​454 witness supplied call-depth or cache-hit proof.
  The result is NO-GO / NO CANDIDATE. No benchmark or maximum resident set
  size (RSS) run was justified. See docs/perf-attribution.md for the command,
  artifact hashes, and reopening condition.

• Recorded P25bb at main commit
  83e0cfbc30ad82e2f327d58e35eea9f438a0ffda. Canopy selected the
  cRecoverStrategy1Election summary contract after P25ba. Focused summary,
  election, scratch-reuse, and allocation tests passed in Docker. No
  authenticated issue #​454 witness supplied election depth or reuse proof.
  The result is NO-GO / NO CANDIDATE. No randomized benchmark or maximum
  resident set size (RSS) run was justified. See docs/perf-attribution.md
  for the command, artifact hashes, and reopening condition.

• P25bc records the main commit
  83e0cfbc30ad82e2f327d58e35eea9f438a0ffda. Canopy selected the
  cDoAllPotentialReductions reduction-search contract after the queued P25bb
  election-summary arm. Focused reduction, version-order, summary-lifetime,
  and pointer-release tests passed in Docker. No authenticated issue #​454
  witness supplied reduction-attempt or allocation proof. The receipt marks
  the result NO-GO / NO CANDIDATE. The proof boundary did not justify a
  randomized benchmark or maximum resident set size (RSS) measurement. See
  docs/perf-attribution.md for the command, artifact hashes, and reopening
  condition.

Correctness

• Bind identity-bearing external scanner checkpoints to compact per-version
  lexer snapshots. Reject incomplete identities before publication. Reject
  changed identities before restore or owned snapshot publication. Do not
  share an equivalent sidecar after identity drift. Forward identities through
  scanner order adapters. Preserve legacy scanner behavior.

• Graduated the Markdown inline smoke route with four exact, compact-only
  conflict policies bound to the built-in grammar blob. Three repetition
  reductions require at least two live compact headers. The HTML entry row
  selects its sole shift. All other repetition rows still fail closed.
  The locked upstream corpus reports 15 direct routes and 348 fallbacks across
  363 cases. Every direct tree matches C exactly. The nested-emphasis
  counterexample remains a required fallback. The admission scorecard now
  reports 201 PASS, zero DIVERGE, zero FALLBACK, five SKIP, and zero ERROR rows.

• Apply the production route's contextual close-angle deferral in the
  compact dispatch and the C4 corridor (issue #​983). Add the two Swift
  witnesses to the committed route-equality seed corpus. Totals stay
  unchanged: 69/0/30/10 canonical, 88/0/46/12 full. Re-adjudicate the
  swift_log_1 and swift_log_2 rows in the T3 oracle witness manifest:
  the compact route now reports the error tree, so compact_has_error
  moves from false to true and all three runtimes agree on both rows.

• Added bounded materiality-only acceptance for no-primary multi-derivation
  end-of-file (EOF) frontiers. The route selects a deterministic provisional
  candidate only for the existing bounded public-tree comparison. It routes
  only when every live candidate materializes to the same public tree. The
  comparison caps live candidates at eight and fails closed on a cap, missing
  context, materialization failure, or tree mismatch. The C# 642-byte
  variableDeclarations.cs row now routes. The 97-row matrix moves from 62
  PASS, 27 FALLBACK, and 8 SKIP to 63 PASS, 26 FALLBACK, and 8 SKIP, with zero
  DIVERGE or ERROR rows. Production, compact, and locked-C report the exact
  deep digest 005b39bd9a68ff9775129d3fb793b9d7a58b9f56812bb9ca9bd0eb753465dd86.
  The C# collapsed-token regression fixture and three Dart constructor probes
  (class, private, and enum) route without a dispatch pass and with exact
  locked-C trees.
  The change grants no language profile or digest grant.

• Added a stored cumulative maximum for dynamic precedence, which ranks
  competing parse paths. Each node keeps C's running value. Merge
  transactions seed the fold from that stored value and apply the C rule
  table from stack_node_add_link: a same-pair assignment overwrites the
  value and can lower it, mergeable and appended links max the incoming
  predecessor's stored value plus the payload contribution, and duplicate
  or lower same-pair links change nothing. Publication never recomputes
  the value from the final link array. Leaf payloads contribute zero. The
  rule-table tests in internal/parsercorephase0/precedence_rule_table_test.go
  pin one case per C branch. The canonical real-corpus ratchet now pins
  69 PASS and at most 30 FALLBACK over 109 rows. The nodeRecord grows
  from 24 to 32 bytes. The Haskell small
  Main.hs row has 260 bytes and source SHA-256
  c60b55de99836dacb00a0f2808835895132996a95d52304cefab548b8cbdef65.
  It routes with counters 1/0 and real recursive link-union work. Production,
  compact, and locked C report deep digest
  6e3806c54c39af93701157f87ac8ee9ef947108d66b7d6069d6908a4d5c71e9f.
  The matrix moves from 63 PASS, 26 FALLBACK, and 8 SKIP to 64 PASS,
  25 FALLBACK, and 8 SKIP, with zero DIVERGE or ERROR rows. The eight-link
  cap remains. No language profile or grammar digest grant was added.

• Raw accepted-leaf coverage now preserves hidden terminals and exact ERROR
  provenance with bounded reusable scratch and cancellation polling. The
  authenticated matrix moves from 60 PASS, 29 FALLBACK, and 8 SKIP to 62 PASS,
  27 FALLBACK, and 8 SKIP, with zero DIVERGE or ERROR rows. Both HTML rows now
  convert directly. Isolated HTML Docker parity is 25/25.

• Added a default-off Core link provenance sidecar. It stores finalized
  drop-cohort reference indexes by LinkID. Compact routing and admission stay
  unchanged.

• Added a default-off reduction output provenance handoff. It carries an
  authenticated graph-chain reference from published node metadata. The
  reference follows next links and does not require adjacent LinkID values.
  It performs no adjacency walk and changes no derivation format, routing,
  admission, or compact counters.

• Included-range parsing now starts byte-seek sources at the first selected
  byte. The parser seeds its initial stack there and preserves the configured
  start point for recovery gaps. A non-seek source preserves a complete
  overlapping token because it cannot reproduce a trimmed boundary token.
  For grammars without an external scanner or external symbols, the internal
  DFA now advances across selected gaps before token acceptance. It preserves
  logical text and cursor state during reset, relex, and generalized LR (GLR)
  probes. A scannerless synthetic external token now advances the source to
  its reported end before the next token. The cursor increases the AMD64
  Parser layout by 40 bytes, from 2,184 to 2,224 bytes.
  The locked Go route now matches C at root byte 26. Child counts remain 10
  for Go and seven for C. Compact and forest included-range routes remain
  uncertified. Keep dispatch.go.source-file-root live until exact shape and
  all required route proofs pass. See docs/root-normalization-retirement.md.

• Recorded a generic Swift issue #​576 recovery candidate at base
  da6f71471aaaa835503accaa1bc2083ced90b4e6. The active deterministic finite
  automaton (DFA) source now replays recovery from the exact skipped-prefix
  offset. It requires the original span, points, token identity, and unchanged
  scanner state. It resynchronizes the source before it emits errorSymbol.
  Recovery replay requires a non-empty scanner checkpoint and live state. A
  checkpointless scanner rejects recovery replay without changing the scanner.
  Generic relex still accepts stateless scanners with empty serialization. The
  Swift scanner now serializes its complete state for the recovery proof. The
  scanner no longer claims that failed scans preserve this state. The token
  source restores failed scans by default. A scanner can explicitly retain a
  required failed-scan state change. Swift uses that capability and records
  distinct start and end checkpoints. Incremental fast-forward restores the
  recorded end checkpoint. Generic relex rejects a synthetic end-of-file
  lookahead that would replace a real token. Swift defers >? to the DFA only
  when an unmatched < exists in the active scope.
  The parser records error-mode lexing only after the DFA produces the token.
  An outer parse operation resets the recovery memo size. Nested retries stay
  warm. Temporary memo growth restores an existing 16,384-entry standard slab.
  A shorter retained slab remains short. Two pooled tests protect the recovery
  lifecycle. The parser returns a rejected recovery probe before its legacy retry. Entry
  scratch now restores the required large-parse reservation after a small
  pooled parse. The 20-byte witness matches the locked C tree. The
  stdlib_FloatingPointToString.swift and stdlib_CollectionAlgorithms.swift
  witnesses still differ from locked C. The 20-seed repair comparison found no
  significant primary timing change. Bytes and allocations stayed unchanged.
  One warmed large-witness sample decreased 0.113090 percent. Keep issue #​576
  open. See the Swift #​576 blocker receipt.

• Recorded the unreceipted dispatch.julia blocker at base
  b35b86cb84d620305515abf970d5598c9573a48b. The focused Docker receipt
  covers raw, production, compact, forest, incremental, and locked-C routes.
  It pins the Julia grammar, blob, manifests, C artifact, runtime, binding,
  compiler, scanner, source hashes, route digests, divergences, compact
  outcomes, dispatch counts, and incremental reuse. The recovered return-range
  witness flips the root error flag. The checked-in Julia source keeps a type
  divergence. Compact falls back on two witnesses, and the authenticated corpus
  lock is absent. Keep the arm live. No parser or registry change is included.

• Recorded the next single-grammar normalization blocker, dispatch.kotlin,
  at base d72987b44b76cf39aa4ad0f5fff03860eed7cd0d.
  The focused Docker gate used the parser-produced witness
  tasks.named<KotlinCompile>("compile") {}.
  The raw and production deep digests differ.
  Production records dispatch.kotlin as checked 1, run 1, visited 22,
  and rewritten 23. The recovered-root subpass records zero rewrites.
  Keep the parent arm live. Stop before compact, strict forest, edited
  incremental, fatal locked-C, survivor, registry, or dead-reference proofs.
  Reopen only after native Kotlin derivation emits every listed shape without
  parent rewrites or parser-state changes. No parser or registry change ships.
  See docs/root-normalization-retirement.md.

• Recorded a TypeScript current-main follow-up at base
  ab84e809297e945a6debd52ec3e211956b497893.
  The one-CPU Docker gate reran raw, production, compact, forest, incremental,
  locked-C, scanner, and cap-one typed-arrow routes.
  The tracked witness keeps 15 production rewrites, 10 incremental rewrites,
  406 reused subtrees, and 2,289 reused bytes.
  Compact keeps its scheduler-frontier fallback, and the authenticated
  TypeScript and TSX corpus lock remains absent.
  Keep the arm live. No parser or registry change is included.
  See docs/root-normalization-retirement.md.

• Recorded the next unreceipted dispatch.templ blocker at base
  3c2a2106102769bab891047174dbcfec15045e74. The A0 manifest records three
  Templ files, three checks, three runs, 1138 visited nodes, 76 rewrites, and
  one error root. The focused Docker receipt covers raw, production with
  admission forced off, compact, forest, incremental, and locked-C routes.
  It pins source, manifest, grammar lock and blob, C artifact, runtime,
  binding, compiler, scanner identity, route digests, divergences, and dispatch
  counts. It also pins compact counters and reasons, forest outcomes, and
  incremental reuse. Templ has no authenticated corpus lock. The medium
  witness retains a locked-C divergence. The small witness matches locked C
  only after dispatch.
  Compact falls back, and the external scanner provides no incremental reuse.
  Keep the arm live. No registry or production code changes are included. See
  docs/root-normalization-retirement.md.

• Recorded the unreceipted dispatch.wgsl blocker.
  The evidence and measurement base is
  cf58fba517ed4fa6a8f5d1328ac2f850d48a8c75.
  The review publication base is
  d134ed5f963c7ed1d27fa1247aeb2a16746ab585.
  The receipt covers three A0 WGSL witnesses and two controls.
  It covers raw, production, compact, forest, incremental, and locked-C routes.
  It pins source, grammar, blob, C artifact, runtime, binding, compiler, and scanner identities.
  It also pins route digests, divergences, dispatch counts, compact outcomes, and reuse counts.
  The one-CPU Docker test passed.
  Keep the arm live because production rewrites remain.
  Compact also falls back on recovery.
  Locked C still differs in shape, type, and error state.
  No parser or registry change is included.
  See docs/root-normalization-retirement.md.

• Recorded the unreceipted dispatch.perl blocker at base
  6eed698a13e7371fa978adb893e8b89ad1cd81ba.
  The focused Docker receipt covers raw, production, compact, forest,
  incremental, and locked-C routes for two source-hashed Perl witnesses.
  It pins the grammar lock, blob, scanner, C artifact, runtime, binding,
  compiler, source digests, route digests, dispatch counts, compact counters,
  forest results, and incremental reuse status.
  Raw trees diverge from locked C, while normalized routes match after dispatch.
  The Perl corpus lock is absent, and the scanner provides no incremental reuse.
  Keep the arm live. No parser or registry change is included.
  See docs/root-normalization-retirement.md.

• Recorded the unreceipted dispatch.wolfram blocker at base
  f8b9d718ee19f65598e274035f5481a899ab2b72. The A0 manifest records three
  Wolfram files, six checks, six runs, 77 visited nodes, zero rewrites, and
  three error roots. The receipt covers raw, production, compact, forest,
  incremental, and locked-C routes. It pins the grammar lock, embedded blob,
  C artifact, runtime, binding, compiler, grammar repository, source digests,
  route digests, divergences, dispatch counts, compact deltas, and external
  scanner identity. The incremental profile records
  external_scanner_unsupported with zero reuse. Other routes log scanner
  identity without inventing reuse fields. The full authenticated corpus is
  absent. Keep the arm live.
  No registry or production code changes are included. See
  docs/root-normalization-retirement.md.

• Recorded the C26y SQL compact checkpoint trace on base
  e24ccf5a87bbd7febc21f67f014c2d5301d229d0. The pinned source uses commit
  587f30d184b058450be2a2330878210c5f33b3f9. The grammar and scanner source
  hashes are 42f011860137175a5a0cb820d1a694e5ccca1d17f226729ff6a4e886910cde1c
  and d437ad9f517d7a1f4248ccd05abe58370b5040c0037c877dab1f0aefeaa04af6.
  The semantically correct locked-blob and target-symbol routes share four
  scanner transitions. At 7-9, the state changes from 00 to 242400.
  At 9-12, it remains 242400. At 12-14, it changes to 00. At 14-15,
  it remains 00. The direct generated route emits an error tree with
  13/4/4 values. Correct production routes record 14/5/5. Compact admission
  records zero sidecars and zero incremental reuse. Reject the compact
  candidate.
  Keep SQL compact admission gated until compact sidecars and safe nonzero
  reuse have a generic proof.

• Screened generic compact-admission sidecars for checkpointed scanners in
  C26z. The diagnostic SQL route recorded 14 records, 5 leaves, and 5
  snapshots with the correct 7-9, 9-12, 12-14, and 14-15 scanner
  transitions. Generated, locked-blob, and locked-C trees matched. Compact
  reuse was 1 subtree and 6 bytes. Production reuse was 1 subtree and 16
  bytes. The candidate was reverted after C26aa traced the gap to compact
  parse-state replay. Generated content replay state 180 made checkpoint
  scanning return error span 9-14. Locked production state 16613 returned
  expected span 9-12. A stale grammar identity reused zero subtrees and zero
  bytes. Keep SQL compact admission gated.

• Recorded the C26ad SQL compact replay state-provenance blocker at publication
  base 515df769b9b4e2f8e3ea715e78b75a44faa3b6d6. The evidence base was
  cf58fba517ed4fa6a8f5d1328ac2f850d48a8c75. The pinned source uses commit
  587f30d184b058450be2a2330878210c5f33b3f9. Its grammar and scanner source
  hashes are 42f011860137175a5a0cb820d1a694e5ccca1d17f226729ff6a4e886910cde1c
  and d437ad9f517d7a1f4248ccd05abe58370b5040c0037c877dab1f0aefeaa04af6.
  Generated and locked SQL tables assign different state and external-symbol
  identities. Generated state 180 is valid with generated symbol 287 and
  scans content [9,12). Locked state 16613 is valid with locked symbol 286
  and scans the same span. A numeric remap cannot prove equal parser
  transitions across tables. The clean Docker route still fails generated
  dollar-quoted parity with the generated scanner's reference symbol mapping;
  temporary target-symbol binding repaired that route but did not establish a
  generic replay contract. No parser, scanner, or test change ships. Keep SQL
  compact replay gated. See docs/compact-route-real-corpus-matrix.md.

• Added the C26ag generic table-identity guard at base
  ae6e49448be249dd52dca5a95ba187fdd3000fe6. The compact core captures the
  producer identity at construction. Loaded languages use the exact grammar
  blob SHA-256. In-memory languages use one process-local producer token.
  Replay now declines before state reconstruction when the producer identity
  changes or is absent. The guard preserves same-language replay and does not
  translate numeric parser states. Focused identity tests passed in Docker.
  SQL scanner unit tests passed. The generated SQL route still has the known
  dollar-quoted locked-C divergence. Keep SQL compact admission gated until
  that parity gap and the complete replay contract are resolved. See
  docs/compact-route-real-corpus-matrix.md.

• Recorded the C26ah generated SQL dollar-quote producer blocker at base
  d72987b44b76cf39aa4ad0f5fff03860eed7cd0d.
  The 16-byte witness SELECT $$hey$$;\n has source SHA-256
  c65f30545110c37897fb7fe364af31ff572b35796963ec8fc59b37b76d319912.
  The generated tree has three source-file children and an error.
  The checked-in and locked-C trees have two children and no error.
  Their deep digest is
  f093882f4f27897036dd245c3e17f1dad2d7cd72e470e8594b5492150a2c451e.
  The generated digest is
  7ae91c65aebee3a10eeef68804af8b74bbf27620b200dfe842916898fc90dd46.
  Compact admission recorded zero routes and one fallback.
  The fallback used the generic recovery no-table-action reason.
  Keep SQL compact admission gated. No parser, scanner, or grammar change
  ships. See docs/compact-route-real-corpus-matrix.md.

• Recorded the C26ai tagged SQL dollar-quote producer witness at base
  7a14a701eb2a5d623ce128e792ee67820a734c8b.
  The 22-byte witness SELECT $tag$hey$tag$;\n has source SHA-256
  1279d93f715690fee6c8af53fa774d0108c19846d9418d86d53edec0d743bc88.
  The generated tree has three source-file children and an error.
  The checked-in and locked-C trees have two children and no error.
  Their deep digest is
  824c8bdf7107be3632bd0a43d89e0324ebc0802dcd8c4dca014130224f930ef6.
  The generated digest is
  ba05964c2f2c62e56a3ee9470c76dc55098f7c2ea4f656607da30c5f8af212d4.
  The first divergence is the generated root child count.
  Keep SQL compact admission gated. No parser, scanner, or grammar change
  ships. See docs/compact-route-real-corpus-matrix.md.

• Recorded the C26aj generated SQL CREATE DOMAIN producer witness at base
  83e0cfbc30ad82e2f327d58e35eea9f438a0ffda.
  The 19-byte witness CREATE DOMAIN test; has source SHA-256
  94c5d360b7205e2bd6e84fa28efc2cb3ee2cbc89aa6b759dd3349e578dd133c8.
  Generated and checked-in trees are both clean with two root children.
  The generated CREATE_DOMAIN node has one child; locked C has none.
  The generated digest is
  f08d628fa30d83cf92352dbfcab4885b7422ac0fadde9c756e747e6c116dc044.
  The checked-in and locked-C digest is
  e72fb9fb57180d5db5be9b649969c7e722d20e1ea4040075260258ee293ce630.
  Keep SQL compact admission gated. No parser, scanner, or grammar change
  ships. See docs/compact-route-real-corpus-matrix.md.

• Recorded the C26ak generated SQL CREATE DOMAIN AS producer witness at base
  83e0cfbc30ad82e2f327d58e35eea9f438a0ffda.
  The 27-byte witness CREATE DOMAIN test AS text; has source SHA-256
  0cad93f1b70ffa192008df866587c05b206ee404cedd5a0025f542c39c6a504b.
  Generated and checked-in trees are both clean with two root children.
  The generated CREATE_DOMAIN node has one child; locked C has none.
  The generated digest is
  67366d68529459613040eb60c5eef47b371fd3091dbe3283c82d7bcff287ea9c.
  The checked-in and locked-C digest is
  d0daa4279f00eb8c7278992cff6a870c98bf3deee2292b28f997adbe2f434916.
  Keep SQL compact admission gated. No parser, scanner, or grammar change
  ships. See docs/compact-route-real-corpus-matrix.md.

• Added authenticated generated-SQL scanner identity to the grammargen C
  parity route. The route now reloads the generated blob through LoadLanguage
  before scanner adaptation. The scanner binds checkpoints to exact generated
  bytes. The focused edit reuses 1 subtree and 16 bytes after recording 13
  checkpoint records, 4 checkpoint leaves, and 4 snapshots. Fresh and
  incremental trees match. A stale
  reference grammar identity reuses zero subtrees and zero bytes. The four
  generated SQL locked-C divergences remain. Keep generated SQL compact parity
  gated until generated and locked-C trees match.

• Recorded the dispatch.solidity blocker at publication base
  e24ccf5a87bbd7febc21f67f014c2d5301d229d0. Keep the arm live. The A0
  manifest records three Solidity files, three checks, three runs, 26897
  visited nodes, and 666 rewrites. The source files use OpenZeppelin commit
  48ab75f29abaa315fad7fa7b8338f92bb07376a7. The grammar lock, Solidity
  blob, C grammar artifact, runtime, binding, and grammar repository identities
  are pinned. The receipt covers raw, production, compact, forest, incremental,
  and locked-C routes. Production forces admission off, and the Docker run sets
  GTS_ADMISSION_CANDIDATE=0. Compact records exact routed and fallback deltas
  for its accepted and fallback cases. The focused receipt reports locked-C
  divergences for Initializable, call aliases, malformed controls, and forest
  witnesses. The authenticated Solidity corpus lock is absent. No registry or
  production code changes are included. See
  docs/root-normalization-retirement.md.

• Added the C26q SQL scanner identity gate on publication base
  a62b9db306bcb983852cbf0043852546e864e856. Native SQL binds each
  checkpoint to its scanner and exact grammar blob. Generated overrides hash
  their exact bytes before scanner adaptation. Equal identities permit reuse;
  missing or changed identities fail closed. The scanner identity is
  7e493677411a501e6d8592c6b9cc158e21a1bfed44c72ca914e2d81e4e34861d.
  It includes local port hash
  588328cd27eea49e88b704b9bd8e46958046564187a5db1a70f6622308a7fff8.
  A test hashes the marked local source region. Production code does not read
  source files. The exact-byte loader owns grammar identity. The public
  language API cannot relabel a loaded language. Equal raw bytes with a
  changed scanner identity fail closed. Arena identity set and inherit paths
  use exact allocation deltas. Reset clears the identity. Native SQL passed
  the route and real-corpus gates. Generated SQL still has four locked-C
  divergences. A one-shot accounting screen is diagnostic only. It does not
  provide release performance evidence. Keep the SQL identity gate scoped.

• Recorded the C26i, C26j, and C26k Swift issue #​576 scanner checkpoint
  blocker. C26i and C26j use evidence base
  137860ebd80921094e5a8069007d49188dcb5e50. C26k uses evidence base
  5d39d9658f5071c5c0f476eaadc6ae067e6c77e1. This receipt uses publication
  base 7b6f40fe089283674f5d0d19408d2380f77caf68. Locked C retries its
  external and internal lexer in error mode, then emits ERROR at row 156.
  Go emits identifier symbol 160 for MutableSpan before recovery. No
  generic per-version scanner checkpoint contract exists. No parser, grammar,
  or test change ships. Keep issue #​576 open. See
  docs/compact-route-real-corpus-matrix.md for identities, traces, routes,
  and reopening conditions.

• Accepted the C26l default-off external-scanner checkpoint foundation at
  evidence and publication base
  929609ccde78b0c9f4e57cf2225e0ae1204149cb. The opt-in API
  requires stable, non-empty scanner and grammar identities. It accepts only
  identities of at most 256 bytes and complete, non-empty serialized state.
  It owns source position, lexer state, token span, identity, and serialized
  bytes. It deep-copies state and fails closed on missing capability,
  incomplete state, inverted spans, or identity mismatch. The API has zero
  production call sites. It does not change parser, grammar,
  Swift, generalized LR (GLR), recovery, merge, or incremental behavior.
  Restore verifies the serialized payload after Deserialize and fails closed
  on any length or byte mismatch. Callers must discard a payload after failed
  verification.
  Synthetic lifecycle tests cover capture, fork, merge, recovery transfer,
  failed-scan restore, overlong-record rejection, restore verification
  mismatch, external-scanner use, and scanner-free off mode. The
  focused Docker run used
  one central processing unit (CPU), 4 GiB, GOMEMLIMIT=3GiB, GOFLAGS=-p=1,
  and -parallel=1.
  Metadata does not set GOMAXPROCS. The run passed without an out-of-memory
  kill or wall timeout. Its artifact is
  /tmp/gts-c26l-checkpoint-foundation-rebase/harness_out/docker/20260823T102036Z-c26l-checkpoint-foundation-rebase.
  Keep issue #​576 open until a real scanner and parser lifecycle use this
  capability with locked-C parity.

• Recorded the N31e C and C++ dispatcher blocker at main commit
  ab2010d74da5330d64dbddb0d9c58969da766d6d. Keep dispatch.c_cpp live.
  The initial dispatcher census (A0) excludes both languages, and the
  declared corpus lock is absent. The C++ clean control matches locked C.
  The recovery witness still differs in the root error shape and field
  metadata. The focused parity test reports nine missing C++ field names.
  The C++ field-preservation repair is language-specific. It does not resolve
  the C recovery or token-source gaps. Ship no parser, registry, or test
  change. See docs/root-normalization-retirement.md for identities,
  artifacts, exclusions, and reopening conditions.

• Recorded the N31f Authzed dispatcher blocker at evidence base
  ab2010d74da5330d64dbddb0d9c58969da766d6d and publication base
  5d39d9658f5071c5c0f476eaadc6ae067e6c77e1. Keep dispatch.authzed live.
  A0 lists three Authzed files, three checked files, three run files, and
  18 recorded rewrites. The refreshed route probe reports 17 rewrites and a
  four-node receipt drift. The probe covers raw, production, compact, forest,
  incremental, and locked C routes. It includes clean controls and malformed
  recovery witnesses. The authenticated corpus and its source lock are
  unavailable. The focused guard pins each source and C digest, route mode,
  divergence path and category, rewrite count, and reuse state. No safe shared
  producer invariant was identified. Ship no parser or registry change. See
  docs/root-normalization-retirement.md for the route receipt, artifacts,
  and reopening condition.

• Recorded the N31h Dart dispatcher blocker at evidence base
  7b6f40fe089283674f5d0d19408d2380f77caf68 and publication base
  09cb5faa41af35a6bc84fefccbab1a17850d38cc. Keep dispatch.dart live.
  The focused probe covers eight clean witnesses and one malformed witness
  on raw, production, compact, forest, incremental, and locked-C routes.
  Four generic-call witnesses differ from locked C on raw routes. The
  single-type and generic-return witnesses still differ on production and
  incremental routes. Forest repairs those witnesses with 10 and 44
  dispatch.dart rewrites. The authenticated Dart corpus is unavailable.
  The focused guard pins source and C digests, divergence paths, route mode,
  pass rewrites, and scanner reuse. No safe shared producer invariant was
  identified. Ship no parser, registry, or production change. See
  docs/root-normalization-retirement.md for the receipt and reopening
  condition.

• Recorded the AWK dispatcher blocker at main commit
  5648911ecf509df8ec870a1214917d9e95cf54f1. Keep dispatch.awk live.
  The focused receipt proves clean raw, production, compact, forest, and
  incremental parity. The tracked T.gawk fixture uses provenance commit
  61a7c75e225e3035390be32d635545e40d8c5faf. The authenticated corpus lock
  uses AWK revision 5739fd79bcfc75ba7526773d0cf634521f8aca3c.
  The recovery witness still differs from locked C. Ship no parser or
  registry change. See docs/root-normalization-retirement.md for the
  route receipt, failed attempts, and reopening condition.

• Rechecked the AWK dispatcher blocker at current main commit
  83e0cfbc30ad82e2f327d58e35eea9f438a0ffda. The one-language Docker guard
  passed with one CPU. Clean raw, production, compact, forest, and
  incremental routes still match locked C. The recovery witness still differs
  in shape, and recovery incremental telemetry remains absent. Keep
  dispatch.awk live. Ship no parser or registry change. See
  docs/root-normalization-retirement.md for the artifact hashes and
  reopening conditions.

• Recorded the SQL dispatcher blocker at base
  ac90e46ace3c4ac6fb6bbc9f0897e449c949cfad.
  The focused Docker receipt covers raw, production, compact, forest,
  incremental, and locked-C routes for a trailing select-list recovery.
  Raw Go output differs from locked C at the source-file child count.
  Production, compact, and incremental routes match locked C after
  dispatch.sql runs. Compact falls back, forest declines, and incremental
  reuse records zero subtrees and zero bytes. Container inspection records
  GOMAXPROCS=1, one CPU, and a 4 GiB memory limit. The receipt does not cover
  the other two SQL helpers. Keep dispatch.sql live. No parser or registry
  change ships. See docs/root-normalization-retirement.md.

• Recorded the N31i Cooklang dispatcher blocker at evidence base
  7498a678c52029a82f312e9637ecb66b15defa0b and publication base
  675697a1144fad306489c5142aedaae0825545d9. Keep dispatch.cooklang live.
  A0 lists three Cooklang files, three checked files, three run files, and
  1,021 rewrites. The focused probe covers nine witnesses and six routes.
  Seven non-control witnesses differ from locked C on at least one route.
  Four witnesses differ from locked C on the production route.
  Compact fallback and forest decline remain active for those witnesses.
  Incremental parsing reports external-scanner fallback with zero reuse.
  The authenticated corpus and source lock are unavailable. The focused guard
  pins source, grammar, C, route, pass, forest, and counter identities. Ship no
  parser, registry, or production change. See
  docs/root-normalization-retirement.md for the receipt and reopening
  conditions.

• Recorded the N31j Go dispatcher blocker at evidence base
  929609ccde78b0c9f4e57cf2225e0ae1204149cb and publication base
  af8a9a5bdb5bd1ac03762bc9a4f1a89f42463682. Keep dispatch.go live.
  The focused receipt covers six standard witnesses and the included-ranges
  route. All standard routes match locked C except raw new/make input.
  Included ranges still differ in root range and child count. The three Go
  subpasses report exact checked, run, and rewrite counts. The authenticated
  Go corpus lock is unavailable. Ship no parser, registry, or production
  change. See docs/root-normalization-retirement.md for the route receipt,
  artifacts, and reopening condition.

• Recorded the N31k Doxygen dispatcher blocker at evidence and publication
  base a62b9db306bcb983852cbf0043852546e864e856. Keep dispatch.doxygen
  live. The focused probe covers six witnesses across raw, production,
  compact, forest, incremental, and locked-C routes. The A0 fixtures have
  zero rewrites. The compact counters record exact routed and fallback deltas.
  The probe uses a deterministic trailing-space deletion for every incremental
  witness. The historical childless and recovered witnesses require three and
  fourteen dispatcher rewrites, respectively. The childless and smoke C digests are pinned,
  and exact witnesses require Go/C digest equality. The A0 fixtures and the
  recovered historical witness still show locked-C divergence, and the
  authenticated Doxygen corpus is unavailable. Ship no
  parser, registry, or production change. See
  docs/root-normalization-retirement.md for identities, artifacts, and
  reopening conditions.

Performance

• Rejected the P25ar lazy node-equivalence table allocation at base
  e24ccf5a87bbd7febc21f67f014c2d5301d229d0. The candidate kept the full
  16384 entry table and deferred its allocation until the first store.
  Focused cache tests and authenticated recovery parity passed. Swift time
  improved 9.36% and JavaScript time improved 5.38%, but both lanes had
  zero bytes-per-operation change. Recovery time regressed 6.10%, and the
  primary single-byte edit control regressed 2.29%. Primary full-parse
  bytes per operation rose 0.55%. The candidate failed the allocation and
  one-percent control gates. Reverted glr.go and glr_test.go. Retain the
  P25aq and P25ar evidence in docs/perf-attribution.md.

• Recorded the P25aq node-equivalence telemetry screen at base
  e24ccf5a87bbd7febc21f67f014c2d5301d229d0. Recovery deletion had 3,431
  lookups, 49 hits, and five depth-zero misses. Swift had 20,549 lookups,
  9,072 hits, and 91 depth-zero misses. The standalone P25aq telemetry log
  recorded zero JavaScript lookups and zero hits. A later focused-cache rerun
  recorded six lookups and two hits; this receipt uses that rerun value. The
  receipt does not infer a cause. The primary trio had zero probes. Depth-zero
  probes produced no hits and were not material. No bypass candidate was
  tested. The focused cache tests and authenticated recovery parity passed.
  The full canonical run stopped at the existing Python external-scanner
  fallback case. No code, test, or documentation change shipped. See
  docs/perf-attribution.md for artifact hashes.

• Rejected the P25an two-entry node-equivalence cache after collision
  hardening and two-language screening. The deterministic test covered full
  node keys, versions, depth, epoch, eviction, and parse-result stability.
  The Swift lane regressed time by 45.38%, which exceeded the one-percent
  limit. The JavaScript lane improved time by 8.45%, but it could not offset
  the Swift regression. Restored the 16384 entry cache. See
  docs/perf-attribution.md for artifacts and hashes.

• Recorded the P25ak-P25al node-equivalence cache screen at base
  5eaa38e536e54530b3d795c6c0a56d927d3d0e0e. P25ak traced the four fixed
  merge caches. The node cache used 512 KiB and had the lowest hit rate.
  The accepted candidate changed glrNodeEquivCacheSize from 16384 to
  2. Its recovery recovery_deletion drained screen reduced bytes per
  operation by 11.41%. P25al passed focused Go, JavaScript, Python, and Rust
  Docker checks. The primary trio improved time by 6.64% to 7.76%. Only
  full parse reduced bytes per operation, by 7.56%; other trio allocation
  metrics stayed unchanged. A known JavaScript control failed in both
  baseline controls; three focused JavaScript regressions passed in both
  trees. P25an later rejected the candidate on a Swift time regression. See
  docs/perf-attribution.md for artifacts, hashes, and limits.

• Recorded the P25ao adaptive node-equivalence cache screen at base
  d54147516440a91b8eda6983251c7cd6c4be2707. The candidate started with two
  entries and doubled after mixed misses and hit streaks. Focused collision
  and epoch tests passed, but Swift time rose 1.72% and authenticated
  recovery deletion time rose 26.34%. Recovery bytes rose 0.17% and
  allocations rose 0.90%. The candidate was reverted. Keep the fixed
  16384 entry cache. See docs/perf-attribution.md for artifacts and
  hashes.

• Recorded the P25x-P25ab performance blocker at publication base
  8c80a46e450d906fc9ce1665c189497b02483a3e. P25x used evidence base
  3d6cd2628f7a42c348f51dce0a0ed9b92b183c6a. P25y and P25z used evidence
  base 675697a1144fad306489c5142aedaae0825545d9. P25aa and P25ab used
  evidence base 2c533f5c19f5f7ab9b586cd8454f0cdc4ece014b. P25x's
  condense guard passed focused correctness checks but lacked a proven generic
  invariant. P25y regressed the primary trio by geometric means of +7.01%,
  +3.79%, and +2.23%; recovery rose +2.41%. P25z found no safe
  reduction shortcut. P25aa's field-scan candidate rose +1.70% on the
  six-seed recovery screen. P25ab found material field-path execution, but no
  safe optimization. Node-arena growth used 74.98% of allocated bytes.
  The retry bypass remains correctness-invalid. No 20-seed run was warranted.
  Earlier P25y figures +1.40%, +2.95%, +0.44%, and +2.62% are
  unsupported by this artifact set. Earlier P25aa figures +1.00% and
  +0.86% are also unsupported. The authenticated raw files supersede both
  sets of figures.
  No code ships. Keep issue #​454 open. See docs/perf-attribution.md for
  artifacts and the reopening condition.

• Recorded the P25ac-P25ae issue #​454 incremental arena retention screen at
  P25ac evidence base 8c80a46e450d906fc9ce1665c189497b02483a3e, P25ad-P25ae
  evidence base af8a9a5bdb5bd1ac03762bc9a4f1a89f42463682, and publication
  base 6a22fcf82c4d84ab613c68084ad356eb52bb4eac. P25ac used a same-length
  edit that took the token-invariant leaf fast path, so it recorded zero
  incremental arena acquisition and zero new nodes. P25ad traced that path
  and selected the authenticated Go recovery_deletion edit. P25ae's 2 MiB
  retention candidate improved the pooled lane, but the drained control
  improved bytes per operation by only 0.61% and increased maximum resident
  set size (RSS) by 7.39%. Keep issue #​454 open. The candidate was fully
  reverted. Ship no
  production or test change. Reopen only when the drained lane meets the
  allocation target and the RSS limit. See docs/perf-attribution.md for
  artifacts, counters, limits, and the superseding receipt.

• Recorded the P25k-P25w performance blocker at publication base
  3d6cd2628f7a42c348f51dce0a0ed9b92b183c6a. P25k ranked the remaining
  source-owned full-parse costs but found no safe duplicate operation.
  P25l through P25n found no safe dispatch, token-source, lexer, or GLR
  ranking reduction. P25o could not use branch counters because Docker
  reported No permission to enable branches event. P25p found no new
  target. P25q separated incremental edit and no-edit costs: the edit path
  spent 88.8 ns in Tree.Edit, 420.0 ns in reuse, and zero time in
  reparse or rebuild; the no-edit path was a same-source identity check.
  All profile containers used one CPU and reported no timeout or out-of-memory
  event. P25r through P25t isolated the Go recovery_deletion forward path,
  but found no generic operation to remove. P25u audited that evidence and
  kept the performance lane open. P25v compared the accepted-error retry with
  a diagnostic bypass; all deep Go/C digests stayed equal, but single-run wall
  and RSS differences are diagnostic, not performance evidence. P25v's focused
  parity diagnostic passed, but no candidate passed the proof boundary. No
  production code ships, and issue #​454 remains open. P25w superseded the
  P25v hypothesis: the independent exact route exposed an incremental digest
  mismatch when the retry was bypassed. No randomized performance gate ran.
  See
  docs/perf-attribution.md for artifacts and the
  reopening condition.

• Recorded the P25h-P25j parser-core dispatch blocker at evidence base
  41d0b9de133de777aeba9c1dca091903da052a7f. P25i used evidence base
  137860ebd80921094e5a8069007d49188dcb5e50. P25j used evidence base
  5d39d9658f5071c5c0f476eaadc6ae067e6c77e1. The publication base is
  526815a853713ef8af114170f87e94eed6438e85. A fresh quiet profile placed
  3.31% flat CPU time in dispatchPassActive and 13.25% in
  runtime.duffcopy. A value projection copied head, s3Region,
  shifted, accepted, and paused. Its raw diff SHA-256 is
  1a21f58236d65b6f2c91d74c6a9be322c4d0e095a929452218b60ebfcfeae776.
  The primary trio geometric mean (geomean) improved 0.79%, but the
  authenticated generalized LR (GLR) control regressed 11.03%
  and bytes per operation
  regressed 16.61%. Warm three-sample maximum resident set size (RSS)
  increased from 600000 KiB to 610240 KiB. Structural counters stayed
  equal. Focused tests and Go parity reproduced baseline results. No code
  ships. A P25i scalar follow-up removed the aggregate snapshot. Its six-seed
  diagnostic screen was neutral on authenticated generalized LR (GLR), and
  its warm RSS median increased 0.95%. No P25i 20-seed publication occurred.
  Keep issue #​454 open. See docs/perf-attribution.md for limits, artifacts,
  and the field-projection reopening condition.

  P25j screened one distinct 224-byte linearGroup copy outside the rejected
  dispatch header snapshots. Field-wise initialization removed that assembly
  copy while preserving the zero-value slot invariant. Its raw diff SHA-256 is
  a055e19160f401b266c6afb43a4be8e24bd058434c05ba6b3050b3629b27404b.
  The six-seed alternating screen was neutral. Its geomean changed by
  -0.07%, with no systematic
  bytes-per-operation, allocation, or parser-work change. The candidate was
  rejected before a 20-seed campaign or RSS measurement. Ship no code. See
  docs/perf-attribution.md for profile identities, artifacts, and reopening
  conditions.

• Recorded the P25g parser-core dispatch blocker at evidence base
  1c30650814ec6e65cbf31184301bf4776f3e5f41 and publication base
  54c7f521505e23b7a32c84c2a14d3bd3175c09dd. A fresh quiet profile measured
  central processing unit (CPU) time. It placed 12.29% flat time in
  runtime.duffcopy and 5.98% in the generic dispatch pass. The rejected hypothesis replaced one 224-byte header value
  copy with indexed access. Its raw diff SHA-256 is
  7c9b90937af20c0d5ffb5768e224fe718201a2592f2f4cf1469e50da40fbac65.
  The candidate regressed the primary trio geomean by +7.02%, and the
  authenticated grammargen_lr control by +54.28%. Full-parse bytes rose
  +9.49%. The three-sample maximum resident set size (RSS) median rose
  +1.92%. No code ships.
  Keep issue #​454 open. See docs/perf-attribution.md for the proof limits,
  artifacts, and field-level projection reopening condition.

• Removed duplicate dynamic-precedence dispatch in gssEntryHash while
  preserving semantics. The primary trio changed by +0.16% for full parsing,
  +0.21% for single-byte edits, and -3.86% for no-edit parsing. Its
  geometric mean (geomean) changed by -1.18%. Bytes per operation and
  allocations per operation stayed unchanged. The real grammargen_lr run
  improved by -3.13% (p=0.004, n=20). The three-sample maximum resident
  set size (RSS) medians were 615840 KiB and 593760 KiB (-3.59%). The
  candidate has two 157 allocs/op
  outliers; other samples report 156 allocs/op. Focused Go, locked-C, hash,
  merge, forest, raw-shape, and incremental gates passed. The P25e profile
  supplies attribution. Its SHA-256 is
  96bead7a8c448a597e4986839b000b602a08bf72b5ffaa5685fa72dcc432715c.
  Exclude the failed 20260823T061724Z runtime probe. No accepted run timed
  out or exhausted memory. Keep issue #​454 open. See
  docs/perf-attribution.md for the evidence base and validation artifacts.

• Recorded the P25e issue #​454 fresh-profile investigation collected at
  evidence base 14f6692fac65eab817f65af8cc6072e423ca6563 and published
  from main commit 2b755f744aef8dd253a4415ca4a5816fa85b0dbb. The workload
  used one Go
  grammar and four authenticated fixtures. It used 20 sequential seeds,
  GOMAXPROCS=1, GOFLAGS=-p=1, -count=1, -benchtime=750ms,
  -benchmem, and shuffle seeds 1 through 20. The receipt records every
  fixture identity, deep digest, metric mean, and metric range. One resident
  set size (RSS) sample measured 601600 KiB on four Docker CPUs without
  CPU pinning. The CPU profile SHA-256 is
  96bead7a8c448a597e4986839b000b602a08bf72b5ffaa5685fa72dcc432715c.
  The profile includes untimed admission work. The broad frames do not
  identify a safe grammar-agnostic candidate. The evidence has no
  incremental or issue #​454 recovery proof. Exclude the no-test
  050742Z run and the compile-failed 050817Z run. Keep issue #​454 live.
  Ship no candidate code. See docs/perf-attribution.md for the complete
  evidence receipt and reopening condition.

• Recorded the P25d issue #​454 C# fresh-parse performance blocker at base
  commit 731f8a9d9440a006b2cc6b56ef5b31c0ff3b5ce7. The synthetic source
  sweep used requested sizes from 2 KiB through 32 KiB. It has no direct
  locked-C parity proof and does not measure incremental parsing because the
  C# scanner does not support incremental reuse. Keep issue #​454 live. Ship
  no candidate code. Three failed construction artifacts are quarantined;
  corrected replacements passed. See docs/perf-attribution.md for exact
  source hashes, controls, resource results, artifacts, and reopening
  conditions.

• Recorded the P25c issue #​454 Objective-C transient-delete performance
  blocker at source commit 838aba943038248529429a572c4d6d98359bd87e.
  The eight-size sweep found no discrete threshold between 512 KiB and
  1 MiB. Each delete used five attempt entries and four retry passes.
  Fresh and incremental trees matched by digest. The Objective-C stack-cap
  helper is grammar-specific. No safe grammar-agnostic candidate passed the
  proof boundary. Keep issue #​454 and the performance arm live. No production
  or test change survives. See docs/perf-attribution.md for the receipt,
  artifacts, and reopening condition.

• Recorded the P25b issue #​454 performance blocker at source commit
  18d63b6f7802b28a0ddb889327fcd4ebebb99426. The exact 137 KiB base source
  matched the locked C tree. The one-byte edited source did not. The Go fresh
  and incremental edited trees matched each other, but both differed from C
  at the first error node. The incremental run rejected reuse, allocated
  3,165,354 to 3,213,594 transient nodes, and replaced the discarded result
  with one default-budget full parse. The focused Docker correctness and
  locked-C ratchets passed. Keep issue [

✂ Note

PR body was truncated to here.

---

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 88.11%. Comparing base (b0dfe13) to head (0cb3a08).

Additional details and impacted files

@@            Coverage Diff             @@
##             main     #343      +/-   ##
==========================================
- Coverage   88.13%   88.11%   -0.03%     
==========================================
  Files         361      361              
  Lines       34636    34636              
==========================================
- Hits        30528    30521       -7     
- Misses       4103     4110       +7     
  Partials        5        5              

Flag	Coverage Δ
unittests	88.11% <ø> (-0.03%)	⬇️

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.