@kudzujs/core 0.8.16 → 0.8.17

package/MIGRATION_ROADMAP.md

@@ -195,6 +195,13 @@ This queue orders the next investigations by general migration value. Start only
 - Component specialization, effect analysis, and keyed-list ownership remain in the main transformer until their AST-identity side tables can be replaced by explicit analysis results rather than moved behind large context objects.
 - The continuation packet under `docs/next-architecture` fixes the Goal A patch sequence, output/performance gates, and explicit decision boundaries for deferred optimization, state/resource research, routing, and React compatibility.
 
+### Completed In 0.8.17
+
+- Supported command handlers cross the first JSON-safe ModuleIR slice: analysis emits plain command data, ModuleIR owns numeric signal/handler slots and lexical/source metadata, and focused codegen restores the existing `__kBehavior()` build ABI.
+- Primitive SET, numeric ADD/subtract, functional setters, state logging, unary-plus, and negative-zero semantics remain specialized; non-finite values safely retain generic handler lowering.
+- Same-named state in separate owners no longer aliases in IR, shared setter environments reuse signal identity, and synthetic specialized callbacks receive no fabricated source position.
+- For unchanged source input, Counter HTML, route plans, command runtime, and generated artifacts remain byte-identical to 0.8.16; no browser capability or source syntax changed.
+
 ## Cross-Cutting Performance Gates
 
 Every migration feature must preserve:

package/PERFORMANCE.md

@@ -1,5 +1,23 @@
 # Performance Records
 
+## 0.8.17 Command ModuleIR
+
+Measured UTC 2026-08-08 on Apple M3, 8 logical CPUs, 8 GiB RAM, macOS 26.5.2 / Darwin 25.5.0, Node 25.6.1, and npm 11.18.0. Baseline `0.8.16` tag `98a4ad9` and the `0.8.17` release candidate used detached worktrees on the same temporary volume with identical installed dependencies.
+
+Both targets received two warm-ups followed by 21 clean `worker-effects` production builds in round-robin alternating order. Cleanup remained outside timing. The distributions overlap; the 1.76% candidate median difference remains below the 5% architecture gate and does not establish a material regression.
+
+| Target | Build median | Worker raw / gzip | Window raw / gzip |
+|---|---:|---:|---:|
+| 0.8.16 baseline | 782.0 ms | 907 B / 475 B | 12,148 B / 5,427 B |
+| 0.8.17 candidate | 795.8 ms | 907 B / 475 B | 12,148 B / 5,427 B |
+
+```text
+0.8.16: [775.9,787.9,846.8,702.3,782.0,712.5,665.1,702.9,835.0,743.2,780.6,931.7,894.1,1004.0,849.8,1031.1,829.7,768.8,718.5,842.9,763.0]
+0.8.17: [696.0,721.9,778.8,850.4,846.1,835.2,710.4,711.6,836.1,766.9,822.6,945.0,838.2,991.5,858.6,803.4,706.3,760.8,773.8,764.3,795.8]
+```
+
+Before release-content updates, the unchanged source site, Counter build module, route plan, and command runtime were byte-identical. The final Worker and window graphs remain byte-identical. This measurement covers compiler clean-build startup and artifact size, not browser interaction latency or cross-framework performance.
+
 ## 0.8.16 Compiler Analysis Boundaries
 
 Measured UTC 2026-08-08 on Apple M3, 8 logical CPUs, 8 GiB RAM, macOS 26.5.2 / Darwin 25.5.0, Node 25.6.1, and npm 11.18.0. Baseline `0.8.15` commit `8405d29` and the `0.8.16` release candidate used detached worktrees on the same temporary volume with identical installed dependencies.

package/README.md

@@ -14,7 +14,7 @@ Kudzu compiles ordinary React-shaped TypeScript and TSX into complete static HTM
 
 > Experimental `0.8.x`: the compiler API and supported TSX surface may change.
 
-**Latest release: 0.8.16 - Compiler analysis boundaries.** Per-source descriptors, pure collection analysis, command specialization, Zustand migration, and route capability planning now have focused compiler ownership while preserving generated output and runtime behavior. Read the [release notes](./RELEASES.md#0816---compiler-analysis-boundaries), open the [release page](https://kudzujs.cloud/releases/0.8.16), or follow the [next architecture packet](./docs/next-architecture/README.md).
+**Latest release: 0.8.17 - Command ModuleIR.** Supported command handlers now cross a real JSON-safe ModuleIR boundary before existing source codegen, preserving byte-identical HTML, route plans, and browser assets. Read the [release notes](./RELEASES.md#0817---command-moduleir), open the [release page](https://kudzujs.cloud/releases/0.8.17), or follow the [next architecture packet](./docs/next-architecture/README.md).
 
 - [Documentation](https://kudzujs.cloud/docs)
 - [Installation guide](https://kudzujs.cloud/docs#install)

package/RELEASES.md

@@ -1,5 +1,37 @@
 # Kudzu Releases
 
+## 0.8.17 - Command ModuleIR
+
+Kudzu 0.8.17 lands the first real Goal A vertical slice: supported command handlers are recognized as plain JSON-safe data, registered in a sparse per-source ModuleIR, and lowered back through focused source codegen without changing deploy output.
+
+### Changed in 0.8.17
+
+- Direct setter arithmetic, functional setter arithmetic, primitive setter values, and state logging now produce plain Command IR instead of generated TypeScript array nodes during analysis.
+- ModuleIR assigns deterministic numeric signal and handler slots while retaining readable state names, lexical state-owner keys, and original source ranges when they exist.
+- Command codegen consumes only ModuleIR signal and handler data to reconstruct the existing `__kBehavior()` call; it performs no source analysis.
+- Signed literals preserve unary-plus and negative-zero source semantics through JSON-safe syntax metadata. Non-finite numeric forms stay on the existing generic handler path.
+- Same-named states in independent component owners receive distinct IR slots, while nested handlers sharing one setter environment reuse the same signal identity.
+- Synthetic specialized handlers omit invented source positions; imported/original handlers retain normalized repository-relative source provenance.
+
+### Goal A boundary
+
+- The first active ModuleIR slice contains lexical signals and command handlers only. `core.mjs` remains authoritative for initial values, final route/layout state IDs, complete HTML, and the serializable route plan.
+- State/props/ref/component specialization is the planned `0.8.18` seam. Bindings, derived values, keyed blocks, and effects remain on their existing paths until their own explicit results replace AST side tables.
+- No VDOM, hydration, component rerender, runtime component tree, public API, or accepted syntax was added.
+
+### Validation
+
+- The complete suite passes 166/166 tests, including JSON round-trip, numeric edge, lexical owner, command codegen, specialized-component, and existing generic-handler contracts.
+- Before release-content updates, the unchanged source site `dist`, Counter build module, route plan, and command runtime were byte-identical to `v0.8.16`; the final release adds only its expected version, homepage, documentation, and release-page content.
+- The tracked Worker and window graphs remain byte-identical. A same-volume 21-run comparison found no build regression; raw arrays and environment are recorded in `PERFORMANCE.md`.
+- `create-kudzu` remains 0.1.101 because its unchanged template already accepts `@kudzujs/core@^0.8.15`.
+
+### Upgrade
+
+```bash
+npm install @kudzujs/core@^0.8.17
+```
+
 ## 0.8.16 - Compiler analysis boundaries
 
 Kudzu 0.8.16 continues the behavior-preserving compiler decomposition: source-local descriptors, the pure collection language, command fast paths, reduced Zustand migration, and route capability projection now have explicit ownership outside build orchestration.

package/docs/next-architecture/README.md

@@ -6,7 +6,7 @@ The top-level [`GOAL_A.md`](../../GOAL_A.md) and [`GOAL_B.md`](../../GOAL_B.md)
 
 | Goal | Decision | Start condition |
 |---|---|---|
-| A: compiler foundation | Approved for execution | Continue with `0.8.17` after the `0.8.16` analysis-boundary release |
+| A: compiler foundation | `0.8.17` command slice complete | Continue with `0.8.18` state/props/component analysis after the release boundary. |
 | B: optimization benchmarks | Deferred | Goal A complete and its output baseline recorded |
 | C: state/resource model | Research only | Reduced fixtures expose a limitation |
 | D: routing compatibility | Current behavior preserved | Revisit only with migration evidence and invariant review |

package/docs/next-architecture/compiler-current-architecture.md

@@ -1,6 +1,6 @@
 # Current Compiler Architecture
 
-This maps the `0.8.16` compiler-analysis boundary. File and function names are the stable references; line numbers are intentionally omitted because Goal A moves code.
+This maps the completed `0.8.17` command ModuleIR boundary. File and function names are the stable references; line numbers are intentionally omitted because Goal A moves code.
 
 ## Responsibility Map
 
@@ -15,6 +15,7 @@ This maps the `0.8.16` compiler-analysis boundary. File and function names are t
 | Pure collection language | [`framework/compiler/collection-analysis.mjs`](../../framework/compiler/collection-analysis.mjs) | Analyzes collection roots/selectors and serializes the allowed pure expression language used by lists and derived dependencies. |
 | Main semantic analysis | `framework/build.mjs`, `createKudzuTransformer()` | Still owns component specialization, hooks/state, effects, keyed-list ownership, imports, reactive JSX, and many AST-identity side tables. This is the largest remaining coupling. |
 | Per-source descriptor registration | [`framework/compiler/descriptor-session.mjs`](../../framework/compiler/descriptor-session.mjs), `createSemanticArtifact()`, `createDescriptorSession()` | Registers deterministic native handler, effect handler, binding, list evaluator, and client-import descriptors into one source-local artifact. |
+| Command IR and codegen | [`framework/compiler/optimize/command-specialization.mjs`](../../framework/compiler/optimize/command-specialization.mjs), [`framework/compiler/ir/module-ir.mjs`](../../framework/compiler/ir/module-ir.mjs), [`framework/compiler/codegen/command-codegen.mjs`](../../framework/compiler/codegen/command-codegen.mjs) | Supported command handlers specialize to JSON-safe ModuleIR, then emit the existing `__kBehavior` AST without changing route plans. |
 | Build module generation | `framework/build.mjs`, `compile()` | Runs TypeScript with the Kudzu transformer, writes build-executable modules to `.kudzu`, rejects surviving React/Router runtime references, and generates handler source when descriptors exist. |
 | Handler/evaluator codegen | [`framework/compiler/handler-codegen.mjs`](../../framework/compiler/handler-codegen.mjs) | Converts descriptor AST into browser ESM exports and rewrites state, setter, reducer, capture, and imported-helper reads. It does not discover features. |
 | Worker graph | [`framework/compiler/worker-compiler.mjs`](../../framework/compiler/worker-compiler.mjs) | Validates the exact effect-owned Worker form, validates its relative graph, emits content-hashed ESM, and resolves placeholders only for rendered effects. |

package/docs/next-architecture/goal-a-compiler-foundation.md

@@ -2,7 +2,7 @@
 
 ## Status
 
-Approved for execution. Goal A is an architecture-only continuation: preserve accepted React-shaped syntax, diagnostics, complete HTML, emitted capability behavior, and current public APIs while making analysis and generation boundaries explicit.
+The `0.8.17` command vertical slice is complete. Goal A continues with the planned `0.8.18` state/props/component analysis result while preserving accepted React-shaped syntax, diagnostics, complete HTML, emitted capability behavior, and current public APIs.
 
 ## Target Boundaries
 
@@ -68,7 +68,7 @@ Analysis produces plain data:
 
 ```js
 {
-  signals: [{ slot: 0, debugName: "count", initial: 0, scope: "local" }],
+  signals: [{ slot: 0, key: "state:0:count", debugName: "count" }],
   handlers: [{
     slot: 0,
     kind: "commands",
@@ -77,6 +77,8 @@ Analysis produces plain data:
 }
 ```
 
+The `0.8.17` slice intentionally records only lexical signal identity and command handlers. Initial values, state scope, bindings, derived values, effects, and keyed blocks join ModuleIR in their later planned patches; `core.mjs` remains authoritative for those values today.
+
 Source codegen lowers that data through the existing build ABI:
 
 ```js

package/docs/next-architecture/versioning.md

@@ -1,6 +1,6 @@
 # Planned Version Sequence
 
-This is an execution sequence, not release history. `0.8.16` is the completed analysis-boundary scope represented by the current package/release records; later rows remain planned until their package version and release record exist.
+This is an execution sequence, not release history. `0.8.16` and `0.8.17` are completed scopes represented by package/release records; later rows remain planned until their package version and release record exist.
 
 Keep each patch behavior-preserving and independently reviewable. If a boundary proves inseparable, revise this plan before combining releases; do not silently broaden a patch.
 

package/framework/README.md

@@ -35,12 +35,12 @@ Reduced Zustand migration stores lower to one ordinary layout-lifetime state slo
 - `compiler/animation-frame-pass.mjs`: effect-owned animation-frame ref validation and plain mutable effect-scope lowering.
 - `compiler/browser-signal-passes.mjs`: static media-query external-store and navigator capability-condition normalization.
 - `compiler/collection-analysis.mjs`: pure collection expression IR, selector pipeline, alias, and imported-transform analysis.
-- `compiler/descriptor-session.mjs`: per-source semantic artifact creation and deterministic handler, effect, binding, and list evaluator descriptor registration.
+- `compiler/descriptor-session.mjs`: per-source semantic artifact creation and deterministic command, handler, effect, binding, and list evaluator descriptor registration.
 - `compiler/normalization-pipeline.mjs`: ordered source normalization with parent-pointer repair after every compiler pass.
 - `compiler/react-migration-pass.mjs`: React import, memo, callback, `forwardRef`, and `useId` migration validation and lowering.
 - `compiler/custom-hook-timer-pass.mjs`: private custom-hook timeout-ref validation and compiler-owned timer-state lowering.
 - `compiler/effect-codegen.mjs`: route-specific ordinary, owned, and navigable effect entry generation.
-- `compiler/event-command-pass.mjs`: direct setter and state-log fast-path recognition into compact command descriptors.
+- `compiler/optimize/command-specialization.mjs`, `compiler/ir/module-ir.mjs`, and `compiler/codegen/command-codegen.mjs`: JSON-safe command analysis, sparse per-source ModuleIR, and source-analysis-free existing behavior-call generation.
 - `compiler/handler-codegen.mjs`: route-specific native handler, reactive binding, keyed-list evaluator, and client-import module source generation.
 - `compiler/render-control-pass.mjs`: render-function early-return and exhaustive adjacent-assignment normalization.
 - `compiler/router-pass.mjs`: React Router import validation and native Link, pathname parameter, search parameter, and imperative navigation lowering.

package/framework/build.mjs

@@ -11,8 +11,8 @@ import { analyzeCollectionPipeline, collectionExpression, collectionParameters,
 import { normalizeCustomHookTimerRefs } from "./compiler/custom-hook-timer-pass.mjs"
 import { captureNames, createDescriptorSession, createSemanticArtifact, nativeCaptureNames, referencedReducerDispatches, referencedStateNames } from "./compiler/descriptor-session.mjs"
 import { createEffectCodegen } from "./compiler/effect-codegen.mjs"
-import { createEventCommandCompiler } from "./compiler/event-command-pass.mjs"
 import { createHandlerCodegen } from "./compiler/handler-codegen.mjs"
+import { createCommandSpecializer } from "./compiler/optimize/command-specialization.mjs"
 import { applyNormalizationPasses } from "./compiler/normalization-pipeline.mjs"
 import { createReactMigrationPass, reactMemoExpression } from "./compiler/react-migration-pass.mjs"
 import { normalizeRenderControlFlow } from "./compiler/render-control-pass.mjs"
@@ -31,7 +31,7 @@ const pagesDirectory = join(sourceDirectory, "pages")
 const workDirectory = join(root, ".kudzu")
 const outputDirectory = join(root, "dist")
 const staticAssetExtensions = new Set([".avif", ".gif", ".ico", ".jpeg", ".jpg", ".otf", ".png", ".svg", ".ttf", ".webp", ".woff", ".woff2"])
-const compileEventCommand = createEventCommandCompiler({ isPrimitiveLiteral: isPrimitiveDefaultLiteral, synthesizeSerializableStateLiteral })
+const compileEventCommand = createCommandSpecializer({ isPrimitiveLiteral: isPrimitiveDefaultLiteral })
 const { analyzeZustandStores, normalizeZustandMigrationSyntax } = createZustandPass({ isSerializableStateLiteral, nativeCaptureNames, sourceDirectory })
 
 export async function build({ quiet = false, minify = true } = {}) {
@@ -677,7 +677,7 @@ function escapeAttribute(value) {
 
 async function compile(file, sourceFiles, sourceIndex, staticFiles, importedAssets, cssModules, base, workerReferences) {
   const source = sourceIndex.get(file)
-  const semantic = createSemanticArtifact()
+  const semantic = createSemanticArtifact(relative(root, file).replaceAll(sep, "/"))
   const handlerPath = `handlers/${relative(sourceDirectory, file).replaceAll(sep, "/").replace(/\.(?:ts|tsx)$/, ".js")}`
   const result = ts.transpileModule(source, {
     fileName: file,
@@ -702,7 +702,7 @@ async function compile(file, sourceFiles, sourceIndex, staticFiles, importedAsse
   await mkdir(resolve(output, ".."), { recursive: true })
   await writeFile(output, result.outputText)
 
-    const { nativeHandlers, effectHandlers, reactiveBindings, listExpressions, clientImports } = semantic
+  const { nativeHandlers, effectHandlers, reactiveBindings, listExpressions, clientImports } = semantic
   if (!nativeHandlers.length && !effectHandlers.length && !reactiveBindings.length && !listExpressions.length) return undefined
   const callbacks = [...nativeHandlers, ...effectHandlers]
   const moduleSource = printHandlerModule({ callbacks, reactiveBindings, listExpressions, handlerPath })
@@ -894,6 +894,7 @@ function createKudzuTransformer({ semantic, handlerUrl, file, sourceFiles, sourc
       context,
       compileEventCommand,
       isPrimitiveLiteral: isPrimitiveDefaultLiteral,
+      sourceName: source => relative(root, source.fileName).replaceAll(sep, "/"),
       rejectWorkerConstructions: expression => workerCompiler.rejectConstructions(expression, expression.getSourceFile(), "Relative TypeScript Worker construction is only supported directly inside an inline useEffect() callback")
     })
     const importBindings = clientImportBindings(sourceFile, file, sourceFiles)

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/descriptor-session.mjs

@@ -1,12 +1,16 @@
 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() {
-  return { nativeHandlers: [], effectHandlers: [], reactiveBindings: [], listExpressions: [], clientImports: new Set() }
+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 }) {
-  const { nativeHandlers, effectHandlers, reactiveBindings, listExpressions, clientImports } = semantic
+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}`
@@ -130,9 +134,14 @@ export function createDescriptorSession({ semantic, handlerUrl, factory, context
 
   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)
+    const commands = statements.map(statement => ts.isExpressionStatement(statement) ? compileEventCommand(statement.expression, setters) : undefined)
     if (!commands.length || commands.some(command => !command)) return undefined
-    return factory.createCallExpression(factory.createIdentifier("__kBehavior"), undefined, [factory.createArrayLiteralExpression(commands)])
+    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) {

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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kudzujs/core",
-  "version": "0.8.16",
+  "version": "0.8.17",
   "description": "HTML-first TSX framework with synchronous state semantics and no virtual DOM",
   "type": "module",
   "license": "MIT",

package/framework/compiler/event-command-pass.mjs

@@ -1,35 +0,0 @@
-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
-}