@kudzujs/core 0.8.14 → 0.8.16

package/framework/build.mjs

@@ -1,12 +1,29 @@
-import { createServer } from "node:http"
 import { createHash, randomUUID } from "node:crypto"
-import { cp, mkdir, readFile, readdir, realpath, rm, stat, watch, writeFile } from "node:fs/promises"
+import { cp, mkdir, readFile, readdir, realpath, rm, stat, writeFile } from "node:fs/promises"
 import { dirname, extname, isAbsolute, join, relative, resolve, sep } from "node:path"
 import { pathToFileURL } from "node:url"
 import { build as bundle, transform } from "esbuild"
 import ts from "typescript"
+import { normalizeEffectAnimationFrameRefs } from "./compiler/animation-frame-pass.mjs"
+import { bindingNames, containsJsx, effectReturns, functionVarDeclaresName, importDeclarationNames, isFunctionLike, isLocalConst, isReferenceIdentifier, isShadowedByParameter, isShadowedIdentifier, isUnshadowedGlobal, nearestFunction, referenceIdentifiers, referencesIdentifier, sourceLocation, sourceNodeError, statementDeclaresName, unwrapExpression } from "./compiler/ast-helpers.mjs"
+import { normalizeMediaQueryExternalStores, normalizeNavigatorCapabilityConditions } from "./compiler/browser-signal-passes.mjs"
+import { analyzeCollectionPipeline, collectionExpression, collectionParameters, isArrayFromCall, mutatingCollectionMethods as mutatingListMethods, pureCollectionMathMethods as pureMathMethods, pureCollectionMethods as pureListMethods } from "./compiler/collection-analysis.mjs"
+import { normalizeCustomHookTimerRefs } from "./compiler/custom-hook-timer-pass.mjs"
+import { captureNames, createDescriptorSession, createSemanticArtifact, nativeCaptureNames, referencedReducerDispatches, referencedStateNames } from "./compiler/descriptor-session.mjs"
+import { createEffectCodegen } from "./compiler/effect-codegen.mjs"
+import { createEventCommandCompiler } from "./compiler/event-command-pass.mjs"
+import { createHandlerCodegen } from "./compiler/handler-codegen.mjs"
+import { applyNormalizationPasses } from "./compiler/normalization-pipeline.mjs"
+import { createReactMigrationPass, reactMemoExpression } from "./compiler/react-migration-pass.mjs"
+import { normalizeRenderControlFlow } from "./compiler/render-control-pass.mjs"
+import { createRouterPass } from "./compiler/router-pass.mjs"
+import { planRouteCapabilities, usesRouteDependencyRuntime } from "./compiler/route-capability-planner.mjs"
+import { createWorkerCompiler } from "./compiler/worker-compiler.mjs"
+import { createZustandPass } from "./compiler/zustand-pass.mjs"
 import { renderPage } from "./core.mjs"
-import { stateSchema } from "./dev-state.js"
+import { parseDevHost, parseDevPort, startDevServer } from "./dev-server.mjs"
+
+export { parseDevHost, parseDevPort }
 
 const root = process.cwd()
 const sourceDirectory = join(root, "src")
@@ -14,8 +31,8 @@ const pagesDirectory = join(sourceDirectory, "pages")
 const workDirectory = join(root, ".kudzu")
 const outputDirectory = join(root, "dist")
 const staticAssetExtensions = new Set([".avif", ".gif", ".ico", ".jpeg", ".jpg", ".otf", ".png", ".svg", ".ttf", ".webp", ".woff", ".woff2"])
-
-const devClient = (session, revision, schema) => `<script>(()=>{const show=event=>{let box=document.getElementById("__kudzu_error");if(!box){box=document.createElement("div");box.id="__kudzu_error";box.setAttribute("role","alert");box.setAttribute("aria-live","assertive");box.style.cssText="position:fixed;inset:0;z-index:2147483647;overflow:auto;padding:2rem;background:#200;color:#fff;font:16px/1.5 ui-monospace,monospace";const title=document.createElement("strong"),text=document.createElement("pre");title.textContent="Kudzu build error";text.style.whiteSpace="pre-wrap";box.append(title,text);document.body.append(box)}box.querySelector("pre").textContent=event.data};const schema=${inlineJson(schema)},route=location.pathname+location.search+location.hash,urls=[...document.querySelectorAll('script[type="module"][src]')].map(node=>node.src).filter(url=>/\\/assets\\/kudzu(?:-(?:binding|list|native))?\\.js$/.test(new URL(url).pathname));const devImport=import("/__kudzu_dev.js"),runtimeImports=Promise.allSettled(urls.map(url=>import(url)));const ready=(async()=>{const dev=await devImport,modules=await runtimeImports,runtime=modules.find(result=>result.status==="fulfilled"&&result.value.browserState instanceof Map&&typeof result.value.commitDom==="function")?.value;try{dev.restoreState(sessionStorage,route,runtime?.browserState,schema,runtime?.commitDom)}catch{}return{dev,runtime}})().catch(()=>({}));const events=new EventSource("/__kudzu_reload?session=${session}&revision=${revision}");let reloading=false;events.addEventListener("reload",async()=>{if(reloading)return;reloading=true;try{const{dev,runtime}=await ready;dev?.snapshotState(sessionStorage,route,runtime?.browserState,schema)}catch{}location.reload()});events.addEventListener("build-error",show)})()</script>`
+const compileEventCommand = createEventCommandCompiler({ isPrimitiveLiteral: isPrimitiveDefaultLiteral, synthesizeSerializableStateLiteral })
+const { analyzeZustandStores, normalizeZustandMigrationSyntax } = createZustandPass({ isSerializableStateLiteral, nativeCaptureNames, sourceDirectory })
 
 export async function build({ quiet = false, minify = true } = {}) {
   const config = await loadConfig()
@@ -63,14 +80,8 @@ export async function build({ quiet = false, minify = true } = {}) {
     if (handlerModule) handlerModules.push(handlerModule)
   }
 
-  let behaviorCount = 0
-  let regularBehaviorCount = 0
-  let bindingCount = 0
-  let listCount = 0
-  let listStyleCount = 0
-  let regularStateSeedCount = 0
-  let dependencyStateSeedCount = 0
   const plans = []
+  const routeCapabilities = new Map()
   const pageEntries = []
   const effectEntries = []
   const nativeEntries = []
@@ -151,27 +162,24 @@ export async function build({ quiet = false, minify = true } = {}) {
         navigationGroup.hasEffects ||= result.hasEffects
         navigationGroup.hasParams ||= result.hasParams
       }
-      const hasDependencies = result.plan.effects.some(effect => effect.dependencies?.length)
-      const usesDependencyRuntime = !navigable && hasDependencies && !result.plan.effects.some(effect => effect.owner) && !result.hasBindings && !result.hasLists && !result.plan.events.some(event => event.native)
+      const usesDependencyRuntime = usesRouteDependencyRuntime({ plan: result.plan, navigable, hasBindings: result.hasBindings, hasLists: result.hasLists })
       pageEntries.push({ route, html: result.html, usesDependencyRuntime })
       plans.push({ route: routePath, ...result.plan })
+      routeCapabilities.set(routePath, {
+        navigable,
+        usesDependencyRuntime,
+        hasBehaviors: result.hasBehaviors,
+        hasBindings: result.hasBindings,
+        hasLists: result.hasLists,
+        hasListStyles: result.hasListStyles,
+        hasStateSeed: result.hasStateSeed
+      })
       if (result.hasParams) paramEntries.push({ path: paramPath, schema: runtimeSchema, params: result.plan.params, searchParams: result.plan.searchParams, searchParamsWritable: result.plan.searchParamsWritable, usesDependencyRuntime, navigable })
       if (result.hasEffects) effectEntries.push({ path: effectPath, effects: runtimeEffects(result.plan.effects, navigable), paramPath: result.hasParams ? paramPath : undefined, usesDependencyRuntime, navigable })
       if (result.plan.events.some(event => event.native)) nativeEntries.push({
         path: nativePath,
         modules: [...new Set(result.plan.events.filter(event => event.native).map(event => event.native.module))]
       })
-      if (result.hasBehaviors) {
-        behaviorCount++
-        if (!usesDependencyRuntime) regularBehaviorCount++
-      }
-      if (result.hasBindings) bindingCount++
-      if (result.hasLists) listCount++
-      if (result.hasListStyles) listStyleCount++
-      if (result.hasStateSeed) {
-        if (usesDependencyRuntime) dependencyStateSeedCount++
-        else regularStateSeedCount++
-      }
     }
   }
 
@@ -189,7 +197,7 @@ export async function build({ quiet = false, minify = true } = {}) {
   const renderedEffects = new Set(plans.flatMap(plan => plan.effects.map(effect => `${effect.module}:${effect.handler}`)))
   const renderedWorkerReferences = workerReferences.filter(reference => renderedEffects.has(`${reference.module}:${reference.handler}`))
   if (renderedWorkerReferences.length && await exists(join(publicDirectory, "assets", "workers"))) throw new Error("public/assets/workers collides with Kudzu's generated Worker asset namespace")
-  const workerAssets = await emitWorkers(renderedWorkerReferences, sourceFileSet, assetsDirectory, base, minify)
+  const workerAssets = await workerCompiler.emit(renderedWorkerReferences, sourceFileSet, assetsDirectory, base, minify)
   for (const module of emittedHandlerModules) {
     for (const reference of workerReferences) {
       if (reference.module !== assetPath(base, `assets/${module.path}`)) continue
@@ -198,43 +206,41 @@ export async function build({ quiet = false, minify = true } = {}) {
     }
     if (module.code.includes("/__kudzu_worker_")) throw new Error(`Worker URL placeholder survived in ${module.path}`)
   }
-  const commandEvents = [...new Set(plans.flatMap(plan => plan.events.filter(event => event.commands).map(event => event.event)))].sort()
-  const nativeEvents = [...new Set(plans.flatMap(plan => plan.events.filter(event => event.native).map(event => event.event)))].sort()
-  const hasTextBindings = plans.some(plan => plan.bindings.some(binding => binding.target === "text"))
-  const hasSvgConditions = plans.some(plan => plan.conditions.some(condition => condition.svg))
-  const hasListConditions = plans.some(plan => plan.lists.some(list => list.conditions))
-  const hasSvgLists = plans.some(plan => plan.lists.some(list => list.svg))
-  const hasDeepListConditions = plans.some(plan => plan.lists.some(list => list.conditionHandlers))
-  const hasListTextRanges = plans.some(plan => plan.lists.some(list => list.textRanges))
-  const hasListAttributes = plans.some(plan => plan.lists.some(list => list.attributes))
-  const hasListEvents = plans.some(plan => plan.lists.some(list => list.events))
-  const hasListExpressions = plans.some(plan => plan.lists.some(list => list.expressions))
-  const hasListExpressionAttributes = plans.some(plan => plan.lists.some(list => list.expressionAttributes))
-  const hasListSeeds = plans.some(plan => plan.lists.some(list => list.seed || list.valueSeed))
-  const hasListEffects = plans.some(plan => plan.lists.some(list => list.effects))
-  const hasListRowHooks = plans.some(plan => plan.lists.some(list => list.rowStates?.length || list.rowRefs?.length))
-  const hasListRowRefs = plans.some(plan => plan.lists.some(list => list.rowRefs?.length))
-  const hasComplexListRowState = plans.some(plan => plan.lists.some(list => list.rowStates?.some(state => state.initialValue !== null && typeof state.initialValue === "object")))
-  const hasNestedLists = plans.some(plan => plan.lists.some(list => list.ownerField))
-  const hasCollectionSelectors = plans.some(plan => plan.lists.some(list => list.selector))
-  const hasCalculatedCollections = plans.some(plan => plan.lists.some(list => list.source))
-  const hasDerivedEffectDependencies = plans.some(plan => plan.effects.some(effect => effect.dependencyExpressions?.length))
-  const hasStaticCollections = plans.some(plan => plan.lists.some(list => list.static))
-  const hasListIndexes = plans.some(plan => plan.lists.some(list => list.indexed))
-  const hasListStableFastPaths = plans.some(plan => plan.lists.some(list => !list.children && !list.ownerField && list.key !== null && !list.indexed && !list.reducer && !list.selector))
-  const hasGeneralListRowHooks = hasListRowRefs || hasComplexListRowState || plans.some(plan => plan.lists.some(list => list.ownerField && (list.rowStates?.length || list.rowRefs?.length)))
-  const hasItemDependencies = plans.some(plan => plan.effects.some(effect => effect.itemDependencies?.length))
-  const hasListAsyncParts = hasListExpressions || hasListExpressionAttributes || hasListConditions
-  const hasListMounts = hasListConditions || hasNestedLists || plans.some(plan => plan.lists.some(list => list.mount))
-  const hasNestedStateCaptures = hasNestedCaptureState(plans)
-  const hasSetterCaptures = hasCaptureType(plans, "setter")
-  const hasEffectCaptures = plans.some(plan => plan.effects.some(effect => Object.keys(effect.scope).length))
-  const hasNativeHandlers = nativeEntries.length > 0
-  const hasEffects = effectEntries.length > 0
-  const hasNavigableEffects = effectEntries.some(entry => entry.navigable)
-  const hasNavigableOwners = effectEntries.some(entry => entry.navigable && entry.effects.some(effect => effect.owner))
-  const hasSharedRuntime = bindingCount || listCount || hasNativeHandlers || navigationRoutes.length
-  const hasDependencyRuntime = pageEntries.some(entry => entry.usesDependencyRuntime)
+  const capabilityManifest = planRouteCapabilities(plans, { routes: routeCapabilities, navigationRouteCount: navigationRoutes.length })
+  const {
+    routes: { behaviors: behaviorCount, regularBehaviors: regularBehaviorCount, regularStateSeeds: regularStateSeedCount, dependencyStateSeeds: dependencyStateSeedCount },
+    events: { command: commandEvents, native: nativeEvents, hasNativeHandlers },
+    bindings: { count: bindingCount, text: hasTextBindings, svgConditions: hasSvgConditions },
+    lists: {
+      count: listCount,
+      styleCount: listStyleCount,
+      conditions: hasListConditions,
+      svg: hasSvgLists,
+      deepConditions: hasDeepListConditions,
+      textRanges: hasListTextRanges,
+      attributes: hasListAttributes,
+      events: hasListEvents,
+      expressions: hasListExpressions,
+      expressionAttributes: hasListExpressionAttributes,
+      seeds: hasListSeeds,
+      effects: hasListEffects,
+      rowHooks: hasListRowHooks,
+      rowRefs: hasListRowRefs,
+      complexRowState: hasComplexListRowState,
+      nested: hasNestedLists,
+      selectors: hasCollectionSelectors,
+      calculated: hasCalculatedCollections,
+      static: hasStaticCollections,
+      indexes: hasListIndexes,
+      stableFastPaths: hasListStableFastPaths,
+      generalRowHooks: hasGeneralListRowHooks,
+      asyncParts: hasListAsyncParts,
+      mounts: hasListMounts
+    },
+    effects: { any: hasEffects, derivedDependencies: hasDerivedEffectDependencies, itemDependencies: hasItemDependencies, captures: hasEffectCaptures, navigable: hasNavigableEffects, navigableOwners: hasNavigableOwners },
+    captures: { nestedState: hasNestedStateCaptures, setter: hasSetterCaptures },
+    runtime: { shared: hasSharedRuntime, dependency: hasDependencyRuntime }
+  } = capabilityManifest
   const runtimeName = usesDependencyRuntime => usesDependencyRuntime ? "kudzu-deps.js" : "kudzu.js"
   for (const entry of pageEntries) {
     const routeDirectory = join(outputDirectory, entry.route)
@@ -399,11 +405,7 @@ export async function build({ quiet = false, minify = true } = {}) {
   for (const entry of effectEntries) {
     const output = join(assetsDirectory, entry.path)
     await mkdir(dirname(output), { recursive: true })
-    await writeJavaScript(output, entry.navigable
-      ? entry.effects.some(effect => effect.owner)
-        ? printOwnedNavigableEffectEntry(entry.effects, output, emittedHandlerModules, assetsDirectory, base)
-        : printNavigableEffectEntry(entry.effects, output, emittedHandlerModules, assetsDirectory, base)
-      : printEffectEntry(entry.effects, output, emittedHandlerModules, assetsDirectory, base, entry.paramPath, runtimeName(entry.usesDependencyRuntime)), minify)
+    await writeJavaScript(output, printEffectEntry(entry.effects, output, emittedHandlerModules, assetsDirectory, base, entry.paramPath, runtimeName(entry.usesDependencyRuntime), entry.navigable), minify)
   }
   const clientModules = await collectClientModules(emittedHandlerModules.flatMap(module => module.clientImports), sourceFileSet)
   for (const file of clientModules) {
@@ -540,559 +542,6 @@ async function printNativeEntry(entry, assetsDirectory, base, minify) {
   await writeJavaScript(output, `import { registerNativeModules } from ${JSON.stringify(runtime)}\n${imports}\nregisterNativeModules([${registrations}])`, minify)
 }
 
-function printEffectEntry(effects, output, handlerModules, assetsDirectory, base, paramPath, runtimeName) {
-  const hasCleanup = effects.some(effect => effect.cleanup)
-  const hasDependencies = effects.some(effect => effect.dependencies?.length || effect.itemDependencies?.length)
-  const hasOwners = effects.some(effect => effect.owner)
-  const hasDependencyExpressions = effects.some(effect => effect.dependencyExpressions?.length)
-  const moduleUrls = [...new Set(effects.map(effect => effect.module))]
-  const modules = moduleUrls.map(url => {
-    const module = handlerModules.find(entry => assetPath(base, `assets/${entry.path}`) === url)
-    if (!module) throw new Error(`Effect handler module was not emitted: ${url}`)
-    return module
-  })
-  const imports = [
-    hasCleanup || hasDependencies || hasOwners
-      ? `import * as __kRuntime from ${JSON.stringify(relativeModulePath(output, join(assetsDirectory, runtimeName)))}\nconst { browserState, commitDom } = __kRuntime`
-      : `import { browserState, commitDom } from ${JSON.stringify(relativeModulePath(output, join(assetsDirectory, runtimeName)))}`,
-    `import { createEffectContext } from ${JSON.stringify(relativeModulePath(output, join(assetsDirectory, "kudzu-effect.js")))}`,
-    ...(hasDependencyExpressions ? [`import { evaluateCollectionExpression as __kEvaluateDependency } from ${JSON.stringify(relativeModulePath(output, join(assetsDirectory, "kudzu-collection-selector.js")))}`] : []),
-    ...(paramPath ? [`import ${JSON.stringify(relativeModulePath(output, join(assetsDirectory, paramPath)))}`] : []),
-    ...modules.map((module, index) => `import * as __kEffectModule${index} from ${JSON.stringify(relativeModulePath(output, join(assetsDirectory, module.path)))}`)
-  ]
-  const entries = moduleUrls.map((url, index) => `[${JSON.stringify(url)}, __kEffectModule${index}]`).join(",")
-  if (hasOwners) return printOwnedEffectEntry(imports, effects, entries)
-  if (effects.length === 1 && effects[0].dependencies?.length === 1 && !hasDependencyExpressions) return printSingleDependencyEffect(imports, effects[0], hasCleanup)
-  const disposal = hasCleanup ? `
-let disposed = false
-const dispose = root => {
-  if (root !== document || disposed) return
-  disposed = true
-  active = false
-  pending.clear()
-  for (const record of records) invokeCleanup(record)
-}
-
-if (__kRuntime.registerUnmountHook) __kRuntime.registerUnmountHook(dispose)
-addEventListener("pagehide", event => {
-  if (event.persisted) return
-  if (__kRuntime.unmountDom) __kRuntime.unmountDom(document)
-  else dispose(document)
-})` : ""
-  if (hasDependencies) return `${imports.join("\n")}
-const effects = ${inlineJson(effects)}
-const modules = new Map([${entries}])
-const records = effects.map((effect, index) => ({ effect, index, values: undefined, cleanup: undefined, token: undefined }))
-const dependencies = new Map()
-const pending = new Set()
-let scheduled = false
-let flushing = false
-let active = true
-for (const record of records) {
-  for (const id of record.effect.dependencies ?? []) {
-    const subscribers = dependencies.get(id) ?? new Set()
-    subscribers.add(record)
-    dependencies.set(id, subscribers)
-  }
-}
-__kRuntime.registerCommitter(id => {
-  if (!active) return
-  for (const record of dependencies.get(id) ?? []) pending.add(record)
-  schedule()
-})
-for (const record of records) {
-  try {
-    record.values = readDependencies(record)
-    invoke(record)
-  } catch (error) {
-    console.error(error)
-  }
-}
-function schedule() {
-  if (!pending.size || scheduled || flushing) return
-  scheduled = true
-  queueMicrotask(flush)
-}
-async function flush() {
-  scheduled = false
-  if (!active) return pending.clear()
-  flushing = true
-  try {
-    const selected = [...pending].sort((left, right) => left.index - right.index)
-    pending.clear()
-    const changed = []
-    for (const record of selected) {
-      try {
-        const values = readDependencies(record)
-        if (!record.values || values.some((value, index) => !Object.is(value, record.values[index]))) {
-          record.values = values
-          changed.push(record)
-        }
-      } catch (error) {
-        console.error(error)
-      }
-    }
-    for (const record of changed) await invokeCleanup(record)
-    if (active) for (const record of changed) invoke(record)
-  } finally {
-    flushing = false
-    if (active) schedule()
-  }
-}
-function readDependencies(record) {
-${hasDependencyExpressions ? printDerivedDependencyRead("browserState") : ""}
-  return (record.effect.dependencies ?? []).map(id => {
-    const value = browserState.get(id)
-    if (value !== null && typeof value !== "string" && typeof value !== "boolean" && !(typeof value === "number" && Number.isFinite(value) && !Object.is(value, -0))) throw new Error("useEffect() dependency state must remain a JSON-safe primitive")
-    return value
-  })
-}
-function invoke(record) {
-  try {
-    const effect = record.effect
-    const token = { active: true }
-    record.token = token
-    const result = modules.get(effect.module)[effect.handler](createEffectContext(browserState, effect.states, commitDom, effect.scope, () => active && token.active && record.token === token))
-    if (effect.cleanup && typeof result === "function") record.cleanup = result
-    else if (result && typeof result.then === "function") result.catch(error => console.error(error))
-  } catch (error) {
-    console.error(error)
-  }
-}
-async function invokeCleanup(record) {
-  if (record.token) record.token.active = false
-  record.token = undefined
-  const cleanup = record.cleanup
-  record.cleanup = undefined
-  if (!cleanup) return
-  try {
-    await cleanup()
-  } catch (error) {
-    console.error(error)
-  }
-}${disposal}`
-  if (!hasCleanup) return `${imports.join("\n")}
-const effects = ${inlineJson(effects)}
-const modules = new Map([${entries}])
-for (const effect of effects) {
-  try {
-    const result = modules.get(effect.module)[effect.handler](createEffectContext(browserState, effect.states, commitDom, effect.scope))
-    if (result && typeof result.then === "function") result.catch(error => console.error(error))
-  } catch (error) {
-    console.error(error)
-  }
-}`
-  return `${imports.join("\n")}
-const effects = ${inlineJson(effects)}
-const modules = new Map([${entries}])
-const cleanups = []
-for (const effect of effects) {
-  try {
-    const result = modules.get(effect.module)[effect.handler](createEffectContext(browserState, effect.states, commitDom, effect.scope))
-    if (effect.cleanup && typeof result === "function") cleanups.push(result)
-    else if (result && typeof result.then === "function") result.catch(error => console.error(error))
-  } catch (error) {
-    console.error(error)
-  }
-}
-let cleaned = false
-const dispose = root => {
-  if (root !== document || cleaned) return
-  cleaned = true
-  for (const cleanup of cleanups) {
-    try {
-      const result = cleanup()
-      if (result && typeof result.then === "function") result.catch(error => console.error(error))
-    } catch (error) {
-      console.error(error)
-    }
-  }
-  cleanups.length = 0
-}
-if (__kRuntime.registerUnmountHook) __kRuntime.registerUnmountHook(dispose)
-addEventListener("pagehide", event => {
-  if (event.persisted) return
-  if (__kRuntime.unmountDom) __kRuntime.unmountDom(document)
-  else dispose(document)
-})`
-}
-
-function printNavigableEffectEntry(effects, output, handlerModules, assetsDirectory, base) {
-  const hasDependencyExpressions = effects.some(effect => effect.dependencyExpressions?.length)
-  const moduleUrls = [...new Set(effects.map(effect => effect.module))]
-  const modules = moduleUrls.map(url => {
-    const module = handlerModules.find(entry => assetPath(base, `assets/${entry.path}`) === url)
-    if (!module) throw new Error(`Effect handler module was not emitted: ${url}`)
-    return module
-  })
-  const imports = [
-    `import * as __kRuntime from ${JSON.stringify(relativeModulePath(output, join(assetsDirectory, "kudzu.js")))}`,
-    `import { createEffectContext } from ${JSON.stringify(relativeModulePath(output, join(assetsDirectory, "kudzu-effect.js")))}`,
-    ...(hasDependencyExpressions ? [`import { evaluateCollectionExpression as __kEvaluateDependency } from ${JSON.stringify(relativeModulePath(output, join(assetsDirectory, "kudzu-collection-selector.js")))}`] : []),
-    ...modules.map((module, index) => `import * as __kEffectModule${index} from ${JSON.stringify(relativeModulePath(output, join(assetsDirectory, module.path)))}`)
-  ]
-  const entries = moduleUrls.map((url, index) => `[${JSON.stringify(url)}, __kEffectModule${index}]`).join(",")
-  return `${imports.join("\n")}
-const effects = ${inlineJson(effects)}
-const modules = new Map([${entries}])
-export const mountLayoutEffects = () => mount("layout")
-export const mountRouteEffects = () => mount("route")
-function mount(lifetime) {
-  let active = true
-  let flushing
-  const records = effects.filter(effect => effect.lifetime === lifetime).map((effect, index) => ({ effect, index, values: undefined, cleanup: undefined, token: undefined }))
-  const dependencies = new Map()
-  const pending = new Set()
-  let scheduled = false
-  for (const record of records) for (const id of record.effect.dependencies ?? []) {
-    const subscribers = dependencies.get(id) ?? new Set()
-    subscribers.add(record)
-    dependencies.set(id, subscribers)
-  }
-  const unsubscribe = dependencies.size ? __kRuntime.registerCommitter(id => {
-    if (!active) return
-    for (const record of dependencies.get(id) ?? []) pending.add(record)
-    if (pending.size && !scheduled && !flushing) {
-      scheduled = true
-      queueMicrotask(flush)
-    }
-  }) : undefined
-  for (const record of records) {
-    try {
-      record.values = readDependencies(record)
-      invoke(record)
-    } catch (error) {
-      console.error(error)
-    }
-  }
-  async function flush() {
-    scheduled = false
-    if (!active) return pending.clear()
-    const operation = (async () => {
-      const selected = [...pending].sort((left, right) => left.index - right.index)
-      pending.clear()
-      const changed = []
-      for (const record of selected) {
-        try {
-          const values = readDependencies(record)
-          if (!record.values || values.some((value, index) => !Object.is(value, record.values[index]))) {
-            record.values = values
-            changed.push(record)
-          }
-        } catch (error) {
-          console.error(error)
-        }
-      }
-      for (const record of changed) await cleanup(record)
-      if (active) for (const record of changed) invoke(record)
-    })()
-    flushing = operation
-    try { await operation } finally {
-      if (flushing === operation) flushing = undefined
-      if (active && pending.size && !scheduled) {
-        scheduled = true
-        queueMicrotask(flush)
-      }
-    }
-  }
-  function readDependencies(record) {
-${hasDependencyExpressions ? printDerivedDependencyRead("__kRuntime.browserState") : ""}
-    return (record.effect.dependencies ?? []).map(id => {
-      const value = __kRuntime.browserState.get(id)
-      if (value !== null && typeof value !== "string" && typeof value !== "boolean" && !(typeof value === "number" && Number.isFinite(value) && !Object.is(value, -0))) throw new Error("useEffect() dependency state must remain a JSON-safe primitive")
-      return value
-    })
-  }
-  function invoke(record) {
-    const token = { active: true }
-    record.token = token
-    try {
-      const effect = record.effect
-      const result = modules.get(effect.module)[effect.handler](createEffectContext(__kRuntime.browserState, effect.states, __kRuntime.commitDom, effect.scope, () => active && token.active && record.token === token))
-      if (effect.cleanup && typeof result === "function") record.cleanup = result
-      else if (result && typeof result.then === "function") result.catch(error => console.error(error))
-    } catch (error) {
-      console.error(error)
-    }
-  }
-  async function cleanup(record) {
-    if (record.token) record.token.active = false
-    record.token = undefined
-    const current = record.cleanup
-    record.cleanup = undefined
-    if (!current) return
-    try { await current() } catch (error) { console.error(error) }
-  }
-  let disposal
-  return async function dispose() {
-    if (disposal) return disposal
-    disposal = (async () => {
-      active = false
-      unsubscribe?.()
-      pending.clear()
-      for (const record of records) if (record.token) record.token.active = false
-      if (flushing) await flushing
-      for (const record of records) await cleanup(record)
-    })()
-    return disposal
-  }
-}`
-}
-
-function printOwnedNavigableEffectEntry(effects, output, handlerModules, assetsDirectory, base) {
-  const hasItemDependencies = effects.some(effect => effect.itemDependencies?.length)
-  const hasDependencyExpressions = effects.some(effect => effect.dependencyExpressions?.length)
-  const moduleUrls = [...new Set(effects.map(effect => effect.module))]
-  const modules = moduleUrls.map(url => {
-    const module = handlerModules.find(entry => assetPath(base, `assets/${entry.path}`) === url)
-    if (!module) throw new Error(`Effect handler module was not emitted: ${url}`)
-    return module
-  })
-  const imports = [
-    `import * as __kRuntime from ${JSON.stringify(relativeModulePath(output, join(assetsDirectory, "kudzu.js")))}`,
-    `import { createEffectContext } from ${JSON.stringify(relativeModulePath(output, join(assetsDirectory, "kudzu-effect.js")))}`,
-    ...(hasDependencyExpressions ? [`import { evaluateCollectionExpression as __kEvaluateDependency } from ${JSON.stringify(relativeModulePath(output, join(assetsDirectory, "kudzu-collection-selector.js")))}`] : []),
-    ...modules.map((module, index) => `import * as __kEffectModule${index} from ${JSON.stringify(relativeModulePath(output, join(assetsDirectory, module.path)))}`)
-  ]
-  const entries = moduleUrls.map((url, index) => `[${JSON.stringify(url)}, __kEffectModule${index}]`).join(",")
-  return `${imports.join("\n")}
-const effects = ${inlineJson(effects)}
-const modules = new Map([${entries}])
-export const mountLayoutEffects = () => mount("layout")
-export const mountRouteEffects = () => mount("route")
-function mount(lifetime) {
-  let active = true
-  let flushing
-  let order = 0
-  const selectedEffects = effects.map((effect, index) => ({ effect, index })).filter(entry => entry.effect.lifetime === lifetime)
-  const records = new Set()
-  const owners = new Map()
-  const listTemplates = new Map()
-  const registrations = new WeakMap()
-  const dependencies = new Map()
-  const pending = new Set()
-  const startedCleanups = new Set()
-  let scheduled = false
-  for (const template of selectedEffects) {
-    if (template.effect.list) listTemplates.set(template.effect.owner, template)
-    else {
-      const record = createRecord(template, !template.effect.owner)
-      if (template.effect.owner) owners.set(template.effect.owner, record)
-    }
-  }
-  const unsubscribeCommitter = selectedEffects.some(({ effect }) => effect.dependencies?.length) ? __kRuntime.registerCommitter(id => {
-    if (!active) return
-    for (const record of dependencies.get(id) ?? []) if (record.mounted) pending.add(record)
-    schedule()
-  }) : undefined
-  const unsubscribeMount = __kRuntime.registerMountHook(mountOwned)
-  const unsubscribeUnmount = __kRuntime.registerUnmountHook(unmountOwned)
-  ${hasItemDependencies ? `const unsubscribeItems = [...new Set(selectedEffects.filter(({ effect }) => effect.itemDependencies?.length).map(({ effect }) => effect.listState))].map(listState => __kRuntime.registerListItemHook(listState, root => {
-    if (!active) return
-    for (const record of registrations.get(root) ?? []) if (record.mounted && record.effect.itemDependencies) pending.add(record)
-    schedule()
-  }))
-  ` : ""}for (const record of records) if (record.mounted) start(record)
-  mountOwned(document)
-  function createRecord(template, mounted = true) {
-    const record = { ...template, order: order++, mounted, marker: undefined, version: 0, values: undefined, cleanup: undefined, disposal: undefined, token: undefined }
-    records.add(record)
-    registerDependencies(record)
-    return record
-  }
-  function registerDependencies(record) {
-    for (const id of record.effect.dependencies ?? []) {
-      const subscribers = dependencies.get(id) ?? new Set()
-      subscribers.add(record)
-      dependencies.set(id, subscribers)
-    }
-  }
-  function unregisterDependencies(record) {
-    for (const id of record.effect.dependencies ?? []) {
-      const subscribers = dependencies.get(id)
-      subscribers?.delete(record)
-      if (!subscribers?.size) dependencies.delete(id)
-    }
-  }
-  function mountOwned(root) {
-    if (!active) return
-    for (const marker of matching(root)) {
-      if (!marker.isConnected) continue
-      if (marker.dataset.kEffects) {
-        if (registrations.has(marker)) continue
-        const rowRecords = JSON.parse(marker.dataset.kEffects).flatMap(owner => {
-          const template = listTemplates.get(owner)
-          if (!template) return []
-          const record = createRecord(template)
-          record.marker = marker
-          start(record)
-          return [record]
-        })
-        if (rowRecords.length) registrations.set(marker, rowRecords)
-        continue
-      }
-      const record = owners.get(marker.dataset.kEffect)
-      if (record && !record.mounted) mountRecord(record, marker)
-    }
-  }
-  function unmountOwned(root) {
-    if (!active) return
-    for (const marker of matching(root)) {
-      const rowRecords = registrations.get(marker)
-      if (rowRecords) {
-        for (const record of rowRecords) unmountRecord(record, true)
-        registrations.delete(marker)
-        continue
-      }
-      const record = owners.get(marker.dataset.kEffect)
-      if (record?.marker === marker) unmountRecord(record)
-    }
-  }
-  function matching(root) {
-    const selector = "template[data-k-effect],[data-k-effects]"
-    return [...(root.matches?.(selector) ? [root] : []), ...(root.querySelectorAll?.(selector) ?? [])]
-  }
-  function mountRecord(record, marker) {
-    record.mounted = true
-    record.marker = marker
-    const version = ++record.version
-    const begin = () => {
-      if (active && record.mounted && record.version === version && marker.isConnected) start(record)
-    }
-    if (record.disposal) record.disposal.then(begin)
-    else begin()
-  }
-  function unmountRecord(record, dynamic = false) {
-    if (!record.mounted) return
-    record.mounted = false
-    record.marker = undefined
-    record.version++
-    pending.delete(record)
-    if (dynamic) {
-      unregisterDependencies(record)
-      records.delete(record)
-    }
-    void cleanup(record)
-  }
-  function start(record) {
-    try {
-      record.values = readDependencies(record)
-      invoke(record)
-    } catch (error) {
-      console.error(error)
-    }
-  }
-  function schedule() {
-    if (!pending.size || scheduled || flushing) return
-    scheduled = true
-    queueMicrotask(flush)
-  }
-  async function flush() {
-    scheduled = false
-    if (!active) return pending.clear()
-    const operation = (async () => {
-      const changed = []
-      const selected = [...pending].filter(record => record.mounted).sort((left, right) => left.index - right.index || left.order - right.order)
-      pending.clear()
-      for (const record of selected) {
-        try {
-          const values = readDependencies(record)
-          if (!record.values || values.some((value, index) => !Object.is(value, record.values[index]))) changed.push([record, record.version])
-        } catch (error) {
-          console.error(error)
-        }
-      }
-      for (const [record] of changed) await cleanup(record)
-      if (active) for (const [record, version] of changed) if (record.mounted && record.version === version) {
-        try {
-          record.values = readDependencies(record)
-          invoke(record)
-        } catch (error) {
-          record.values = undefined
-          console.error(error)
-        }
-      }
-    })()
-    flushing = operation
-    try { await operation } finally {
-      if (flushing === operation) flushing = undefined
-      if (active) schedule()
-    }
-  }
-  function readDependencies(record) {
-${hasDependencyExpressions ? printDerivedDependencyRead("__kRuntime.browserState") : ""}
-    const values = (record.effect.dependencies ?? []).map(id => {
-      const value = __kRuntime.browserState.get(id)
-      if (value !== null && typeof value !== "string" && typeof value !== "boolean" && !(typeof value === "number" && Number.isFinite(value) && !Object.is(value, -0))) throw new Error("useEffect() dependency state must remain a JSON-safe primitive")
-      return value
-    })
-    ${hasItemDependencies ? `if (record.effect.itemDependencies) {
-      const item = JSON.parse(record.marker.dataset.kEffectItem)
-      for (const field of record.effect.itemDependencies) {
-        const value = item[field]
-        if (value !== null && typeof value !== "string" && typeof value !== "boolean" && !(typeof value === "number" && Number.isFinite(value) && !Object.is(value, -0))) throw new Error(\`useEffect() keyed item dependency "\${field}" must remain a JSON-safe primitive\`)
-        values.push(value)
-      }
-    }` : ""}
-    return values
-  }
-  function invoke(record) {
-    const token = { active: true }
-    record.token = token
-    try {
-      const effect = record.effect
-      const scope = effect.list
-        ? Object.fromEntries(Object.entries(effect.scope).map(([name, value]) => [name, value?.type === "list-item" ? JSON.parse(record.marker.dataset.kEffectItem) : value]))
-        : effect.scope
-      const result = modules.get(effect.module)[effect.handler](createEffectContext(__kRuntime.browserState, effect.states, __kRuntime.commitDom, scope, () => active && token.active && record.token === token))
-      if (effect.cleanup && typeof result === "function") record.cleanup = result
-      else if (result && typeof result.then === "function") result.catch(error => console.error(error))
-    } catch (error) {
-      console.error(error)
-    }
-  }
-  function cleanup(record) {
-    if (record.token) record.token.active = false
-    record.token = undefined
-    if (record.disposal) return record.disposal
-    const current = record.cleanup
-    record.cleanup = undefined
-    if (!current) return Promise.resolve()
-    const disposal = (async () => {
-      try { await current() } catch (error) { console.error(error) }
-    })()
-    record.disposal = disposal
-    startedCleanups.add(disposal)
-    disposal.finally(() => {
-      startedCleanups.delete(disposal)
-      if (record.disposal === disposal) record.disposal = undefined
-    })
-    return disposal
-  }
-  let disposal
-  return async function dispose() {
-    if (disposal) return disposal
-    disposal = (async () => {
-      active = false
-      unsubscribeCommitter?.()
-      ${hasItemDependencies ? "for (const unsubscribe of unsubscribeItems) unsubscribe()\n      " : ""}unsubscribeMount()
-      unsubscribeUnmount()
-      pending.clear()
-      for (const record of records) if (record.token) record.token.active = false
-      if (flushing) await flushing
-      const mounted = [...records].filter(record => record.mounted).sort((left, right) => left.index - right.index || left.order - right.order)
-      for (const record of mounted) {
-        record.mounted = false
-        await cleanup(record)
-      }
-      await Promise.all([...startedCleanups])
-      records.clear()
-    })()
-    return disposal
-  }
-}`
-}
-
 function runtimeEffects(effects, lifetimes = false) {
   return effects.map(effect => ({
     module: effect.module,
@@ -1109,328 +558,6 @@ function runtimeEffects(effects, lifetimes = false) {
   }))
 }
 
-function printDerivedDependencyRead(state) {
-  return `    if (record.effect.dependencyExpressions) return record.effect.dependencyExpressions.map(expression => {
-      const value = __kEvaluateDependency(expression, undefined, undefined, name => ${state}.get(record.effect.dependencyStates[name]))
-      if (value !== null && typeof value !== "string" && typeof value !== "boolean" && !(typeof value === "number" && Number.isFinite(value) && !Object.is(value, -0))) throw new Error("useEffect() derived dependency must remain a JSON-safe primitive")
-      return value
-    })`
-}
-
-function printOwnedEffectEntry(imports, effects, entries) {
-  const hasItemDependencies = effects.some(effect => effect.itemDependencies?.length)
-  const hasOrdinaryDependencies = effects.some(effect => effect.dependencies?.length)
-  const hasDependencyExpressions = effects.some(effect => effect.dependencyExpressions?.length)
-  const hasRowState = effects.some(effect => JSON.stringify([effect.dependencies, effect.dependencyStates, effect.states, effect.scope]).includes("$k"))
-  return `${imports.join("\n")}
-const effects = ${inlineJson(effects)}
-const modules = new Map([${entries}])
-${hasItemDependencies ? "let order = 0\n" : ""}const records = effects.map((effect, index) => effect.list ? undefined : createRecord(effect, index)).filter(Boolean)
-const listTemplates = new Map(effects.map((effect, index) => effect.list ? [effect.owner, { effect, index }] : undefined).filter(Boolean))
-const owners = new Map(records.filter(record => record.effect.owner).map(record => [record.effect.owner, record]))
-const listRegistrations = new WeakMap()
-const mountedRecords = new Set(records.filter(record => record.mounted))
-const dependencies = new Map()
-const pending = new Set()
-let scheduled = false
-let flushing = false
-let active = true
-for (const record of records) registerDependencies(record)
-function createRecord(effect, index${hasRowState ? ", marker" : ""}) {
-  return { effect: ${hasRowState ? "marker ? specializeRowEffect(effect, marker) : effect" : "effect"}, index, ${hasItemDependencies ? "order: order++, " : ""}mounted: !effect.owner, marker: undefined, version: 0, values: undefined, cleanup: undefined, disposal: undefined, token: undefined }
-}
-${hasRowState ? `function specializeRowEffect(effect, marker) {
-  const path = marker.dataset.kRowPath
-  const id = value => typeof value === "string" ? value.replace("$k", path) : value
-  const capture = value => value?.type === "state" || value?.type === "setter" || value?.type === "ref" ? { ...value, id: id(value.id) } : value?.type === "array" ? { ...value, value: value.value.map(capture) } : value?.type === "object" ? { ...value, value: value.value.map(([key, entry]) => [key, capture(entry)]) } : value
-  return { ...effect, dependencies: effect.dependencies?.map(id), dependencyStates: effect.dependencyStates && Object.fromEntries(Object.entries(effect.dependencyStates).map(([name, value]) => [name, id(value)])), states: Object.fromEntries(Object.entries(effect.states).map(([name, value]) => [name, id(value)])), scope: Object.fromEntries(Object.entries(effect.scope).map(([name, value]) => [name, capture(value)])) }
-}
-` : ""}
-function registerDependencies(record) {
-  for (const id of record.effect.dependencies ?? []) {
-  const subscribers = dependencies.get(id) ?? new Set()
-  subscribers.add(record)
-  dependencies.set(id, subscribers)
-  }
-}
-function unregisterDependencies(record) {
-  for (const id of record.effect.dependencies ?? []) {
-    const subscribers = dependencies.get(id)
-    subscribers?.delete(record)
-    if (!subscribers?.size) dependencies.delete(id)
-  }
-}
-${hasItemDependencies ? `if (${hasOrdinaryDependencies}) ` : ""}__kRuntime.registerCommitter(id => {
-  if (!active) return
-  for (const record of dependencies.get(id) ?? []) if (record.mounted) pending.add(record)
-  schedule()
-})
-${hasItemDependencies ? `for (const listState of new Set(effects.filter(effect => effect.itemDependencies?.length).map(effect => effect.listState))) __kRuntime.registerListItemHook(listState, root => {
-  if (!active) return
-  for (const record of listRegistrations.get(root) ?? []) if (record.mounted && record.effect.itemDependencies) pending.add(record)
-  schedule()
-})
-` : ""}__kRuntime.registerMountHook(root => {
-  if (!active) return
-  for (const marker of matching(root)) {
-    if (marker.dataset.kEffects) {
-      if (listRegistrations.has(marker)) continue
-      const rowRecords = JSON.parse(marker.dataset.kEffects).map(owner => {
-        const template = listTemplates.get(owner)
-        if (!template) throw new Error("Keyed row effect template was not emitted")
-        const record = createRecord(template.effect, template.index${hasRowState ? ", marker" : ""})
-        registerDependencies(record)
-        mount(record, marker)
-        return record
-      })
-      listRegistrations.set(marker, rowRecords)
-      continue
-    }
-    const record = owners.get(marker.dataset.kEffect)
-    if (!record?.mounted) mount(record, marker)
-  }
-})
-__kRuntime.registerUnmountHook(root => {
-  if (root === document) {
-    if (!active) return
-    active = false
-    pending.clear()
-    for (const record of [...mountedRecords]) unmount(record, record.effect.list)
-    return
-  }
-  for (const marker of matching(root)) {
-    const rowRecords = listRegistrations.get(marker)
-    if (rowRecords) {
-      for (const record of rowRecords) unmount(record, true)
-      listRegistrations.delete(marker)
-      continue
-    }
-    const record = owners.get(marker.dataset.kEffect)
-    if (record?.marker === marker) unmount(record)
-  }
-})
-for (const record of records) if (record.mounted) start(record)
-__kRuntime.mountDom(document)
-addEventListener("pagehide", event => {
-  if (!event.persisted) __kRuntime.unmountDom(document)
-})
-function matching(root) {
-  const selector = "template[data-k-effect],[data-k-effects]"
-  return [...(root.matches?.(selector) ? [root] : []), ...(root.querySelectorAll?.(selector) ?? [])]
-}
-function mount(record, marker) {
-  record.mounted = true
-  record.marker = marker
-  mountedRecords.add(record)
-  const version = ++record.version
-  const begin = () => {
-    if (!active || !record.mounted || record.version !== version || !marker.isConnected) return
-    start(record)
-  }
-  if (record.disposal) record.disposal.then(begin)
-  else begin()
-}
-function unmount(record, dynamic = false) {
-  if (!record.mounted) return
-  record.mounted = false
-  record.marker = undefined
-  mountedRecords.delete(record)
-  if (dynamic) unregisterDependencies(record)
-  record.version++
-  pending.delete(record)
-  invokeCleanup(record)
-}
-function start(record) {
-  try {
-    record.values = readDependencies(record)
-    invoke(record)
-  } catch (error) {
-    console.error(error)
-  }
-}
-function schedule() {
-  if (!pending.size || scheduled || flushing) return
-  scheduled = true
-  queueMicrotask(flush)
-}
-async function flush() {
-  scheduled = false
-  if (!active) return pending.clear()
-  flushing = true
-  try {
-    const selected = [...pending].filter(record => record.mounted).sort((left, right) => left.index - right.index${hasItemDependencies ? " || left.order - right.order" : ""})
-    pending.clear()
-    const changed = []
-    for (const record of selected) {
-      try {
-        const values = readDependencies(record)
-        if (!record.values || values.some((value, index) => !Object.is(value, record.values[index]))) changed.push([record, record.version])
-      } catch (error) {
-        console.error(error)
-      }
-    }
-    for (const [record] of changed) await invokeCleanup(record)
-    if (active) for (const [record, version] of changed) if (record.mounted && record.version === version) {
-      try {
-        record.values = readDependencies(record)
-        invoke(record)
-      } catch (error) {
-        record.values = undefined
-        console.error(error)
-      }
-    }
-  } finally {
-    flushing = false
-    if (active) schedule()
-  }
-}
-function readDependencies(record) {
-${hasDependencyExpressions ? printDerivedDependencyRead("browserState") : ""}
-  const values = (record.effect.dependencies ?? []).map(id => {
-    const value = browserState.get(id)
-    if (value !== null && typeof value !== "string" && typeof value !== "boolean" && !(typeof value === "number" && Number.isFinite(value) && !Object.is(value, -0))) throw new Error("useEffect() dependency state must remain a JSON-safe primitive")
-    return value
-  })
-  ${hasItemDependencies ? `if (record.effect.itemDependencies) {
-    const item = JSON.parse(record.marker.dataset.kEffectItem)
-    for (const field of record.effect.itemDependencies) {
-      const value = item[field]
-      if (value !== null && typeof value !== "string" && typeof value !== "boolean" && !(typeof value === "number" && Number.isFinite(value) && !Object.is(value, -0))) throw new Error(\`useEffect() keyed item dependency "\${field}" must remain a JSON-safe primitive\`)
-      values.push(value)
-    }
-  }` : ""}
-  return values
-}
-function invoke(record) {
-  const token = { active: true }
-  record.token = token
-  try {
-    const effect = record.effect
-    const scope = effect.list
-      ? Object.fromEntries(Object.entries(effect.scope).map(([name, value]) => [name, value?.type === "list-item" ? JSON.parse(record.marker.dataset.kEffectItem) : value]))
-      : effect.scope
-    const result = modules.get(effect.module)[effect.handler](createEffectContext(browserState, effect.states, commitDom, scope, () => active && token.active && record.token === token))
-    if (effect.cleanup && typeof result === "function") record.cleanup = result
-    else if (result && typeof result.then === "function") result.catch(error => console.error(error))
-  } catch (error) {
-    console.error(error)
-  }
-}
-function invokeCleanup(record) {
-  if (record.token) record.token.active = false
-  record.token = undefined
-  if (record.disposal) return record.disposal
-  const cleanup = record.cleanup
-  record.cleanup = undefined
-  if (!cleanup) return Promise.resolve()
-  const disposal = (async () => {
-    try {
-      await cleanup()
-    } catch (error) {
-      console.error(error)
-    }
-  })()
-  record.disposal = disposal
-  disposal.finally(() => {
-    if (record.disposal === disposal) record.disposal = undefined
-  })
-  return disposal
-}`
-}
-
-function printSingleDependencyEffect(imports, effect, hasCleanup) {
-  const disposal = hasCleanup ? `
-const dispose = root => {
-  if (root !== document || !active) return
-  active = false
-  pending = false
-  invokeCleanup()
-}
-if (__kRuntime.registerUnmountHook) __kRuntime.registerUnmountHook(dispose)
-addEventListener("pagehide", event => {
-  if (event.persisted) return
-  if (__kRuntime.unmountDom) __kRuntime.unmountDom(document)
-  else dispose(document)
-})` : ""
-  return `${imports.join("\n")}
-const effect = ${inlineJson(effect)}
-const dependency = effect.dependencies[0]
-let value
-let cleanup
-let token
-let active = true
-let pending = false
-let scheduled = false
-let running = false
-__kRuntime.registerCommitter(id => {
-  if (active && id === dependency) {
-    pending = true
-    schedule()
-  }
-})
-try {
-  value = readDependency()
-  invoke()
-} catch (error) {
-  console.error(error)
-}
-function schedule() {
-  if (!pending || scheduled || running) return
-  scheduled = true
-  queueMicrotask(flush)
-}
-async function flush() {
-  scheduled = false
-  if (!active) return
-  let next
-  try {
-    next = readDependency()
-  } catch (error) {
-    console.error(error)
-    return
-  }
-  pending = false
-  if (Object.is(next, value)) return
-  value = next
-  running = true
-  try {
-    await invokeCleanup()
-    if (active) invoke()
-  } finally {
-    running = false
-    if (active) schedule()
-  }
-}
-function readDependency() {
-  const next = browserState.get(dependency)
-  if (next !== null && typeof next !== "string" && typeof next !== "boolean" && !(typeof next === "number" && Number.isFinite(next) && !Object.is(next, -0))) throw new Error("useEffect() dependency state must remain a JSON-safe primitive")
-  return next
-}
-function invoke() {
-  try {
-    const current = { active: true }
-    token = current
-    const result = __kEffectModule0[effect.handler](createEffectContext(browserState, effect.states, commitDom, effect.scope, () => active && current.active && token === current))
-    if (effect.cleanup && typeof result === "function") cleanup = result
-    else if (result && typeof result.then === "function") result.catch(error => console.error(error))
-  } catch (error) {
-    console.error(error)
-  }
-}
-async function invokeCleanup() {
-  if (token) token.active = false
-  token = undefined
-  const current = cleanup
-  cleanup = undefined
-  if (!current) return
-  try {
-    await current()
-  } catch (error) {
-    console.error(error)
-  }
-}${disposal}`
-}
-
 function printParamEntry(schema, params, searchParams, searchParamsWritable, output, assetsDirectory, base, runtimeName, navigable) {
   const hasSearch = searchParams.length || searchParamsWritable
   const signature = hasSearch ? "pathname, search" : "pathname"
@@ -1500,20 +627,6 @@ addEventListener("popstate", () => ${searchParams.length ? "initializeSearch(loc
 ${searchInitializer}${prefix}${pathname}${query}${suffix}${writer}`
 }
 
-function hasCaptureType(value, type) {
-  if (!value || typeof value !== "object") return false
-  if (value.type === type) return true
-  return (Array.isArray(value) ? value : Object.values(value)).some(entry => hasCaptureType(entry, type))
-}
-
-function hasNestedCaptureState(value, insideCapture = false) {
-  if (!value || typeof value !== "object") return false
-  if (value.type === "state") return insideCapture
-  if (value.type === "array") return value.value.some(entry => hasNestedCaptureState(entry, true))
-  if (value.type === "object") return value.value.some(([, entry]) => hasNestedCaptureState(entry, true))
-  return (Array.isArray(value) ? value : Object.values(value)).some(entry => hasNestedCaptureState(entry, false))
-}
-
 export function specializeRuntime(source, events, hasStateSeed) {
   const specialized = specializeEvents(source, events)
   if (hasStateSeed) return specialized
@@ -1543,225 +656,17 @@ async function writeBundledJavaScript(file, source, minify, define) {
   await writeFile(file, result.outputFiles[0].contents)
 }
 
-export function parseDevPort(value) {
-  if (value === undefined || value.trim() === "") return 3000
-  if (!/^\d+$/.test(value)) throw new Error(`Invalid dev server port: ${value}`)
-  const port = Number(value)
-  if (port > 65535) throw new Error(`Invalid dev server port: ${value}`)
-  return port
-}
-
-export function parseDevHost(value) {
-  return value?.trim() || "127.0.0.1"
-}
-
 export async function dev({ port = parseDevPort(process.env.PORT), host = parseDevHost(process.env.HOST) } = {}) {
   if (!Number.isInteger(port) || port < 0 || port > 65535) throw new Error(`Invalid dev server port: ${port}`)
   if (typeof host !== "string" || !host.trim()) throw new Error(`Invalid dev server host: ${host}`)
   const base = normalizeBase((await loadConfig()).base)
-
-  let buildError
-  let revision = 0
-  const session = randomUUID()
-  try {
-    await build({ minify: false })
-    revision++
-  } catch (error) {
-    buildError = errorText(error)
-    console.error(error)
-  }
-
-  const clients = new Set()
-
-  const server = createServer(async (request, response) => {
-    try {
-      const url = new URL(request.url, "http://localhost")
-      const rawPathname = url.pathname
-      const pathname = decodeURIComponent(rawPathname)
-      if (pathname === "/__kudzu_reload") {
-        response.writeHead(200, {
-          "content-type": "text/event-stream; charset=utf-8",
-          "cache-control": "no-cache, no-transform",
-          connection: "keep-alive"
-        })
-        response.write(": connected\n\n")
-        clients.add(response)
-        request.on("close", () => clients.delete(response))
-        if (buildError) sendEvent(response, "build-error", buildError)
-        else if (url.searchParams.get("session") !== session || url.searchParams.get("revision") !== String(revision)) sendEvent(response, "reload")
-        return
-      }
-      if (pathname === "/__kudzu_dev.js") {
-        response.writeHead(200, { "content-type": "text/javascript; charset=utf-8", "cache-control": "no-store" })
-        response.end(await readFile(new URL("./dev-state.js", import.meta.url)))
-        return
-      }
-
-      const relativePath = stripBaseStrict(pathname, decodeURIComponent(base)).replace(/^\/+/, "")
-      let file = resolve(outputDirectory, relativePath)
-      if (!file.startsWith(`${outputDirectory}${sep}`) && file !== outputDirectory) throw new Error("Invalid path")
-
-      if ((await exists(file)) && (await stat(file)).isDirectory()) file = join(file, "index.html")
-      if (!(await exists(file)) && !extname(file)) file = join(file, "index.html")
-      let matchedRoute
-      if (!(await exists(file)) && !buildError) {
-        const plan = JSON.parse(await readFile(join(workDirectory, "kudzu-plan.json"), "utf8"))
-        const rewrite = plan.rewrites?.find(entry => runtimePathValues(rawPathname, entry, browserPath(base)))
-        if (rewrite) {
-          file = resolve(outputDirectory, rewrite.file)
-          matchedRoute = rewrite.pattern
-        }
-      }
-      const isHtml = extname(file) === ".html"
-      const content = isHtml
-        ? injectDevClient(buildError ? errorPage(buildError) : await readFile(file, "utf8"), session, revision, buildError ? [] : await devSchema(withBase(base, stripBaseStrict(pathname, decodeURIComponent(base))), matchedRoute))
-        : await readFile(file)
-      response.writeHead(200, {
-        "content-type": contentType(file),
-        "cache-control": "no-store"
-      })
-      response.end(content)
-    } catch {
-      response.writeHead(404, { "content-type": "text/plain; charset=utf-8", "cache-control": "no-store" })
-      response.end("Not found")
-    }
-  })
-
-  const listeningPort = await listenDevServer(server, port, host)
-  console.log(`Kudzu dev server: http://${host}:${listeningPort}`)
-
-  let timer
-  let rebuilding = false
-  let pending = false
-  let changedFile
-  const rebuild = async () => {
-    if (rebuilding) {
-      pending = true
-      return
-    }
-    rebuilding = true
-    do {
-      pending = false
-      try {
-        await build({ quiet: true, minify: false })
-        buildError = undefined
-        revision++
-        console.log(`Rebuilt after ${changedFile ?? "source change"}`)
-        for (const client of clients) sendEvent(client, "reload")
-      } catch (error) {
-        buildError = errorText(error)
-        console.error(error)
-        for (const client of clients) sendEvent(client, "build-error", buildError)
-      }
-    } while (pending)
-    rebuilding = false
-  }
-  const watcher = watch(sourceDirectory, { recursive: true })
-  for await (const event of watcher) {
-    changedFile = event.filename
-    clearTimeout(timer)
-    timer = setTimeout(rebuild, 80)
-  }
-}
-
-async function listenDevServer(server, port, host) {
-  let candidate = port
-  while (true) {
-    try {
-      await new Promise((resolve, reject) => {
-        const onError = error => {
-          server.off("listening", onListening)
-          reject(error)
-        }
-        const onListening = () => {
-          server.off("error", onError)
-          resolve()
-        }
-        server.once("error", onError)
-        server.once("listening", onListening)
-        server.listen(candidate, host)
-      })
-      return server.address().port
-    } catch (error) {
-      if (error.code !== "EADDRINUSE" || candidate === 0 || candidate === 65535) throw error
-      console.log(`Port ${candidate} is in use, trying ${candidate + 1}`)
-      candidate++
-    }
-  }
-}
-
-function injectDevClient(html, session, revision, schema) {
-  return `${html}${devClient(session, revision, schema).replace("binding|list|native", "binding|deps|list|native")}`
-}
-
-function stripBaseStrict(path, base) {
-  if (!base) return path
-  if (path === base) return "/"
-  if (path.startsWith(`${base}/`)) return path.slice(base.length)
-  throw new Error("Path is outside the configured base")
-}
-
-async function devSchema(pathname, matchedRoute) {
-  try {
-    const plan = JSON.parse(await readFile(join(workDirectory, "kudzu-plan.json"), "utf8"))
-    const route = matchedRoute ?? (pathname.replace(/\/(?:index\.html)?$/, "") || "/")
-    return stateSchema(plan.routes.find(entry => entry.route === route)?.states ?? [])
-  } catch {
-    return []
-  }
-}
-
-function runtimePathValues(pathname, rewrite, base) {
-  try {
-    let path = stripBrowserBase(pathname, base)
-    if (path.length > 1 && path.endsWith("/")) path = path.slice(0, -1)
-    const rawSegments = path.slice(1).split("/")
-    if (rawSegments.length !== rewrite.segments.length) return undefined
-    const values = Object.create(null)
-    for (let index = 0; index < rewrite.segments.length; index++) {
-      const segment = rewrite.segments[index]
-      const value = decodeRuntimeSegment(rawSegments[index], Boolean(segment.param))
-      if (segment.literal !== undefined && value !== segment.literal) return undefined
-      if (segment.param) values[segment.param] = value
-    }
-    return values
-  } catch {
-    return undefined
-  }
-}
-
-function stripBrowserBase(path, base) {
-  if (!base) return path
-  const pathSegments = path.slice(1).split("/")
-  const baseSegments = base.slice(1).split("/").map(segment => decodeURIComponent(segment))
-  if (pathSegments.length < baseSegments.length || baseSegments.some((segment, index) => decodeRuntimeSegment(pathSegments[index], false) !== segment)) throw new Error("Path is outside the configured base")
-  return `/${pathSegments.slice(baseSegments.length).join("/")}`
-}
-
-function decodeRuntimeSegment(raw, param) {
-  if (param && /%(?:2f|5c)/i.test(raw)) throw new Error("Encoded separator")
-  const value = decodeURIComponent(raw)
-  const decodedDots = value.replace(/%2e/gi, ".")
-  if (param && (!value || value === "." || value === ".." || decodedDots === "." || decodedDots === ".." || /[\\/?#]/.test(value) || [...value].some(character => character.charCodeAt(0) < 32 || character.charCodeAt(0) >= 127 && character.charCodeAt(0) <= 159) || /%(?:2f|5c)/i.test(value))) throw new Error("Invalid runtime parameter")
-  return value
+  return startDevServer({ build, port, host, base, sourceDirectory, workDirectory, outputDirectory })
 }
 
 function inlineJson(value) {
   return JSON.stringify(value).replaceAll("<", "\\u003c").replaceAll("\u2028", "\\u2028").replaceAll("\u2029", "\\u2029")
 }
 
-function errorPage(error) {
-  return `<!doctype html><html lang="en"><head><meta charset="utf-8"><title>Kudzu build error</title></head><body><div id="__kudzu_error" role="alert" aria-live="assertive" style="position:fixed;inset:0;overflow:auto;padding:2rem;background:#200;color:#fff;font:16px/1.5 ui-monospace,monospace"><strong>Kudzu build error</strong><pre style="white-space:pre-wrap">${escapeHtml(error)}</pre></div></body></html>`
-}
-
-function errorText(error) {
-  return String(error?.message ?? error)
-}
-
-function sendEvent(response, event, data = "") {
-  response.write(`event: ${event}\n${String(data).replaceAll("\r", "").split("\n").map(line => `data: ${line}\n`).join("")}\n`)
-}
-
 function escapeHtml(value) {
   return value.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;")
 }
@@ -1772,11 +677,7 @@ function escapeAttribute(value) {
 
 async function compile(file, sourceFiles, sourceIndex, staticFiles, importedAssets, cssModules, base, workerReferences) {
   const source = sourceIndex.get(file)
-  const nativeHandlers = []
-  const effectHandlers = []
-  const reactiveBindings = []
-  const listExpressions = []
-  const clientImports = new Set()
+  const semantic = createSemanticArtifact()
   const handlerPath = `handlers/${relative(sourceDirectory, file).replaceAll(sep, "/").replace(/\.(?:ts|tsx)$/, ".js")}`
   const result = ts.transpileModule(source, {
     fileName: file,
@@ -1786,7 +687,7 @@ async function compile(file, sourceFiles, sourceIndex, staticFiles, importedAsse
       jsx: ts.JsxEmit.ReactJSX,
       jsxImportSource: "@kudzujs/core"
     },
-    transformers: { before: [createKudzuTransformer(nativeHandlers, effectHandlers, reactiveBindings, listExpressions, assetPath(base, `assets/${handlerPath}`), file, sourceFiles, sourceIndex, staticFiles, importedAssets, cssModules, base, clientImports, workerReferences)] },
+    transformers: { before: [createKudzuTransformer({ semantic, handlerUrl: assetPath(base, `assets/${handlerPath}`), file, sourceFiles, sourceIndex, staticFiles, importedAssets, cssModules, base, workerReferences })] },
     reportDiagnostics: true
   })
 
@@ -1801,14 +702,10 @@ async function compile(file, sourceFiles, sourceIndex, staticFiles, importedAsse
   await mkdir(resolve(output, ".."), { recursive: true })
   await writeFile(output, result.outputText)
 
+    const { nativeHandlers, effectHandlers, reactiveBindings, listExpressions, clientImports } = semantic
   if (!nativeHandlers.length && !effectHandlers.length && !reactiveBindings.length && !listExpressions.length) return undefined
   const callbacks = [...nativeHandlers, ...effectHandlers]
-  const moduleSource = [
-    printClientImports([...callbacks, ...reactiveBindings].flatMap(handler => handler.imports ?? []), handlerPath),
-    ...callbacks.map(handler => printNativeHandler(handler)),
-    ...reactiveBindings.map(entry => printReactiveBinding(entry)),
-    ...listExpressions.map(entry => printListExpression(entry))
-  ].join("\n")
+  const moduleSource = printHandlerModule({ callbacks, reactiveBindings, listExpressions, handlerPath })
   const moduleResult = ts.transpileModule(moduleSource, {
     compilerOptions: { target: ts.ScriptTarget.ES2022, module: ts.ModuleKind.ESNext },
     reportDiagnostics: true
@@ -1840,259 +737,18 @@ function reachableSourceFiles(entries, sourceFiles, sourceIndex) {
     const sourceFile = parseSourceFile(file, sourceIndex.get(file))
     const visit = node => {
       const specifier = (ts.isImportDeclaration(node) || ts.isExportDeclaration(node)) && runtimeModuleReference(node) && node.moduleSpecifier
-      if (specifier && ts.isStringLiteral(specifier) && specifier.text.startsWith(".") && !isStaticImport(specifier.text)) {
-        try { queue.push(resolveSourceImport(file, specifier.text, sourceFiles)) } catch {}
-      }
-      const worker = relativeWorkerCandidate(node, sourceFile)
-      if (worker && ts.isStringLiteral(worker.url.arguments[0]) && worker.url.arguments[0].text.endsWith(".worker.ts")) {
-        try { queue.push(resolveSourceImport(file, worker.url.arguments[0].text, sourceFiles)) } catch {}
-      }
-      ts.forEachChild(node, visit)
-    }
-    visit(sourceFile)
-  }
-  return [...reachable].sort()
-}
-
-function normalizeReactRouterSyntax(sourceFile, factory, context, base) {
-  const links = new Set()
-  const params = new Set()
-  const searchHooks = new Set()
-  const navigateHooks = new Set()
-  for (const statement of sourceFile.statements) {
-    if ((ts.isExportDeclaration(statement) || ts.isImportDeclaration(statement)) && statement.moduleSpecifier && ts.isStringLiteral(statement.moduleSpecifier) && statement.moduleSpecifier.text === "react-router-dom") {
-      if (ts.isExportDeclaration(statement)) throw sourceNodeError(statement, sourceFile, "React Router exports are not supported; import Link directly where it renders")
-      const clause = statement.importClause
-      if (clause?.isTypeOnly) continue
-      if (!clause) throw sourceNodeError(statement, sourceFile, "Side-effect React Router imports are not supported")
-      if (clause.name) throw sourceNodeError(clause.name, sourceFile, "React Router default imports are not supported; use named Link, useParams, useSearchParams, or useNavigate imports")
-      const bindings = clause.namedBindings
-      if (!bindings || ts.isNamespaceImport(bindings)) throw sourceNodeError(bindings ?? statement, sourceFile, "React Router namespace imports are not supported; use named Link, useParams, useSearchParams, or useNavigate imports")
-      for (const entry of bindings.elements) {
-        if (entry.isTypeOnly) continue
-        const imported = (entry.propertyName ?? entry.name).text
-        if (imported === "NavLink") throw sourceNodeError(entry, sourceFile, "React Router NavLink active-route semantics cannot be erased to a native anchor")
-        if (imported === "Link") links.add(entry.name.text)
-        else if (imported === "useParams") params.add(entry.name.text)
-        else if (imported === "useSearchParams") searchHooks.add(entry.name.text)
-        else if (imported === "useNavigate") navigateHooks.add(entry.name.text)
-        else throw sourceNodeError(entry, sourceFile, `React Router ${imported} is not supported; only named Link, useParams, useSearchParams, and useNavigate imports can be lowered`)
-      }
-    }
-  }
-  if (!links.size && !params.size && !searchHooks.size && !navigateHooks.size) return sourceFile
-
-  let searchHelper = "__kUseSearchParam"
-  while (sourceFile.text.includes(searchHelper)) searchHelper += "_"
-  let searchWriterHelper = "__kUseSearchParamsWriter"
-  while (sourceFile.text.includes(searchWriterHelper)) searchWriterHelper += "_"
-  const searchDeclarations = new Set()
-  const searchReads = new Map()
-  const searchWrites = new Map()
-  const searchObjects = []
-  const collectSearchHooks = node => {
-    if (ts.isCallExpression(node) && ts.isIdentifier(node.expression) && searchHooks.has(node.expression.text) && !isShadowedIdentifier(node.expression, sourceFile)) {
-      const declaration = node.parent
-      const statement = declaration?.parent?.parent
-      const owner = nearestFunction(node)
-      const first = ts.isVariableDeclaration(declaration) && ts.isArrayBindingPattern(declaration.name) ? declaration.name.elements[0] : undefined
-      const second = ts.isVariableDeclaration(declaration) && ts.isArrayBindingPattern(declaration.name) ? declaration.name.elements[1] : undefined
-      if (node.questionDotToken || node.arguments.length || node.typeArguments?.length || !ts.isVariableDeclaration(declaration) || declaration.initializer !== node || !isLocalConst(declaration) || !owner || statement?.parent !== owner.body || !ts.isBindingElement(first) || !ts.isIdentifier(first.name) || declaration.name.elements.length > 2 || second && (!ts.isBindingElement(second) || !ts.isIdentifier(second.name))) {
-        throw sourceNodeError(node, sourceFile, "React Router useSearchParams must initialize one top-level const [params] or [params, setParams] binding")
-      }
-      const entry = { name: first.name.text, setter: second?.name.text, declaration, statement, owner }
-      searchDeclarations.add(declaration)
-      searchObjects.push(entry)
-    }
-    ts.forEachChild(node, collectSearchHooks)
-  }
-  collectSearchHooks(sourceFile)
-  const localBindingShadowed = (node, entry, name = entry.name) => {
-    for (let current = node.parent; current && current !== entry.owner; current = current.parent) {
-      if (isFunctionLike(current) && (current.parameters.some(parameter => bindingNames(parameter.name).includes(name)) || functionVarDeclaresName(current, name))) return true
-      if (ts.isBlock(current) && current.statements.some(statement => statement !== entry.statement && statementDeclaresName(statement, name))) return true
-      if (ts.isCaseBlock(current) && current.clauses.some(clause => clause.statements.some(statement => statement !== entry.statement && statementDeclaresName(statement, name)))) return true
-      if (ts.isCatchClause(current) && current.variableDeclaration && bindingNames(current.variableDeclaration.name).includes(name)) return true
-      if ((ts.isForStatement(current) || ts.isForInStatement(current) || ts.isForOfStatement(current)) && loopDeclaresName(current, name)) return true
-    }
-    return false
-  }
-  for (const entry of searchObjects) {
-    const collectReads = node => {
-      if (ts.isIdentifier(node) && node.text === entry.name && isReferenceIdentifier(node) && !localBindingShadowed(node, entry)) {
-        if (entry.setter && ts.isCallExpression(node.parent) && node.parent.arguments.includes(node) && ts.isIdentifier(node.parent.expression) && node.parent.expression.text === entry.setter) return
-        const property = node.parent
-        const call = property?.parent
-        const declaration = call?.parent
-        const statement = declaration?.parent?.parent
-        if (!ts.isPropertyAccessExpression(property) || property.expression !== node || property.name.text !== "get" || !ts.isCallExpression(call) || call.expression !== property || call.questionDotToken || call.typeArguments?.length || call.arguments.length !== 1 || !ts.isStringLiteral(call.arguments[0])) {
-          throw sourceNodeError(node, sourceFile, 'React Router search parameters only support direct get("static-name") reads')
-        }
-        if (!ts.isVariableDeclaration(declaration) || declaration.initializer !== call || !ts.isIdentifier(declaration.name) || !isLocalConst(declaration) || statement?.parent !== entry.owner.body) {
-          throw sourceNodeError(call, sourceFile, "React Router search parameter get() must directly initialize one top-level const identifier")
-        }
-        searchReads.set(call, call.arguments[0])
-        return
-      }
-      ts.forEachChild(node, collectReads)
-    }
-    collectReads(entry.owner.body)
-    if (!entry.setter) continue
-    const collectWrites = node => {
-      if (ts.isIdentifier(node) && node.text === entry.setter && isReferenceIdentifier(node) && !localBindingShadowed(node, entry, entry.setter)) {
-        const call = node.parent
-        if (!ts.isCallExpression(call) || call.expression !== node || call.questionDotToken || call.typeArguments?.length || nearestFunction(call) === entry.owner) throw sourceNodeError(node, sourceFile, "React Router search parameter setters may only be called directly from a nested browser callback")
-        if (call.arguments.length < 1 || call.arguments.length > 2) throw sourceNodeError(call, sourceFile, "React Router search parameter setters require one inline updater and optional { replace: true }")
-        const updater = unwrapExpression(call.arguments[0])
-        if ((!ts.isArrowFunction(updater) && !ts.isFunctionExpression(updater)) || updater.asteriskToken || updater.modifiers?.some(modifier => modifier.kind === ts.SyntaxKind.AsyncKeyword) || updater.parameters.length !== 1 || !ts.isIdentifier(updater.parameters[0].name)) throw sourceNodeError(call.arguments[0], sourceFile, "React Router search parameter setters require one synchronous inline updater with one identifier parameter")
-        let replace = false
-        if (call.arguments.length === 2) {
-          const options = unwrapExpression(call.arguments[1])
-          const property = ts.isObjectLiteralExpression(options) && options.properties.length === 1 ? options.properties[0] : undefined
-          const name = property && ts.isPropertyAssignment(property) && !ts.isComputedPropertyName(property.name) && (ts.isIdentifier(property.name) || ts.isStringLiteral(property.name)) ? property.name.text : undefined
-          if (name !== "replace" || property.initializer.kind !== ts.SyntaxKind.TrueKeyword) throw sourceNodeError(call.arguments[1], sourceFile, "React Router search parameter setters only support exactly { replace: true } as a second argument")
-          replace = true
-        }
-        searchWrites.set(call, { updater, replace })
-        return
-      }
-      ts.forEachChild(node, collectWrites)
-    }
-    collectWrites(entry.owner.body)
-  }
-
-  const navigateDeclarations = new Set()
-  const navigateCalls = new Map()
-  const navigateFunctions = []
-  const collectNavigateHooks = node => {
-    if (ts.isCallExpression(node) && ts.isIdentifier(node.expression) && navigateHooks.has(node.expression.text) && !isShadowedIdentifier(node.expression, sourceFile)) {
-      const declaration = node.parent
-      const statement = declaration?.parent?.parent
-      const owner = nearestFunction(node)
-      if (node.questionDotToken || node.arguments.length || node.typeArguments?.length || !ts.isVariableDeclaration(declaration) || declaration.initializer !== node || !ts.isIdentifier(declaration.name) || !isLocalConst(declaration) || !owner || statement?.parent !== owner.body) {
-        throw sourceNodeError(node, sourceFile, "React Router useNavigate must initialize one top-level const identifier in a component")
-      }
-      const entry = { name: declaration.name.text, declaration, statement, owner }
-      navigateDeclarations.add(declaration)
-      navigateFunctions.push(entry)
-    }
-    ts.forEachChild(node, collectNavigateHooks)
-  }
-  collectNavigateHooks(sourceFile)
-  for (const entry of navigateFunctions) {
-    const collectCalls = node => {
-      if (ts.isIdentifier(node) && node.text === entry.name && isReferenceIdentifier(node) && !localBindingShadowed(node, entry)) {
-        const call = node.parent
-        if (!ts.isCallExpression(call) || call.expression !== node || call.questionDotToken || call.typeArguments?.length || nearestFunction(call) === entry.owner) {
-          throw sourceNodeError(node, sourceFile, "React Router navigate bindings may only be called directly from a nested browser callback")
-        }
-        if (call.arguments.length < 1 || call.arguments.length > 2 || !ts.isStringLiteral(call.arguments[0])) {
-          throw sourceNodeError(call, sourceFile, 'React Router useNavigate requires a static root-relative navigate("/path") destination')
-        }
-        const destination = call.arguments[0].text
-        const pathname = destination.match(/^[^?#]*/)[0]
-        let decoded
-        try { decoded = decodeURIComponent(pathname) } catch { throw sourceNodeError(call.arguments[0], sourceFile, 'React Router useNavigate requires a safe static root-relative navigate("/path") destination') }
-        if (!destination.startsWith("/") || destination.startsWith("//") || /%(?:2f|5c)/i.test(pathname) || /[\\\0]/.test(decoded) || decoded.split("/").includes("..") || [...decoded].some(character => character.charCodeAt(0) < 32 || character.charCodeAt(0) >= 127 && character.charCodeAt(0) <= 159)) throw sourceNodeError(call.arguments[0], sourceFile, 'React Router useNavigate requires a safe static root-relative navigate("/path") destination')
-        let method = "assign"
-        if (call.arguments.length === 2) {
-          const options = unwrapExpression(call.arguments[1])
-          const property = ts.isObjectLiteralExpression(options) && options.properties.length === 1 ? options.properties[0] : undefined
-          const name = property && ts.isPropertyAssignment(property) && !ts.isComputedPropertyName(property.name) && (ts.isIdentifier(property.name) || ts.isStringLiteral(property.name)) ? property.name.text : undefined
-          if (name !== "replace" || property.initializer.kind !== ts.SyntaxKind.TrueKeyword) throw sourceNodeError(call.arguments[1], sourceFile, 'React Router useNavigate only supports exactly { replace: true } as a second argument')
-          method = "replace"
-        }
-        navigateCalls.set(call, { method, destination: withBase(base, destination) })
-        return
-      }
-      ts.forEachChild(node, collectCalls)
-    }
-    collectCalls(entry.owner.body)
-  }
-
-  const routerProps = new Set(["discover", "end", "prefetch", "preventScrollReset", "relative", "reloadDocument", "replace", "state", "viewTransition"])
-  const attributes = attributesNode => {
-    const output = []
-    let destination
-    for (const property of attributesNode.properties) {
-      if (ts.isJsxSpreadAttribute(property)) throw sourceNodeError(property, sourceFile, "React Router Link does not support spread attributes during native anchor lowering")
-      const name = property.name.text
-      if (name === "href") throw sourceNodeError(property, sourceFile, "React Router Link must not declare href; Kudzu derives it from to")
-      if (routerProps.has(name)) throw sourceNodeError(property, sourceFile, `React Router Link prop ${JSON.stringify(name)} cannot be erased to a native anchor`)
-      if (name !== "to") {
-        output.push(ts.visitEachChild(property, visitor, context))
-        continue
+      if (specifier && ts.isStringLiteral(specifier) && specifier.text.startsWith(".") && !isStaticImport(specifier.text)) {
+        try { queue.push(resolveSourceImport(file, specifier.text, sourceFiles)) } catch {}
       }
-      if (destination !== undefined) throw sourceNodeError(property, sourceFile, "React Router Link requires exactly one to attribute")
-      if (!property.initializer || !ts.isStringLiteral(property.initializer)) throw sourceNodeError(property, sourceFile, 'React Router Link requires a static root-relative to="/path"')
-      destination = property.initializer.text
-      const pathname = destination.match(/^[^?#]*/)[0]
-      let decoded
-      try { decoded = decodeURIComponent(pathname) } catch { throw sourceNodeError(property.initializer, sourceFile, 'React Router Link requires a safe static root-relative to="/path"') }
-      if (!destination.startsWith("/") || destination.startsWith("//") || /%(?:2f|5c)/i.test(pathname) || /[\\\0]/.test(decoded) || decoded.split("/").includes("..") || [...decoded].some(character => character.charCodeAt(0) < 32 || character.charCodeAt(0) >= 127 && character.charCodeAt(0) <= 159)) throw sourceNodeError(property.initializer, sourceFile, 'React Router Link requires a safe static root-relative to="/path"')
-      output.push(factory.createJsxAttribute(factory.createIdentifier("href"), factory.createStringLiteral(withBase(base, destination))))
-    }
-    if (destination === undefined) throw sourceNodeError(attributesNode.parent, sourceFile, "React Router Link requires exactly one static root-relative to attribute")
-    return factory.updateJsxAttributes(attributesNode, output)
-  }
-  const importedLink = tag => ts.isIdentifier(tag) && links.has(tag.text) && !isShadowedIdentifier(tag, sourceFile)
-  const visitor = node => {
-    if (ts.isVariableStatement(node) && node.declarationList.declarations.some(declaration => searchDeclarations.has(declaration) || navigateDeclarations.has(declaration))) {
-      const declarations = node.declarationList.declarations.flatMap(declaration => {
-        if (navigateDeclarations.has(declaration)) return []
-        if (!searchDeclarations.has(declaration)) return [ts.visitEachChild(declaration, visitor, context)]
-        const entry = searchObjects.find(candidate => candidate.declaration === declaration)
-        if (!entry?.setter) return []
-        return [factory.updateVariableDeclaration(declaration, declaration.name, declaration.exclamationToken, declaration.type, factory.createCallExpression(factory.createIdentifier(searchWriterHelper), undefined, []))]
-      })
-      if (!declarations.length) return undefined
-      return factory.updateVariableStatement(node, node.modifiers, factory.updateVariableDeclarationList(node.declarationList, declarations))
-    }
-    if (ts.isCallExpression(node) && searchReads.has(node)) return factory.createCallExpression(factory.createIdentifier(searchHelper), undefined, [searchReads.get(node)])
-    if (ts.isCallExpression(node) && searchWrites.has(node)) {
-      const { updater, replace } = searchWrites.get(node)
-      return factory.createCallExpression(factory.createPropertyAccessExpression(factory.createIdentifier("globalThis"), "__kSetSearchParams"), undefined, [ts.visitNode(updater, visitor), replace ? factory.createTrue() : factory.createFalse()])
-    }
-    if (ts.isCallExpression(node) && navigateCalls.has(node)) {
-      const { method, destination } = navigateCalls.get(node)
-      return factory.createCallExpression(factory.createPropertyAccessExpression(factory.createPropertyAccessExpression(factory.createIdentifier("globalThis"), "location"), method), undefined, [factory.createStringLiteral(destination)])
-    }
-    if (ts.isJsxElement(node) && importedLink(node.openingElement.tagName)) {
-      const opening = factory.updateJsxOpeningElement(node.openingElement, factory.createIdentifier("a"), node.openingElement.typeArguments, attributes(node.openingElement.attributes))
-      const closing = factory.updateJsxClosingElement(node.closingElement, factory.createIdentifier("a"))
-      return factory.updateJsxElement(node, opening, ts.visitNodes(node.children, visitor), closing)
-    }
-    if (ts.isJsxSelfClosingElement(node) && importedLink(node.tagName)) return factory.updateJsxSelfClosingElement(node, factory.createIdentifier("a"), node.typeArguments, attributes(node.attributes))
-    if (ts.isCallExpression(node) && ts.isIdentifier(node.expression) && params.has(node.expression.text) && !isShadowedIdentifier(node.expression, sourceFile)) {
-      if (node.questionDotToken || node.arguments.length || (node.typeArguments?.length ?? 0) > 1) throw sourceNodeError(node, sourceFile, "React Router useParams must be called directly without runtime arguments and with at most one type argument")
-      return node
-    }
-    if (ts.isIdentifier(node) && links.has(node.text) && isReferenceIdentifier(node) && !isShadowedIdentifier(node, sourceFile)) throw sourceNodeError(node, sourceFile, "React Router Link imports may only be used as direct JSX elements")
-    if (ts.isIdentifier(node) && params.has(node.text) && isReferenceIdentifier(node) && !isShadowedIdentifier(node, sourceFile)) throw sourceNodeError(node, sourceFile, "React Router useParams imports may only be called directly")
-    if (ts.isIdentifier(node) && searchHooks.has(node.text) && isReferenceIdentifier(node) && !isShadowedIdentifier(node, sourceFile)) throw sourceNodeError(node, sourceFile, "React Router useSearchParams imports may only initialize the supported top-level tuple binding")
-    if (ts.isIdentifier(node) && navigateHooks.has(node.text) && isReferenceIdentifier(node) && !isShadowedIdentifier(node, sourceFile)) throw sourceNodeError(node, sourceFile, "React Router useNavigate imports may only initialize the supported top-level navigate binding")
-    if (ts.isImportDeclaration(node) && ts.isStringLiteral(node.moduleSpecifier) && node.moduleSpecifier.text === "react-router-dom") {
-      const clause = node.importClause
-      if (!clause || clause.isTypeOnly) return node
-      const bindings = clause.namedBindings
-      if (!bindings || !ts.isNamedImports(bindings)) return node
-      const elements = bindings.elements.filter(entry => entry.isTypeOnly || !["Link", "useParams", "useSearchParams", "useNavigate"].includes((entry.propertyName ?? entry.name).text))
-      if (!elements.length) return undefined
-      return factory.updateImportDeclaration(node, node.modifiers, factory.updateImportClause(clause, clause.isTypeOnly, undefined, factory.updateNamedImports(bindings, elements)), node.moduleSpecifier, node.attributes)
+      const worker = workerCompiler.candidate(node, sourceFile)
+      if (worker && ts.isStringLiteral(worker.url.arguments[0]) && worker.url.arguments[0].text.endsWith(".worker.ts")) {
+        try { queue.push(resolveSourceImport(file, worker.url.arguments[0].text, sourceFiles)) } catch {}
+      }
+      ts.forEachChild(node, visit)
     }
-    return ts.visitEachChild(node, visitor, context)
+    visit(sourceFile)
   }
-  const normalized = ts.visitNode(sourceFile, visitor)
-  if (!params.size && !searchHooks.size) return normalized
-  const imports = [
-    ...[...params].map(name => factory.createImportSpecifier(false, name === "useParams" ? undefined : factory.createIdentifier("useParams"), factory.createIdentifier(name))),
-    ...(searchReads.size ? [factory.createImportSpecifier(false, factory.createIdentifier("useSearchParam"), factory.createIdentifier(searchHelper))] : []),
-    ...(searchObjects.some(entry => entry.setter) ? [factory.createImportSpecifier(false, factory.createIdentifier("useSearchParamsWriter"), factory.createIdentifier(searchWriterHelper))] : [])
-  ]
-  const declaration = factory.createImportDeclaration(undefined, factory.createImportClause(false, undefined, factory.createNamedImports(imports)), factory.createStringLiteral("@kudzujs/core"))
-  const statements = [...normalized.statements]
-  statements.splice(statements.findLastIndex(statement => ts.isImportDeclaration(statement)) + 1, 0, declaration)
-  return factory.updateSourceFile(normalized, statements)
+  return [...reachable].sort()
 }
 
 function normalizeClsxSyntax(sourceFile, factory, context) {
@@ -2142,360 +798,6 @@ function normalizeClsxSyntax(sourceFile, factory, context) {
   return ts.visitNode(sourceFile, visitor)
 }
 
-function analyzeZustandStores(sourceFile) {
-  const createNames = new Set()
-  for (const statement of sourceFile.statements) {
-    if (!ts.isImportDeclaration(statement) || statement.importClause?.isTypeOnly || !ts.isStringLiteral(statement.moduleSpecifier) || statement.moduleSpecifier.text !== "zustand") continue
-    const bindings = statement.importClause?.namedBindings
-    if (statement.importClause?.name || !bindings || !ts.isNamedImports(bindings)) throw sourceNodeError(statement, sourceFile, "Zustand migration input requires a named create import")
-    for (const entry of bindings.elements) {
-      if (entry.isTypeOnly) continue
-      if ((entry.propertyName ?? entry.name).text !== "create") throw sourceNodeError(entry, sourceFile, "Only Zustand create is supported")
-      createNames.add(entry.name.text)
-    }
-  }
-  const stores = new Map()
-  if (!createNames.size) return stores
-  for (const statement of sourceFile.statements) {
-    if (!ts.isVariableStatement(statement) || !statement.modifiers?.some(modifier => modifier.kind === ts.SyntaxKind.ExportKeyword)) continue
-    for (const declaration of statement.declarationList.declarations) {
-      if (!ts.isIdentifier(declaration.name) || !declaration.initializer || !ts.isCallExpression(declaration.initializer) || !ts.isIdentifier(declaration.initializer.expression) || !createNames.has(declaration.initializer.expression.text)) continue
-      const callback = declaration.initializer.arguments[0]
-      if (declaration.initializer.arguments.length !== 1 || !callback || (!ts.isArrowFunction(callback) && !ts.isFunctionExpression(callback)) || callback.parameters.length !== 1 || !ts.isIdentifier(callback.parameters[0].name) || callback.asteriskToken || callback.modifiers?.some(modifier => modifier.kind === ts.SyntaxKind.AsyncKeyword)) throw sourceNodeError(declaration.initializer, sourceFile, "Zustand create() requires one synchronous initializer with one set parameter")
-      const body = unwrapExpression(callback.body)
-      if (!ts.isObjectLiteralExpression(body)) throw sourceNodeError(callback.body, sourceFile, "Zustand create() initializer must return one object literal")
-      const data = []
-      const actions = new Map()
-      for (const property of body.properties) {
-        if (!ts.isPropertyAssignment(property) || !property.name || !(ts.isIdentifier(property.name) || ts.isStringLiteral(property.name))) throw sourceNodeError(property, sourceFile, "Zustand store entries must be ordinary properties")
-        const name = property.name.text
-        const value = unwrapExpression(property.initializer)
-        if (ts.isArrowFunction(value) || ts.isFunctionExpression(value)) actions.set(name, value)
-        else data.push({ name, value })
-      }
-      if (data.length !== 1 || !isSerializableStateLiteral(data[0].value)) throw sourceNodeError(body, sourceFile, "Zustand migration stores require exactly one directly serializable data property")
-      if (!actions.size) throw sourceNodeError(body, sourceFile, "Zustand migration stores require at least one action")
-      for (const [name, action] of actions) {
-        if (action.asteriskToken || action.modifiers?.some(modifier => modifier.kind === ts.SyntaxKind.AsyncKeyword)) throw sourceNodeError(action, sourceFile, `Zustand action ${JSON.stringify(name)} must be synchronous`)
-        const capture = [...nativeCaptureNames(action, new Map())].find(entry => entry !== callback.parameters[0].name.text)
-        if (capture) throw sourceNodeError(action, sourceFile, `Zustand action ${JSON.stringify(name)} cannot capture ${JSON.stringify(capture)}`)
-        const validateAction = node => {
-          if (ts.isAwaitExpression(node) || ts.isYieldExpression(node) || ts.isNewExpression(node)) throw sourceNodeError(node, sourceFile, `Zustand action ${JSON.stringify(name)} must be synchronous`)
-          if (ts.isCallExpression(node) && ts.isPropertyAccessExpression(node.expression) && ["then", "catch", "finally"].includes(node.expression.name.text)) throw sourceNodeError(node, sourceFile, `Zustand action ${JSON.stringify(name)} cannot schedule asynchronous updates`)
-          if (ts.isCallExpression(node) && ts.isIdentifier(node.expression) && node.expression.text === callback.parameters[0].name.text && !isShadowedIdentifier(node.expression, action)) {
-            if (nearestFunction(node) !== action) throw sourceNodeError(node, sourceFile, `Zustand action ${JSON.stringify(name)} must call set directly`)
-            if (node.arguments.length !== 1) throw sourceNodeError(node, sourceFile, `Zustand action ${JSON.stringify(name)} set() requires exactly one partial update`)
-          }
-          ts.forEachChild(node, validateAction)
-        }
-        validateAction(action.body)
-      }
-      stores.set(declaration.name.text, { name: declaration.name.text, setName: callback.parameters[0].name.text, field: data[0].name, initialValue: data[0].value, actions, declaration })
-    }
-  }
-  const visit = node => {
-    const recognized = ts.isIdentifier(node) && ts.isCallExpression(node.parent) && node.parent.expression === node && [...stores.values()].some(store => store.declaration.initializer === node.parent)
-    if (ts.isIdentifier(node) && createNames.has(node.text) && isReferenceIdentifier(node) && !isShadowedIdentifier(node, sourceFile) && !recognized) throw sourceNodeError(node, sourceFile, "Zustand create must directly initialize an exported const store")
-    ts.forEachChild(node, visit)
-  }
-  visit(sourceFile)
-  return stores
-}
-
-function normalizeZustandMigrationSyntax(sourceFile, factory, context) {
-  const stores = analyzeZustandStores(sourceFile)
-  if (!stores.size) {
-    const declaration = sourceFile.statements.find(statement => ts.isImportDeclaration(statement) && ts.isStringLiteral(statement.moduleSpecifier) && statement.moduleSpecifier.text === "zustand" && !statement.importClause?.isTypeOnly)
-    if (declaration) throw sourceNodeError(declaration, sourceFile, "Zustand create must directly initialize an exported const store")
-    return sourceFile
-  }
-  const identity = name => `${relative(sourceDirectory, sourceFile.fileName).replaceAll(sep, "/")}#${name}`
-  const visitor = node => {
-    if (ts.isVariableDeclaration(node) && ts.isIdentifier(node.name) && stores.has(node.name.text)) {
-      const store = stores.get(node.name.text)
-      return factory.updateVariableDeclaration(node, node.name, node.exclamationToken, node.type, factory.createCallExpression(factory.createIdentifier("__kCreateStore"), undefined, [
-        factory.createStringLiteral(identity(store.name)),
-        factory.createStringLiteral(store.field),
-        store.initialValue,
-        factory.createArrayLiteralExpression([...store.actions.keys()].map(name => factory.createStringLiteral(name)))
-      ]))
-    }
-    if (ts.isImportDeclaration(node) && ts.isStringLiteral(node.moduleSpecifier) && node.moduleSpecifier.text === "zustand") return undefined
-    return ts.visitEachChild(node, visitor, context)
-  }
-  const normalized = ts.visitNode(sourceFile, visitor)
-  const declaration = factory.createImportDeclaration(undefined, factory.createImportClause(false, undefined, factory.createNamedImports([factory.createImportSpecifier(false, undefined, factory.createIdentifier("__kCreateStore"))])), factory.createStringLiteral("@kudzujs/core"))
-  const statements = [...normalized.statements]
-  statements.splice(statements.findLastIndex(statement => ts.isImportDeclaration(statement)) + 1, 0, declaration)
-  return factory.updateSourceFile(normalized, statements)
-}
-
-function normalizeReactMigrationSyntax(sourceFile, factory, context, importedCollections = new Set()) {
-  const supported = new Set(["createContext", "useContext", "useEffect", "useId", "useReducer", "useRef", "useState"])
-  const erased = new Set(["forwardRef", "memo", "useCallback", "useMemo"])
-  const aliases = new Map()
-  const reactObjects = new Set()
-  for (const statement of sourceFile.statements) {
-    if (!ts.isImportDeclaration(statement) || statement.importClause?.isTypeOnly || !ts.isStringLiteral(statement.moduleSpecifier) || statement.moduleSpecifier.text !== "react") continue
-    if (statement.importClause?.name) reactObjects.add(statement.importClause.name.text)
-    const bindings = statement.importClause?.namedBindings
-    if (bindings && ts.isNamespaceImport(bindings)) reactObjects.add(bindings.name.text)
-    if (bindings && ts.isNamedImports(bindings)) for (const entry of bindings.elements) {
-      const imported = (entry.propertyName ?? entry.name).text
-      if (!entry.isTypeOnly && (supported.has(imported) || erased.has(imported))) aliases.set(entry.name.text, imported)
-      else if (!entry.isTypeOnly && /^use[A-Z]/.test(imported)) throw sourceNodeError(entry, sourceFile, `React ${imported} is not supported by Kudzu migration input`)
-    }
-  }
-  if (!aliases.size && !reactObjects.size) return sourceFile
-
-  const migrationCallName = call => {
-    if (ts.isIdentifier(call.expression) && aliases.has(call.expression.text) && !isShadowedIdentifier(call.expression, sourceFile)) return aliases.get(call.expression.text)
-    if (ts.isPropertyAccessExpression(call.expression) && ts.isIdentifier(call.expression.expression) && reactObjects.has(call.expression.expression.text) && !isShadowedIdentifier(call.expression.expression, sourceFile)) return call.expression.name.text
-    return undefined
-  }
-  const ownerStateNames = owner => {
-    const names = new Set()
-    const collect = node => {
-      if (node !== owner && isFunctionLike(node)) return
-      if (ts.isVariableDeclaration(node) && ts.isArrayBindingPattern(node.name) && node.initializer && ts.isCallExpression(node.initializer) && ["useReducer", "useState"].includes(migrationCallName(node.initializer))) {
-        const state = node.name.elements[0]
-        if (state && ts.isBindingElement(state) && ts.isIdentifier(state.name)) names.add(state.name.text)
-      }
-      ts.forEachChild(node, collect)
-    }
-    collect(owner)
-    return names
-  }
-
-  const validate = node => {
-    if (ts.isTypeNode(node)) return
-    if (ts.isIdentifier(node) && aliases.has(node.text) && isReferenceIdentifier(node) && !isShadowedIdentifier(node, sourceFile) && !(ts.isCallExpression(node.parent) && node.parent.expression === node)) throw sourceNodeError(node, sourceFile, `Aliased React ${aliases.get(node.text)} must be called directly`)
-    if (ts.isIdentifier(node) && reactObjects.has(node.text) && isReferenceIdentifier(node) && !isShadowedIdentifier(node, sourceFile) && !(ts.isPropertyAccessExpression(node.parent) && node.parent.expression === node)) throw sourceNodeError(node, sourceFile, "React default or namespace imports may only be used for direct supported members or React.Fragment")
-    if (ts.isPropertyAccessExpression(node) && ts.isIdentifier(node.expression) && reactObjects.has(node.expression.text) && !isShadowedIdentifier(node.expression, sourceFile)) {
-      const name = node.name.text
-      if (name !== "Fragment" && !(ts.isCallExpression(node.parent) && node.parent.expression === node && (supported.has(name) || erased.has(name)))) throw sourceNodeError(node, sourceFile, `React.${name} is not supported; use a directly supported hook call or React.Fragment`)
-    }
-    ts.forEachChild(node, validate)
-  }
-  validate(sourceFile)
-
-  const memoLocals = new Map()
-  const collectMemoLocals = node => {
-    if (ts.isVariableDeclaration(node) && ts.isIdentifier(node.name) && node.initializer && ts.isCallExpression(node.initializer) && migrationCallName(node.initializer) === "useMemo") {
-      if (!isLocalConst(node)) throw sourceNodeError(node, sourceFile, "React useMemo() local values must use const declarations")
-      const callback = node.initializer.arguments[0]
-      if (callback && (ts.isArrowFunction(callback) || ts.isFunctionExpression(callback))) {
-        const expression = lowerReactMemoCollectionExpression(reactMemoExpression(callback), factory)
-        const owner = nearestFunction(node)
-        if (owner && expression) {
-          const entries = memoLocals.get(owner) ?? new Map()
-          if (entries.has(node.name.text)) throw sourceNodeError(node.name, sourceFile, `React useMemo() local ${JSON.stringify(node.name.text)} must be unique within its component`)
-          entries.set(node.name.text, { declaration: node, expression })
-          memoLocals.set(owner, entries)
-        }
-      }
-    }
-    ts.forEachChild(node, collectMemoLocals)
-  }
-  collectMemoLocals(sourceFile)
-  const memoLocalIsShadowed = (node, owner, entry) => {
-    if (isShadowedByParameter(node, owner)) return true
-    const declarationStatement = entry.declaration.parent?.parent
-    for (let current = node.parent; current && current !== owner; current = current.parent) {
-      if (ts.isFunctionExpression(current) && current.name?.text === node.text) return true
-      if (ts.isBlock(current) && current.statements.some(statement => statement !== declarationStatement && statementDeclaresName(statement, node.text))) return true
-      if (ts.isCaseBlock(current) && current.clauses.some(clause => clause.statements.some(statement => statement !== declarationStatement && statementDeclaresName(statement, node.text)))) return true
-      if (ts.isCatchClause(current) && current.variableDeclaration && bindingNames(current.variableDeclaration.name).includes(node.text)) return true
-      if ((ts.isForStatement(current) || ts.isForInStatement(current) || ts.isForOfStatement(current)) && loopDeclaresName(current, node.text)) return true
-    }
-    return false
-  }
-  for (const [owner, entries] of memoLocals) for (const [name, entry] of entries) {
-    const visit = node => {
-      if (ts.isIdentifier(node) && node.text === name && isReferenceIdentifier(node) && nearestFunctionLike(node) !== owner && !memoLocalIsShadowed(node, owner, entry)) throw sourceNodeError(node, sourceFile, `React useMemo() local ${JSON.stringify(name)} cannot be captured by a nested function`)
-      ts.forEachChild(node, visit)
-    }
-    visit(owner.body)
-  }
-
-  const required = new Set()
-  const imported = new Set()
-  const visitor = node => {
-    if (ts.isVariableStatement(node)) {
-      const entries = memoLocals.get(nearestFunction(node))
-      if (entries) {
-        for (const declaration of node.declarationList.declarations) if (ts.isIdentifier(declaration.name) && entries.has(declaration.name.text) && declaration.initializer) ts.visitNode(declaration.initializer, visitor)
-        const declarations = node.declarationList.declarations.filter(declaration => !ts.isIdentifier(declaration.name) || !entries.has(declaration.name.text))
-        if (!declarations.length) return undefined
-        if (declarations.length !== node.declarationList.declarations.length) return factory.updateVariableStatement(node, node.modifiers, factory.updateVariableDeclarationList(node.declarationList, declarations.map(declaration => ts.visitEachChild(declaration, visitor, context))))
-      }
-    }
-    if (ts.isIdentifier(node) && isReferenceIdentifier(node)) {
-      const owner = nearestFunctionLike(node)
-      const entry = memoLocals.get(owner)?.get(node.text)
-      if (entry && !memoLocalIsShadowed(node, owner, entry)) return ts.visitNode(cloneAst(entry.expression, factory, context), visitor)
-    }
-    if (ts.isCallExpression(node)) {
-      const name = migrationCallName(node)
-      if (name === "forwardRef") return ts.visitNode(lowerReactForwardRef(node, sourceFile, factory), visitor)
-      if (name === "memo") {
-        if (node.arguments.length !== 1 || !(ts.isArrowFunction(node.arguments[0]) || ts.isFunctionExpression(node.arguments[0]) || ts.isIdentifier(node.arguments[0]))) throw sourceNodeError(node, sourceFile, "React memo() requires exactly one function component or component identifier")
-        if (ts.isIdentifier(node.arguments[0]) && isShadowedIdentifier(node.arguments[0], sourceFile)) throw sourceNodeError(node.arguments[0], sourceFile, "React memo() component identifiers must resolve to an unshadowed same-file top-level function")
-        const component = ts.isIdentifier(node.arguments[0]) ? reactMemoComponentExpression(node.arguments[0], sourceFile, factory, context) : node.arguments[0]
-        if (!component) throw sourceNodeError(node.arguments[0], sourceFile, "React memo() identifiers must name a same-file top-level function component")
-        return ts.visitNode(component, visitor)
-      }
-      if (name === "useCallback") {
-        if (node.arguments.length !== 2 || !ts.isArrayLiteralExpression(node.arguments[1]) || !(ts.isArrowFunction(node.arguments[0]) || ts.isFunctionExpression(node.arguments[0]))) throw sourceNodeError(node, sourceFile, "React useCallback() requires an inline function and a literal dependency array")
-        const dependency = node.arguments[1].elements.find(entry => !isReactCallbackDependency(entry))
-        if (dependency) throw sourceNodeError(dependency, sourceFile, "React useCallback() dependencies must be identifiers or primitive literals")
-        const dependencies = new Set(node.arguments[1].elements.map(unwrapExpression).filter(ts.isIdentifier).map(entry => entry.text))
-        const owner = nearestFunction(node)
-        const stale = owner && [...ownerStateNames(owner)].find(state => referenceIdentifiers(node.arguments[0], state).length && !dependencies.has(state))
-        if (stale) throw sourceNodeError(node.arguments[1], sourceFile, `React useCallback() must list captured state ${JSON.stringify(stale)} as a dependency`)
-        return ts.visitNode(node.arguments[0], visitor)
-      }
-      if (name === "useMemo") {
-        if (node.arguments.length !== 2 || !ts.isArrayLiteralExpression(node.arguments[1]) || !(ts.isArrowFunction(node.arguments[0]) || ts.isFunctionExpression(node.arguments[0]))) throw sourceNodeError(node, sourceFile, "React useMemo() requires an inline function and a literal dependency array")
-        const callback = node.arguments[0]
-        if (callback.parameters.length || callback.asteriskToken || callback.modifiers?.some(modifier => modifier.kind === ts.SyntaxKind.AsyncKeyword)) throw sourceNodeError(callback, sourceFile, "React useMemo() callback must be synchronous and parameterless")
-        const dependency = node.arguments[1].elements.find(entry => !isReactCallbackDependency(entry))
-        if (dependency) throw sourceNodeError(dependency, sourceFile, "React useMemo() dependencies must be identifiers or primitive literals")
-        const expression = lowerReactMemoCollectionExpression(reactMemoExpression(callback), factory)
-        const dependencies = new Set(node.arguments[1].elements.map(unwrapExpression).filter(ts.isIdentifier).map(entry => entry.text))
-        const owner = nearestFunction(node)
-        const states = owner ? ownerStateNames(owner) : new Set()
-        const collection = expression && reactMemoCollection(expression, states, importedCollections, sourceFile)
-        if (!expression || !collection && !isPureReactMemoExpression(expression)) throw sourceNodeError(callback.body, sourceFile, "React useMemo() callback must return one pure expression or analyzable collection pipeline")
-        if (!collection) {
-          const unsupported = [...reactMemoReferenceNames(expression)].find(reference => !states.has(reference))
-          if (unsupported) throw sourceNodeError(expression, sourceFile, `React useMemo() pure expressions may only reference direct local state; found ${JSON.stringify(unsupported)}`)
-        }
-        const collectionDependencies = collection ? new Set([...collection.selectorStates, ...(collection.static ? [] : [collection.state.text])]) : undefined
-        const stale = collection
-          ? [...collectionDependencies].find(state => !dependencies.has(state))
-          : [...states].find(state => referenceIdentifiers(expression, state).length && !dependencies.has(state))
-        if (stale) throw sourceNodeError(node.arguments[1], sourceFile, `React useMemo() must list captured state ${JSON.stringify(stale)} as a dependency`)
-        return ts.visitNode(expression, visitor)
-      }
-      if (name && supported.has(name)) {
-        required.add(name)
-        return factory.updateCallExpression(node, factory.createIdentifier(name), node.typeArguments, ts.visitNodes(node.arguments, visitor))
-      }
-    }
-    if (ts.isImportDeclaration(node) && !node.importClause?.isTypeOnly && ts.isStringLiteral(node.moduleSpecifier) && node.moduleSpecifier.text === "react") {
-      const clause = node.importClause
-      if (!clause) return node
-      let bindings = clause.namedBindings
-      if (bindings && ts.isNamedImports(bindings)) {
-        const entries = []
-        for (const entry of bindings.elements) {
-          const name = (entry.propertyName ?? entry.name).text
-          if (entry.isTypeOnly) continue
-          if (!entry.isTypeOnly && erased.has(name)) continue
-          if (!entry.isTypeOnly && supported.has(name)) {
-            if (imported.has(name)) continue
-            imported.add(name)
-            required.add(name)
-            entries.push(factory.createImportSpecifier(false, undefined, factory.createIdentifier(name)))
-          } else {
-            entries.push(entry)
-          }
-        }
-        bindings = entries.length ? factory.updateNamedImports(bindings, entries) : undefined
-      }
-      if (!clause.name && !bindings) return undefined
-      return factory.updateImportDeclaration(node, node.modifiers, factory.updateImportClause(clause, clause.isTypeOnly, clause.name, bindings), node.moduleSpecifier, node.attributes)
-    }
-    return ts.visitEachChild(node, visitor, context)
-  }
-  let normalized = ts.visitNode(sourceFile, visitor)
-  const missing = [...required].filter(name => !imported.has(name)).sort()
-  if (!missing.length) return normalized
-  for (const name of missing) {
-    const collision = sourceFile.statements.some(statement => statementDeclaresName(statement, name) || ts.isImportDeclaration(statement) && importDeclarationNames(statement).includes(name) && statement.moduleSpecifier.text !== "react")
-    if (collision) throw sourceNodeError(sourceFile, sourceFile, `React.${name} cannot be normalized because ${JSON.stringify(name)} is already declared`)
-  }
-  const declaration = factory.createImportDeclaration(undefined, factory.createImportClause(false, undefined, factory.createNamedImports(missing.map(name => factory.createImportSpecifier(false, undefined, factory.createIdentifier(name))))), factory.createStringLiteral("react"))
-  const statements = [...normalized.statements]
-  const lastImport = statements.findLastIndex(statement => ts.isImportDeclaration(statement))
-  statements.splice(lastImport + 1, 0, declaration)
-  normalized = factory.updateSourceFile(normalized, statements)
-  return normalized
-}
-
-function lowerReactForwardRef(call, sourceFile, factory) {
-  const declaration = call.parent
-  const statement = declaration?.parent?.parent
-  if (!ts.isVariableDeclaration(declaration) || declaration.initializer !== call || !ts.isIdentifier(declaration.name) || !statement || !ts.isVariableStatement(statement) || (statement.declarationList.flags & ts.NodeFlags.Const) === 0 || statement.parent !== sourceFile) {
-    throw sourceNodeError(call, sourceFile, "React forwardRef() must directly initialize one top-level const component")
-  }
-  if (call.arguments.length !== 1 || !ts.isArrowFunction(call.arguments[0]) && !ts.isFunctionExpression(call.arguments[0])) throw sourceNodeError(call, sourceFile, "React forwardRef() requires exactly one inline render function")
-  const callback = call.arguments[0]
-  if (callback.asteriskToken || callback.modifiers?.some(modifier => modifier.kind === ts.SyntaxKind.AsyncKeyword)) throw sourceNodeError(callback, sourceFile, "React forwardRef() render function must be synchronous and cannot be a generator")
-  if (callback.parameters.length !== 2) throw sourceNodeError(callback, sourceFile, "React forwardRef() render function must declare exactly (props, ref)")
-  const [props, ref] = callback.parameters
-  if (props.dotDotDotToken || props.initializer || !ts.isIdentifier(props.name) && !ts.isObjectBindingPattern(props.name)) throw sourceNodeError(props, sourceFile, "React forwardRef() props must use one identifier or a flat object binding")
-  if (ref.dotDotDotToken || ref.initializer || !ts.isIdentifier(ref.name)) throw sourceNodeError(ref, sourceFile, "React forwardRef() ref parameter must be one identifier")
-
-  let elements
-  if (ts.isIdentifier(props.name)) {
-    elements = [
-      factory.createBindingElement(undefined, factory.createIdentifier("ref"), factory.createIdentifier(ref.name.text)),
-      factory.createBindingElement(factory.createToken(ts.SyntaxKind.DotDotDotToken), undefined, factory.createIdentifier(props.name.text))
-    ]
-  } else {
-    for (const element of props.name.elements) {
-      const property = (element.propertyName ?? element.name)
-      if (!ts.isIdentifier(element.name) || property.text === "ref") throw sourceNodeError(element, sourceFile, property.text === "ref" ? "React forwardRef() props must not declare ref; Kudzu supplies ref through the second parameter" : "React forwardRef() props must use one identifier or a flat object binding")
-    }
-    const rest = props.name.elements.findIndex(element => Boolean(element.dotDotDotToken))
-    elements = [...props.name.elements]
-    elements.splice(rest < 0 ? elements.length : rest, 0, factory.createBindingElement(undefined, factory.createIdentifier("ref"), factory.createIdentifier(ref.name.text)))
-  }
-
-  const last = ts.isBlock(callback.body) ? callback.body.statements.at(-1) : undefined
-  let returnCount = 0
-  const countReturns = node => {
-    if (node !== callback.body && isFunctionLike(node)) return
-    if (ts.isReturnStatement(node)) returnCount++
-    ts.forEachChild(node, countReturns)
-  }
-  countReturns(callback.body)
-  const returned = ts.isBlock(callback.body)
-    ? last && ts.isReturnStatement(last) ? last.expression : undefined
-    : callback.body
-  const root = returned && unwrapExpression(returned)
-  const tag = root && jsxTagName(root)
-  if ((ts.isBlock(callback.body) && returnCount !== 1) || !root || !ts.isJsxElement(root) && !ts.isJsxSelfClosingElement(root) || !ts.isIdentifier(tag) || tag.text[0] !== tag.text[0].toLowerCase()) throw sourceNodeError(callback.body, sourceFile, "React forwardRef() render function must directly return one intrinsic JSX element")
-  const attributes = ts.isJsxElement(root) ? root.openingElement.attributes : root.attributes
-  const forwarded = attributes.properties.filter(attribute => ts.isJsxAttribute(attribute) && attribute.name.text === "ref" && ts.isJsxExpression(attribute.initializer) && ts.isIdentifier(attribute.initializer.expression) && attribute.initializer.expression.text === ref.name.text)
-  if (forwarded.length !== 1 || referenceIdentifiers(callback.body, ref.name.text).length !== 1) throw sourceNodeError(ref, sourceFile, "React forwardRef() ref must be forwarded exactly once as ref={ref} on the direct intrinsic root")
-
-  const parameter = factory.updateParameterDeclaration(props, props.modifiers, undefined, factory.createObjectBindingPattern(elements), props.questionToken, props.type, undefined)
-  return ts.isArrowFunction(callback)
-    ? factory.updateArrowFunction(callback, callback.modifiers, callback.typeParameters, [parameter], callback.type, callback.equalsGreaterThanToken, callback.body)
-    : factory.updateFunctionExpression(callback, callback.modifiers, undefined, callback.name, callback.typeParameters, [parameter], callback.type, callback.body)
-}
-
-function validateUseIdSyntax(sourceFile) {
-  const imported = sourceFile.statements.some(statement => ts.isImportDeclaration(statement) && ["@kudzujs/core", "react"].includes(statement.moduleSpecifier.text) && statement.importClause?.namedBindings && ts.isNamedImports(statement.importClause.namedBindings) && statement.importClause.namedBindings.elements.some(entry => !entry.propertyName && entry.name.text === "useId"))
-  if (!imported) return
-  const visit = node => {
-    if (ts.isCallExpression(node) && ts.isIdentifier(node.expression) && node.expression.text === "useId" && !isShadowedIdentifier(node.expression, sourceFile)) {
-      if (node.arguments.length) throw sourceNodeError(node, sourceFile, "useId() does not accept arguments")
-      const declaration = node.parent
-      const statement = declaration?.parent?.parent
-      const owner = nearestFunction(node)
-      if (!ts.isVariableDeclaration(declaration) || declaration.initializer !== node || !ts.isIdentifier(declaration.name) || !statement || !ts.isVariableStatement(statement) || (statement.declarationList.flags & ts.NodeFlags.Const) === 0 || !owner || !ts.isBlock(owner.body) || statement.parent !== owner.body) {
-        throw sourceNodeError(node, sourceFile, "useId() must be assigned to one top-level const identifier in a component")
-      }
-    }
-    ts.forEachChild(node, visit)
-  }
-  visit(sourceFile)
-}
-
 function normalizeLazyStateInitializers(sourceFile, factory, context, file, sourceFiles, sourceIndex) {
   const bindings = new Set()
   for (const statement of sourceFile.statements) {
@@ -2544,519 +846,56 @@ function normalizeLazyStateInitializers(sourceFile, factory, context, file, sour
   return ts.visitNode(sourceFile, visitor)
 }
 
-function importDeclarationNames(statement) {
-  const names = []
-  if (statement.importClause?.name) names.push(statement.importClause.name.text)
-  const bindings = statement.importClause?.namedBindings
-  if (bindings && ts.isNamespaceImport(bindings)) names.push(bindings.name.text)
-  if (bindings && ts.isNamedImports(bindings)) for (const entry of bindings.elements) names.push(entry.name.text)
-  return names
-}
-
-function isReactCallbackDependency(node) {
-  node = unwrapExpression(node)
-  return ts.isIdentifier(node) || ts.isStringLiteral(node) || ts.isNumericLiteral(node) || node.kind === ts.SyntaxKind.TrueKeyword || node.kind === ts.SyntaxKind.FalseKeyword || node.kind === ts.SyntaxKind.NullKeyword
-}
-
-function reactMemoExpression(callback) {
-  if (!ts.isBlock(callback.body)) return callback.body
-  if (callback.body.statements.length !== 1 || !ts.isReturnStatement(callback.body.statements[0])) return undefined
-  return callback.body.statements[0].expression
-}
-
-function lowerReactMemoCollectionExpression(expression, factory) {
-  if (!expression) return undefined
-  const visit = node => {
-    if (ts.isCallExpression(node) && ts.isPropertyAccessExpression(node.expression) && node.expression.name.text === "map" && node.arguments.length === 1) {
-      return factory.createCallExpression(factory.createPropertyAccessExpression(factory.createIdentifier("Array"), "from"), undefined, [visit(node.expression.expression), node.arguments[0]])
-    }
-    if (ts.isCallExpression(node) && ts.isPropertyAccessExpression(node.expression) && ["filter", "flatMap", "slice", "toSorted"].includes(node.expression.name.text)) {
-      return factory.updateCallExpression(node, factory.updatePropertyAccessExpression(node.expression, visit(node.expression.expression), node.expression.name), node.typeArguments, node.arguments)
-    }
-    if (isArrayFromCall(node)) return factory.updateCallExpression(node, node.expression, node.typeArguments, [visit(node.arguments[0]), ...node.arguments.slice(1)])
-    return node
-  }
-  return visit(expression)
-}
-
-function reactMemoCollection(expression, states, importedCollections, sourceFile) {
-  const setters = new Map([...states].map(state => [state, state]))
-  const fail = (node, message) => { throw sourceNodeError(node, sourceFile, message) }
-  return renderedCollectionSource(expression, setters, undefined, fail, new Set(), importedCollections, states)
-}
-
-function reactMemoComponentExpression(identifier, sourceFile, factory, context) {
-  for (const statement of sourceFile.statements) {
-    if (ts.isFunctionDeclaration(statement) && statement.name?.text === identifier.text && statement.body) {
-      const clone = cloneAst(statement, factory, context)
-      return factory.createFunctionExpression(clone.modifiers?.filter(modifier => modifier.kind === ts.SyntaxKind.AsyncKeyword), clone.asteriskToken, clone.name, clone.typeParameters, clone.parameters, clone.type, clone.body)
-    }
-    if (!ts.isVariableStatement(statement)) continue
-    const declaration = statement.declarationList.declarations.find(entry => ts.isIdentifier(entry.name) && entry.name.text === identifier.text)
-    if (declaration?.initializer && (ts.isArrowFunction(declaration.initializer) || ts.isFunctionExpression(declaration.initializer))) return cloneAst(declaration.initializer, factory, context)
-  }
-  return undefined
-}
-
-function isPureReactMemoExpression(node) {
-  node = unwrapExpression(node)
-  if (ts.isIdentifier(node) || ts.isStringLiteral(node) || ts.isNumericLiteral(node) || ts.isNoSubstitutionTemplateLiteral(node) || node.kind === ts.SyntaxKind.TrueKeyword || node.kind === ts.SyntaxKind.FalseKeyword || node.kind === ts.SyntaxKind.NullKeyword) return true
-  if (ts.isParenthesizedExpression(node)) return isPureReactMemoExpression(node.expression)
-  if (ts.isPrefixUnaryExpression(node)) return ![ts.SyntaxKind.PlusPlusToken, ts.SyntaxKind.MinusMinusToken].includes(node.operator) && isPureReactMemoExpression(node.operand)
-  if (ts.isBinaryExpression(node)) return node.operatorToken.kind < ts.SyntaxKind.FirstAssignment && isPureReactMemoExpression(node.left) && isPureReactMemoExpression(node.right)
-  if (ts.isConditionalExpression(node)) return isPureReactMemoExpression(node.condition) && isPureReactMemoExpression(node.whenTrue) && isPureReactMemoExpression(node.whenFalse)
-  if (ts.isTemplateExpression(node)) return node.templateSpans.every(span => isPureReactMemoExpression(span.expression))
-  return false
-}
-
-function reactMemoReferenceNames(root) {
-  const names = new Set()
-  const visit = node => {
-    if (ts.isIdentifier(node) && isReferenceIdentifier(node)) names.add(node.text)
-    ts.forEachChild(node, visit)
-  }
-  visit(root)
-  return names
-}
-
-const customHookTimerStatePrefix = "__kTimerState_"
-const customHookTimerSetterPrefix = "__kSetTimerState_"
-const customHookTimerStatesBySource = new WeakMap()
-
-function normalizeCustomHookTimerRefs(sourceFile, factory, context) {
-  const timerCall = (node, name) => ts.isCallExpression(node) && (
-    ts.isIdentifier(node.expression) && node.expression.text === name ||
-    ts.isPropertyAccessExpression(node.expression) && ts.isIdentifier(node.expression.expression) && node.expression.expression.text === "window" && node.expression.name.text === name
-  )
-  const currentAccess = (node, name) => ts.isPropertyAccessExpression(node) && ts.isIdentifier(node.expression) && node.expression.text === name && node.name.text === "current"
-  const clearStatement = (node, name) => {
-    if (!ts.isIfStatement(node) || node.elseStatement || !currentAccess(unwrapExpression(node.expression), name)) return undefined
-    const statement = ts.isBlock(node.thenStatement) && node.thenStatement.statements.length === 1 ? node.thenStatement.statements[0] : node.thenStatement
-    if (!ts.isExpressionStatement(statement) || !timerCall(statement.expression, "clearTimeout") || statement.expression.arguments.length !== 1 || !currentAccess(unwrapExpression(statement.expression.arguments[0]), name)) return undefined
-    return { condition: unwrapExpression(node.expression), argument: unwrapExpression(statement.expression.arguments[0]) }
-  }
-  const analyze = (hook, hookName) => {
-    if (!/^use[A-Z]/.test(hookName) || hook.parameters.length || !hook.body || !ts.isBlock(hook.body)) return undefined
-    const returnedStatement = hook.body.statements.at(-1)
-    const returned = returnedStatement && ts.isReturnStatement(returnedStatement) && returnedStatement.expression ? unwrapExpression(returnedStatement.expression) : undefined
-    if (!returned || !ts.isObjectLiteralExpression(returned)) return undefined
-    const returnedNames = new Set(returned.properties.filter(ts.isShorthandPropertyAssignment).map(property => property.name.text))
-    const callbacks = new Map()
-    const refs = []
-    for (const statement of hook.body.statements) {
-      if (!ts.isVariableStatement(statement) || !(statement.declarationList.flags & ts.NodeFlags.Const)) continue
-      for (const declaration of statement.declarationList.declarations) {
-        if (ts.isIdentifier(declaration.name) && declaration.initializer && (ts.isArrowFunction(declaration.initializer) || ts.isFunctionExpression(declaration.initializer))) callbacks.set(declaration.name.text, declaration.initializer)
-        if (ts.isIdentifier(declaration.name) && declaration.initializer && ts.isCallExpression(declaration.initializer) && ts.isIdentifier(declaration.initializer.expression) && declaration.initializer.expression.text === "useRef" && declaration.initializer.arguments.length === 1 && declaration.initializer.arguments[0].kind === ts.SyntaxKind.NullKeyword) refs.push({ declaration, name: declaration.name.text })
-      }
-    }
-    const candidates = []
-    for (const ref of refs) {
-      const assignments = []
-      const accesses = []
-      const clearStatements = []
-      const collect = node => {
-        if (currentAccess(node, ref.name)) accesses.push(node)
-        if (ts.isBinaryExpression(node) && node.operatorToken.kind === ts.SyntaxKind.EqualsToken && currentAccess(unwrapExpression(node.left), ref.name)) assignments.push(node)
-        const clear = clearStatement(node, ref.name)
-        if (clear) clearStatements.push({ node, ...clear })
-        ts.forEachChild(node, collect)
-      }
-      collect(hook.body)
-      if (assignments.some(assignment => timerCall(unwrapExpression(assignment.right), "setTimeout"))) candidates.push({ ...ref, assignments, accesses, clearStatements })
-    }
-    if (!candidates.length) return undefined
-    if (candidates.length !== 1) throw sourceNodeError(hook, sourceFile, "Relative custom hooks may own only one private timeout ref")
-    const timer = candidates[0]
-    if (timer.assignments.length !== 1) throw sourceNodeError(timer.declaration, sourceFile, "Private timeout refs require one direct timer.current = setTimeout(...) assignment")
-    const assignment = timer.assignments[0]
-    const timeout = unwrapExpression(assignment.right)
-    const timeoutCallback = timeout.arguments[0]
-    const delay = timeout.arguments[1]
-    if (!timerCall(timeout, "setTimeout") || timeout.arguments.length !== 2 || !timeoutCallback || !(ts.isArrowFunction(timeoutCallback) || ts.isFunctionExpression(timeoutCallback)) || timeoutCallback.parameters.length || !delay || !ts.isNumericLiteral(unwrapExpression(delay))) throw sourceNodeError(assignment, sourceFile, "Private timeout refs require setTimeout() with one zero-argument callback and a numeric literal delay")
-    const callback = nearestFunction(assignment)
-    const callbackName = [...callbacks].find(([, value]) => value === callback)?.[0]
-    if (!callbackName || !returnedNames.has(callbackName) || !ts.isBlock(callback.body) || !ts.isExpressionStatement(assignment.parent) || assignment.parent.parent !== callback.body) throw sourceNodeError(assignment, sourceFile, "Private timeout refs must be assigned directly inside one returned custom-hook callback")
-    const callbackClear = timer.clearStatements.find(entry => nearestFunction(entry.node) === callback)
-    if (!callbackClear || callbackClear.node.parent !== callback.body || callback.body.statements.indexOf(callbackClear.node) >= callback.body.statements.indexOf(assignment.parent)) throw sourceNodeError(callback, sourceFile, "Private timeout callbacks must directly clear the previous timer before assigning its replacement")
-    const effectCalls = hook.body.statements.flatMap(statement => {
-      if (!ts.isExpressionStatement(statement) || !ts.isCallExpression(statement.expression) || !ts.isIdentifier(statement.expression.expression) || statement.expression.expression.text !== "useEffect") return []
-      return [statement.expression]
-    })
-    let cleanupClear
-    for (const effect of effectCalls) {
-      const [setup, dependencies] = effect.arguments
-      if (!(ts.isArrowFunction(setup) || ts.isFunctionExpression(setup)) || !ts.isArrayLiteralExpression(dependencies) || dependencies.elements.length) continue
-      const returns = effectReturns(setup)
-      if (returns.cleanups.length !== 1) continue
-      const cleanup = returns.cleanups[0]
-      const entry = timer.clearStatements.find(candidate => nearestFunction(candidate.node) === cleanup)
-      if (entry && ts.isBlock(cleanup.body) && cleanup.body.statements.length === 1 && cleanup.body.statements[0] === entry.node) cleanupClear = entry
-    }
-    if (!cleanupClear) throw sourceNodeError(timer.declaration, sourceFile, "Private timeout refs require one empty-dependency effect that directly clears the timer on cleanup")
-    const accepted = new Set([assignment.left, callbackClear.condition, callbackClear.argument, cleanupClear.condition, cleanupClear.argument].map(unwrapExpression))
-    const unsupported = timer.accesses.find(access => !accepted.has(access))
-    if (unsupported) throw sourceNodeError(unsupported, sourceFile, "Private timeout refs may only be read by their direct replacement and cleanup guards")
-    const identity = createHash("sha256").update(`${sourceFile.fileName}:${hook.pos}:${timer.name}`).digest("hex").slice(0, 10)
-    const stateName = `${customHookTimerStatePrefix}${identity}`
-    const setterName = `${customHookTimerSetterPrefix}${identity}`
-    if (referencesIdentifier(hook.body, stateName) || referencesIdentifier(hook.body, setterName)) throw sourceNodeError(timer.declaration, sourceFile, "Private timeout ref conflicts with compiler-owned bindings")
-    return { assignment, declaration: timer.declaration, refName: timer.name, returned, stateName, setterName }
-  }
-  const timerStates = new Set()
-  const transform = (hook, hookName) => {
-    const timer = analyze(hook, hookName)
-    if (!timer) return undefined
-    timerStates.add(timer.stateName)
-    const timerVisitor = current => {
-      if (current === timer.declaration) {
-        const binding = factory.createArrayBindingPattern([
-          factory.createBindingElement(undefined, undefined, timer.stateName),
-          factory.createBindingElement(undefined, undefined, timer.setterName)
-        ])
-        const initializer = factory.updateCallExpression(current.initializer, factory.createIdentifier("useState"), current.initializer.typeArguments, current.initializer.arguments)
-        return factory.updateVariableDeclaration(current, binding, current.exclamationToken, undefined, initializer)
-      }
-      if (current === timer.assignment) return factory.createCallExpression(factory.createIdentifier(timer.setterName), undefined, [ts.visitNode(current.right, timerVisitor)])
-      if (currentAccess(current, timer.refName)) return factory.createIdentifier(timer.stateName)
-      if (current === timer.returned) return factory.updateObjectLiteralExpression(current, [
-        ...current.properties,
-        factory.createShorthandPropertyAssignment(timer.stateName),
-        factory.createShorthandPropertyAssignment(timer.setterName)
-      ])
-      return ts.visitEachChild(current, timerVisitor, context)
-    }
-    return ts.visitEachChild(hook, timerVisitor, context)
-  }
-  const visitor = node => {
-    if (ts.isFunctionDeclaration(node)) {
-      const hookName = node.name?.text ?? (node.modifiers?.some(modifier => modifier.kind === ts.SyntaxKind.DefaultKeyword) ? "useDefault" : "")
-      const transformed = transform(node, hookName)
-      if (transformed) return transformed
-    }
-    if (ts.isVariableDeclaration(node) && ts.isIdentifier(node.name) && node.initializer && (ts.isArrowFunction(node.initializer) || ts.isFunctionExpression(node.initializer))) {
-      const transformed = transform(node.initializer, node.name.text)
-      if (transformed) return factory.updateVariableDeclaration(node, node.name, node.exclamationToken, node.type, transformed)
-    }
-    return ts.visitEachChild(node, visitor, context)
-  }
-  const normalized = ts.visitNode(sourceFile, visitor)
-  customHookTimerStatesBySource.set(normalized, timerStates)
-  return normalized
-}
-
-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))
-  const externalStoreImport = imports.flatMap(statement => statement.importClause.namedBindings.elements.map(entry => ({ entry, statement }))).find(({ entry }) => !entry.isTypeOnly && !entry.propertyName && entry.name.text === "useSyncExternalStore")
-  if (!externalStoreImport) return sourceFile
-  const returnedExpression = callback => {
-    if (!(ts.isArrowFunction(callback) || ts.isFunctionExpression(callback)) || callback.parameters.length) return undefined
-    if (!ts.isBlock(callback.body)) return unwrapExpression(callback.body)
-    if (callback.body.statements.length !== 1 || !ts.isReturnStatement(callback.body.statements[0]) || !callback.body.statements[0].expression) return undefined
-    return unwrapExpression(callback.body.statements[0].expression)
-  }
-  const matchMediaQuery = expression => {
-    expression = unwrapExpression(expression)
-    if (!ts.isCallExpression(expression) || expression.arguments.length !== 1 || !ts.isStringLiteral(unwrapExpression(expression.arguments[0])) || !ts.isPropertyAccessExpression(expression.expression) || !ts.isIdentifier(expression.expression.expression) || expression.expression.expression.text !== "window" || expression.expression.name.text !== "matchMedia" || !isUnshadowedGlobal(expression.expression.expression, sourceFile)) return undefined
-    return unwrapExpression(expression.arguments[0]).text
-  }
-  const mediaListener = (statement, method, media, callback) => ts.isExpressionStatement(statement) && ts.isCallExpression(statement.expression) && statement.expression.arguments.length === 2 && ts.isPropertyAccessExpression(statement.expression.expression) && ts.isIdentifier(statement.expression.expression.expression) && statement.expression.expression.expression.text === media && statement.expression.expression.name.text === method && ts.isStringLiteral(unwrapExpression(statement.expression.arguments[0])) && unwrapExpression(statement.expression.arguments[0]).text === "change" && ts.isIdentifier(unwrapExpression(statement.expression.arguments[1])) && unwrapExpression(statement.expression.arguments[1]).text === callback
-  const candidates = new Map()
-  let index = 0
-  const inspect = node => {
-    if (!ts.isVariableStatement(node) || !(node.declarationList.flags & ts.NodeFlags.Const) || node.declarationList.declarations.length !== 1) {
-      ts.forEachChild(node, inspect)
-      return
-    }
-    const declaration = node.declarationList.declarations[0]
-    const call = declaration.initializer && unwrapExpression(declaration.initializer)
-    if (!ts.isIdentifier(declaration.name) || !call || !ts.isCallExpression(call) || !ts.isIdentifier(call.expression) || call.expression.text !== "useSyncExternalStore" || isShadowedIdentifier(call.expression, sourceFile)) {
-      ts.forEachChild(node, inspect)
-      return
-    }
-    if (call.arguments.length !== 3) throw sourceNodeError(call, sourceFile, "Media query useSyncExternalStore() requires subscribe, browser snapshot, and false server snapshot callbacks")
-    const [subscribe, snapshot, serverSnapshot] = call.arguments.map(unwrapExpression)
-    if (!(ts.isArrowFunction(subscribe) || ts.isFunctionExpression(subscribe)) || subscribe.parameters.length !== 1 || !ts.isIdentifier(subscribe.parameters[0].name) || !ts.isBlock(subscribe.body)) throw sourceNodeError(subscribe, sourceFile, "Media query subscriptions require one inline callback parameter and block body")
-    if (subscribe.body.statements.length !== 3) throw sourceNodeError(subscribe, sourceFile, "Media query subscriptions must add and remove one matching change listener")
-    const callback = subscribe.parameters[0].name.text
-    const [mediaStatement, addStatement, returnStatement] = subscribe.body.statements
-    const mediaDeclaration = ts.isVariableStatement(mediaStatement) && (mediaStatement.declarationList.flags & ts.NodeFlags.Const) && mediaStatement.declarationList.declarations.length === 1 ? mediaStatement.declarationList.declarations[0] : undefined
-    const media = mediaDeclaration && ts.isIdentifier(mediaDeclaration.name) ? mediaDeclaration.name.text : undefined
-    const query = mediaDeclaration?.initializer && matchMediaQuery(mediaDeclaration.initializer)
-    const cleanup = ts.isReturnStatement(returnStatement) && returnStatement.expression ? unwrapExpression(returnStatement.expression) : undefined
-    const cleanupStatement = cleanup && (ts.isArrowFunction(cleanup) || ts.isFunctionExpression(cleanup)) && !cleanup.parameters.length
-      ? ts.isBlock(cleanup.body) ? cleanup.body.statements.length === 1 ? cleanup.body.statements[0] : undefined : factory.createExpressionStatement(cleanup.body)
-      : undefined
-    if (!media || !query || !mediaListener(addStatement, "addEventListener", media, callback) || !cleanupStatement || !mediaListener(cleanupStatement, "removeEventListener", media, callback)) throw sourceNodeError(subscribe, sourceFile, "Media query subscriptions must add and remove one matching change listener")
-    const snapshotValue = returnedExpression(snapshot)
-    const snapshotQuery = snapshotValue && ts.isPropertyAccessExpression(snapshotValue) && snapshotValue.name.text === "matches" ? matchMediaQuery(snapshotValue.expression) : undefined
-    const serverValue = returnedExpression(serverSnapshot)
-    if (snapshotQuery !== query || !serverValue || serverValue.kind !== ts.SyntaxKind.FalseKeyword) throw sourceNodeError(call, sourceFile, "Media query external stores require matching static snapshots and a false server fallback")
-    const owner = nearestFunction(node)
-    const topLevelOwner = owner && (owner.parent === sourceFile || ts.isVariableDeclaration(owner.parent) && owner.parent.parent?.parent?.parent === sourceFile)
-    if (!topLevelOwner || !owner.body || !ts.isBlock(owner.body) || node.parent !== owner.body) throw sourceNodeError(declaration, sourceFile, "Media query external stores must initialize one top-level component const")
-    for (const name of ["useEffect", "useState"]) if (owner.parameters.some(parameter => bindingNames(parameter.name).includes(name)) || functionVarDeclaresName(owner, name) || owner.body.statements.some(statement => statementDeclaresName(statement, name))) throw sourceNodeError(declaration, sourceFile, `Media query external stores conflict with component-local ${name}`)
-    let setter = `__kSetMediaQuery${index++}`
-    while (sourceFile.text.includes(setter)) setter = `__kSetMediaQuery${index++}`
-    candidates.set(node, { declaration, query, setter })
-  }
-  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")
-  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) {
-    const collision = sourceFile.statements.some(statement => statementDeclaresName(statement, name) || ts.isImportDeclaration(statement) && importDeclarationNames(statement).includes(name))
-    if (collision) throw sourceNodeError([...candidates.values()][0].declaration, sourceFile, `Media query external stores conflict with local ${name}`)
-  }
-
-  const visitor = node => {
-    const candidate = ts.isVariableStatement(node) ? candidates.get(node) : undefined
-    if (candidate) {
-      const state = factory.createVariableStatement(node.modifiers, factory.createVariableDeclarationList([
-        factory.createVariableDeclaration(factory.createArrayBindingPattern([
-          factory.createBindingElement(undefined, undefined, candidate.declaration.name),
-          factory.createBindingElement(undefined, undefined, candidate.setter)
-        ]), undefined, undefined, factory.createCallExpression(factory.createIdentifier("useState"), undefined, [factory.createFalse()]))
-      ], ts.NodeFlags.Const))
-      const media = factory.createIdentifier("media")
-      const update = factory.createIdentifier("update")
-      const mediaCall = factory.createCallExpression(factory.createPropertyAccessExpression(factory.createIdentifier("window"), "matchMedia"), undefined, [factory.createStringLiteral(candidate.query)])
-      const updateCallback = factory.createArrowFunction(undefined, undefined, [], undefined, factory.createToken(ts.SyntaxKind.EqualsGreaterThanToken), factory.createCallExpression(factory.createIdentifier(candidate.setter), undefined, [factory.createPropertyAccessExpression(media, "matches")]))
-      const listener = method => factory.createCallExpression(factory.createPropertyAccessExpression(media, method), undefined, [factory.createStringLiteral("change"), update])
-      const cleanup = factory.createArrowFunction(undefined, undefined, [], undefined, factory.createToken(ts.SyntaxKind.EqualsGreaterThanToken), listener("removeEventListener"))
-      const setup = factory.createArrowFunction(undefined, undefined, [], undefined, factory.createToken(ts.SyntaxKind.EqualsGreaterThanToken), factory.createBlock([
-        factory.createVariableStatement(undefined, factory.createVariableDeclarationList([factory.createVariableDeclaration(media, undefined, undefined, mediaCall)], ts.NodeFlags.Const)),
-        factory.createVariableStatement(undefined, factory.createVariableDeclarationList([factory.createVariableDeclaration(update, undefined, undefined, updateCallback)], ts.NodeFlags.Const)),
-        factory.createExpressionStatement(factory.createCallExpression(update, undefined, [])),
-        factory.createExpressionStatement(listener("addEventListener")),
-        factory.createReturnStatement(cleanup)
-      ], true))
-      const effectCall = factory.createCallExpression(factory.createIdentifier("useEffect"), undefined, [setup, factory.createArrayLiteralExpression()])
-      ts.setOriginalNode(effectCall, candidate.declaration.initializer)
-      ts.setTextRange(effectCall, candidate.declaration.initializer)
-      return [state, factory.createExpressionStatement(effectCall)]
-    }
-    if (node === externalStoreImport.statement) {
-      const clause = node.importClause
-      const bindings = clause.namedBindings
-      const elements = bindings.elements.filter(entry => entry !== externalStoreImport.entry)
-      for (const name of missingHooks) elements.push(factory.createImportSpecifier(false, undefined, factory.createIdentifier(name)))
-      return factory.updateImportDeclaration(node, node.modifiers, factory.updateImportClause(clause, false, clause.name, factory.updateNamedImports(bindings, elements)), node.moduleSpecifier, node.attributes)
-    }
-    return ts.visitEachChild(node, visitor, 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
-}
-
-function normalizeNavigatorCapabilityConditions(sourceFile, factory, context) {
-  const candidates = new Map()
-  let index = 0
-  const inspect = node => {
-    if (!ts.isVariableStatement(node) || !(node.declarationList.flags & ts.NodeFlags.Const) || node.declarationList.declarations.length !== 1) {
-      ts.forEachChild(node, inspect)
-      return
-    }
-    const declaration = node.declarationList.declarations[0]
-    const value = declaration.initializer && unwrapExpression(declaration.initializer)
-    if (!ts.isIdentifier(declaration.name) || !value || !ts.isBinaryExpression(value) || value.operatorToken.kind !== ts.SyntaxKind.InKeyword || !ts.isStringLiteral(unwrapExpression(value.left)) || !ts.isIdentifier(unwrapExpression(value.right)) || unwrapExpression(value.right).text !== "navigator" || !isUnshadowedGlobal(unwrapExpression(value.right), sourceFile)) {
-      ts.forEachChild(node, inspect)
-      return
-    }
-    const owner = nearestFunction(node)
-    const topLevelOwner = owner && (owner.parent === sourceFile || ts.isVariableDeclaration(owner.parent) && owner.parent.parent?.parent?.parent === sourceFile)
-    if (!topLevelOwner || !owner.body || !ts.isBlock(owner.body) || node.parent !== owner.body) throw sourceNodeError(declaration, sourceFile, "Navigator capability conditions must be top-level component const declarations")
-    const references = referenceIdentifiers(owner.body, declaration.name.text)
-    const condition = references.length === 1 ? references[0] : undefined
-    const structural = condition && ts.isBinaryExpression(condition.parent) && condition.parent.left === condition && condition.parent.operatorToken.kind === ts.SyntaxKind.AmpersandAmpersandToken && containsJsx(condition.parent.right) && ts.isJsxExpression(condition.parent.parent) && condition.parent.parent.expression === condition.parent
-    if (!structural) throw sourceNodeError(declaration, sourceFile, "Navigator capability values may only control one direct JSX && branch")
-    for (const name of ["useEffect", "useState"]) if (owner.parameters.some(parameter => bindingNames(parameter.name).includes(name)) || functionVarDeclaresName(owner, name) || owner.body.statements.some(statement => statementDeclaresName(statement, name))) throw sourceNodeError(declaration, sourceFile, `Navigator capability conditions conflict with component-local ${name}`)
-    let setter = `__kSetNavigatorCapability${index++}`
-    while (sourceFile.text.includes(setter)) setter = `__kSetNavigatorCapability${index++}`
-    candidates.set(node, { declaration, property: unwrapExpression(value.left).text, setter })
-  }
-  inspect(sourceFile)
-  if (!candidates.size) return sourceFile
-
-  const visitor = node => {
-    const candidate = ts.isVariableStatement(node) ? candidates.get(node) : undefined
-    if (candidate) {
-      const state = factory.createVariableStatement(node.modifiers, factory.createVariableDeclarationList([
-        factory.createVariableDeclaration(factory.createArrayBindingPattern([
-          factory.createBindingElement(undefined, undefined, candidate.declaration.name),
-          factory.createBindingElement(undefined, undefined, candidate.setter)
-        ]), undefined, undefined, factory.createCallExpression(factory.createIdentifier("useState"), undefined, [factory.createFalse()]))
-      ], ts.NodeFlags.Const))
-      const capability = factory.createBinaryExpression(factory.createStringLiteral(candidate.property), factory.createToken(ts.SyntaxKind.InKeyword), factory.createIdentifier("navigator"))
-      const setup = factory.createArrowFunction(undefined, undefined, [], undefined, factory.createToken(ts.SyntaxKind.EqualsGreaterThanToken), factory.createBlock([
-        factory.createExpressionStatement(factory.createCallExpression(factory.createIdentifier(candidate.setter), undefined, [capability]))
-      ], true))
-      const effectCall = factory.createCallExpression(factory.createIdentifier("useEffect"), undefined, [setup, factory.createArrayLiteralExpression()])
-      ts.setOriginalNode(effectCall, candidate.declaration.initializer)
-      ts.setTextRange(effectCall, candidate.declaration.initializer)
-      const effect = factory.createExpressionStatement(effectCall)
-      return [state, effect]
-    }
-    return ts.visitEachChild(node, visitor, context)
-  }
-  let normalized = ts.visitNode(sourceFile, visitor)
-  const hookImports = normalized.statements.filter(statement => ts.isImportDeclaration(statement) && !statement.importClause?.isTypeOnly && ts.isStringLiteral(statement.moduleSpecifier) && ["react", "@kudzujs/core"].includes(statement.moduleSpecifier.text) && statement.importClause?.namedBindings && ts.isNamedImports(statement.importClause.namedBindings))
-  const hookImport = hookImports[0]
-  const bindings = hookImport?.importClause.namedBindings
-  const imported = new Set(hookImports.flatMap(statement => statement.importClause.namedBindings.elements.map(entry => entry.name.text)))
-  const missing = ["useEffect", "useState"].filter(name => !imported.has(name))
-  if (!missing.length) return normalized
-  for (const name of missing) if (normalized.statements.some(statement => !hookImports.includes(statement) && (statementDeclaresName(statement, name) || ts.isImportDeclaration(statement) && importDeclarationNames(statement).includes(name)))) throw sourceNodeError([...candidates.values()][0].declaration, sourceFile, `Navigator capability conditions conflict with local ${name}`)
-  if (hookImport && bindings && ts.isNamedImports(bindings)) {
-    const statements = normalized.statements.map(statement => statement === hookImport ? factory.updateImportDeclaration(statement, statement.modifiers, factory.updateImportClause(statement.importClause, false, statement.importClause.name, factory.updateNamedImports(bindings, [
-      ...bindings.elements,
-      ...missing.map(name => factory.createImportSpecifier(false, undefined, factory.createIdentifier(name)))
-    ])), statement.moduleSpecifier, statement.attributes) : statement)
-    return factory.updateSourceFile(normalized, statements)
-  }
-  const declaration = factory.createImportDeclaration(undefined, factory.createImportClause(false, undefined, factory.createNamedImports(missing.map(name => factory.createImportSpecifier(false, undefined, factory.createIdentifier(name))))), factory.createStringLiteral("@kudzujs/core"))
-  const statements = [...normalized.statements]
-  statements.splice(statements.findLastIndex(statement => ts.isImportDeclaration(statement)) + 1, 0, declaration)
-  return factory.updateSourceFile(normalized, statements)
-}
-
-function normalizeEffectAnimationFrameRefs(sourceFile, factory, context) {
-  const frameCall = (node, name) => ts.isCallExpression(node) && (
-    ts.isIdentifier(node.expression) && node.expression.text === name ||
-    ts.isPropertyAccessExpression(node.expression) && ts.isIdentifier(node.expression.expression) && node.expression.expression.text === "window" && node.expression.name.text === name
-  )
-  const unshadowedFrameCall = (node, owner) => {
-    const name = ts.isIdentifier(node.expression) ? node.expression : ts.isPropertyAccessExpression(node.expression) && ts.isIdentifier(node.expression.expression) ? node.expression.expression : undefined
-    return name && !isShadowedIdentifier(name, owner) && !sourceFile.statements.some(statement => statementDeclaresName(statement, name.text) || ts.isImportDeclaration(statement) && importDeclarationNames(statement).includes(name.text))
-  }
-  const currentAccess = (node, name) => ts.isPropertyAccessExpression(node) && ts.isIdentifier(node.expression) && node.expression.text === name && node.name.text === "current"
-  const inside = (node, root) => {
-    for (let current = node; current; current = current.parent) if (current === root) return true
-    return false
-  }
-  const directOrGuarded = (statement, body, name, negated) => {
-    if (statement.parent === body) return true
-    let branch = statement
-    if (ts.isBlock(statement.parent) && statement.parent.statements.length === 1) branch = statement.parent
-    const conditional = branch.parent
-    if (!ts.isIfStatement(conditional) || conditional.thenStatement !== branch || conditional.parent !== body || conditional.elseStatement) return false
-    let condition = unwrapExpression(conditional.expression)
-    const isNegated = ts.isPrefixUnaryExpression(condition) && condition.operator === ts.SyntaxKind.ExclamationToken
-    if (isNegated) condition = unwrapExpression(condition.operand)
-    return isNegated === negated && currentAccess(condition, name)
-  }
-  const hasUseRefImport = sourceFile.statements.some(statement => ts.isImportDeclaration(statement) && !statement.importClause?.isTypeOnly && ts.isStringLiteral(statement.moduleSpecifier) && ["react", "@kudzujs/core"].includes(statement.moduleSpecifier.text) && statement.importClause?.namedBindings && ts.isNamedImports(statement.importClause.namedBindings) && statement.importClause.namedBindings.elements.some(entry => !entry.propertyName && entry.name.text === "useRef"))
-  const hasUseEffectImport = sourceFile.statements.some(statement => ts.isImportDeclaration(statement) && !statement.importClause?.isTypeOnly && ts.isStringLiteral(statement.moduleSpecifier) && ["react", "@kudzujs/core"].includes(statement.moduleSpecifier.text) && statement.importClause?.namedBindings && ts.isNamedImports(statement.importClause.namedBindings) && statement.importClause.namedBindings.elements.some(entry => !entry.propertyName && entry.name.text === "useEffect"))
-  const replacements = new Set()
-  const inspect = node => {
-    if (!hasUseRefImport || !ts.isVariableDeclaration(node) || !ts.isIdentifier(node.name) || !node.initializer || !ts.isCallExpression(node.initializer) || !ts.isIdentifier(node.initializer.expression) || node.initializer.expression.text !== "useRef" || isShadowedIdentifier(node.initializer.expression, sourceFile) || node.initializer.arguments.length !== 1 || !ts.isNumericLiteral(node.initializer.arguments[0]) || Number(node.initializer.arguments[0].text) !== 0) {
-      ts.forEachChild(node, inspect)
-      return
-    }
-    const owner = nearestFunction(node)
-    if (!owner?.body || !ts.isBlock(owner.body)) return
-    const accesses = []
-    const collect = current => {
-      if (currentAccess(current, node.name.text) && !isShadowedIdentifier(current.expression, owner.body)) accesses.push(current)
-      ts.forEachChild(current, collect)
-    }
-    collect(owner.body)
-    const frameAssignments = accesses.filter(access => ts.isBinaryExpression(access.parent) && unwrapExpression(access.parent.left) === access && access.parent.operatorToken.kind === ts.SyntaxKind.EqualsToken && frameCall(unwrapExpression(access.parent.right), "requestAnimationFrame") && unshadowedFrameCall(unwrapExpression(access.parent.right), owner))
-    if (!frameAssignments.length) return
-    const invalidReference = referenceIdentifiers(owner.body, node.name.text).find(reference => !ts.isPropertyAccessExpression(reference.parent) || reference.parent.expression !== reference || reference.parent.name.text !== "current")
-    if (invalidReference) throw sourceNodeError(invalidReference, sourceFile, "Animation frame refs may only use direct .current reads and assignments")
-    const statement = node.parent?.parent
-    const topLevelOwner = owner.parent === sourceFile || ts.isVariableDeclaration(owner.parent) && owner.parent.parent?.parent?.parent === sourceFile
-    if (!topLevelOwner || !ts.isVariableStatement(statement) || !(statement.declarationList.flags & ts.NodeFlags.Const) || statement.declarationList.declarations.length !== 1 || statement.parent !== owner.body) throw sourceNodeError(node, sourceFile, "Animation frame refs must be one top-level component const")
-    if (frameAssignments.length !== 1) throw sourceNodeError(node, sourceFile, "Animation frame refs require one direct ref.current = requestAnimationFrame(callback) assignment")
-    const frame = unwrapExpression(frameAssignments[0].parent.right)
-    const frameCallback = frame.arguments.length === 1 && ts.isIdentifier(unwrapExpression(frame.arguments[0])) ? unwrapExpression(frame.arguments[0]) : undefined
-    const effectCalls = owner.body.statements.flatMap(statement => hasUseEffectImport && ts.isExpressionStatement(statement) && ts.isCallExpression(statement.expression) && ts.isIdentifier(statement.expression.expression) && statement.expression.expression.text === "useEffect" && !isShadowedIdentifier(statement.expression.expression, sourceFile) ? [statement.expression] : [])
-    const effects = effectCalls.filter(effect => effect.arguments[0] && inside(frameAssignments[0], effect.arguments[0]))
-    if (effects.length !== 1) throw sourceNodeError(node, sourceFile, "Animation frame refs must belong to one inline component effect")
-    const effect = effects[0]
-    const callback = effect.arguments[0]
-    if (!(ts.isArrowFunction(callback) || ts.isFunctionExpression(callback)) || !ts.isBlock(callback.body)) throw sourceNodeError(callback, sourceFile, "Animation frame refs require one inline block-bodied effect")
-    if (accesses.some(access => !inside(access, callback))) throw sourceNodeError(node, sourceFile, "Animation frame refs may only be used inside their owning effect")
-    const callbacks = new Map()
-    for (const statement of callback.body.statements) {
-      if (ts.isVariableStatement(statement)) for (const declaration of statement.declarationList.declarations) {
-        if (ts.isIdentifier(declaration.name) && declaration.initializer && (ts.isArrowFunction(declaration.initializer) || ts.isFunctionExpression(declaration.initializer))) callbacks.set(declaration.name.text, declaration.initializer)
-      }
-      if (ts.isFunctionDeclaration(statement) && statement.name && statement.body) callbacks.set(statement.name.text, statement)
-    }
-    const frameOwner = nearestFunction(frameAssignments[0])
-    const shadowedCallback = frameCallback && isShadowedIdentifier(frameCallback, callback.body)
-    const update = frameCallback && !shadowedCallback && callbacks.get(frameCallback.text)
-    if (!update) throw sourceNodeError(frame, sourceFile, "Animation frame refs require a direct local callback")
-    const frameStatement = frameAssignments[0].parent.parent
-    if (!frameOwner || ![...callbacks.values()].includes(frameOwner) || !ts.isBlock(frameOwner.body) || !ts.isExpressionStatement(frameStatement) || !directOrGuarded(frameStatement, frameOwner.body, node.name.text, true)) throw sourceNodeError(frameAssignments[0], sourceFile, "Animation frame requests must be assigned directly inside one local scheduler")
-    const resetAssignments = accesses.filter(access => ts.isBinaryExpression(access.parent) && unwrapExpression(access.parent.left) === access && access.parent.operatorToken.kind === ts.SyntaxKind.EqualsToken && ts.isNumericLiteral(unwrapExpression(access.parent.right)) && Number(unwrapExpression(access.parent.right).text) === 0)
-    const resetStatement = resetAssignments[0]?.parent.parent
-    if (resetAssignments.length !== 1 || nearestFunction(resetAssignments[0]) !== update || !ts.isBlock(update.body) || !ts.isExpressionStatement(resetStatement) || resetStatement.parent !== update.body) throw sourceNodeError(update, sourceFile, "Animation frame callbacks must directly reset their ref to 0")
-    const writes = accesses.filter(access => ts.isBinaryExpression(access.parent) && unwrapExpression(access.parent.left) === access && access.parent.operatorToken.kind >= ts.SyntaxKind.FirstAssignment && access.parent.operatorToken.kind <= ts.SyntaxKind.LastAssignment)
-    if (writes.length !== 2) throw sourceNodeError(node, sourceFile, "Animation frame refs may only be assigned by their request and reset operations")
-    const returns = effectReturns(callback)
-    const cancellations = []
-    const collectCancellations = current => {
-      const argument = current.arguments?.[0] && unwrapExpression(current.arguments[0])
-      if (frameCall(current, "cancelAnimationFrame") && unshadowedFrameCall(current, owner) && current.arguments.length === 1 && currentAccess(argument, node.name.text) && !isShadowedIdentifier(argument.expression, owner.body)) cancellations.push(current)
-      ts.forEachChild(current, collectCancellations)
+function normalizeCompilerSource(sourceFile, { base, context, file, importedCollections, importedStaticCollections, sourceFiles, sourceIndex }) {
+  const factory = context.factory
+  let customHookTimerStates = new Set()
+  sourceFile = applyNormalizationPasses(sourceFile, [
+    ...(importedStaticCollections ? [source => normalizeImportedStaticCollections(source, importedStaticCollections, factory, context)] : []),
+    source => normalizeReactRouterSyntax(source, factory, context, base),
+    source => normalizeClsxSyntax(source, factory, context),
+    source => normalizeMediaQueryExternalStores(source, factory, context),
+    source => normalizeReactMigrationSyntax(source, factory, context, importedCollections ?? importedSerializableCollectionNames(source, file, sourceFiles, sourceIndex)),
+    source => normalizeNavigatorCapabilityConditions(source, factory, context),
+    source => normalizeEffectAnimationFrameRefs(source, factory, context),
+    source => {
+      const result = normalizeCustomHookTimerRefs(source, factory, context)
+      customHookTimerStates = result.timerStates
+      return result.sourceFile
+    },
+    source => {
+      validateUseIdSyntax(source)
+      return source
+    },
+    source => normalizeLazyStateInitializers(source, factory, context, file, sourceFiles, sourceIndex),
+    source => normalizeZustandMigrationSyntax(source, factory, context),
+    source => normalizeRenderControlFlow(source, factory, context),
+    source => {
+      workerCompiler.rejectOrdinaryImports(source, file, sourceFiles)
+      return source
     }
-    collectCancellations(callback.body)
-    const cancellation = cancellations[0]
-    const cleanup = cancellation && returns.cleanups.find(candidate => nearestFunction(cancellation) === candidate)
-    const cancellationStatement = cancellation?.parent
-    if (cancellations.length !== 1 || !cleanup || !ts.isBlock(cleanup.body) || !ts.isExpressionStatement(cancellationStatement) || !directOrGuarded(cancellationStatement, cleanup.body, node.name.text, false)) throw sourceNodeError(node, sourceFile, "Animation frame refs require direct cancellation in effect cleanup")
-    replacements.add(node)
-  }
-  inspect(sourceFile)
-  if (!replacements.size) return sourceFile
-  const visitor = node => {
-    if (replacements.has(node)) return factory.updateVariableDeclaration(node, node.name, node.exclamationToken, node.type, factory.createObjectLiteralExpression([
-      factory.createPropertyAssignment("current", factory.createNumericLiteral(0))
-    ]))
-    return ts.visitEachChild(node, visitor, context)
-  }
-  return ts.visitNode(sourceFile, visitor)
+  ])
+  return { sourceFile, customHookTimerStates }
 }
 
-function createKudzuTransformer(nativeHandlers, effectHandlers, reactiveBindings, listExpressions, handlerUrl, file, sourceFiles, sourceIndex, staticFiles, importedAssets, cssModules, base, clientImports, workerReferences) {
+function createKudzuTransformer({ semantic, handlerUrl, file, sourceFiles, sourceIndex, staticFiles, importedAssets, cssModules, base, workerReferences }) {
+  const { nativeHandlers, effectHandlers } = semantic
   return context => sourceFile => {
-    const factory = context.factory
     const hasLinkElements = /<link/i.test(sourceFile.text)
     const importedStaticCollections = importedSerializableCollections(sourceFile, file, sourceFiles, sourceIndex)
     const importedCollections = new Set(importedStaticCollections.keys())
-    sourceFile = normalizeImportedStaticCollections(sourceFile, importedStaticCollections, factory, context)
-    ts.setParentRecursive(sourceFile, false)
-    sourceFile = normalizeReactRouterSyntax(sourceFile, factory, context, base)
-    ts.setParentRecursive(sourceFile, false)
-    sourceFile = normalizeClsxSyntax(sourceFile, factory, context)
-    ts.setParentRecursive(sourceFile, false)
-    sourceFile = normalizeMediaQueryExternalStores(sourceFile, factory, context)
-    ts.setParentRecursive(sourceFile, false)
-    sourceFile = normalizeReactMigrationSyntax(sourceFile, factory, context, importedCollections)
-    ts.setParentRecursive(sourceFile, false)
-    sourceFile = normalizeNavigatorCapabilityConditions(sourceFile, factory, context)
-    ts.setParentRecursive(sourceFile, false)
-    sourceFile = normalizeEffectAnimationFrameRefs(sourceFile, factory, context)
-    ts.setParentRecursive(sourceFile, false)
-    sourceFile = normalizeCustomHookTimerRefs(sourceFile, factory, context)
-    const customHookTimerStates = customHookTimerStatesBySource.get(sourceFile) ?? new Set()
-    ts.setParentRecursive(sourceFile, false)
-    validateUseIdSyntax(sourceFile)
-    sourceFile = normalizeLazyStateInitializers(sourceFile, factory, context, file, sourceFiles, sourceIndex)
-    ts.setParentRecursive(sourceFile, false)
-    sourceFile = normalizeZustandMigrationSyntax(sourceFile, factory, context)
-    ts.setParentRecursive(sourceFile, false)
-    sourceFile = normalizeRenderControlFlow(sourceFile, factory, context)
-    ts.setParentRecursive(sourceFile, false)
-    rejectOrdinaryWorkerImports(sourceFile, file, sourceFiles)
+    const normalized = normalizeCompilerSource(sourceFile, { base, context, file, importedCollections, importedStaticCollections, sourceFiles, sourceIndex })
+    sourceFile = normalized.sourceFile
+    const { customHookTimerStates } = normalized
+    const factory = context.factory
+    const descriptors = createDescriptorSession({
+      semantic,
+      handlerUrl,
+      factory,
+      context,
+      compileEventCommand,
+      isPrimitiveLiteral: isPrimitiveDefaultLiteral,
+      rejectWorkerConstructions: expression => workerCompiler.rejectConstructions(expression, expression.getSourceFile(), "Relative TypeScript Worker construction is only supported directly inside an inline useEffect() callback")
+    })
     const importBindings = clientImportBindings(sourceFile, file, sourceFiles)
     const packageBindings = packageImportBindings(sourceFile)
     for (const [name] of packageBindings) {
@@ -3065,36 +904,14 @@ function createKudzuTransformer(nativeHandlers, effectHandlers, reactiveBindings
       if (invalid) throw sourceNodeError(invalid, sourceFile, `Package import ${JSON.stringify(name)} may only be referenced directly inside JSX event handlers`)
     }
     const hasUseEffectImport = sourceFile.statements.some(statement => ts.isImportDeclaration(statement) && ["@kudzujs/core", "react"].includes(statement.moduleSpecifier.text) && statement.importClause?.namedBindings && ts.isNamedImports(statement.importClause.namedBindings) && statement.importClause.namedBindings.elements.some(entry => !entry.propertyName && entry.name.text === "useEffect"))
-    const importedSources = new Map()
-    const importedTimerStates = new Map()
+    const importedSourceCache = new Map()
     const importedSource = target => {
-      let imported = importedSources.get(target)
-      if (!imported) {
-        imported = normalizeReactRouterSyntax(parseSourceFile(target, sourceIndex.get(target)), factory, context, base)
-        ts.setParentRecursive(imported, false)
-        imported = normalizeClsxSyntax(imported, factory, context)
-        ts.setParentRecursive(imported, false)
-        imported = normalizeMediaQueryExternalStores(imported, factory, context)
-        ts.setParentRecursive(imported, false)
-        imported = normalizeReactMigrationSyntax(imported, factory, context, importedSerializableCollectionNames(imported, target, sourceFiles, sourceIndex))
-        ts.setParentRecursive(imported, false)
-        imported = normalizeNavigatorCapabilityConditions(imported, factory, context)
-        ts.setParentRecursive(imported, false)
-        imported = normalizeEffectAnimationFrameRefs(imported, factory, context)
-        ts.setParentRecursive(imported, false)
-        imported = normalizeCustomHookTimerRefs(imported, factory, context)
-        importedTimerStates.set(target, customHookTimerStatesBySource.get(imported) ?? new Set())
-        ts.setParentRecursive(imported, false)
-        validateUseIdSyntax(imported)
-        imported = normalizeLazyStateInitializers(imported, factory, context, target, sourceFiles, sourceIndex)
-        ts.setParentRecursive(imported, false)
-        imported = normalizeZustandMigrationSyntax(imported, factory, context)
-        ts.setParentRecursive(imported, false)
-        imported = normalizeRenderControlFlow(imported, factory, context)
-        ts.setParentRecursive(imported, false)
-        importedSources.set(target, imported)
+      let result = importedSourceCache.get(target)
+      if (!result) {
+        result = normalizeCompilerSource(parseSourceFile(target, sourceIndex.get(target)), { base, context, file: target, sourceFiles, sourceIndex })
+        importedSourceCache.set(target, result)
       }
-      return imported
+      return result.sourceFile
     }
     const importedCollectionTransforms = new Map()
     const importedCalculationFunctions = new Map()
@@ -3255,7 +1072,7 @@ function createKudzuTransformer(nativeHandlers, effectHandlers, reactiveBindings
         const capture = nativeCaptureNames(callback, states).values().next().value
         if (capture) throw sourceNodeError(callback, hookSource, `Relative custom hook callback ${JSON.stringify(name)} cannot capture private binding ${JSON.stringify(capture)}`)
       }
-      const privateStates = new Set([...states.values()].filter(state => importedTimerStates.get(hookSource.fileName)?.has(state)))
+      const privateStates = new Set([...states.values()].filter(state => importedSourceCache.get(hookSource.fileName)?.customHookTimerStates.has(state)))
       const analysis = { callbacks, fields, privateStates, states }
       customHooks.set(key, analysis)
       return analysis
@@ -3492,14 +1309,14 @@ function createKudzuTransformer(nativeHandlers, effectHandlers, reactiveBindings
             const call = unwrapExpression(current.expression)
             if (ts.isIdentifier(call.expression) && importBindings.has(call.expression.text) && importBindings.get(call.expression.text).kind !== "namespace") {
               validateImportedCalculation(call, current.name.text)
-              for (const argument of call.arguments) collectionExpression(argument, {}, (target, message) => fail(target, message.replace("Rendered collection", "Reactive imported calculation")), allowedNames)
+              for (const argument of call.arguments) collectionExpression(argument, { fail: (target, message) => fail(target, message.replace("Rendered collection", "Reactive imported calculation")), stateNames: allowedNames })
               return factory.createNumericLiteral(0)
             }
           }
           return ts.visitEachChild(current, validate, context)
         }
         const normalized = ts.visitNode(value, validate)
-        collectionExpression(normalized, {}, (node, message) => fail(node, message.replace("Rendered collection", "Reactive JSX local")), allowedNames)
+        collectionExpression(normalized, { fail: (node, message) => fail(node, message.replace("Rendered collection", "Reactive JSX local")), stateNames: allowedNames })
         return
       }
       const intl = constructor.expression.expression
@@ -3509,7 +1326,7 @@ function createKudzuTransformer(nativeHandlers, effectHandlers, reactiveBindings
       const roundAccess = rounded && ts.isCallExpression(rounded) && !rounded.questionDotToken && rounded.arguments.length === 1 && ts.isPropertyAccessExpression(rounded.expression) && !rounded.expression.questionDotToken && rounded.expression.name.text === "round" && ts.isIdentifier(rounded.expression.expression) && rounded.expression.expression.text === "Math" ? rounded.expression : undefined
       if (!roundAccess) fail(value, "Reactive JSX Intl.NumberFormat format() requires exactly Math.round(expression)")
       if (!isUnshadowedGlobal(roundAccess.expression, sourceFile)) fail(roundAccess.expression, "Reactive JSX Intl.NumberFormat requires the unshadowed global Math object")
-      collectionExpression(rounded.arguments[0], {}, (node, message) => fail(node, message.replace("Rendered collection", "Reactive JSX local")), allowedNames)
+      collectionExpression(rounded.arguments[0], { fail: (node, message) => fail(node, message.replace("Rendered collection", "Reactive JSX local")), stateNames: allowedNames })
     }
     const resolveReactiveJsxExpression = (expression, owner, setters) => {
       const declarations = jsxLocalDeclarations.get(owner)
@@ -4081,16 +1898,12 @@ function createKudzuTransformer(nativeHandlers, effectHandlers, reactiveBindings
       if (!usedStates.size && !captures.size) return ts.visitEachChild(expression, visitor, context)
       usesBehavior = true
       usesConditional = true
-      return compileConditional(
+      return descriptors.compileConditional(
         parts.kind,
         parts.condition,
         compileRenderExpression(parts.truthy, anchor),
         compileRenderExpression(parts.falsy, anchor),
-        setters,
-        factory,
-        context,
-        reactiveBindings,
-        handlerUrl
+        setters
       )
     }
 
@@ -4190,7 +2003,7 @@ function createKudzuTransformer(nativeHandlers, effectHandlers, reactiveBindings
           const derivedStates = initializer && !directAlias ? referencedStateNames(initializer, setters) : new Set()
           if (derivedStates.size) {
             const usedStates = new Set()
-            const expression = collectionExpression(initializer, {}, effectFail, stateNames, usedStates)
+            const expression = collectionExpression(initializer, { fail: effectFail, stateNames, selectorStates: usedStates })
             if (!usedStates.size) effectFail(dependency, `useEffect() derived dependency "${dependency.text}" must read direct primitive state`)
             dependencyExpressions.push(expression)
             for (const name of usedStates) {
@@ -4242,11 +2055,19 @@ function createKudzuTransformer(nativeHandlers, effectHandlers, reactiveBindings
         }
         if (listEffect && callbackFile !== file) {
           const originalCallback = listEffect.source.arguments[0]
-          rejectWorkerConstructions(originalCallback, callbackSource, "Relative TypeScript Worker construction in imported keyed-row effects is not supported; construct the Worker in a directly compiled page or local component effect")
+          workerCompiler.rejectConstructions(originalCallback, callbackSource, "Relative TypeScript Worker construction in imported keyed-row effects is not supported; construct the Worker in a directly compiled page or local component effect")
         } else {
-          compiledCallback = rewriteEffectWorkers(compiledCallback, callbackFile, callbackSource, sourceFiles, workerReferences, factory, context)
-        }
-        const descriptor = compileNativeCallback(compiledCallback, setters, reducersForNode(node, reducersByFunction), factory, effectHandlers, specializedEffect?.imports ?? importBindings, clientImports, "effect", dependencyItem, true, returns.cleanup, customHookTimerStates)
+          compiledCallback = workerCompiler.rewriteEffect(compiledCallback, callbackFile, callbackSource, sourceFiles, workerReferences, factory, context)
+        }
+        const descriptor = descriptors.compileEffectCallback(compiledCallback, {
+          setters,
+          reducers: reducersForNode(node, reducersByFunction),
+          importBindings: specializedEffect?.imports ?? importBindings,
+          listItem: dependencyItem,
+          deferValues: true,
+          snapshotNested: returns.cleanup,
+          liveStates: customHookTimerStates
+        })
         for (const reference of workerReferences.slice(workerStart)) Object.assign(reference, { module: handlerUrl, handler: descriptor.exportName })
         usesListItem ||= Boolean(itemDependencies.length && !listEffect)
         usesBehavior = true
@@ -4302,19 +2123,19 @@ function createKudzuTransformer(nativeHandlers, effectHandlers, reactiveBindings
 
       if (ts.isJsxExpression(node) && node.expression && listConditions.has(node.expression)) {
         const entry = listConditions.get(node.expression)
-        return factory.updateJsxExpression(node, compileListConditional({
+        return factory.updateJsxExpression(node, descriptors.compileListConditional({
           ...entry,
           truthy: ts.visitNode(entry.truthy, visitor),
           falsy: ts.visitNode(entry.falsy, visitor)
-        }, factory, listExpressions, handlerUrl))
+        }))
       }
 
       if (ts.isJsxExpression(node) && node.expression && listValues.has(node.expression)) {
-        return factory.updateJsxExpression(node, compileListValue(node.expression, listValues.get(node.expression), factory, context, listExpressions, handlerUrl))
+        return factory.updateJsxExpression(node, descriptors.compileListValue(node.expression, listValues.get(node.expression)))
       }
 
       if (ts.isJsxAttribute(node) && node.initializer && ts.isJsxExpression(node.initializer) && node.initializer.expression && listValues.has(node.initializer.expression)) {
-        return factory.updateJsxAttribute(node, node.name, factory.createJsxExpression(undefined, compileListValue(node.initializer.expression, listValues.get(node.initializer.expression), factory, context, listExpressions, handlerUrl)))
+        return factory.updateJsxAttribute(node, node.name, factory.createJsxExpression(undefined, descriptors.compileListValue(node.initializer.expression, listValues.get(node.initializer.expression))))
       }
 
       if (ts.isJsxExpression(node) && node.initializer === undefined && node.expression && (ts.isJsxElement(node.parent) || ts.isJsxFragment(node.parent))) {
@@ -4326,7 +2147,7 @@ function createKudzuTransformer(nativeHandlers, effectHandlers, reactiveBindings
           let listSource = listParts.state
           if (listParts.calculation) {
             usesBinding = true
-            listSource = compileReactiveBinding(listParts.calculation, settersForNode(node, settersByFunction), factory, context, reactiveBindings, handlerUrl, importBindings, clientImports)
+            listSource = descriptors.compileReactiveBinding(listParts.calculation, { setters: settersForNode(node, settersByFunction), importBindings })
           }
           const arguments_ = [
             listSource,
@@ -4352,7 +2173,7 @@ function createKudzuTransformer(nativeHandlers, effectHandlers, reactiveBindings
         if ((usedStates.size || captures.size) && !ts.isIdentifier(expression) && !containsJsx(expression)) {
           usesBehavior = true
           usesBinding = true
-          return factory.updateJsxExpression(node, compileReactiveBinding(expression, setters, factory, context, reactiveBindings, handlerUrl, importBindings, clientImports))
+          return factory.updateJsxExpression(node, descriptors.compileReactiveBinding(expression, { setters, importBindings }))
         }
       }
 
@@ -4365,14 +2186,20 @@ function createKudzuTransformer(nativeHandlers, effectHandlers, reactiveBindings
         if ((usedStates.size || captures.size) && !ts.isIdentifier(expression)) {
           usesBehavior = true
           usesBinding = true
-          const compiled = compileReactiveBinding(expression, setters, factory, context, reactiveBindings, handlerUrl, importBindings, clientImports)
+          const compiled = descriptors.compileReactiveBinding(expression, { setters, importBindings })
           return factory.updateJsxAttribute(node, node.name, factory.createJsxExpression(undefined, compiled))
         }
       }
 
       if (ts.isJsxAttribute(node) && node.initializer && ts.isJsxExpression(node.initializer) && node.initializer.expression && /^on[A-Z]/.test(node.name.text)) {
         const setters = settersForNode(node, settersByFunction)
-        const event = compileEvent(node.initializer.expression, setters, reducersForNode(node, reducersByFunction), functionsForNode(node), factory, nativeHandlers, handlerUrl, listEventItems.get(node), new Map([...importBindings, ...packageBindings]), clientImports)
+        const event = descriptors.compileEvent(node.initializer.expression, {
+          setters,
+          reducers: reducersForNode(node, reducersByFunction),
+          functions: functionsForNode(node),
+          listItem: listEventItems.get(node),
+          importBindings: new Map([...importBindings, ...packageBindings])
+        })
         if (event) {
           usesBehavior = true
           return factory.updateJsxAttribute(node, node.name, factory.createJsxExpression(undefined, event))
@@ -4416,106 +2243,12 @@ function createKudzuTransformer(nativeHandlers, effectHandlers, reactiveBindings
     if (usesComponentEffects) behaviorImports.push(factory.createImportSpecifier(false, factory.createIdentifier("useEffect"), factory.createIdentifier("__kComponentUseEffect")))
     if (usesBinding || usesConditional) behaviorImports.push(factory.createImportSpecifier(false, factory.createIdentifier("bindingValue"), factory.createIdentifier("__kBindingValue")))
     const behaviorImport = factory.createImportDeclaration(
-      undefined,
-      factory.createImportClause(false, undefined, factory.createNamedImports(behaviorImports)),
-      factory.createStringLiteral("@kudzujs/core")
-    )
-    return factory.updateSourceFile(transformed, [behaviorImport, ...transformed.statements])
-  }
-}
-
-function normalizeRenderControlFlow(sourceFile, factory, context) {
-  const normalizeStatements = statements => {
-    const nested = statements.map(statement => ts.visitEachChild(statement, visitNested, context))
-    const assigned = []
-    for (let index = 0; index < nested.length; index++) {
-      const statement = nested[index]
-      const next = nested[index + 1]
-      const declaration = singleUninitializedLet(statement)
-      const assignment = declaration && next && assignmentConditional(next, declaration.name.text, factory)
-      if (declaration && assignment) {
-        const updated = factory.updateVariableDeclaration(declaration, declaration.name, declaration.exclamationToken, declaration.type, assignment)
-        const list = factory.createVariableDeclarationList([updated], ts.NodeFlags.Const)
-        assigned.push(factory.updateVariableStatement(statement, statement.modifiers, list))
-        index++
-      } else {
-        assigned.push(statement)
-      }
-    }
-
-    if (!assigned.length) return assigned
-    const finalIf = returnConditional(assigned.at(-1), factory)
-    if (finalIf) return [...assigned.slice(0, -1), factory.createReturnStatement(finalIf)]
-    if (!ts.isReturnStatement(assigned.at(-1)) || !assigned.at(-1).expression) return assigned
-    let expression = assigned.at(-1).expression
-    let start = assigned.length - 1
-    while (start > 0) {
-      const previous = assigned[start - 1]
-      if (!ts.isIfStatement(previous) || previous.elseStatement) break
-      const truthy = returnOnlyExpression(previous.thenStatement)
-      if (!truthy) break
-      expression = factory.createConditionalExpression(previous.expression, factory.createToken(ts.SyntaxKind.QuestionToken), truthy, factory.createToken(ts.SyntaxKind.ColonToken), expression)
-      start--
-    }
-    return start === assigned.length - 1 ? assigned : [...assigned.slice(0, start), factory.createReturnStatement(expression)]
-  }
-
-  const visitNested = node => {
-    if (ts.isBlock(node)) return factory.updateBlock(node, normalizeStatements([...node.statements]))
-    if (isFunctionLike(node) && ts.isBlock(node.body)) {
-      if (!isRenderFunction(node)) return node
-      const body = factory.updateBlock(node.body, normalizeStatements([...node.body.statements]))
-      if (ts.isFunctionDeclaration(node)) return factory.updateFunctionDeclaration(node, node.modifiers, node.asteriskToken, node.name, node.typeParameters, node.parameters, node.type, body)
-      if (ts.isFunctionExpression(node)) return factory.updateFunctionExpression(node, node.modifiers, node.asteriskToken, node.name, node.typeParameters, node.parameters, node.type, body)
-      if (ts.isArrowFunction(node)) return factory.updateArrowFunction(node, node.modifiers, node.typeParameters, node.parameters, node.type, node.equalsGreaterThanToken, body)
-    }
-    return ts.visitEachChild(node, visitNested, context)
-  }
-
-  return ts.visitEachChild(sourceFile, visitNested, context)
-}
-
-function isRenderFunction(node) {
-  if (ts.isFunctionDeclaration(node)) return node.modifiers?.some(modifier => modifier.kind === ts.SyntaxKind.DefaultKeyword) || Boolean(node.name && /^[A-Z]/.test(node.name.text))
-  const declaration = node.parent
-  return ts.isVariableDeclaration(declaration) && ts.isIdentifier(declaration.name) && /^[A-Z]/.test(declaration.name.text)
-}
-
-function singleUninitializedLet(statement) {
-  if (!ts.isVariableStatement(statement) || (statement.declarationList.flags & ts.NodeFlags.Let) === 0 || statement.declarationList.declarations.length !== 1) return undefined
-  const declaration = statement.declarationList.declarations[0]
-  return ts.isIdentifier(declaration.name) && !declaration.initializer ? declaration : undefined
-}
-
-function assignmentConditional(statement, name, factory) {
-  if (!ts.isIfStatement(statement) || !statement.elseStatement) return undefined
-  const truthy = assignmentOnlyExpression(statement.thenStatement, name)
-  const falsy = ts.isIfStatement(statement.elseStatement)
-    ? assignmentConditional(statement.elseStatement, name, factory)
-    : assignmentOnlyExpression(statement.elseStatement, name)
-  if (!truthy || !falsy) return undefined
-  return factory.createConditionalExpression(statement.expression, factory.createToken(ts.SyntaxKind.QuestionToken), truthy, factory.createToken(ts.SyntaxKind.ColonToken), falsy)
-}
-
-function assignmentOnlyExpression(statement, name) {
-  const candidate = ts.isBlock(statement) && statement.statements.length === 1 ? statement.statements[0] : statement
-  if (!ts.isExpressionStatement(candidate) || !ts.isBinaryExpression(candidate.expression) || candidate.expression.operatorToken.kind !== ts.SyntaxKind.EqualsToken || !ts.isIdentifier(candidate.expression.left) || candidate.expression.left.text !== name) return undefined
-  return candidate.expression.right
-}
-
-function returnConditional(statement, factory) {
-  if (!ts.isIfStatement(statement) || !statement.elseStatement) return undefined
-  const truthy = returnOnlyExpression(statement.thenStatement)
-  const falsy = ts.isIfStatement(statement.elseStatement)
-    ? returnConditional(statement.elseStatement, factory)
-    : returnOnlyExpression(statement.elseStatement)
-  if (!truthy || !falsy) return undefined
-  return factory.createConditionalExpression(statement.expression, factory.createToken(ts.SyntaxKind.QuestionToken), truthy, factory.createToken(ts.SyntaxKind.ColonToken), falsy)
-}
-
-function returnOnlyExpression(statement) {
-  const candidate = ts.isBlock(statement) && statement.statements.length === 1 ? statement.statements[0] : statement
-  return ts.isReturnStatement(candidate) && candidate.expression ? candidate.expression : undefined
+      undefined,
+      factory.createImportClause(false, undefined, factory.createNamedImports(behaviorImports)),
+      factory.createStringLiteral("@kudzujs/core")
+    )
+    return factory.updateSourceFile(transformed, [behaviorImport, ...transformed.statements])
+  }
 }
 
 function containsRenderControl(root, knownLocals) {
@@ -4534,7 +2267,9 @@ function keyedListParts(expression, setters, declarations, fail, aliases = new S
   const value = unwrapExpression(expression)
   const directFrom = isArrayFromCall(value) && value.arguments.length === 2 && containsJsx(value.arguments[1])
   if (!directFrom && (!ts.isCallExpression(value) || value.arguments.length !== 1 || !ts.isPropertyAccessExpression(value.expression) || value.expression.name.text !== "map")) return undefined
-  let collection = renderedCollectionSource(directFrom ? value.arguments[0] : value.expression.expression, setters, declarations, fail, aliases, importedCollections, new Set(setters.values()), importedCollectionTransforms, factory, context, calculatedCollection, staticCollection)
+  let collection = analyzeCollectionPipeline(directFrom ? value.arguments[0] : value.expression.expression, {
+    setters, declarations, fail, aliases, importedCollections, stateNames: new Set(setters.values()), importedCollectionTransforms, calculatedCollection, staticCollection
+  })
   if (!collection?.state && !collection?.calculation) return undefined
   if (directFrom) collection.selector.push(["from", undefined])
   let callback = directFrom ? value.arguments[1] : value.arguments[0]
@@ -4544,7 +2279,7 @@ function keyedListParts(expression, setters, declarations, fail, aliases = new S
     if (!context || root.statements.length !== 2 || !ts.isVariableStatement(root.statements[0]) || (root.statements[0].declarationList.flags & ts.NodeFlags.Const) === 0 || root.statements[0].declarationList.declarations.length !== 1 || !ts.isReturnStatement(root.statements[1]) || !root.statements[1].expression) fail(root, "Block-bodied keyed list map callbacks require one computed child collection const and a final JSX return")
     const declaration = root.statements[0].declarationList.declarations[0]
     if (!ts.isIdentifier(declaration.name) || !declaration.initializer) fail(declaration, "Computed child collections must initialize one const identifier")
-    const computed = renderedCollectionSource(declaration.initializer, new Map(), undefined, fail, new Set(), new Set(), new Set(), importedCollectionTransforms, factory, context)
+    const computed = analyzeCollectionPipeline(declaration.initializer, { fail, importedCollectionTransforms })
     if (!computed?.ownerField || computed.parentItem !== parameters.item) fail(declaration.initializer, `Computed child collections must start from ${parameters.item}.<field>`)
     const returned = root.statements[1].expression
     if (identifierReferenceCount(returned, declaration.name.text) !== 1) fail(declaration.name, `Computed child collection alias "${declaration.name.text}" must be used exactly once`)
@@ -4568,7 +2303,7 @@ function keyedListParts(expression, setters, declarations, fail, aliases = new S
 function nestedKeyedListParts(expression, parentItem, fail) {
   const value = unwrapExpression(expression)
   if (!ts.isCallExpression(value) || value.arguments.length !== 1 || !ts.isPropertyAccessExpression(value.expression) || value.expression.name.text !== "map") return undefined
-  let collection = renderedCollectionSource(value.expression.expression, new Map(), undefined, fail, new Set())
+  let collection = analyzeCollectionPipeline(value.expression.expression, { fail })
   if (!collection?.ownerField || collection.parentItem !== parentItem) return undefined
   let callback = value.arguments[0]
   const parameters = collectionParameters(callback, "Nested keyed list map", fail)
@@ -4600,175 +2335,13 @@ function conditionalKeyedMapRoot(callback, root, parameters, collection, fail, s
   }
   if (parameters.index) fail(callback.parameters[1], "Conditional keyed map callbacks cannot use a map index because filtering changes index semantics; use an explicit filter(...).map((item, index) => ...) when a filtered index is intended")
   const selectorStates = new Set(collection.selectorStates)
-  const selector = collectionExpression(condition, parameters, fail, stateNames, selectorStates)
+  const selector = collectionExpression(condition, { parameters, fail, stateNames, selectorStates })
   const normalized = factory.updateArrowFunction(callback, callback.modifiers, callback.typeParameters, callback.parameters, callback.type, callback.equalsGreaterThanToken, rendered)
   ts.setParentRecursive(normalized, false)
   normalized.parent = parent
   return { callback: normalized, root: rendered, collection: { ...collection, selector: [...collection.selector, ["filter", selector]], selectorStates } }
 }
 
-function renderedCollectionSource(expression, setters, declarations, fail, aliases, importedCollections = new Set(), stateNames = new Set(), importedCollectionTransforms = new Map(), factory = ts.factory, context, calculatedCollection, staticCollection) {
-  const value = unwrapExpression(expression)
-  if (ts.isIdentifier(value)) {
-    if ([...setters.values()].includes(value.text)) {
-      const localStatic = staticCollection?.(value.text)
-      return { state: value, static: localStatic, localStatic, selector: [], selectorStates: new Set() }
-    }
-    if (importedCollections.has(value.text)) return { state: value, static: true, selector: [], selectorStates: new Set() }
-    const entries = declarations?.get(value.text)
-    if (!entries) return undefined
-    if (entries.length !== 1 || aliases.has(value.text) || entries[0].node.parent?.parent?.parent !== nearestFunction(entries[0].node)?.body) fail(value, `Rendered collection alias "${value.text}" must be one top-level immutable local`)
-    aliases.add(value.text)
-    const source = renderedCollectionSource(entries[0].initializer, setters, declarations, fail, aliases, importedCollections, stateNames, importedCollectionTransforms, factory, context, calculatedCollection, staticCollection)
-    aliases.delete(value.text)
-    return source && { ...source, aliasDeclarations: [...(source.aliasDeclarations ?? []), entries[0].node], aliasUses: [...(source.aliasUses ?? []), value] }
-  }
-  if (ts.isPropertyAccessExpression(value) && ts.isIdentifier(value.expression)) {
-    const calculation = calculatedCollection?.(value)
-    if (calculation) return { calculation, 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)) {
-    const transform = importedCollectionTransforms.get(value.expression.text)
-    const parameter = transform.parameters[0]
-    if (value.arguments.length !== 1 || transform.parameters.length !== 1 || transform.asteriskToken || transform.modifiers?.some(modifier => modifier.kind === ts.SyntaxKind.AsyncKeyword) || !parameter || !ts.isIdentifier(parameter.name) || parameter.dotDotDotToken || parameter.initializer || parameter.questionToken) fail(value, `Imported collection transform "${value.expression.text}" must be synchronous with exactly one identifier parameter and one argument`)
-    const returned = ts.isBlock(transform.body)
-      ? transform.body.statements.length === 1 && ts.isReturnStatement(transform.body.statements[0]) ? transform.body.statements[0].expression : undefined
-      : transform.body
-    if (!returned) fail(value, `Imported collection transform "${value.expression.text}" must contain only one returned collection expression`)
-    const transformSource = renderedCollectionSource(returned, new Map([[parameter.name.text, parameter.name.text]]), undefined, fail, new Set(), new Set(), new Set([parameter.name.text]))
-    if (!transformSource?.state || transformSource.state.text !== parameter.name.text || transformSource.selectorStates.size) fail(value, `Imported collection transform "${value.expression.text}" must return a supported pure pipeline rooted only in its parameter`)
-    const source = renderedCollectionSource(value.arguments[0], setters, declarations, fail, aliases, importedCollections, stateNames, importedCollectionTransforms, factory, context, calculatedCollection, staticCollection)
-    if (!source) fail(value.arguments[0], `Imported collection transform "${value.expression.text}" requires a supported collection argument`)
-    return { ...source, selector: [...source.selector, ...transformSource.selector] }
-  }
-  if (ts.isCallExpression(value) && ts.isPropertyAccessExpression(value.expression)) {
-    const method = value.expression.name.text
-    if (method === "filter") {
-      if (value.arguments.length !== 1) fail(value, "Rendered collection filter() requires one inline predicate")
-      const source = renderedCollectionSource(value.expression.expression, setters, declarations, fail, aliases, importedCollections, stateNames, importedCollectionTransforms, factory, context, calculatedCollection, staticCollection)
-      if (!source) return undefined
-      const parameters = collectionParameters(value.arguments[0], "Rendered collection filter()", fail)
-      const selectorStates = new Set(source.selectorStates)
-      return { ...source, selector: [...source.selector, ["filter", collectionExpression(unwrapExpression(value.arguments[0].body), parameters, fail, stateNames, selectorStates)]], selectorStates }
-    }
-    if (method === "flatMap") {
-      if (value.arguments.length !== 1) fail(value, "Rendered collection flatMap() requires one inline projector")
-      const source = renderedCollectionSource(value.expression.expression, setters, declarations, fail, aliases, importedCollections, stateNames, importedCollectionTransforms, factory, context, calculatedCollection, staticCollection)
-      if (!source) return undefined
-      const parameters = collectionParameters(value.arguments[0], "Rendered collection flatMap()", fail)
-      const field = directProperty(value.arguments[0].body, parameters.item)
-      if (!field) fail(value.arguments[0].body, `Rendered collection flatMap() projector must be ${parameters.item}.<field>`)
-      if (["__proto__", "constructor", "prototype"].includes(field)) fail(value.arguments[0].body, `Rendered collection property "${field}" is not supported`)
-      return { ...source, selector: [...source.selector, ["flatMap", field]] }
-    }
-    if (method === "slice") {
-      if (value.arguments.length < 1 || value.arguments.length > 2) fail(value, "Rendered collection slice() requires a start and optional end")
-      const source = renderedCollectionSource(value.expression.expression, setters, declarations, fail, aliases, importedCollections, stateNames, importedCollectionTransforms, factory, context, calculatedCollection, staticCollection)
-      if (!source) return undefined
-      const selectorStates = new Set(source.selectorStates)
-      const start = collectionExpression(value.arguments[0], {}, fail, stateNames, selectorStates)
-      const end = value.arguments[1] && collectionExpression(value.arguments[1], {}, fail, stateNames, selectorStates)
-      return { ...source, selector: [...source.selector, ["slice", start, end]], selectorStates }
-    }
-    if (method === "toSorted") {
-      if (value.arguments.length !== 1) fail(value, "Rendered collection toSorted() requires one inline comparator")
-      const source = renderedCollectionSource(value.expression.expression, setters, declarations, fail, aliases, importedCollections, stateNames, importedCollectionTransforms, factory, context, calculatedCollection, staticCollection)
-      if (!source) return undefined
-      const comparator = value.arguments[0]
-      const parameters = collectionParameters(comparator, "Rendered collection toSorted()", fail)
-      if (comparator.parameters.length !== 2 || ts.isBlock(comparator.body)) fail(comparator, "Rendered collection toSorted() comparator must be a synchronous expression arrow with (left, right) identifier parameters")
-      const selectorStates = new Set(source.selectorStates)
-      const expression = collectionExpression(comparator.body, parameters, fail, stateNames, selectorStates)
-      return { ...source, selector: [...source.selector, ["sort", expression]], selectorStates }
-    }
-    if (method === "sort") fail(value, "Rendered collections cannot use mutating sort(); use toSorted()")
-  }
-  if (isArrayFromCall(value)) {
-    if (value.arguments.length < 1 || value.arguments.length > 2) fail(value, "Rendered Array.from() requires an anchor and optional inline mapper")
-    const source = renderedCollectionSource(value.arguments[0], setters, declarations, fail, aliases, importedCollections, stateNames, importedCollectionTransforms, factory, context, calculatedCollection, staticCollection)
-    if (!source) return undefined
-    let mapper
-    if (value.arguments[1]) {
-      const parameters = collectionParameters(value.arguments[1], "Rendered Array.from() mapper", fail)
-      const selectorStates = new Set(source.selectorStates)
-      mapper = collectionExpression(unwrapExpression(value.arguments[1].body), parameters, fail, stateNames, selectorStates)
-      source.selectorStates = selectorStates
-    }
-    return { ...source, selector: [...source.selector, ["from", mapper]] }
-  }
-}
-
-function isArrayFromCall(value) {
-  return ts.isCallExpression(value) && ts.isPropertyAccessExpression(value.expression) && ts.isIdentifier(value.expression.expression) && value.expression.expression.text === "Array" && value.expression.name.text === "from"
-}
-
-function collectionParameters(callback, label, fail) {
-  if (!ts.isArrowFunction(callback) || callback.modifiers?.some(modifier => modifier.kind === ts.SyntaxKind.AsyncKeyword) || callback.parameters.length < 1 || callback.parameters.length > 2 || callback.parameters.some(parameter => !ts.isIdentifier(parameter.name) || parameter.dotDotDotToken || parameter.initializer || parameter.questionToken)) fail(callback, `${label} callback must be a synchronous arrow function with (item) or (item, index) identifier parameters`)
-  return { item: callback.parameters[0].name.text, index: callback.parameters[1]?.name.text }
-}
-
-function collectionExpression(expression, parameters, fail, stateNames = new Set(), selectorStates = new Set()) {
-  const encode = node => {
-    node = unwrapExpression(node)
-    if (ts.isStringLiteral(node) || ts.isNoSubstitutionTemplateLiteral(node) || ts.isNumericLiteral(node)) return ["value", ts.isNumericLiteral(node) ? Number(node.text) : node.text]
-    if (node.kind === ts.SyntaxKind.TrueKeyword) return ["value", true]
-    if (node.kind === ts.SyntaxKind.FalseKeyword) return ["value", false]
-    if (node.kind === ts.SyntaxKind.NullKeyword) return ["value", null]
-    if (ts.isIdentifier(node)) {
-      if (node.text === parameters.item) return ["item"]
-      if (node.text === parameters.index) return ["index"]
-      if (node.text === "undefined") return ["undefined"]
-      if (stateNames.has(node.text)) {
-        selectorStates.add(node.text)
-        return ["state", node.text]
-      }
-      fail(node, `Rendered collection expression identifier "${node.text}" is not allowed`)
-    }
-    if (ts.isPropertyAccessExpression(node)) {
-      if (["__proto__", "constructor", "prototype"].includes(node.name.text)) fail(node, `Rendered collection property "${node.name.text}" is not supported`)
-      return ["get", encode(node.expression), node.name.text, Boolean(node.questionDotToken)]
-    }
-    if (ts.isElementAccessExpression(node)) {
-      const key = node.argumentExpression
-      if (!ts.isStringLiteral(key) && !ts.isNumericLiteral(key)) fail(node, "Rendered collection computed properties require a direct string or numeric literal key")
-      if (ts.isStringLiteral(key) && ["__proto__", "constructor", "prototype"].includes(key.text)) fail(node, `Rendered collection property "${key.text}" is not supported`)
-      return ["get", encode(node.expression), ts.isNumericLiteral(key) ? Number(key.text) : key.text, Boolean(node.questionDotToken)]
-    }
-    if (ts.isPrefixUnaryExpression(node)) {
-      const operator = node.operator === ts.SyntaxKind.ExclamationToken ? "!" : node.operator === ts.SyntaxKind.PlusToken ? "+" : node.operator === ts.SyntaxKind.MinusToken ? "-" : undefined
-      if (!operator) fail(node, "Rendered collection expression uses an unsupported unary operator")
-      return ["unary", operator, encode(node.operand)]
-    }
-    if (ts.isTypeOfExpression(node)) return ["unary", "typeof", encode(node.expression)]
-    if (ts.isBinaryExpression(node)) {
-      const operator = node.operatorToken.getText()
-      if (!new Set(["&&", "||", "??", "===", "!==", "==", "!=", "<", "<=", ">", ">=", "+", "-", "*", "/", "%"]).has(operator)) fail(node, `Rendered collection expression operator "${operator}" is not supported`)
-      return ["binary", operator, encode(node.left), encode(node.right)]
-    }
-    if (ts.isConditionalExpression(node)) return ["conditional", encode(node.condition), encode(node.whenTrue), encode(node.whenFalse)]
-    if (ts.isArrayLiteralExpression(node) && !node.elements.some(ts.isSpreadElement)) return ["array", ...node.elements.map(encode)]
-    if (ts.isObjectLiteralExpression(node)) return ["object", ...node.properties.map(property => {
-      if (!ts.isPropertyAssignment(property) || !ts.isIdentifier(property.name) && !ts.isStringLiteral(property.name) && !ts.isNumericLiteral(property.name)) fail(property, "Rendered collection mapper objects require direct properties")
-      return [property.name.text, encode(property.initializer)]
-    })]
-    if (ts.isTemplateExpression(node)) return ["template", [node.head.text, ...node.templateSpans.map(span => span.literal.text)], node.templateSpans.map(span => encode(span.expression))]
-    if (ts.isCallExpression(node)) {
-      if (ts.isIdentifier(node.expression) && ["Boolean", "Number", "String"].includes(node.expression.text)) return ["global", node.expression.text, ...node.arguments.map(encode)]
-      if (ts.isPropertyAccessExpression(node.expression)) {
-        const method = node.expression.name.text
-        if (ts.isIdentifier(node.expression.expression) && node.expression.expression.text === "Math" && pureMathMethods.has(method)) return ["math", method, ...node.arguments.map(encode)]
-        if (pureListMethods.has(method)) return ["call", encode(node.expression.expression), method, ...node.arguments.map(encode)]
-        if (mutatingListMethods.has(method)) fail(node, `Rendered collection expressions cannot call mutating method "${method}"`)
-      }
-      fail(node, "Rendered collection expressions cannot call arbitrary functions")
-    }
-    if (ts.isArrowFunction(node) || ts.isFunctionExpression(node) || ts.isAwaitExpression(node) || ts.isNewExpression(node) || ts.isYieldExpression(node) || ts.isDeleteExpression(node) || ts.isPostfixUnaryExpression(node)) fail(node, "Rendered collection expressions must be pure and synchronous")
-    fail(node, "Rendered collection expression is not supported")
-  }
-  return encode(expression)
-}
-
 function jsonExpression(value, factory) {
   return factory.createCallExpression(factory.createPropertyAccessExpression(factory.createIdentifier("JSON"), "parse"), undefined, [factory.createStringLiteral(JSON.stringify(value))])
 }
@@ -4851,16 +2424,6 @@ function runtimeImportNames(sourceFile, relative) {
   return names
 }
 
-function referenceIdentifiers(root, name) {
-  const references = []
-  const visit = node => {
-    if (ts.isIdentifier(node) && node.text === name && isReferenceIdentifier(node) && !isShadowedIdentifier(node, root)) references.push(node)
-    ts.forEachChild(node, visit)
-  }
-  visit(root)
-  return references
-}
-
 function insideJsxEventHandler(node, root) {
   for (let current = node.parent; current && current !== root.parent; current = current.parent) {
     if (ts.isJsxAttribute(current) && /^on[A-Z]/.test(current.name.text)) return true
@@ -5385,564 +2948,126 @@ function isJsxSyntaxIdentifier(node) {
   const parent = node.parent
   return (ts.isJsxOpeningElement(parent) || ts.isJsxClosingElement(parent) || ts.isJsxSelfClosingElement(parent)) && parent.tagName === node || ts.isJsxAttribute(parent) && parent.name === node
 }
-
-function isFunctionLike(node) {
-  return ts.isFunctionDeclaration(node) || ts.isFunctionExpression(node) || ts.isArrowFunction(node) || ts.isMethodDeclaration(node) || ts.isGetAccessorDeclaration(node) || ts.isSetAccessorDeclaration(node) || ts.isConstructorDeclaration(node)
-}
-
-function isDestructuredParameter(identifier, fn) {
-  return fn?.parameters.some(parameter => ts.isObjectBindingPattern(parameter.name) && parameter.name.elements.some(element => ts.isIdentifier(element.name) && element.name.text === identifier.text)) ?? false
-}
-
-function isExportedDeclaration(node) {
-  const statement = ts.isVariableDeclaration(node) ? node.parent?.parent : node
-  return statement?.modifiers?.some(modifier => modifier.kind === ts.SyntaxKind.ExportKeyword || modifier.kind === ts.SyntaxKind.DefaultKeyword) ?? false
-}
-
-function jsxTagUses(root, name) {
-  const uses = []
-  const visit = node => {
-    const tag = ts.isJsxElement(node) ? node.openingElement.tagName : ts.isJsxSelfClosingElement(node) ? node.tagName : undefined
-    if (tag && ts.isIdentifier(tag) && tag.text === name) uses.push(node)
-    ts.forEachChild(node, visit)
-  }
-  visit(root)
-  return uses
-}
-
-const pureListMethods = new Set(["at", "charAt", "charCodeAt", "concat", "endsWith", "includes", "indexOf", "join", "lastIndexOf", "localeCompare", "padEnd", "padStart", "repeat", "replace", "replaceAll", "slice", "startsWith", "substring", "toLowerCase", "toUpperCase", "trim", "trimEnd", "trimStart"])
-const mutatingListMethods = new Set(["copyWithin", "fill", "pop", "push", "reverse", "shift", "sort", "splice", "unshift"])
-const pureMathMethods = new Set(["abs", "ceil", "floor", "max", "min", "pow", "round", "sign", "sqrt", "trunc"])
-const pureListGlobals = new Set(["Boolean", "Infinity", "Math", "NaN", "Number", "String", "undefined"])
-const assignmentOperators = new Set([
-  ts.SyntaxKind.EqualsToken, ts.SyntaxKind.PlusEqualsToken, ts.SyntaxKind.MinusEqualsToken,
-  ts.SyntaxKind.AsteriskEqualsToken, ts.SyntaxKind.AsteriskAsteriskEqualsToken, ts.SyntaxKind.SlashEqualsToken,
-  ts.SyntaxKind.PercentEqualsToken, ts.SyntaxKind.LessThanLessThanEqualsToken, ts.SyntaxKind.GreaterThanGreaterThanEqualsToken,
-  ts.SyntaxKind.GreaterThanGreaterThanGreaterThanEqualsToken, ts.SyntaxKind.AmpersandEqualsToken, ts.SyntaxKind.BarEqualsToken,
-  ts.SyntaxKind.CaretEqualsToken, ts.SyntaxKind.BarBarEqualsToken, ts.SyntaxKind.AmpersandAmpersandEqualsToken,
-  ts.SyntaxKind.QuestionQuestionEqualsToken
-])
-
-function validateListExpression(expression, item, source, fail, index, states = new Set()) {
-  const visit = node => {
-    if (ts.isTypeNode(node)) return
-    if (ts.isElementAccessExpression(node) && referencesIdentifier(node.expression, item)) {
-      const key = node.argumentExpression
-      if (!ts.isStringLiteral(key) && !ts.isNumericLiteral(key)) fail(source, "Derived keyed list item computed properties require a direct string or numeric literal key")
-      if (ts.isStringLiteral(key) && ["__proto__", "constructor", "prototype"].includes(key.text)) fail(source, `Derived keyed list item property "${key.text}" is not supported`)
-    }
-    if (ts.isPropertyAccessExpression(node) && ["__proto__", "constructor", "prototype"].includes(node.name.text) || ts.isElementAccessExpression(node) && ts.isStringLiteral(node.argumentExpression) && ["__proto__", "constructor", "prototype"].includes(node.argumentExpression.text)) {
-      fail(source, "Derived keyed list item expressions cannot read __proto__, prototype, or constructor")
-    }
-    if (ts.isBinaryExpression(node) && assignmentOperators.has(node.operatorToken.kind) || ts.isPostfixUnaryExpression(node) || ts.isPrefixUnaryExpression(node) && [ts.SyntaxKind.PlusPlusToken, ts.SyntaxKind.MinusMinusToken].includes(node.operator)) {
-      fail(source, "Derived keyed list item expressions must be pure; assignments and updates are not supported")
-    }
-    if (ts.isDeleteExpression(node) || ts.isAwaitExpression(node) || ts.isNewExpression(node) || ts.isYieldExpression(node)) {
-      fail(source, "Derived keyed list item expressions must be synchronous and side-effect free; delete, await, yield, and new are not supported")
-    }
-    if (ts.isArrowFunction(node) || ts.isFunctionExpression(node) || ts.isTaggedTemplateExpression(node)) {
-      fail(source, "Derived keyed list item expressions cannot create or invoke arbitrary functions")
-    }
-    if (ts.isCallExpression(node)) {
-      if (ts.isPropertyAccessExpression(node.expression)) {
-        const method = node.expression.name.text
-        if (mutatingListMethods.has(method)) fail(source, `Derived keyed list item expressions cannot call mutating method "${method}"`)
-        const receiver = node.expression.expression
-        const mathCall = ts.isIdentifier(receiver) && receiver.text === "Math" && pureMathMethods.has(method)
-        if (!mathCall && !pureListMethods.has(method)) fail(source, `Derived keyed list item expressions cannot call arbitrary method "${method}"`)
-      } else if (!ts.isIdentifier(node.expression) || !["Boolean", "Number", "String"].includes(node.expression.text)) {
-        fail(source, "Derived keyed list item expressions cannot call arbitrary functions")
-      }
-    }
-    if (ts.isIdentifier(node) && isReferenceIdentifier(node) && !isJsxSyntaxIdentifier(node) && node.text !== item && node.text !== index && !states.has(node.text) && !pureListGlobals.has(node.text)) {
-      fail(source, `Derived keyed list item expression identifier "${node.text}" is not allowed`)
-    }
-    ts.forEachChild(node, visit)
-  }
-  visit(expression)
-}
-
-function containsJsx(root) {
-  let found = false
-  const visit = node => {
-    if (ts.isJsxElement(node) || ts.isJsxSelfClosingElement(node) || ts.isJsxFragment(node)) found = true
-    if (!found) ts.forEachChild(node, visit)
-  }
-  visit(root)
-  return found
-}
-
-function compileListExpression(read, expression, item, factory, listExpressions, handlerUrl, index, states = new Set()) {
-  const exportName = `listExpression${listExpressions.length}`
-  listExpressions.push({ exportName, expression, item, index, states })
-  const arguments_ = [read, factory.createStringLiteral(handlerUrl), factory.createStringLiteral(exportName)]
-  if (states.size) arguments_.push(factory.createArrayLiteralExpression([...states].map(name => factory.createArrayLiteralExpression([factory.createStringLiteral(name), factory.createIdentifier(name)]))))
-  return factory.createCallExpression(factory.createIdentifier("__kListExpression"), undefined, arguments_)
-}
-
-function compileListConditional(entry, factory, listExpressions, handlerUrl) {
-  const exportName = `listExpression${listExpressions.length}`
-  listExpressions.push({ exportName, expression: entry.condition, item: entry.item, index: entry.index })
-  const read = factory.createArrowFunction(undefined, undefined, [], undefined, factory.createToken(ts.SyntaxKind.EqualsGreaterThanToken), entry.condition)
-  const thunk = branch => factory.createArrowFunction(undefined, undefined, [], undefined, factory.createToken(ts.SyntaxKind.EqualsGreaterThanToken), branch)
-  return factory.createCallExpression(factory.createIdentifier("__kListConditional"), undefined, [
-    factory.createStringLiteral(entry.kind), read, thunk(entry.truthy), thunk(entry.falsy), factory.createStringLiteral(handlerUrl), factory.createStringLiteral(exportName)
-  ])
-}
-
-function compileListValue(expression, entry, factory, context, listExpressions, handlerUrl) {
-  const rewrite = node => {
-    if (ts.isShorthandPropertyAssignment(node) && entry.states?.has(node.name.text)) return factory.createPropertyAssignment(node.name, factory.createPropertyAccessExpression(node.name, "value"))
-    if (ts.isIdentifier(node) && entry.states?.has(node.text) && isReferenceIdentifier(node)) return factory.createPropertyAccessExpression(node, "value")
-    return ts.visitEachChild(node, rewrite, context)
-  }
-  const initial = entry.states?.size ? ts.visitNode(expression, rewrite) : expression
-  const read = factory.createArrowFunction(undefined, undefined, [], undefined, factory.createToken(ts.SyntaxKind.EqualsGreaterThanToken), initial)
-  return entry.field
-    ? factory.createCallExpression(factory.createIdentifier("__kListField"), undefined, [read, factory.createStringLiteral(entry.field)])
-    : compileListExpression(read, expression, entry.item, factory, listExpressions, handlerUrl, entry.index, entry.states)
-}
-
-function directProperty(expression, objectName) {
-  const value = unwrapExpression(expression)
-  if (!ts.isPropertyAccessExpression(value) || !ts.isIdentifier(value.expression)) return undefined
-  if (objectName !== undefined && value.expression.text !== objectName) return undefined
-  return value.name.text
-}
-
-function keyedListParentTag(node) {
-  for (let current = node.parent; current; current = current.parent) {
-    if (ts.isJsxElement(current)) return current.openingElement.tagName.getText().toLowerCase()
-  }
-  return undefined
-}
-
-function referencesIdentifier(root, name) {
-  let found = false
-  const visit = node => {
-    if (ts.isIdentifier(node) && node.text === name && isReferenceIdentifier(node)) found = true
-    if (!found) ts.forEachChild(node, visit)
-  }
-  visit(root)
-  return found
-}
-
-function identifierReferenceCount(root, name) {
-  return identifierReferences(root, name).length
-}
-
-function identifierReferences(root, name) {
-  const references = []
-  const visit = node => {
-    if (ts.isIdentifier(node) && node.text === name && isReferenceIdentifier(node) && !ts.isJsxClosingElement(node.parent)) references.push(node)
-    ts.forEachChild(node, visit)
-  }
-  visit(root)
-  return references
-}
-
-function unwrapExpression(node) {
-  return ts.isParenthesizedExpression(node) || ts.isAsExpression(node) || ts.isTypeAssertionExpression(node) || ts.isNonNullExpression(node) || ts.isSatisfiesExpression(node) ? unwrapExpression(node.expression) : node
-}
-
-function isLocalConst(node) {
-  const list = node.parent
-  const statement = list?.parent
-  return ts.isVariableDeclarationList(list) && (list.flags & ts.NodeFlags.Const) !== 0 && ts.isVariableStatement(statement)
-}
-
-function isJsxLocalValue(expression, known) {
-  const value = unwrapExpression(expression)
-  if (ts.isJsxElement(value) || ts.isJsxSelfClosingElement(value) || ts.isJsxFragment(value)) return true
-  if (ts.isIdentifier(value)) return known.has(value.text)
-  const parts = conditionalParts(value)
-  return Boolean(parts && (isJsxLocalValue(parts.truthy, known) || isJsxLocalValue(parts.falsy, known)))
-}
-
-function compileReactiveBinding(expression, setters, factory, context, reactiveBindings, handlerUrl, importBindings = new Map(), clientImports = new Set()) {
-  const parts = conditionalParts(expression)
-  const state = parts && directStateIdentifier(parts.condition, setters)
-  if (state && isPrimitiveDefaultLiteral(parts.truthy) && isPrimitiveDefaultLiteral(parts.falsy)) {
-    return factory.createCallExpression(factory.createIdentifier("__kSelect"), undefined, [state, parts.truthy, parts.falsy])
-  }
-  return factory.createCallExpression(factory.createIdentifier("__kBinding"), undefined, compileReactiveExpression(expression, setters, factory, context, reactiveBindings, handlerUrl, importBindings, clientImports))
-}
-
-function compileConditional(kind, expression, truthy, falsy, setters, factory, context, reactiveBindings, handlerUrl) {
-  const state = directStateIdentifier(expression, setters)
-  const thunk = branch => factory.createArrowFunction(undefined, undefined, [], undefined, factory.createToken(ts.SyntaxKind.EqualsGreaterThanToken), branch)
-  if (state) return factory.createCallExpression(factory.createIdentifier("__kStateConditional"), undefined, [factory.createStringLiteral(kind), state, thunk(truthy), thunk(falsy)])
-  const [initial, ...descriptor] = compileReactiveExpression(expression, setters, factory, context, reactiveBindings, handlerUrl)
-  return factory.createCallExpression(factory.createIdentifier("__kConditional"), undefined, [factory.createStringLiteral(kind), initial, thunk(truthy), thunk(falsy), ...descriptor])
-}
-
-function directStateIdentifier(expression, setters) {
-  const value = unwrapExpression(expression)
-  return ts.isIdentifier(value) && new Set(setters.values()).has(value.text) ? value : undefined
-}
-
-function compileReactiveExpression(expression, setters, factory, context, reactiveBindings, handlerUrl, importBindings = new Map(), clientImports = new Set()) {
-  const usedStates = referencedStateNames(expression, setters)
-  const importedNames = referencedImportedBindings(expression, importBindings)
-  const imports = [...importedNames].map(name => importBindings.get(name))
-  for (const entry of imports) if (!entry.package) clientImports.add(entry.target)
-  const captures = new Set([...captureNames(expression, expression, setters)].filter(name => !importedNames.has(name)))
-  const exportName = `binding${reactiveBindings.length}`
-  reactiveBindings.push({ exportName, expression, captures, states: usedStates, imports })
-  const states = [...usedStates].map(name => factory.createArrayLiteralExpression([
-    factory.createStringLiteral(name),
-    factory.createIdentifier(name)
-  ]))
-  const scope = [...captures].map(name => factory.createArrayLiteralExpression([
-    factory.createStringLiteral(name),
-    factory.createIdentifier(name)
-  ]))
-  const stateNames = new Set(usedStates)
-  const rewriteInitial = node => {
-    if (ts.isShorthandPropertyAssignment(node) && stateNames.has(node.name.text)) {
-      return factory.createPropertyAssignment(node.name, factory.createPropertyAccessExpression(node.name, "value"))
-    }
-    if (ts.isIdentifier(node) && stateNames.has(node.text) && isReferenceIdentifier(node) && !isShadowedByParameter(node, expression)) {
-      return factory.createPropertyAccessExpression(node, "value")
-    }
-    if (ts.isShorthandPropertyAssignment(node) && captures.has(node.name.text)) {
-      return factory.createPropertyAssignment(node.name, factory.createCallExpression(factory.createIdentifier("__kBindingValue"), undefined, [node.name]))
-    }
-    if (ts.isIdentifier(node) && captures.has(node.text) && isReferenceIdentifier(node)) {
-      return factory.createCallExpression(factory.createIdentifier("__kBindingValue"), undefined, [node])
-    }
-    return ts.visitEachChild(node, rewriteInitial, context)
-  }
-  return [
-    ts.visitNode(expression, rewriteInitial),
-    factory.createStringLiteral(handlerUrl),
-    factory.createStringLiteral(exportName),
-    factory.createArrayLiteralExpression(states),
-    factory.createArrayLiteralExpression(scope)
-  ]
-}
-
-function conditionalParts(expression) {
-  const unwrap = node => ts.isParenthesizedExpression(node) ? unwrap(node.expression) : node
-  const value = unwrap(expression)
-  if (ts.isBinaryExpression(value) && value.operatorToken.kind === ts.SyntaxKind.AmpersandAmpersandToken) {
-    return { kind: "and", condition: value.left, truthy: unwrap(value.right), falsy: factoryNull() }
-  }
-  if (ts.isConditionalExpression(value)) {
-    return { kind: "ternary", condition: value.condition, truthy: unwrap(value.whenTrue), falsy: unwrap(value.whenFalse) }
-  }
-  return undefined
-}
-
-function factoryNull() {
-  return ts.factory.createNull()
-}
-
-function compileEvent(expression, setters, reducers, functions, factory, nativeHandlers, handlerUrl, listItem, importBindings, clientImports) {
-  if (ts.isIdentifier(expression)) expression = functions.get(expression.text)
-  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, factory)
-  if (optimized) return optimized
-
-  rejectWorkerConstructions(expression, expression.getSourceFile(), "Relative TypeScript Worker construction is only supported directly inside an inline useEffect() callback")
-  const descriptor = compileNativeCallback(expression, setters, reducers, factory, nativeHandlers, importBindings, clientImports, "handler", listItem)
-  return factory.createCallExpression(factory.createIdentifier("__kNativeBehavior"), undefined, [
-    factory.createStringLiteral(handlerUrl),
-    factory.createStringLiteral(descriptor.exportName),
-    descriptor.states,
-    descriptor.scope
-  ])
-}
-
-function compileNativeCallback(expression, setters, reducers, factory, entries, importBindings, clientImports, prefix, listItem, deferValues = false, snapshotNested = false, liveStates = new Set()) {
-  const allCaptures = nativeCaptureNames(expression, setters)
-  const usedReducers = referencedReducerDispatches(expression.body, reducers, expression)
-  const imports = [...referencedImportedBindings(expression, importBindings)].map(name => importBindings.get(name))
-  imports.push(...[...usedReducers].map(name => reducers.get(name).import).filter(Boolean))
-  const captures = new Set([...allCaptures].filter(name => !importBindings.has(name) && !usedReducers.has(name)))
-  for (const entry of imports) if (!entry.package) clientImports.add(entry.target)
-  const usedStates = nativeStateNames(expression, setters)
-  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)) usedStates.add(state)
-  }
-  const exportName = `${prefix}${entries.length}`
-  entries.push({ exportName, expression, captures, imports, liveStates, setters: new Map([...setters].filter(([, state]) => usedStates.has(state))), reducers: new Map([...reducers].filter(([name]) => usedReducers.has(name))), snapshotNested })
-  const value = name => deferValues
-    ? factory.createArrowFunction(undefined, undefined, [], undefined, factory.createToken(ts.SyntaxKind.EqualsGreaterThanToken), factory.createIdentifier(name))
-    : factory.createIdentifier(name)
-  return {
-    exportName,
-    states: factory.createArrayLiteralExpression([...usedStates].map(name => factory.createArrayLiteralExpression([
-      factory.createStringLiteral(name),
-      value(name)
-    ]))),
-    scope: factory.createArrayLiteralExpression([...captures].map(name => factory.createArrayLiteralExpression([
-      factory.createStringLiteral(name),
-      name === (typeof listItem === "string" ? listItem : listItem?.item)
-        ? factory.createCallExpression(factory.createIdentifier("__kListItem"), undefined, [])
-        : name === listItem?.index
-          ? factory.createCallExpression(factory.createIdentifier("__kListIndex"), undefined, [])
-          : value(name)
-    ])))
-  }
-}
-
-function referencedReducerDispatches(root, reducers, scopeRoot = root) {
-  const used = new Set()
-  const visit = node => {
-    if (ts.isIdentifier(node) && reducers.has(node.text) && isReferenceIdentifier(node) && !isShadowedIdentifier(node, scopeRoot)) used.add(node.text)
-    ts.forEachChild(node, visit)
-  }
-  visit(root)
-  return used
-}
-
-function nativeStateNames(expression, setters) {
-  return referencedStateNames(expression.body, setters, expression)
-}
-
-function referencedStateNames(root, setters, scopeRoot = root) {
-  const stateNames = new Set(setters.values())
-  const used = new Set()
-  const visit = node => {
-    if (ts.isCallExpression(node) && ts.isIdentifier(node.expression) && setters.has(node.expression.text) && !isShadowedIdentifier(node.expression, scopeRoot)) used.add(setters.get(node.expression.text))
-    if (ts.isIdentifier(node) && setters.has(node.text) && isReferenceIdentifier(node) && !isShadowedIdentifier(node, scopeRoot)) used.add(setters.get(node.text))
-    if (ts.isIdentifier(node) && stateNames.has(node.text) && isReferenceIdentifier(node) && !isShadowedByParameter(node, scopeRoot)) used.add(node.text)
-    ts.forEachChild(node, visit)
-  }
-  visit(root)
-  return used
-}
-
-function compileOptimizedEvent(expression, setters, factory) {
-  const statements = ts.isBlock(expression.body) ? expression.body.statements : [factory.createExpressionStatement(expression.body)]
-  const commands = statements.map(statement => {
-    if (!ts.isExpressionStatement(statement)) return undefined
-    return compileEventCommand(statement.expression, setters, factory)
-  })
-  if (!commands.length || commands.some(command => !command)) return undefined
-
-  return factory.createCallExpression(factory.createIdentifier("__kBehavior"), undefined, [factory.createArrayLiteralExpression(commands)])
-}
-
-const nativeGlobals = new Set([
-  "Array", "ArrayBuffer", "BigInt", "Blob", "Boolean", "Date", "Error", "Event", "FileReader", "FormData", "Infinity", "IntersectionObserver", "Intl", "JSON", "Map", "Math", "NaN", "Number", "Object", "Promise", "Proxy", "RangeError", "ReferenceError", "Reflect", "RegExp", "Set", "String", "Symbol", "TypeError", "URL", "URLSearchParams", "WeakMap", "WeakSet", "WebSocket", "Worker", "alert", "atob", "btoa", "cancelAnimationFrame", "clearInterval", "clearTimeout", "console", "crypto", "document", "fetch", "globalThis", "history", "isFinite", "isNaN", "localStorage", "location", "navigator", "parseFloat", "parseInt", "performance", "queueMicrotask", "requestAnimationFrame", "setInterval", "setTimeout", "structuredClone", "undefined", "window"
-])
-
-function rewriteEffectWorkers(callback, file, sourceFile, sourceFiles, workerReferences, factory, context) {
-  const visit = node => {
-    const candidate = relativeWorkerCandidate(node, sourceFile)
-    if (candidate) {
-      if (nearestFunction(node) !== callback) throw sourceNodeError(node, sourceFile, "Relative TypeScript Worker construction must be directly inside the inline useEffect() callback, not a nested function")
-      const { worker, url, specifier, options } = validateWorkerCandidate(candidate, sourceFile)
-      const target = resolve(dirname(file), specifier)
-      const sourceRelative = relative(sourceDirectory, target)
-      if (sourceRelative.startsWith(`..${sep}`) || sourceRelative === ".." || resolve(sourceDirectory, sourceRelative) !== target) throw sourceNodeError(url.arguments[0], sourceFile, "Relative TypeScript Worker source must remain under src/")
-      if (!sourceFiles.has(target)) throw sourceNodeError(url.arguments[0], sourceFile, `Relative TypeScript Worker ${JSON.stringify(specifier)} must resolve to an existing .worker.ts file under src/`)
-      const identity = `${sourceRelative.replaceAll(sep, "/")}:${ts.getOriginalNode(node).getStart(sourceFile)}`
-      const placeholder = `/__kudzu_worker_${createHash("sha256").update(identity).digest("hex").slice(0, 16)}__.js`
-      workerReferences.push({ root: target, placeholder })
-      return factory.updateNewExpression(worker, worker.expression, worker.typeArguments, [factory.createStringLiteral(placeholder), options])
-    }
-    return ts.visitEachChild(node, visit, context)
-  }
-  return ts.visitEachChild(callback, visit, context)
-}
-
-function rejectWorkerConstructions(expression, sourceFile, message) {
-  const visit = node => {
-    if (relativeWorkerCandidate(node, sourceFile)) throw sourceNodeError(node, sourceFile, message)
-    ts.forEachChild(node, visit)
-  }
-  visit(expression.body ?? expression)
-}
-
-function relativeWorkerCandidate(node, sourceFile) {
-  if (!ts.isNewExpression(node) || !ts.isIdentifier(node.expression) || node.expression.text !== "Worker") return undefined
-  const first = node.arguments?.[0]
-  if (!first || !ts.isNewExpression(first) || !ts.isIdentifier(first.expression) || first.expression.text !== "URL") return undefined
-  const specifier = first.arguments?.[0]
-  const base = first.arguments?.[1]
-  const relativeLiteral = ts.isStringLiteral(specifier) && (specifier.text.startsWith("./") || specifier.text.startsWith("../"))
-  if (!relativeLiteral && !(specifier && !ts.isStringLiteral(specifier) && base && isImportMetaUrl(base))) return undefined
-  return { worker: node, url: first, sourceFile }
-}
-
-function validateWorkerCandidate(candidate, sourceFile) {
-  const { worker, url } = candidate
-  if (!isUnshadowedGlobal(worker.expression, sourceFile)) throw sourceNodeError(worker.expression, sourceFile, "Relative TypeScript Workers require the unshadowed global Worker constructor")
-  if (!isUnshadowedGlobal(url.expression, sourceFile)) throw sourceNodeError(url.expression, sourceFile, "Relative TypeScript Workers require the unshadowed global URL constructor")
-  if (url.arguments?.length !== 2 || !isImportMetaUrl(url.arguments[1])) throw sourceNodeError(url, sourceFile, "Relative TypeScript Workers require new URL(relativeLiteral, import.meta.url)")
-  const specifierNode = url.arguments[0]
-  if (!ts.isStringLiteral(specifierNode) || !(specifierNode.text.startsWith("./") || specifierNode.text.startsWith("../"))) throw sourceNodeError(specifierNode, sourceFile, "Relative TypeScript Worker paths must be relative string literals")
-  if (/[\\?#]/.test(specifierNode.text) || !specifierNode.text.endsWith(".worker.ts")) throw sourceNodeError(specifierNode, sourceFile, "Relative TypeScript Worker paths must end in .worker.ts")
-  if (worker.arguments?.length !== 2) throw sourceNodeError(worker, sourceFile, 'Relative TypeScript Workers require exactly { type: "module" } as the second argument')
-  const options = worker.arguments[1]
-  if (!ts.isObjectLiteralExpression(options) || options.properties.length !== 1) throw sourceNodeError(options, sourceFile, 'Relative TypeScript Workers require exactly { type: "module" } as the second argument')
-  const property = options.properties[0]
-  const name = ts.isPropertyAssignment(property) && !ts.isComputedPropertyName(property.name) && (ts.isIdentifier(property.name) || ts.isStringLiteral(property.name)) ? property.name.text : undefined
-  if (name !== "type" || !ts.isStringLiteral(property.initializer) || property.initializer.text !== "module") throw sourceNodeError(property, sourceFile, 'Relative TypeScript Workers require exactly { type: "module" } as the second argument')
-  return { worker, url, specifier: specifierNode.text, options }
-}
-
-function isImportMetaUrl(node) {
-  return ts.isPropertyAccessExpression(node) && node.name.text === "url" && ts.isMetaProperty(node.expression) && node.expression.keywordToken === ts.SyntaxKind.ImportKeyword && node.expression.name.text === "meta"
-}
-
-function isUnshadowedGlobal(identifier, sourceFile) {
-  if (isShadowedIdentifier(identifier, sourceFile)) return false
-  return !sourceFile.statements.some(statement => {
-    if (statementDeclaresName(statement, identifier.text)) return true
-    if (!ts.isImportDeclaration(statement) || !statement.importClause) return false
-    const clause = statement.importClause
-    if (clause.name?.text === identifier.text) return true
-    if (clause.namedBindings && ts.isNamespaceImport(clause.namedBindings)) return clause.namedBindings.name.text === identifier.text
-    return clause.namedBindings && ts.isNamedImports(clause.namedBindings) ? clause.namedBindings.elements.some(entry => entry.name.text === identifier.text) : false
-  })
+
+function isDestructuredParameter(identifier, fn) {
+  return fn?.parameters.some(parameter => ts.isObjectBindingPattern(parameter.name) && parameter.name.elements.some(element => ts.isIdentifier(element.name) && element.name.text === identifier.text)) ?? false
 }
 
-function nativeCaptureNames(expression, setters) {
-  return captureNames(expression, expression.body, setters)
+function isExportedDeclaration(node) {
+  const statement = ts.isVariableDeclaration(node) ? node.parent?.parent : node
+  return statement?.modifiers?.some(modifier => modifier.kind === ts.SyntaxKind.ExportKeyword || modifier.kind === ts.SyntaxKind.DefaultKeyword) ?? false
 }
 
-function referencedImportedBindings(expression, imports) {
-  const names = new Set()
+function jsxTagUses(root, name) {
+  const uses = []
   const visit = node => {
-    if (ts.isIdentifier(node) && imports.has(node.text) && isReferenceIdentifier(node)) names.add(node.text)
+    const tag = ts.isJsxElement(node) ? node.openingElement.tagName : ts.isJsxSelfClosingElement(node) ? node.tagName : undefined
+    if (tag && ts.isIdentifier(tag) && tag.text === name) uses.push(node)
     ts.forEachChild(node, visit)
   }
-  visit(expression.body ?? expression)
-  return names
+  visit(root)
+  return uses
 }
 
-function captureNames(declarationRoot, referenceRoot, setters) {
-  const local = new Set()
-  if (!isFunctionLike(declarationRoot)) {
-    const collectDeclarations = node => {
-      if (ts.isVariableDeclaration(node)) for (const name of bindingNames(node.name)) local.add(name)
-      if (ts.isParameter(node)) for (const name of bindingNames(node.name)) local.add(name)
-      if ((ts.isFunctionDeclaration(node) || ts.isClassDeclaration(node)) && node.name) local.add(node.name.text)
-      ts.forEachChild(node, collectDeclarations)
-    }
-    collectDeclarations(declarationRoot)
-  }
-  const stateNames = new Set(setters.values())
-  const captures = new Set()
+const pureListGlobals = new Set(["Boolean", "Infinity", "Math", "NaN", "Number", "String", "undefined"])
+const assignmentOperators = new Set([
+  ts.SyntaxKind.EqualsToken, ts.SyntaxKind.PlusEqualsToken, ts.SyntaxKind.MinusEqualsToken,
+  ts.SyntaxKind.AsteriskEqualsToken, ts.SyntaxKind.AsteriskAsteriskEqualsToken, ts.SyntaxKind.SlashEqualsToken,
+  ts.SyntaxKind.PercentEqualsToken, ts.SyntaxKind.LessThanLessThanEqualsToken, ts.SyntaxKind.GreaterThanGreaterThanEqualsToken,
+  ts.SyntaxKind.GreaterThanGreaterThanGreaterThanEqualsToken, ts.SyntaxKind.AmpersandEqualsToken, ts.SyntaxKind.BarEqualsToken,
+  ts.SyntaxKind.CaretEqualsToken, ts.SyntaxKind.BarBarEqualsToken, ts.SyntaxKind.AmpersandAmpersandEqualsToken,
+  ts.SyntaxKind.QuestionQuestionEqualsToken
+])
+
+function validateListExpression(expression, item, source, fail, index, states = new Set()) {
   const visit = node => {
     if (ts.isTypeNode(node)) return
-    if (ts.isIdentifier(node)) {
-      const declared = isFunctionLike(declarationRoot) ? isShadowedIdentifier(node, declarationRoot) : local.has(node.text)
-      if (isReferenceIdentifier(node) && !declared && !setters.has(node.text) && !stateNames.has(node.text) && !nativeGlobals.has(node.text)) captures.add(node.text)
+    if (ts.isElementAccessExpression(node) && referencesIdentifier(node.expression, item)) {
+      const key = node.argumentExpression
+      if (!ts.isStringLiteral(key) && !ts.isNumericLiteral(key)) fail(source, "Derived keyed list item computed properties require a direct string or numeric literal key")
+      if (ts.isStringLiteral(key) && ["__proto__", "constructor", "prototype"].includes(key.text)) fail(source, `Derived keyed list item property "${key.text}" is not supported`)
+    }
+    if (ts.isPropertyAccessExpression(node) && ["__proto__", "constructor", "prototype"].includes(node.name.text) || ts.isElementAccessExpression(node) && ts.isStringLiteral(node.argumentExpression) && ["__proto__", "constructor", "prototype"].includes(node.argumentExpression.text)) {
+      fail(source, "Derived keyed list item expressions cannot read __proto__, prototype, or constructor")
+    }
+    if (ts.isBinaryExpression(node) && assignmentOperators.has(node.operatorToken.kind) || ts.isPostfixUnaryExpression(node) || ts.isPrefixUnaryExpression(node) && [ts.SyntaxKind.PlusPlusToken, ts.SyntaxKind.MinusMinusToken].includes(node.operator)) {
+      fail(source, "Derived keyed list item expressions must be pure; assignments and updates are not supported")
+    }
+    if (ts.isDeleteExpression(node) || ts.isAwaitExpression(node) || ts.isNewExpression(node) || ts.isYieldExpression(node)) {
+      fail(source, "Derived keyed list item expressions must be synchronous and side-effect free; delete, await, yield, and new are not supported")
+    }
+    if (ts.isArrowFunction(node) || ts.isFunctionExpression(node) || ts.isTaggedTemplateExpression(node)) {
+      fail(source, "Derived keyed list item expressions cannot create or invoke arbitrary functions")
+    }
+    if (ts.isCallExpression(node)) {
+      if (ts.isPropertyAccessExpression(node.expression)) {
+        const method = node.expression.name.text
+        if (mutatingListMethods.has(method)) fail(source, `Derived keyed list item expressions cannot call mutating method "${method}"`)
+        const receiver = node.expression.expression
+        const mathCall = ts.isIdentifier(receiver) && receiver.text === "Math" && pureMathMethods.has(method)
+        if (!mathCall && !pureListMethods.has(method)) fail(source, `Derived keyed list item expressions cannot call arbitrary method "${method}"`)
+      } else if (!ts.isIdentifier(node.expression) || !["Boolean", "Number", "String"].includes(node.expression.text)) {
+        fail(source, "Derived keyed list item expressions cannot call arbitrary functions")
+      }
+    }
+    if (ts.isIdentifier(node) && isReferenceIdentifier(node) && !isJsxSyntaxIdentifier(node) && node.text !== item && node.text !== index && !states.has(node.text) && !pureListGlobals.has(node.text)) {
+      fail(source, `Derived keyed list item expression identifier "${node.text}" is not allowed`)
     }
     ts.forEachChild(node, visit)
   }
-  visit(referenceRoot)
-  return captures
+  visit(expression)
 }
 
-function bindingNames(name) {
-  if (ts.isIdentifier(name)) return [name.text]
-  return name.elements.flatMap(element => ts.isBindingElement(element) ? bindingNames(element.name) : [])
+function directProperty(expression, objectName) {
+  const value = unwrapExpression(expression)
+  if (!ts.isPropertyAccessExpression(value) || !ts.isIdentifier(value.expression)) return undefined
+  if (objectName !== undefined && value.expression.text !== objectName) return undefined
+  return value.name.text
 }
 
-function isReferenceIdentifier(node) {
-  const parent = node.parent
-  if (!parent) return true
-  if ((ts.isPropertyAccessExpression(parent) && parent.name === node) ||
-      (ts.isPropertyAssignment(parent) && parent.name === node) ||
-      (ts.isMethodDeclaration(parent) && parent.name === node) ||
-      ((ts.isGetAccessorDeclaration(parent) || ts.isSetAccessorDeclaration(parent)) && parent.name === node) ||
-      (ts.isVariableDeclaration(parent) && parent.name === node) ||
-      (ts.isParameter(parent) && parent.name === node) ||
-      (ts.isFunctionDeclaration(parent) && parent.name === node) ||
-      (ts.isJsxAttribute(parent) && parent.name === node) ||
-      (ts.isBindingElement(parent) && (parent.name === node || parent.propertyName === node)) ||
-      ts.isImportSpecifier(parent) || ts.isImportClause(parent)) return false
-  return true
-}
-
-function nearestFunction(node) {
+function keyedListParentTag(node) {
   for (let current = node.parent; current; current = current.parent) {
-    if (ts.isFunctionDeclaration(current) || ts.isFunctionExpression(current) || ts.isArrowFunction(current)) return current
+    if (ts.isJsxElement(current)) return current.openingElement.tagName.getText().toLowerCase()
   }
   return undefined
 }
 
-function nearestFunctionLike(node) {
-  for (let current = node.parent; current; current = current.parent) if (isFunctionLike(current)) return current
-  return undefined
-}
-
-function isShadowedByParameter(node, scopeRoot) {
-  for (let current = node.parent; current; current = current.parent) {
-    if (isFunctionLike(current) && current.parameters.some(parameter => bindingNames(parameter.name).includes(node.text))) return true
-    if (current === scopeRoot) break
-  }
-  return false
+function identifierReferenceCount(root, name) {
+  return identifierReferences(root, name).length
 }
 
-function isShadowedIdentifier(node, scopeRoot) {
-  if (isShadowedByParameter(node, scopeRoot)) return true
-  if (node === scopeRoot) return false
-  if (isFunctionLike(scopeRoot) && scopeRoot.name?.text === node.text) return true
-  if (isFunctionLike(scopeRoot) && functionVarDeclaresName(scopeRoot, node.text)) return true
-  for (let current = node.parent; current; current = current.parent) {
-    if (current === scopeRoot) break
-    if (ts.isFunctionExpression(current) && current.name?.text === node.text) return true
-    if (ts.isBlock(current) && current.statements.some(statement => statementDeclaresName(statement, node.text))) return true
-    if (ts.isCaseBlock(current) && current.clauses.some(clause => clause.statements.some(statement => statementDeclaresName(statement, node.text)))) return true
-    if (ts.isCatchClause(current) && current.variableDeclaration && bindingNames(current.variableDeclaration.name).includes(node.text)) return true
-    if ((ts.isForStatement(current) || ts.isForInStatement(current) || ts.isForOfStatement(current)) && loopDeclaresName(current, node.text)) return true
-    if (isFunctionLike(current) && functionVarDeclaresName(current, node.text)) return true
+function identifierReferences(root, name) {
+  const references = []
+  const visit = node => {
+    if (ts.isIdentifier(node) && node.text === name && isReferenceIdentifier(node) && !ts.isJsxClosingElement(node.parent)) references.push(node)
+    ts.forEachChild(node, visit)
   }
-  return false
+  visit(root)
+  return references
 }
 
-function statementDeclaresName(statement, name) {
-  if (ts.isVariableStatement(statement)) return statement.declarationList.declarations.some(declaration => bindingNames(declaration.name).includes(name))
-  if (ts.isFunctionDeclaration(statement) || ts.isClassDeclaration(statement) || ts.isImportEqualsDeclaration(statement)) return statement.name?.text === name
-  if ((ts.isEnumDeclaration(statement) || ts.isModuleDeclaration(statement)) && !statement.modifiers?.some(modifier => modifier.kind === ts.SyntaxKind.DeclareKeyword)) return ts.isIdentifier(statement.name) && statement.name.text === name
-  return false
+function isJsxLocalValue(expression, known) {
+  const value = unwrapExpression(expression)
+  if (ts.isJsxElement(value) || ts.isJsxSelfClosingElement(value) || ts.isJsxFragment(value)) return true
+  if (ts.isIdentifier(value)) return known.has(value.text)
+  const parts = conditionalParts(value)
+  return Boolean(parts && (isJsxLocalValue(parts.truthy, known) || isJsxLocalValue(parts.falsy, known)))
 }
 
-function rejectOrdinaryWorkerImports(sourceFile, file, sourceFiles) {
-  for (const node of sourceFile.statements) {
-    let specifier
-    let runtime = false
-    if ((ts.isImportDeclaration(node) || ts.isExportDeclaration(node)) && node.moduleSpecifier && ts.isStringLiteral(node.moduleSpecifier)) {
-      specifier = node.moduleSpecifier
-      runtime = runtimeModuleReference(node)
-    } else if (ts.isImportEqualsDeclaration(node) && ts.isExternalModuleReference(node.moduleReference) && ts.isStringLiteral(node.moduleReference.expression)) {
-      specifier = node.moduleReference.expression
-      runtime = !node.isTypeOnly
-    }
-    if (!runtime || !specifier?.text.startsWith(".")) continue
-    let target
-    try {
-      target = resolveSourceImport(file, specifier.text, sourceFiles)
-    } catch {
-      continue
-    }
-    if (target.endsWith(".worker.ts")) throw sourceNodeError(specifier, sourceFile, "Worker source modules cannot be imported or re-exported as ordinary runtime modules; use new Worker(new URL(relative.worker.ts, import.meta.url), { type: \"module\" }) inside an inline useEffect() callback")
+function conditionalParts(expression) {
+  const unwrap = node => ts.isParenthesizedExpression(node) ? unwrap(node.expression) : node
+  const value = unwrap(expression)
+  if (ts.isBinaryExpression(value) && value.operatorToken.kind === ts.SyntaxKind.AmpersandAmpersandToken) {
+    return { kind: "and", condition: value.left, truthy: unwrap(value.right), falsy: factoryNull() }
   }
+  if (ts.isConditionalExpression(value)) {
+    return { kind: "ternary", condition: value.condition, truthy: unwrap(value.whenTrue), falsy: unwrap(value.whenFalse) }
+  }
+  return undefined
 }
 
-function loopDeclaresName(loop, name) {
-  const declaration = ts.isForStatement(loop) ? loop.initializer : loop.initializer
-  return declaration && ts.isVariableDeclarationList(declaration) && declaration.declarations.some(entry => bindingNames(entry.name).includes(name))
-}
-
-function functionVarDeclaresName(fn, name) {
-  let found = false
-  const visit = node => {
-    if (found || node !== fn.body && isFunctionLike(node)) return
-    if (ts.isVariableDeclarationList(node) && (node.flags & ts.NodeFlags.BlockScoped) === 0 && node.declarations.some(entry => bindingNames(entry.name).includes(name))) found = true
-    if (!found) ts.forEachChild(node, visit)
-  }
-  if (fn.body) visit(fn.body)
-  return found
+function factoryNull() {
+  return ts.factory.createNull()
 }
 
 function settersForNode(node, settersByFunction) {
@@ -6097,40 +3222,6 @@ function localComponentDeclaration(sourceFile, name) {
   return undefined
 }
 
-function sourceNodeError(node, fallbackSource, message) {
-  const original = ts.getOriginalNode(node)
-  const sourceFile = original.getSourceFile?.()?.fileName ? original.getSourceFile() : fallbackSource
-  const position = sourceFile.getLineAndCharacterOfPosition(original.getStart(sourceFile))
-  return new Error(`${sourceFile.fileName}:${position.line + 1}:${position.character + 1} ${message}`)
-}
-
-function sourceLocation(node, fallbackSource) {
-  const original = ts.getOriginalNode(node)
-  const sourceFile = original.getSourceFile?.()?.fileName ? original.getSourceFile() : fallbackSource
-  const position = sourceFile.getLineAndCharacterOfPosition(original.getStart(sourceFile))
-  return `${sourceFile.fileName}:${position.line + 1}:${position.character + 1}`
-}
-
-function effectReturns(callback) {
-  let cleanup = false
-  let invalid
-  const cleanups = []
-  const visit = node => {
-    if (invalid || node !== callback.body && isFunctionLike(node)) return
-    if (ts.isReturnStatement(node) && node.expression) {
-      const expression = unwrapExpression(node.expression)
-      if (ts.isArrowFunction(expression) || ts.isFunctionExpression(expression)) {
-        cleanup = true
-        cleanups.push(expression)
-      }
-      else invalid = node
-    }
-    if (!invalid) ts.forEachChild(node, visit)
-  }
-  visit(callback.body)
-  return { cleanup, cleanups, invalid }
-}
-
 function validateEffectOwnedBrowserResources(callback, returns, fail) {
   const observers = []
   const frameAssignments = []
@@ -6155,86 +3246,6 @@ function validateEffectOwnedBrowserResources(callback, returns, fail) {
   }
 }
 
-function printClientImports(entries, handlerPath) {
-  const unique = new Map(entries.map(entry => [`${entry.target}:${entry.kind}:${entry.imported ?? ""}:${entry.local}`, entry]))
-  const groups = Map.groupBy(unique.values(), entry => entry.target)
-  const imports = []
-  for (const [target, group] of groups) {
-    const specifier = group[0].package ? target : relativeModulePath(handlerPath, clientModulePath(target))
-    const defaults = group.filter(entry => entry.kind === "default")
-    const named = group.filter(entry => entry.kind === "named")
-    if (defaults.length === 1 || named.length) imports.push(`import ${defaults.length === 1 ? `${defaults[0].local}${named.length ? ", " : ""}` : ""}${named.length ? `{ ${named.map(entry => entry.imported === entry.local ? entry.local : `${entry.imported} as ${entry.local}`).join(", ")} }` : ""} from ${JSON.stringify(specifier)}`)
-    if (defaults.length > 1) for (const entry of defaults) imports.push(`import ${entry.local} from ${JSON.stringify(specifier)}`)
-    for (const entry of group.filter(entry => entry.kind === "namespace")) imports.push(`import * as ${entry.local} from ${JSON.stringify(specifier)}`)
-  }
-  return imports.join("\n")
-}
-
-async function emitWorkers(references, sourceFiles, assetsDirectory, base, minify) {
-  const roots = [...new Set(references.map(reference => reference.root))].sort()
-  if (!roots.length) return new Map()
-  await validateWorkerGraphs(roots, sourceFiles)
-  const workerDirectory = join(assetsDirectory, "workers")
-  await mkdir(workerDirectory, { recursive: true })
-  const result = await bundle({
-    absWorkingDir: root,
-    entryPoints: roots,
-    outbase: sourceDirectory,
-    outdir: workerDirectory,
-    entryNames: "[dir]/[name]-[hash]",
-    chunkNames: "chunks/[name]-[hash]",
-    bundle: true,
-    splitting: true,
-    format: "esm",
-    platform: "browser",
-    target: "es2022",
-    minify,
-    legalComments: "none",
-    metafile: true,
-    logLevel: "silent"
-  })
-  const emitted = new Map()
-  for (const [output, metadata] of Object.entries(result.metafile.outputs)) {
-    if (!metadata.entryPoint) continue
-    const entry = resolve(root, metadata.entryPoint)
-    const rootReferences = references.filter(reference => reference.root === entry)
-    const outputFile = resolve(root, output)
-    const url = assetPath(base, relative(outputDirectory, outputFile).replaceAll(sep, "/"))
-    for (const reference of rootReferences) emitted.set(reference.placeholder, url)
-  }
-  for (const reference of references) if (!emitted.has(reference.placeholder)) throw new Error(`Worker entry was not emitted: ${relative(root, reference.root)}`)
-  return emitted
-}
-
-async function validateWorkerGraphs(roots, sourceFiles) {
-  const visited = new Set()
-  const queue = [...roots]
-  while (queue.length) {
-    const file = queue.shift()
-    if (visited.has(file)) continue
-    visited.add(file)
-    const sourceFile = parseSourceFile(file, await readFile(file, "utf8"))
-    if (containsJsx(sourceFile)) throw sourceNodeError(sourceFile, sourceFile, "Worker modules must not contain JSX")
-    const visit = node => {
-      if (ts.isImportEqualsDeclaration(node)) throw sourceNodeError(node, sourceFile, "TypeScript import-equals declarations are not supported in Worker modules; use a relative ESM import")
-      if (ts.isCallExpression(node) && node.expression.kind === ts.SyntaxKind.ImportKeyword) throw sourceNodeError(node, sourceFile, "Dynamic imports are not supported in Worker modules")
-      if (ts.isCallExpression(node) && ts.isIdentifier(node.expression) && node.expression.text === "require") throw sourceNodeError(node, sourceFile, "require() is not supported in Worker modules")
-      ts.forEachChild(node, visit)
-    }
-    visit(sourceFile)
-    for (const node of sourceFile.statements) {
-      if ((!ts.isImportDeclaration(node) && !ts.isExportDeclaration(node)) || !node.moduleSpecifier || !ts.isStringLiteral(node.moduleSpecifier) || !runtimeModuleReference(node)) continue
-      if (!node.moduleSpecifier.text.startsWith(".")) throw sourceNodeError(node.moduleSpecifier, sourceFile, "Worker modules may only use relative runtime imports")
-      try {
-        queue.push(resolveSourceImport(file, node.moduleSpecifier.text, sourceFiles))
-      } catch (error) {
-        const message = error.message.slice(error.message.indexOf("Relative import"))
-        throw sourceNodeError(node.moduleSpecifier, sourceFile, message)
-      }
-    }
-  }
-}
-
 async function collectClientModules(entries, sourceFiles) {
   const modules = new Set()
   const queue = [...new Set(entries)]
@@ -6243,7 +3254,7 @@ async function collectClientModules(entries, sourceFiles) {
     if (modules.has(file)) continue
     const source = await readFile(file, "utf8")
     const sourceFile = parseSourceFile(file, source)
-    rejectWorkerConstructions(sourceFile, sourceFile, "Relative TypeScript Worker construction is only supported directly inside an inline useEffect() callback, not imported client helpers")
+    workerCompiler.rejectConstructions(sourceFile, sourceFile, "Relative TypeScript Worker construction is only supported directly inside an inline useEffect() callback, not imported client helpers")
     if (containsJsx(sourceFile)) throw new Error(`${relative(root, file)} Imported client helpers must not contain JSX`)
     rejectUnsupportedClientImports(sourceFile, file)
     modules.add(file)
@@ -6570,310 +3581,6 @@ function relativeModulePath(from, to) {
   return path.startsWith(".") ? path : `./${path}`
 }
 
-function printNativeHandler({ exportName, expression, captures, setters, reducers = new Map(), snapshotNested, liveStates = new Set() }) {
-  const factory = ts.factory
-  const stateNames = new Set(setters.values())
-  const snapshotNames = snapshotNested ? nestedStateNames(expression, setters, liveStates) : new Set()
-  const snapshots = new Map([...snapshotNames].map(name => [name, factory.createUniqueName("__kEffectState")]))
-  const captureSnapshotNames = snapshotNested ? nestedCaptureNames(expression, captures) : new Set()
-  const captureSnapshots = new Map([...captureSnapshotNames].map(name => [name, factory.createUniqueName("__kEffectCapture")]))
-  const transformer = context => root => {
-    const visitor = node => {
-      if (ts.isCallExpression(node) && ts.isIdentifier(node.expression) && reducers.has(node.expression.text) && !isShadowedIdentifier(node.expression, expression)) {
-        const reducer = reducers.get(node.expression.text)
-        if (reducer.contextAction) {
-          const action = synthesizeTree(cloneAst(reducer.contextAction, factory, context))
-          const call = factory.createCallExpression(action, undefined, node.arguments)
-          ts.setParentRecursive(call, false)
-          return ts.visitNode(call, visitor)
-        }
-        if (reducer.store) return zustandActionDispatch(factory, reducer, node.arguments.map(argument => ts.visitNode(argument, visitor)))
-        if (node.arguments.length !== 1) throw sourceNodeError(node, expression.getSourceFile(), "Reducer dispatches require exactly one action")
-        return reducerDispatch(factory, reducer, ts.visitNode(node.arguments[0], visitor))
-      }
-      if (ts.isShorthandPropertyAssignment(node) && reducers.has(node.name.text) && !isShadowedIdentifier(node.name, expression)) {
-        if (reducers.get(node.name.text).contextAction) throw sourceNodeError(node, expression.getSourceFile(), "Context actions must be called directly inside an event handler")
-        if (reducers.get(node.name.text).store) throw sourceNodeError(node, expression.getSourceFile(), "Zustand actions must be called directly inside an event handler")
-        return factory.createPropertyAssignment(node.name, reducerReference(factory, reducers.get(node.name.text)))
-      }
-      if (ts.isIdentifier(node) && reducers.has(node.text) && isReferenceIdentifier(node) && !isShadowedIdentifier(node, expression)) {
-        if (reducers.get(node.text).contextAction) throw sourceNodeError(node, expression.getSourceFile(), "Context actions must be called directly inside an event handler")
-        if (reducers.get(node.text).store) throw sourceNodeError(node, expression.getSourceFile(), "Zustand actions must be called directly inside an event handler")
-        return reducerReference(factory, reducers.get(node.text))
-      }
-      if (ts.isCallExpression(node) && ts.isIdentifier(node.expression) && setters.has(node.expression.text) && !isShadowedIdentifier(node.expression, expression)) {
-        return factory.createCallExpression(
-          factory.createPropertyAccessExpression(factory.createIdentifier("__k"), "set"),
-          undefined,
-          [factory.createStringLiteral(setters.get(node.expression.text)), ...node.arguments.map(argument => ts.visitNode(argument, visitor))]
-        )
-      }
-      if (ts.isShorthandPropertyAssignment(node) && setters.has(node.name.text) && !isShadowedIdentifier(node.name, expression)) {
-        return factory.createPropertyAssignment(node.name, setterReference(factory, setters.get(node.name.text)))
-      }
-      if (ts.isIdentifier(node) && setters.has(node.text) && isReferenceIdentifier(node) && !isShadowedIdentifier(node, expression)) {
-        return setterReference(factory, setters.get(node.text))
-      }
-      if (ts.isShorthandPropertyAssignment(node) && stateNames.has(node.name.text) && !isShadowedIdentifier(node.name, expression)) {
-        if (snapshots.has(node.name.text) && insideNestedFunction(node, expression)) return factory.createPropertyAssignment(node.name, snapshots.get(node.name.text))
-        return factory.createPropertyAssignment(node.name, factory.createCallExpression(factory.createPropertyAccessExpression(factory.createIdentifier("__k"), "get"), undefined, [factory.createStringLiteral(node.name.text)]))
-      }
-      if (ts.isIdentifier(node) && stateNames.has(node.text) && isReferenceIdentifier(node) && !isShadowedIdentifier(node, expression)) {
-        if (snapshots.has(node.text) && insideNestedFunction(node, expression)) return snapshots.get(node.text)
-        return factory.createCallExpression(
-          factory.createPropertyAccessExpression(factory.createIdentifier("__k"), "get"),
-          undefined,
-          [factory.createStringLiteral(node.text)]
-        )
-      }
-      if (ts.isShorthandPropertyAssignment(node) && captures.has(node.name.text) && !isShadowedIdentifier(node.name, expression)) {
-        if (captureSnapshots.has(node.name.text) && insideNestedFunction(node, expression)) return factory.createPropertyAssignment(node.name, captureSnapshots.get(node.name.text))
-        return factory.createPropertyAssignment(node.name, scopeRead(factory, node.name.text))
-      }
-      if (ts.isIdentifier(node) && captures.has(node.text) && isReferenceIdentifier(node) && !isShadowedIdentifier(node, expression)) {
-        if (captureSnapshots.has(node.text) && insideNestedFunction(node, expression)) return captureSnapshots.get(node.text)
-        return scopeRead(factory, node.text)
-      }
-      return ts.visitEachChild(node, visitor, context)
-    }
-    return ts.visitNode(root, visitor)
-  }
-  const transformed = ts.transform(expression.body, [transformer])
-  try {
-    let body = ts.isBlock(expression.body)
-      ? transformed.transformed[0]
-      : factory.createBlock([factory.createReturnStatement(transformed.transformed[0])], true)
-    const snapshotDeclarations = [
-      ...[...snapshots].map(([name, identifier]) => factory.createVariableDeclaration(identifier, undefined, undefined, factory.createCallExpression(factory.createPropertyAccessExpression(factory.createIdentifier("__k"), "get"), undefined, [factory.createStringLiteral(name)]))),
-      ...[...captureSnapshots].map(([name, identifier]) => factory.createVariableDeclaration(identifier, undefined, undefined, factory.createCallExpression(factory.createPropertyAccessExpression(factory.createIdentifier("__k"), "scope"), undefined, [factory.createStringLiteral(name)])))
-    ]
-    if (snapshotDeclarations.length) body = factory.updateBlock(body, [
-      factory.createVariableStatement(undefined, factory.createVariableDeclarationList(snapshotDeclarations, ts.NodeFlags.Const)),
-      ...body.statements
-    ])
-    const modifiers = [factory.createModifier(ts.SyntaxKind.ExportKeyword)]
-    if (expression.modifiers?.some(modifier => modifier.kind === ts.SyntaxKind.AsyncKeyword)) modifiers.push(factory.createModifier(ts.SyntaxKind.AsyncKeyword))
-    const declaration = factory.createFunctionDeclaration(
-      modifiers,
-      expression.asteriskToken,
-      exportName,
-      undefined,
-      [factory.createParameterDeclaration(undefined, undefined, "__k"), ...expression.parameters],
-      undefined,
-      body
-    )
-    return ts.createPrinter().printNode(ts.EmitHint.Unspecified, declaration, expression.getSourceFile())
-  } finally {
-    transformed.dispose()
-  }
-}
-
-function nestedCaptureNames(expression, captures) {
-  const names = new Set()
-  const visit = node => {
-    if (ts.isIdentifier(node) && captures.has(node.text) && isReferenceIdentifier(node) && insideNestedFunction(node, expression) && !isShadowedIdentifier(node, expression)) names.add(node.text)
-    ts.forEachChild(node, visit)
-  }
-  visit(expression.body)
-  return names
-}
-
-function nestedStateNames(expression, setters, liveStates = new Set()) {
-  const states = new Set(setters.values())
-  const names = new Set()
-  const visit = node => {
-    if (ts.isIdentifier(node) && states.has(node.text) && !liveStates.has(node.text) && isReferenceIdentifier(node) && insideNestedFunction(node, expression) && !isShadowedIdentifier(node, expression)) names.add(node.text)
-    ts.forEachChild(node, visit)
-  }
-  visit(expression.body)
-  return names
-}
-
-function insideNestedFunction(node, root) {
-  for (let current = node.parent; current && current !== root; current = current.parent) {
-    if (isFunctionLike(current)) return true
-  }
-  return false
-}
-
-function setterReference(factory, stateName) {
-  return factory.createArrowFunction(
-    undefined,
-    undefined,
-    [factory.createParameterDeclaration(undefined, undefined, "value")],
-    undefined,
-    factory.createToken(ts.SyntaxKind.EqualsGreaterThanToken),
-    factory.createCallExpression(factory.createPropertyAccessExpression(factory.createIdentifier("__k"), "set"), undefined, [factory.createStringLiteral(stateName), factory.createIdentifier("value")])
-  )
-}
-
-function reducerReference(factory, reducer) {
-  const action = factory.createUniqueName("__kAction")
-  return factory.createArrowFunction(undefined, undefined, [factory.createParameterDeclaration(undefined, undefined, action)], undefined, factory.createToken(ts.SyntaxKind.EqualsGreaterThanToken), reducerDispatch(factory, reducer, action))
-}
-
-function reducerDispatch(factory, reducer, action) {
-  if (reducer.store) return zustandActionDispatch(factory, reducer, [action])
-  const previous = factory.createUniqueName("__kPrevious")
-  const update = factory.createArrowFunction(undefined, undefined, [factory.createParameterDeclaration(undefined, undefined, previous)], undefined, factory.createToken(ts.SyntaxKind.EqualsGreaterThanToken), factory.createCallExpression(factory.createIdentifier(reducer.reducer), undefined, [previous, action]))
-  return factory.createCallExpression(factory.createPropertyAccessExpression(factory.createIdentifier("__k"), "set"), undefined, [factory.createStringLiteral(reducer.state), update])
-}
-
-function zustandActionDispatch(factory, reducer, args) {
-  const previous = factory.createUniqueName("__kPrevious")
-  const current = factory.createUniqueName("__kStore")
-  const updateValue = factory.createUniqueName("__kUpdate")
-  const partial = factory.createUniqueName("__kPartial")
-  const action = factory.createUniqueName("__kAction")
-  const set = factory.createIdentifier(reducer.store.setName)
-  const merge = factory.createExpressionStatement(factory.createBinaryExpression(current, factory.createToken(ts.SyntaxKind.EqualsToken), factory.createObjectLiteralExpression([
-    factory.createSpreadAssignment(current),
-    factory.createSpreadAssignment(partial)
-  ])))
-  const setBody = factory.createBlock([
-    factory.createVariableStatement(undefined, factory.createVariableDeclarationList([factory.createVariableDeclaration(partial, undefined, undefined, factory.createConditionalExpression(
-      factory.createBinaryExpression(factory.createTypeOfExpression(updateValue), factory.createToken(ts.SyntaxKind.EqualsEqualsEqualsToken), factory.createStringLiteral("function")),
-      undefined,
-      factory.createCallExpression(updateValue, undefined, [current]),
-      undefined,
-      updateValue
-    ))], ts.NodeFlags.Const)),
-    merge
-  ], true)
-  const body = factory.createBlock([
-    factory.createVariableStatement(undefined, factory.createVariableDeclarationList([factory.createVariableDeclaration(current, undefined, undefined, factory.createObjectLiteralExpression([factory.createPropertyAssignment(reducer.store.field, previous)]))], ts.NodeFlags.Let)),
-    factory.createVariableStatement(undefined, factory.createVariableDeclarationList([factory.createVariableDeclaration(set, undefined, undefined, factory.createArrowFunction(undefined, undefined, [factory.createParameterDeclaration(undefined, undefined, updateValue)], undefined, factory.createToken(ts.SyntaxKind.EqualsGreaterThanToken), setBody))], ts.NodeFlags.Const)),
-    factory.createVariableStatement(undefined, factory.createVariableDeclarationList([factory.createVariableDeclaration(action, undefined, undefined, synthesizeTree(reducer.store.actions.get(reducer.action)))], ts.NodeFlags.Const)),
-    factory.createExpressionStatement(factory.createCallExpression(action, undefined, args)),
-    factory.createReturnStatement(factory.createPropertyAccessExpression(current, reducer.store.field))
-  ], true)
-  const update = factory.createArrowFunction(undefined, undefined, [factory.createParameterDeclaration(undefined, undefined, previous)], undefined, factory.createToken(ts.SyntaxKind.EqualsGreaterThanToken), body)
-  return factory.createCallExpression(factory.createPropertyAccessExpression(factory.createIdentifier("__k"), "set"), undefined, [factory.createStringLiteral(reducer.state), update])
-}
-
-function printReactiveBinding({ exportName, expression, captures, states }) {
-  const factory = ts.factory
-  const transformer = context => root => {
-    const visitor = node => {
-      if (ts.isShorthandPropertyAssignment(node) && states.has(node.name.text)) {
-        return factory.createPropertyAssignment(
-          node.name,
-          factory.createCallExpression(
-            factory.createPropertyAccessExpression(factory.createIdentifier("__k"), "get"),
-            undefined,
-            [factory.createStringLiteral(node.name.text)]
-          )
-        )
-      }
-      if (ts.isIdentifier(node) && states.has(node.text) && isReferenceIdentifier(node) && !isShadowedByParameter(node, expression)) {
-        return factory.createCallExpression(
-          factory.createPropertyAccessExpression(factory.createIdentifier("__k"), "get"),
-          undefined,
-          [factory.createStringLiteral(node.text)]
-        )
-      }
-      if (ts.isShorthandPropertyAssignment(node) && captures.has(node.name.text)) {
-        return factory.createPropertyAssignment(node.name, scopeRead(factory, node.name.text))
-      }
-      if (ts.isIdentifier(node) && captures.has(node.text) && isReferenceIdentifier(node)) {
-        return scopeRead(factory, node.text)
-      }
-      return ts.visitEachChild(node, visitor, context)
-    }
-    return ts.visitNode(root, visitor)
-  }
-  const transformed = ts.transform(expression, [transformer])
-  try {
-    const declaration = factory.createFunctionDeclaration(
-      [factory.createModifier(ts.SyntaxKind.ExportKeyword)],
-      undefined,
-      exportName,
-      undefined,
-      [factory.createParameterDeclaration(undefined, undefined, "__k")],
-      undefined,
-      factory.createBlock([factory.createReturnStatement(transformed.transformed[0])], true)
-    )
-    return ts.createPrinter().printNode(ts.EmitHint.Unspecified, declaration, expression.getSourceFile())
-  } finally {
-    transformed.dispose()
-  }
-}
-
-function printListExpression({ exportName, expression, item, index, states = new Set() }) {
-  const factory = ts.factory
-  const transformer = context => root => {
-    const visitor = node => {
-      if (ts.isShorthandPropertyAssignment(node) && states.has(node.name.text)) {
-        return factory.createPropertyAssignment(node.name, factory.createCallExpression(factory.createPropertyAccessExpression(factory.createIdentifier("__k"), "get"), undefined, [factory.createStringLiteral(node.name.text)]))
-      }
-      if (ts.isIdentifier(node) && states.has(node.text) && isReferenceIdentifier(node) && !isShadowedByParameter(node, expression)) {
-        return factory.createCallExpression(factory.createPropertyAccessExpression(factory.createIdentifier("__k"), "get"), undefined, [factory.createStringLiteral(node.text)])
-      }
-      return ts.visitEachChild(node, visitor, context)
-    }
-    return ts.visitNode(root, visitor)
-  }
-  const transformed = ts.transform(expression, [transformer])
-  const declaration = ts.factory.createFunctionDeclaration(
-    [ts.factory.createModifier(ts.SyntaxKind.ExportKeyword)],
-    undefined,
-    exportName,
-    undefined,
-    [ts.factory.createParameterDeclaration(undefined, undefined, item), ts.factory.createParameterDeclaration(undefined, undefined, index ?? "__kIndex"), ts.factory.createParameterDeclaration(undefined, undefined, "__k")],
-    undefined,
-    ts.factory.createBlock([ts.factory.createReturnStatement(transformed.transformed[0])], true)
-  )
-  try {
-    return ts.createPrinter().printNode(ts.EmitHint.Unspecified, declaration, expression.getSourceFile())
-  } finally {
-    transformed.dispose()
-  }
-}
-
-function scopeRead(factory, name) {
-  return factory.createCallExpression(
-    factory.createPropertyAccessExpression(factory.createIdentifier("__k"), "scope"),
-    undefined,
-    [factory.createStringLiteral(name)]
-  )
-}
-
-function compileEventCommand(expression, setters, factory) {
-  if (ts.isCallExpression(expression) && ts.isPropertyAccessExpression(expression.expression) && ts.isIdentifier(expression.expression.expression) && expression.expression.expression.text === "console" && expression.expression.name.text === "log" && expression.arguments.length === 2 && ts.isStringLiteral(expression.arguments[0]) && ts.isIdentifier(expression.arguments[1]) && [...setters.values()].includes(expression.arguments[1].text)) {
-    return command(factory, "log", expression.arguments[1], factory.createStringLiteral(expression.arguments[0].text))
-  }
-
-  if (!ts.isCallExpression(expression) || !ts.isIdentifier(expression.expression) || expression.arguments.length !== 1) return undefined
-  const stateName = setters.get(expression.expression.text)
-  if (!stateName) return undefined
-
-  const state = factory.createIdentifier(stateName)
-  const value = expression.arguments[0]
-  if (ts.isBinaryExpression(value) && ts.isIdentifier(value.left) && value.left.text === stateName && ts.isNumericLiteral(value.right)) {
-    if (value.operatorToken.kind !== ts.SyntaxKind.PlusToken && value.operatorToken.kind !== ts.SyntaxKind.MinusToken) return undefined
-    return command(factory, "add", state, numericExpression(factory, Number(value.right.text), value.operatorToken.kind === ts.SyntaxKind.MinusToken))
-  }
-  if (ts.isArrowFunction(value) && value.parameters.length === 1 && ts.isIdentifier(value.parameters[0].name) && ts.isBinaryExpression(value.body) && ts.isIdentifier(value.body.left) && value.body.left.text === value.parameters[0].name.text && ts.isNumericLiteral(value.body.right)) {
-    if (value.body.operatorToken.kind !== ts.SyntaxKind.PlusToken && value.body.operatorToken.kind !== ts.SyntaxKind.MinusToken) return undefined
-    return command(factory, "add", state, numericExpression(factory, Number(value.body.right.text), value.body.operatorToken.kind === ts.SyntaxKind.MinusToken))
-  }
-  if (isPrimitiveLiteral(value)) return command(factory, "set", state, synthesizeSerializableStateLiteral(value, factory))
-  return undefined
-}
-
-function command(factory, operation, state, value) {
-  return factory.createArrayLiteralExpression([factory.createStringLiteral(operation), state, value])
-}
-
-function isPrimitiveLiteral(node) {
-  return isPrimitiveDefaultLiteral(node)
-}
-
-function numericExpression(factory, value, negative) {
-  const literal = factory.createNumericLiteral(value)
-  return negative ? factory.createPrefixUnaryExpression(ts.SyntaxKind.MinusToken, literal) : literal
-}
-
 function compiledPath(file) {
   return join(workDirectory, relative(sourceDirectory, file)).replace(/\.(?:ts|tsx)$/, ".mjs")
 }
@@ -7025,6 +3732,25 @@ function withBase(base, path) {
   return base ? `${base}${path}` : path
 }
 
+const workerCompiler = createWorkerCompiler({
+  root,
+  sourceDirectory,
+  outputDirectory,
+  assetPath,
+  parseSourceFile,
+  resolveSourceImport,
+  runtimeModuleReference
+})
+
+const printEffectEntry = createEffectCodegen({ assetPath, inlineJson, relativeModulePath })
+const printHandlerModule = createHandlerCodegen({
+  cloneAst,
+  synthesizeTree,
+  resolveClientImport: (entry, handlerPath) => entry.package ? entry.target : relativeModulePath(handlerPath, clientModulePath(entry.target))
+})
+const { normalizeReactMigrationSyntax, validateUseIdSyntax } = createReactMigrationPass({ cloneAst, jsxTagName })
+const normalizeReactRouterSyntax = createRouterPass({ withBase })
+
 async function staticPathEntries(module, file) {
   if (typeof module.getStaticPaths !== "function") return [{ params: {}, props: {} }]
   const entries = await module.getStaticPaths()
@@ -7109,13 +3835,3 @@ async function exists(path) {
     return false
   }
 }
-
-function contentType(file) {
-  return {
-    ".html": "text/html; charset=utf-8",
-    ".css": "text/css; charset=utf-8",
-    ".js": "text/javascript; charset=utf-8",
-    ".json": "application/json; charset=utf-8",
-    ".svg": "image/svg+xml"
-  }[extname(file)] ?? "application/octet-stream"
-}