@kudzujs/core 0.8.15 → 0.8.17

package/framework/compiler/codegen/command-codegen.mjs

@@ -0,0 +1,20 @@
+import ts from "typescript"
+
+export function generateCommandBehavior(moduleIR, handler, factory = ts.factory) {
+  const commands = handler.commands.map(command => factory.createArrayLiteralExpression([
+    factory.createStringLiteral(command.operation),
+    factory.createIdentifier(moduleIR.signals[command.signal].debugName),
+    literal(factory, command.value, command.syntax)
+  ]))
+  return factory.createCallExpression(factory.createIdentifier("__kBehavior"), undefined, [factory.createArrayLiteralExpression(commands)])
+}
+
+function literal(factory, value, syntax) {
+  if (value === null) return factory.createNull()
+  if (typeof value === "string") return factory.createStringLiteral(value)
+  if (typeof value === "boolean") return value ? factory.createTrue() : factory.createFalse()
+  const number = factory.createNumericLiteral(Math.abs(value))
+  if (syntax === "positive") return factory.createPrefixUnaryExpression(ts.SyntaxKind.PlusToken, number)
+  if (syntax === "negative") return factory.createPrefixUnaryExpression(ts.SyntaxKind.MinusToken, number)
+  return value < 0 ? factory.createPrefixUnaryExpression(ts.SyntaxKind.MinusToken, number) : number
+}

package/framework/compiler/collection-analysis.mjs

@@ -0,0 +1,187 @@
+import ts from "typescript"
+import { nearestFunction, unwrapExpression } from "./ast-helpers.mjs"
+
+export const pureCollectionMethods = 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"])
+export const mutatingCollectionMethods = new Set(["copyWithin", "fill", "pop", "push", "reverse", "shift", "sort", "splice", "unshift"])
+export const pureCollectionMathMethods = new Set(["abs", "ceil", "floor", "max", "min", "pow", "round", "sign", "sqrt", "trunc"])
+
+export 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"
+}
+
+export 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 }
+}
+
+export function analyzeCollectionPipeline(expression, options) {
+  const {
+    setters = new Map(),
+    declarations,
+    fail,
+    aliases = new Set(),
+    importedCollections = new Set(),
+    stateNames = new Set(),
+    importedCollectionTransforms = new Map(),
+    calculatedCollection,
+    staticCollection
+  } = options
+  const nestedOptions = { setters, declarations, fail, aliases, importedCollections, stateNames, importedCollectionTransforms, 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 = analyzeCollectionPipeline(entries[0].initializer, nestedOptions)
+    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 = analyzeCollectionPipeline(returned, { setters: new Map([[parameter.name.text, parameter.name.text]]), fail, stateNames: 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 = analyzeCollectionPipeline(value.arguments[0], nestedOptions)
+    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 = analyzeCollectionPipeline(value.expression.expression, nestedOptions)
+      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 = analyzeCollectionPipeline(value.expression.expression, nestedOptions)
+      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 = analyzeCollectionPipeline(value.expression.expression, nestedOptions)
+      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 = analyzeCollectionPipeline(value.expression.expression, nestedOptions)
+      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 encoded = collectionExpression(comparator.body, { parameters, fail, stateNames, selectorStates })
+      return { ...source, selector: [...source.selector, ["sort", encoded]], 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 = analyzeCollectionPipeline(value.arguments[0], nestedOptions)
+    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]] }
+  }
+}
+
+export 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" && pureCollectionMathMethods.has(method)) return ["math", method, ...node.arguments.map(encode)]
+        if (pureCollectionMethods.has(method)) return ["call", encode(node.expression.expression), method, ...node.arguments.map(encode)]
+        if (mutatingCollectionMethods.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 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
+}

package/framework/compiler/descriptor-session.mjs

@@ -0,0 +1,231 @@
+import ts from "typescript"
+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"
+
+export function createSemanticArtifact(file) {
+  return { moduleIR: createModuleIR(file), nativeHandlers: [], effectHandlers: [], reactiveBindings: [], listExpressions: [], clientImports: new Set() }
+}
+
+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
+
+  function compileListExpression(read, expression, item, 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) {
+    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) {
+    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, entry.index, entry.states)
+  }
+
+  function compileReactiveBinding(expression, { setters, importBindings = new Map() }) {
+    const parts = conditionalParts(expression)
+    const state = parts && directStateIdentifier(parts.condition, setters)
+    if (state && isPrimitiveLiteral(parts.truthy) && isPrimitiveLiteral(parts.falsy)) {
+      return factory.createCallExpression(factory.createIdentifier("__kSelect"), undefined, [state, parts.truthy, parts.falsy])
+    }
+    return factory.createCallExpression(factory.createIdentifier("__kBinding"), undefined, compileReactiveExpression(expression, setters, importBindings))
+  }
+
+  function compileConditional(kind, expression, truthy, falsy, setters) {
+    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)
+    return factory.createCallExpression(factory.createIdentifier("__kConditional"), undefined, [factory.createStringLiteral(kind), initial, thunk(truthy), thunk(falsy), ...descriptor])
+  }
+
+  function compileReactiveExpression(expression, setters, importBindings = new Map()) {
+    const usedStates = referencedStateNames(expression, setters)
+    const importedNames = referencedImportedBindings(expression, importBindings)
+    const imports = [...importedNames].map(name => importBindings.get(name))
+    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 })
+    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 compileEvent(expression, { 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)
+    if (optimized) return optimized
+    rejectWorkerConstructions(expression)
+    const descriptor = compileNativeCallback(expression, { setters, reducers, entries: nativeHandlers, importBindings, prefix: "handler", 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" })
+  }
+
+  function compileNativeCallback(expression, { setters, reducers, entries, importBindings, 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)))
+    registerClientImports(imports)
+    const usedStates = referencedStateNames(expression.body, setters, expression)
+    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 compileOptimizedEvent(expression, setters) {
+    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)
+    return generateCommandBehavior(moduleIR, handler, factory)
+  }
+
+  function registerClientImports(imports) {
+    for (const entry of imports) if (!entry.package) clientImports.add(entry.target)
+  }
+
+  return { compileConditional, compileEffectCallback, compileEvent, compileListConditional, compileListValue, compileReactiveBinding }
+}
+
+function directStateIdentifier(expression, setters) {
+  const value = unwrapExpression(expression)
+  return ts.isIdentifier(value) && new Set(setters.values()).has(value.text) ? value : undefined
+}
+
+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 { condition: value.left, truthy: unwrap(value.right), falsy: ts.factory.createNull() }
+  if (ts.isConditionalExpression(value)) return { condition: value.condition, truthy: unwrap(value.whenTrue), falsy: unwrap(value.whenFalse) }
+  return undefined
+}
+
+export 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
+}
+
+export 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
+}
+
+export function nativeCaptureNames(expression, setters) {
+  return captureNames(expression, expression.body, setters)
+}
+
+function referencedImportedBindings(expression, imports) {
+  const names = new Set()
+  const visit = node => {
+    if (ts.isIdentifier(node) && imports.has(node.text) && isReferenceIdentifier(node)) names.add(node.text)
+    ts.forEachChild(node, visit)
+  }
+  visit(expression.body ?? expression)
+  return names
+}
+
+export 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 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)
+    }
+    ts.forEachChild(node, visit)
+  }
+  visit(referenceRoot)
+  return captures
+}
+
+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"
+])

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

@@ -0,0 +1,23 @@
+export function createModuleIR(file) {
+  return { version: 1, file, signals: [], handlers: [] }
+}
+
+export function registerCommandHandler(moduleIR, commands, source, scope = "module") {
+  const slots = new Map(moduleIR.signals.map(signal => [signal.key, signal.slot]))
+  for (const { state } of commands) {
+    const key = `${scope}:${state}`
+    if (slots.has(key)) continue
+    const slot = moduleIR.signals.length
+    slots.set(key, slot)
+    moduleIR.signals.push({ slot, key, debugName: state })
+  }
+  const signal = state => slots.get(`${scope}:${state}`) ?? slots.get(state)
+  const handler = {
+    slot: moduleIR.handlers.length,
+    kind: "commands",
+    commands: commands.map(({ operation, state, value, syntax }) => ({ operation, signal: signal(state), value, ...(syntax ? { syntax } : {}) })),
+    ...(source ? { source } : {})
+  }
+  moduleIR.handlers.push(handler)
+  return handler
+}

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

@@ -0,0 +1,46 @@
+import ts from "typescript"
+
+export function createCommandSpecializer({ isPrimitiveLiteral }) {
+  return function specializeCommand(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 (isPrimitiveLiteral(value)) {
+      const literal = primitiveValue(value)
+      return literal ? { operation: "set", state, ...literal } : undefined
+    }
+    return undefined
+  }
+}
+
+function primitiveValue(node) {
+  if (ts.isStringLiteral(node)) return { value: node.text }
+  if (ts.isNumericLiteral(node)) return signedNumber(node)
+  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 }
+  return signedNumber(node.operand, node.operator === ts.SyntaxKind.MinusToken ? "negative" : "positive")
+}
+
+function signedNumber(node, syntax) {
+  const number = Number(node.text)
+  if (!Number.isFinite(number)) return undefined
+  if (syntax === "negative") return number === 0 ? { value: 0, syntax } : { value: -number }
+  return syntax ? { value: number, syntax } : { value: number }
+}

package/framework/compiler/react-migration-pass.mjs

@@ -1,7 +1,8 @@
 import ts from "typescript"
 import { bindingNames, importDeclarationNames, isFunctionLike, isLocalConst, isReferenceIdentifier, isShadowedByParameter, isShadowedIdentifier, loopDeclaresName, nearestFunction, nearestFunctionLike, referenceIdentifiers, sourceNodeError, statementDeclaresName, unwrapExpression } from "./ast-helpers.mjs"
+import { analyzeCollectionPipeline, isArrayFromCall } from "./collection-analysis.mjs"
 
-export function createReactMigrationPass({ cloneAst, isArrayFromCall, jsxTagName, renderedCollectionSource }) {
+export function createReactMigrationPass({ cloneAst, jsxTagName }) {
   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"])
@@ -291,7 +292,7 @@ export function createReactMigrationPass({ cloneAst, isArrayFromCall, jsxTagName
   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)
+    return analyzeCollectionPipeline(expression, { setters, fail, importedCollections, stateNames: states })
   }
 
   function reactMemoComponentExpression(identifier, sourceFile, factory, context) {