@kudzujs/core 0.16.21 → 0.16.23

package/PERFORMANCE.md

@@ -65,6 +65,33 @@ cost, so this proof does not authorize `1.0.0`. This evidence packet changes no
 compiler, runtime, public API, dependency, generated application, or browser
 artifact.
 
+The 2026-09-04 collection follow-up removes the first blocker for one ordinary
+immutable filtered alias reused by keyed rendering, a top-level count, reactive
+text, and a count-selected branch. It adds no primitive, pass, runtime concept,
+API, dependency, or shared-runtime byte; net production compiler growth is 37
+lines across two existing files. The maintained positive and negative fixtures
+pass all 302 tests with Chrome required. Their exercised interactive route uses
+the unchanged 36,219 B shared runtime closure and 37,870 B total JavaScript with
+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`.
+
 ## 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.21 - AI evidence npm recovery.** The production-shaped `0.21.4` comparison measured Kudzu at 11/25 attributable successes and React + Vite at 24/25, so the `1.0.0` gate remains blocked while content, CRUD, and commerce compiler boundaries are investigated. This patch retries the unchanged evidence after npm rejected the `0.16.20` trusted-publishing certificate. Read the [release notes](./RELEASES.md#01621---ai-evidence-npm-recovery), open the [release page](https://github.com/kudzujs/kudzu/releases/tag/v0.16.21), or follow the [architecture packet](./docs/next-architecture/README.md).
+**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).
 
 - [Documentation](https://kudzujs.cloud/docs)
 - [Installation guide](https://kudzujs.cloud/docs#install)

package/RELEASES.md

@@ -1,5 +1,57 @@
 # Kudzu Releases
 
+## 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
+`0.21.4` AI delivery evidence: an ordinary filtered collection alias can now
+feed keyed rendering, a top-level count, reactive text, and a count-selected
+conditional branch without duplicating state or restructuring the component.
+
+### Changed in 0.16.22
+
+- Normalizes supported collection alias `.length` reads through existing
+  collection analysis and reactive binding compilation.
+- Expands count aliases before conditional compilation while preserving initial
+  server-rendered values and keyed DOM ownership across filter changes.
+- Verifies reactive count updates, empty-branch unmount, keyed remount, and the
+  retained diagnostic for unsupported collection alias consumers in Chrome.
+- Adds no semantic primitive, compiler pass, runtime concept, public API,
+  dependency, or shared-runtime byte; `1.0.0` remains unauthorized.
+- Updates `create-kudzu@0.1.147` to generate projects on
+  `@kudzujs/core@^0.16.22`.
+
+### Upgrade
+
+```sh
+npm install @kudzujs/core@^0.16.22
+```
+
 ## 0.16.21 - AI Evidence npm Recovery
 
 Kudzu 0.16.21 retries npm publication of the unchanged corrected `0.21.4` AI

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

@@ -2154,6 +2154,35 @@ and count reuse, then reactive text inside selected conditional branches.
 pass, runtime concept, public API, dependency, generated behavior, or browser
 byte.
 
+The first evidence-selected follow-up now normalizes one supported collection
+alias across a keyed map, a top-level `.length` count, reactive text, and a
+count-selected JSX branch. It reuses collection analysis plus existing binding,
+conditional, and keyed ownership: no semantic primitive, compiler pass, runtime
+concept, API, dependency, or shared-runtime byte was added. The implementation
+changes two existing compiler files by net 37 lines and extends one positive and
+one negative fixture. Required Chrome verifies count updates, empty-branch
+unmount, keyed remount, and retained source diagnostics; all 302 tests, package
+smoke, and `npm run check` pass. The exercised route ships the unchanged 36,219
+B shared runtime closure and 37,870 B total JavaScript including its existing
+route handlers. No benchmark contract or budget changes; the production AI
+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`.
+
 ## `1.0.0`: Stable Application Model
 
 `1.0.0` is authorized only after every required `0.21.x` gate passes. It means:
@@ -2299,4 +2328,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; npm recovery released as `0.16.21` | Preserve both raw batches, the corrected revision-2 protocols, and the failed success/cost decision; keep `1.0.0` blocked. | Kudzu 11/25 versus React + Vite 24/25; next evidence work is reactive collection normalization/count reuse and conditional-branch reactive text |
+| `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` |

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

@@ -1,6 +1,6 @@
 # Current Compiler Architecture
 
-This maps the current `0.16.21` 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.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.
 
 ## 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.146` retains the explicit install instructions and generates projects with `@kudzujs/core@^0.16.21`.
+`create-kudzu@0.1.148` retains the explicit install instructions and generates projects with `@kudzujs/core@^0.16.23`.
 
 ## Release Boundary
 

package/framework/compiler/descriptor-session.mjs

@@ -102,11 +102,11 @@ export function createDescriptorSession({ semantic, handlerUrl, factory, context
     }
   }
 
-  function compileConditional(kind, expression, truthy, falsy, setters) {
+  function compileConditional(kind, expression, truthy, falsy, setters, importBindings = new Map()) {
     const state = directStateIdentifier(expression, setters, bindingIndex)
     const thunk = branch => factory.createArrowFunction(undefined, undefined, [], undefined, factory.createToken(ts.SyntaxKind.EqualsGreaterThanToken), branch)
     if (state) return factory.createCallExpression(factory.createIdentifier("__kStateConditional"), undefined, [factory.createStringLiteral(kind), state, thunk(truthy), thunk(falsy)])
-    const [initial, ...descriptor] = compileReactiveExpression(expression, setters)
+    const [initial, ...descriptor] = compileReactiveExpression(expression, setters, importBindings)
     return factory.createCallExpression(factory.createIdentifier("__kConditional"), undefined, [factory.createStringLiteral(kind), initial, thunk(truthy), thunk(falsy), ...descriptor])
   }
 

package/framework/compiler/source-compiler.mjs

@@ -1107,7 +1107,7 @@ function createKudzuTransformer({ semantic, handlerUrl, file, sourceFiles, sourc
       visit(calculation.body)
       validatedEffectCalculations.add(calculation)
     }
-    const validateReactiveJsxExpression = (expression, allowedNames) => {
+    const validateReactiveJsxExpression = (expression, allowedNames, setters) => {
       const value = unwrapExpression(expression)
       const formatAccess = ts.isCallExpression(value) && !value.questionDotToken && ts.isPropertyAccessExpression(value.expression) && !value.expression.questionDotToken && value.expression.name.text === "format" ? value.expression : undefined
       const formatter = formatAccess && unwrapExpression(formatAccess.expression)
@@ -1115,6 +1115,17 @@ function createKudzuTransformer({ semantic, handlerUrl, file, sourceFiles, sourc
       if (!constructor) {
         const validate = node => {
           const current = unwrapExpression(node)
+          if (ts.isPropertyAccessExpression(current) && current.name.text === "length") {
+            const collection = analyzeCollectionPipeline(current.expression, {
+              setters,
+              declarations: jsxLocalDeclarations.get(nearestFunction(expression)),
+              fail,
+              importedCollections,
+              stateNames: allowedNames,
+              importedCollectionTransforms
+            })
+            if (collection?.state || collection?.calculation) return factory.createNumericLiteral(0)
+          }
           if (ts.isPropertyAccessExpression(current) && ts.isCallExpression(unwrapExpression(current.expression))) {
             const call = unwrapExpression(current.expression)
             if (ts.isIdentifier(call.expression) && importBindings.has(call.expression.text) && importBindings.get(call.expression.text).kind !== "namespace") {
@@ -1175,7 +1186,7 @@ function createKudzuTransformer({ semantic, handlerUrl, file, sourceFiles, sourc
       if (!usedStates.size) return expression
       const captures = captureNames(expanded, expanded, setters, bindingIndex)
       const allowedNames = new Set([...setters.values(), ...captures])
-      validateReactiveJsxExpression(expanded, allowedNames)
+      validateReactiveJsxExpression(expanded, allowedNames, setters)
       return expanded
     }
     const componentSpecializations = new WeakMap()
@@ -1684,9 +1695,22 @@ function createKudzuTransformer({ semantic, handlerUrl, file, sourceFiles, sourc
     collectRenderedLists(sourceFile)
     const collectionAliasUses = rawRenderedLists.flatMap(({ parts }) => parts.aliasUses ?? [])
     const collectionAliasDeclarations = new Set(rawRenderedLists.flatMap(({ parts }) => parts.aliasDeclarations ?? []))
+    const collectionLengthDeclarations = new Set()
     for (const declaration of collectionAliasDeclarations) {
       const owner = nearestFunction(declaration)
-      const unsupported = identifierReferences(owner.body, declaration.name.text).find(reference => !collectionAliasUses.includes(reference))
+      const unsupported = identifierReferences(owner.body, declaration.name.text).find(reference => {
+        if (collectionAliasUses.includes(reference)) return false
+        if (!ts.isPropertyAccessExpression(reference.parent) || reference.parent.expression !== reference || reference.parent.name.text !== "length") return true
+        for (let current = reference.parent; current && current !== owner; current = current.parent) {
+          if (isFunctionLike(current)) return true
+          if (ts.isVariableDeclaration(current) && current.initializer && current.parent?.parent?.parent === owner.body && isLocalConst(current)) {
+            collectionLengthDeclarations.add(current)
+            return false
+          }
+          if (ts.isJsxExpression(current) && current.initializer === undefined) return false
+        }
+        return true
+      })
       if (unsupported) fail(unsupported, `Rendered collection alias "${declaration.name.text}" may only be used as a rendered collection source`)
     }
     const rejectUnsupportedRenderControl = node => {
@@ -1848,19 +1872,32 @@ 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)
-      const usedStates = referencedStateNames(parts.condition, setters, parts.condition, bindingIndex)
-      const captures = captureNames(parts.condition, parts.condition, setters, bindingIndex)
+      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)
       if (!usedStates.size && !captures.size) return ts.visitEachChild(expression, visitor, context)
       usesBehavior = true
       usesConditional = true
       return descriptors.compileConditional(
         parts.kind,
-        parts.condition,
+        condition,
         compileRenderExpression(parts.truthy, anchor),
         compileRenderExpression(parts.falsy, anchor),
-        setters
+        setters,
+        importBindings
       )
     }
 
@@ -2192,6 +2229,17 @@ 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) {
+        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")
+          return ts.visitEachChild(current, rewrite, context)
+        }
+        return factory.updateVariableDeclaration(node, node.name, node.exclamationToken, node.type, ts.visitNode(expression, rewrite))
+      }
+
       if (ts.isVariableDeclaration(node) && ts.isIdentifier(node.name) && node.initializer && ts.isCallExpression(node.initializer) && ts.isIdentifier(node.initializer.expression) && importBindings.has(node.initializer.expression.text)) {
         if (parameterizedDebounceCalls.has(node.initializer)) return node
         const setters = settersForNode(node, settersByFunction)

package/package.json

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