@kudzujs/core 0.6.14 → 0.6.16

package/README.md

@@ -190,7 +190,7 @@ function Controls({ dispatch }: { dispatch: Dispatch<TodoAction> }) {
 return <Controls dispatch={dispatch} />
 ```
 
-Kudzu specializes that call at build time; no function prop or child component survives in the browser. Relative TypeScript constants and helpers used inside the child handler are renamed for call-site safety and bundled into the parent handler graph. Lazy initializers, package, namespace, local, async, and generator reducers, package imports or child imports used outside event handlers, forwarding across another component, and reducer dispatch through context remain unsupported.
+Kudzu specializes that call at build time; no function prop or child component survives in the browser. The direct child may also be a keyed row such as `todos.map(todo => <Item key={todo.id} todo={todo} dispatch={dispatch} />)`. Its inline or simple `const` event handler receives the latest keyed item, while relative TypeScript constants and helpers used inside the handler are renamed for call-site safety and bundled into the parent handler graph. Lazy initializers, package, namespace, local, async, and generator reducers, package imports or child imports used outside event handlers, further dispatch forwarding, reducer-dispatch keyed-row effects or local state, and reducer dispatch through context remain unsupported.
 
 That specialized component may pass one inline or simple `const` callback containing dispatch to one relative-imported synchronous child with an intrinsic root:
 
@@ -201,6 +201,14 @@ return <Input onSubmit={add} />
 
 Kudzu substitutes the callback into the child's compiled event handler at build time. This is not general function-prop serialization: only one nested specialized callback boundary is supported, and `useCallback`, further forwarding, effects, component roots, and callback use outside event handlers are rejected.
 
+Reducer dispatch and callback components may use destructured string, finite-number, boolean, or `null` defaults. A missing prop is replaced during specialization; object, array, computed, and function-call defaults remain unsupported:
+
+```tsx
+function Input({ onSubmit, editing = false }) {
+  // ...
+}
+```
+
 ## Reactive Attributes
 
 `className`, `disabled`, controlled `value`, and controlled `checked` accept normal state-dependent TSX expressions. The same `value` binding works for inputs and selects:

package/framework/README.md

@@ -25,7 +25,7 @@ Inline SVG rendering normalizes an explicit set of common React presentation ali
 
 Same-file and relative-imported components receiving a direct local-state array prop are specialized to intrinsic JSX before keyed-list analysis, so their component function is not retained in the browser. Handler modules are emitted only when a rendered descriptor references them, preventing specialized imported components from adding dead browser assets. Direct JSON-safe primitive keyed-item dependencies subscribe each row record to its owning list commit and compare selected fields after `list-runtime.js` synchronously refreshes the row marker. Only changed rows rerun with the complete latest item; reorder compares equal, unrelated fields do nothing, and key changes remain remove plus mount. Builds without item dependencies emit no item reader or list-state subscription code.
 
-The reduced `useReducer` form reuses ordinary state slots. A direct dispatch in a compiled handler becomes a functional `set` whose reducer is bundled from a relative TypeScript module into that handler graph. One direct dispatch prop into a same-file or relative-imported synchronous component is specialized to intrinsic JSX at the call site, so its handler retains the parent reducer scope and no dispatch capture or child handler asset is emitted. Relative TypeScript imports referenced inside that child handler receive collision-free call-site aliases and join the parent handler graph. One nested relative-imported intrinsic child may receive an inline or simple `const` callback containing dispatch; the compiler recursively substitutes that callback once and omits the nested child handler asset. Reducer-free routes and shared runtimes are unchanged; no reducer runtime or browser component instance exists.
+The reduced `useReducer` form reuses ordinary state slots. A direct dispatch in a compiled handler becomes a functional `set` whose reducer is bundled from a relative TypeScript module into that handler graph. One direct dispatch prop into a same-file or relative-imported synchronous component, including a direct keyed row, is specialized to intrinsic JSX at the call site, so its handler retains the parent reducer scope and no dispatch capture or child handler asset is emitted. A keyed-row handler reads the latest item through the existing list scope. Relative TypeScript imports referenced inside that child handler receive collision-free call-site aliases and join the parent handler graph. One nested relative-imported intrinsic child may receive an inline or simple `const` callback containing dispatch; the compiler recursively substitutes that callback once and omits the nested child handler asset. Missing primitive literal defaults in these reducer specializations are substituted at the same call site. Reducer-free routes and shared runtimes are unchanged; no reducer runtime or browser component instance exists.
 
 `kudzu.config` may opt one emitted shared-layout group into same-document navigation with legacy `navigation: { routes: ["/product", "/items/[id]"] }`, or multiple groups with `navigation: { groups: [{ routes: [...] }, { routes: [...] }] }`. The forms are mutually exclusive. Identities are globally unique emitted exact paths or `runtimeParams` patterns; each group uses one page-exported layout function identity. Runtime records securely match concrete pathnames under `base`, and their cache-safe parameter initializer runs before route DOM/effects mount on every transition. Each group receives a deterministic route-hashed asset specialized to only its records, pattern decoder, and effect/parameter lifecycle needs. Cross-group and ungrouped anchors remain native and are not prefetched; overlapping path domains across groups fail the build. Route effect entries export cache-safe layout and route mount functions: layout effects, including conditional/keyed DOM-owned effects, persist for the group session; route effects receive a fresh owner registry after each route insertion; and non-persisted page disposal cleans route before layout. Direct primitive state, runtime parameter, and keyed-item property dependencies and cleanup are supported. Fragment payloads and coordinated View Transitions are not implemented.
 

package/framework/build.mjs

@@ -1735,6 +1735,7 @@ function createKudzuTransformer(nativeHandlers, effectHandlers, reactiveBindings
       throw sourceNodeError(node, sourceFile, message)
     }
     const componentSpecializations = new WeakMap()
+    const reducerComponentCalls = new WeakSet()
     const specializedDeclarations = new WeakSet()
     const stateBackedComponentFunctions = new WeakSet()
     const stateBackedComponentRoots = []
@@ -1838,6 +1839,7 @@ function createKudzuTransformer(nativeHandlers, effectHandlers, reactiveBindings
         if (specialization.effects.length) fail(call, "Reducer-dispatch components cannot declare effects")
         specialization.root = expandReducerCallbacks(specialization.root, component.function.getSourceFile(), call)
         componentSpecializations.set(call, specialization)
+        reducerComponentCalls.add(call)
       }
       specializedDeclarations.add(component.declaration)
     }
@@ -1862,6 +1864,7 @@ function createKudzuTransformer(nativeHandlers, effectHandlers, reactiveBindings
         specialization.root = mergeSpecializedImports(specialization.root, componentSource, call)
         synthesizeTree(specialization.root)
         componentSpecializations.set(call, specialization)
+        reducerComponentCalls.add(call)
       }
     }
     const rawRenderedLists = []
@@ -1910,7 +1913,9 @@ function createKudzuTransformer(nativeHandlers, effectHandlers, reactiveBindings
         ...stateBackedComponentRoots.flatMap(root => jsxTagUses(root, name))
       ]
       for (const call of calls) {
-        const specialization = specializeComponentCall(call, component.function, sourceFile, factory, context, fail)
+        const specialization = reducerComponentCalls.has(call)
+          ? componentSpecializations.get(call)
+          : specializeComponentCall(call, component.function, sourceFile, factory, context, fail)
         if (specialization.effects.length && !keyedComponentCalls.has(call)) fail(call, "Effectful keyed row components may only be used directly as keyed map rows")
         componentSpecializations.set(call, specialization)
       }
@@ -2473,10 +2478,11 @@ function specializeComponentCall(call, component, sourceFile, factory, context,
   const substitutions = new Map()
   const acceptedProps = new Set()
   for (const element of component.parameters[0].name.elements) {
-    if (element.dotDotDotToken || element.initializer || !ts.isIdentifier(element.name)) fail(element, `${label} component props cannot use rest, defaults, or nested destructuring`)
-    const prop = (element.propertyName ?? element.name).getText()
+    if (element.dotDotDotToken || !ts.isIdentifier(element.name) || (element.initializer && label === "Keyed list")) fail(element, `${label} component props cannot use rest, defaults, or nested destructuring`)
+    if (element.initializer && !isPrimitiveDefaultLiteral(element.initializer)) fail(element.initializer, `${label} component prop defaults must be primitive literals`)
+    const prop = (element.propertyName ?? element.name).text
     acceptedProps.add(prop)
-    substitutions.set(element.name.text, props.get(prop) ?? factory.createIdentifier("undefined"))
+    substitutions.set(element.name.text, props.has(prop) ? props.get(prop) : element.initializer ?? factory.createIdentifier("undefined"))
   }
   for (const prop of props.keys()) if (!acceptedProps.has(prop)) fail(call, `Unknown ${label.toLowerCase()} component prop "${prop}"`)
 
@@ -2498,7 +2504,7 @@ function specializeComponentCall(call, component, sourceFile, factory, context,
       const declaration = statement.declarationList.declarations[0]
       if (!ts.isIdentifier(declaration.name) || !declaration.initializer) fail(declaration, `${label} component locals must be initialized identifiers`)
       const calculation = substituteClone(declaration.initializer, substitutions, factory, context)
-      calculations.push(calculation)
+      calculations.push({ name: declaration.name.text, expression: calculation })
       substitutions.set(declaration.name.text, calculation)
     }
     returned = last.expression
@@ -2513,7 +2519,42 @@ function specializeComponentCall(call, component, sourceFile, factory, context,
   ts.setParentRecursive(root, false)
   root.parent = call.parent
   const effects = effectCalls.map(source => ({ source, call: substituteClone(source, substitutions, factory, context) }))
-  return { root, calculations, effects }
+  return {
+    root,
+    calculations: calculations
+      .filter(calculation => label !== "Reducer-dispatch" || !isFunctionLike(calculation.expression) || !isEventOnlyComponentLocal(returned, calculation.name))
+      .map(calculation => calculation.expression),
+    effects
+  }
+}
+
+function isPrimitiveDefaultLiteral(node) {
+  return ts.isStringLiteral(node) || ts.isNumericLiteral(node) ||
+    (ts.isPrefixUnaryExpression(node) && (node.operator === ts.SyntaxKind.PlusToken || node.operator === ts.SyntaxKind.MinusToken) && ts.isNumericLiteral(node.operand)) ||
+    node.kind === ts.SyntaxKind.TrueKeyword || node.kind === ts.SyntaxKind.FalseKeyword || node.kind === ts.SyntaxKind.NullKeyword
+}
+
+function isEventOnlyComponentLocal(root, name) {
+  let found = false
+  let eventOnly = true
+  const visit = node => {
+    if (ts.isIdentifier(node) && node.text === name && isReferenceIdentifier(node)) {
+      found = true
+      let parent = node.parent
+      while (parent && parent !== root) {
+        if (ts.isJsxAttribute(parent)) {
+          if (!/^on[A-Z]/.test(parent.name.text)) eventOnly = false
+          return
+        }
+        parent = parent.parent
+      }
+      eventOnly = false
+      return
+    }
+    ts.forEachChild(node, visit)
+  }
+  visit(root)
+  return found && eventOnly
 }
 
 function substituteClone(root, substitutions, factory, context) {

package/package.json

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