@kudzujs/core 0.8.45 → 0.8.47

package/MIGRATION_ROADMAP.md

@@ -2,7 +2,7 @@
 
 This document is the source of truth for Kudzu's product direction, architecture invariants, and future development order. Read it before extending React-shaped syntax or browser capabilities.
 
-The executable post-`0.8.45` compiler and large-application sequence is maintained in [`docs/next-architecture/large-application-ai-native-roadmap.md`](./docs/next-architecture/large-application-ai-native-roadmap.md). Follow its PR dependencies for implementation work; this document remains authoritative when selecting or accepting a migration capability.
+The executable post-`0.8.47` compiler and large-application sequence is maintained in [`docs/next-architecture/large-application-ai-native-roadmap.md`](./docs/next-architecture/large-application-ai-native-roadmap.md). Follow its PR dependencies for implementation work; this document remains authoritative when selecting or accepting a migration capability.
 
 [`GOAL_A.md`](./GOAL_A.md) and [`GOAL_B.md`](./GOAL_B.md) are completed capability-validation records. Their commerce and realtime dashboard fixtures prove general lifecycle, navigation, async-workflow, and Worker capabilities; they are not separate product verticals or future priority lists.
 
@@ -143,6 +143,8 @@ This queue orders the next investigations by general migration value. Start only
 
 - A React Notes migration preserves its Provider, relative `useNotes()` alias, consumer components, and parameterized CRUD actions. A direct custom-hook `useContext(Context)` return resolves one local or named relative Context module whose Provider value exposes direct state/setter pairs and synchronous actions.
 - Context actions inline into existing route handler ESM and compile to concrete state operations. Private captures, dynamic Provider objects, and multiple Provider implementations remain diagnosed; no browser Context tree, callback registry, or shared runtime was added.
+- In `0.8.46`, the same Notes migration may omit action-only setters from its public Context type and authored Provider value when the corresponding state remains exposed. Kudzu restores those setters only in build scratch so existing concrete state operations, RouteIR signals, CRUD behavior, and zero-Context runtime output remain unchanged. Fully hidden action state and exposed setters without state remain diagnosed.
+- In `0.8.47`, a specialized setter-callback child may initialize local state directly from one primitive parent state prop. Build scratch reads the parent signal's build value while retaining the structural prop signal for handlers/effects; direct object/array props, aliases, and composed initializer expressions remain diagnosed.
 
 ### Completed In 0.8.10
 

package/PERFORMANCE.md

@@ -6,7 +6,15 @@ Reproducibility classes: `npm run benchmark`, `npm run benchmark:keyed`, `npm ru
 
 The maintained 2026-08-13 comparison used Node 24.14.0 and an Intel Core i5-9500 Linux x64 host, one warm-up, and seven alternating fresh-process samples against clean `v0.8.44`. A narrow fast path skips Kudzu semantic transformation for 450 plain `.ts` modules whose runtime edges are exclusively resolvable relative TypeScript imports or exports; all other modules retain the existing transformer. Compile median fell from 2,323.9 ms to 1,413.2 ms (39.2%) and clean-build median from 3,325.3 ms to 2,382.4 ms (28.4%); every paired sample improved. Compile peak-RSS median fell from 571.2 MiB to 552.6 MiB, while build peak RSS was 570.9 MiB versus 568.8 MiB. Compiler scratch fell from 7,328,390 to 1,971,061 bytes. Both targets emitted the same 50 static HTML files, 10,980 bytes, and deploy SHA-256 `e107d78a7f55bc8a1af0ea6e53efeffa19b3d44d21c892484d103fa346e7ba7b`. This is a source-scale compiler comparison, not a cross-framework result.
 
-## Current 0.8.45 Optimization Snapshot
+## Current 0.8.47 Release Snapshot
+
+Kudzu 0.8.47 changes compiler-only specialized child initialization and retains existing parent/child state ownership, handler capabilities, and browser runtimes. No new performance claim is made.
+
+## Maintained 0.8.46 Release Snapshot
+
+Kudzu 0.8.46 changes compiler-only Context Provider scratch and retains the same concrete Notes state operations, RouteIR signals, runtime modules, and static sibling output. No new performance claim is made.
+
+## Maintained 0.8.45 Optimization Snapshot
 
 Kudzu 0.8.45 adds the plain TypeScript fast path and maintained paired source-scale runner described above. It changes compiler scratch only: the measured deploy graph is byte-identical to `v0.8.44`, and no browser runtime or public API changed.
 

package/README.md

@@ -14,7 +14,7 @@ Kudzu compiles ordinary React-shaped TypeScript and TSX into complete static HTM
 
 > Experimental `0.8.x`: the compiler API and supported TSX surface may change.
 
-**Latest release: 0.8.45 - Plain TypeScript fast path.** Proven relative-only `.ts` modules skip Kudzu's TSX semantic transformer while uncertain modules retain the existing path. The maintained 500-module fixture reduced compile median 39.2% and clean-build median 28.4% with identical deploy output. Read the [release notes](./RELEASES.md#0845---plain-typescript-fast-path), open the [release page](https://github.com/kudzujs/kudzu/releases/tag/v0.8.45), or follow the [architecture packet](./docs/next-architecture/README.md).
+**Latest release: 0.8.47 - Direct primitive prop state.** Specialized setter-callback children may initialize local state directly from one primitive parent state prop. Kudzu reads the build-known primitive value while retaining independent child ownership and the structural parent signal. Read the [release notes](./RELEASES.md#0847---direct-primitive-prop-state), open the [release page](https://github.com/kudzujs/kudzu/releases/tag/v0.8.47), 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,63 @@
 # Kudzu Releases
 
+## 0.8.47 - Direct primitive prop state
+
+Kudzu 0.8.47 lets a compiler-specialized setter-callback child initialize local state directly from one primitive parent state prop without a migration-only wrapper expression.
+
+### Changed in 0.8.47
+
+- `useState(value)` is accepted when `value` is a direct specialized prop linked to parent state with a proven primitive literal initializer.
+- Build scratch reads the parent signal's initial primitive value while preserving the structural prop signal for handlers and effects.
+- Existing direct `value.toString()` initialization remains supported for string input buffers.
+- Composed expressions, aliases, and object/array state props remain source-diagnosed.
+
+### Output and performance
+
+- Parent and child retain independent state IDs and JSON-safe initial values.
+- Handler specialization continues to target the same parent and child signals without a component runtime.
+- No browser runtime module, public Kudzu API, or new performance claim is added.
+
+### Validation
+
+- `npm run check`, `npm test`, and `npm run test:package` pass with all 212 tests and 162 generated pages.
+- A direct string-state prop emits complete initial input HTML and two matching RouteIR state seeds.
+- Focused negative fixtures retain diagnostics for composed initializer expressions and object-state props.
+
+### Upgrade
+
+```bash
+npm install @kudzujs/core@^0.8.47
+```
+
+## 0.8.46 - Private Context action setters
+
+Kudzu 0.8.46 lets relative Context-hook actions use Provider-owned setters without forcing those implementation-only setters into the authored Provider value or public Context type.
+
+### Changed in 0.8.46
+
+- An action-required setter may be omitted when its corresponding Provider state value remains exposed.
+- Kudzu adds only the required setter fields to compiler build scratch so existing setter identity and HandlerIR lowering remain unchanged.
+- Consumer scratch receives collision-free private bindings for action lowering without changing authored hook destructuring.
+- Fully hidden action state and Provider setters exposed without their state remain source-diagnosed.
+
+### Output and performance
+
+- The Notes migration retains the same two RouteIR signals and concrete `notes` and `activeId` state operations.
+- Context objects, Provider trees, action functions, and a setter registry remain absent from browser output; the static sibling remains zero JavaScript.
+- No browser runtime module, public Kudzu API, or new performance claim is added.
+
+### Validation
+
+- `npm run check`, `npm test`, and `npm run test:package` pass with all 210 tests and 161 generated pages.
+- The maintained Chrome Notes journey passes create, rename, select, delete, list identity, and active-note updates with authored setters omitted.
+- Focused negative fixtures retain diagnostics for fully hidden action state, setter-only exposure, private captures, and indirect action references.
+
+### Upgrade
+
+```bash
+npm install @kudzujs/core@^0.8.46
+```
+
 ## 0.8.45 - Plain TypeScript fast path
 
 Kudzu 0.8.45 reduces large-project compiler work by sending proven plain `.ts` modules through TypeScript transpilation and relative ESM path rewriting without running Kudzu's TSX semantic transformer.

package/docs/next-architecture/README.md

@@ -11,7 +11,7 @@ The top-level [`GOAL_A.md`](../../GOAL_A.md) and [`GOAL_B.md`](../../GOAL_B.md)
 | C: state/resource model | Research only | Reduced fixtures expose a limitation |
 | D: routing compatibility | Current behavior preserved | Revisit only with migration evidence and invariant review |
 
-The active post-`0.8.45` implementation sequence is [`large-application-ai-native-roadmap.md`](./large-application-ai-native-roadmap.md). P0.12 validation, property-level object-state dependencies, direct three-boundary callback/ref ownership, collision-free Context action-private state, measured route-entry output optimization, and the plain TypeScript source-scale fast path are complete; broader prop, callback, ref, and Context dataflow remains migration-backed work. The plan orders compiler semantic generalization, large-application foundations, compatibility boundaries, AI tooling, and production validation without changing the invariants below.
+The active post-`0.8.47` implementation sequence is [`large-application-ai-native-roadmap.md`](./large-application-ai-native-roadmap.md). P0.12 validation, property-level object-state dependencies, direct three-boundary callback/ref ownership, direct primitive prop state initialization, collision-free and private Context action setters, measured route-entry output optimization, and the plain TypeScript source-scale fast path are complete; broader prop, callback, ref, and Context dataflow remains migration-backed work. The plan orders compiler semantic generalization, large-application foundations, compatibility boundaries, AI tooling, and production validation without changing the invariants below.
 
 ## Required Invariants
 

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

@@ -1,6 +1,6 @@
 # Current Compiler Architecture
 
-This maps the current `0.8.45` architecture, built on the completed `0.8.23` Goal A compiler foundation. File and function names are the stable references; line numbers are intentionally omitted because later work may still move code.
+This maps the current `0.8.47` architecture, built on the completed `0.8.23` Goal A compiler foundation. File and function names are the stable references; line numbers are intentionally omitted because later work may still move code.
 
 ## Responsibility Map
 
@@ -17,7 +17,7 @@ This maps the current `0.8.45` architecture, built on the completed `0.8.23` Goa
 | Source-local binding index | [`framework/compiler/analysis/binding-index.mjs`](../../framework/compiler/analysis/binding-index.mjs) | After normalization, assigns deterministic lexical slots and classifies local, parameter, import, capture, global, and unresolved references. Native handler, effect, binding, list evaluator, optimized-command, and effect-resource consumers use complete index-owned AST; synthesized expressions retain the existing fallback. |
 | Pure collection language | [`framework/compiler/collection-analysis.mjs`](../../framework/compiler/collection-analysis.mjs) | Analyzes collection roots/selectors and serializes the allowed pure expression language used by lists and derived dependencies. |
 | Main semantic analysis | [`framework/compiler/source-compiler.mjs`](../../framework/compiler/source-compiler.mjs), `createKudzuTransformer()` | Produces transformed source plus explicit component, handler, binding, derived, keyed, and effect ownership results. |
-| Component ownership analysis | [`framework/compiler/analysis/component-analysis.mjs`](../../framework/compiler/analysis/component-analysis.mjs) | Produces ComponentAnalysis v2 with ordered JSON-safe owner and specialization slots for state, setters, props, refs, IDs, direct SignalIR links, structural OwnerRefs, source-local SiteIds, and source provenance. Three direct callback/ref component boundaries specialize into the same parent signal and intrinsic ownership; Context action-private state fields receive collision-free consumer-local aliases; AST identity remains private to its source-local session. |
+| Component ownership analysis | [`framework/compiler/analysis/component-analysis.mjs`](../../framework/compiler/analysis/component-analysis.mjs) | Produces ComponentAnalysis v2 with ordered JSON-safe owner and specialization slots for state, setters, props, refs, IDs, direct SignalIR links, structural OwnerRefs, source-local SiteIds, and source provenance. Three direct callback/ref component boundaries specialize into the same parent signal and intrinsic ownership; Context action-private setters may remain compiler-only and receive collision-free consumer-local aliases; AST identity remains private to its source-local session. |
 | Per-source descriptor registration | [`framework/compiler/descriptor-session.mjs`](../../framework/compiler/descriptor-session.mjs), `createSemanticArtifact()`, `createDescriptorSession()` | Keeps AST descriptors private during analysis, then finalizes ModuleIR v2 with deterministic SymbolRef, SignalIR, HandlerIR, BindingIR, DerivedIR, EffectIR, KeyedBlockIR, and ImportIR slots. One fail-closed boundary validates every source-local and component ownership edge before build-module generation. |
 | Route artifact graph | [`framework/compiler/route-build-record.mjs`](../../framework/compiler/route-build-record.mjs), `createRouteBuildRecord()`, `planRouteArtifacts()` | Validates each rendered route's RouteIR, capabilities, entry paths, styles, and exact handler/effect references. Handler modules, Workers, package-client modules, and bundle entry/chunk closure derive from structural edges without serialized output searches or formatted composite keys. |
 | Route contract validation | [`framework/compiler/route-ir.mjs`](../../framework/compiler/route-ir.mjs), `assertRouteIR()` | Fails before artifact selection for invalid state/parameter identity, commands, native/effect captures and dependencies, reactive descriptors, conditions, keyed-list identity/ownership, marker fields, or JSON safety. Immutable in-memory contracts validate once by identity. |

package/docs/next-architecture/large-application-ai-native-roadmap.md

@@ -379,7 +379,7 @@ function increment(value) { setCount(value + 1) }; increment(count)
 After the relevant P0 foundations, investigate capabilities in this order:
 
 1. Property-level derived dependencies over ordinary object state. **Completed in `0.8.40`:** direct property paths and top-level immutable primitive locals over object state reuse tagged DerivedIR, subscribe to the source signal, and compare selected values with `Object.is`; whole-object and dynamic dependencies remain rejected.
-2. Multi-boundary component/prop/callback/ref/context dataflow. **Three-boundary callback/ref ownership completed in `0.8.43`; collision-free Context action-private state completed in `0.8.44`:** forwarding preserves parent SignalIR and Context action lowering uses compiler-owned aliases when consumer locals reuse Provider state/setter names. A fourth callback boundary remains fail-closed. Broader prop, callback, ref, and Context graphs remain migration-led work.
+2. Multi-boundary component/prop/callback/ref/context dataflow. **Three-boundary callback/ref ownership completed in `0.8.43`; collision-free Context action-private state completed in `0.8.44`; action-only Provider setter exposure removed in `0.8.46`; direct primitive prop state initialization completed in `0.8.47`:** forwarding preserves parent SignalIR, Context action lowering uses compiler-owned aliases when consumer locals reuse Provider state/setter names, action-required setters may remain compiler-only when their state is publicly exposed, and specialized children may seed local state from a direct primitive parent signal. A fourth callback boundary, fully hidden Context state, and object/array prop initializers remain fail-closed. Broader prop, callback, ref, and Context graphs remain migration-led work.
 3. Package-neutral shared state/actions and migration of current Zustand internals.
 4. Browser-only package imports in owned effect/resource modules.
 5. ResourceIR from at least two independent WebSocket/SSE/SDK fixtures with the same semantics.
@@ -481,4 +481,4 @@ The first comparison is Kudzu versus React + Vite using the same agent, model, t
 
 ## Immediate Decision
 
-PR 1 through PR 12, the `0.8.40` property-dependency slice, the `0.8.41` and `0.8.43` direct multi-boundary callback/ref slices, the `0.8.44` Context alias slice, and the `0.8.42` measured route-output optimization are complete. Continue broader **component/prop/callback/ref/context dataflow** only from the next real migration blocker. Do not skip directly to a store, resource, router, virtualization, or ecosystem package feature.
+PR 1 through PR 12, the `0.8.40` property-dependency slice, the `0.8.41` and `0.8.43` direct multi-boundary callback/ref slices, the `0.8.44` Context alias slice, the `0.8.46` action-only Provider setter slice, the `0.8.47` direct primitive prop initializer slice, and the `0.8.42` measured route-output optimization are complete. Continue broader **component/prop/callback/ref/context dataflow** only from the next real migration blocker. Do not skip directly to a store, resource, router, virtualization, or ecosystem package feature.

package/docs/next-architecture/versioning.md

@@ -1,6 +1,6 @@
 # Planned Version Sequence
 
-This is an execution sequence, not release history. `0.8.16` through `0.8.45` are completed scopes represented by package/release records.
+This is an execution sequence, not release history. `0.8.16` through `0.8.47` are completed scopes represented by package/release records.
 
 Keep each patch behavior-preserving and independently reviewable. If a boundary proves inseparable, revise this plan before combining releases; do not silently broaden a patch.
 
@@ -36,6 +36,8 @@ Keep each patch behavior-preserving and independently reviewable. If a boundary
 | `0.8.43` | Preserve callback, setter, and ref ownership through a third direct component boundary. | Parent SignalIR, child state/effects/IDs, object refs, conditional cleanup, fresh remount, and static zero-JavaScript output pass in Chrome; a fourth callback boundary fails closed. |
 | `0.8.44` | Remove consumer-local name collisions from specialized Context actions. | Action-private Provider state/setter fields receive deterministic collision-free aliases; CRUD browser behavior, direct state operations, diagnostics, and zero Context runtime output pass. |
 | `0.8.45` | Add a source-scale benchmark and skip Kudzu semantic transformation for proven plain TypeScript modules. | Seven alternating samples improve compile and clean-build medians with identical deploy output; uncertain modules retain the existing transformer. |
+| `0.8.46` | Remove action-only setter fields from authored Context Provider APIs. | Compiler scratch restores required setters while Notes CRUD, RouteIR signals, concrete state operations, diagnostics, and zero Context runtime output pass. |
+| `0.8.47` | Initialize specialized child state from one direct primitive parent state prop. | Build-known primitive seeds, independent state ownership, existing handler specialization, and negative object/expression diagnostics pass without a runtime change. |
 
 ## Sequence Rules
 

package/framework/compiler/source-compiler.mjs

@@ -359,6 +359,7 @@ function createKudzuTransformer({ semantic, handlerUrl, file, sourceFiles, sourc
     const functions = new Map()
     const customHookFunctionsByOwner = new Map()
     const customHookPrivateFields = new WeakMap()
+    const contextProviderPrivateSetters = new WeakMap()
     const components = new Map()
     const contexts = new Set()
     const customHooks = new Map()
@@ -490,7 +491,7 @@ function createKudzuTransformer({ semantic, handlerUrl, file, sourceFiles, sourc
         fields.add(name)
       }
       for (const [setter, state] of states) {
-        if (fields.has(setter) !== fields.has(state)) throw sourceNodeError(value, providerSource, `Context Provider state ${JSON.stringify(state)} and setter ${JSON.stringify(setter)} must be exposed together`)
+        if (fields.has(setter) && !fields.has(state)) throw sourceNodeError(value, providerSource, `Context Provider setter ${JSON.stringify(setter)} requires exposed state ${JSON.stringify(state)}`)
       }
       for (const [name, callback] of callbacks) {
         if (!fields.has(name)) continue
@@ -499,7 +500,7 @@ function createKudzuTransformer({ semantic, handlerUrl, file, sourceFiles, sourc
         if (capture) throw sourceNodeError(callback, providerSource, `Context action ${JSON.stringify(name)} cannot capture private binding ${JSON.stringify(capture)}`)
         for (const state of referencedStateNames(callback.body, states, callback)) {
           const setter = [...states].find(([, candidate]) => candidate === state)?.[0]
-          if (!setter || !fields.has(state) || !fields.has(setter)) throw sourceNodeError(callback, providerSource, `Context action ${JSON.stringify(name)} requires exposed state and setter fields for ${JSON.stringify(state)}`)
+          if (!setter || !fields.has(state)) throw sourceNodeError(callback, providerSource, `Context action ${JSON.stringify(name)} requires exposed state field ${JSON.stringify(state)}`)
         }
       }
       return { callbacks: new Map([...callbacks].filter(([name]) => fields.has(name))), context: true, fields, privateStates: new Set(), stateOwner, stateSymbols, states }
@@ -739,6 +740,32 @@ function createKudzuTransformer({ semantic, handlerUrl, file, sourceFiles, sourc
       ts.forEachChild(node, collect)
     }
     collect(sourceFile)
+    const collectContextProviderPrivateSetters = node => {
+      if (ts.isJsxAttribute(node) && isContextProviderValue(node, contexts)) {
+        const value = node.initializer && ts.isJsxExpression(node.initializer) && node.initializer.expression ? unwrapExpression(node.initializer.expression) : undefined
+        const owner = nearestFunction(node)
+        if (value && ts.isObjectLiteralExpression(value) && owner) {
+          const states = new Map()
+          const callbacks = new Map()
+          const visitOwner = current => {
+            if (ts.isVariableDeclaration(current) && nearestFunction(current) === owner) {
+              if (ts.isArrayBindingPattern(current.name) && current.initializer && ts.isCallExpression(current.initializer) && ts.isIdentifier(current.initializer.expression) && current.initializer.expression.text === "useState") {
+                const [state, setter] = current.name.elements
+                if (current.name.elements.length === 2 && state && setter && ts.isBindingElement(state) && ts.isBindingElement(setter) && ts.isIdentifier(state.name) && ts.isIdentifier(setter.name)) states.set(setter.name.text, state.name.text)
+              }
+              if (ts.isIdentifier(current.name) && current.initializer && (ts.isArrowFunction(current.initializer) || ts.isFunctionExpression(current.initializer))) callbacks.set(current.name.text, current.initializer)
+            }
+            ts.forEachChild(current, visitOwner)
+          }
+          visitOwner(owner.body)
+          const fields = new Set(value.properties.filter(ts.isShorthandPropertyAssignment).map(property => property.name.text))
+          const missing = [...states].filter(([setter, state]) => fields.has(state) && !fields.has(setter) && [...callbacks].some(([name, callback]) => fields.has(name) && referencedStateNames(callback.body, states, callback).has(state))).map(([setter]) => setter)
+          if (missing.length) contextProviderPrivateSetters.set(node, missing)
+        }
+      }
+      ts.forEachChild(node, collectContextProviderPrivateSetters)
+    }
+    collectContextProviderPrivateSetters(sourceFile)
     const functionsForNode = node => {
       const callbacks = customHookFunctionsByOwner.get(nearestFunction(node))
       return callbacks ? new Map([...functions, ...callbacks]) : functions
@@ -1581,6 +1608,11 @@ function createKudzuTransformer({ semantic, handlerUrl, file, sourceFiles, sourc
       return factory.updateJsxExpression(node, factory.createCallExpression(factory.createIdentifier("__kList"), undefined, arguments_))
     }
     const visitor = node => {
+      if (ts.isJsxAttribute(node) && contextProviderPrivateSetters.has(node)) {
+        const expression = unwrapExpression(node.initializer.expression)
+        const value = factory.updateObjectLiteralExpression(expression, [...expression.properties, ...contextProviderPrivateSetters.get(node).map(name => factory.createShorthandPropertyAssignment(name))])
+        return factory.updateJsxAttribute(node, node.name, factory.updateJsxExpression(node.initializer, value))
+      }
       if (ts.isVariableDeclaration(node) && ts.isObjectBindingPattern(node.name) && customHookPrivateFields.has(node)) {
         const privateFields = customHookPrivateFields.get(node)
         return factory.updateVariableDeclaration(node, factory.updateObjectBindingPattern(node.name, [
@@ -2408,10 +2440,12 @@ function specializeComponentCall(call, component, sourceFile, factory, context,
       if (declaration.initializer && ts.isCallExpression(declaration.initializer) && ts.isIdentifier(declaration.initializer.expression) && declaration.initializer.expression.text === "useState") {
         const hookLabel = ordinaryHooks ? "Setter-callback component" : "Keyed row"
         const initialArgument = declaration.initializer.arguments[0]
-        const propReceiver = ordinaryHooks && initialArgument && ts.isCallExpression(initialArgument) && initialArgument.arguments.length === 0 && !initialArgument.questionDotToken && ts.isPropertyAccessExpression(initialArgument.expression) && !initialArgument.expression.questionDotToken && initialArgument.expression.name.text === "toString" && ts.isIdentifier(initialArgument.expression.expression) ? initialArgument.expression.expression : undefined
+        const propReceiver = ordinaryHooks && initialArgument && (ts.isIdentifier(initialArgument) ? initialArgument : ts.isCallExpression(initialArgument) && initialArgument.arguments.length === 0 && !initialArgument.questionDotToken && ts.isPropertyAccessExpression(initialArgument.expression) && !initialArgument.expression.questionDotToken && initialArgument.expression.name.text === "toString" && ts.isIdentifier(initialArgument.expression.expression) ? initialArgument.expression.expression : undefined)
         const substitutedProp = propReceiver ? substitutions.get(propReceiver.text) : undefined
-        const propStringInitializer = substitutedProp && ts.isIdentifier(unwrapExpression(substitutedProp)) && ordinaryStateNames.has(unwrapExpression(substitutedProp).text)
-        if (declaration.initializer.arguments.length !== 1 || !isSerializableStateLiteral(initialArgument) && !propStringInitializer) throw sourceNodeError(declaration.initializer, component.getSourceFile(), `${hookLabel} useState() must use one directly serializable primitive, plain object, or array initial value${ordinaryHooks ? " or direct primitive state prop.toString()" : ""}; other dynamic initializers are not supported`)
+        const substitutedState = substitutedProp && ts.isIdentifier(unwrapExpression(substitutedProp)) ? unwrapExpression(substitutedProp).text : undefined
+        const directProp = ts.isIdentifier(initialArgument)
+        const propInitializer = substitutedState && ordinaryStateNames.has(substitutedState) && (!directProp || hasPrimitiveStateInitializer(call, substitutedState))
+        if (declaration.initializer.arguments.length !== 1 || !isSerializableStateLiteral(initialArgument) && !propInitializer) throw sourceNodeError(declaration.initializer, component.getSourceFile(), `${hookLabel} useState() must use one directly serializable primitive, plain object, or array initial value${ordinaryHooks ? " or direct primitive state prop, optionally followed by .toString()" : ""}; other dynamic initializers are not supported`)
         if (!ts.isArrayBindingPattern(declaration.name) || declaration.name.elements.length !== 2 || declaration.name.elements.some(element => !element || !ts.isBindingElement(element) || !ts.isIdentifier(element.name) || element.initializer || element.dotDotDotToken)) throw sourceNodeError(declaration.name, component.getSourceFile(), `${hookLabel} useState() must use [state, setter] identifier destructuring`)
         const suffix = `${Math.max(0, call.pos)}_${ordinaryHooks ? ordinaryStates.length : rowStates.length}`
         const state = ordinaryHooks ? `__kComponentState${suffix}` : `__kRowState${suffix}`
@@ -2422,7 +2456,11 @@ function specializeComponentCall(call, component, sourceFile, factory, context,
           factory.createBindingElement(undefined, undefined, factory.createIdentifier(state)),
           factory.createBindingElement(undefined, undefined, factory.createIdentifier(setter))
         ])
-        const initialValue = propStringInitializer ? substituteClone(initialArgument, substitutions, factory, context) : cloneAst(initialArgument, factory, context)
+        const initialValue = propInitializer
+          ? ts.isIdentifier(initialArgument)
+            ? factory.createPropertyAccessExpression(cloneAst(substitutedProp, factory, context), "value")
+            : substituteClone(initialArgument, substitutions, factory, context)
+          : cloneAst(initialArgument, factory, context)
         synthesizeTree(initialValue)
         const initializer = factory.createCallExpression(factory.createIdentifier(ordinaryHooks ? "__kComponentUseState" : "__kRowUseState"), undefined, [initialValue])
         hookDeclarations.push(factory.createVariableStatement(undefined, factory.createVariableDeclarationList([factory.createVariableDeclaration(binding, undefined, undefined, initializer)], ts.NodeFlags.Const)))
@@ -2505,6 +2543,20 @@ function isSerializableStateLiteral(node) {
   return value.properties.every(property => ts.isPropertyAssignment(property) && !ts.isComputedPropertyName(property.name) && property.name.text !== "__proto__" && isSerializableStateLiteral(property.initializer))
 }
 
+function hasPrimitiveStateInitializer(call, name) {
+  const owner = nearestFunction(call)
+  if (!owner || !ts.isBlock(owner.body)) return false
+  for (const statement of owner.body.statements) {
+    if (!ts.isVariableStatement(statement)) continue
+    for (const declaration of statement.declarationList.declarations) {
+      if (!ts.isArrayBindingPattern(declaration.name) || !declaration.initializer || !ts.isCallExpression(declaration.initializer) || !ts.isIdentifier(declaration.initializer.expression) || declaration.initializer.expression.text !== "useState") continue
+      const state = declaration.name.elements[0]
+      if (state && ts.isBindingElement(state) && ts.isIdentifier(state.name) && state.name.text === name) return declaration.initializer.arguments.length === 1 && isPrimitiveDefaultLiteral(unwrapExpression(declaration.initializer.arguments[0]))
+    }
+  }
+  return false
+}
+
 function synthesizeSerializableStateLiteral(node, factory) {
   node = unwrapExpression(node)
   if (ts.isStringLiteral(node)) return factory.createStringLiteral(node.text)

package/package.json

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