@kudzujs/core 0.16.23 → 0.16.25

package/PERFORMANCE.md

@@ -2,6 +2,284 @@
 
 Reproducibility classes: `npm run benchmark`, `npm run benchmark:keyed`, `npm run benchmark:native`, `npm run benchmark:module-cache`, `npm run benchmark:project-navigation`, `npm run benchmark:project-state`, `npm run benchmark:source-scale`, `npm run benchmark:ai-delivery`, and `npm run benchmark:ai-delivery-production` are maintained in this repository; `npm run benchmark:commerce` is a maintained paired runner over the public external storefront; older excluded-workspace sections are historical provenance only and are not current framework rankings.
 
+## 0.16.25 Release Scope
+
+The following r5 compiler follow-up and future-only r6 acceptance alignment ship
+as `@kudzujs/core@0.16.25` with `create-kudzu@0.1.150`. The session records below
+retain their original pre-release scope and verification counts. Publication
+does not rerun a model, rescore r5, upload its local raw archive, or establish a
+timing/cost improvement. Frozen r6 starters remain pinned to released 0.16.24;
+benchmarking the new compiler requires a separately frozen revision and full run.
+
+## r5 Compiler Follow-Up (2026-09-07)
+
+This is compiler regression work and deterministic source replay against
+`5ed0f9bc875691e4e86e2fab832491c78c2f0c69` (`0.16.24`), not a model rerun,
+release, or replacement benchmark score. The dirty r5 results and separately
+prepared r6 acceptance/protocol changes remain intact. Historical r5 stays
+Kudzu 18/25 versus React + Vite 23/25, with two partial traces; `1.0.0` remains
+blocked. No production prompt, protocol, contract, or acceptance script was
+edited by this compiler follow-up.
+
+### Evidence And Reduction
+
+Authorizing batch:
+`test-results/ai-delivery-production/0.21.4-gpt-5.6-sol-r5-kudzu-0.16.24-20260907-01/`.
+The reduced checks were run red before their respective compiler edits.
+
+| Evidence | Confirmed problem | Existing path used |
+|---|---|---|
+| `content-kudzu-1/adapter.stdout:35`, first patch; build failure at line 42 | `normalizedQuery = query.trim().toLowerCase()` survives in build scratch when `filteredArticles.length` is read directly in JSX rather than through a count local. It calls a string method on the signal object. | Collection-alias count validation now registers its substituted dependencies in the existing build-value declaration set. Existing binding/conditional/list consumers still subscribe to `query`; build scratch reads `query.value`. |
+| Unchanged content starter `src/pages/topics/performance.tsx:13`, including historically accepted attempts 0/1/4 | A direct imported static `filter().map()` unnecessarily creates list state, prototypes, handler ESM, and a runtime family. | After existing collection/predicate/key analysis, direct imported pipelines with no selector states and no collection aliases remain ordinary build-time map execution. Local state and reactive selectors retain keyed ownership. |
+| `realtime-kudzu-0` and `realtime-kudzu-3`, `src/pages/index.tsx:16` | Zero-initialized version refs have no cleanup reset and are intended to survive `[paused]` effect replacements. | Existing effect-private cleanup diagnostic is correct and remains unchanged. Making the ref invocation-private would reset the version and violate the authored lifetime. No persistent-ref support is added. |
+| `realtime-kudzu-1`, `src/pages/index.tsx:16-17` | An unattached null ref is assigned `1` during render, then mutated by snapshot callbacks. Compilation previously accepted it as a DOM ref. `core.mjs` serializes ref captures by ID, not by numeric `.current`; this does not provide a retained version cell. | Existing ref normalization now rejects render-time writes at the authored source, recommending component state for retained values or cleanup-owned private refs for invocation-local values. This closes a diagnostic gap, not a resource-lifetime extension. |
+
+The historical realtime timeout did not record an exact browser exception, so
+none is asserted retroactively. The new negative reduction proves the null-ref
+shape compiled before the guard and is diagnosed afterward. Replays of original
+realtime sources 0/3 retain the cleanup diagnostic, source 1 receives the new
+render-write diagnostic, and unchanged state-based sources 2/4 still build and
+pass the realtime browser journey. Their authoring compromises remain explicit;
+this is not a claim of persistent React ref compatibility.
+
+### Output And Browser Proof
+
+The new direct-alias-count case uses the existing imported article fixture and
+Chrome journey. All four source variants emit byte-identical JavaScript:
+9 files, 32,190 raw / 12,324 aggregate gzip B. Search by title/topic, whitespace
+and case normalization, singular/plural status, empty branches, retained keys,
+and fresh restored rows pass. The new static topic reduction emits matching
+HTML, no excluded article seed, no state markers, and zero JavaScript files.
+The six existing unsafe collection forms remain source-located diagnostics.
+
+The original failing article source was recovered from the first patch event,
+not reconstructed from the agent's final workaround. Recovered page SHA-256:
+`915d825d15d1799b2a6fc891e12e1e84ca366df5a00a7721bd83d1b0f33db4d2`.
+It and all five final content sources pass the separately prepared r6 acceptance
+with all ten static siblings checked. The two combined polite-region sources
+also pass its corrected semantic count check. These source-only results do not
+erase historical budget failures or change model success/cost denominators.
+
+| Output | Before raw / gzip B | After raw / gzip B | Delta raw / gzip B |
+|---|---:|---:|---:|
+| Complete content JavaScript, attempts 0/1/2/4 | 55,447 / 20,976 | 34,908 / 13,677 | -20,539 / -7,299 |
+| Complete content JavaScript, attempt 3 | 55,440 / 20,987 | 34,901 / 13,688 | -20,539 / -7,299 |
+| Content runtime files only, all five attempts | 51,357 / 19,100 | 30,895 / 11,896 | -20,462 / -7,204 |
+| `/topics/performance/` JavaScript graph | 20,539 / 7,299 | 0 / 0 | -20,539 / -7,299 |
+| Existing reduced search graph | 32,190 / 12,324 | 32,190 / 12,324 | 0 / 0 |
+
+Each content build changes from 11 pages / 2 interactive / 13 JavaScript files
+to 11 pages / 1 interactive / 9 JavaScript files. Removed paths are
+`assets/handlers/pages/topics/performance.js` and the `kudzu.js`, `kudzu-list.js`,
+and `kudzu-collection-selector.js` files in runtime family `432dc692688d09a1`.
+Every retained JavaScript path and byte is identical to its archived r5 output.
+The recovered source emits the same graph as final attempts 0/1/2/4, SHA-256
+`34a34339db48a3da01f67b41fa5a5b0f50ea4d1854e3c30a1569e8e32b2c5270`
+(sorted relative JavaScript paths followed by their bytes). Gzip is summed per
+artifact with Node `gzipSync`, not a compressed archive or network measurement.
+
+### Accounting And Verification
+
+| Metric | Delta |
+|---|---:|
+| Semantic primitives / ModuleIR kinds / core passes | 0 / 0 / 0 |
+| Core semantic LOC (`source-compiler.mjs`, including comment) | +5 |
+| Focused normalization LOC (`effect-private-ref-pass.mjs`) | +2 |
+| Production compiler LOC total | +7 |
+| Ordered normalization entries / transform rules / adapters | 0 / 0 / 0 |
+| Source diagnostic guards | +1 |
+| Runtime concepts / runtime source LOC / dependencies / public APIs | 0 / 0 / 0 / 0 |
+| Positive reduced cases / negative reduced cases | +2 / +2 |
+| AI score, build-speed, interaction-timing, CPU, heap claims | None |
+
+The positive cases extend the existing isolated fixture generator; the two
+negative source fixtures live in `test/realtime-version-ref.test.mjs`. No new
+runtime or generic compiler abstraction was introduced. Static collection
+aliases and cross-invocation mutable refs are not broadened by this change.
+
+```bash
+KUDZU_REQUIRE_CHROME=1 node --test test/imported-article-search.test.mjs
+node --test test/realtime-version-ref.test.mjs
+node /tmp/opencode/r5-compiler-followup.mjs
+node /tmp/opencode/verify-r5-compiler-output.mjs
+npm run check
+KUDZU_REQUIRE_CHROME=1 npm test
+npm run test:package
+```
+
+All pass on the same Linux x64 / Node 24.14.0 / Chrome 152.0.7977.64 host as r5.
+Check builds 224 pages, two interactive. The final full run passes the standalone
+project ownership gate plus 315/315 tests, including the preserved r6 acceptance
+tests; package smoke installs four packages and builds one zero-JavaScript page.
+Full commands use a 1,200,000 ms timeout. Local replay sources, artifacts, full
+acceptance JSON, errors, path lists, and raw/gzip totals are retained separately
+at `/tmp/opencode/r5-compiler-followup-EQOrpR/report.json` and adjacent directories.
+No model, commit, version bump, publication, or release was run. Build/browser
+timings were not sampled under an interleaved performance protocol, so no timing
+improvement is claimed.
+
+## 0.21.4 Released 0.16.24 Rerun (2026-09-07)
+
+All 50 scheduled attempts executed, without selective retries, from
+`2026-09-07T04:18:00.678Z` through `2026-09-07T05:36:06.037Z` (78 minutes
+5 seconds). The frozen scorer reports **Kudzu 18/25 (72%) versus React + Vite
+23/25 (92%)**. Execution finished, but `suite.json` correctly says `incomplete`:
+two Kudzu realtime attempts retain partial attribution after their deadlines.
+This is a new local r5 observation, not a rewrite of the published r2 result,
+proof of a statistically significant improvement, or authorization for `1.0.0`.
+The acceptance/prompt and output-contract gaps below also prevent treating this
+score as a clean production-framework ranking.
+
+### Protocol And Execution
+
+Base revision: `5ed0f9bc875691e4e86e2fab832491c78c2f0c69`, released
+`@kudzujs/core@0.16.24`; no compiler changes during this packet. Although no r4
+execution was found in the local evidence inventory, r4's `0.16.23` pins were
+already release-documented. Revision 5 therefore explicitly changes all five
+Kudzu manifests, lock root dependencies, resolved core versions/tarball URLs,
+registry integrity values, and canonical starter digests. Historical r2/r3 raw
+directories and release records remain untouched. The r4 lifecycle adapter is
+unchanged, SHA-256
+`91c0db691c2f7a7d5c40122e86b2ac7b928e3016a80a202f8c079c2013b3eb0e`.
+
+Model remains `openai/gpt-5.6-sol`; exact OpenCode `1.18.27` is selected with
+`OPENCODE_BIN` rather than the host default `1.18.29`. Node `24.14.0`, npm
+`11.9.0`, Chrome `152.0.7977.64`, Linux x64 `7.0.0-30-generic`, Intel i5-9500
+(6 logical CPUs), and 33,491,050,496 bytes RAM were recorded. OAuth presence was
+checked without reading credentials. A separate tool-free model preflight
+returned `READY`; its 6,755 tokens are excluded from task accounting.
+
+The model, budgets, tools, prompts, public context, executable acceptance,
+written contracts, all React starters, and alternating schedules are identical
+to r4. Each adapter has a setup-inclusive 300,000 ms deadline and limits of
+400,000 input, 20,000 output, 20,000 reasoning tokens, 40 tool calls, 20 files
+read, 8 files modified, and 5 builds. Tasks execute serially in content, forms,
+CRUD, commerce, realtime order; model processes never run in parallel.
+
+```bash
+OPENCODE_BIN=/home/kft/.npm/_npx/3fe6b69ccd55ed58/node_modules/.bin/opencode CHROME_BIN=/usr/bin/google-chrome npm run benchmark:ai-delivery-production -- --out test-results/ai-delivery-production/0.21.4-gpt-5.6-sol-r5-kudzu-0.16.24-20260907-01 > test-results/ai-delivery-production/0.21.4-gpt-5.6-sol-r5-kudzu-0.16.24-20260907-01/suite.stdout 2> test-results/ai-delivery-production/0.21.4-gpt-5.6-sol-r5-kudzu-0.16.24-20260907-01/suite.stderr
+```
+
+The command exits 0 after all schedules finish; that is not a passing benchmark
+gate. The output directory contains `suite.json`, all five `run.json` and copied
+protocols, 50 attempt results, raw adapter output/traces, build/acceptance logs,
+retained source and deploy artifacts, preflight logs, test logs, and `audit.json`
+(all source diffs, raw-trace review extracts, and artifact/token aggregates).
+The complete local archive is
+`test-results/ai-delivery-production/0.21.4-gpt-5.6-sol-r5-kudzu-0.16.24-20260907-01.tar.gz`,
+SHA-256 `d0190c9c4d6da0bd9676365037cf1a1def72e808010e3b03a94a701138a31205`.
+Gzip integrity passes; all 50 schedule entries, 50 pinned-model attribution
+traces, and 300 recorded command-stream SHA-256 values were verified. The archive
+is local evidence only and was not uploaded or released.
+
+| Task | r5 protocol SHA-256 | Kudzu starter SHA-256 |
+|---|---|---|
+| Content | `f63c11e20e21659c25ef99498e13085054565382af9a500e7aa6e6520968b1ec` | `6b56448eb0b9179183aeb433bd3e52538749f1a2e609c37c5a8bdf8e479ccd92` |
+| Forms | `967335af955b23c23e8ce81eed35b3a9426c08047b4286a5328e144f30b6e9aa` | `0a762afe93c77cec2137e956796f47a944b9222e3dcff1178462665cf995291b` |
+| CRUD | `063625fd48442c639a059c240d1edaef63f54176f921dcd297c8daf97086430d` | `1e349e2deb163b8bc52fb8844a989e8f29f1ed12a2857da86119bf89ffa3e5c2` |
+| Commerce | `c35cb1801f5a4b98a644f6f48f7c02b2168ebc9ce901b0b8e74fcf792c3d2e0b` | `d2b6e8d926b3e55d0e3e47c0647fdd75f01b46e3dc4ac705108974c7d3e186b3` |
+| Realtime | `bda2526c95862b8d55045018da70370b9dd9a36d4e7ccfe56b3af56f06dbad10` | `f5adc4cf163a8e9cb838173d718fd21302a474fd70920167c12d64518890b218` |
+
+The starter digest is SHA-256 over recursively locale-sorted file names, each
+relative slash-normalized path followed by NUL and file bytes, matching the
+integrity test. Every core lock entry uses registry integrity
+`sha512-qLcVItXkI7vI5ktOC16+87uQ4BqQTQOVrFqR4AK7gz4eMN4imL7o+ocUBc7znuVsMML98ChKLRgMSsUot7GUhg==`.
+
+### Scores And Attribution
+
+| Task | Kudzu success | React success | Kudzu tokens / success | React tokens / success |
+|---|---:|---:|---:|---:|
+| Content | 3/5 | 5/5 | 591,903 | 77,522 |
+| Forms | 5/5 | 5/5 | 92,087 | 81,111 |
+| CRUD | 3/5 | 3/5 | 250,028 | 197,556 |
+| Commerce | 5/5 | 5/5 | 68,746 | 57,756 |
+| Realtime | 2/5 | 5/5 | unavailable | 142,071 |
+| Overall | 18/25 | 23/25 | unavailable | task median 81,111 |
+
+Tokens per success include failed attempts, cache-read input, output, and
+reasoning, following the existing runner's accounting. Recorded totals are
+4,279,911 Kudzu tokens (a lower bound because two traces are partial) and
+2,384,962 React tokens. There are 48 complete and 2 incomplete traces; no raw
+model error event was found. Both timed-out model sessions had already produced
+source and a compiler diagnostic, so they are not model-unavailability failures.
+Provider-reported subscription cost is zero, not a market-price cost comparison.
+Kudzu's aggregate failure-inclusive task cost remains unavailable, not zero.
+Successful-attempt elapsed medians are 69,363/65,918 ms, tool calls 12/10, files
+read 5/4, files modified 2/2, builds 1/1, and correction cycles 0/0 for
+Kudzu/React. These are descriptive scorer subsets, not speed or cost wins.
+
+Final builds passed 23/25 Kudzu and 25/25 React; complete executable acceptance
+passed 18/25 and 23/25. Against historical r2's 11/25 and 24/25, the observed
+counts change by +7 and -1, with content and commerce now having scored Kudzu
+successes. Different stochastic runs, compiler pins, lifecycle accounting, and
+the limitations below prevent attributing that entire change to the compiler.
+
+### Every Failure
+
+| Attempts | Observed failure | Attribution / limitation |
+|---|---|---|
+| `content-kudzu-2`, `content-kudzu-3` | Empty-state live-region text is `0 articlesNo articles match your search.` rather than exactly `0 articles`; all filtering/count transitions otherwise match. Attempt 2 also uses 497,474 input tokens, over 400,000. | Both place separate count and empty-message paragraphs inside one polite region. The grader assumes the entire first live region is the count. Preserve failures, but do not call this broken filtering; the prompt does not explicitly require a count-only region. |
+| `crud-kudzu-1`, `crud-kudzu-3`, `crud-react-vite-2`, `crud-react-vite-4` | Only `initial.group` fails; keyed retention, filters, create/edit/delete, counts, focus, and empty state pass. | All use `role="group" aria-label="Filter memos by status"`. The grader requires exact `Filter memos`. That name exists in the written contract and starter, but the supplied prompt asks only for a named group. The adapter does not supply the written contract. This is a prompt/acceptance alignment gap, not a compiler or missing-group failure. |
+| `realtime-kudzu-0`, `realtime-kudzu-3` | Adapter SIGKILL at about 300,011 ms; final build rejects `src/pages/index.tsx:16:9`: effect-private refs require cleanup that resets or invalidates `.current`. No deploy output. | Version refs initialized with zero are intended to survive pause/resume; current effect-private ownership cannot provide that lifetime. Atomic partial traces retain 117,447 and 175,039 recorded tokens, respectively. No retry or synthetic completion. |
+| `realtime-kudzu-1` | Build passes after changing `useRef(1)` to an unattached `useRef(null)` plus render-time initialization; acceptance times out waiting for the first four-row snapshot. | Generated handler still reads `scope("version").current`. The runtime-ref workaround is not proven safe by its successful build. The frozen timeout path does not serialize browser exception details; do not invent an exact exception or claim a diagnosed compiler fix. |
+
+Raw content traces also retain a residual `query.trim is not a function`
+build failure in attempts 1 and 3 when a normalized query alias feeds a filtered
+array whose `.length` is consumed directly. Both agents inline the query
+expression to recover. Attempts 0/2/4 retain the normalized query with a separate
+count local and build. These exact sources, plus the realtime ref cases, are
+future reduced-fixture inputs; this rerun makes no speculative compiler change.
+
+### Output And Source
+
+| Executable-accepted subset | Kudzu median artifact raw / gzip B | React median artifact raw / gzip B | Kudzu / React median transferred JS B |
+|---|---:|---:|---:|
+| Content (3 / 5 attempts) | 93,274 / 35,226 | 206,504 / 66,425 | 37,608 / 199,132 |
+| Forms (5 / 5) | 23,832 / 9,771 | 202,704 / 64,305 | 15,147 / 198,469 |
+| CRUD (3 / 3) | 48,490 / 16,727 | 203,383 / 64,471 | 35,542 / 198,476 |
+| Commerce (5 / 5) | 53,886 / 21,871 | 201,055 / 64,188 | 30,214 / 197,976 |
+| Realtime (2 / 5) | 45,555 / 16,150 | 202,524 / 64,244 | 36,012 / 199,043 |
+
+Artifact totals include every deploy file; gzip is summed per file. Transferred
+JS sums `.js` resource entries from the frozen journey, including protocol
+overhead, not CPU time or a complete multi-route session. All 18 scored Kudzu
+successes have the designated complete, script/marker-free static sibling.
+Content emits 11 HTML pages but only nine are script/marker-free: besides the
+search route, `/topics/performance/` loads a list capability. Its source was not
+edited by the agents, but this violates the broader written content static-route
+expectation and is not checked by executable acceptance. React's
+`staticZeroJavaScript: true` is a bypass in the checker, not evidence of zero
+React JavaScript. No complete 0.9 performance, memory, resilience, or all-route
+accessibility parity claim follows from these artifact observations.
+
+All 50 retained source inventories were compared with their starters. Only
+authored TSX/CSS changed (one to three files); manifests, locks, seeded data,
+fake transport, and test infrastructure remain unchanged. Search preserves
+`ArticleCard`/`Shell` composition and imported data; CRUD preserves its shared
+Provider and keyed declarative rows. No imperative list/DOM replacement was
+found. Native form refs, focus, and validity calls are ordinary form behavior.
+Maintainability is not uniformly equivalent: commerce Kudzu attempt 4 adds
+derived display state after a formatting diagnostic; realtime Kudzu attempt 2
+calls `setMemos` inside a version-state updater, while attempt 4 carries version
+through state plus an effect-local copy instead of React's persistent ref.
+These are explicit authoring compromises, not proof of abstraction parity.
+The runner's byte-identical-file retention metric includes lockfile bytes and
+is not a semantic source-retention percentage.
+
+Next prerequisite is an acceptance/prompt alignment review, preserving this raw
+batch and changing no scores retroactively. The retained direct-count query and
+cross-invocation version-ref failures then provide concrete compiler intake;
+the static topic output also needs a separately scoped check. `1.0.0` remains
+blocked. This packet adds zero semantic primitives, compiler passes/LOC, runtime
+concepts, or dependencies, and makes no release, speed, price, or superiority claim.
+
+Verification: six protocol/runner/lifecycle tests pass; before execution and
+again after the results documentation, `npm run check` builds 224 pages, two
+interactive, and `npm test` passes the standalone project ownership test plus
+308/308 tests. Final logs are `final-check.log` and `final-test.log` in the raw
+directory. `git diff --check` passes. The final archive/checksum metadata update
+does not change model inputs or any recorded artifact.
+
 ## 0.21.4 Corrected AI Delivery Proof
 
 Measured 2026-09-03 on Linux x64 with Node 24.14.0, Chrome 152.0.7977.64,
@@ -92,6 +370,64 @@ not a new equal-condition model run, so the published 11/25 versus 24/25 result
 and the `1.0.0` block remain unchanged pending the complete production rerun.
 This follow-up ships as `@kudzujs/core@0.16.23`.
 
+### Imported Search Source Replay (2026-09-07)
+
+Compiler follow-up shipping as `0.16.24` to `f88279024e68c875ea35592a1ab363bde1cec9d0`
+(`0.16.23`), on Linux x64, Node 24.14.0 and Chrome 152.0.7977.64. Authorizing
+evidence is the initial aliased search patch at line 50 of
+`test-results/ai-delivery-production/0.21.4-gpt-5.6-sol-r3-kudzu-0.16.23-continuation-20260907/content/attempts/content-kudzu-0/adapter.stdout`.
+The reduced fixture first reproduced both the source-located generic expression
+diagnostic and the direct-filter-count `query.trim is not a function` build error.
+
+Imported collection discovery now follows top-level const selector aliases from
+map/count uses. Filter predicates encode proven pure query locals using the
+existing expression language, and count dependencies use signal build values in
+scratch rather than invoking string methods on signal objects. Existing binding,
+selector, keyed, and conditional consumers remain authoritative.
+
+| Metric | Result |
+|---|---|
+| Semantic primitives / IR kinds / runtime concepts / APIs | +0 / +0 / +0 / +0 |
+| Core passes / ordered normalization entries / adapters | +0 / +0 / +0 |
+| Existing normalization/proof boundaries extended | 3: import roots, pure filter locals, count build values |
+| Core semantic LOC, unchanged 0.9 file set | +39, 5,466 -> 5,505; source compiler +26, collection analysis +13 |
+| Regression evidence | 1 reduced fixture; 3 positive source variants, 6 negative forms, 4 tests |
+| Reduced route JS | 9 files; 32,190 raw / 12,324 aggregate gzip B in every variant |
+| Delta from fully inlined control | 0 raw / 0 gzip B; identical JS paths and contents |
+| Reduced static sibling | Complete HTML, 0 B JavaScript |
+| Full retained application replay | 11 pages, 2 interactive; build and existing content acceptance pass |
+| Full application JS vs earlier retained inlined artifacts | 13 files; 55,447 raw / 20,976 aggregate gzip B; all paths/bytes identical |
+| Build/browser timing and AI-cost delta | Not measured; no fresh model benchmark or ranking claim |
+
+The full replay restores the initial page and stylesheet patch over the content
+starter while preserving the retained application's other source. It uses the
+current workspace compiler and the unchanged existing content acceptance runner,
+not a new adapter invocation. It passes search/count/empty/restore, accessibility,
+zero-JavaScript static output, and no browser exceptions or failed requests.
+Raw build/acceptance output and `replay.json` are retained separately under
+`test-results/ai-delivery-production/imported-article-search-source-replay-20260907/`. Its sorted
+HTML/CSS/JS path-plus-NUL-plus-content SHA-256 is
+`92d96f7cfdd4535de28ff9b7665aa241815ed2649e6db14fc22c5eadc8258904`.
+The original attempt and earlier benchmark results are not rewritten.
+
+Release verification: `npm run check` (224 pages, 2 interactive),
+`KUDZU_REQUIRE_CHROME=1 npm test` (standalone project ownership gate, then
+308/308 tests), `npm run test:package` (4 installed packages, one static page),
+and both package dry-runs pass. The release gates ran sequentially with a
+1,200-second tool limit, avoiding overlapping fixture tests.
+Chrome regression checks also prove retained rows and fresh remounts; they are
+correctness checks, not latency samples. Mutable aliases, impure calls, cycles,
+collection escapes, mutating sort, and predicate-parameter state collisions remain
+diagnosed. No general local/callback graph or effect cleanup claim is added.
+The same release includes separate r4 benchmark lifecycle integrity changes:
+atomic partial-usage checkpoints, bounded incremental stdout/stderr evidence,
+setup-inclusive deadlines, owned process-tree termination, and incomplete timeout
+attribution. Two Linux lifecycle regressions cover setup and model timeouts,
+partial usage, descendant termination, and passing acceptance after adapter timeout.
+The Windows `taskkill` path remains untested. Future r4 protocols pin published
+`0.16.23` starters; historical raw evidence remains untouched. The published
+11/25 versus 24/25 comparison and `1.0.0` block remain unchanged.
+
 ## 0.21.2 Browser Performance And Memory
 
 Measured 2026-09-03 at revision

package/README.md

@@ -14,7 +14,7 @@ Kudzu compiles ordinary React-shaped TypeScript and TSX into complete static HTM
 
 > Experimental `0.16.x`: the compiler API and supported TSX surface may change.
 
-**Latest release: 0.16.23 - reactive conditional branch text.** Selected conditional branches now keep scalar text reactive while their condition remains true, using Kudzu's existing text-binding ownership. The retained commerce sources pass 5/5 on the current compiler; `1.0.0` remains blocked pending a complete equal-condition rerun. Read the [release notes](./RELEASES.md#01623---reactive-conditional-branch-text), open the [release page](https://github.com/kudzujs/kudzu/releases/tag/v0.16.23), or follow the [architecture packet](./docs/next-architecture/README.md).
+**Latest release: 0.16.25 - static content and acceptance alignment.** Direct imported static selectors emit HTML without list JavaScript, and original query aliases support direct JSX counts. Content source replay removes four files and 20,539 raw / 7,299 aggregate gzip JavaScript bytes. Future-only r6 acceptance covers named groups, combined polite regions, and all ten static siblings. Historical r5 remains 18/25 versus 23/25 with two partial traces; no fresh model rerun or replacement score is claimed, and `1.0.0` remains blocked. Read the [release notes](./RELEASES.md#01625---static-content-and-acceptance-alignment), open the [release page](https://github.com/kudzujs/kudzu/releases/tag/v0.16.25), or follow the [architecture packet](./docs/next-architecture/README.md).
 
 - [Documentation](https://kudzujs.cloud/docs)
 - [Installation guide](https://kudzujs.cloud/docs#install)

package/RELEASES.md

@@ -1,5 +1,71 @@
 # Kudzu Releases
 
+## 0.16.25 - Static Content And Acceptance Alignment
+
+Kudzu 0.16.25 closes the r5 static-topic and direct-count compiler gaps and
+aligns future acceptance with communicated requirements. This release includes
+historical r5 observations, not a fresh model rerun or replacement score.
+
+### Changed in 0.16.25
+
+- Keeps proven direct imported static selector maps at build time and registers
+  normalized query build values for collection counts consumed directly in JSX.
+- Removes four topic JavaScript files from each replayed content build: 13 to 9
+  files, saving 20,539 raw / 7,299 aggregate gzip bytes. Retained JavaScript is
+  byte-identical, and all ten static siblings pass source-replay acceptance.
+- Rejects unsafe render-written mutable refs at authored source locations.
+  Persistent realtime version refs across effect replacements remain unsupported;
+  existing cleanup diagnostics and state-based realtime sources are preserved.
+- Adds seven production compiler lines across two existing files, no semantic
+  primitive, pass, IR kind, runtime concept, public API, or dependency.
+- Aligns named CRUD groups and combined polite count/empty regions, enforces
+  static exclusion on all ten content siblings, and freezes r6 protocol hashes.
+  Those future-only protocols retain published 0.16.24 starters; no r6 model run
+  has been performed.
+- Preserves historical r5's 18/25 Kudzu versus 23/25 React + Vite, with two partial
+  Kudzu traces and acceptance limitations. Published r2 remains 11/25 versus
+  24/25. Neither is rescored; `1.0.0` remains blocked. No timing or cost win is claimed.
+- Updates `create-kudzu@0.1.150` to generate `@kudzujs/core@^0.16.25` projects.
+
+### Upgrade
+
+```sh
+npm install @kudzujs/core@^0.16.25
+```
+
+## 0.16.24 - Imported Article Search And Benchmark Integrity
+
+Kudzu 0.16.24 compiles the original authored imported-article search shape
+without an inlined workaround and hardens evidence lifecycle integrity for
+future AI delivery runs. This is source replay evidence, not a new AI score.
+
+### Changed in 0.16.24
+
+- Follows imported collection selector aliases, normalizes proven pure query
+  locals, and evaluates count dependencies from signal build values.
+- Adds 39 net core semantic lines across two existing compiler files, with no
+  new semantic primitive, pass, IR kind, runtime concept, API, or dependency.
+- Covers three byte-identical search variants, six rejected unsafe forms,
+  retained keyed identity, fresh remounts, and a zero-JavaScript static sibling.
+- Replays the original authored application search successfully through the
+  unchanged content acceptance: 13 JavaScript files, 55,447 raw / 20,976 gzip
+  bytes, identical to the retained inlined application's JavaScript.
+- Checkpoints adapter usage atomically, streams bounded output evidence, shares
+  the deadline with setup, kills owned process trees on timeout, and prevents
+  incomplete or timed-out attempts from becoming successful attribution.
+- Freezes r4 protocols with published 0.16.23 starters for future runs only.
+  Historical raw evidence is unchanged. Linux lifecycle regressions cover the
+  termination paths; the Windows `taskkill` path remains untested.
+- Makes no fresh timing, cost, or AI performance claim. The published 11/25
+  versus 24/25 comparison and the `1.0.0` block remain unchanged.
+- Updates `create-kudzu@0.1.149` to generate `@kudzujs/core@^0.16.24` projects.
+
+### Upgrade
+
+```sh
+npm install @kudzujs/core@^0.16.24
+```
+
 ## 0.16.23 - Reactive Conditional Branch Text
 
 Kudzu 0.16.23 removes the second commerce compiler blocker selected by the

package/docs/next-architecture/application-capability-release-plan.md

@@ -2183,6 +2183,120 @@ This does not revise the published equal-condition score without a complete
 rerun, so `1.0.0` remains unauthorized. This follow-up is released as
 `@kudzujs/core@0.16.23` with `create-kudzu@0.1.148`.
 
+The user-approved 2026-09-07 `0.16.24` continuation addresses the initial r3
+content patch's imported collection alias and direct filter-count failures.
+[`imported-article-search`](../../test/fixtures/imported-article-search/README.md)
+reproduced both failures before changes. The reduction extends existing import
+discovery, pure selector normalization, and count build-value lowering, with
+existing BindingIR/DerivedIR/KeyedBlockIR consumers and route/keyed/conditional
+ownership. It adds no primitive, IR kind, pass, runtime concept, API, or adapter;
+the two core files grow by net 39 lines. Three source variants produce identical
+JavaScript (32,190 raw / 12,324 gzip B) and six unsafe neighboring forms remain
+source-located errors. Required Chrome verifies search/count/empty transitions,
+retained keys, fresh remounts, and static zero-JavaScript exclusion. Check, the
+project ownership gate plus 308 tests, package smoke, and both package dry-runs pass.
+
+The full initial-source replay passes the unchanged content acceptance and emits
+the same 13 JavaScript files/bytes as the earlier retained inlined workaround
+(55,447 raw / 20,976 gzip B). This is a source replay, not a fresh model trial or
+replacement benchmark score; no timing or AI-cost improvement is claimed.
+[`PERFORMANCE.md`](../../PERFORMANCE.md#imported-search-source-replay-2026-09-07)
+records commands, provenance, accounting, and limits. Preserve the original r3
+evidence. The release also includes the reviewed r4 protocol/adapter lifecycle
+work: atomic partial traces, bounded incremental output, setup-inclusive deadlines,
+owned process-tree termination, and incomplete timeout attribution. Two Linux
+lifecycle regressions protect future-run integrity; Windows termination remains
+untested. The frozen r4 starters stay on published `0.16.23`; old raw records are
+not reinterpreted. This packet ships as `@kudzujs/core@0.16.24` with
+`create-kudzu@0.1.149`, without authorizing `1.0.0` or a new AI performance claim.
+
+The post-release 2026-09-07 r5 rerun now executes all 50 predeclared attempts with
+published `0.16.24` core pins, registry lock integrity, and canonical hashes in
+all five Kudzu starters. Revision 5 preserves the release-documented r4 pins as
+history rather than relabeling them; model `openai/gpt-5.6-sol`, OpenCode 1.18.27,
+budgets, prompts, public context, acceptance, React starters, schedules, and the
+r4 lifecycle adapter are unchanged. No compiler or runtime change is made.
+
+The frozen scorer records Kudzu 18/25 versus React + Vite 23/25, with per-task
+counts 3/5, 5/5, 3/5, 5/5, 2/5 versus 5/5, 5/5, 3/5, 5/5, 5/5. All tasks finish,
+but two Kudzu realtime deadline failures retain partial attribution, so suite
+status and Kudzu aggregate token cost remain incomplete. React's failure-inclusive
+task-token median is 81,111. Historical r2's published 11/25 versus 24/25 and all
+r3 raw evidence remain unchanged; no selective retries or replacement scores.
+
+This is not a clean ranking or `1.0.0` authorization. Four CRUD failures are
+exact accessible-name mismatches against a requirement absent from the supplied
+prompt; two content failures arise from the grader reading count and empty copy
+as one live-region string, one also exceeding the input budget. The next
+prerequisite is acceptance/prompt alignment review without retroactive rescoring.
+Real compiler intake remains in raw `query.trim` failures for direct count uses
+of normalized-query filters and realtime refs intended to survive pause/resume.
+One null-ref workaround builds but fails the first snapshot; two zero-ref
+attempts fail cleanup proof and time out. Accepted source retains declarative
+composition but some Kudzu attempts add derived/version state workarounds.
+Designated static siblings remain script-free; content's unchanged topic source
+emits list scripts, leaving the broader static-route contract unproven.
+
+Exact commands, nine-failure census, hashes, artifact medians, and scope limits:
+[`PERFORMANCE.md`](../../PERFORMANCE.md#0214-released-01624-rerun-2026-09-07).
+Local raw evidence is
+`test-results/ai-delivery-production/0.21.4-gpt-5.6-sol-r5-kudzu-0.16.24-20260907-01/`.
+Six integrity/lifecycle tests, `npm run check`, and the standalone ownership gate
+plus 308 tests pass. No commit, version bump, publication, or release is part of
+this continuation.
+
+### r5 Compiler Follow-Up
+
+The evidence-backed follow-up is implemented without changing the dirty r5/r6
+protocol, prompt, contract, or acceptance work. The two content reductions were
+confirmed red before compiler changes: direct JSX `.length` over a normalized
+query filter threw `query.trim is not a function`, and the unchanged static topic
+filter emitted list state/scripts. Existing count dependency registration now
+selects signal build values, while direct imported pipelines without selector
+states or collection aliases stay in ordinary build-time map execution.
+BindingIR, DerivedIR, KeyedBlockIR, and route/keyed/conditional ownership remain
+unchanged; reactive selectors retain the existing list path and negative checks.
+
+Realtime source tracing closes the proposed lifetime extension negatively.
+Attempts 0/3 correctly reject version refs without cleanup reset; moving them
+into invocation-private closures would lose the version on pause/resume. Attempt
+1 exposes a separate diagnostic gap: render-written null refs were accepted as
+DOM refs, which serialize an ID rather than the retained numeric value. Existing
+ref normalization now rejects those writes at source. No cross-invocation ref,
+resource primitive, runtime, or arbitrary callback support was added. Original
+state-based attempts 2/4 still pass the realtime browser journey.
+
+Accounting: semantic primitives, IR kinds, core passes, normalization entries,
+transform/adapter rules, runtime concepts/source, and APIs all +0; core semantic
+LOC +5, focused normalization LOC +2, one diagnostic guard, two positive and two
+negative reduced cases. The four search variants emit identical JavaScript at
+32,190 raw / 12,324 gzip B. All five final content sources plus the recovered
+first attempt-1 patch pass the prepared r6 acceptance, including every one of the
+ten static siblings and combined polite regions. Each deploy removes four topic
+JavaScript files totaling 20,539 raw / 7,299 gzip B, including 20,462 / 7,204 B of
+runtime files; every retained JavaScript file is byte-identical to r5.
+
+`npm run check`, the standalone ownership gate plus 315 required-Chrome tests,
+and package smoke pass with 1,200,000 ms command timeouts. Exact source locations,
+replay hashes, commands, output tables, diagnostic boundaries, and local evidence
+are in [`PERFORMANCE.md`](../../PERFORMANCE.md#r5-compiler-follow-up-2026-09-07).
+This is source replay, not AI rescoring: r5 remains 18/25 versus 23/25 with partial
+traces, and published r2 remains 11/25 versus 24/25. No model rerun, timing claim,
+commit, release, or `1.0.0` authorization follows. The next benchmark decision
+must use the aligned r6 protocol in a separately authorized complete run, not
+selective retries or broader compiler semantics without new evidence.
+
+### 0.16.25 Release Transaction
+
+The user-authorized patch packages the preceding r5 records, compiler fixes,
+render-ref diagnostic, and future-only r6 acceptance alignment as core 0.16.25
+and create-kudzu 0.1.150. The pre-release session records above remain historical.
+R6 accepts semantically named CRUD groups and combined polite count/empty regions,
+and checks all ten content static siblings. Its hashes and published 0.16.24
+starter pins remain frozen; testing 0.16.25 in a model run requires a new frozen
+revision. No fresh model run, score replacement, persistent-ref support, or
+`1.0.0` authorization is part of this release.
+
 ## `1.0.0`: Stable Application Model
 
 `1.0.0` is authorized only after every required `0.21.x` gate passes. It means:
@@ -2328,4 +2442,4 @@ release transaction where possible or document and publish a forward-fix patch.
 | `0.21.1` | Released as `0.16.16` | Preserve 100/1,000/10,000-route phase, RSS, output, digest, incremental-equivalence, recovery, and bounded canonical-AST retention evidence. | Full 10,000-route report has one complete measured run after two measured-stage diagnostics; no projection used |
 | `0.21.2` | Closed by existing semantics | Preserve initial/session/lazy bytes, keyed/range/navigation median alarms, and bounded endurance ownership evidence. | Same-revision absolute gates; structural artifact bytes are not compressed network transfer |
 | `0.21.3` | Released as `0.16.17` | Preserve exact package, browser, benchmark, registry, and fresh-install evidence. | One initial navigation benchmark invocation stalled at the outer timeout; its clean seven-profile rerun passed all alarms |
-| `0.21.4` | Measured gate failed; selected blockers released through `0.16.23` | Preserve both raw batches, the corrected revision-2 protocols, the failed success/cost decision, collection count reuse, and selected-branch reactive text; keep `1.0.0` blocked pending a complete rerun. | Published result remains Kudzu 11/25 versus React + Vite 24/25; retained commerce sources now pass 5/5 on `0.16.23` |
+| `0.21.4` | r5 executed all 50 attempts; compiler follow-up verified; gate remains blocked | Preserve raw scores and partial traces. Direct-count/static-topic fixes and the render-ref diagnostic are verified; persistent version refs remain unsupported. Use aligned r6 only in a separately authorized complete run. | Local historical r5 scorer: Kudzu 18/25 versus React + Vite 23/25, with two partial Kudzu traces. Source replay passes all ten content static siblings but does not replace scores. Published r2 remains 11/25 versus 24/25. |

package/docs/next-architecture/compiler-current-architecture.md

@@ -1,6 +1,8 @@
 # Current Compiler Architecture
 
-This maps the current `0.16.23` architecture, built on the completed `0.9.0` semantic-compression release and `0.8.23` Goal A compiler foundation. The `0.21.4` AI delivery gate is measured and blocked; file and function names are the stable references, while line numbers are intentionally omitted because later work may still move code.
+This maps the current `0.16.25` architecture, built on the completed `0.9.0` semantic-compression release and `0.8.23` Goal A compiler foundation. The `0.21.4` AI delivery gate is measured and blocked; file and function names are the stable references, while line numbers are intentionally omitted because later work may still move code.
+
+The r5 follow-up registers direct collection-count query build values and leaves proven direct imported static selectors in build-time map execution. Existing ref normalization rejects render-written mutable refs; persistent cross-effect version refs remain unsupported. These changes add seven compiler lines, no pass, IR kind, or runtime concept.
 
 ## Responsibility Map
 

package/docs/next-architecture/versioning.md

@@ -66,7 +66,7 @@ Keep each patch behavior-preserving and independently reviewable. If a boundary
 
 ## Generator Versions
 
-`create-kudzu@0.1.148` retains the explicit install instructions and generates projects with `@kudzujs/core@^0.16.23`.
+`create-kudzu@0.1.150` retains the explicit install instructions and generates projects with `@kudzujs/core@^0.16.25`.
 
 ## Release Boundary
 

package/framework/compiler/collection-analysis.mjs

@@ -73,7 +73,7 @@ export function analyzeCollectionPipeline(expression, options) {
       if (!source) return undefined
       const parameters = collectionParameters(value.arguments[0], "Rendered collection filter()", fail)
       const selectorStates = new Set(source.selectorStates)
-      return { ...source, selector: [...source.selector, ["filter", collectionExpression(unwrapExpression(value.arguments[0].body), { parameters, fail, stateNames, selectorStates })]], selectorStates }
+      return { ...source, selector: [...source.selector, ["filter", collectionExpression(unwrapExpression(value.arguments[0].body), { parameters, fail, stateNames, selectorStates, declarations })]], selectorStates }
     }
     if (method === "flatMap") {
       if (value.arguments.length !== 1) fail(value, "Rendered collection flatMap() requires one inline projector")
@@ -122,7 +122,7 @@ export function analyzeCollectionPipeline(expression, options) {
   }
 }
 
-export function collectionExpression(expression, { parameters = {}, fail, stateNames = new Set(), selectorStates = new Set() }) {
+export function collectionExpression(expression, { parameters = {}, fail, stateNames = new Set(), selectorStates = new Set(), declarations, aliases = new Set() }) {
   const encode = node => {
     node = unwrapExpression(node)
     if (ts.isStringLiteral(node) || ts.isNoSubstitutionTemplateLiteral(node) || ts.isNumericLiteral(node)) return ["value", ts.isNumericLiteral(node) ? Number(node.text) : node.text]
@@ -137,6 +137,19 @@ export function collectionExpression(expression, { parameters = {}, fail, stateN
         selectorStates.add(node.text)
         return ["state", node.text]
       }
+      const entries = declarations?.get(node.text)
+      if (entries?.length === 1 && entries[0].node.parent?.parent?.parent === nearestFunction(entries[0].node)?.body) {
+        if (aliases.has(node.text)) fail(node, `Rendered collection expression local cycle at "${node.text}"`)
+        aliases.add(node.text)
+        const dependencies = new Set()
+        const result = collectionExpression(entries[0].initializer, { fail, stateNames, selectorStates: dependencies, declarations, aliases })
+        for (const name of dependencies) {
+          if (name === parameters.item || name === parameters.index) fail(node, `Rendered collection expression local "${node.text}" cannot capture state shadowed by predicate parameters`)
+          selectorStates.add(name)
+        }
+        aliases.delete(node.text)
+        return result
+      }
       fail(node, `Rendered collection expression identifier "${node.text}" is not allowed`)
     }
     if (ts.isPropertyAccessExpression(node)) {

package/framework/compiler/effect-private-ref-pass.mjs

@@ -72,6 +72,8 @@ export function normalizeEffectPrivateRefs(sourceFile, factory, context) {
       if (frameAssignments.length && invalidReference) throw sourceNodeError(invalidReference, sourceFile, "Animation frame refs may only use direct .current reads and assignments")
       if (frameAssignments.length && !topLevelConst) throw sourceNodeError(node, sourceFile, "Animation frame refs must be one top-level component const")
       if (attachedToJsx && mutations.length) throw sourceNodeError(mutations[0], sourceFile, "JSX object refs may not assign to ref.current")
+      const renderWrite = mutations.find(access => nearestFunction(access) === owner)
+      if (renderWrite) throw sourceNodeError(renderWrite, sourceFile, "Mutable refs cannot be assigned during render; use component state for values retained across effect replacements, or an effect-private ref with cleanup for invocation-local values")
       if (!topLevelConst || invalidReference || !accesses.length) return
       const effectCalls = owner.body.statements.flatMap(statement => hasUseEffectImport && ts.isExpressionStatement(statement) && ts.isCallExpression(statement.expression) && ts.isIdentifier(statement.expression.expression) && statement.expression.expression.text === "useEffect" && !isShadowedIdentifier(statement.expression.expression, sourceFile) ? [statement.expression] : [])
       const effects = effectCalls.filter(effect => {

package/framework/compiler/source-compiler.mjs

@@ -1149,7 +1149,7 @@ function createKudzuTransformer({ semantic, handlerUrl, file, sourceFiles, sourc
       if (!isUnshadowedGlobal(roundAccess.expression, sourceFile)) fail(roundAccess.expression, "Reactive JSX Intl.NumberFormat requires the unshadowed global Math object")
       collectionExpression(rounded.arguments[0], { fail: (node, message) => fail(node, message.replace("Rendered collection", "Reactive JSX local")), stateNames: allowedNames })
     }
-    const resolveReactiveJsxExpression = (expression, owner, setters) => {
+    const resolveReactiveJsxExpression = (expression, owner, setters, buildDeclarations) => {
       const declarations = jsxLocalDeclarations.get(owner)
       if (!declarations) return expression
       const substitutions = new Map()
@@ -1187,6 +1187,7 @@ function createKudzuTransformer({ semantic, handlerUrl, file, sourceFiles, sourc
       const captures = captureNames(expanded, expanded, setters, bindingIndex)
       const allowedNames = new Set([...setters.values(), ...captures])
       validateReactiveJsxExpression(expanded, allowedNames, setters)
+      if (buildDeclarations) for (const name of substitutions.keys()) buildDeclarations.add(declarations.get(name)[0].node)
       return expanded
     }
     const componentSpecializations = new WeakMap()
@@ -1696,6 +1697,7 @@ function createKudzuTransformer({ semantic, handlerUrl, file, sourceFiles, sourc
     const collectionAliasUses = rawRenderedLists.flatMap(({ parts }) => parts.aliasUses ?? [])
     const collectionAliasDeclarations = new Set(rawRenderedLists.flatMap(({ parts }) => parts.aliasDeclarations ?? []))
     const collectionLengthDeclarations = new Set()
+    const collectionValueDeclarations = new Set()
     for (const declaration of collectionAliasDeclarations) {
       const owner = nearestFunction(declaration)
       const unsupported = identifierReferences(owner.body, declaration.name.text).find(reference => {
@@ -1707,12 +1709,28 @@ function createKudzuTransformer({ semantic, handlerUrl, file, sourceFiles, sourc
             collectionLengthDeclarations.add(current)
             return false
           }
-          if (ts.isJsxExpression(current) && current.initializer === undefined) return false
+          if (ts.isJsxExpression(current) && current.initializer === undefined) {
+            resolveReactiveJsxExpression(reference.parent, owner, settersForNode(reference, settersByFunction), collectionValueDeclarations)
+            return false
+          }
         }
         return true
       })
       if (unsupported) fail(unsupported, `Rendered collection alias "${declaration.name.text}" may only be used as a rendered collection source`)
     }
+    for (const [owner, declarations] of jsxLocalDeclarations) for (const entries of declarations.values()) {
+      if (entries.length !== 1 || entries[0].node.parent?.parent?.parent !== owner?.body) continue
+      const { node, initializer } = entries[0]
+      const value = unwrapExpression(initializer)
+      if (!ts.isPropertyAccessExpression(value) || value.name.text !== "length") continue
+      const setters = settersForNode(node, settersByFunction)
+      const expression = resolveReactiveJsxExpression(initializer, owner, setters, collectionValueDeclarations)
+      if (!referencedStateNames(expression, setters).size) continue
+      const collection = analyzeCollectionPipeline(unwrapExpression(expression).expression, { setters, declarations, fail, importedCollections, stateNames: new Set(setters.values()), importedCollectionTransforms })
+      if (!collection?.selector.length) continue
+      validateReactiveJsxExpression(expression, new Set(setters.values()), setters)
+      collectionLengthDeclarations.add(node)
+    }
     const rejectUnsupportedRenderControl = node => {
       if (ts.isIfStatement(node) && containsRenderControl(node, jsxLocalsByFunction.get(nearestFunction(node)) ?? new Set())) {
         const setters = settersForNode(node, settersByFunction)
@@ -2229,12 +2247,12 @@ function createKudzuTransformer({ semantic, handlerUrl, file, sourceFiles, sourc
         return factory.updateVariableDeclaration(node, node.name, node.exclamationToken, node.type, factory.createIdentifier("undefined"))
       }
 
-      if (ts.isVariableDeclaration(node) && collectionLengthDeclarations.has(node) && node.initializer) {
+      if (ts.isVariableDeclaration(node) && node.initializer && (collectionLengthDeclarations.has(node) || collectionValueDeclarations.has(node))) {
         const setters = settersForNode(node, settersByFunction)
         const expression = resolveReactiveJsxExpression(node.initializer, nearestFunction(node), setters)
         const stateNames = new Set(setters.values())
         const rewrite = current => {
-          if (ts.isIdentifier(current) && stateNames.has(current.text) && isReferenceIdentifier(current)) return factory.createPropertyAccessExpression(current, "value")
+          if (ts.isIdentifier(current) && stateNames.has(current.text) && isReferenceIdentifier(current) && !isShadowedByParameter(current, expression)) return factory.createPropertyAccessExpression(current, "value")
           return ts.visitEachChild(current, rewrite, context)
         }
         return factory.updateVariableDeclaration(node, node.name, node.exclamationToken, node.type, ts.visitNode(expression, rewrite))
@@ -2449,6 +2467,8 @@ function keyedListParts(expression, setters, declarations, fail, aliases = new S
   const field = keyExpression && directProperty(keyExpression, parameters.item)
   const positional = Boolean(keyExpression && parameters.index && ts.isIdentifier(unwrapExpression(keyExpression)) && unwrapExpression(keyExpression).text === parameters.index)
   if (!field && !positional) fail(key ?? root, `Keyed list root must have key={${parameters.item}.<field>} or key={${parameters.index ?? "index"}}`)
+  // Direct build-known imports can execute their map without keyed browser ownership.
+  if (collection.static && !collection.localStatic && !collection.selectorStates.size && !collection.aliasDeclarations?.length) return undefined
   return { ...collection, static: collection.static && (!collection.localStatic || collection.selector.length > 0), callback, root, item: parameters.item, index: parameters.index, indexed: Boolean(parameters.index), keyField: positional ? null : field }
 }
 
@@ -3526,16 +3546,27 @@ function importedSerializableCollections(sourceFile, file, sourceFiles, sourceIn
   for (const statement of sourceFile.statements) if (ts.isImportDeclaration(statement) && ["react", "@kudzujs/core"].includes(statement.moduleSpecifier.text) && statement.importClause?.namedBindings && ts.isNamedImports(statement.importClause.namedBindings)) {
     for (const entry of statement.importClause.namedBindings.elements) if ((entry.propertyName ?? entry.name).text === "useMemo") memoNames.add(entry.name.text)
   }
+  const visitedAliases = new Set()
   const collectRoot = node => {
-    if (ts.isPropertyAccessExpression(node) && ["filter", "flatMap", "slice", "toSorted", "map"].includes(node.name.text)) {
+    if (ts.isPropertyAccessExpression(node) && ["filter", "flatMap", "slice", "toSorted", "map", "length"].includes(node.name.text)) {
       let expression = node.expression
       while (ts.isCallExpression(expression) || ts.isPropertyAccessExpression(expression)) expression = expression.expression
-      if (ts.isIdentifier(expression)) mapped.add(expression.text)
+      if (ts.isIdentifier(expression)) {
+        if (!isShadowedIdentifier(expression, sourceFile)) mapped.add(expression.text)
+        const owner = nearestFunction(node)
+        if (owner?.body && ts.isBlock(owner.body)) for (const statement of owner.body.statements) {
+          if (!ts.isVariableStatement(statement) || !(statement.declarationList.flags & ts.NodeFlags.Const)) continue
+          for (const declaration of statement.declarationList.declarations) if (ts.isIdentifier(declaration.name) && declaration.name.text === expression.text && declaration.initializer && !visitedAliases.has(declaration)) {
+            visitedAliases.add(declaration)
+            collectRoot(declaration.initializer)
+          }
+        }
+      }
     }
     ts.forEachChild(node, collectRoot)
   }
   const visit = node => {
-    if (ts.isPropertyAccessExpression(node) && node.name.text === "map") {
+    if (ts.isPropertyAccessExpression(node) && ["map", "length"].includes(node.name.text)) {
       collectRoot(node)
     }
     if (ts.isCallExpression(node) && ts.isIdentifier(node.expression) && memoNames.has(node.expression.text) && node.arguments[0]) collectRoot(node.arguments[0])

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kudzujs/core",
-  "version": "0.16.23",
+  "version": "0.16.25",
   "description": "HTML-first TSX framework with synchronous state semantics and no virtual DOM",
   "type": "module",
   "license": "MIT",