@kudzujs/core 0.8.14 → 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/custom-hook-timer-pass.mjs

@@ -0,0 +1,126 @@
+import { createHash } from "node:crypto"
+import ts from "typescript"
+import { effectReturns, nearestFunction, referencesIdentifier, sourceNodeError, unwrapExpression } from "./ast-helpers.mjs"
+
+const customHookTimerStatePrefix = "__kTimerState_"
+const customHookTimerSetterPrefix = "__kSetTimerState_"
+
+export function normalizeCustomHookTimerRefs(sourceFile, factory, context) {
+    const timerCall = (node, name) => ts.isCallExpression(node) && (
+      ts.isIdentifier(node.expression) && node.expression.text === name ||
+      ts.isPropertyAccessExpression(node.expression) && ts.isIdentifier(node.expression.expression) && node.expression.expression.text === "window" && node.expression.name.text === name
+    )
+    const currentAccess = (node, name) => ts.isPropertyAccessExpression(node) && ts.isIdentifier(node.expression) && node.expression.text === name && node.name.text === "current"
+    const clearStatement = (node, name) => {
+      if (!ts.isIfStatement(node) || node.elseStatement || !currentAccess(unwrapExpression(node.expression), name)) return undefined
+      const statement = ts.isBlock(node.thenStatement) && node.thenStatement.statements.length === 1 ? node.thenStatement.statements[0] : node.thenStatement
+      if (!ts.isExpressionStatement(statement) || !timerCall(statement.expression, "clearTimeout") || statement.expression.arguments.length !== 1 || !currentAccess(unwrapExpression(statement.expression.arguments[0]), name)) return undefined
+      return { condition: unwrapExpression(node.expression), argument: unwrapExpression(statement.expression.arguments[0]) }
+    }
+    const analyze = (hook, hookName) => {
+      if (!/^use[A-Z]/.test(hookName) || hook.parameters.length || !hook.body || !ts.isBlock(hook.body)) return undefined
+      const returnedStatement = hook.body.statements.at(-1)
+      const returned = returnedStatement && ts.isReturnStatement(returnedStatement) && returnedStatement.expression ? unwrapExpression(returnedStatement.expression) : undefined
+      if (!returned || !ts.isObjectLiteralExpression(returned)) return undefined
+      const returnedNames = new Set(returned.properties.filter(ts.isShorthandPropertyAssignment).map(property => property.name.text))
+      const callbacks = new Map()
+      const refs = []
+      for (const statement of hook.body.statements) {
+        if (!ts.isVariableStatement(statement) || !(statement.declarationList.flags & ts.NodeFlags.Const)) continue
+        for (const declaration of statement.declarationList.declarations) {
+          if (ts.isIdentifier(declaration.name) && declaration.initializer && (ts.isArrowFunction(declaration.initializer) || ts.isFunctionExpression(declaration.initializer))) callbacks.set(declaration.name.text, declaration.initializer)
+          if (ts.isIdentifier(declaration.name) && declaration.initializer && ts.isCallExpression(declaration.initializer) && ts.isIdentifier(declaration.initializer.expression) && declaration.initializer.expression.text === "useRef" && declaration.initializer.arguments.length === 1 && declaration.initializer.arguments[0].kind === ts.SyntaxKind.NullKeyword) refs.push({ declaration, name: declaration.name.text })
+        }
+      }
+      const candidates = []
+      for (const ref of refs) {
+        const assignments = []
+        const accesses = []
+        const clearStatements = []
+        const collect = node => {
+          if (currentAccess(node, ref.name)) accesses.push(node)
+          if (ts.isBinaryExpression(node) && node.operatorToken.kind === ts.SyntaxKind.EqualsToken && currentAccess(unwrapExpression(node.left), ref.name)) assignments.push(node)
+          const clear = clearStatement(node, ref.name)
+          if (clear) clearStatements.push({ node, ...clear })
+          ts.forEachChild(node, collect)
+        }
+        collect(hook.body)
+        if (assignments.some(assignment => timerCall(unwrapExpression(assignment.right), "setTimeout"))) candidates.push({ ...ref, assignments, accesses, clearStatements })
+      }
+      if (!candidates.length) return undefined
+      if (candidates.length !== 1) throw sourceNodeError(hook, sourceFile, "Relative custom hooks may own only one private timeout ref")
+      const timer = candidates[0]
+      if (timer.assignments.length !== 1) throw sourceNodeError(timer.declaration, sourceFile, "Private timeout refs require one direct timer.current = setTimeout(...) assignment")
+      const assignment = timer.assignments[0]
+      const timeout = unwrapExpression(assignment.right)
+      const timeoutCallback = timeout.arguments[0]
+      const delay = timeout.arguments[1]
+      if (!timerCall(timeout, "setTimeout") || timeout.arguments.length !== 2 || !timeoutCallback || !(ts.isArrowFunction(timeoutCallback) || ts.isFunctionExpression(timeoutCallback)) || timeoutCallback.parameters.length || !delay || !ts.isNumericLiteral(unwrapExpression(delay))) throw sourceNodeError(assignment, sourceFile, "Private timeout refs require setTimeout() with one zero-argument callback and a numeric literal delay")
+      const callback = nearestFunction(assignment)
+      const callbackName = [...callbacks].find(([, value]) => value === callback)?.[0]
+      if (!callbackName || !returnedNames.has(callbackName) || !ts.isBlock(callback.body) || !ts.isExpressionStatement(assignment.parent) || assignment.parent.parent !== callback.body) throw sourceNodeError(assignment, sourceFile, "Private timeout refs must be assigned directly inside one returned custom-hook callback")
+      const callbackClear = timer.clearStatements.find(entry => nearestFunction(entry.node) === callback)
+      if (!callbackClear || callbackClear.node.parent !== callback.body || callback.body.statements.indexOf(callbackClear.node) >= callback.body.statements.indexOf(assignment.parent)) throw sourceNodeError(callback, sourceFile, "Private timeout callbacks must directly clear the previous timer before assigning its replacement")
+      const effectCalls = hook.body.statements.flatMap(statement => {
+        if (!ts.isExpressionStatement(statement) || !ts.isCallExpression(statement.expression) || !ts.isIdentifier(statement.expression.expression) || statement.expression.expression.text !== "useEffect") return []
+        return [statement.expression]
+      })
+      let cleanupClear
+      for (const effect of effectCalls) {
+        const [setup, dependencies] = effect.arguments
+        if (!(ts.isArrowFunction(setup) || ts.isFunctionExpression(setup)) || !ts.isArrayLiteralExpression(dependencies) || dependencies.elements.length) continue
+        const returns = effectReturns(setup)
+        if (returns.cleanups.length !== 1) continue
+        const cleanup = returns.cleanups[0]
+        const entry = timer.clearStatements.find(candidate => nearestFunction(candidate.node) === cleanup)
+        if (entry && ts.isBlock(cleanup.body) && cleanup.body.statements.length === 1 && cleanup.body.statements[0] === entry.node) cleanupClear = entry
+      }
+      if (!cleanupClear) throw sourceNodeError(timer.declaration, sourceFile, "Private timeout refs require one empty-dependency effect that directly clears the timer on cleanup")
+      const accepted = new Set([assignment.left, callbackClear.condition, callbackClear.argument, cleanupClear.condition, cleanupClear.argument].map(unwrapExpression))
+      const unsupported = timer.accesses.find(access => !accepted.has(access))
+      if (unsupported) throw sourceNodeError(unsupported, sourceFile, "Private timeout refs may only be read by their direct replacement and cleanup guards")
+      const identity = createHash("sha256").update(`${sourceFile.fileName}:${hook.pos}:${timer.name}`).digest("hex").slice(0, 10)
+      const stateName = `${customHookTimerStatePrefix}${identity}`
+      const setterName = `${customHookTimerSetterPrefix}${identity}`
+      if (referencesIdentifier(hook.body, stateName) || referencesIdentifier(hook.body, setterName)) throw sourceNodeError(timer.declaration, sourceFile, "Private timeout ref conflicts with compiler-owned bindings")
+      return { assignment, declaration: timer.declaration, refName: timer.name, returned, stateName, setterName }
+    }
+    const timerStates = new Set()
+    const transform = (hook, hookName) => {
+      const timer = analyze(hook, hookName)
+      if (!timer) return undefined
+      timerStates.add(timer.stateName)
+      const timerVisitor = current => {
+        if (current === timer.declaration) {
+          const binding = factory.createArrayBindingPattern([
+            factory.createBindingElement(undefined, undefined, timer.stateName),
+            factory.createBindingElement(undefined, undefined, timer.setterName)
+          ])
+          const initializer = factory.updateCallExpression(current.initializer, factory.createIdentifier("useState"), current.initializer.typeArguments, current.initializer.arguments)
+          return factory.updateVariableDeclaration(current, binding, current.exclamationToken, undefined, initializer)
+        }
+        if (current === timer.assignment) return factory.createCallExpression(factory.createIdentifier(timer.setterName), undefined, [ts.visitNode(current.right, timerVisitor)])
+        if (currentAccess(current, timer.refName)) return factory.createIdentifier(timer.stateName)
+        if (current === timer.returned) return factory.updateObjectLiteralExpression(current, [
+          ...current.properties,
+          factory.createShorthandPropertyAssignment(timer.stateName),
+          factory.createShorthandPropertyAssignment(timer.setterName)
+        ])
+        return ts.visitEachChild(current, timerVisitor, context)
+      }
+      return ts.visitEachChild(hook, timerVisitor, context)
+    }
+    const visitor = node => {
+      if (ts.isFunctionDeclaration(node)) {
+        const hookName = node.name?.text ?? (node.modifiers?.some(modifier => modifier.kind === ts.SyntaxKind.DefaultKeyword) ? "useDefault" : "")
+        const transformed = transform(node, hookName)
+        if (transformed) return transformed
+      }
+      if (ts.isVariableDeclaration(node) && ts.isIdentifier(node.name) && node.initializer && (ts.isArrowFunction(node.initializer) || ts.isFunctionExpression(node.initializer))) {
+        const transformed = transform(node.initializer, node.name.text)
+        if (transformed) return factory.updateVariableDeclaration(node, node.name, node.exclamationToken, node.type, transformed)
+      }
+      return ts.visitEachChild(node, visitor, context)
+    }
+    return { sourceFile: ts.visitNode(sourceFile, visitor), timerStates }
+}

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"
+])