@kudzujs/core 0.16.22 → 0.16.24

package/PERFORMANCE.md

@@ -76,6 +76,80 @@ route handlers. Benchmark contract and budget deltas are zero; the production AI
 comparison is not rerun until selected-branch reactive text is also addressed.
 This follow-up ships as `@kudzujs/core@0.16.22`.
 
+The 2026-09-04 selected-branch follow-up lowers a reactive scalar branch through
+the existing text-binding compiler path. It adds no semantic primitive,
+compiler pass, runtime concept, API, dependency, or shared-runtime source byte;
+net production growth is 11 lines in one existing compiler file. The focused
+fixture covers an update that remains in the selected branch and a later branch
+replacement. Required Chrome, all 302 tests, `npm run check`, and package smoke
+pass. Rebuilding the five retained commerce sources against this tree changes
+their frozen `below` check from false to true, so all five pass build, behavior,
+accessibility, browser, and output acceptance while retaining the zero-JavaScript
+static sibling. The existing checkout handler grows by 147-154 transferred bytes
+across those authored variants; no shared runtime module was added. Benchmark
+contracts and budgets are unchanged. This is a same-source compiler follow-up,
+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.22 - reactive collection count reuse.** Filtered collection aliases now feed keyed rendering, top-level counts, reactive text, and count-selected branches without duplicated state. This removes the first blocker selected by the failed `0.21.4` AI delivery gate; `1.0.0` remains blocked. Read the [release notes](./RELEASES.md#01622---reactive-collection-count-reuse), open the [release page](https://github.com/kudzujs/kudzu/releases/tag/v0.16.22), or follow the [architecture packet](./docs/next-architecture/README.md).
+**Latest release: 0.16.24 - imported article search and benchmark integrity.** Ordinary imported search aliases and counts compile through existing semantics with byte-identical JavaScript to the inlined control. Revision-4 benchmark protocols preserve partial evidence and enforce setup-inclusive deadlines for future runs; no fresh AI performance result is claimed, and `1.0.0` remains blocked. Read the [release notes](./RELEASES.md#01624---imported-article-search-and-benchmark-integrity), open the [release page](https://github.com/kudzujs/kudzu/releases/tag/v0.16.24), 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,64 @@
 # Kudzu Releases
 
+## 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
+corrected `0.21.4` AI delivery evidence: scalar text inside a selected
+conditional branch remains reactive without restructuring ordinary TSX.
+
+### Changed in 0.16.23
+
+- Lowers reactive scalar conditional branches through the existing text-binding
+  compiler path while preserving conditional ownership and static HTML.
+- Verifies updates that remain in one branch and later replace that branch in
+  required Chrome.
+- Passes all five retained commerce sources with `empty`, `below`, and `reached`
+  true while preserving their zero-JavaScript static siblings.
+- Adds no semantic primitive, compiler pass, runtime concept, public API,
+  dependency, or shared-runtime source byte; `1.0.0` remains unauthorized pending
+  a complete equal-condition rerun.
+- Updates `create-kudzu@0.1.148` to generate projects on
+  `@kudzujs/core@^0.16.23`.
+
+### Upgrade
+
+```sh
+npm install @kudzujs/core@^0.16.23
+```
+
 ## 0.16.22 - Reactive Collection Count Reuse
 
 Kudzu 0.16.22 removes the first compiler blocker selected by the corrected

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

@@ -2169,6 +2169,47 @@ comparison must be rerun only after the remaining selected-branch reactive-text
 blocker is addressed. This follow-up is released as `@kudzujs/core@0.16.22`
 with `create-kudzu@0.1.147`. `1.0.0` remains unauthorized.
 
+The second evidence-selected follow-up now lowers reactive scalar text inside a
+selected conditional branch through the existing binding descriptor and
+conditional ownership paths. It adds no semantic primitive, compiler pass,
+runtime concept, API, dependency, or shared-runtime source byte; one production
+compiler file grows by net 11 lines. A focused fixture proves same-branch text
+updates and branch replacement, and required Chrome, all 302 tests, package
+smoke, and `npm run check` pass. The five retained commerce sources now pass
+their complete acceptance with `empty`, `below`, and `reached` all true and a
+zero-JavaScript static sibling. Their route-specific checkout handlers add
+147-154 transferred bytes; no runtime module or benchmark contract changes.
+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.
+
 ## `1.0.0`: Stable Application Model
 
 `1.0.0` is authorized only after every required `0.21.x` gate passes. It means:
@@ -2314,4 +2355,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; first blocker released as `0.16.22` | Preserve both raw batches, the corrected revision-2 protocols, the failed success/cost decision, and collection count reuse; keep `1.0.0` blocked. | Kudzu 11/25 versus React + Vite 24/25; next evidence work is conditional-branch reactive text |
+| `0.21.4` | Measured gate failed; selected blockers released through `0.16.24` | Preserve historical raw batches and failed success/cost decision; r4 lifecycle integrity applies only to future runs. Keep `1.0.0` blocked pending a complete rerun. | Published result remains Kudzu 11/25 versus React + Vite 24/25; commerce replay passes 5/5 and original imported search replay passes with unchanged JavaScript |

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

@@ -1,6 +1,6 @@
 # Current Compiler Architecture
 
-This maps the current `0.16.22` 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.24` 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.
 
 ## 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.147` retains the explicit install instructions and generates projects with `@kudzujs/core@^0.16.22`.
+`create-kudzu@0.1.149` retains the explicit install instructions and generates projects with `@kudzujs/core@^0.16.24`.
 
 ## 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/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 => {
@@ -1713,6 +1715,19 @@ function createKudzuTransformer({ semantic, handlerUrl, file, sourceFiles, sourc
       })
       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)
@@ -1872,8 +1887,19 @@ function createKudzuTransformer({ semantic, handlerUrl, file, sourceFiles, sourc
 
     const compileRenderExpression = (expression, anchor) => {
       const parts = conditionalParts(expression)
-      if (!parts) return ts.visitNode(expression, visitor)
       const setters = settersForNode(anchor, settersByFunction)
+      if (!parts) {
+        if (containsJsx(expression)) return ts.visitNode(expression, visitor)
+        const resolved = resolveReactiveJsxExpression(expression, nearestFunction(anchor), setters)
+        const usedStates = referencedStateNames(resolved, setters, resolved, bindingIndex)
+        const captures = captureNames(resolved, resolved, setters, bindingIndex)
+        if ((usedStates.size || captures.size) && !ts.isIdentifier(resolved)) {
+          usesBehavior = true
+          usesBinding = true
+          return descriptors.compileReactiveBinding(resolved, { setters, importBindings, derived: calculationBinding(expression, nearestFunction(anchor)) }).node
+        }
+        return ts.visitNode(expression, visitor)
+      }
       const condition = resolveReactiveJsxExpression(parts.condition, nearestFunction(anchor), setters)
       const usedStates = referencedStateNames(condition, setters, condition, bindingIndex)
       const captures = captureNames(condition, condition, setters, bindingIndex)
@@ -2218,12 +2244,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))
@@ -3515,16 +3541,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.22",
+  "version": "0.16.24",
   "description": "HTML-first TSX framework with synchronous state semantics and no virtual DOM",
   "type": "module",
   "license": "MIT",