@kudzujs/core 0.8.61 → 0.9.0

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

@@ -2,9 +2,9 @@
 
 ## Status
 
-Active execution plan after `0.8.35`. This document turns the current compiler audit into an ordered implementation program. It does not mark any planned capability as supported and does not authorize a React runtime, VDOM, hydration, retained browser component tree, generic rerenderer, public store/query/resource API, SPA router, or islands.
+Completed compiler-foundation record and longer-term plan after `0.8.35`. The active post-`0.8.62` execution queue is [`0.9-semantic-compression.md`](./0.9-semantic-compression.md). This document does not mark any remaining planned capability as supported and does not authorize a React runtime, VDOM, hydration, retained browser component tree, generic rerenderer, public store/query/resource API, SPA router, or islands.
 
-[`MIGRATION_ROADMAP.md`](../../MIGRATION_ROADMAP.md) remains authoritative for product invariants and fixture-driven feature selection. This plan is authoritative for the order and completion evidence of compiler generalization, large-application foundations, compatibility boundaries, AI tooling, and scale validation. If implementation evidence changes a boundary, update this document before broadening a patch.
+[`MIGRATION_ROADMAP.md`](../../MIGRATION_ROADMAP.md) remains authoritative for product invariants and fixture-driven feature selection. [`0.9-semantic-compression.md`](./0.9-semantic-compression.md) is authoritative for current work order and evidence; this plan retains the completed foundation, deferred program, and long-term production gates. If implementation evidence changes either boundary, update the relevant document before broadening a patch.
 
 ## Product Outcome
 
@@ -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`; action-only Provider setter exposure removed in `0.8.46`; direct primitive prop state initialization completed in `0.8.47`; repeated direct leaf-handler callback use completed in `0.8.48`; direct child callback fan-out completed in `0.8.49`; direct plain-object prop state initialization completed in `0.8.57`; direct keyed item draft initialization completed in `0.8.58`; direct array prop draft initialization completed in `0.8.59`; matching array-draft setter effects completed in `0.8.60`; parameterized primitive debounce hooks completed in `0.8.61`:** 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, specialized children may seed local state from a direct parent signal authored with a serializable primitive, plain-object, or array literal, keyed rows may seed object draft state from their direct item prop, and one callback may branch through multiple component `on*` props and intrinsic handlers. A direct first-boundary parent setter may also retain its authored matching `set*` prop name; additional forwarding remains restricted to `on*` props. The ClimateCompatibleGrowth-derived dropdown proves independent array drafts and exact direct setter-effect synchronization, while its relative debounce hook specializes one direct primitive source and literal delay through existing timeout cleanup ownership. A fourth callback boundary, callback aliases/non-handler uses, dynamic debounce delays, non-primitive debounce inputs, mismatched state/setter effect pairs, fully hidden Context state, additional `set*` forwarding, keyed item aliases, property paths, and composed expressions remain 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`; repeated direct leaf-handler callback use completed in `0.8.48`; direct child callback fan-out completed in `0.8.49`; direct plain-object prop state initialization completed in `0.8.57`; direct keyed item draft initialization completed in `0.8.58`; direct array prop draft initialization completed in `0.8.59`; matching array-draft setter effects completed in `0.8.60`; parameterized primitive debounce hooks completed in `0.8.61`; direct `createRef()` outside-click hooks completed in `0.8.62`:** 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, specialized children may seed local state from a direct parent signal authored with a serializable primitive, plain-object, or array literal, keyed rows may seed object draft state from their direct item prop, and one callback may branch through multiple component `on*` props and intrinsic handlers. A direct first-boundary parent setter may also retain its authored matching `set*` prop name; additional forwarding remains restricted to `on*` props. The ClimateCompatibleGrowth-derived dropdown proves independent array drafts, exact direct setter-effect synchronization, parameterized debounce ownership, and one exact outside-click listener over an intrinsic DOM ref. A fourth callback boundary, callback aliases/non-handler uses, dynamic debounce delays, non-primitive debounce inputs, dynamic outside-click events, mismatched cleanup/state-setter pairs, fully hidden Context state, additional `set*` forwarding, keyed item aliases, property paths, and composed expressions 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. **Completed in `0.8.50`:** Zustand source normalization produces one generic shared-state adapter descriptor; selectors and handlers register JSON-safe SharedStateIR/SharedActionIR records, handler lowering consumes package-neutral actions, and existing RouteIR, layout ownership, same-turn updates, navigation persistence, and browser output remain unchanged. Redux/RTK and public adapter APIs remain unsupported.
 4. Browser-only package imports in owned effect/resource modules. **Completed in `0.8.51` for effects:** direct package references in inline effect setup/cleanup callbacks use existing package import records and route-owned effect ESM bundling; build-time component modules and static siblings omit the package. Helper-indirect, render-time, dynamic-import, and ResourceIR package graphs remain unsupported.
 5. ResourceIR from at least two independent WebSocket/SSE/SDK fixtures with the same semantics. **Completed in `0.8.52` without ResourceIR for private ownership:** the E2B terminal and route-owned WebSocket fixtures lower refs used exclusively by one inline effect to invocation-private closure objects, while existing effect ownership supplies replacement, cleanup, stale setter invalidation, navigation, and BFCache disposal. ResourceIR remains unapproved and now requires independent cross-owner transport/subscription fixtures that cannot fit this narrower model.
@@ -453,6 +453,8 @@ The first comparison is Kudzu versus React + Vite using the same agent, model, t
 
 ## Production Gates Before 1.0
 
+- The active `0.9.0` cross-framework gate proves lower browser cost and matched user-facing performance against React + Vite, Vue, Svelte, and Astro before AI productivity claims are considered.
+- The maintained AI delivery suite uses the same model, tools, requirements, budgets, and acceptance checks across frameworks, includes failed attempts, and establishes the highest success rate plus lowest median cost per successful task before `1.0.0`.
 - Async native and effect work cannot write after ownership release.
 - Build output is staged, collision-safe, and rollback/recovery guarded.
 - Source maps connect generated route code to TS/TSX diagnostics.
@@ -481,4 +483,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, the `0.8.46` action-only Provider setter slice, the `0.8.47` direct primitive, `0.8.57` plain-object prop, `0.8.58` direct keyed item, `0.8.59` direct array prop initializer, `0.8.60` matching array-draft setter-effect, and `0.8.61` parameterized primitive debounce-hook slices, the `0.8.48` repeated direct leaf-handler callback slice, the `0.8.49` direct child callback fan-out slice, the `0.8.50` package-neutral shared-state/action slice, the `0.8.51` owned-effect package import slice, the `0.8.52` effect-private mutable-ref slice, the `0.8.53` route/layout CSS closure slice, the `0.8.54` structural per-route capability/chunk report, the `0.8.55` signature-keyed runtime families, item 7 incremental source and affected-route builds, and the `0.8.42` measured route-output optimization are complete. Continue migration-led semantic generalization; keep ResourceIR limited to independent fixtures, and do not add range ownership, virtualization, optimistic transactions, a public adapter/store API, or a router before evidence justifies them.
+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, `0.8.57` plain-object prop, `0.8.58` direct keyed item, `0.8.59` direct array prop initializer, `0.8.60` matching array-draft setter-effect, `0.8.61` parameterized primitive debounce-hook, and `0.8.62` direct-ref outside-click-hook slices, the `0.8.48` repeated direct leaf-handler callback slice, the `0.8.49` direct child callback fan-out slice, the `0.8.50` package-neutral shared-state/action slice, the `0.8.51` owned-effect package import slice, the `0.8.52` effect-private mutable-ref slice, the `0.8.53` route/layout CSS closure slice, the `0.8.54` structural per-route capability/chunk report, the `0.8.55` signature-keyed runtime families, item 7 incremental source and affected-route builds, and the `0.8.42` measured route-output optimization are complete. Continue with `0.9.0-01` in the active Semantic Compression plan; keep ResourceIR limited to qualifying independent fixtures, and do not add range ownership, virtualization, optimistic transactions, a public adapter/store API, or a router before evidence justifies them.

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.61` are completed scopes represented by package/release records.
+This is an execution sequence, not release history. `0.8.16` through `0.8.62` 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.
 
@@ -52,6 +52,7 @@ Keep each patch behavior-preserving and independently reviewable. If a boundary
 | `0.8.59` | Initialize specialized child draft state from one direct parent array-state prop and accept a direct matching `set*` setter prop. | A ClimateCompatibleGrowth-derived dropdown preserves independent array drafts, explicit parent commit, source naming, nearby diagnostics, and a static zero-JavaScript sibling without runtime changes. |
 | `0.8.60` | Synchronize direct prop-derived array draft state through its matching parent setter in a dependency effect. | The ClimateCompatibleGrowth-derived dropdown preserves its exact direct effect/dependency shape, stable setter erasure, array identity comparison, independent parent replacement, nearby diagnostics, and a static zero-JavaScript sibling without runtime changes. |
 | `0.8.61` | Specialize one parameterized relative primitive debounce hook through existing state and dependency-effect ownership. | The ClimateCompatibleGrowth-derived hook preserves direct state initialization, literal delay scope, timeout replacement/cleanup, conditional release, latest-value commit, nearby diagnostics, and a static zero-JavaScript sibling without runtime changes. |
+| `0.8.62` | Lower direct React `createRef()` and one parameterized outside-click hook through existing DOM-ref and effect ownership. | The ClimateCompatibleGrowth-derived hook preserves inside/outside behavior, serializable setter scope, exact listener cleanup, conditional release/remount, nearby diagnostics, and a static zero-JavaScript sibling without runtime changes. |
 
 ## Sequence Rules
 
@@ -64,7 +65,7 @@ Keep each patch behavior-preserving and independently reviewable. If a boundary
 
 ## Generator Versions
 
-`create-kudzu@0.1.102` adds an explicit install step to the generated README and clearer completion output. Its `@kudzujs/core` range `^0.8.15` accepts every current `0.8.x` patch; a future `0.9.0` template must use `^0.9.0`.
+`create-kudzu@0.1.103` retains the explicit install instructions and generates projects with `@kudzujs/core@^0.9.0`.
 
 ## Release Boundary
 

package/framework/README.md

@@ -6,7 +6,7 @@ Migration source may retain conventional `react` imports for supported named or
 
 Compilation begins from page entries and follows relative runtime imports, re-exports, and validated Worker references; unreachable TypeScript migration files are not transformed. Direct maps over imported immutable JSON-safe arrays fold to literals for zero-JavaScript static rows. Synchronous relative calculation functions may return objects whose direct static fields feed reactive JSX bindings; build rendering uses current signal values and route-specific binding ESM reevaluates the same helper after state commits. One direct array field may instead feed a keyed intrinsic map: its evaluator refreshes a compiler-owned array anchor before the existing list reconciler runs, preserving keyed DOM and SVG identity without a calculation runtime. That field must remain a JSON-safe array after every source-state commit. Package imports have a separate narrow boundary: direct references inside intrinsic JSX event callbacks are erased from build modules and bundled into route handler ESM, while render-time, effect, helper-indirect, and mixed package use fails.
 
-Native platform work remains ordinary source. A direct async handler or directly returned relative custom-hook callback may call `navigator.clipboard.writeText()` and update application-owned success/failure state; Kudzu emits only its existing route handler ESM. Debounced synchronization uses a dependency effect that creates `setTimeout()` work and directly returns `clearTimeout()` cleanup, reusing dependency, conditional, keyed, and route ownership. A relative `useDebounce(value, delay)` hook may accept one direct primitive state and numeric literal delay, initialize and return one debounced state, and reuse that same effect ownership. One directly returned relative custom-hook callback may own one `null`-initialized private timeout ref when it directly clears the previous value, assigns a numeric-literal-delay `setTimeout()`, and an empty-dependency effect directly clears the timer on cleanup. Kudzu lowers that ref to compiler-owned state shared by existing handler and effect contexts. An ordinary inline effect may exclusively own top-level `useRef(null)` and `useRef(0)` values through direct `.current` references; Kudzu moves them into the setup invocation's closure for browser SDK handles, WebSockets, generation tokens, and animation frames without serialized captures or a resource runtime. Multiple timers, dynamic delays, intervals, ref aliases, cross-effect/event mutable refs, unowned delayed writes, and arbitrary timed callback graphs remain unsupported.
+Native platform work remains ordinary source. A direct async handler or directly returned relative custom-hook callback may call `navigator.clipboard.writeText()` and update application-owned success/failure state; Kudzu emits only its existing route handler ESM. Debounced synchronization uses a dependency effect that creates `setTimeout()` work and directly returns `clearTimeout()` cleanup, reusing dependency, conditional, keyed, and route ownership. A relative `useDebounce(value, delay)` hook may accept one direct primitive state and numeric literal delay, initialize and return one debounced state, and reuse that same effect ownership. Direct React `createRef()` input may lower to an intrinsic DOM ref passed with one direct literal setter callback into an exact outside-click listener effect; ref and setter serialization reuse existing effect scope and cleanup. One directly returned relative custom-hook callback may own one `null`-initialized private timeout ref when it directly clears the previous value, assigns a numeric-literal-delay `setTimeout()`, and an empty-dependency effect directly clears the timer on cleanup. Kudzu lowers that ref to compiler-owned state shared by existing handler and effect contexts. An ordinary inline effect may exclusively own top-level `useRef(null)` and `useRef(0)` values through direct `.current` references; Kudzu moves them into the setup invocation's closure for browser SDK handles, WebSockets, generation tokens, and animation frames without serialized captures or a resource runtime. Multiple timers, dynamic delays, intervals, ref aliases, cross-effect/event mutable refs, unowned delayed writes, and arbitrary timed callback graphs remain unsupported.
 
 Imperative canvas migrations use the same effect ownership rather than a component or canvas runtime. One `null`-initialized canvas DOM ref may feed an inline effect whose local variables persist across a recursive animation-frame callback, an `IntersectionObserver`, and native canvas/window listeners; the returned cleanup must cancel the latest frame, disconnect the observer, and remove every listener. Bare `IntersectionObserver` and `performance` identifiers remain browser globals in emitted effect ESM. Component-level mutable value refs and callbacks shared across effects or JSX handlers remain unsupported; move resource-private state and listeners into the owning effect.
 
@@ -94,4 +94,6 @@ A direct setter or inline/simple `const` setter callback may cross one same-file
 
 `kudzu.config` may opt one emitted shared-layout group into same-document navigation with legacy `navigation: { routes: ["/product", "/items/[id]"] }`, or multiple groups with `navigation: { groups: [{ routes: [...] }, { routes: [...] }] }`. The forms are mutually exclusive. Identities are globally unique emitted exact paths or `runtimeParams` patterns; each group uses one page-exported layout function identity. Runtime records securely match concrete pathnames under `base`, and their cache-safe parameter initializer runs before route DOM/effects mount on every transition. Each group receives a deterministic route-hashed asset specialized to only its records, pattern decoder, and effect/parameter lifecycle needs. Cross-group and ungrouped anchors remain native and are not prefetched; overlapping path domains across groups fail the build. Route effect entries export cache-safe layout and route mount functions: layout effects, including conditional/keyed DOM-owned effects, persist for the group session; route effects receive a fresh owner registry after each route insertion; and non-persisted page disposal cleans route before layout. Direct primitive state, runtime parameter, and keyed-item property dependencies and cleanup are supported. Fragment payloads and coordinated View Transitions are not implemented.
 
+A direct object-state prop may expose one-segment static fields when its same-file or relative-imported child directly maps an array field. Scalar bindings and that selected array effect dependency reuse the parent signal, existing `Object.is` comparison, and binding-backed keyed ownership without field state or a browser component. Dynamic paths, aliases, mutation, child state/ref/ID hooks, and opaque call-site values remain unsupported.
+
 Cross-framework performance tables are historical snapshots from excluded workspaces and are not current rankings. `npm run benchmark` tracks the Worker build/graph fixture; `RUNS=21 npm run benchmark:keyed` tracks large keyed restoration; `BASELINE_ROOT=... npm run benchmark:native` tracks native dispatch and exact artifact changes. Current methodology, raw arrays, external-fixture limits, and artifact deltas live in `PERFORMANCE.md` and the web docs.

package/framework/binding-runtime.js

@@ -56,10 +56,10 @@ function commitBindings(id) {
 }
 
 registerCommitter(commitBindings)
-registerMountHook(mountBindings)
-registerMountHook(mountConditions)
-registerUnmountHook(unmountBindings)
-registerUnmountHook(unmountConditions)
+registerMountHook(mountBindings, "bindings")
+registerMountHook(mountConditions, "conditions")
+registerUnmountHook(unmountBindings, "bindings")
+registerUnmountHook(unmountConditions, "conditions")
 registerStateReleaseHook(releaseBindings)
 
 if (typeof document !== "undefined") mountDom(document)

package/framework/build.mjs

@@ -7,7 +7,7 @@ import { createEffectCodegen } from "./compiler/effect-codegen.mjs"
 import { generateListRuntime } from "./compiler/list-runtime-codegen.mjs"
 import { assetPath, browserPath, relativeModulePath, withBase } from "./compiler/path-helpers.mjs"
 import { createProjectSession } from "./compiler/project-session.mjs"
-import { createRouteBuildRecord, planRouteArtifacts } from "./compiler/route-build-record.mjs"
+import { createRouteBuildRecord, planRouteArtifacts, releaseRouteBuildRecordPlan } from "./compiler/route-build-record.mjs"
 import { createRouteArtifactReport } from "./compiler/route-artifact-report.mjs"
 import { planRuntimeFamilies } from "./compiler/runtime-family-planner.mjs"
 import { createSourceCompiler } from "./compiler/source-compiler.mjs"
@@ -33,10 +33,10 @@ async function loadConfig(root) {
 
 export async function build({ quiet = false, minify = true, root: projectRoot = process.cwd() } = {}) {
   const project = createProjectSession(projectRoot)
-  return buildWithSession(project, { quiet, minify })
+  return buildWithSession(project, { quiet, minify, retainCache: false })
 }
 
-export async function buildWithSession(project, { changedFiles, quiet = false, minify = true } = {}) {
+export async function buildWithSession(project, { changedFiles, quiet = false, minify = true, retainCache = true } = {}) {
   const { root, outputDirectory } = project
   const stagedOutput = join(root, ".kudzu-dist-staging")
   const backupOutput = join(root, ".kudzu-dist-backup")
@@ -45,9 +45,9 @@ export async function buildWithSession(project, { changedFiles, quiet = false, m
   try {
     await recoverOutput(outputDirectory, backupOutput)
     await rm(stagedOutput, { recursive: true, force: true })
-    const { result, pageCount, behaviorCount, cache } = await buildInto(project, stagedOutput, { changedFiles, minify })
+    const { result, pageCount, behaviorCount, cache } = await buildInto(project, stagedOutput, { changedFiles, minify, retainCache })
     await promoteOutput(stagedOutput, outputDirectory, backupOutput)
-    project.buildCache = cache
+    project.buildCache = retainCache ? cache : undefined
     if (!quiet) console.log(`Built ${pageCount} page(s), ${behaviorCount} interactive page(s) into dist/`)
     return result
   } finally {
@@ -63,12 +63,12 @@ export async function buildWithSession(project, { changedFiles, quiet = false, m
   }
 }
 
-async function buildInto(project, outputDirectory, { changedFiles, minify }) {
+async function buildInto(project, outputDirectory, { changedFiles, minify, retainCache }) {
   const { root, sourceDirectory, pagesDirectory, workDirectory } = project
-  const previous = project.buildCache
+  const previous = retainCache ? project.buildCache : undefined
   project.buildGeneration = (project.buildGeneration ?? 0) + 1
   project.buildDirectory = project.buildGeneration > 1 ? join(workDirectory, "build", String(project.buildGeneration)) : workDirectory
-  const { collectClientModules, compileClientModule, compiledPath, compileSource, layoutExportError, orderSourceStyles, reachableSourceFiles, safeStaticFiles } = createSourceCompiler(project)
+  const { collectClientModules, compileClientModule, compiledPath, compileSourceAsync, layoutExportError, orderSourceStyles, reachableSourceFiles, safeStaticFiles } = createSourceCompiler(project)
   const config = await loadConfig(root)
   const base = normalizeBase(config.base)
   const configuredStyles = normalizeStyles(config.styles, base, project)
@@ -122,7 +122,7 @@ async function buildInto(project, outputDirectory, { changedFiles, minify }) {
     if (file.endsWith(".worker.ts")) continue
     let result = !affectedSources.has(file) ? previous?.sourceResults.get(file) : undefined
     if (!result) {
-      result = compileSource(file, sourceFileSet, sourceIndex, staticFiles, cssModules, base)
+      result = await compileSourceAsync(file, sourceFileSet, sourceIndex, staticFiles, cssModules, base)
       compiledModules++
     }
     result = { ...result, buildModule: { ...result.buildModule, path: relative(root, compiledPath(file)).replaceAll(sep, "/") } }
@@ -139,12 +139,14 @@ async function buildInto(project, outputDirectory, { changedFiles, minify }) {
     if (!handler || handler.kind !== "module-export" || handler.role !== "effect") throw new Error(`EffectIR ${effect.slot} has no effect HandlerIR`)
     return effect.workers.map(worker => ({ ...worker, module: assetPath(base, `assets/${result.handlerModule.path}`), handler: handler.exportName }))
   }))
+  globalThis.gc?.()
 
   let routeRecords = []
   const routeDrafts = []
   const routeEntryTransforms = new Map()
   const routeEntrySources = new Map()
   const routeEntryPaths = new Map()
+  const routePlanPools = Object.fromEntries(["states", "params", "searchParams", "effects", "conditions", "lists", "commands", "nativeStates", "nativeScope", "bindingStates", "bindingScope", "scopeStates", "scopeBindings"].map(name => [name, new Map()]))
   const rewrites = []
   const emittedRoutes = new Set()
   const emittedApplicationRoutes = new Set()
@@ -249,8 +251,8 @@ async function buildInto(project, outputDirectory, { changedFiles, minify }) {
         navigationGroup.hasEffects ||= result.hasEffects
         navigationGroup.hasParams ||= result.hasParams
       }
-      const usesDependencyRuntime = usesRouteDependencyRuntime({ plan: result.plan, navigable, hasBindings: result.hasBindings, hasLists: result.hasLists })
-      const plan = { route: routePath, ...result.plan }
+      const plan = internRoutePlan({ route: routePath, ...result.plan }, routePlanPools)
+      const usesDependencyRuntime = usesRouteDependencyRuntime({ plan, navigable, hasBindings: result.hasBindings, hasLists: result.hasLists }, false)
       const entries = {
         ...(result.hasParams ? { param: paramPath } : {}),
         ...(result.hasEffects ? { effect: effectPath } : {}),
@@ -279,7 +281,13 @@ async function buildInto(project, outputDirectory, { changedFiles, minify }) {
       })
       routeRecords.push(record)
       if (navigationGroup) navigationGroup.buildRecords.push(record)
-      routeDrafts.push({ record, result, runtimeSchema, navigationGroup, applicationRoute, effectPath, nativePath, paramPath })
+      routeDrafts.push({ record, runtimeSchema, navigationGroup, applicationRoute, effectPath, nativePath, paramPath })
+      if (!retainCache && config.afterBuild === undefined) {
+        const routeDirectory = join(outputDirectory, record.output)
+        await mkdir(routeDirectory, { recursive: true })
+        await writeFile(join(routeDirectory, "index.html"), record.html)
+        record.html = ""
+      }
     }
     pageRenders.set(pageFile, {
       drafts: routeDrafts.slice(draftOffset).map(({ navigationGroup: _, ...draft }) => draft),
@@ -303,14 +311,16 @@ async function buildInto(project, outputDirectory, { changedFiles, minify }) {
     group.assetPath = assetPath(base, `assets/runtime/${group.runtimeFamily.id}/${group.assetName}`)
   }
   const runtimeFamilyByRecord = new Map()
-  routeRecords = routeDrafts.map(draft => {
-    const { record, result, runtimeSchema, navigationGroup, effectPath, nativePath, paramPath } = draft
+  const finalizedRecords = []
+  for (const draft of routeDrafts) {
+    const { record, runtimeSchema, navigationGroup, effectPath, nativePath, paramPath } = draft
     const family = runtimePlan.familyByRecord.get(record)
     if (record.capabilities.hasBehaviors && !family) throw new Error(`Interactive route has no runtime family: ${record.route}`)
     const runtimeDirectory = family ? join(outputDirectory, "assets", "runtime", family.id) : undefined
     const routeRuntimeName = record.capabilities.usesDependencyRuntime ? "kudzu-deps.js" : "kudzu.js"
     const entries = {}
-    let html = record.html
+    const routeFile = join(outputDirectory, record.output, "index.html")
+    let html = retainCache || config.afterBuild !== undefined ? record.html : await readFile(routeFile, "utf8")
     if (record.capabilities.hasParams) {
       const entry = retainRouteEntry(paramPath, output => printParamEntry(runtimeSchema, record.plan.params, record.plan.searchParams, record.plan.searchParamsWritable, output, runtimeDirectory, base, routeRuntimeName, record.capabilities.navigable), routeEntrySources, routeEntryPaths, outputDirectory)
       entries.param = entry.path
@@ -330,25 +340,31 @@ async function buildInto(project, outputDirectory, { changedFiles, minify }) {
     }
     if (family) {
       html = html.replaceAll(runtimePlaceholder, escapeAttribute(assetPath(base, `assets/runtime/${family.id}/${routeRuntimeName}`)))
-      html = html.replaceAll(bindingPlaceholder, escapeAttribute(assetPath(base, `assets/runtime/${family.id}/kudzu-binding.js`)))
-      html = html.replaceAll(listPlaceholder, escapeAttribute(assetPath(base, `assets/runtime/${family.id}/kudzu-list.js`)))
+      if (record.capabilities.hasBindings) html = html.replaceAll(bindingPlaceholder, escapeAttribute(assetPath(base, `assets/runtime/${family.id}/kudzu-binding.js`)))
+      if (record.capabilities.hasLists) html = html.replaceAll(listPlaceholder, escapeAttribute(assetPath(base, `assets/runtime/${family.id}/kudzu-list.js`)))
     }
     if (navigationGroup) html = html.replaceAll(escapeAttribute(navigationAssets.get(record.route)), escapeAttribute(navigationGroup.assetPath))
-    const finalRecord = createRouteBuildRecord({
+    const finalRecord = retainCache ? createRouteBuildRecord({
       route: record.route,
       output: record.output,
       html,
       plan: record.plan,
-      handlerReferences: result.handlerReferences,
+      handlerReferences: record.artifacts.handlers,
       styles: record.artifacts.styles,
       capabilities: record.capabilities,
       entries,
       runtimeSchema
-    })
+    }) : Object.assign(record, { html: "", entries })
+    if (!retainCache) {
+      if ([runtimePlaceholder, bindingPlaceholder, listPlaceholder].some(placeholder => html.includes(placeholder))) throw new Error(`Runtime family placeholder survived in ${record.route}`)
+      await mkdir(dirname(routeFile), { recursive: true })
+      await writeFile(routeFile, preloadModules(html))
+    }
     if (family) runtimeFamilyByRecord.set(finalRecord, family)
     if (navigationGroup) navigationAssets.set(finalRecord.route, navigationGroup.assetPath)
-    return finalRecord
-  })
+    finalizedRecords.push(finalRecord)
+  }
+  routeRecords = finalizedRecords
 
   const assetsDirectory = join(outputDirectory, "assets")
   await mkdir(assetsDirectory, { recursive: true })
@@ -364,9 +380,15 @@ async function buildInto(project, outputDirectory, { changedFiles, minify }) {
     }
     if (module.code.includes("/__kudzu_worker_")) throw new Error(`Worker URL placeholder survived in ${module.path}`)
   }
-  const plans = routeRecords.map(record => record.plan)
+  const sortedRewrites = rewrites.sort((left, right) => runtimeSpecificity(right) - runtimeSpecificity(left) || left.pattern.localeCompare(right.pattern))
+  const releaseRoutePlans = !retainCache && config.afterBuild === undefined
+  const plans = releaseRoutePlans ? undefined : routeRecords.map(record => record.plan)
+  if (releaseRoutePlans) {
+    await writeRoutePlans(join(workDirectory, "kudzu-plan.json"), routeRecords, sortedRewrites, runtimeFamilyByRecord, routeDrafts)
+    globalThis.gc?.()
+  }
   const behaviorCount = routeRecords.filter(record => record.capabilities.hasBehaviors).length
-  for (let offset = 0; offset < routeRecords.length; offset += 64) {
+  for (let offset = 0; retainCache && offset < routeRecords.length; offset += 64) {
     await Promise.all(routeRecords.slice(offset, offset + 64).map(async record => {
       const routeDirectory = join(outputDirectory, record.output)
       await mkdir(routeDirectory, { recursive: true })
@@ -451,10 +473,9 @@ async function buildInto(project, outputDirectory, { changedFiles, minify }) {
     handlerMetafile = result.metafile
     await rm(join(assetsDirectory, "modules"), { recursive: true, force: true })
   }
-  const sortedRewrites = rewrites.sort((left, right) => runtimeSpecificity(right) - runtimeSpecificity(left) || left.pattern.localeCompare(right.pattern))
-  await writeFile(join(workDirectory, "kudzu-plan.json"), JSON.stringify({ routes: plans, rewrites: sortedRewrites }, null, 2))
+  if (!releaseRoutePlans) await writePrettyJson(join(workDirectory, "kudzu-plan.json"), { routes: plans, rewrites: sortedRewrites })
   const artifacts = createRouteArtifactReport(routeRecords, { base, handlerMetafile, outputDirectory, navigationAssets, runtimeFamilies: runtimePlan.families, runtimeFamilyByRecord, workerReferences: renderedWorkerReferences, workerOutputs })
-  await writeFile(join(workDirectory, "kudzu-artifacts.json"), JSON.stringify(artifacts, null, 2))
+  await writePrettyJson(join(workDirectory, "kudzu-artifacts.json"), artifacts)
   const emittedCssFiles = new Set()
   for (const file of cssFiles.filter(file => renderedStyleUrls.has(assetPath(base, `assets/${relative(sourceDirectory, file).replaceAll(sep, "/")}`)))) {
     const output = join(assetsDirectory, relative(sourceDirectory, file))
@@ -492,7 +513,7 @@ async function buildInto(project, outputDirectory, { changedFiles, minify }) {
   const incremental = { compiledModules, renderedPages }
   return {
     result: { sourceResults, incremental },
-    pageCount: plans.length,
+    pageCount: routeRecords.length,
     behaviorCount,
     cache: { pageRenders, pageSources, placeholders, sourceResults: sourceResultsByFile }
   }
@@ -555,8 +576,8 @@ function replayPageRender(cached, state) {
     if (navigationGroup) {
       state.navigationAssets.set(draft.record.route, navigationGroup.assetPath)
       navigationGroup.buildRecords.push(draft.record)
-      navigationGroup.hasEffects ||= draft.result.hasEffects
-      navigationGroup.hasParams ||= draft.result.hasParams
+      navigationGroup.hasEffects ||= draft.record.capabilities.hasEffects
+      navigationGroup.hasParams ||= draft.record.capabilities.hasParams
     }
     state.routeRecords.push(draft.record)
     state.routeDrafts.push({ ...draft, navigationGroup })
@@ -688,6 +709,7 @@ function runtimeEffects(effects, lifetimes = false) {
     handler: effect.handler,
     ...(effect.dependencies ? { dependencies: effect.dependencies } : {}),
     ...(effect.dependencyExpressions ? { dependencyExpressions: effect.dependencyExpressions, dependencyStates: effect.dependencyStates } : {}),
+    ...(effect.dependencyEvaluators ? { dependencyEvaluators: effect.dependencyEvaluators } : {}),
     ...(effect.itemDependencies ? { itemDependencies: effect.itemDependencies, listState: effect.listState } : {}),
     ...(effect.cleanup ? { cleanup: true } : {}),
     ...(effect.owner ? { owner: effect.owner } : {}),
@@ -698,11 +720,94 @@ function runtimeEffects(effects, lifetimes = false) {
   }))
 }
 
+function internRoutePlan(plan, pools) {
+  for (const field of ["states", "params", "searchParams", "effects", "conditions", "lists"]) plan[field] = internJson(plan[field], pools[field])
+  for (const event of plan.events) {
+    if (event.commands) event.commands = internJson(event.commands, pools.commands)
+    if (event.native) {
+      event.native.states = internJson(event.native.states, pools.nativeStates)
+      event.native.scope = internJson(event.native.scope, pools.nativeScope)
+    }
+  }
+  for (const binding of plan.bindings) {
+    if (binding.states) binding.states = internJson(binding.states, pools.bindingStates)
+    if (binding.scope) binding.scope = internJson(binding.scope, pools.bindingScope)
+    if (binding.scopeStates) binding.scopeStates = internJson(binding.scopeStates, pools.scopeStates)
+    if (binding.scopeBindings) binding.scopeBindings = internJson(binding.scopeBindings, pools.scopeBindings)
+  }
+  return plan
+}
+
+function internJson(value, pool) {
+  const encoded = JSON.stringify(value)
+  const existing = pool.get(encoded)
+  if (existing !== undefined) return existing
+  pool.set(encoded, value)
+  return value
+}
+
 async function writeJavaScript(file, source, minify, define) {
   const code = minify || define ? (await transform(source, { define, format: "esm", legalComments: "none", minify, target: "es2022" })).code : source
   await writeFile(file, code)
 }
 
+async function writePrettyJson(file, value) {
+  const entries = Object.entries(value)
+  if (!entries.some(([, entry]) => Array.isArray(entry) && entry.length > 2048)) {
+    await writeFile(file, JSON.stringify(value, null, 2))
+    return
+  }
+  const output = await open(file, "w")
+  try {
+    await output.write("{\n")
+    for (let entryIndex = 0; entryIndex < entries.length; entryIndex++) {
+      const [key, entry] = entries[entryIndex]
+      const comma = entryIndex === entries.length - 1 ? "" : ","
+      if (!Array.isArray(entry) || entry.length <= 2048) {
+        await output.write(`  ${JSON.stringify(key)}: ${JSON.stringify(entry, null, 2).replaceAll("\n", "\n  ")}${comma}\n`)
+        continue
+      }
+      await output.write(`  ${JSON.stringify(key)}: [\n`)
+      for (let offset = 0; offset < entry.length; offset += 64) {
+        const batch = entry.slice(offset, offset + 64).map((item, index) => {
+          const separator = offset + index === entry.length - 1 ? "" : ","
+          return `    ${JSON.stringify(item, null, 2).replaceAll("\n", "\n    ")}${separator}\n`
+        }).join("")
+        await output.write(batch)
+      }
+      await output.write(`  ]${comma}\n`)
+    }
+    await output.write("}")
+  } finally {
+    await output.close()
+  }
+}
+
+async function writeRoutePlans(file, records, rewrites, familyByRecord, drafts) {
+  const output = await open(file, "w")
+  try {
+    await output.write(records.length ? '{\n  "routes": [\n' : '{\n  "routes": []')
+    for (let offset = 0; offset < records.length; offset += 64) {
+      const batch = records.slice(offset, offset + 64).map((record, index) => {
+        const recordIndex = offset + index
+        const separator = recordIndex === records.length - 1 ? "" : ","
+        const encoded = `    ${JSON.stringify(record.plan, null, 2).replaceAll("\n", "\n    ")}${separator}\n`
+        const family = familyByRecord.get(record)
+        if (family && !family.navigation) {
+          releaseRouteBuildRecordPlan(record)
+          if (drafts[recordIndex].record !== record) releaseRouteBuildRecordPlan(drafts[recordIndex].record)
+        }
+        return encoded
+      }).join("")
+      await output.write(batch)
+      if ((offset + 64) % 512 === 0) globalThis.gc?.()
+    }
+    await output.write(`${records.length ? "  ]" : ""},\n  "rewrites": ${JSON.stringify(rewrites, null, 2).replaceAll("\n", "\n  ")}\n}`)
+  } finally {
+    await output.close()
+  }
+}
+
 export async function writeRouteEntry(file, source, minify, transforms, transformSource = transform, write = writeFile) {
   let code = transforms.get(source)
   if (code === undefined) {

package/framework/compiler/ast-helpers.mjs

@@ -160,6 +160,11 @@ export function sourceLocation(node, fallbackSource) {
   return `${sourceFile.fileName}:${position.line + 1}:${position.character + 1}`
 }
 
+export function isNodeWithin(node, root) {
+  for (let current = node; current; current = current.parent) if (current === root) return true
+  return false
+}
+
 export function effectReturns(callback) {
   let cleanup = false
   let invalid

package/framework/compiler/browser-signal-passes.mjs

@@ -1,5 +1,5 @@
 import ts from "typescript"
-import { bindingNames, containsJsx, functionVarDeclaresName, importDeclarationNames, isShadowedIdentifier, isUnshadowedGlobal, nearestFunction, referenceIdentifiers, sourceNodeError, statementDeclaresName, unwrapExpression } from "./ast-helpers.mjs"
+import { bindingNames, containsJsx, functionVarDeclaresName, importDeclarationNames, isNodeWithin, isShadowedIdentifier, isUnshadowedGlobal, nearestFunction, referenceIdentifiers, sourceNodeError, statementDeclaresName, unwrapExpression } from "./ast-helpers.mjs"
 
 export function normalizeMediaQueryExternalStores(sourceFile, factory, context) {
     const imports = sourceFile.statements.filter(statement => ts.isImportDeclaration(statement) && !statement.importClause?.isTypeOnly && ts.isStringLiteral(statement.moduleSpecifier) && statement.moduleSpecifier.text === "react" && statement.importClause?.namedBindings && ts.isNamedImports(statement.importClause.namedBindings))
@@ -58,7 +58,7 @@ export function normalizeMediaQueryExternalStores(sourceFile, factory, context)
     }
     inspect(sourceFile)
     const references = referenceIdentifiers(sourceFile, "useSyncExternalStore")
-    if (references.length !== candidates.size) throw sourceNodeError(references.find(reference => ![...candidates.values()].some(candidate => insideNode(reference, candidate.declaration.initializer))) ?? externalStoreImport.entry, sourceFile, "useSyncExternalStore is supported only for direct static media query declarations")
+    if (references.length !== candidates.size) throw sourceNodeError(references.find(reference => ![...candidates.values()].some(candidate => isNodeWithin(reference, candidate.declaration.initializer))) ?? externalStoreImport.entry, sourceFile, "useSyncExternalStore is supported only for direct static media query declarations")
     const directHooks = new Set(imports.flatMap(statement => statement.importClause.namedBindings.elements.filter(entry => !entry.propertyName).map(entry => entry.name.text)))
     const missingHooks = ["useEffect", "useState"].filter(name => !directHooks.has(name))
     for (const name of missingHooks) {
@@ -105,11 +105,6 @@ export function normalizeMediaQueryExternalStores(sourceFile, factory, context)
     return ts.visitNode(sourceFile, visitor)
   }
 
-  function insideNode(node, root) {
-    for (let current = node; current; current = current.parent) if (current === root) return true
-    return false
-  }
-
 export function normalizeNavigatorCapabilityConditions(sourceFile, factory, context) {
     const candidates = new Map()
     let index = 0

package/framework/compiler/collection-analysis.mjs

@@ -45,6 +45,10 @@ export function analyzeCollectionPipeline(expression, options) {
   if (ts.isPropertyAccessExpression(value) && ts.isIdentifier(value.expression)) {
     const calculation = calculatedCollection?.(value)
     if (calculation) return { calculation, selector: [], selectorStates: new Set() }
+    if (stateNames.has(value.expression.text)) {
+      if (["__proto__", "constructor", "prototype"].includes(value.name.text)) fail(value, `Rendered collection property "${value.name.text}" is not supported`)
+      return { state: value.expression, calculation: value, selector: [], selectorStates: new Set() }
+    }
     return { state: undefined, ownerField: value.name.text, selector: [], parentItem: value.expression.text }
   }
   if (ts.isCallExpression(value) && ts.isIdentifier(value.expression) && importedCollectionTransforms.has(value.expression.text)) {

package/framework/compiler/descriptor-session.mjs

@@ -75,14 +75,30 @@ export function createDescriptorSession({ semantic, handlerUrl, factory, context
       : compileListExpression(read, expression, entry.item, entry.index, entry.states, entry.keyedBlock, indexed ? bindingIndex : undefined)
   }
 
-  function compileReactiveBinding(expression, { setters, importBindings = new Map(), keyedBlock }) {
+  function compileReactiveBinding(expression, { setters, importBindings = new Map(), keyedBlock, derived }) {
     const parts = conditionalParts(expression)
     const state = parts && directStateIdentifier(parts.condition, setters, bindingIndex)
     if (state && isPrimitiveLiteral(parts.truthy) && isPrimitiveLiteral(parts.falsy)) {
       return { node: factory.createCallExpression(factory.createIdentifier("__kSelect"), undefined, [state, parts.truthy, parts.falsy]) }
     }
     const binding = reactiveBindings.length
-    return { node: factory.createCallExpression(factory.createIdentifier("__kBinding"), undefined, compileReactiveExpression(expression, setters, importBindings, keyedBlock)), binding }
+    const node = factory.createCallExpression(factory.createIdentifier("__kBinding"), undefined, compileReactiveExpression(expression, setters, importBindings, keyedBlock))
+    if (derived) reactiveBindings[binding].derived = derived
+    return { node, binding }
+  }
+
+  function compileDerivedEvaluator(expression, { setters, importBindings = new Map() }) {
+    const binding = reactiveBindings.length
+    const [, module, handler, states, scope] = compileReactiveExpression(expression, setters, importBindings)
+    return {
+      binding,
+      descriptor: factory.createObjectLiteralExpression([
+        factory.createPropertyAssignment("module", module),
+        factory.createPropertyAssignment("handler", handler),
+        factory.createPropertyAssignment("states", states),
+        factory.createPropertyAssignment("scope", scope)
+      ])
+    }
   }
 
   function compileConditional(kind, expression, truthy, falsy, setters) {
@@ -125,12 +141,18 @@ export function createDescriptorSession({ semantic, handlerUrl, factory, context
   }
 
   function compileEvent(expression, { owner = "module", stateOwners = new Map(), setters, reducers, functions, listItem, keyedBlock, importBindings }) {
-    if (ts.isIdentifier(expression)) expression = functions.get(expression.text)
+    const directFunction = ts.isIdentifier(expression) ? functions.get(expression.text) : undefined
+    const directReducer = ts.isIdentifier(expression) ? reducers.get(expression.text) : undefined
+    const directImplementation = directReducer?.sharedAction?.directImplementation
+    const directSource = directFunction && ts.getOriginalNode(directFunction)
+    const actionSource = directImplementation && ts.getOriginalNode(directImplementation)
+    const directAction = directSource?.pos >= 0 && directSource.pos === actionSource?.pos && directSource.end === actionSource.end && directSource.getSourceFile().fileName === actionSource.getSourceFile().fileName ? directReducer.sharedAction : undefined
+    if (ts.isIdentifier(expression)) expression = directFunction
     if (!expression || (!ts.isArrowFunction(expression) && !ts.isFunctionExpression(expression) && !ts.isFunctionDeclaration(expression))) return undefined
-    const optimized = referencedReducerDispatches(expression.body, reducers, expression).size ? undefined : compileOptimizedEvent(expression, setters, stateOwners, owner, keyedBlock)
+    const optimized = referencedReducerDispatches(expression.body, reducers, expression).size ? undefined : compileOptimizedEvent(expression, setters, stateOwners, owner, keyedBlock, directAction ? [directAction.slot] : [])
     if (optimized) return optimized
     rejectWorkerConstructions(expression)
-    const descriptor = compileNativeCallback(expression, { setters, reducers, entries: nativeHandlers, importBindings, prefix: "handler", role: "native", listItem, keyedBlock, stateOwners })
+    const descriptor = compileNativeCallback(expression, { setters, reducers, entries: nativeHandlers, importBindings, prefix: "handler", role: "native", listItem, keyedBlock, stateOwners, actionSlots: directAction ? [directAction.slot] : [] })
     return factory.createCallExpression(factory.createIdentifier("__kNativeBehavior"), undefined, [
       factory.createStringLiteral(handlerUrl), factory.createStringLiteral(descriptor.exportName), descriptor.states, descriptor.scope
     ])
@@ -140,7 +162,7 @@ export function createDescriptorSession({ semantic, handlerUrl, factory, context
     return compileNativeCallback(expression, { ...options, entries: effectHandlers, prefix: "effect", role: "effect" })
   }
 
-  function compileNativeCallback(expression, { setters, reducers, entries, importBindings, prefix, role, listItem, keyedBlock, stateOwners, deferValues = false, snapshotNested = false, liveStates = new Set() }) {
+  function compileNativeCallback(expression, { setters, reducers, entries, importBindings, prefix, role, listItem, keyedBlock, stateOwners, actionSlots = [], deferValues = false, snapshotNested = false, liveStates = new Set() }) {
     const indexedBindingIndex = indexedReferences(bindingIndex, expression, expression) ? bindingIndex : undefined
     const allCaptures = nativeCaptureNames(expression, setters, indexedBindingIndex)
     const usedReducers = referencedReducerDispatches(expression.body, reducers, expression, indexedBindingIndex)
@@ -151,10 +173,11 @@ export function createDescriptorSession({ semantic, handlerUrl, factory, context
     const usedStates = referencedStateNames(expression.body, setters, expression, indexedBindingIndex)
     for (const name of usedReducers) {
       const reducer = reducers.get(name)
-      if (reducer.contextAction) for (const state of referencedStateNames(reducer.contextAction.body, reducer.states, reducer.contextAction, bindingIndex)) usedStates.add(state)
+      const direct = reducer.directImplementation ?? reducer.sharedAction?.directImplementation
+      if (direct) for (const state of referencedStateNames(direct.body, reducer.states ?? reducer.sharedAction.states, direct, bindingIndex)) usedStates.add(state)
     }
     const exportName = `${prefix}${entries.length}`
-    const entry = { exportName, expression, captures, deferValues, imports, listItem, keyedBlock, liveStates, role, setters: new Map([...setters].filter(([, state]) => usedStates.has(state))), reducers: new Map([...reducers].filter(([name]) => usedReducers.has(name))), snapshotNested, usedStates, signalRefs: new Map([...usedStates].map(name => [name, signal(name, expression, stateOwners, [...setters].filter(([, state]) => state === name).map(([setter]) => setter))])), bindingIndex: indexedBindingIndex }
+    const entry = { actionSlots, exportName, expression, captures, deferValues, imports, listItem, keyedBlock, liveStates, role, setters: new Map([...setters].filter(([, state]) => usedStates.has(state))), reducers: new Map([...reducers].filter(([name]) => usedReducers.has(name))), snapshotNested, usedStates, signalRefs: new Map([...usedStates].map(name => [name, signal(name, expression, stateOwners, [...setters].filter(([, state]) => state === name).map(([setter]) => setter))])), bindingIndex: indexedBindingIndex }
     entries.push(entry)
     const value = name => deferValues
       ? factory.createArrowFunction(undefined, undefined, [], undefined, factory.createToken(ts.SyntaxKind.EqualsGreaterThanToken), factory.createIdentifier(name))
@@ -172,14 +195,14 @@ export function createDescriptorSession({ semantic, handlerUrl, factory, context
     }
   }
 
-  function compileOptimizedEvent(expression, setters, stateOwners, owner, keyedBlock) {
+  function compileOptimizedEvent(expression, setters, stateOwners, owner, keyedBlock, actions = []) {
     const statements = ts.isBlock(expression.body) ? expression.body.statements : [factory.createExpressionStatement(expression.body)]
     let commands = statements.map(statement => ts.isExpressionStatement(statement) && canSpecializeCommand(statement.expression, expression, setters) ? compileEventCommand(statement.expression, setters) : undefined)
     if ((!commands.length || commands.some(command => !command)) && compileEventCommand.handler) commands = compileEventCommand.handler(expression, setters, bindingIndex)
     if (!commands?.length || commands.some(command => !command)) return undefined
     const original = ts.getOriginalNode(expression)
     const source = original.pos >= 0 && original.end >= 0 ? { file: sourceName(original.getSourceFile()), start: original.getStart(), end: original.end } : undefined
-    const handler = registerCommandHandler(moduleIR, commands.map(command => ({ ...command, reference: stateOwners.get(command.state) ?? stateReferences(expression).get(command.state) })), source)
+    const handler = registerCommandHandler(moduleIR, commands.map(command => ({ ...command, reference: stateOwners.get(command.state) ?? stateReferences(expression).get(command.state) })), source, actions)
     if (keyedBlock !== undefined) handler.keyedBlock = keyedBlock
     return generateCommandBehavior(moduleIR, handler, factory)
   }
@@ -244,7 +267,7 @@ export function createDescriptorSession({ semantic, handlerUrl, factory, context
           snapshot: lowered.captureSnapshots.includes(name)
         })),
         imports: entry.imports.map(entry => importSlot(importRecord(entry))),
-        actions: [...entry.reducers.values()].flatMap(reducer => reducer.sharedAction ? [reducer.sharedAction.slot] : []),
+        actions: [...new Set([...entry.actionSlots, ...[...entry.reducers.values()].flatMap(reducer => reducer.sharedAction ? [reducer.sharedAction.slot] : [])])],
         code: lowered.code,
         ...(source(entry.expression) ? { source: source(entry.expression) } : {})
       })
@@ -258,6 +281,7 @@ export function createDescriptorSession({ semantic, handlerUrl, factory, context
       signals: [...entry.states].map(name => entry.signalRefs.get(name)),
       captures: [...entry.captures].map(name => ({ ...(symbolSlot(entry, name) !== undefined ? { symbol: symbolSlot(entry, name) } : {}), name, source: "scope" })),
       imports: entry.imports.map(entry => importSlot(importRecord(entry))),
+      ...(entry.derived ? { derived: entry.derived } : {}),
       code: handlerLowering.lowerReactiveBinding(entry),
       ...(source(entry.expression) ? { source: source(entry.expression) } : {})
     })
@@ -293,7 +317,7 @@ export function createDescriptorSession({ semantic, handlerUrl, factory, context
 
   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, registerEffect: registerEffectResult, registerKeyedBlock: registerKeyedBlockResult, signal }
+  return { compileConditional, compileDerivedEvaluator, compileEffectCallback, compileEvent, compileListConditional, compileListValue, compileReactiveBinding, finalize, registerDerived: registerDerivedResult, registerEffect: registerEffectResult, registerKeyedBlock: registerKeyedBlockResult, signal }
 }
 
 function bindingIdentifier(name, names) {