@kudzujs/core 0.8.17 → 0.8.19

package/framework/compiler/analysis/component-analysis.mjs

@@ -0,0 +1,49 @@
+export function createComponentAnalysis(file) {
+  return { version: 1, file, owners: [], specializations: [] }
+}
+
+export function createComponentAnalysisSession(analysis) {
+  const owners = new WeakMap()
+
+  function registerOwner(identity, descriptor = {}) {
+    let owner = owners.get(identity)
+    if (!owner) {
+      owner = { slot: analysis.owners.length, kind: descriptor.kind ?? "component", name: descriptor.name ?? "anonymous", props: descriptor.props ?? [], states: [], setters: [], refs: [], ids: [], ...(descriptor.source ? { source: descriptor.source } : {}) }
+      owners.set(identity, owner)
+      analysis.owners.push(owner)
+    }
+    return owner
+  }
+
+  function registerState(identity, descriptor) {
+    const owner = owners.get(identity)
+    if (!owner) throw new Error("Component owner must be registered before its state")
+    let state = owner.states.find(entry => entry.name === descriptor.name && entry.owner === descriptor.owner)
+    if (!state) {
+      state = { slot: owner.states.length, name: descriptor.name, kind: descriptor.kind, ...(descriptor.owner ? { owner: descriptor.owner } : {}), ...(descriptor.source ? { source: descriptor.source } : {}) }
+      owner.states.push(state)
+    }
+    if (descriptor.setter && !owner.setters.some(entry => entry.name === descriptor.setter)) owner.setters.push({ name: descriptor.setter, signal: state.slot, kind: descriptor.kind })
+    return state
+  }
+
+  function registerRef(identity, descriptor) {
+    const owner = owners.get(identity)
+    if (!owner) throw new Error("Component owner must be registered before its ref")
+    if (!owner.refs.some(entry => entry.name === descriptor.name)) owner.refs.push({ slot: owner.refs.length, ...descriptor })
+  }
+
+  function registerId(identity, descriptor) {
+    const owner = owners.get(identity)
+    if (!owner) throw new Error("Component owner must be registered before its ID")
+    if (!owner.ids.some(entry => entry.name === descriptor.name)) owner.ids.push({ slot: owner.ids.length, ...descriptor })
+  }
+
+  function registerSpecialization(descriptor) {
+    const specialization = { slot: analysis.specializations.length, ...descriptor }
+    analysis.specializations.push(specialization)
+    return specialization
+  }
+
+  return { owner: identity => owners.get(identity), registerId, registerOwner, registerRef, registerSpecialization, registerState }
+}

package/framework/compiler/descriptor-session.mjs

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

package/framework/compiler/handler-codegen.mjs

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