@kudzujs/core 0.8.18 → 0.8.19

package/MIGRATION_ROADMAP.md

@@ -209,6 +209,13 @@ This queue orders the next investigations by general migration value. Start only
 - Specialized prop records retain default application and direct signal links; imported hook declarations keep source provenance while synthetic ownership invents no source range.
 - `core.mjs` remains authoritative for final route/layout state, ref, ID, conditional, and keyed allocation. Repeated, conditional, imported, setter-adapter, Context, and reducer fixtures preserve their existing ownership and deploy output.
 
+### Completed In 0.8.19
+
+- Native and effect callback exports now finalize into JSON-safe HandlerIR with ordered signals, setters, captures, snapshot policy, imports, roles, source provenance, and generated module source.
+- Reactive bindings, list expressions, and list condition evaluators finalize into BindingIR with explicit states, captures, parameters, imports, and deterministic export slots.
+- Existing tagged collection expressions and selectors are canonical DerivedIR for rendered lists and derived effect dependencies; transformed source embeds the registered records rather than parallel analyzer values.
+- AST, `Map`, and `Set` callback descriptors remain private only until source-local lowering completes. Handler codegen now performs no TypeScript traversal or state/capture/reducer/import discovery, while command-only routes retain zero handler ESM.
+
 ## Cross-Cutting Performance Gates
 
 Every migration feature must preserve:

package/PERFORMANCE.md

@@ -1,5 +1,51 @@
 # Performance Records
 
+## 0.8.19 Handler, Binding, And Derived IR
+
+Measured UTC 2026-08-08 on Apple M3, 8 logical CPUs, 8 GiB RAM, macOS 26.5.2 / Darwin 25.5.0, Node 25.6.1, and npm 11.18.0. Baseline `0.8.18` tag `3598be0` and the `0.8.19` compiler-only candidate used detached worktrees on the same temporary volume with identical installed dependencies.
+
+The candidate compiler patch over `3598be0` had SHA-256 `7b2afc4c9a0d1963c8d3ccacfb1e95152136d77cc7afc250d17b1986ca329fb3`, produced by:
+
+```bash
+git diff --binary 3598be0 -- framework/build.mjs framework/compiler/descriptor-session.mjs framework/compiler/handler-codegen.mjs framework/compiler/handler-lowering.mjs framework/compiler/ir/module-ir.mjs | shasum -a 256
+```
+
+Both targets received one warm-up followed by 21 clean `worker-effects` production builds in round-robin alternating order. Cleanup remained outside timing. The distributions overlap; the candidate median was 0.32% lower and does not establish a material change.
+
+| Target | Build median | Worker raw / gzip | Window raw / gzip |
+|---|---:|---:|---:|
+| 0.8.18 baseline | 253.4 ms | 907 B / 475 B | 12,148 B / 5,427 B |
+| 0.8.19 candidate | 252.6 ms | 907 B / 475 B | 12,148 B / 5,427 B |
+
+```text
+0.8.18: [252.3,254.5,251.0,254.8,254.3,253.8,253.4,251.6,255.4,252.4,249.6,254.2,251.0,253.7,256.0,250.4,251.0,255.4,253.3,253.6,250.5]
+0.8.19: [252.3,251.7,252.9,251.9,251.5,253.0,252.3,251.3,253.0,252.1,254.3,258.4,249.8,251.6,256.2,253.7,253.5,252.6,252.9,252.5,255.9]
+```
+
+Before release-content updates, the complete site `dist` was byte-identical. Representative fixture builds retained identical file lists and SHA-256 content; `.kudzu` comparisons replaced only each detached worktree's absolute root in existing source-location strings. The complete fixture lists were:
+
+```text
+bindings: dist/assets/handlers/pages/index.js, dist/assets/kudzu-binding.js, dist/assets/kudzu-serialization.js, dist/assets/kudzu-style.js, dist/assets/kudzu.js, dist/index.html, .kudzu/kudzu-plan.json, .kudzu/pages/index.mjs
+native: dist/assets/handlers/pages/index.js, dist/assets/handlers/pages/other/index.js, dist/assets/kudzu-native.js, dist/assets/kudzu-serialization.js, dist/assets/kudzu.js, dist/assets/native/index.js, dist/assets/native/other/index.js, dist/index.html, dist/other/index.html, .kudzu/helpers.mjs, .kudzu/kudzu-plan.json, .kudzu/math.mjs, .kudzu/pages/index.mjs, .kudzu/pages/other/index.mjs
+reducer: dist/assets/handlers/pages/index.js, dist/assets/handlers/pages/lazy.js, dist/assets/kudzu-binding.js, dist/assets/kudzu-list.js, dist/assets/kudzu-native.js, dist/assets/kudzu-serialization.js, dist/assets/kudzu-style.js, dist/assets/kudzu.js, dist/assets/native/index.js, dist/index.html, dist/lazy/index.html, .kudzu/ImportedControls.mjs, .kudzu/ImportedInput.mjs, .kudzu/ImportedItem.mjs, .kudzu/kudzu-plan.json, .kudzu/pages/index.mjs, .kudzu/pages/lazy.mjs, .kudzu/todoReducer.mjs, .kudzu/todoSupport.mjs
+context-actions: dist/assets/handlers/pages/index.js, dist/assets/kudzu-list.js, dist/assets/kudzu-native.js, dist/assets/kudzu-serialization.js, dist/assets/kudzu.js, dist/assets/native/index.js, dist/index.html, dist/static/index.html, .kudzu/kudzu-plan.json, .kudzu/notes.mjs, .kudzu/pages/index.mjs, .kudzu/pages/static.mjs, .kudzu/useNotes.mjs
+zustand-migration: dist/assets/handlers/Shell.js, dist/assets/handlers/pages/cart.js, dist/assets/handlers/pages/index.js, dist/assets/kudzu-binding.js, dist/assets/kudzu-native.js, dist/assets/kudzu-navigation.js, dist/assets/kudzu-serialization.js, dist/assets/kudzu-style.js, dist/assets/kudzu.js, dist/assets/native/cart/index.js, dist/assets/native/index.js, dist/cart/index.html, dist/index.html, .kudzu/Shell.mjs, .kudzu/kudzu-plan.json, .kudzu/pages/cart.mjs, .kudzu/pages/index.mjs, .kudzu/store.mjs
+event-package: dist/assets/handlers/pages/index.js, dist/assets/kudzu-native.js, dist/assets/kudzu-serialization.js, dist/assets/kudzu.js, dist/assets/native/index.js, dist/index.html, .kudzu/kudzu-plan.json, .kudzu/pages/index.mjs
+list-expressions: dist/assets/handlers/pages/index.js, dist/assets/kudzu-list.js, dist/assets/kudzu.js, dist/index.html, .kudzu/kudzu-plan.json, .kudzu/pages/index.mjs
+effect-dependencies: dist/assets/effects/index.js, dist/assets/handlers/pages/index.js, dist/assets/kudzu-collection-selector.js, dist/assets/kudzu-deps.js, dist/assets/kudzu-effect.js, dist/assets/kudzu-serialization.js, dist/assets/kudzu.js, dist/command/index.html, dist/index.html, .kudzu/kudzu-plan.json, .kudzu/pages/command.mjs, .kudzu/pages/index.mjs
+landing-page-migration: dist/assets/assets/badge.png, dist/assets/assets/hero.svg, dist/assets/assets/landing.woff2, dist/assets/assets/module-mark.svg, dist/assets/assets/preview.webp, dist/assets/handlers/pages/index.js, dist/assets/kudzu-binding.js, dist/assets/kudzu-native.js, dist/assets/kudzu-serialization.js, dist/assets/kudzu-style.js, dist/assets/kudzu.js, dist/assets/native/index.js, dist/assets/styles/Hero.module.css, dist/assets/styles/landing.css, dist/index.html, dist/static/index.html, .kudzu/LandingSections.mjs, .kudzu/kudzu-plan.json, .kudzu/pages/index.mjs, .kudzu/pages/static.mjs
+```
+
+This measurement covers compiler clean-build startup and artifact size, not browser interaction latency or cross-framework performance.
+
+The recorded cleanup, warm-up, and alternating 21-run loop is reproducible with:
+
+```bash
+BASELINE_ROOT="/private/var/folders/bt/3r_ntp5x65j81brs6_p93rl00000gn/T/opencode/kudzu-0819-baseline" CANDIDATE_ROOT="/var/folders/bt/3r_ntp5x65j81brs6_p93rl00000gn/T/opencode/kudzu-0.8.19-candidate" node --input-type=module -e 'import { spawnSync } from "node:child_process"; import { rmSync } from "node:fs"; import { performance } from "node:perf_hooks"; import { resolve } from "node:path"; const roots={baseline:process.env.BASELINE_ROOT,candidate:process.env.CANDIDATE_ROOT}; const runs={baseline:[],candidate:[]}; const build=name=>{const root=roots[name],fixture=resolve(root,"test/fixtures/worker-effects"); rmSync(resolve(fixture,"dist"),{recursive:true,force:true}); rmSync(resolve(fixture,".kudzu"),{recursive:true,force:true}); const start=performance.now(); const result=spawnSync(process.execPath,[resolve(root,"bin/kudzu.mjs"),"build"],{cwd:fixture,encoding:"utf8"}); if(result.status!==0) throw new Error(result.stderr||result.stdout); return Number((performance.now()-start).toFixed(1));}; build("baseline"); build("candidate"); for(let index=0;index<21;index++) for(const name of index%2?["candidate","baseline"]:["baseline","candidate"]) runs[name].push(build(name)); console.log(JSON.stringify(runs));'
+```
+
+The complete `worker-effects` benchmark list was: `dist/assets/effects/dashboard/index.js`, `dist/assets/handlers/pages/dashboard.js`, `dist/assets/kudzu-effect.js`, `dist/assets/kudzu-navigation.js`, `dist/assets/kudzu.js`, `dist/assets/workers/telemetry.worker-BVG2SA55.js`, `dist/dashboard/index.html`, `dist/plain/index.html`, `dist/static/index.html`, `.kudzu/Shell.mjs`, `.kudzu/chart.mjs`, `.kudzu/kudzu-plan.json`, `.kudzu/pages/dashboard.mjs`, `.kudzu/pages/plain.mjs`, `.kudzu/pages/static.mjs`, `.kudzu/telemetry/downsample.mjs`, and `.kudzu/telemetry/ring.mjs`.
+
 ## 0.8.18 Explicit Component Ownership
 
 Measured UTC 2026-08-08 on Apple M3, 8 logical CPUs, 8 GiB RAM, macOS 26.5.2 / Darwin 25.5.0, Node 25.6.1, and npm 11.18.0. Baseline `0.8.17` tag `d48f0cf` and the `0.8.18` compiler-only candidate used detached worktrees on the same temporary volume with identical installed dependencies.

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.18 - Explicit component ownership.** Source analysis now records JSON-safe state, setter, prop, ref, ID, and specialization ownership while final route state allocation remains unchanged. Read the [release notes](./RELEASES.md#0818---explicit-component-ownership), open the [release page](https://kudzujs.cloud/releases/0.8.18), or follow the [next architecture packet](./docs/next-architecture/README.md).
+**Latest release: 0.8.19 - Handler, binding, and derived IR.** Native callbacks, reactive bindings, list evaluators, imports, and pure derived expressions now cross one JSON-safe ModuleIR boundary before source-only artifact codegen. Read the [release notes](./RELEASES.md#0819---handler-binding-and-derived-ir), open the [release page](https://kudzujs.cloud/releases/0.8.19), or follow the [next 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,38 @@
 # Kudzu Releases
 
+## 0.8.19 - Handler, binding, and derived IR
+
+Kudzu 0.8.19 completes the next Goal A source-analysis boundary: native callbacks, reactive bindings, list evaluators, imports, and pure derived expressions now finalize into JSON-safe ModuleIR before mechanical artifact codegen.
+
+### Changed in 0.8.19
+
+- Native and effect callback exports retain explicit roles, signals, setters, captures, snapshot policy, imports, source ranges, and finalized export source in HandlerIR.
+- Reactive bindings, list expressions, and list condition evaluators retain explicit states, captures, parameters, imports, and deterministic module-export slots in BindingIR.
+- Rendered list selectors and derived effect dependencies use the existing tagged collection-expression language as canonical DerivedIR; transformed build source reads back the registered records.
+- Reducer, Context, Zustand, package-import, nested snapshot, and scope semantics finish lowering while source AST and diagnostics are still available.
+- `handler-codegen.mjs` imports no TypeScript or AST helpers. It renders the finalized ordered imports and concatenates generated HandlerIR/BindingIR export source.
+- The previous semantic artifact arrays containing callback/expression AST, `Map`, and `Set` values were deleted. They remain only inside the source-local session until finalization and do not cross the IR boundary.
+
+### Goal A boundary
+
+- Effect lifetime, cleanup, dependencies, Worker edges, and ownership remain on the existing path until EffectIR in `0.8.21`; only their generated callback exports join HandlerIR now.
+- Keyed DOM ownership remains on the existing path until KeyedBlockIR in `0.8.20`; list evaluators and pure selectors are explicit without moving key-path ownership early.
+- `core.mjs` remains authoritative for complete HTML, final route/layout state IDs, and the serializable route plan.
+- No accepted syntax, public API, runtime capability, VDOM, hydration, component rerender, or retained browser component tree was added.
+
+### Validation
+
+- The complete suite passes 167/167 tests, including ModuleIR JSON round-trip, command-only exclusion, native async handlers, bindings, package imports, reducer, Context, Zustand, list-derived, and effect-derived contracts.
+- Before release-content updates, the complete site `dist` and nine representative fixture output trees matched `v0.8.18`; detached-worktree roots were normalized only in existing `.kudzu` diagnostic strings.
+- Worker and window graphs remain byte-identical. A same-volume 21-run interleaved comparison measured a 0.32% lower candidate median; raw arrays, file lists, and environment are recorded in `PERFORMANCE.md`.
+- `create-kudzu` remains 0.1.101 because its unchanged template already accepts `@kudzujs/core@^0.8.15`.
+
+### Upgrade
+
+```bash
+npm install @kudzujs/core@^0.8.19
+```
+
 ## 0.8.18 - Explicit component ownership
 
 Kudzu 0.8.18 completes the next Goal A source-analysis seam: state, setters, props, refs, IDs, and supported component specializations now have one ordered JSON-safe ownership result without changing final route allocation or deploy behavior.

package/docs/next-architecture/README.md

@@ -6,7 +6,7 @@ The top-level [`GOAL_A.md`](../../GOAL_A.md) and [`GOAL_B.md`](../../GOAL_B.md)
 
 | Goal | Decision | Start condition |
 |---|---|---|
-| A: compiler foundation | `0.8.18` component ownership result complete | Continue with `0.8.19` HandlerIR, BindingIR, and DerivedIR after the release boundary. |
+| A: compiler foundation | `0.8.19` handler/binding/derived IR complete | Continue with `0.8.20` KeyedBlockIR ownership after the release boundary. |
 | B: optimization benchmarks | Deferred | Goal A complete and its output baseline recorded |
 | 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 |

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

@@ -1,6 +1,6 @@
 # Current Compiler Architecture
 
-This maps the completed `0.8.18` component ownership boundary. File and function names are the stable references; line numbers are intentionally omitted because Goal A moves code.
+This maps the completed `0.8.19` handler, binding, and derived IR boundary. File and function names are the stable references; line numbers are intentionally omitted because Goal A moves code.
 
 ## Responsibility Map
 
@@ -13,12 +13,13 @@ This maps the completed `0.8.18` component ownership boundary. File and function
 | Focused normalization passes | [`framework/compiler/`](../../framework/compiler/) | React, Router, browser signals, animation-frame refs, custom-hook timers, Zustand, and render control each validate and lower a narrow source shape. |
 | Shared AST/scope helpers | [`framework/compiler/ast-helpers.mjs`](../../framework/compiler/ast-helpers.mjs) | Binding, scope, reference, effect-return, and source-location analysis. |
 | 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/build.mjs`, `createKudzuTransformer()` | Produces transformed source and the explicit component ownership result while still owning effects, keyed-list ownership, imports, reactive JSX, and their remaining AST-identity side tables. |
+| Main semantic analysis | `framework/build.mjs`, `createKudzuTransformer()` | Produces transformed source plus explicit component, handler, binding, and derived results while still owning effect and keyed-list ownership side tables. |
 | Component ownership analysis | [`framework/compiler/analysis/component-analysis.mjs`](../../framework/compiler/analysis/component-analysis.mjs) | Retains ordered JSON-safe owner and specialization records for state, setters, props, refs, IDs, direct signal links, and source provenance; 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()` | Registers deterministic component analysis, native handler, effect handler, binding, list evaluator, and client-import results into one source-local artifact. |
+| Per-source descriptor registration | [`framework/compiler/descriptor-session.mjs`](../../framework/compiler/descriptor-session.mjs), `createSemanticArtifact()`, `createDescriptorSession()` | Keeps AST descriptors private during analysis, then finalizes deterministic JSON-safe HandlerIR, BindingIR, DerivedIR, imports, and client roots into ModuleIR. |
 | Command IR and codegen | [`framework/compiler/optimize/command-specialization.mjs`](../../framework/compiler/optimize/command-specialization.mjs), [`framework/compiler/ir/module-ir.mjs`](../../framework/compiler/ir/module-ir.mjs), [`framework/compiler/codegen/command-codegen.mjs`](../../framework/compiler/codegen/command-codegen.mjs) | Supported command handlers specialize to JSON-safe ModuleIR, then emit the existing `__kBehavior` AST without changing route plans. |
 | Build module generation | `framework/build.mjs`, `compile()` | Runs TypeScript with the Kudzu transformer, writes build-executable modules to `.kudzu`, rejects surviving React/Router runtime references, and generates handler source when descriptors exist. |
-| Handler/evaluator codegen | [`framework/compiler/handler-codegen.mjs`](../../framework/compiler/handler-codegen.mjs) | Converts descriptor AST into browser ESM exports and rewrites state, setter, reducer, capture, and imported-helper reads. It does not discover features. |
+| Handler/evaluator lowering | [`framework/compiler/handler-lowering.mjs`](../../framework/compiler/handler-lowering.mjs) | Completes source-local callback/binding/list AST rewriting and diagnostics before the JSON-safe IR boundary. |
+| Handler module codegen | [`framework/compiler/handler-codegen.mjs`](../../framework/compiler/handler-codegen.mjs) | Renders finalized ordered imports and concatenates generated module-export source without TypeScript AST or semantic discovery. |
 | Worker graph | [`framework/compiler/worker-compiler.mjs`](../../framework/compiler/worker-compiler.mjs) | Validates the exact effect-owned Worker form, validates its relative graph, emits content-hashed ESM, and resolves placeholders only for rendered effects. |
 | Build-time JSX execution | [`framework/core.mjs`](../../framework/core.mjs), `renderPage()` | Executes compiled pages/layouts, allocates deterministic route/layout ownership IDs, emits complete HTML, and returns the serializable route plan and capability booleans. |
 | Route capability projection | [`framework/compiler/route-capability-planner.mjs`](../../framework/compiler/route-capability-planner.mjs), `planRouteCapabilities()` | Purely folds rendered route plans and route facts into aggregate runtime/artifact requirements. |
@@ -57,7 +58,7 @@ The browser consumes static HTML first. State seeds and descriptors in that HTML
 ## Current Coupling To Remove
 
 - `createKudzuTransformer()` combines discovery, validation, specialization, descriptor registration, and transformed-source emission.
-- Effect/list relationships and transient component rewrite indexes remain in `WeakMap`/`WeakSet` tables keyed by AST identity; component ownership itself now has an explicit JSON-safe source result.
+- Effect/keyed ownership relationships and transient component rewrite indexes remain in `WeakMap`/`WeakSet` tables keyed by AST identity; handler, binding, derived, and component ownership now have explicit JSON-safe source results.
 - `build()` destructures a broad capability manifest into many booleans and performs artifact-specific source surgery.
 - Runtime specialization relies on exact source-string and regular-expression replacements in `framework/build.mjs`.
 - Route facts, rendered plans, artifact requirements, and emitted-file decisions are represented at adjacent but not fully explicit boundaries.

package/docs/next-architecture/goal-a-compiler-foundation.md

@@ -2,7 +2,7 @@
 
 ## Status
 
-The `0.8.18` state/props/component ownership result is complete. Goal A continues with the planned `0.8.19` HandlerIR, BindingIR, and DerivedIR seam while preserving accepted React-shaped syntax, diagnostics, complete HTML, emitted capability behavior, and current public APIs.
+The `0.8.19` HandlerIR, BindingIR, and DerivedIR seam is complete. Goal A continues with the planned `0.8.20` KeyedBlockIR ownership result while preserving accepted React-shaped syntax, diagnostics, complete HTML, emitted capability behavior, and current public APIs.
 
 ## Target Boundaries
 
@@ -77,7 +77,7 @@ Analysis produces plain data:
 }
 ```
 
-The `0.8.18` source result adds ordered JSON-safe component ownership beside ModuleIR: lexical state/setter pairs, props, refs, IDs, and supported specialization records carry numeric slots, direct signal links, and source provenance. Initial values, final state IDs, bindings, derived values, effects, and keyed blocks join their explicit results in later planned patches; `core.mjs` remains authoritative for route allocation today.
+The `0.8.19` source result adds module-export HandlerIR, BindingIR, ordered imports/client roots, and canonical tagged DerivedIR beside command and component ownership. Source-local AST lowering completes before this boundary; artifact codegen consumes finalized records without semantic traversal. Initial values, final state IDs, effect ownership, and keyed blocks join their explicit results in later planned patches; `core.mjs` remains authoritative for route allocation today.
 
 Source codegen lowers that data through the existing build ABI:
 

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.18` are completed scopes represented by package/release records; later rows remain planned until their package version and release record exist.
+This is an execution sequence, not release history. `0.8.16` through `0.8.19` are completed scopes represented by package/release records; later rows remain planned until their package version and release record exist.
 
 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.
 

package/framework/README.md

@@ -36,13 +36,14 @@ Reduced Zustand migration stores lower to one ordinary layout-lifetime state slo
 - `compiler/animation-frame-pass.mjs`: effect-owned animation-frame ref validation and plain mutable effect-scope lowering.
 - `compiler/browser-signal-passes.mjs`: static media-query external-store and navigator capability-condition normalization.
 - `compiler/collection-analysis.mjs`: pure collection expression IR, selector pipeline, alias, and imported-transform analysis.
-- `compiler/descriptor-session.mjs`: per-source semantic artifact creation and deterministic command, handler, effect, binding, and list evaluator descriptor registration.
+- `compiler/descriptor-session.mjs`: private source-local descriptor registration and deterministic JSON-safe HandlerIR, BindingIR, DerivedIR, import, and client-root finalization.
 - `compiler/normalization-pipeline.mjs`: ordered source normalization with parent-pointer repair after every compiler pass.
 - `compiler/react-migration-pass.mjs`: React import, memo, callback, `forwardRef`, and `useId` migration validation and lowering.
 - `compiler/custom-hook-timer-pass.mjs`: private custom-hook timeout-ref validation and compiler-owned timer-state lowering.
 - `compiler/effect-codegen.mjs`: route-specific ordinary, owned, and navigable effect entry generation.
 - `compiler/optimize/command-specialization.mjs`, `compiler/ir/module-ir.mjs`, and `compiler/codegen/command-codegen.mjs`: JSON-safe command analysis, sparse per-source ModuleIR, and source-analysis-free existing behavior-call generation.
-- `compiler/handler-codegen.mjs`: route-specific native handler, reactive binding, keyed-list evaluator, and client-import module source generation.
+- `compiler/handler-lowering.mjs`: source-local native/effect callback, reducer, Context, Zustand, reactive-binding, and list-evaluator AST lowering before IR finalization.
+- `compiler/handler-codegen.mjs`: AST-free ordered import rendering and finalized handler/binding export-source assembly.
 - `compiler/render-control-pass.mjs`: render-function early-return and exhaustive adjacent-assignment normalization.
 - `compiler/router-pass.mjs`: React Router import validation and native Link, pathname parameter, search parameter, and imperative navigation lowering.
 - `compiler/route-capability-planner.mjs`: pure route-plan projection into runtime and artifact capability requirements.

package/framework/build.mjs

@@ -13,6 +13,7 @@ import { normalizeCustomHookTimerRefs } from "./compiler/custom-hook-timer-pass.
 import { captureNames, createDescriptorSession, createSemanticArtifact, nativeCaptureNames, referencedReducerDispatches, referencedStateNames } from "./compiler/descriptor-session.mjs"
 import { createEffectCodegen } from "./compiler/effect-codegen.mjs"
 import { createHandlerCodegen } from "./compiler/handler-codegen.mjs"
+import { createHandlerLowering } from "./compiler/handler-lowering.mjs"
 import { createCommandSpecializer } from "./compiler/optimize/command-specialization.mjs"
 import { applyNormalizationPasses } from "./compiler/normalization-pipeline.mjs"
 import { createReactMigrationPass, reactMemoExpression } from "./compiler/react-migration-pass.mjs"
@@ -704,18 +705,18 @@ async function compile(file, sourceFiles, sourceIndex, staticFiles, importedAsse
   await mkdir(resolve(output, ".."), { recursive: true })
   await writeFile(output, result.outputText)
 
-  const { componentAnalysis, nativeHandlers, effectHandlers, reactiveBindings, listExpressions, clientImports } = semantic
-  const sourceResult = { file: relative(root, file).replaceAll(sep, "/"), componentAnalysis }
-  if (!nativeHandlers.length && !effectHandlers.length && !reactiveBindings.length && !listExpressions.length) return sourceResult
-  const callbacks = [...nativeHandlers, ...effectHandlers]
-  const moduleSource = printHandlerModule({ callbacks, reactiveBindings, listExpressions, handlerPath })
+  const { componentAnalysis, moduleIR } = semantic
+  const sourceResult = { file: relative(root, file).replaceAll(sep, "/"), componentAnalysis, moduleIR }
+  const moduleHandlers = moduleIR.handlers.filter(handler => handler.kind === "module-export")
+  if (!moduleHandlers.length && !moduleIR.bindings.length) return sourceResult
+  const moduleSource = printHandlerModule({ moduleIR, handlerPath })
   const moduleResult = ts.transpileModule(moduleSource, {
     compilerOptions: { target: ts.ScriptTarget.ES2022, module: ts.ModuleKind.ESNext },
     reportDiagnostics: true
   })
   const moduleErrors = moduleResult.diagnostics?.filter(diagnostic => diagnostic.category === ts.DiagnosticCategory.Error) ?? []
   if (moduleErrors.length) throw new Error(moduleErrors.map(error => ts.flattenDiagnosticMessageText(error.messageText, "\n")).join("\n"))
-  sourceResult.handlerModule = { path: handlerPath, code: moduleResult.outputText, hasNativeHandlers: nativeHandlers.length > 0, hasEffects: effectHandlers.length > 0, clientImports: [...clientImports], hasPackageImports: [...callbacks, ...reactiveBindings].some(entry => entry.imports?.some(import_ => import_.package)) }
+  sourceResult.handlerModule = { path: handlerPath, code: moduleResult.outputText, hasNativeHandlers: moduleHandlers.some(handler => handler.role === "native"), hasEffects: moduleHandlers.some(handler => handler.role === "effect"), clientImports: moduleIR.clientModules, hasPackageImports: moduleIR.imports.some(entry => entry.package) }
   return sourceResult
 }
 
@@ -882,7 +883,7 @@ function normalizeCompilerSource(sourceFile, { base, context, file, importedColl
 }
 
 function createKudzuTransformer({ semantic, handlerUrl, file, sourceFiles, sourceIndex, staticFiles, importedAssets, cssModules, base, workerReferences }) {
-  const { nativeHandlers, effectHandlers } = semantic
+  const { moduleIR } = semantic
   return context => sourceFile => {
     const hasLinkElements = /<link/i.test(sourceFile.text)
     const importedStaticCollections = importedSerializableCollections(sourceFile, file, sourceFiles, sourceIndex)
@@ -899,6 +900,7 @@ function createKudzuTransformer({ semantic, handlerUrl, file, sourceFiles, sourc
       factory,
       context,
       compileEventCommand,
+      handlerLowering,
       isPrimitiveLiteral: isPrimitiveDefaultLiteral,
       sourceName,
       rejectWorkerConstructions: expression => workerCompiler.rejectConstructions(expression, expression.getSourceFile(), "Relative TypeScript Worker construction is only supported directly inside an inline useEffect() callback")
@@ -2118,7 +2120,7 @@ function createKudzuTransformer({ semantic, handlerUrl, file, sourceFiles, sourc
         }
         const invalidDependency = ordinaryDependencies.find(dependency => !ts.isIdentifier(dependency))
         if (invalidDependency) effectFail(invalidDependency, "useEffect() dependencies must be direct state or runtime parameter identifiers")
-        const dependencyExpressions = []
+        const dependencyDerived = []
         const dependencyStates = new Map()
         const dependencySubstitutions = new Map()
         const subscriptionDependencies = []
@@ -2134,7 +2136,7 @@ function createKudzuTransformer({ semantic, handlerUrl, file, sourceFiles, sourc
             const usedStates = new Set()
             const expression = collectionExpression(initializer, { fail: effectFail, stateNames, selectorStates: usedStates })
             if (!usedStates.size) effectFail(dependency, `useEffect() derived dependency "${dependency.text}" must read direct primitive state`)
-            dependencyExpressions.push(expression)
+            dependencyDerived.push({ expression, states: usedStates, source: initializer })
             for (const name of usedStates) {
               subscriptionDependencies.push(factory.createIdentifier(name))
               dependencyStates.set(name, factory.createIdentifier(name))
@@ -2143,12 +2145,12 @@ function createKudzuTransformer({ semantic, handlerUrl, file, sourceFiles, sourc
             hasDerivedDependency = true
           } else {
             subscriptionDependencies.push(dependency)
-            dependencyExpressions.push(["state", dependency.text])
+            dependencyDerived.push({ expression: ["state", dependency.text], states: [dependency.text], source: dependency })
             dependencyStates.set(dependency.text, dependency)
           }
         }
         if (!hasDerivedDependency) {
-          dependencyExpressions.length = 0
+          dependencyDerived.length = 0
           dependencyStates.clear()
         }
         if (!effectOwner) fail(node, "useEffect() cannot be used outside a Kudzu component")
@@ -2200,6 +2202,7 @@ function createKudzuTransformer({ semantic, handlerUrl, file, sourceFiles, sourc
         for (const reference of workerReferences.slice(workerStart)) Object.assign(reference, { module: handlerUrl, handler: descriptor.exportName })
         usesListItem ||= Boolean(itemDependencies.length && !listEffect)
         usesBehavior = true
+        const derivedDependencies = hasDerivedDependency ? dependencyDerived.map(entry => descriptors.registerDerived("expression", entry.expression, entry.states, entry.source)) : []
         return factory.updateCallExpression(node, node.expression, node.typeArguments, [
           callback,
           factory.createArrayLiteralExpression(hasDerivedDependency ? subscriptionDependencies : ordinaryDependencies),
@@ -2210,7 +2213,7 @@ function createKudzuTransformer({ semantic, handlerUrl, file, sourceFiles, sourc
           factory.createStringLiteral(specializedEffect ? sourceLocation(specializedEffect.source, specializedEffect.sourceFile) : sourceLocation(node, sourceFile)),
           returns.cleanup ? factory.createTrue() : factory.createFalse(),
           factory.createArrayLiteralExpression(itemDependencies.map(field => factory.createStringLiteral(field))),
-          hasDerivedDependency ? jsonExpression(dependencyExpressions, factory) : factory.createArrayLiteralExpression(),
+          hasDerivedDependency ? jsonExpression(derivedDependencies.map(entry => entry.expression), factory) : factory.createArrayLiteralExpression(),
           factory.createArrayLiteralExpression([...dependencyStates].map(([name, state]) => factory.createArrayLiteralExpression([factory.createStringLiteral(name), state])))
         ])
       }
@@ -2278,12 +2281,13 @@ function createKudzuTransformer({ semantic, handlerUrl, file, sourceFiles, sourc
             usesBinding = true
             listSource = descriptors.compileReactiveBinding(listParts.calculation, { setters: settersForNode(node, settersByFunction), importBindings })
           }
+          const selector = listParts.selector?.length ? descriptors.registerDerived("selector", listParts.selector, listParts.selectorStates, node).selector : listParts.selector ?? []
           const arguments_ = [
             listSource,
             listParts.keyField === null ? factory.createNull() : factory.createStringLiteral(listParts.keyField),
             visitWithStateOwners(listParts.callback, listParts.analysisStateOwners ?? new Map()),
             factory.createStringLiteral(listParts.ownerField ?? ""),
-            jsonExpression(listParts.selector ?? [], factory),
+            jsonExpression(selector, factory),
             listParts.indexed ? factory.createTrue() : factory.createFalse()
           ]
           if (listParts.selectorStates?.size || listParts.static) arguments_.push(factory.createArrayLiteralExpression([...(listParts.selectorStates ?? [])].map(name => factory.createArrayLiteralExpression([factory.createStringLiteral(name), factory.createIdentifier(name)]))))
@@ -2344,10 +2348,11 @@ function createKudzuTransformer({ semantic, handlerUrl, file, sourceFiles, sourc
     }
 
     const transformed = ts.visitNode(sourceFile, visitor)
+    descriptors.finalize()
     if (!usesBehavior) return transformed
 
     const behaviorImports = [factory.createImportSpecifier(false, factory.createIdentifier("behavior"), factory.createIdentifier("__kBehavior"))]
-    if (nativeHandlers.length) behaviorImports.push(factory.createImportSpecifier(false, factory.createIdentifier("nativeBehavior"), factory.createIdentifier("__kNativeBehavior")))
+    if (moduleIR.handlers.some(handler => handler.kind === "module-export" && handler.role === "native")) behaviorImports.push(factory.createImportSpecifier(false, factory.createIdentifier("nativeBehavior"), factory.createIdentifier("__kNativeBehavior")))
     if (usesBinding) {
       behaviorImports.push(factory.createImportSpecifier(false, factory.createIdentifier("binding"), factory.createIdentifier("__kBinding")))
       behaviorImports.push(factory.createImportSpecifier(false, factory.createIdentifier("select"), factory.createIdentifier("__kSelect")))
@@ -3885,9 +3890,8 @@ const workerCompiler = createWorkerCompiler({
 })
 
 const printEffectEntry = createEffectCodegen({ assetPath, inlineJson, relativeModulePath })
+const handlerLowering = createHandlerLowering({ cloneAst, synthesizeTree })
 const printHandlerModule = createHandlerCodegen({
-  cloneAst,
-  synthesizeTree,
   resolveClientImport: (entry, handlerPath) => entry.package ? entry.target : relativeModulePath(handlerPath, clientModulePath(entry.target))
 })
 const { normalizeReactMigrationSyntax, validateUseIdSyntax } = createReactMigrationPass({ cloneAst, jsxTagName })

package/framework/compiler/descriptor-session.mjs

@@ -2,17 +2,23 @@ import ts from "typescript"
 import { createComponentAnalysis } from "./analysis/component-analysis.mjs"
 import { bindingNames, isFunctionLike, isReferenceIdentifier, isShadowedByParameter, isShadowedIdentifier, unwrapExpression } from "./ast-helpers.mjs"
 import { generateCommandBehavior } from "./codegen/command-codegen.mjs"
-import { createModuleIR, registerCommandHandler } from "./ir/module-ir.mjs"
+import { createModuleIR, registerBinding, registerCommandHandler, registerDerived, registerModuleHandler } from "./ir/module-ir.mjs"
 
 export function createSemanticArtifact(file) {
-  return { componentAnalysis: createComponentAnalysis(file), moduleIR: createModuleIR(file), nativeHandlers: [], effectHandlers: [], reactiveBindings: [], listExpressions: [], clientImports: new Set() }
+  return { componentAnalysis: createComponentAnalysis(file), moduleIR: createModuleIR(file) }
 }
 
-export function createDescriptorSession({ semantic, handlerUrl, factory, context, compileEventCommand, isPrimitiveLiteral, rejectWorkerConstructions, sourceName = source => source.fileName }) {
-  const { moduleIR, nativeHandlers, effectHandlers, reactiveBindings, listExpressions, clientImports } = semantic
+export function createDescriptorSession({ semantic, handlerUrl, factory, context, compileEventCommand, handlerLowering, isPrimitiveLiteral, rejectWorkerConstructions, sourceName = source => source.fileName }) {
+  const { moduleIR } = semantic
+  const nativeHandlers = []
+  const effectHandlers = []
+  const reactiveBindings = []
+  const listExpressions = []
+  const clientModules = new Set()
+
   function compileListExpression(read, expression, item, index, states = new Set()) {
     const exportName = `listExpression${listExpressions.length}`
-    listExpressions.push({ exportName, expression, item, index, states })
+    listExpressions.push({ exportName, expression, item, index, states, role: "list-expression" })
     const arguments_ = [read, factory.createStringLiteral(handlerUrl), factory.createStringLiteral(exportName)]
     if (states.size) arguments_.push(factory.createArrayLiteralExpression([...states].map(name => factory.createArrayLiteralExpression([factory.createStringLiteral(name), factory.createIdentifier(name)]))))
     return factory.createCallExpression(factory.createIdentifier("__kListExpression"), undefined, arguments_)
@@ -20,7 +26,7 @@ export function createDescriptorSession({ semantic, handlerUrl, factory, context
 
   function compileListConditional(entry) {
     const exportName = `listExpression${listExpressions.length}`
-    listExpressions.push({ exportName, expression: entry.condition, item: entry.item, index: entry.index })
+    listExpressions.push({ exportName, expression: entry.condition, item: entry.item, index: entry.index, role: "list-conditional" })
     const read = factory.createArrowFunction(undefined, undefined, [], undefined, factory.createToken(ts.SyntaxKind.EqualsGreaterThanToken), entry.condition)
     const thunk = branch => factory.createArrowFunction(undefined, undefined, [], undefined, factory.createToken(ts.SyntaxKind.EqualsGreaterThanToken), branch)
     return factory.createCallExpression(factory.createIdentifier("__kListConditional"), undefined, [
@@ -65,7 +71,7 @@ export function createDescriptorSession({ semantic, handlerUrl, factory, context
     registerClientImports(imports)
     const captures = new Set([...captureNames(expression, expression, setters)].filter(name => !importedNames.has(name)))
     const exportName = `binding${reactiveBindings.length}`
-    reactiveBindings.push({ exportName, expression, captures, states: usedStates, imports })
+    reactiveBindings.push({ exportName, expression, captures, states: usedStates, imports, role: "binding" })
     const states = [...usedStates].map(name => factory.createArrayLiteralExpression([factory.createStringLiteral(name), factory.createIdentifier(name)]))
     const scope = [...captures].map(name => factory.createArrayLiteralExpression([factory.createStringLiteral(name), factory.createIdentifier(name)]))
     const stateNames = new Set(usedStates)
@@ -91,17 +97,17 @@ export function createDescriptorSession({ semantic, handlerUrl, factory, context
     const optimized = referencedReducerDispatches(expression.body, reducers, expression).size ? undefined : compileOptimizedEvent(expression, setters, stateOwners, owner)
     if (optimized) return optimized
     rejectWorkerConstructions(expression)
-    const descriptor = compileNativeCallback(expression, { setters, reducers, entries: nativeHandlers, importBindings, prefix: "handler", listItem })
+    const descriptor = compileNativeCallback(expression, { setters, reducers, entries: nativeHandlers, importBindings, prefix: "handler", role: "native", listItem })
     return factory.createCallExpression(factory.createIdentifier("__kNativeBehavior"), undefined, [
       factory.createStringLiteral(handlerUrl), factory.createStringLiteral(descriptor.exportName), descriptor.states, descriptor.scope
     ])
   }
 
   function compileEffectCallback(expression, options) {
-    return compileNativeCallback(expression, { ...options, entries: effectHandlers, prefix: "effect" })
+    return compileNativeCallback(expression, { ...options, entries: effectHandlers, prefix: "effect", role: "effect" })
   }
 
-  function compileNativeCallback(expression, { setters, reducers, entries, importBindings, prefix, listItem, deferValues = false, snapshotNested = false, liveStates = new Set() }) {
+  function compileNativeCallback(expression, { setters, reducers, entries, importBindings, prefix, role, listItem, deferValues = false, snapshotNested = false, liveStates = new Set() }) {
     const allCaptures = nativeCaptureNames(expression, setters)
     const usedReducers = referencedReducerDispatches(expression.body, reducers, expression)
     const imports = [...referencedImportedBindings(expression, importBindings)].map(name => importBindings.get(name))
@@ -114,7 +120,7 @@ export function createDescriptorSession({ semantic, handlerUrl, factory, context
       if (reducer.contextAction) for (const state of referencedStateNames(reducer.contextAction.body, reducer.states, reducer.contextAction)) usedStates.add(state)
     }
     const exportName = `${prefix}${entries.length}`
-    entries.push({ exportName, expression, captures, imports, liveStates, setters: new Map([...setters].filter(([, state]) => usedStates.has(state))), reducers: new Map([...reducers].filter(([name]) => usedReducers.has(name))), snapshotNested })
+    entries.push({ exportName, expression, captures, deferValues, imports, listItem, liveStates, role, setters: new Map([...setters].filter(([, state]) => usedStates.has(state))), reducers: new Map([...reducers].filter(([name]) => usedReducers.has(name))), snapshotNested, usedStates })
     const value = name => deferValues
       ? factory.createArrowFunction(undefined, undefined, [], undefined, factory.createToken(ts.SyntaxKind.EqualsGreaterThanToken), factory.createIdentifier(name))
       : factory.createIdentifier(name)
@@ -141,10 +147,75 @@ export function createDescriptorSession({ semantic, handlerUrl, factory, context
   }
 
   function registerClientImports(imports) {
-    for (const entry of imports) if (!entry.package) clientImports.add(entry.target)
+    for (const entry of imports) if (!entry.package) clientModules.add(entry.target)
+  }
+
+  function registerDerivedResult(kind, value, states = [], node) {
+    const normalized = JSON.parse(JSON.stringify(value))
+    return registerDerived(moduleIR, { kind, [kind]: normalized, states: [...states], ...(source(node) ? { source: source(node) } : {}) })
   }
 
-  return { compileConditional, compileEffectCallback, compileEvent, compileListConditional, compileListValue, compileReactiveBinding }
+  function finalize() {
+    const callbacks = [...nativeHandlers, ...effectHandlers]
+    for (const entry of callbacks) {
+      const lowered = handlerLowering.lowerNativeHandler(entry)
+      const setters = Map.groupBy(entry.setters, ([, state]) => state)
+      registerModuleHandler(moduleIR, {
+        role: entry.role,
+        exportName: entry.exportName,
+        async: Boolean(entry.expression.modifiers?.some(modifier => modifier.kind === ts.SyntaxKind.AsyncKeyword)),
+        generator: Boolean(entry.expression.asteriskToken),
+        signals: [...entry.usedStates].map(name => ({
+          name,
+          setters: (setters.get(name) ?? []).map(([setter]) => setter),
+          value: entry.deferValues ? "deferred" : "direct",
+          snapshot: lowered.stateSnapshots.includes(name)
+        })),
+        captures: [...entry.captures].map(name => ({
+          name,
+          source: name === (typeof entry.listItem === "string" ? entry.listItem : entry.listItem?.item) ? "list-item" : name === entry.listItem?.index ? "list-index" : "scope",
+          value: entry.deferValues ? "deferred" : "direct",
+          snapshot: lowered.captureSnapshots.includes(name)
+        })),
+        imports: entry.imports.map(importRecord),
+        code: lowered.code,
+        ...(source(entry.expression) ? { source: source(entry.expression) } : {})
+      })
+    }
+    for (const entry of reactiveBindings) registerBinding(moduleIR, {
+      role: entry.role,
+      exportName: entry.exportName,
+      parameters: ["__k"],
+      states: [...entry.states],
+      captures: [...entry.captures].map(name => ({ name, source: "scope" })),
+      imports: entry.imports.map(importRecord),
+      code: handlerLowering.lowerReactiveBinding(entry),
+      ...(source(entry.expression) ? { source: source(entry.expression) } : {})
+    })
+    for (const entry of listExpressions) registerBinding(moduleIR, {
+      role: entry.role,
+      exportName: entry.exportName,
+      parameters: [entry.item, entry.index ?? "__kIndex", "__k"],
+      states: [...(entry.states ?? [])],
+      captures: [],
+      imports: [],
+      code: handlerLowering.lowerListExpression(entry),
+      ...(source(entry.expression) ? { source: source(entry.expression) } : {})
+    })
+    const imports = [...callbacks, ...reactiveBindings].flatMap(entry => entry.imports ?? []).map(importRecord)
+    moduleIR.imports = [...new Map(imports.map(entry => [`${entry.target}:${entry.kind}:${entry.imported ?? ""}:${entry.local}`, entry])).values()]
+    moduleIR.clientModules = [...clientModules]
+  }
+
+  function source(node) {
+    if (!node) return undefined
+    const original = ts.getOriginalNode(node)
+    return original.pos >= 0 && original.end >= 0 ? { file: sourceName(original.getSourceFile()), start: original.getStart(), end: original.end } : undefined
+  }
+
+  const importRecord = entry => ({ target: entry.target, kind: entry.kind, local: entry.local, ...(entry.imported ? { imported: entry.imported } : {}), package: Boolean(entry.package) })
+
+  return { compileConditional, compileEffectCallback, compileEvent, compileListConditional, compileListValue, compileReactiveBinding, finalize, registerDerived: registerDerivedResult }
 }
 
 function directStateIdentifier(expression, setters) {

package/framework/compiler/handler-codegen.mjs

@@ -1,19 +1,14 @@
-import ts from "typescript"
-import { isFunctionLike, isReferenceIdentifier, isShadowedByParameter, isShadowedIdentifier, sourceNodeError } from "./ast-helpers.mjs"
-
-export function createHandlerCodegen({ cloneAst, synthesizeTree, resolveClientImport }) {
-  return function printHandlerModule({ callbacks, reactiveBindings, listExpressions, handlerPath }) {
+export function createHandlerCodegen({ resolveClientImport }) {
+  return function printHandlerModule({ moduleIR, handlerPath }) {
     return [
-      printClientImports([...callbacks, ...reactiveBindings].flatMap(handler => handler.imports ?? []), handlerPath),
-      ...callbacks.map(handler => printNativeHandler(handler)),
-      ...reactiveBindings.map(entry => printReactiveBinding(entry)),
-      ...listExpressions.map(entry => printListExpression(entry))
+      printClientImports(moduleIR.imports, handlerPath),
+      ...moduleIR.handlers.filter(handler => handler.kind === "module-export").map(handler => handler.code),
+      ...moduleIR.bindings.map(binding => binding.code)
     ].join("\n")
   }
 
   function printClientImports(entries, handlerPath) {
-    const unique = new Map(entries.map(entry => [`${entry.target}:${entry.kind}:${entry.imported ?? ""}:${entry.local}`, entry]))
-    const groups = Map.groupBy(unique.values(), entry => entry.target)
+    const groups = Map.groupBy(entries, entry => entry.target)
     const imports = []
     for (const [target, group] of groups) {
       const specifier = resolveClientImport(group[0], handlerPath)
@@ -25,272 +20,4 @@ export function createHandlerCodegen({ cloneAst, synthesizeTree, resolveClientIm
     }
     return imports.join("\n")
   }
-
-  function printNativeHandler({ exportName, expression, captures, setters, reducers = new Map(), snapshotNested, liveStates = new Set() }) {
-    const factory = ts.factory
-    const stateNames = new Set(setters.values())
-    const snapshotNames = snapshotNested ? nestedStateNames(expression, setters, liveStates) : new Set()
-    const snapshots = new Map([...snapshotNames].map(name => [name, factory.createUniqueName("__kEffectState")]))
-    const captureSnapshotNames = snapshotNested ? nestedCaptureNames(expression, captures) : new Set()
-    const captureSnapshots = new Map([...captureSnapshotNames].map(name => [name, factory.createUniqueName("__kEffectCapture")]))
-    const transformer = context => root => {
-      const visitor = node => {
-        if (ts.isCallExpression(node) && ts.isIdentifier(node.expression) && reducers.has(node.expression.text) && !isShadowedIdentifier(node.expression, expression)) {
-          const reducer = reducers.get(node.expression.text)
-          if (reducer.contextAction) {
-            const action = synthesizeTree(cloneAst(reducer.contextAction, factory, context))
-            const call = factory.createCallExpression(action, undefined, node.arguments)
-            ts.setParentRecursive(call, false)
-            return ts.visitNode(call, visitor)
-          }
-          if (reducer.store) return zustandActionDispatch(factory, reducer, node.arguments.map(argument => ts.visitNode(argument, visitor)))
-          if (node.arguments.length !== 1) throw sourceNodeError(node, expression.getSourceFile(), "Reducer dispatches require exactly one action")
-          return reducerDispatch(factory, reducer, ts.visitNode(node.arguments[0], visitor))
-        }
-        if (ts.isShorthandPropertyAssignment(node) && reducers.has(node.name.text) && !isShadowedIdentifier(node.name, expression)) {
-          if (reducers.get(node.name.text).contextAction) throw sourceNodeError(node, expression.getSourceFile(), "Context actions must be called directly inside an event handler")
-          if (reducers.get(node.name.text).store) throw sourceNodeError(node, expression.getSourceFile(), "Zustand actions must be called directly inside an event handler")
-          return factory.createPropertyAssignment(node.name, reducerReference(factory, reducers.get(node.name.text)))
-        }
-        if (ts.isIdentifier(node) && reducers.has(node.text) && isReferenceIdentifier(node) && !isShadowedIdentifier(node, expression)) {
-          if (reducers.get(node.text).contextAction) throw sourceNodeError(node, expression.getSourceFile(), "Context actions must be called directly inside an event handler")
-          if (reducers.get(node.text).store) throw sourceNodeError(node, expression.getSourceFile(), "Zustand actions must be called directly inside an event handler")
-          return reducerReference(factory, reducers.get(node.text))
-        }
-        if (ts.isCallExpression(node) && ts.isIdentifier(node.expression) && setters.has(node.expression.text) && !isShadowedIdentifier(node.expression, expression)) {
-          return factory.createCallExpression(
-            factory.createPropertyAccessExpression(factory.createIdentifier("__k"), "set"),
-            undefined,
-            [factory.createStringLiteral(setters.get(node.expression.text)), ...node.arguments.map(argument => ts.visitNode(argument, visitor))]
-          )
-        }
-        if (ts.isShorthandPropertyAssignment(node) && setters.has(node.name.text) && !isShadowedIdentifier(node.name, expression)) {
-          return factory.createPropertyAssignment(node.name, setterReference(factory, setters.get(node.name.text)))
-        }
-        if (ts.isIdentifier(node) && setters.has(node.text) && isReferenceIdentifier(node) && !isShadowedIdentifier(node, expression)) {
-          return setterReference(factory, setters.get(node.text))
-        }
-        if (ts.isShorthandPropertyAssignment(node) && stateNames.has(node.name.text) && !isShadowedIdentifier(node.name, expression)) {
-          if (snapshots.has(node.name.text) && insideNestedFunction(node, expression)) return factory.createPropertyAssignment(node.name, snapshots.get(node.name.text))
-          return factory.createPropertyAssignment(node.name, factory.createCallExpression(factory.createPropertyAccessExpression(factory.createIdentifier("__k"), "get"), undefined, [factory.createStringLiteral(node.name.text)]))
-        }
-        if (ts.isIdentifier(node) && stateNames.has(node.text) && isReferenceIdentifier(node) && !isShadowedIdentifier(node, expression)) {
-          if (snapshots.has(node.text) && insideNestedFunction(node, expression)) return snapshots.get(node.text)
-          return factory.createCallExpression(
-            factory.createPropertyAccessExpression(factory.createIdentifier("__k"), "get"),
-            undefined,
-            [factory.createStringLiteral(node.text)]
-          )
-        }
-        if (ts.isShorthandPropertyAssignment(node) && captures.has(node.name.text) && !isShadowedIdentifier(node.name, expression)) {
-          if (captureSnapshots.has(node.name.text) && insideNestedFunction(node, expression)) return factory.createPropertyAssignment(node.name, captureSnapshots.get(node.name.text))
-          return factory.createPropertyAssignment(node.name, scopeRead(factory, node.name.text))
-        }
-        if (ts.isIdentifier(node) && captures.has(node.text) && isReferenceIdentifier(node) && !isShadowedIdentifier(node, expression)) {
-          if (captureSnapshots.has(node.text) && insideNestedFunction(node, expression)) return captureSnapshots.get(node.text)
-          return scopeRead(factory, node.text)
-        }
-        return ts.visitEachChild(node, visitor, context)
-      }
-      return ts.visitNode(root, visitor)
-    }
-    const transformed = ts.transform(expression.body, [transformer])
-    try {
-      let body = ts.isBlock(expression.body)
-        ? transformed.transformed[0]
-        : factory.createBlock([factory.createReturnStatement(transformed.transformed[0])], true)
-      const snapshotDeclarations = [
-        ...[...snapshots].map(([name, identifier]) => factory.createVariableDeclaration(identifier, undefined, undefined, factory.createCallExpression(factory.createPropertyAccessExpression(factory.createIdentifier("__k"), "get"), undefined, [factory.createStringLiteral(name)]))),
-        ...[...captureSnapshots].map(([name, identifier]) => factory.createVariableDeclaration(identifier, undefined, undefined, factory.createCallExpression(factory.createPropertyAccessExpression(factory.createIdentifier("__k"), "scope"), undefined, [factory.createStringLiteral(name)])))
-      ]
-      if (snapshotDeclarations.length) body = factory.updateBlock(body, [
-        factory.createVariableStatement(undefined, factory.createVariableDeclarationList(snapshotDeclarations, ts.NodeFlags.Const)),
-        ...body.statements
-      ])
-      const modifiers = [factory.createModifier(ts.SyntaxKind.ExportKeyword)]
-      if (expression.modifiers?.some(modifier => modifier.kind === ts.SyntaxKind.AsyncKeyword)) modifiers.push(factory.createModifier(ts.SyntaxKind.AsyncKeyword))
-      const declaration = factory.createFunctionDeclaration(
-        modifiers,
-        expression.asteriskToken,
-        exportName,
-        undefined,
-        [factory.createParameterDeclaration(undefined, undefined, "__k"), ...expression.parameters],
-        undefined,
-        body
-      )
-      return ts.createPrinter().printNode(ts.EmitHint.Unspecified, declaration, expression.getSourceFile())
-    } finally {
-      transformed.dispose()
-    }
-  }
-
-  function nestedCaptureNames(expression, captures) {
-    const names = new Set()
-    const visit = node => {
-      if (ts.isIdentifier(node) && captures.has(node.text) && isReferenceIdentifier(node) && insideNestedFunction(node, expression) && !isShadowedIdentifier(node, expression)) names.add(node.text)
-      ts.forEachChild(node, visit)
-    }
-    visit(expression.body)
-    return names
-  }
-
-  function nestedStateNames(expression, setters, liveStates = new Set()) {
-    const states = new Set(setters.values())
-    const names = new Set()
-    const visit = node => {
-      if (ts.isIdentifier(node) && states.has(node.text) && !liveStates.has(node.text) && isReferenceIdentifier(node) && insideNestedFunction(node, expression) && !isShadowedIdentifier(node, expression)) names.add(node.text)
-      ts.forEachChild(node, visit)
-    }
-    visit(expression.body)
-    return names
-  }
-
-  function insideNestedFunction(node, root) {
-    for (let current = node.parent; current && current !== root; current = current.parent) {
-      if (isFunctionLike(current)) return true
-    }
-    return false
-  }
-
-  function setterReference(factory, stateName) {
-    return factory.createArrowFunction(
-      undefined,
-      undefined,
-      [factory.createParameterDeclaration(undefined, undefined, "value")],
-      undefined,
-      factory.createToken(ts.SyntaxKind.EqualsGreaterThanToken),
-      factory.createCallExpression(factory.createPropertyAccessExpression(factory.createIdentifier("__k"), "set"), undefined, [factory.createStringLiteral(stateName), factory.createIdentifier("value")])
-    )
-  }
-
-  function reducerReference(factory, reducer) {
-    const action = factory.createUniqueName("__kAction")
-    return factory.createArrowFunction(undefined, undefined, [factory.createParameterDeclaration(undefined, undefined, action)], undefined, factory.createToken(ts.SyntaxKind.EqualsGreaterThanToken), reducerDispatch(factory, reducer, action))
-  }
-
-  function reducerDispatch(factory, reducer, action) {
-    if (reducer.store) return zustandActionDispatch(factory, reducer, [action])
-    const previous = factory.createUniqueName("__kPrevious")
-    const update = factory.createArrowFunction(undefined, undefined, [factory.createParameterDeclaration(undefined, undefined, previous)], undefined, factory.createToken(ts.SyntaxKind.EqualsGreaterThanToken), factory.createCallExpression(factory.createIdentifier(reducer.reducer), undefined, [previous, action]))
-    return factory.createCallExpression(factory.createPropertyAccessExpression(factory.createIdentifier("__k"), "set"), undefined, [factory.createStringLiteral(reducer.state), update])
-  }
-
-  function zustandActionDispatch(factory, reducer, args) {
-    const previous = factory.createUniqueName("__kPrevious")
-    const current = factory.createUniqueName("__kStore")
-    const updateValue = factory.createUniqueName("__kUpdate")
-    const partial = factory.createUniqueName("__kPartial")
-    const action = factory.createUniqueName("__kAction")
-    const set = factory.createIdentifier(reducer.store.setName)
-    const merge = factory.createExpressionStatement(factory.createBinaryExpression(current, factory.createToken(ts.SyntaxKind.EqualsToken), factory.createObjectLiteralExpression([
-      factory.createSpreadAssignment(current),
-      factory.createSpreadAssignment(partial)
-    ])))
-    const setBody = factory.createBlock([
-      factory.createVariableStatement(undefined, factory.createVariableDeclarationList([factory.createVariableDeclaration(partial, undefined, undefined, factory.createConditionalExpression(
-        factory.createBinaryExpression(factory.createTypeOfExpression(updateValue), factory.createToken(ts.SyntaxKind.EqualsEqualsEqualsToken), factory.createStringLiteral("function")),
-        undefined,
-        factory.createCallExpression(updateValue, undefined, [current]),
-        undefined,
-        updateValue
-      ))], ts.NodeFlags.Const)),
-      merge
-    ], true)
-    const body = factory.createBlock([
-      factory.createVariableStatement(undefined, factory.createVariableDeclarationList([factory.createVariableDeclaration(current, undefined, undefined, factory.createObjectLiteralExpression([factory.createPropertyAssignment(reducer.store.field, previous)]))], ts.NodeFlags.Let)),
-      factory.createVariableStatement(undefined, factory.createVariableDeclarationList([factory.createVariableDeclaration(set, undefined, undefined, factory.createArrowFunction(undefined, undefined, [factory.createParameterDeclaration(undefined, undefined, updateValue)], undefined, factory.createToken(ts.SyntaxKind.EqualsGreaterThanToken), setBody))], ts.NodeFlags.Const)),
-      factory.createVariableStatement(undefined, factory.createVariableDeclarationList([factory.createVariableDeclaration(action, undefined, undefined, synthesizeTree(reducer.store.actions.get(reducer.action)))], ts.NodeFlags.Const)),
-      factory.createExpressionStatement(factory.createCallExpression(action, undefined, args)),
-      factory.createReturnStatement(factory.createPropertyAccessExpression(current, reducer.store.field))
-    ], true)
-    const update = factory.createArrowFunction(undefined, undefined, [factory.createParameterDeclaration(undefined, undefined, previous)], undefined, factory.createToken(ts.SyntaxKind.EqualsGreaterThanToken), body)
-    return factory.createCallExpression(factory.createPropertyAccessExpression(factory.createIdentifier("__k"), "set"), undefined, [factory.createStringLiteral(reducer.state), update])
-  }
-
-  function printReactiveBinding({ exportName, expression, captures, states }) {
-    const factory = ts.factory
-    const transformer = context => root => {
-      const visitor = node => {
-        if (ts.isShorthandPropertyAssignment(node) && states.has(node.name.text)) {
-          return factory.createPropertyAssignment(
-            node.name,
-            factory.createCallExpression(
-              factory.createPropertyAccessExpression(factory.createIdentifier("__k"), "get"),
-              undefined,
-              [factory.createStringLiteral(node.name.text)]
-            )
-          )
-        }
-        if (ts.isIdentifier(node) && states.has(node.text) && isReferenceIdentifier(node) && !isShadowedByParameter(node, expression)) {
-          return factory.createCallExpression(
-            factory.createPropertyAccessExpression(factory.createIdentifier("__k"), "get"),
-            undefined,
-            [factory.createStringLiteral(node.text)]
-          )
-        }
-        if (ts.isShorthandPropertyAssignment(node) && captures.has(node.name.text)) {
-          return factory.createPropertyAssignment(node.name, scopeRead(factory, node.name.text))
-        }
-        if (ts.isIdentifier(node) && captures.has(node.text) && isReferenceIdentifier(node)) {
-          return scopeRead(factory, node.text)
-        }
-        return ts.visitEachChild(node, visitor, context)
-      }
-      return ts.visitNode(root, visitor)
-    }
-    const transformed = ts.transform(expression, [transformer])
-    try {
-      const declaration = factory.createFunctionDeclaration(
-        [factory.createModifier(ts.SyntaxKind.ExportKeyword)],
-        undefined,
-        exportName,
-        undefined,
-        [factory.createParameterDeclaration(undefined, undefined, "__k")],
-        undefined,
-        factory.createBlock([factory.createReturnStatement(transformed.transformed[0])], true)
-      )
-      return ts.createPrinter().printNode(ts.EmitHint.Unspecified, declaration, expression.getSourceFile())
-    } finally {
-      transformed.dispose()
-    }
-  }
-
-  function printListExpression({ exportName, expression, item, index, states = new Set() }) {
-    const factory = ts.factory
-    const transformer = context => root => {
-      const visitor = node => {
-        if (ts.isShorthandPropertyAssignment(node) && states.has(node.name.text)) {
-          return factory.createPropertyAssignment(node.name, factory.createCallExpression(factory.createPropertyAccessExpression(factory.createIdentifier("__k"), "get"), undefined, [factory.createStringLiteral(node.name.text)]))
-        }
-        if (ts.isIdentifier(node) && states.has(node.text) && isReferenceIdentifier(node) && !isShadowedByParameter(node, expression)) {
-          return factory.createCallExpression(factory.createPropertyAccessExpression(factory.createIdentifier("__k"), "get"), undefined, [factory.createStringLiteral(node.text)])
-        }
-        return ts.visitEachChild(node, visitor, context)
-      }
-      return ts.visitNode(root, visitor)
-    }
-    const transformed = ts.transform(expression, [transformer])
-    const declaration = ts.factory.createFunctionDeclaration(
-      [ts.factory.createModifier(ts.SyntaxKind.ExportKeyword)],
-      undefined,
-      exportName,
-      undefined,
-      [ts.factory.createParameterDeclaration(undefined, undefined, item), ts.factory.createParameterDeclaration(undefined, undefined, index ?? "__kIndex"), ts.factory.createParameterDeclaration(undefined, undefined, "__k")],
-      undefined,
-      ts.factory.createBlock([ts.factory.createReturnStatement(transformed.transformed[0])], true)
-    )
-    try {
-      return ts.createPrinter().printNode(ts.EmitHint.Unspecified, declaration, expression.getSourceFile())
-    } finally {
-      transformed.dispose()
-    }
-  }
-
-  function scopeRead(factory, name) {
-    return factory.createCallExpression(
-      factory.createPropertyAccessExpression(factory.createIdentifier("__k"), "scope"),
-      undefined,
-      [factory.createStringLiteral(name)]
-    )
-  }
 }

package/framework/compiler/handler-lowering.mjs

@@ -0,0 +1,278 @@
+import ts from "typescript"
+import { isFunctionLike, isReferenceIdentifier, isShadowedByParameter, isShadowedIdentifier, sourceNodeError } from "./ast-helpers.mjs"
+
+export function createHandlerLowering({ cloneAst, synthesizeTree }) {
+  return { lowerListExpression: printListExpression, lowerNativeHandler: printNativeHandler, lowerReactiveBinding: printReactiveBinding }
+
+  function printNativeHandler({ exportName, expression, captures, setters, reducers = new Map(), snapshotNested, liveStates = new Set() }) {
+    const factory = ts.factory
+    const stateNames = new Set(setters.values())
+    const snapshotNames = snapshotNested ? nestedStateNames(expression, setters, liveStates) : new Set()
+    const snapshots = new Map([...snapshotNames].map(name => [name, factory.createUniqueName("__kEffectState")]))
+    const captureSnapshotNames = snapshotNested ? nestedCaptureNames(expression, captures) : new Set()
+    const captureSnapshots = new Map([...captureSnapshotNames].map(name => [name, factory.createUniqueName("__kEffectCapture")]))
+    const transformer = context => root => {
+      const visitor = node => {
+        if (ts.isCallExpression(node) && ts.isIdentifier(node.expression) && reducers.has(node.expression.text) && !isShadowedIdentifier(node.expression, expression)) {
+          const reducer = reducers.get(node.expression.text)
+          if (reducer.contextAction) {
+            const action = synthesizeTree(cloneAst(reducer.contextAction, factory, context))
+            const call = factory.createCallExpression(action, undefined, node.arguments)
+            ts.setParentRecursive(call, false)
+            return ts.visitNode(call, visitor)
+          }
+          if (reducer.store) return zustandActionDispatch(factory, reducer, node.arguments.map(argument => ts.visitNode(argument, visitor)))
+          if (node.arguments.length !== 1) throw sourceNodeError(node, expression.getSourceFile(), "Reducer dispatches require exactly one action")
+          return reducerDispatch(factory, reducer, ts.visitNode(node.arguments[0], visitor))
+        }
+        if (ts.isShorthandPropertyAssignment(node) && reducers.has(node.name.text) && !isShadowedIdentifier(node.name, expression)) {
+          if (reducers.get(node.name.text).contextAction) throw sourceNodeError(node, expression.getSourceFile(), "Context actions must be called directly inside an event handler")
+          if (reducers.get(node.name.text).store) throw sourceNodeError(node, expression.getSourceFile(), "Zustand actions must be called directly inside an event handler")
+          return factory.createPropertyAssignment(node.name, reducerReference(factory, reducers.get(node.name.text)))
+        }
+        if (ts.isIdentifier(node) && reducers.has(node.text) && isReferenceIdentifier(node) && !isShadowedIdentifier(node, expression)) {
+          if (reducers.get(node.text).contextAction) throw sourceNodeError(node, expression.getSourceFile(), "Context actions must be called directly inside an event handler")
+          if (reducers.get(node.text).store) throw sourceNodeError(node, expression.getSourceFile(), "Zustand actions must be called directly inside an event handler")
+          return reducerReference(factory, reducers.get(node.text))
+        }
+        if (ts.isCallExpression(node) && ts.isIdentifier(node.expression) && setters.has(node.expression.text) && !isShadowedIdentifier(node.expression, expression)) {
+          return factory.createCallExpression(
+            factory.createPropertyAccessExpression(factory.createIdentifier("__k"), "set"),
+            undefined,
+            [factory.createStringLiteral(setters.get(node.expression.text)), ...node.arguments.map(argument => ts.visitNode(argument, visitor))]
+          )
+        }
+        if (ts.isShorthandPropertyAssignment(node) && setters.has(node.name.text) && !isShadowedIdentifier(node.name, expression)) {
+          return factory.createPropertyAssignment(node.name, setterReference(factory, setters.get(node.name.text)))
+        }
+        if (ts.isIdentifier(node) && setters.has(node.text) && isReferenceIdentifier(node) && !isShadowedIdentifier(node, expression)) {
+          return setterReference(factory, setters.get(node.text))
+        }
+        if (ts.isShorthandPropertyAssignment(node) && stateNames.has(node.name.text) && !isShadowedIdentifier(node.name, expression)) {
+          if (snapshots.has(node.name.text) && insideNestedFunction(node, expression)) return factory.createPropertyAssignment(node.name, snapshots.get(node.name.text))
+          return factory.createPropertyAssignment(node.name, factory.createCallExpression(factory.createPropertyAccessExpression(factory.createIdentifier("__k"), "get"), undefined, [factory.createStringLiteral(node.name.text)]))
+        }
+        if (ts.isIdentifier(node) && stateNames.has(node.text) && isReferenceIdentifier(node) && !isShadowedIdentifier(node, expression)) {
+          if (snapshots.has(node.text) && insideNestedFunction(node, expression)) return snapshots.get(node.text)
+          return factory.createCallExpression(
+            factory.createPropertyAccessExpression(factory.createIdentifier("__k"), "get"),
+            undefined,
+            [factory.createStringLiteral(node.text)]
+          )
+        }
+        if (ts.isShorthandPropertyAssignment(node) && captures.has(node.name.text) && !isShadowedIdentifier(node.name, expression)) {
+          if (captureSnapshots.has(node.name.text) && insideNestedFunction(node, expression)) return factory.createPropertyAssignment(node.name, captureSnapshots.get(node.name.text))
+          return factory.createPropertyAssignment(node.name, scopeRead(factory, node.name.text))
+        }
+        if (ts.isIdentifier(node) && captures.has(node.text) && isReferenceIdentifier(node) && !isShadowedIdentifier(node, expression)) {
+          if (captureSnapshots.has(node.text) && insideNestedFunction(node, expression)) return captureSnapshots.get(node.text)
+          return scopeRead(factory, node.text)
+        }
+        return ts.visitEachChild(node, visitor, context)
+      }
+      return ts.visitNode(root, visitor)
+    }
+    const transformed = ts.transform(expression.body, [transformer])
+    try {
+      let body = ts.isBlock(expression.body)
+        ? transformed.transformed[0]
+        : factory.createBlock([factory.createReturnStatement(transformed.transformed[0])], true)
+      const snapshotDeclarations = [
+        ...[...snapshots].map(([name, identifier]) => factory.createVariableDeclaration(identifier, undefined, undefined, factory.createCallExpression(factory.createPropertyAccessExpression(factory.createIdentifier("__k"), "get"), undefined, [factory.createStringLiteral(name)]))),
+        ...[...captureSnapshots].map(([name, identifier]) => factory.createVariableDeclaration(identifier, undefined, undefined, factory.createCallExpression(factory.createPropertyAccessExpression(factory.createIdentifier("__k"), "scope"), undefined, [factory.createStringLiteral(name)])))
+      ]
+      if (snapshotDeclarations.length) body = factory.updateBlock(body, [
+        factory.createVariableStatement(undefined, factory.createVariableDeclarationList(snapshotDeclarations, ts.NodeFlags.Const)),
+        ...body.statements
+      ])
+      const modifiers = [factory.createModifier(ts.SyntaxKind.ExportKeyword)]
+      if (expression.modifiers?.some(modifier => modifier.kind === ts.SyntaxKind.AsyncKeyword)) modifiers.push(factory.createModifier(ts.SyntaxKind.AsyncKeyword))
+      const declaration = factory.createFunctionDeclaration(
+        modifiers,
+        expression.asteriskToken,
+        exportName,
+        undefined,
+        [factory.createParameterDeclaration(undefined, undefined, "__k"), ...expression.parameters],
+        undefined,
+        body
+      )
+      return {
+        code: ts.createPrinter().printNode(ts.EmitHint.Unspecified, declaration, expression.getSourceFile()),
+        stateSnapshots: [...snapshotNames],
+        captureSnapshots: [...captureSnapshotNames]
+      }
+    } finally {
+      transformed.dispose()
+    }
+  }
+
+  function nestedCaptureNames(expression, captures) {
+    const names = new Set()
+    const visit = node => {
+      if (ts.isIdentifier(node) && captures.has(node.text) && isReferenceIdentifier(node) && insideNestedFunction(node, expression) && !isShadowedIdentifier(node, expression)) names.add(node.text)
+      ts.forEachChild(node, visit)
+    }
+    visit(expression.body)
+    return names
+  }
+
+  function nestedStateNames(expression, setters, liveStates = new Set()) {
+    const states = new Set(setters.values())
+    const names = new Set()
+    const visit = node => {
+      if (ts.isIdentifier(node) && states.has(node.text) && !liveStates.has(node.text) && isReferenceIdentifier(node) && insideNestedFunction(node, expression) && !isShadowedIdentifier(node, expression)) names.add(node.text)
+      ts.forEachChild(node, visit)
+    }
+    visit(expression.body)
+    return names
+  }
+
+  function insideNestedFunction(node, root) {
+    for (let current = node.parent; current && current !== root; current = current.parent) {
+      if (isFunctionLike(current)) return true
+    }
+    return false
+  }
+
+  function setterReference(factory, stateName) {
+    return factory.createArrowFunction(
+      undefined,
+      undefined,
+      [factory.createParameterDeclaration(undefined, undefined, "value")],
+      undefined,
+      factory.createToken(ts.SyntaxKind.EqualsGreaterThanToken),
+      factory.createCallExpression(factory.createPropertyAccessExpression(factory.createIdentifier("__k"), "set"), undefined, [factory.createStringLiteral(stateName), factory.createIdentifier("value")])
+    )
+  }
+
+  function reducerReference(factory, reducer) {
+    const action = factory.createUniqueName("__kAction")
+    return factory.createArrowFunction(undefined, undefined, [factory.createParameterDeclaration(undefined, undefined, action)], undefined, factory.createToken(ts.SyntaxKind.EqualsGreaterThanToken), reducerDispatch(factory, reducer, action))
+  }
+
+  function reducerDispatch(factory, reducer, action) {
+    if (reducer.store) return zustandActionDispatch(factory, reducer, [action])
+    const previous = factory.createUniqueName("__kPrevious")
+    const update = factory.createArrowFunction(undefined, undefined, [factory.createParameterDeclaration(undefined, undefined, previous)], undefined, factory.createToken(ts.SyntaxKind.EqualsGreaterThanToken), factory.createCallExpression(factory.createIdentifier(reducer.reducer), undefined, [previous, action]))
+    return factory.createCallExpression(factory.createPropertyAccessExpression(factory.createIdentifier("__k"), "set"), undefined, [factory.createStringLiteral(reducer.state), update])
+  }
+
+  function zustandActionDispatch(factory, reducer, args) {
+    const previous = factory.createUniqueName("__kPrevious")
+    const current = factory.createUniqueName("__kStore")
+    const updateValue = factory.createUniqueName("__kUpdate")
+    const partial = factory.createUniqueName("__kPartial")
+    const action = factory.createUniqueName("__kAction")
+    const set = factory.createIdentifier(reducer.store.setName)
+    const merge = factory.createExpressionStatement(factory.createBinaryExpression(current, factory.createToken(ts.SyntaxKind.EqualsToken), factory.createObjectLiteralExpression([
+      factory.createSpreadAssignment(current),
+      factory.createSpreadAssignment(partial)
+    ])))
+    const setBody = factory.createBlock([
+      factory.createVariableStatement(undefined, factory.createVariableDeclarationList([factory.createVariableDeclaration(partial, undefined, undefined, factory.createConditionalExpression(
+        factory.createBinaryExpression(factory.createTypeOfExpression(updateValue), factory.createToken(ts.SyntaxKind.EqualsEqualsEqualsToken), factory.createStringLiteral("function")),
+        undefined,
+        factory.createCallExpression(updateValue, undefined, [current]),
+        undefined,
+        updateValue
+      ))], ts.NodeFlags.Const)),
+      merge
+    ], true)
+    const body = factory.createBlock([
+      factory.createVariableStatement(undefined, factory.createVariableDeclarationList([factory.createVariableDeclaration(current, undefined, undefined, factory.createObjectLiteralExpression([factory.createPropertyAssignment(reducer.store.field, previous)]))], ts.NodeFlags.Let)),
+      factory.createVariableStatement(undefined, factory.createVariableDeclarationList([factory.createVariableDeclaration(set, undefined, undefined, factory.createArrowFunction(undefined, undefined, [factory.createParameterDeclaration(undefined, undefined, updateValue)], undefined, factory.createToken(ts.SyntaxKind.EqualsGreaterThanToken), setBody))], ts.NodeFlags.Const)),
+      factory.createVariableStatement(undefined, factory.createVariableDeclarationList([factory.createVariableDeclaration(action, undefined, undefined, synthesizeTree(reducer.store.actions.get(reducer.action)))], ts.NodeFlags.Const)),
+      factory.createExpressionStatement(factory.createCallExpression(action, undefined, args)),
+      factory.createReturnStatement(factory.createPropertyAccessExpression(current, reducer.store.field))
+    ], true)
+    const update = factory.createArrowFunction(undefined, undefined, [factory.createParameterDeclaration(undefined, undefined, previous)], undefined, factory.createToken(ts.SyntaxKind.EqualsGreaterThanToken), body)
+    return factory.createCallExpression(factory.createPropertyAccessExpression(factory.createIdentifier("__k"), "set"), undefined, [factory.createStringLiteral(reducer.state), update])
+  }
+
+  function printReactiveBinding({ exportName, expression, captures, states }) {
+    const factory = ts.factory
+    const transformer = context => root => {
+      const visitor = node => {
+        if (ts.isShorthandPropertyAssignment(node) && states.has(node.name.text)) {
+          return factory.createPropertyAssignment(
+            node.name,
+            factory.createCallExpression(
+              factory.createPropertyAccessExpression(factory.createIdentifier("__k"), "get"),
+              undefined,
+              [factory.createStringLiteral(node.name.text)]
+            )
+          )
+        }
+        if (ts.isIdentifier(node) && states.has(node.text) && isReferenceIdentifier(node) && !isShadowedByParameter(node, expression)) {
+          return factory.createCallExpression(
+            factory.createPropertyAccessExpression(factory.createIdentifier("__k"), "get"),
+            undefined,
+            [factory.createStringLiteral(node.text)]
+          )
+        }
+        if (ts.isShorthandPropertyAssignment(node) && captures.has(node.name.text)) {
+          return factory.createPropertyAssignment(node.name, scopeRead(factory, node.name.text))
+        }
+        if (ts.isIdentifier(node) && captures.has(node.text) && isReferenceIdentifier(node)) {
+          return scopeRead(factory, node.text)
+        }
+        return ts.visitEachChild(node, visitor, context)
+      }
+      return ts.visitNode(root, visitor)
+    }
+    const transformed = ts.transform(expression, [transformer])
+    try {
+      const declaration = factory.createFunctionDeclaration(
+        [factory.createModifier(ts.SyntaxKind.ExportKeyword)],
+        undefined,
+        exportName,
+        undefined,
+        [factory.createParameterDeclaration(undefined, undefined, "__k")],
+        undefined,
+        factory.createBlock([factory.createReturnStatement(transformed.transformed[0])], true)
+      )
+      return ts.createPrinter().printNode(ts.EmitHint.Unspecified, declaration, expression.getSourceFile())
+    } finally {
+      transformed.dispose()
+    }
+  }
+
+  function printListExpression({ exportName, expression, item, index, states = new Set() }) {
+    const factory = ts.factory
+    const transformer = context => root => {
+      const visitor = node => {
+        if (ts.isShorthandPropertyAssignment(node) && states.has(node.name.text)) {
+          return factory.createPropertyAssignment(node.name, factory.createCallExpression(factory.createPropertyAccessExpression(factory.createIdentifier("__k"), "get"), undefined, [factory.createStringLiteral(node.name.text)]))
+        }
+        if (ts.isIdentifier(node) && states.has(node.text) && isReferenceIdentifier(node) && !isShadowedByParameter(node, expression)) {
+          return factory.createCallExpression(factory.createPropertyAccessExpression(factory.createIdentifier("__k"), "get"), undefined, [factory.createStringLiteral(node.text)])
+        }
+        return ts.visitEachChild(node, visitor, context)
+      }
+      return ts.visitNode(root, visitor)
+    }
+    const transformed = ts.transform(expression, [transformer])
+    const declaration = ts.factory.createFunctionDeclaration(
+      [ts.factory.createModifier(ts.SyntaxKind.ExportKeyword)],
+      undefined,
+      exportName,
+      undefined,
+      [ts.factory.createParameterDeclaration(undefined, undefined, item), ts.factory.createParameterDeclaration(undefined, undefined, index ?? "__kIndex"), ts.factory.createParameterDeclaration(undefined, undefined, "__k")],
+      undefined,
+      ts.factory.createBlock([ts.factory.createReturnStatement(transformed.transformed[0])], true)
+    )
+    try {
+      return ts.createPrinter().printNode(ts.EmitHint.Unspecified, declaration, expression.getSourceFile())
+    } finally {
+      transformed.dispose()
+    }
+  }
+
+  function scopeRead(factory, name) {
+    return factory.createCallExpression(
+      factory.createPropertyAccessExpression(factory.createIdentifier("__k"), "scope"),
+      undefined,
+      [factory.createStringLiteral(name)]
+    )
+  }
+}

package/framework/compiler/ir/module-ir.mjs

@@ -1,5 +1,5 @@
 export function createModuleIR(file) {
-  return { version: 1, file, signals: [], handlers: [] }
+  return { version: 1, file, signals: [], handlers: [], bindings: [], derived: [], imports: [], clientModules: [] }
 }
 
 export function registerCommandHandler(moduleIR, commands, source, scope = "module") {
@@ -21,3 +21,21 @@ export function registerCommandHandler(moduleIR, commands, source, scope = "modu
   moduleIR.handlers.push(handler)
   return handler
 }
+
+export function registerModuleHandler(moduleIR, descriptor) {
+  const handler = { slot: moduleIR.handlers.length, kind: "module-export", ...descriptor }
+  moduleIR.handlers.push(handler)
+  return handler
+}
+
+export function registerBinding(moduleIR, descriptor) {
+  const binding = { slot: moduleIR.bindings.length, kind: "module-export", ...descriptor }
+  moduleIR.bindings.push(binding)
+  return binding
+}
+
+export function registerDerived(moduleIR, descriptor) {
+  const derived = { slot: moduleIR.derived.length, ...descriptor }
+  moduleIR.derived.push(derived)
+  return derived
+}

package/package.json

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