@kudzujs/core 0.8.15 → 0.8.16

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,222 @@
+import ts from "typescript"
+import { bindingNames, isFunctionLike, isReferenceIdentifier, isShadowedByParameter, isShadowedIdentifier, unwrapExpression } from "./ast-helpers.mjs"
+
+export function createSemanticArtifact() {
+  return { nativeHandlers: [], effectHandlers: [], reactiveBindings: [], listExpressions: [], clientImports: new Set() }
+}
+
+export function createDescriptorSession({ semantic, handlerUrl, factory, context, compileEventCommand, isPrimitiveLiteral, rejectWorkerConstructions }) {
+  const { nativeHandlers, effectHandlers, reactiveBindings, listExpressions, clientImports } = semantic
+
+  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, factory) : undefined)
+    if (!commands.length || commands.some(command => !command)) return undefined
+    return factory.createCallExpression(factory.createIdentifier("__kBehavior"), undefined, [factory.createArrayLiteralExpression(commands)])
+  }
+
+  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/event-command-pass.mjs

@@ -0,0 +1,35 @@
+import ts from "typescript"
+
+export function createEventCommandCompiler({ isPrimitiveLiteral, synthesizeSerializableStateLiteral }) {
+  return function compileEventCommand(expression, setters, factory) {
+    if (ts.isCallExpression(expression) && ts.isPropertyAccessExpression(expression.expression) && ts.isIdentifier(expression.expression.expression) && expression.expression.expression.text === "console" && expression.expression.name.text === "log" && expression.arguments.length === 2 && ts.isStringLiteral(expression.arguments[0]) && ts.isIdentifier(expression.arguments[1]) && [...setters.values()].includes(expression.arguments[1].text)) {
+      return command(factory, "log", expression.arguments[1], factory.createStringLiteral(expression.arguments[0].text))
+    }
+
+    if (!ts.isCallExpression(expression) || !ts.isIdentifier(expression.expression) || expression.arguments.length !== 1) return undefined
+    const stateName = setters.get(expression.expression.text)
+    if (!stateName) return undefined
+
+    const state = factory.createIdentifier(stateName)
+    const value = expression.arguments[0]
+    if (ts.isBinaryExpression(value) && ts.isIdentifier(value.left) && value.left.text === stateName && ts.isNumericLiteral(value.right)) {
+      if (value.operatorToken.kind !== ts.SyntaxKind.PlusToken && value.operatorToken.kind !== ts.SyntaxKind.MinusToken) return undefined
+      return command(factory, "add", state, numericExpression(factory, Number(value.right.text), value.operatorToken.kind === ts.SyntaxKind.MinusToken))
+    }
+    if (ts.isArrowFunction(value) && value.parameters.length === 1 && ts.isIdentifier(value.parameters[0].name) && ts.isBinaryExpression(value.body) && ts.isIdentifier(value.body.left) && value.body.left.text === value.parameters[0].name.text && ts.isNumericLiteral(value.body.right)) {
+      if (value.body.operatorToken.kind !== ts.SyntaxKind.PlusToken && value.body.operatorToken.kind !== ts.SyntaxKind.MinusToken) return undefined
+      return command(factory, "add", state, numericExpression(factory, Number(value.body.right.text), value.body.operatorToken.kind === ts.SyntaxKind.MinusToken))
+    }
+    if (isPrimitiveLiteral(value)) return command(factory, "set", state, synthesizeSerializableStateLiteral(value, factory))
+    return undefined
+  }
+}
+
+function command(factory, operation, state, value) {
+  return factory.createArrayLiteralExpression([factory.createStringLiteral(operation), state, value])
+}
+
+function numericExpression(factory, value, negative) {
+  const literal = factory.createNumericLiteral(value)
+  return negative ? factory.createPrefixUnaryExpression(ts.SyntaxKind.MinusToken, literal) : literal
+}

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

package/framework/compiler/route-capability-planner.mjs

@@ -0,0 +1,118 @@
+export function usesRouteDependencyRuntime({ plan, navigable, hasBindings, hasLists }) {
+  const hasDependencies = plan.effects.some(effect => effect.dependencies?.length)
+  return !navigable && hasDependencies && !plan.effects.some(effect => effect.owner) && !hasBindings && !hasLists && !plan.events.some(event => event.native)
+}
+
+export function planRouteCapabilities(plans, { routes = new Map(), navigationRouteCount = 0 } = {}) {
+  const commandEvents = new Set()
+  const nativeEvents = new Set()
+  const bindings = { count: 0, text: false, svgConditions: false }
+  const lists = {
+    count: 0,
+    styleCount: 0,
+    conditions: false,
+    svg: false,
+    deepConditions: false,
+    textRanges: false,
+    attributes: false,
+    events: false,
+    expressions: false,
+    expressionAttributes: false,
+    seeds: false,
+    effects: false,
+    rowHooks: false,
+    rowRefs: false,
+    complexRowState: false,
+    nested: false,
+    selectors: false,
+    calculated: false,
+    static: false,
+    indexes: false,
+    stableFastPaths: false,
+    generalRowHooks: false,
+    asyncParts: false,
+    mounts: false
+  }
+  const effects = { any: false, derivedDependencies: false, itemDependencies: false, captures: false, navigable: false, navigableOwners: false }
+
+  for (let index = 0; index < plans.length; index++) {
+    const plan = plans[index]
+    const route = routes.get(plan.route)
+    for (const event of plan.events) {
+      if (event.commands) commandEvents.add(event.event)
+      if (event.native) nativeEvents.add(event.event)
+    }
+    bindings.text ||= plan.bindings.some(binding => binding.target === "text")
+    bindings.svgConditions ||= plan.conditions.some(condition => condition.svg)
+    effects.any ||= plan.effects.length > 0
+    effects.derivedDependencies ||= plan.effects.some(effect => effect.dependencyExpressions?.length)
+    effects.itemDependencies ||= plan.effects.some(effect => effect.itemDependencies?.length)
+    effects.captures ||= plan.effects.some(effect => Object.keys(effect.scope).length)
+    effects.navigable ||= Boolean(route?.navigable && plan.effects.length)
+    effects.navigableOwners ||= Boolean(route?.navigable && plan.effects.some(effect => effect.owner))
+    for (const list of plan.lists) {
+      lists.conditions ||= Boolean(list.conditions)
+      lists.svg ||= Boolean(list.svg)
+      lists.deepConditions ||= Boolean(list.conditionHandlers)
+      lists.textRanges ||= Boolean(list.textRanges)
+      lists.attributes ||= Boolean(list.attributes)
+      lists.events ||= Boolean(list.events)
+      lists.expressions ||= Boolean(list.expressions)
+      lists.expressionAttributes ||= Boolean(list.expressionAttributes)
+      lists.seeds ||= Boolean(list.seed || list.valueSeed)
+      lists.effects ||= Boolean(list.effects)
+      lists.rowHooks ||= Boolean(list.rowStates?.length || list.rowRefs?.length)
+      lists.rowRefs ||= Boolean(list.rowRefs?.length)
+      lists.complexRowState ||= Boolean(list.rowStates?.some(state => state.initialValue !== null && typeof state.initialValue === "object"))
+      lists.nested ||= Boolean(list.ownerField)
+      lists.selectors ||= Boolean(list.selector)
+      lists.calculated ||= Boolean(list.source)
+      lists.static ||= Boolean(list.static)
+      lists.indexes ||= Boolean(list.indexed)
+      lists.stableFastPaths ||= !list.children && !list.ownerField && list.key !== null && !list.indexed && !list.reducer && !list.selector
+      lists.generalRowHooks ||= Boolean(list.ownerField && (list.rowStates?.length || list.rowRefs?.length))
+      lists.mounts ||= Boolean(list.mount)
+    }
+  }
+
+  const routeEntries = [...routes.values()]
+  const routeCounts = {
+    behaviors: routeEntries.filter(route => route.hasBehaviors).length,
+    regularBehaviors: routeEntries.filter(route => route.hasBehaviors && !route.usesDependencyRuntime).length,
+    regularStateSeeds: routeEntries.filter(route => route.hasStateSeed && !route.usesDependencyRuntime).length,
+    dependencyStateSeeds: routeEntries.filter(route => route.hasStateSeed && route.usesDependencyRuntime).length
+  }
+  bindings.count = routeEntries.filter(route => route.hasBindings).length
+  lists.count = routeEntries.filter(route => route.hasLists).length
+  lists.styleCount = routeEntries.filter(route => route.hasListStyles).length
+  lists.generalRowHooks ||= lists.rowRefs || lists.complexRowState
+  lists.asyncParts = lists.expressions || lists.expressionAttributes || lists.conditions
+  lists.mounts ||= lists.conditions || lists.nested
+
+  return {
+    routes: routeCounts,
+    events: { command: [...commandEvents].sort(), native: [...nativeEvents].sort(), hasNativeHandlers: nativeEvents.size > 0 },
+    bindings,
+    lists,
+    effects,
+    captures: { nestedState: hasNestedCaptureState(plans), setter: hasCaptureType(plans, "setter") },
+    runtime: {
+      shared: Boolean(bindings.count || lists.count || nativeEvents.size || navigationRouteCount),
+      dependency: routeEntries.some(route => route.usesDependencyRuntime)
+    }
+  }
+}
+
+function hasCaptureType(value, type) {
+  if (!value || typeof value !== "object") return false
+  if (value.type === type) return true
+  return (Array.isArray(value) ? value : Object.values(value)).some(entry => hasCaptureType(entry, type))
+}
+
+function hasNestedCaptureState(value, insideCapture = false) {
+  if (!value || typeof value !== "object") return false
+  if (value.type === "state") return insideCapture
+  if (value.type === "array") return value.value.some(entry => hasNestedCaptureState(entry, true))
+  if (value.type === "object") return value.value.some(([, entry]) => hasNestedCaptureState(entry, true))
+  return (Array.isArray(value) ? value : Object.values(value)).some(entry => hasNestedCaptureState(entry, false))
+}