@kudzujs/core 0.8.35 → 0.8.37

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

@@ -1,48 +1,159 @@
 export function createModuleIR(file) {
-  return { version: 1, file, signals: [], handlers: [], bindings: [], derived: [], effects: [], keyedBlocks: [], imports: [], clientModules: [] }
+  return { version: 2, file, symbols: [], signals: [], handlers: [], bindings: [], derived: [], effects: [], keyedBlocks: [], imports: [], clientModules: [] }
 }
 
-export function assertModuleIRReferences(moduleIR) {
-  const slot = (records, value, label) => {
-    if (!Number.isInteger(value) || value < 0 || value >= records.length) throw new Error(`ModuleIR ${label} references missing slot ${JSON.stringify(value)}`)
+export function assertModuleIRReferences(moduleIR, componentAnalysis) {
+  if (moduleIR?.version !== 2) throw new Error(`Unsupported ModuleIR version: ${JSON.stringify(moduleIR?.version)}`)
+  if (componentAnalysis && componentAnalysis.version !== 2) throw new Error(`Unsupported ComponentAnalysis version: ${JSON.stringify(componentAnalysis.version)}`)
+  const slot = (records, value, label, kind) => {
+    if (!Number.isInteger(value) || value < 0 || value >= records.length) throw new Error(`${label} references missing ${kind} slot ${JSON.stringify(value)}`)
+    return records[value]
   }
-  for (const [name, records] of [["signal", moduleIR.signals], ["handler", moduleIR.handlers], ["binding", moduleIR.bindings], ["derived", moduleIR.derived], ["effect", moduleIR.effects], ["keyed block", moduleIR.keyedBlocks]]) {
+  const indexed = (name, records) => {
     records.forEach((record, index) => {
-      if (record.slot !== index) throw new Error(`ModuleIR ${name} slot ${JSON.stringify(record.slot)} must equal its index ${index}`)
+      if (record.slot !== index) throw new Error(`${name} slot ${JSON.stringify(record.slot)} must equal its index ${index}`)
     })
   }
+  indexed("SymbolRef", moduleIR.symbols)
+  indexed("SignalIR", moduleIR.signals)
+  indexed("HandlerIR", moduleIR.handlers)
+  indexed("BindingIR", moduleIR.bindings)
+  indexed("DerivedIR", moduleIR.derived)
+  indexed("EffectIR", moduleIR.effects)
+  indexed("KeyedBlockIR", moduleIR.keyedBlocks)
+  indexed("ImportIR", moduleIR.imports)
+  if (componentAnalysis) {
+    indexed("Component owner", componentAnalysis.owners)
+    indexed("Component specialization", componentAnalysis.specializations)
+    for (const owner of componentAnalysis.owners) {
+      indexed(`Component owner ${owner.slot} state`, owner.states)
+      indexed(`Component owner ${owner.slot} ref`, owner.refs)
+      indexed(`Component owner ${owner.slot} ID`, owner.ids)
+      for (const setter of owner.setters) slot(owner.states, setter.signal, `Component owner ${owner.slot} setter ${JSON.stringify(setter.name)}`, "state")
+      for (const state of owner.states) if (state.owner !== undefined) ownerRef(state.owner, `Component owner ${owner.slot} state ${state.slot} external owner`)
+    }
+    for (const specialization of componentAnalysis.specializations) {
+      indexed(`Component specialization ${specialization.slot} state`, specialization.states)
+      indexed(`Component specialization ${specialization.slot} ref`, specialization.refs)
+      indexed(`Component specialization ${specialization.slot} ID`, specialization.ids)
+      if (specialization.owner !== undefined) ownerRef(specialization.owner, `Component specialization ${specialization.slot} owner`)
+      for (const prop of specialization.props ?? []) for (const signal of prop.signals ?? []) slot(moduleIR.signals, signal, `Component specialization ${specialization.slot} prop ${JSON.stringify(prop.name)}`, "SignalIR")
+    }
+  }
+  function moduleSymbol(symbol, label) {
+    if (!symbol || typeof symbol.id !== "string" || typeof symbol.module !== "string" || typeof symbol.site !== "string" || typeof symbol.name !== "string") throw new Error(`${label} must be a ModuleSymbol`)
+  }
+  function ownerRef(reference, label) {
+    if (!reference || typeof reference !== "object") throw new Error(`${label} must be an OwnerRef`)
+    if (reference.kind === "component") return slot(componentAnalysis?.owners ?? [], reference.slot, label, "component owner")
+    if (reference.kind === "specialization") return slot(componentAnalysis?.specializations ?? [], reference.slot, label, "component specialization")
+    if (reference.kind === "module-symbol") return moduleSymbol(reference.symbol, label)
+    if (reference.kind !== "module") throw new Error(`${label} has invalid kind ${JSON.stringify(reference.kind)}`)
+  }
+  function stateRef(reference, label) {
+    if (!reference || typeof reference !== "object") throw new Error(`${label} must be a StateRef`)
+    if (reference.kind === "module-symbol") return moduleSymbol(reference.symbol, label)
+    if (reference.kind === "symbol") return slot(moduleIR.symbols, reference.symbol, label, "SymbolRef")
+    if (reference.kind !== "state") throw new Error(`${label} has invalid kind ${JSON.stringify(reference.kind)}`)
+    const owner = ownerRef(reference.owner, `${label} owner`)
+    const states = reference.owner.kind === "component" || reference.owner.kind === "specialization" ? owner.states : []
+    slot(states, reference.slot, label, "owner state")
+  }
+  const exports = new Map()
+  const exported = (record, label) => {
+    if (record.kind !== "module-export") return
+    if (typeof record.exportName !== "string" || !record.exportName) throw new Error(`${label} requires an export name`)
+    const previous = exports.get(record.exportName)
+    if (previous) throw new Error(`ModuleIR export ${JSON.stringify(record.exportName)} is declared by both ${previous} and ${label}`)
+    exports.set(record.exportName, label)
+  }
+  for (const signal of moduleIR.signals) stateRef(signal.reference, `SignalIR ${signal.slot}`)
   for (const handler of moduleIR.handlers) {
-    for (const command of handler.commands ?? []) slot(moduleIR.signals, command.signal, `handler ${handler.slot} command signal`)
-    if (handler.keyedBlock !== undefined) slot(moduleIR.keyedBlocks, handler.keyedBlock, `handler ${handler.slot} keyed block`)
+    exported(handler, `HandlerIR ${handler.slot}`)
+    for (const [index, command] of (handler.commands ?? []).entries()) slot(moduleIR.signals, command.signal, `HandlerIR ${handler.slot} command ${index}`, "SignalIR")
+    for (const [index, signal] of (handler.signals ?? []).entries()) slot(moduleIR.signals, signal.signal, `HandlerIR ${handler.slot} signal ${index}`, "SignalIR")
+    for (const [index, imported] of (handler.imports ?? []).entries()) slot(moduleIR.imports, imported, `HandlerIR ${handler.slot} import ${index}`, "ImportIR")
+    for (const [index, capture] of (handler.captures ?? []).entries()) if (capture.symbol !== undefined) slot(moduleIR.symbols, capture.symbol, `HandlerIR ${handler.slot} capture ${index}`, "SymbolRef")
+    if (handler.keyedBlock !== undefined) slot(moduleIR.keyedBlocks, handler.keyedBlock, `HandlerIR ${handler.slot} keyed block`, "KeyedBlockIR")
   }
-  for (const binding of moduleIR.bindings) if (binding.keyedBlock !== undefined) slot(moduleIR.keyedBlocks, binding.keyedBlock, `binding ${binding.slot} keyed block`)
+  for (const binding of moduleIR.bindings) {
+    exported(binding, `BindingIR ${binding.slot}`)
+    for (const [index, signal] of (binding.signals ?? []).entries()) slot(moduleIR.signals, signal, `BindingIR ${binding.slot} signal ${index}`, "SignalIR")
+    for (const [index, imported] of (binding.imports ?? []).entries()) slot(moduleIR.imports, imported, `BindingIR ${binding.slot} import ${index}`, "ImportIR")
+    for (const [index, capture] of (binding.captures ?? []).entries()) if (capture.symbol !== undefined) slot(moduleIR.symbols, capture.symbol, `BindingIR ${binding.slot} capture ${index}`, "SymbolRef")
+    if (binding.keyedBlock !== undefined) slot(moduleIR.keyedBlocks, binding.keyedBlock, `BindingIR ${binding.slot} keyed block`, "KeyedBlockIR")
+  }
+  for (const derived of moduleIR.derived) for (const [index, signal] of (derived.signals ?? []).entries()) slot(moduleIR.signals, signal, `DerivedIR ${derived.slot} signal ${index}`, "SignalIR")
   for (const effect of moduleIR.effects) {
-    slot(moduleIR.handlers, effect.setup?.handler, `effect ${effect.slot} setup handler`)
-    for (const dependency of effect.dependencies ?? []) if (dependency.kind === "derived") slot(moduleIR.derived, dependency.derived, `effect ${effect.slot} derived dependency`)
-    if (effect.ownership?.keyedBlock !== undefined) slot(moduleIR.keyedBlocks, effect.ownership.keyedBlock, `effect ${effect.slot} keyed block`)
+    const handler = slot(moduleIR.handlers, effect.setup?.handler, `EffectIR ${effect.slot} setup`, "HandlerIR")
+    if (handler.kind !== "module-export" || handler.role !== "effect") throw new Error(`EffectIR ${effect.slot} setup HandlerIR ${handler.slot} must have role "effect"`)
+    for (const [index, dependency] of (effect.dependencies ?? []).entries()) {
+      if (dependency.kind === "signal") slot(moduleIR.signals, dependency.signal, `EffectIR ${effect.slot} dependency ${index}`, "SignalIR")
+      else if (dependency.kind === "derived") {
+        slot(moduleIR.derived, dependency.derived, `EffectIR ${effect.slot} dependency ${index}`, "DerivedIR")
+        for (const [sourceIndex, signal] of (dependency.sources ?? []).entries()) slot(moduleIR.signals, signal, `EffectIR ${effect.slot} dependency ${index} source ${sourceIndex}`, "SignalIR")
+      } else throw new Error(`EffectIR ${effect.slot} dependency ${index} has invalid kind ${JSON.stringify(dependency.kind)}`)
+    }
+    for (const [index, signal] of (effect.subscriptions ?? []).entries()) slot(moduleIR.signals, signal, `EffectIR ${effect.slot} subscription ${index}`, "SignalIR")
+    for (const [index, signal] of (effect.dependencySignals ?? []).entries()) slot(moduleIR.signals, signal, `EffectIR ${effect.slot} dependency signal ${index}`, "SignalIR")
+    if (effect.ownership?.owner) ownerRef(effect.ownership.owner, `EffectIR ${effect.slot} ownership`)
+    if (effect.ownership?.keyedBlock !== undefined) {
+      slot(moduleIR.keyedBlocks, effect.ownership.keyedBlock, `EffectIR ${effect.slot} ownership`, "KeyedBlockIR")
+      if (handler.keyedBlock !== effect.ownership.keyedBlock) throw new Error(`EffectIR ${effect.slot} and HandlerIR ${handler.slot} must reference the same KeyedBlockIR`)
+    }
   }
   for (const block of moduleIR.keyedBlocks) {
-    if (block.parent !== undefined) slot(moduleIR.keyedBlocks, block.parent, `keyed block ${block.slot} parent`)
-    for (const child of block.children ?? []) slot(moduleIR.keyedBlocks, child, `keyed block ${block.slot} child`)
-    if (block.selector !== undefined) slot(moduleIR.derived, block.selector, `keyed block ${block.slot} selector`)
+    if (block.collection?.kind === "signal") slot(moduleIR.signals, block.collection.signal, `KeyedBlockIR ${block.slot} collection`, "SignalIR")
+    else if (block.collection?.kind === "binding") slot(moduleIR.bindings, block.collection.binding, `KeyedBlockIR ${block.slot} collection`, "BindingIR")
+    else if (block.collection?.kind === "symbol") slot(moduleIR.symbols, block.collection.symbol, `KeyedBlockIR ${block.slot} collection`, "SymbolRef")
+    else if (block.collection?.kind !== "static") throw new Error(`KeyedBlockIR ${block.slot} collection has invalid kind ${JSON.stringify(block.collection?.kind)}`)
+    if (block.parent !== undefined) {
+      const parent = slot(moduleIR.keyedBlocks, block.parent, `KeyedBlockIR ${block.slot} parent`, "KeyedBlockIR")
+      if (!(parent.children ?? []).includes(block.slot)) throw new Error(`KeyedBlockIR ${block.slot} parent ${parent.slot} does not reciprocally list child ${block.slot}`)
+    }
+    for (const childSlot of block.children ?? []) {
+      const child = slot(moduleIR.keyedBlocks, childSlot, `KeyedBlockIR ${block.slot} child`, "KeyedBlockIR")
+      if (child.parent !== block.slot) throw new Error(`KeyedBlockIR ${block.slot} child ${child.slot} does not reciprocally reference parent ${block.slot}`)
+    }
+    if (new Set(block.children ?? []).size !== (block.children ?? []).length) throw new Error(`KeyedBlockIR ${block.slot} has duplicate children`)
+    if (block.selector !== undefined) slot(moduleIR.derived, block.selector, `KeyedBlockIR ${block.slot} selector`, "DerivedIR")
+    for (const [index, signal] of (block.selectorSignals ?? []).entries()) slot(moduleIR.signals, signal, `KeyedBlockIR ${block.slot} selector signal ${index}`, "SignalIR")
+    for (const [index, specialization] of (block.specializations ?? []).entries()) slot(componentAnalysis?.specializations ?? [], specialization, `KeyedBlockIR ${block.slot} specialization ${index}`, "component specialization")
+    for (const [index, row] of (block.rowStates ?? []).entries()) slot(moduleIR.signals, row.signal, `KeyedBlockIR ${block.slot} row state ${index}`, "SignalIR")
+    for (const [index, row] of (block.rowRefs ?? []).entries()) {
+      const specialization = slot(componentAnalysis?.specializations ?? [], row.specialization, `KeyedBlockIR ${block.slot} row ref ${index}`, "component specialization")
+      slot(specialization.refs, row.ref, `KeyedBlockIR ${block.slot} row ref ${index}`, "specialization ref")
+    }
+  }
+  const visiting = new Set()
+  const visited = new Set()
+  const visit = (block, trail) => {
+    if (visiting.has(block.slot)) throw new Error(`KeyedBlockIR parent cycle: ${[...trail, block.slot].join(" -> ")}`)
+    if (visited.has(block.slot)) return
+    visiting.add(block.slot)
+    if (block.parent !== undefined) visit(moduleIR.keyedBlocks[block.parent], [...trail, block.slot])
+    visiting.delete(block.slot)
+    visited.add(block.slot)
   }
+  for (const block of moduleIR.keyedBlocks) visit(block, [])
   return moduleIR
 }
 
-export function registerCommandHandler(moduleIR, commands, source, scope = "module") {
-  const slots = new Map(moduleIR.signals.map(signal => [signal.key, signal.slot]))
-  for (const { state, owner = scope } of commands) {
-    const key = `${owner}:${state}`
-    if (slots.has(key)) continue
-    const slot = moduleIR.signals.length
-    slots.set(key, slot)
-    moduleIR.signals.push({ slot, key, debugName: state })
+export function registerSignal(moduleIR, reference, debugName) {
+  const key = JSON.stringify(reference)
+  let signal = moduleIR.signals.find(entry => JSON.stringify(entry.reference) === key)
+  if (!signal) {
+    signal = { slot: moduleIR.signals.length, reference, debugName }
+    moduleIR.signals.push(signal)
   }
-  const signal = command => slots.get(`${command.owner ?? scope}:${command.state}`)
+  return signal
+}
+
+export function registerCommandHandler(moduleIR, commands, source) {
   const handler = {
     slot: moduleIR.handlers.length,
     kind: "commands",
-    commands: commands.map(({ operation, state, owner, value, syntax }) => ({ operation, signal: signal({ state, owner }), value, ...(syntax ? { syntax } : {}) })),
+    commands: commands.map(({ operation, reference, state, value, syntax }) => ({ operation, signal: registerSignal(moduleIR, reference, state).slot, value, ...(syntax ? { syntax } : {}) })),
     ...(source ? { source } : {})
   }
   moduleIR.handlers.push(handler)
@@ -50,31 +161,31 @@ export function registerCommandHandler(moduleIR, commands, source, scope = "modu
 }
 
 export function registerModuleHandler(moduleIR, descriptor) {
-  const handler = { slot: moduleIR.handlers.length, kind: "module-export", ...descriptor }
+  const handler = { ...descriptor, slot: moduleIR.handlers.length, kind: "module-export" }
   moduleIR.handlers.push(handler)
   return handler
 }
 
 export function registerBinding(moduleIR, descriptor) {
-  const binding = { slot: moduleIR.bindings.length, kind: "module-export", ...descriptor }
+  const binding = { ...descriptor, slot: moduleIR.bindings.length, kind: "module-export" }
   moduleIR.bindings.push(binding)
   return binding
 }
 
 export function registerDerived(moduleIR, descriptor) {
-  const derived = { slot: moduleIR.derived.length, ...descriptor }
+  const derived = { ...descriptor, slot: moduleIR.derived.length }
   moduleIR.derived.push(derived)
   return derived
 }
 
 export function registerEffect(moduleIR, descriptor) {
-  const effect = { slot: moduleIR.effects.length, ...descriptor }
+  const effect = { ...descriptor, slot: moduleIR.effects.length }
   moduleIR.effects.push(effect)
   return effect
 }
 
 export function registerKeyedBlock(moduleIR, descriptor) {
-  const block = { slot: moduleIR.keyedBlocks.length, ...descriptor }
+  const block = { ...descriptor, slot: moduleIR.keyedBlocks.length }
   moduleIR.keyedBlocks.push(block)
   return block
 }

package/framework/compiler/optimize/command-specialization.mjs

@@ -1,32 +1,203 @@
 import ts from "typescript"
+import { sourceNodeError } from "../ast-helpers.mjs"
 
 export function createCommandSpecializer({ isPrimitiveLiteral }) {
-  return function specializeCommand(expression, setters) {
+  const specialize = (expression, setters) => {
     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 { operation: "log", state: expression.arguments[1].text, value: expression.arguments[0].text }
     }
-
     if (!ts.isCallExpression(expression) || !ts.isIdentifier(expression.expression) || expression.arguments.length !== 1) return undefined
     const state = setters.get(expression.expression.text)
     if (!state) return undefined
-
     const value = expression.arguments[0]
-    if (ts.isBinaryExpression(value) && ts.isIdentifier(value.left) && value.left.text === state && ts.isNumericLiteral(value.right)) {
-      if (value.operatorToken.kind !== ts.SyntaxKind.PlusToken && value.operatorToken.kind !== ts.SyntaxKind.MinusToken) return undefined
-      const operand = signedNumber(value.right, value.operatorToken.kind === ts.SyntaxKind.MinusToken ? "negative" : undefined)
-      return operand ? { operation: "add", state, ...operand } : undefined
-    }
-    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
-      const operand = signedNumber(value.body.right, value.body.operatorToken.kind === ts.SyntaxKind.MinusToken ? "negative" : undefined)
-      return operand ? { operation: "add", state, ...operand } : undefined
-    }
+    if (ts.isBinaryExpression(value) && ts.isIdentifier(value.left) && value.left.text === state) return addCommand(state, value)
+    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) return addCommand(state, value.body)
     if (isPrimitiveLiteral(value)) {
       const literal = primitiveValue(value)
       return literal ? { operation: "set", state, ...literal } : undefined
     }
-    return undefined
   }
+  specialize.handler = (handler, setters, bindingIndex) => specializeHandler(handler, setters, bindingIndex, specialize)
+  return specialize
+}
+
+function specializeHandler(handler, setters, bindingIndex, specialize) {
+  const statements = ts.isBlock(handler.body) ? handler.body.statements.filter(statement => !ts.isEmptyStatement(statement)) : []
+  if (statements.length === 2) {
+    const command = aliasCommand(statements, handler, setters, bindingIndex) ?? helperCommand(statements, handler, setters, bindingIndex, specialize)
+    if (command) return [command]
+  }
+  rejectUnsafe(statements, handler, setters, bindingIndex)
+}
+
+function aliasCommand([first, second], boundary, setters, bindingIndex) {
+  const declaration = oneDeclaration(first)
+  if (!declaration || !(first.declarationList.flags & ts.NodeFlags.Const) || !declaration.initializer || !ts.isExpressionStatement(second)) return undefined
+  const value = stateAdd(declaration.initializer, boundary, setters, bindingIndex)
+  const call = second.expression
+  if (!value || !directCall(call) || call.arguments.length !== 1 || !ts.isIdentifier(call.arguments[0])) return undefined
+  const state = setters.get(call.expression.text)
+  if (state !== value.state || !captured(call.expression, boundary, call.expression.text, bindingIndex) || !declaredBy(call.arguments[0], declaration.name, boundary, bindingIndex) || refs(boundary, declaration.name, boundary, bindingIndex).length !== 1) return undefined
+  return { operation: "add", state, ...value.operand }
+}
+
+function helperCommand([first, second], boundary, setters, bindingIndex, specialize) {
+  if (!ts.isExpressionStatement(second) || !directCall(second.expression)) return undefined
+  const call = second.expression
+  let name
+  let command
+  const declaration = oneDeclaration(first)
+  if (declaration && first.declarationList.flags & ts.NodeFlags.Const && declaration.initializer && ts.isArrowFunction(declaration.initializer) && !declaration.initializer.modifiers?.some(modifier => modifier.kind === ts.SyntaxKind.AsyncKeyword) && !declaration.initializer.parameters.length && !ts.isBlock(declaration.initializer.body) && !call.arguments.length) {
+    name = declaration.name
+    command = safeDirect(declaration.initializer.body, boundary, setters, bindingIndex, specialize)
+  } else if (ts.isFunctionDeclaration(first) && first.name && first.body && !first.asteriskToken && !first.modifiers?.some(modifier => modifier.kind === ts.SyntaxKind.AsyncKeyword) && first.parameters.length === 1 && first.body.statements.length === 1 && ts.isExpressionStatement(first.body.statements[0]) && call.arguments.length === 1 && ts.isIdentifier(call.arguments[0])) {
+    const parameter = first.parameters[0]
+    if (!ts.isIdentifier(parameter.name) || parameter.initializer || parameter.dotDotDotToken) return undefined
+    name = first.name
+    command = parameterCommand(first.body.statements[0].expression, parameter.name, first, call.arguments[0], boundary, setters, bindingIndex)
+  }
+  if (!name || !command || call.expression.text !== name.text || !declaredBy(call.expression, name, boundary, bindingIndex) || refs(boundary, name, boundary, bindingIndex).length !== 1) return undefined
+  return command
+}
+
+function safeDirect(expression, boundary, setters, bindingIndex, specialize) {
+  const command = specialize(expression, setters)
+  if (!command || command.operation === "log") return undefined
+  if (!captured(expression.expression, boundary, expression.expression.text, bindingIndex)) return undefined
+  const value = expression.arguments[0]
+  return !ts.isBinaryExpression(value) || captured(value.left, boundary, command.state, bindingIndex) ? command : undefined
+}
+
+function parameterCommand(expression, parameter, helper, argument, boundary, setters, bindingIndex) {
+  if (!directCall(expression) || expression.arguments.length !== 1 || !ts.isBinaryExpression(expression.arguments[0])) return undefined
+  const state = setters.get(expression.expression.text)
+  const value = expression.arguments[0]
+  if (!state || !captured(expression.expression, boundary, expression.expression.text, bindingIndex) || !ts.isIdentifier(value.left) || !declaredBy(value.left, parameter, helper, bindingIndex) || !captured(argument, boundary, state, bindingIndex)) return undefined
+  const operand = addOperand(value)
+  return operand ? { operation: "add", state, ...operand } : undefined
+}
+
+function rejectUnsafe(statements, boundary, setters, bindingIndex) {
+  if (!bindingIndex) return
+  for (const statement of statements) {
+    const declaration = oneDeclaration(statement)
+    if (declaration?.initializer && ts.isObjectLiteralExpression(declaration.initializer) && containsSetter(declaration.initializer, boundary, setters, bindingIndex)) {
+      const use = refs(boundary, declaration.name, boundary, bindingIndex).find(dynamic)
+      if (use) fail(use, "Semantic state helpers do not support dynamic dispatch")
+    }
+    if (declaration?.initializer && stateAdd(declaration.initializer, boundary, setters, bindingIndex)) {
+      const use = setterAliasUse(boundary, declaration.name, setters, bindingIndex)
+      if (!use) continue
+      const uses = refs(boundary, declaration.name, boundary, bindingIndex)
+      if (!(statement.declarationList.flags & ts.NodeFlags.Const) || uses.some(mutated)) fail(declaration.name, "Semantic state aliases must remain immutable")
+      fail(uses.find(reference => reference !== use) ?? use, "Semantic state aliases must be passed directly to one setter and cannot escape")
+    }
+    const helper = helperDeclaration(statement, boundary, setters, bindingIndex)
+    if (!helper) continue
+    const uses = refs(boundary, helper.name, boundary, bindingIndex)
+    if (uses.some(reference => inside(reference, helper.body))) fail(helper.name, "Semantic state helpers cannot be recursive")
+    if (helper.mutable || uses.some(mutated)) fail(helper.name, "Semantic state helpers must remain immutable")
+    if (uses.some(dynamic)) fail(uses.find(dynamic), "Semantic state helpers do not support dynamic dispatch")
+    if (uses.length !== 1 || !directIdentifierCall(uses[0])) fail(uses.find(reference => !directIdentifierCall(reference)) ?? helper.name, "Semantic state helpers must be called exactly once and cannot escape")
+    fail(helper.body, "Semantic state helpers must contain one synchronous state operation")
+  }
+}
+
+function helperDeclaration(statement, boundary, setters, bindingIndex) {
+  const declaration = oneDeclaration(statement)
+  if (declaration?.initializer && (ts.isArrowFunction(declaration.initializer) || ts.isFunctionExpression(declaration.initializer)) && containsSetter(declaration.initializer, boundary, setters, bindingIndex)) return { name: declaration.name, body: declaration.initializer, mutable: !(statement.declarationList.flags & ts.NodeFlags.Const) }
+  if (ts.isFunctionDeclaration(statement) && statement.name && statement.body && containsSetter(statement.body, boundary, setters, bindingIndex)) return { name: statement.name, body: statement.body, mutable: false }
+}
+
+function stateAdd(expression, boundary, setters, bindingIndex) {
+  if (!ts.isBinaryExpression(expression) || !ts.isIdentifier(expression.left) || ![...setters.values()].includes(expression.left.text) || !captured(expression.left, boundary, expression.left.text, bindingIndex)) return undefined
+  const operand = addOperand(expression)
+  return operand ? { state: expression.left.text, operand } : undefined
+}
+
+function addCommand(state, expression) {
+  const operand = addOperand(expression)
+  return operand ? { operation: "add", state, ...operand } : undefined
+}
+
+function addOperand(expression) {
+  if (!ts.isBinaryExpression(expression) || !ts.isNumericLiteral(expression.right) || ![ts.SyntaxKind.PlusToken, ts.SyntaxKind.MinusToken].includes(expression.operatorToken.kind)) return undefined
+  return signedNumber(expression.right, expression.operatorToken.kind === ts.SyntaxKind.MinusToken ? "negative" : undefined)
+}
+
+function oneDeclaration(statement) {
+  if (!ts.isVariableStatement(statement) || statement.declarationList.declarations.length !== 1) return undefined
+  const declaration = statement.declarationList.declarations[0]
+  return ts.isIdentifier(declaration.name) ? declaration : undefined
+}
+
+function directCall(node) {
+  return ts.isCallExpression(node) && !node.questionDotToken && ts.isIdentifier(node.expression)
+}
+
+function captured(identifier, boundary, name, bindingIndex) {
+  if (!ts.isIdentifier(identifier)) return false
+  const resolution = bindingIndex?.resolveReference(identifier, boundary)
+  return !resolution ? identifier.text === name : resolution.debugName === name && ["capture", "unresolved"].includes(resolution.kind)
+}
+
+function declaredBy(identifier, declaration, boundary, bindingIndex) {
+  const resolution = bindingIndex?.resolveReference(identifier, boundary)
+  return bindingIndex ? resolution?.declaration === declaration : identifier.text === declaration.text
+}
+
+function refs(root, declaration, boundary, bindingIndex) {
+  const found = []
+  const visit = node => {
+    if (ts.isIdentifier(node) && declaredBy(node, declaration, boundary, bindingIndex)) found.push(node)
+    ts.forEachChild(node, visit)
+  }
+  visit(root)
+  return found
+}
+
+function containsSetter(root, boundary, setters, bindingIndex) {
+  let found = false
+  const visit = node => {
+    if (ts.isCallExpression(node) && ts.isIdentifier(node.expression) && setters.has(node.expression.text) && captured(node.expression, boundary, node.expression.text, bindingIndex)) found = true
+    if (!found) ts.forEachChild(node, visit)
+  }
+  visit(root)
+  return found
+}
+
+function setterAliasUse(root, declaration, setters, bindingIndex) {
+  let found
+  const visit = node => {
+    if (ts.isCallExpression(node) && ts.isIdentifier(node.expression) && setters.has(node.expression.text) && ts.isIdentifier(node.arguments[0]) && declaredBy(node.arguments[0], declaration, root, bindingIndex)) found = node.arguments[0]
+    if (!found) ts.forEachChild(node, visit)
+  }
+  visit(root)
+  return found
+}
+
+function directIdentifierCall(identifier) {
+  return ts.isCallExpression(identifier.parent) && identifier.parent.expression === identifier && !identifier.parent.questionDotToken
+}
+
+function dynamic(identifier) {
+  if (ts.isCallExpression(identifier.parent) && identifier.parent.expression === identifier) return Boolean(identifier.parent.questionDotToken)
+  for (let current = identifier.parent; current && !ts.isStatement(current); current = current.parent) if (ts.isCallExpression(current)) return true
+  return false
+}
+
+function mutated(identifier) {
+  const parent = identifier.parent
+  return ts.isPrefixUnaryExpression(parent) && [ts.SyntaxKind.PlusPlusToken, ts.SyntaxKind.MinusMinusToken].includes(parent.operator) || ts.isPostfixUnaryExpression(parent) || ts.isBinaryExpression(parent) && parent.left === identifier && parent.operatorToken.kind >= ts.SyntaxKind.FirstAssignment && parent.operatorToken.kind <= ts.SyntaxKind.LastAssignment
+}
+
+function inside(node, root) {
+  for (let current = node; current; current = current.parent) if (current === root) return true
+  return false
+}
+
+function fail(node, message) {
+  throw sourceNodeError(node, node.getSourceFile(), message)
 }
 
 function primitiveValue(node) {