@kudzujs/core 0.8.62 → 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
 
@@ -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, `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 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

@@ -65,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

@@ -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) {