@multitapio/multitap 0.0.1

package/dist/vite/index.js

@@ -0,0 +1,4202 @@
+// src/vite/plugin.ts
+import { resolve as resolve2, dirname as dirname3 } from "node:path";
+
+// src/vite/codegen-runner.ts
+import { writeFile, mkdir } from "node:fs/promises";
+import { join as join2 } from "node:path";
+
+// src/codegen/config.ts
+import { readFileSync, readdirSync, statSync } from "node:fs";
+import { join, dirname, isAbsolute, resolve } from "node:path";
+function findConfig(path) {
+  const stat2 = statSync(path);
+  if (!stat2.isDirectory()) {
+    return path;
+  }
+  const entries = readdirSync(path);
+  const matches = entries.filter(
+    (entry) => entry.endsWith("mt.config.json") && statSync(join(path, entry)).isFile()
+  );
+  if (matches.length === 0) {
+    throw new Error(`No *mt.config.json found in ${path}`);
+  }
+  if (matches.length > 1) {
+    throw new Error(`Multiple config files found in ${path}: ${matches.join(", ")} (specify exact path)`);
+  }
+  return join(path, matches[0]);
+}
+function loadConfig(path) {
+  const data = readFileSync(path, "utf-8");
+  try {
+    return JSON.parse(data);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    throw new Error(`Cannot parse config file ${path}: ${message}`);
+  }
+}
+function loadProject(path) {
+  const configPath = findConfig(path);
+  const absConfigPath = resolve(configPath);
+  const config = loadConfig(absConfigPath);
+  return {
+    config,
+    configPath: absConfigPath,
+    dir: dirname(absConfigPath)
+  };
+}
+function resolvePath(path, baseDir) {
+  if (isAbsolute(path)) {
+    return path;
+  }
+  return join(baseDir, path);
+}
+function loadConfigGraph(root) {
+  const plugins = /* @__PURE__ */ new Map();
+  const visited = /* @__PURE__ */ new Set();
+  const queue = [];
+  for (const p of root.config.plugins ?? []) {
+    const absPath = resolvePath(p, root.dir);
+    queue.push({ pluginPath: absPath, baseDir: root.dir });
+  }
+  while (queue.length > 0) {
+    const item = queue.shift();
+    if (visited.has(item.pluginPath)) {
+      continue;
+    }
+    visited.add(item.pluginPath);
+    const configPath = findConfig(item.pluginPath);
+    const config = loadConfig(configPath);
+    if (!config.wasm) {
+      throw new Error(`Plugin ${item.pluginPath}: missing required wasm.reservedBytes in config`);
+    }
+    if (config.wasm.reservedBytes <= 0) {
+      throw new Error(`Plugin ${item.pluginPath}: wasm.reservedBytes must be > 0`);
+    }
+    const maxReservedBytes = 256 * 1024 * 1024;
+    if (config.wasm.reservedBytes > maxReservedBytes) {
+      throw new Error(
+        `Plugin ${item.pluginPath}: wasm.reservedBytes ${config.wasm.reservedBytes} exceeds maximum ${maxReservedBytes}`
+      );
+    }
+    const pluginDir = dirname(configPath);
+    const deps = [];
+    for (const dep of config.plugins ?? []) {
+      const absDepPath = resolvePath(dep, pluginDir);
+      deps.push(absDepPath);
+      if (!visited.has(absDepPath)) {
+        queue.push({ pluginPath: absDepPath, baseDir: pluginDir });
+      }
+    }
+    plugins.set(item.pluginPath, {
+      path: item.pluginPath,
+      config,
+      dependencies: deps
+    });
+  }
+  const order = topologicalSort(plugins);
+  return {
+    root,
+    plugins,
+    order
+  };
+}
+function topologicalSort(plugins) {
+  const inDegree = /* @__PURE__ */ new Map();
+  for (const [path, node] of plugins) {
+    inDegree.set(path, node.dependencies.length);
+  }
+  let queue = [];
+  for (const [path, degree] of inDegree) {
+    if (degree === 0) {
+      queue.push(path);
+    }
+  }
+  queue.sort();
+  const order = [];
+  while (queue.length > 0) {
+    const path = queue.shift();
+    order.push(path);
+    for (const [otherPath, node] of plugins) {
+      for (const dep of node.dependencies) {
+        if (dep === path) {
+          const newDegree = inDegree.get(otherPath) - 1;
+          inDegree.set(otherPath, newDegree);
+          if (newDegree === 0) {
+            queue.push(otherPath);
+            queue.sort();
+          }
+        }
+      }
+    }
+  }
+  if (order.length !== plugins.size) {
+    throw new Error("Cycle detected in plugin dependencies");
+  }
+  return order;
+}
+function mergeConfigs(graph) {
+  const componentOwners = /* @__PURE__ */ new Map();
+  const eventOwners = /* @__PURE__ */ new Map();
+  const mergedComponents = [];
+  const mergedEvents = [];
+  for (const pluginPath of graph.order) {
+    const node = graph.plugins.get(pluginPath);
+    for (const comp of node.config.state.components ?? []) {
+      if (componentOwners.has(comp.name)) {
+        const owner = componentOwners.get(comp.name);
+        throw new Error(`Component "${comp.name}" defined in both ${owner} and ${pluginPath}`);
+      }
+      componentOwners.set(comp.name, pluginPath);
+      mergedComponents.push(comp);
+    }
+  }
+  for (const comp of graph.root.config.state.components ?? []) {
+    if (componentOwners.has(comp.name)) {
+      const owner = componentOwners.get(comp.name);
+      throw new Error(`Component "${comp.name}" defined in both ${owner} and root config`);
+    }
+    componentOwners.set(comp.name, graph.root.dir);
+    mergedComponents.push(comp);
+  }
+  for (const pluginPath of graph.order) {
+    const node = graph.plugins.get(pluginPath);
+    for (const event of node.config.state.events ?? []) {
+      if (eventOwners.has(event.name)) {
+        const owner = eventOwners.get(event.name);
+        throw new Error(`Event "${event.name}" defined in both ${owner} and ${pluginPath}`);
+      }
+      eventOwners.set(event.name, pluginPath);
+      mergedEvents.push(event);
+    }
+  }
+  for (const event of graph.root.config.state.events ?? []) {
+    if (eventOwners.has(event.name)) {
+      const owner = eventOwners.get(event.name);
+      throw new Error(`Event "${event.name}" defined in both ${owner} and root config`);
+    }
+    eventOwners.set(event.name, graph.root.dir);
+    mergedEvents.push(event);
+  }
+  const mergedState = {
+    maxEntities: graph.root.config.state.maxEntities,
+    components: mergedComponents
+  };
+  if (mergedEvents.length > 0) {
+    mergedState.events = mergedEvents;
+  }
+  const mergedConfig = {
+    appID: graph.root.config.appID,
+    entrypoint: graph.root.config.entrypoint,
+    output: graph.root.config.output,
+    tickRate: graph.root.config.tickRate,
+    maxTicks: graph.root.config.maxTicks,
+    maxParticipants: graph.root.config.maxParticipants,
+    input: graph.root.config.input,
+    state: mergedState
+  };
+  if (graph.root.config.tests) {
+    mergedConfig.tests = graph.root.config.tests;
+  }
+  if (graph.root.config.fixtures !== void 0) {
+    mergedConfig.fixtures = graph.root.config.fixtures;
+  }
+  return {
+    config: mergedConfig,
+    pluginOrder: graph.order,
+    componentOwners
+  };
+}
+
+// src/codegen/inject.ts
+function buildPlayerComponent(inputSchema) {
+  const fields = [{ name: "index", type: "uint8" }];
+  for (const ctrl of inputSchema.controls) {
+    switch (ctrl.type) {
+      case "vec2":
+        fields.push(
+          { name: `${ctrl.name}_x`, type: "f32" },
+          { name: `${ctrl.name}_y`, type: "f32" }
+        );
+        break;
+      case "vec3":
+        fields.push(
+          { name: `${ctrl.name}_x`, type: "f32" },
+          { name: `${ctrl.name}_y`, type: "f32" },
+          { name: `${ctrl.name}_z`, type: "f32" }
+        );
+        break;
+      case "quat":
+        fields.push(
+          { name: `${ctrl.name}_x`, type: "f32" },
+          { name: `${ctrl.name}_y`, type: "f32" },
+          { name: `${ctrl.name}_z`, type: "f32" },
+          { name: `${ctrl.name}_w`, type: "f32" }
+        );
+        break;
+      case "flags8":
+        fields.push({ name: ctrl.name, type: "uint8" });
+        break;
+      case "flags16":
+        fields.push({ name: ctrl.name, type: "uint16" });
+        break;
+      case "flags32":
+        fields.push({ name: ctrl.name, type: "uint32" });
+        break;
+      default:
+        fields.push({ name: ctrl.name, type: ctrl.type });
+        break;
+    }
+  }
+  return {
+    name: "Player",
+    type: "compound",
+    fields
+  };
+}
+function injectPlayerComponent(schema, inputSchema) {
+  for (const comp of schema.components) {
+    if (comp.name === "Player") {
+      throw new Error(
+        "Schema already contains a 'Player' component; this is reserved for input-derived generation"
+      );
+    }
+  }
+  const playerComp = buildPlayerComponent(inputSchema);
+  schema.components.push(playerComp);
+}
+function buildCommandEvents(inputSchema) {
+  const events = [];
+  for (const cmd of inputSchema.commands) {
+    const fields = [{ name: "player_index", type: "uint8" }];
+    for (const arg of cmd.args) {
+      switch (arg.type) {
+        case "vec2":
+          fields.push(
+            { name: `${arg.name}_x`, type: "f32" },
+            { name: `${arg.name}_y`, type: "f32" }
+          );
+          break;
+        case "vec3":
+          fields.push(
+            { name: `${arg.name}_x`, type: "f32" },
+            { name: `${arg.name}_y`, type: "f32" },
+            { name: `${arg.name}_z`, type: "f32" }
+          );
+          break;
+        case "quat":
+          fields.push(
+            { name: `${arg.name}_x`, type: "f32" },
+            { name: `${arg.name}_y`, type: "f32" },
+            { name: `${arg.name}_z`, type: "f32" },
+            { name: `${arg.name}_w`, type: "f32" }
+          );
+          break;
+        case "flags8":
+          fields.push({ name: arg.name, type: "uint8" });
+          break;
+        case "flags16":
+          fields.push({ name: arg.name, type: "uint16" });
+          break;
+        case "flags32":
+          fields.push({ name: arg.name, type: "uint32" });
+          break;
+        default:
+          fields.push({ name: arg.name, type: arg.type });
+          break;
+      }
+    }
+    const eventName = cmd.name.charAt(0).toUpperCase() + cmd.name.slice(1) + "Command";
+    events.push({
+      name: eventName,
+      maxEvents: 16,
+      // Default max commands per tick
+      fields
+    });
+  }
+  return events;
+}
+function injectCommandEvents(schema, inputSchema) {
+  const commandEvents = buildCommandEvents(inputSchema);
+  const existingNames = /* @__PURE__ */ new Set();
+  for (const event of schema.events ?? []) {
+    existingNames.add(event.name);
+  }
+  for (const cmdEvent of commandEvents) {
+    if (existingNames.has(cmdEvent.name)) {
+      throw new Error(
+        `Schema already contains event '${cmdEvent.name}'; command-derived events use {Name}Command naming`
+      );
+    }
+  }
+  if (!schema.events) {
+    schema.events = [];
+  }
+  schema.events.push(...commandEvents);
+}
+function prepareStateSchema(stateSchema, inputSchema) {
+  const schema = {
+    maxEntities: stateSchema.maxEntities,
+    components: [...stateSchema.components ?? []]
+  };
+  if (stateSchema.events) {
+    schema.events = [...stateSchema.events];
+  }
+  injectPlayerComponent(schema, inputSchema);
+  injectCommandEvents(schema, inputSchema);
+  return schema;
+}
+
+// src/codegen/generator.ts
+function toUpperSnake(s) {
+  let result = "";
+  for (let i = 0; i < s.length; i++) {
+    const c = s[i];
+    if (i > 0 && c >= "A" && c <= "Z") {
+      result += "_";
+    }
+    result += c.toUpperCase();
+  }
+  return result;
+}
+function toLowerSnake(s) {
+  let result = "";
+  for (let i = 0; i < s.length; i++) {
+    const c = s[i];
+    if (i > 0 && c >= "A" && c <= "Z") {
+      result += "_";
+    }
+    result += c.toLowerCase();
+  }
+  return result;
+}
+function toCamelCase(s) {
+  if (s === "") return "";
+  const pascal = toPascalCase(s);
+  if (pascal === "") return "";
+  return pascal[0].toLowerCase() + pascal.slice(1);
+}
+function toPascalCase(s) {
+  if (s === "") return "";
+  let result = "";
+  let capitalizeNext = true;
+  for (const c of s) {
+    if (c === "_") {
+      capitalizeNext = true;
+      continue;
+    }
+    if (capitalizeNext) {
+      result += c.toUpperCase();
+      capitalizeNext = false;
+    } else {
+      result += c;
+    }
+  }
+  return result;
+}
+function needsEndian(type) {
+  switch (type) {
+    case "uint16":
+    case "int16":
+    case "uint32":
+    case "int32":
+    case "f32":
+    case "entityRef":
+      return true;
+    default:
+      return false;
+  }
+}
+function getElementSize(type) {
+  switch (type) {
+    case "bool":
+    case "uint8":
+    case "int8":
+      return 1;
+    case "uint16":
+    case "int16":
+      return 2;
+    case "uint32":
+    case "int32":
+    case "f32":
+    case "entityRef":
+      return 4;
+    default:
+      return 0;
+  }
+}
+
+// src/codegen/typescript.ts
+function tsType(field) {
+  if (field.arrayElementType) {
+    return tsTypeMapping(field.arrayElementType);
+  }
+  if (field.type === "vec2" || field.type === "vec3" || field.type === "quat") {
+    return "number";
+  }
+  if (field.type === "enum") {
+    return "number";
+  }
+  return tsTypeMapping(field.type);
+}
+function tsTypeMapping(typ) {
+  switch (typ) {
+    case "bool":
+      return "boolean";
+    case "uint8":
+    case "int8":
+    case "uint16":
+    case "int16":
+    case "uint32":
+    case "int32":
+    case "f32":
+    case "entityRef":
+      return "number";
+    default:
+      throw new Error(`Unknown type '${typ}' in TypeScript code generation`);
+  }
+}
+function tsInputType(typ) {
+  switch (typ) {
+    case "bool":
+      return "boolean";
+    case "uint8":
+    case "int8":
+    case "uint16":
+    case "int16":
+    case "uint32":
+    case "int32":
+    case "f32":
+    case "flags8":
+    case "flags16":
+    case "flags32":
+    case "vec2":
+    case "vec3":
+    case "quat":
+      return "number";
+    default:
+      throw new Error(`Unknown input type '${typ}' in TypeScript code generation`);
+  }
+}
+function tsLoadFn(field) {
+  let typ = field.type;
+  if (field.arrayElementType) {
+    typ = field.arrayElementType;
+  }
+  if (typ === "vec2" || typ === "vec3" || typ === "quat") {
+    typ = "f32";
+  }
+  if (typ === "enum") {
+    typ = "uint8";
+  }
+  return tsLoadFnForType(typ);
+}
+function tsLoadFnForType(typ) {
+  switch (typ) {
+    case "bool":
+    case "uint8":
+      return "getUint8";
+    case "int8":
+      return "getInt8";
+    case "uint16":
+      return "getUint16";
+    case "int16":
+      return "getInt16";
+    case "uint32":
+    case "entityRef":
+      return "getUint32";
+    case "int32":
+      return "getInt32";
+    case "f32":
+      return "getFloat32";
+    default:
+      throw new Error(`Unknown type '${typ}' in TypeScript load function generation`);
+  }
+}
+function tsStoreFn(field) {
+  let typ = field.type;
+  if (field.arrayElementType) {
+    typ = field.arrayElementType;
+  }
+  if (typ === "vec2" || typ === "vec3" || typ === "quat") {
+    typ = "f32";
+  }
+  if (typ === "enum") {
+    typ = "uint8";
+  }
+  return tsStoreFnForType(typ);
+}
+function tsStoreFnForType(typ) {
+  switch (typ) {
+    case "bool":
+    case "uint8":
+      return "setUint8";
+    case "int8":
+      return "setInt8";
+    case "uint16":
+      return "setUint16";
+    case "int16":
+      return "setInt16";
+    case "uint32":
+    case "entityRef":
+      return "setUint32";
+    case "int32":
+      return "setInt32";
+    case "f32":
+      return "setFloat32";
+    default:
+      throw new Error(`Unknown type '${typ}' in TypeScript store function generation`);
+  }
+}
+function fieldNeedsEndian(field) {
+  let typ = field.type;
+  if (field.arrayElementType) {
+    typ = field.arrayElementType;
+  }
+  if (typ === "vec2" || typ === "vec3" || typ === "quat") {
+    typ = "f32";
+  }
+  if (typ === "enum") {
+    typ = "uint8";
+  }
+  return needsEndian(typ);
+}
+function fieldElemSize(field) {
+  if (field.arrayElementType) {
+    return getElementSize(field.arrayElementType);
+  }
+  return getElementSize(field.type);
+}
+function generateStateHeader(schema) {
+  return `// TypeScript State Bindings
+// Auto-generated - do not edit
+// MaxEntities: ${schema.maxEntities}
+// TotalSize: ${schema.totalSize} bytes
+
+// =============================================================================
+// State View Helper
+// =============================================================================
+
+/** Convert a Uint8Array state buffer to a DataView for use with accessor functions */
+export function stateView(state: Uint8Array): DataView {
+  return new DataView(state.buffer, state.byteOffset, state.byteLength);
+}
+
+// =============================================================================
+// Constants
+// =============================================================================
+
+export const MAX_ENTITIES = ${schema.maxEntities};
+export const HEADER_SIZE = ${schema.headerSize};
+export const ENTITY_TABLE_OFFSET = ${schema.entityTableOffset};
+export const ENTITY_RECORD_SIZE = ${schema.entityRecordSize};
+export const FREE_STACK_OFFSET = ${schema.freeStackOffset};
+export const FREE_STACK_SIZE = ${schema.freeStackSize};
+export const COMPONENT_STORAGE_OFFSET = ${schema.componentStorageOffset};
+export const SINGLETON_STORAGE_OFFSET = ${schema.singletonStorageOffset};
+export const BITMASK_SIZE = ${schema.bitmaskSize};
+export const STATE_ID_OFFSET = 8;
+export const STATE_ID_SIZE = 32;
+export const TICK_OFFSET = 40;
+export const TICK_RATE_OFFSET = 6;
+`;
+}
+function generateComponentOffsets(schema) {
+  let out = `
+// =============================================================================
+// Component Offsets
+// =============================================================================
+`;
+  for (const comp of schema.components) {
+    if (!comp.isSingleton) {
+      out += `export const ${toUpperSnake(comp.name)}_BIT = ${comp.index};
+`;
+      if (comp.size > 0) {
+        out += `const ${toUpperSnake(comp.name)}_OFFSET = ${comp.storageOffset};
+`;
+        out += `const ${toUpperSnake(comp.name)}_SIZE = ${comp.size};
+`;
+      }
+    } else {
+      if (comp.size > 0) {
+        out += `const ${toUpperSnake(comp.name)}_OFFSET = ${comp.storageOffset};
+`;
+      }
+    }
+  }
+  out += `
+// Component bit constants for query
+`;
+  for (const comp of schema.entityComponents) {
+    out += `export const ${comp.name} = ${toUpperSnake(comp.name)}_BIT;
+`;
+  }
+  return out;
+}
+function generateEntityHelpers() {
+  return `
+// =============================================================================
+// Entity Reference
+// =============================================================================
+
+export type EntityRef = number;
+export const NULL_ENTITY: EntityRef = 0xFFFFFFFF;
+
+/** Pack entity index and generation into an EntityRef */
+export function packRef(index: number, generation: number): EntityRef {
+  return (((generation & 0xFFFF) << 16) | (index & 0xFFFF)) >>> 0;
+}
+
+/** Extract entity index from EntityRef */
+export function unpackIndex(entity: EntityRef): number {
+  return entity & 0xFFFF;
+}
+
+/** Extract generation from EntityRef */
+export function unpackGeneration(entity: EntityRef): number {
+  return (entity >>> 16) & 0xFFFF;
+}
+
+// =============================================================================
+// Internal Helpers
+// =============================================================================
+
+function getEntityRecordOffset(index: number): number {
+  return ENTITY_TABLE_OFFSET + index * ENTITY_RECORD_SIZE;
+}
+
+function getEntityGeneration(state: DataView, index: number): number {
+  return state.getUint16(getEntityRecordOffset(index), true);
+}
+
+function setEntityGeneration(state: DataView, index: number, generation: number): void {
+  state.setUint16(getEntityRecordOffset(index), generation, true);
+}
+
+function getAliveCount(state: DataView): number {
+  return state.getUint16(4, true);
+}
+
+function setAliveCount(state: DataView, count: number): void {
+  state.setUint16(4, count, true);
+}
+
+/** Get current tick from header */
+export function getTick(state: DataView): number {
+  return state.getUint32(TICK_OFFSET, true);
+}
+
+/** Set current tick in header */
+export function setTick(state: DataView, tick: number): void {
+  state.setUint32(TICK_OFFSET, tick, true);
+}
+
+/** Get tick rate from header */
+export function getTickRate(state: DataView): number {
+  return state.getUint8(TICK_RATE_OFFSET);
+}
+
+function getFreeStackCount(state: DataView): number {
+  return state.getUint16(FREE_STACK_OFFSET, true);
+}
+
+function setFreeStackCount(state: DataView, count: number): void {
+  state.setUint16(FREE_STACK_OFFSET, count, true);
+}
+
+function hasBit(state: DataView, index: number, bit: number): boolean {
+  const bitmaskOffset = getEntityRecordOffset(index) + 2;
+  const byteIndex = bit >>> 3;
+  const bitIndex = bit & 7;
+  return (state.getUint8(bitmaskOffset + byteIndex) & (1 << bitIndex)) !== 0;
+}
+
+function setBit(state: DataView, index: number, bit: number): void {
+  const bitmaskOffset = getEntityRecordOffset(index) + 2;
+  const byteIndex = bit >>> 3;
+  const bitIndex = bit & 7;
+  const current = state.getUint8(bitmaskOffset + byteIndex);
+  state.setUint8(bitmaskOffset + byteIndex, current | (1 << bitIndex));
+}
+
+function clearBit(state: DataView, index: number, bit: number): void {
+  const bitmaskOffset = getEntityRecordOffset(index) + 2;
+  const byteIndex = bit >>> 3;
+  const bitIndex = bit & 7;
+  const current = state.getUint8(bitmaskOffset + byteIndex);
+  state.setUint8(bitmaskOffset + byteIndex, current & ~(1 << bitIndex));
+}
+`;
+}
+function generateIterationHelpers(schema) {
+  let out = `
+// =============================================================================
+// Entity Iteration Helpers
+// =============================================================================
+
+/** Get generation for a raw slot index */
+export function getGenerationAtSlot(state: DataView, index: number): number {
+  return getEntityGeneration(state, index);
+}
+
+/** Build an EntityRef for a slot using its current generation */
+export function entityAtSlot(state: DataView, index: number): EntityRef {
+  return packRef(index, getEntityGeneration(state, index));
+}
+
+function hasAnyComponentAtSlot(state: DataView, index: number): boolean {
+  const bitmaskOffset = getEntityRecordOffset(index) + 2;
+  for (let i = 0; i < BITMASK_SIZE; i++) {
+    if (state.getUint8(bitmaskOffset + i) !== 0) {
+      return true;
+    }
+  }
+  return false;
+}
+
+// Per-component slot presence checks
+`;
+  for (const comp of schema.entityComponents) {
+    out += `export function has${comp.name}AtSlot(state: DataView, index: number): boolean {
+  return hasBit(state, index, ${toUpperSnake(comp.name)}_BIT);
+}
+`;
+  }
+  return out;
+}
+function generateQueryHelpers() {
+  return `
+// =============================================================================
+// Entity Queries (Zero-Allocation)
+// =============================================================================
+
+/** Build a query mask from component bits */
+export function queryMask(bits: number[]): bigint {
+  let mask = 0n;
+  for (const bit of bits) {
+    mask |= 1n << BigInt(bit);
+  }
+  return mask;
+}
+
+function loadComponentMask(state: DataView, bitmaskOffset: number): bigint {
+  let mask = 0n;
+  for (let i = 0; i < BITMASK_SIZE; i++) {
+    mask |= BigInt(state.getUint8(bitmaskOffset + i)) << BigInt(i * 8);
+  }
+  return mask;
+}
+
+function hasMask(state: DataView, index: number, mask: bigint): boolean {
+  const bitmaskOffset = getEntityRecordOffset(index) + 2;
+  const entityMask = loadComponentMask(state, bitmaskOffset);
+  return (entityMask & mask) === mask;
+}
+
+/** Iterate entities matching mask (generator) */
+export function* iterQuery(state: DataView, requiredMask: bigint): Generator<EntityRef> {
+  for (let i = 0; i < MAX_ENTITIES; i++) {
+    if (!hasAnyComponentAtSlot(state, i)) {
+      continue;
+    }
+    if (!hasMask(state, i, requiredMask)) {
+      continue;
+    }
+    const entity = entityAtSlot(state, i);
+    if (isAlive(state, entity)) {
+      yield entity;
+    }
+  }
+}
+`;
+}
+function generateLifecycle(schema) {
+  let despawnZeroComponents = "";
+  for (const comp of schema.entityComponents) {
+    if (!comp.isTag && comp.size > 0) {
+      despawnZeroComponents += `  for (let i = 0; i < ${toUpperSnake(comp.name)}_SIZE; i++) {
+    state.setUint8(${toUpperSnake(comp.name)}_OFFSET + index * ${toUpperSnake(comp.name)}_SIZE + i, 0);
+  }
+`;
+    }
+  }
+  return `
+// =============================================================================
+// Entity Lifecycle
+// =============================================================================
+
+/** Check if entity reference is valid (alive) */
+export function isAlive(state: DataView, entity: EntityRef): boolean {
+  if (entity === NULL_ENTITY) {
+    return false;
+  }
+  const index = unpackIndex(entity);
+  if (index >= MAX_ENTITIES) {
+    return false;
+  }
+  const expectedGen = unpackGeneration(entity);
+  const currentGen = getEntityGeneration(state, index);
+  return currentGen === expectedGen;
+}
+
+/** Spawn a new entity, returns EntityRef */
+export function spawn(state: DataView): EntityRef {
+  const count = getFreeStackCount(state);
+  if (count === 0) {
+    return NULL_ENTITY;
+  }
+
+  const entryOffset = FREE_STACK_OFFSET + 2 + (count - 1) * 2;
+  const index = state.getUint16(entryOffset, true);
+  setFreeStackCount(state, count - 1);
+
+  const generation = getEntityGeneration(state, index);
+  setAliveCount(state, getAliveCount(state) + 1);
+
+  return packRef(index, generation);
+}
+
+/** Despawn an entity */
+export function despawn(state: DataView, entity: EntityRef): void {
+  if (!isAlive(state, entity)) {
+    return;
+  }
+
+  const index = unpackIndex(entity);
+  const oldGen = getEntityGeneration(state, index);
+  setEntityGeneration(state, index, (oldGen + 1) & 0xFFFF);
+
+  // Clear component bitmask
+  const bitmaskOffset = getEntityRecordOffset(index) + 2;
+  for (let i = 0; i < BITMASK_SIZE; i++) {
+    state.setUint8(bitmaskOffset + i, 0);
+  }
+
+  // Zero all component storage for this entity
+${despawnZeroComponents}
+  // Push index back onto free stack
+  const freeCount = getFreeStackCount(state);
+  const entryOffset = FREE_STACK_OFFSET + 2 + freeCount * 2;
+  state.setUint16(entryOffset, index, true);
+  setFreeStackCount(state, freeCount + 1);
+
+  setAliveCount(state, getAliveCount(state) - 1);
+}
+`;
+}
+function generateComponentAccessors(comp) {
+  const UPPER = toUpperSnake(comp.name);
+  let out = `
+// ---------- ${comp.name} Component ----------
+`;
+  if (comp.isTag) {
+    out += `
+/** Check if entity has ${comp.name} tag */
+export function has${comp.name}(state: DataView, entity: EntityRef): boolean {
+  return hasBit(state, unpackIndex(entity), ${UPPER}_BIT);
+}
+
+/** Add ${comp.name} tag to entity */
+export function add${comp.name}(state: DataView, entity: EntityRef): void {
+  setBit(state, unpackIndex(entity), ${UPPER}_BIT);
+}
+
+/** Remove ${comp.name} tag from entity */
+export function remove${comp.name}(state: DataView, entity: EntityRef): void {
+  clearBit(state, unpackIndex(entity), ${UPPER}_BIT);
+}
+`;
+    return out;
+  }
+  out += `
+/** Check if entity has ${comp.name} component */
+export function has${comp.name}(state: DataView, entity: EntityRef): boolean {
+  return hasBit(state, unpackIndex(entity), ${UPPER}_BIT);
+}
+
+/** Add ${comp.name} component to entity */
+export function add${comp.name}(state: DataView, entity: EntityRef): void {
+  setBit(state, unpackIndex(entity), ${UPPER}_BIT);
+}
+
+/** Remove ${comp.name} component from entity */
+export function remove${comp.name}(state: DataView, entity: EntityRef): void {
+  const index = unpackIndex(entity);
+  clearBit(state, index, ${UPPER}_BIT);
+  for (let i = 0; i < ${UPPER}_SIZE; i++) {
+    state.setUint8(${UPPER}_OFFSET + index * ${UPPER}_SIZE + i, 0);
+  }
+}
+`;
+  for (const field of comp.fields) {
+    out += generateFieldAccessors(comp, field, false);
+  }
+  return out;
+}
+function generateFieldAccessors(comp, field, isSingleton) {
+  const UPPER = toUpperSnake(comp.name);
+  const isScalar = field.name === "";
+  const suffix = isScalar ? "" : toPascalCase(field.name);
+  const offsetExpr = isSingleton ? field.offset > 0 ? `${UPPER}_OFFSET + ${field.offset}` : `${UPPER}_OFFSET` : field.offset > 0 ? `${UPPER}_OFFSET + unpackIndex(entity) * ${UPPER}_SIZE + ${field.offset}` : `${UPPER}_OFFSET + unpackIndex(entity) * ${UPPER}_SIZE`;
+  const entityParam = isSingleton ? "" : "entity: EntityRef, ";
+  if (field.arrayLength && field.arrayLength > 0) {
+    const elemSize = fieldElemSize(field);
+    const isBoolArray = field.arrayElementType === "bool";
+    const defaultVal = isBoolArray ? "false" : "0";
+    const endianArg2 = fieldNeedsEndian(field) ? ", true" : "";
+    return `
+/** Get ${comp.name}${isScalar ? "" : "." + field.name}[index] */
+export function get${comp.name}${suffix}(state: DataView, ${entityParam}index: number): ${tsType(field)} {
+  if (index < 0 || index >= ${field.arrayLength}) {
+    return ${defaultVal};
+  }
+${isBoolArray ? `  return state.${tsLoadFn(field)}(${offsetExpr} + index * ${elemSize}) !== 0;` : `  return state.${tsLoadFn(field)}(${offsetExpr} + index * ${elemSize}${endianArg2});`}
+}
+
+/** Set ${comp.name}${isScalar ? "" : "." + field.name}[index] */
+export function set${comp.name}${suffix}(state: DataView, ${entityParam}index: number, value: ${tsType(field)}): void {
+  if (index < 0 || index >= ${field.arrayLength}) {
+    return;
+  }
+${isBoolArray ? `  state.${tsStoreFn(field)}(${offsetExpr} + index * ${elemSize}, value ? 1 : 0);` : `  state.${tsStoreFn(field)}(${offsetExpr} + index * ${elemSize}, value${endianArg2});`}
+}
+`;
+  }
+  if (field.type === "vec2") {
+    const baseOffset = isSingleton ? `${UPPER}_OFFSET${field.offset > 0 ? ` + ${field.offset}` : ""}` : `${UPPER}_OFFSET + unpackIndex(entity) * ${UPPER}_SIZE${field.offset > 0 ? ` + ${field.offset}` : ""}`;
+    return `
+/** Get ${comp.name}${isScalar ? "" : "." + field.name} as [x, y] */
+export function get${comp.name}${suffix}(state: DataView${isSingleton ? "" : ", entity: EntityRef"}): [number, number] {
+  const offset = ${baseOffset};
+  return [
+    state.getFloat32(offset, true),
+    state.getFloat32(offset + 4, true),
+  ];
+}
+
+/** Set ${comp.name}${isScalar ? "" : "." + field.name} from [x, y] */
+export function set${comp.name}${suffix}(state: DataView${isSingleton ? "" : ", entity: EntityRef"}, value: [number, number]): void {
+  const offset = ${baseOffset};
+  state.setFloat32(offset, value[0], true);
+  state.setFloat32(offset + 4, value[1], true);
+}
+
+/** Get ${comp.name}${isScalar ? "" : "." + field.name}.x */
+export function get${comp.name}${suffix}X(state: DataView${isSingleton ? "" : ", entity: EntityRef"}): number {
+  return state.getFloat32(${baseOffset}, true);
+}
+
+/** Set ${comp.name}${isScalar ? "" : "." + field.name}.x */
+export function set${comp.name}${suffix}X(state: DataView${isSingleton ? "" : ", entity: EntityRef"}, value: number): void {
+  state.setFloat32(${baseOffset}, value, true);
+}
+
+/** Get ${comp.name}${isScalar ? "" : "." + field.name}.y */
+export function get${comp.name}${suffix}Y(state: DataView${isSingleton ? "" : ", entity: EntityRef"}): number {
+  return state.getFloat32(${baseOffset} + 4, true);
+}
+
+/** Set ${comp.name}${isScalar ? "" : "." + field.name}.y */
+export function set${comp.name}${suffix}Y(state: DataView${isSingleton ? "" : ", entity: EntityRef"}, value: number): void {
+  state.setFloat32(${baseOffset} + 4, value, true);
+}
+`;
+  }
+  if (field.type === "vec3") {
+    const baseOffset = isSingleton ? `${UPPER}_OFFSET${field.offset > 0 ? ` + ${field.offset}` : ""}` : `${UPPER}_OFFSET + unpackIndex(entity) * ${UPPER}_SIZE${field.offset > 0 ? ` + ${field.offset}` : ""}`;
+    return `
+/** Get ${comp.name}${isScalar ? "" : "." + field.name} as [x, y, z] */
+export function get${comp.name}${suffix}(state: DataView${isSingleton ? "" : ", entity: EntityRef"}): [number, number, number] {
+  const offset = ${baseOffset};
+  return [
+    state.getFloat32(offset, true),
+    state.getFloat32(offset + 4, true),
+    state.getFloat32(offset + 8, true),
+  ];
+}
+
+/** Set ${comp.name}${isScalar ? "" : "." + field.name} from [x, y, z] */
+export function set${comp.name}${suffix}(state: DataView${isSingleton ? "" : ", entity: EntityRef"}, value: [number, number, number]): void {
+  const offset = ${baseOffset};
+  state.setFloat32(offset, value[0], true);
+  state.setFloat32(offset + 4, value[1], true);
+  state.setFloat32(offset + 8, value[2], true);
+}
+
+/** Get ${comp.name}${isScalar ? "" : "." + field.name}.x */
+export function get${comp.name}${suffix}X(state: DataView${isSingleton ? "" : ", entity: EntityRef"}): number {
+  return state.getFloat32(${baseOffset}, true);
+}
+
+/** Set ${comp.name}${isScalar ? "" : "." + field.name}.x */
+export function set${comp.name}${suffix}X(state: DataView${isSingleton ? "" : ", entity: EntityRef"}, value: number): void {
+  state.setFloat32(${baseOffset}, value, true);
+}
+
+/** Get ${comp.name}${isScalar ? "" : "." + field.name}.y */
+export function get${comp.name}${suffix}Y(state: DataView${isSingleton ? "" : ", entity: EntityRef"}): number {
+  return state.getFloat32(${baseOffset} + 4, true);
+}
+
+/** Set ${comp.name}${isScalar ? "" : "." + field.name}.y */
+export function set${comp.name}${suffix}Y(state: DataView${isSingleton ? "" : ", entity: EntityRef"}, value: number): void {
+  state.setFloat32(${baseOffset} + 4, value, true);
+}
+
+/** Get ${comp.name}${isScalar ? "" : "." + field.name}.z */
+export function get${comp.name}${suffix}Z(state: DataView${isSingleton ? "" : ", entity: EntityRef"}): number {
+  return state.getFloat32(${baseOffset} + 8, true);
+}
+
+/** Set ${comp.name}${isScalar ? "" : "." + field.name}.z */
+export function set${comp.name}${suffix}Z(state: DataView${isSingleton ? "" : ", entity: EntityRef"}, value: number): void {
+  state.setFloat32(${baseOffset} + 8, value, true);
+}
+`;
+  }
+  if (field.type === "quat") {
+    const baseOffset = isSingleton ? `${UPPER}_OFFSET${field.offset > 0 ? ` + ${field.offset}` : ""}` : `${UPPER}_OFFSET + unpackIndex(entity) * ${UPPER}_SIZE${field.offset > 0 ? ` + ${field.offset}` : ""}`;
+    return `
+/** Get ${comp.name}${isScalar ? "" : "." + field.name} as [x, y, z, w] */
+export function get${comp.name}${suffix}(state: DataView${isSingleton ? "" : ", entity: EntityRef"}): [number, number, number, number] {
+  const offset = ${baseOffset};
+  return [
+    state.getFloat32(offset, true),
+    state.getFloat32(offset + 4, true),
+    state.getFloat32(offset + 8, true),
+    state.getFloat32(offset + 12, true),
+  ];
+}
+
+/** Set ${comp.name}${isScalar ? "" : "." + field.name} from [x, y, z, w] */
+export function set${comp.name}${suffix}(state: DataView${isSingleton ? "" : ", entity: EntityRef"}, value: [number, number, number, number]): void {
+  const offset = ${baseOffset};
+  state.setFloat32(offset, value[0], true);
+  state.setFloat32(offset + 4, value[1], true);
+  state.setFloat32(offset + 8, value[2], true);
+  state.setFloat32(offset + 12, value[3], true);
+}
+
+/** Get ${comp.name}${isScalar ? "" : "." + field.name}.x */
+export function get${comp.name}${suffix}X(state: DataView${isSingleton ? "" : ", entity: EntityRef"}): number {
+  return state.getFloat32(${baseOffset}, true);
+}
+
+/** Set ${comp.name}${isScalar ? "" : "." + field.name}.x */
+export function set${comp.name}${suffix}X(state: DataView${isSingleton ? "" : ", entity: EntityRef"}, value: number): void {
+  state.setFloat32(${baseOffset}, value, true);
+}
+
+/** Get ${comp.name}${isScalar ? "" : "." + field.name}.y */
+export function get${comp.name}${suffix}Y(state: DataView${isSingleton ? "" : ", entity: EntityRef"}): number {
+  return state.getFloat32(${baseOffset} + 4, true);
+}
+
+/** Set ${comp.name}${isScalar ? "" : "." + field.name}.y */
+export function set${comp.name}${suffix}Y(state: DataView${isSingleton ? "" : ", entity: EntityRef"}, value: number): void {
+  state.setFloat32(${baseOffset} + 4, value, true);
+}
+
+/** Get ${comp.name}${isScalar ? "" : "." + field.name}.z */
+export function get${comp.name}${suffix}Z(state: DataView${isSingleton ? "" : ", entity: EntityRef"}): number {
+  return state.getFloat32(${baseOffset} + 8, true);
+}
+
+/** Set ${comp.name}${isScalar ? "" : "." + field.name}.z */
+export function set${comp.name}${suffix}Z(state: DataView${isSingleton ? "" : ", entity: EntityRef"}, value: number): void {
+  state.setFloat32(${baseOffset} + 8, value, true);
+}
+
+/** Get ${comp.name}${isScalar ? "" : "." + field.name}.w */
+export function get${comp.name}${suffix}W(state: DataView${isSingleton ? "" : ", entity: EntityRef"}): number {
+  return state.getFloat32(${baseOffset} + 12, true);
+}
+
+/** Set ${comp.name}${isScalar ? "" : "." + field.name}.w */
+export function set${comp.name}${suffix}W(state: DataView${isSingleton ? "" : ", entity: EntityRef"}, value: number): void {
+  state.setFloat32(${baseOffset} + 12, value, true);
+}
+`;
+  }
+  if (field.type === "enum" && field.variants) {
+    let enumOut = `
+// ${comp.name}${isScalar ? "" : "." + field.name} enum values
+`;
+    for (let i = 0; i < field.variants.length; i++) {
+      const constName = isScalar ? `${UPPER}_${toUpperSnake(field.variants[i])}` : `${UPPER}_${toUpperSnake(field.name)}_${toUpperSnake(field.variants[i])}`;
+      enumOut += `export const ${constName} = ${i};
+`;
+    }
+    enumOut += `
+/** Get ${comp.name}${isScalar ? "" : "." + field.name} value */
+export function get${comp.name}${suffix}(state: DataView${isSingleton ? "" : ", entity: EntityRef"}): number {
+  return state.getUint8(${offsetExpr});
+}
+
+/** Set ${comp.name}${isScalar ? "" : "." + field.name} value */
+export function set${comp.name}${suffix}(state: DataView${isSingleton ? "" : ", entity: EntityRef"}, value: number): void {
+  state.setUint8(${offsetExpr}, value);
+}
+`;
+    return enumOut;
+  }
+  const isBool = field.type === "bool";
+  const endianArg = fieldNeedsEndian(field) ? ", true" : "";
+  return `
+/** Get ${comp.name}${isScalar ? "" : "." + field.name} value */
+export function get${comp.name}${suffix}(state: DataView${isSingleton ? "" : ", entity: EntityRef"}): ${tsType(field)} {
+${isBool ? `  return state.${tsLoadFn(field)}(${offsetExpr}) !== 0;` : `  return state.${tsLoadFn(field)}(${offsetExpr}${endianArg});`}
+}
+
+/** Set ${comp.name}${isScalar ? "" : "." + field.name} value */
+export function set${comp.name}${suffix}(state: DataView${isSingleton ? "" : ", entity: EntityRef"}, value: ${tsType(field)}): void {
+${isBool ? `  state.${tsStoreFn(field)}(${offsetExpr}, value ? 1 : 0);` : `  state.${tsStoreFn(field)}(${offsetExpr}, value${endianArg});`}
+}
+`;
+}
+function generateSingletonAccessors(comp) {
+  let out = `
+// ---------- ${comp.name} Singleton ----------
+`;
+  for (const field of comp.fields) {
+    out += generateFieldAccessors(comp, field, true);
+  }
+  return out;
+}
+function generateEventAccessors(event) {
+  const UPPER = toUpperSnake(event.name);
+  let out = `
+// ---------- ${event.name} Event ----------
+
+export const ${UPPER}_MAX_EVENTS = ${event.maxEvents};
+export const ${UPPER}_RECORD_SIZE = ${event.recordSize};
+const ${UPPER}_OFFSET = ${event.storageOffset};
+
+/** Clear all ${event.name} events (call at tick start) */
+export function clear${event.name}Events(state: DataView): void {
+  state.setUint16(${UPPER}_OFFSET, 0, true);
+}
+
+/** Get count of ${event.name} events this tick */
+export function get${event.name}Count(state: DataView): number {
+  return state.getUint16(${UPPER}_OFFSET, true);
+}
+
+`;
+  const pushParams = [];
+  const pushWrites = [];
+  for (const field of event.fields) {
+    if (field.type === "vec2") {
+      pushParams.push(`${toCamelCase(field.name)}X: number`);
+      pushParams.push(`${toCamelCase(field.name)}Y: number`);
+      pushWrites.push(`  state.setFloat32(recordOffset + ${field.offset}, ${toCamelCase(field.name)}X, true);`);
+      pushWrites.push(`  state.setFloat32(recordOffset + ${field.offset} + 4, ${toCamelCase(field.name)}Y, true);`);
+    } else if (field.type === "vec3") {
+      pushParams.push(`${toCamelCase(field.name)}X: number`);
+      pushParams.push(`${toCamelCase(field.name)}Y: number`);
+      pushParams.push(`${toCamelCase(field.name)}Z: number`);
+      pushWrites.push(`  state.setFloat32(recordOffset + ${field.offset}, ${toCamelCase(field.name)}X, true);`);
+      pushWrites.push(`  state.setFloat32(recordOffset + ${field.offset} + 4, ${toCamelCase(field.name)}Y, true);`);
+      pushWrites.push(`  state.setFloat32(recordOffset + ${field.offset} + 8, ${toCamelCase(field.name)}Z, true);`);
+    } else if (field.type === "quat") {
+      pushParams.push(`${toCamelCase(field.name)}X: number`);
+      pushParams.push(`${toCamelCase(field.name)}Y: number`);
+      pushParams.push(`${toCamelCase(field.name)}Z: number`);
+      pushParams.push(`${toCamelCase(field.name)}W: number`);
+      pushWrites.push(`  state.setFloat32(recordOffset + ${field.offset}, ${toCamelCase(field.name)}X, true);`);
+      pushWrites.push(`  state.setFloat32(recordOffset + ${field.offset} + 4, ${toCamelCase(field.name)}Y, true);`);
+      pushWrites.push(`  state.setFloat32(recordOffset + ${field.offset} + 8, ${toCamelCase(field.name)}Z, true);`);
+      pushWrites.push(`  state.setFloat32(recordOffset + ${field.offset} + 12, ${toCamelCase(field.name)}W, true);`);
+    } else if (field.type === "bool") {
+      pushParams.push(`${toCamelCase(field.name)}: ${tsType(field)}`);
+      pushWrites.push(`  state.${tsStoreFn(field)}(recordOffset + ${field.offset}, ${toCamelCase(field.name)} ? 1 : 0);`);
+    } else {
+      pushParams.push(`${toCamelCase(field.name)}: ${tsType(field)}`);
+      const endianArg = fieldNeedsEndian(field) ? ", true" : "";
+      pushWrites.push(`  state.${tsStoreFn(field)}(recordOffset + ${field.offset}, ${toCamelCase(field.name)}${endianArg});`);
+    }
+  }
+  out += `/** Push a ${event.name} event. Returns false if buffer is full. */
+export function push${event.name}(
+  state: DataView,
+  ${pushParams.join(",\n  ")},
+): boolean {
+  const count = state.getUint16(${UPPER}_OFFSET, true);
+  if (count >= ${UPPER}_MAX_EVENTS) {
+    return false;
+  }
+  const recordOffset = ${UPPER}_OFFSET + 2 + count * ${UPPER}_RECORD_SIZE;
+${pushWrites.join("\n")}
+  state.setUint16(${UPPER}_OFFSET, count + 1, true);
+  return true;
+}
+
+// Indexed field accessors for ${event.name}
+`;
+  for (const field of event.fields) {
+    const suffix = toPascalCase(field.name);
+    if (field.type === "vec2") {
+      out += `
+/** Get ${event.name}.${field.name}.x at index */
+export function get${event.name}${suffix}X(state: DataView, index: number): number {
+  return state.getFloat32(${UPPER}_OFFSET + 2 + index * ${UPPER}_RECORD_SIZE + ${field.offset}, true);
+}
+
+/** Get ${event.name}.${field.name}.y at index */
+export function get${event.name}${suffix}Y(state: DataView, index: number): number {
+  return state.getFloat32(${UPPER}_OFFSET + 2 + index * ${UPPER}_RECORD_SIZE + ${field.offset} + 4, true);
+}
+`;
+    } else if (field.type === "vec3") {
+      out += `
+/** Get ${event.name}.${field.name}.x at index */
+export function get${event.name}${suffix}X(state: DataView, index: number): number {
+  return state.getFloat32(${UPPER}_OFFSET + 2 + index * ${UPPER}_RECORD_SIZE + ${field.offset}, true);
+}
+
+/** Get ${event.name}.${field.name}.y at index */
+export function get${event.name}${suffix}Y(state: DataView, index: number): number {
+  return state.getFloat32(${UPPER}_OFFSET + 2 + index * ${UPPER}_RECORD_SIZE + ${field.offset} + 4, true);
+}
+
+/** Get ${event.name}.${field.name}.z at index */
+export function get${event.name}${suffix}Z(state: DataView, index: number): number {
+  return state.getFloat32(${UPPER}_OFFSET + 2 + index * ${UPPER}_RECORD_SIZE + ${field.offset} + 8, true);
+}
+`;
+    } else if (field.type === "quat") {
+      out += `
+/** Get ${event.name}.${field.name}.x at index */
+export function get${event.name}${suffix}X(state: DataView, index: number): number {
+  return state.getFloat32(${UPPER}_OFFSET + 2 + index * ${UPPER}_RECORD_SIZE + ${field.offset}, true);
+}
+
+/** Get ${event.name}.${field.name}.y at index */
+export function get${event.name}${suffix}Y(state: DataView, index: number): number {
+  return state.getFloat32(${UPPER}_OFFSET + 2 + index * ${UPPER}_RECORD_SIZE + ${field.offset} + 4, true);
+}
+
+/** Get ${event.name}.${field.name}.z at index */
+export function get${event.name}${suffix}Z(state: DataView, index: number): number {
+  return state.getFloat32(${UPPER}_OFFSET + 2 + index * ${UPPER}_RECORD_SIZE + ${field.offset} + 8, true);
+}
+
+/** Get ${event.name}.${field.name}.w at index */
+export function get${event.name}${suffix}W(state: DataView, index: number): number {
+  return state.getFloat32(${UPPER}_OFFSET + 2 + index * ${UPPER}_RECORD_SIZE + ${field.offset} + 12, true);
+}
+`;
+    } else {
+      const isBool = field.type === "bool";
+      const endianArg = fieldNeedsEndian(field) ? ", true" : "";
+      out += `
+/** Get ${event.name}.${field.name} at index */
+export function get${event.name}${suffix}(state: DataView, index: number): ${tsType(field)} {
+${isBool ? `  return state.${tsLoadFn(field)}(${UPPER}_OFFSET + 2 + index * ${UPPER}_RECORD_SIZE + ${field.offset}) !== 0;` : `  return state.${tsLoadFn(field)}(${UPPER}_OFFSET + 2 + index * ${UPPER}_RECORD_SIZE + ${field.offset}${endianArg});`}
+}
+`;
+    }
+  }
+  const iterTypes = [];
+  const iterYields = [];
+  for (const field of event.fields) {
+    const suffix = toPascalCase(field.name);
+    if (field.type === "vec2") {
+      iterTypes.push("number", "number");
+      iterYields.push(`get${event.name}${suffix}X(state, i)`);
+      iterYields.push(`get${event.name}${suffix}Y(state, i)`);
+    } else if (field.type === "vec3") {
+      iterTypes.push("number", "number", "number");
+      iterYields.push(`get${event.name}${suffix}X(state, i)`);
+      iterYields.push(`get${event.name}${suffix}Y(state, i)`);
+      iterYields.push(`get${event.name}${suffix}Z(state, i)`);
+    } else if (field.type === "quat") {
+      iterTypes.push("number", "number", "number", "number");
+      iterYields.push(`get${event.name}${suffix}X(state, i)`);
+      iterYields.push(`get${event.name}${suffix}Y(state, i)`);
+      iterYields.push(`get${event.name}${suffix}Z(state, i)`);
+      iterYields.push(`get${event.name}${suffix}W(state, i)`);
+    } else {
+      iterTypes.push(tsType(field));
+      iterYields.push(`get${event.name}${suffix}(state, i)`);
+    }
+  }
+  out += `
+/** Iterate ${event.name} events */
+export function* iter${event.name}(state: DataView): Generator<[${iterTypes.join(", ")}]> {
+  const count = get${event.name}Count(state);
+  for (let i = 0; i < count; i++) {
+    yield [
+      ${iterYields.join(",\n      ")},
+    ];
+  }
+}
+`;
+  return out;
+}
+function isArrayType(type) {
+  return /^\w+\[\d+\]$/.test(type);
+}
+function validateInputSchemaForCodegen(schema) {
+  for (const ctrl of schema.controls) {
+    if (isArrayType(ctrl.type)) {
+      throw new Error(
+        `Input array types are not supported by codegen: control '${ctrl.name}' has type '${ctrl.type}'`
+      );
+    }
+  }
+  for (const cmd of schema.commands) {
+    for (const arg of cmd.args) {
+      if (isArrayType(arg.type) || arg.arrayLength) {
+        throw new Error(
+          `Input array types are not supported by codegen: command '${cmd.name}' argument '${arg.name}' has type '${arg.type}'`
+        );
+      }
+    }
+  }
+}
+function generateInputHeader() {
+  return `// TypeScript Input Bindings
+// Auto-generated - do not edit
+// Input Schema for TLV-encoded payloads
+
+/** Input payload size (matches protocol, always zero-padded to this size) */
+export const INPUT_PAYLOAD_SIZE = 255;
+`;
+}
+function generateControlConstants(schema) {
+  let out = `
+// =============================================================================
+// Control Index Constants
+// =============================================================================
+`;
+  for (const ctrl of schema.controls) {
+    out += `export const CONTROL_${toUpperSnake(ctrl.name)} = ${ctrl.index};
+`;
+  }
+  return out;
+}
+function generateFlagConstants(schema) {
+  let out = `
+// =============================================================================
+// Flag Bit Constants
+// =============================================================================
+`;
+  for (const ctrl of schema.controls) {
+    if (ctrl.options && ctrl.options.length > 0) {
+      out += `// ${ctrl.name} flags
+`;
+      for (let i = 0; i < ctrl.options.length; i++) {
+        out += `export const ${toUpperSnake(ctrl.name)}_${toUpperSnake(ctrl.options[i])} = ${i};
+`;
+      }
+    }
+  }
+  return out;
+}
+function generateTLVDecoders() {
+  return `
+// =============================================================================
+// TLV Decoders
+// =============================================================================
+
+/** Helper to get a DataView from a Uint8Array payload */
+function payloadView(payload: Uint8Array): DataView {
+  return new DataView(payload.buffer, payload.byteOffset, payload.byteLength);
+}
+
+/**
+ * Find a control in a TLV-encoded payload by index.
+ * Returns the data offset, or -1 if not found.
+ * TLV format: [controlIndex:1][length:1][data:length]...
+ */
+function findControl(payload: Uint8Array, index: number): number {
+  const view = payloadView(payload);
+  let offset = 0;
+  while (offset + 2 <= INPUT_PAYLOAD_SIZE) {
+    const ctrlIndex = view.getUint8(offset);
+    const dataLen = view.getUint8(offset + 1);
+    const nextOffset = offset + 2 + dataLen;
+
+    if (nextOffset > INPUT_PAYLOAD_SIZE) {
+      return -1; // malformed
+    }
+
+    if (dataLen > 0 && ctrlIndex === index) {
+      return offset + 2;
+    }
+
+    offset = nextOffset;
+  }
+  return -1;
+}
+
+/** Iterator over TLV entries in a payload. */
+export function* iterControls(payload: Uint8Array): Generator<[number, number, number]> {
+  const view = payloadView(payload);
+  let offset = 0;
+  while (offset + 2 <= INPUT_PAYLOAD_SIZE) {
+    const ctrlIndex = view.getUint8(offset);
+    const dataLen = view.getUint8(offset + 1);
+    const nextOffset = offset + 2 + dataLen;
+
+    if (nextOffset > INPUT_PAYLOAD_SIZE) {
+      return;
+    }
+
+    if (dataLen > 0) {
+      yield [ctrlIndex, offset + 2, dataLen];
+    }
+
+    offset = nextOffset;
+  }
+}
+
+/** Iterator over TLV entries matching a specific control index. */
+export function* iterControlsWithIndex(payload: Uint8Array, index: number): Generator<[number, number]> {
+  for (const [ctrlIndex, dataOffset, dataLen] of iterControls(payload)) {
+    if (ctrlIndex === index) {
+      yield [dataOffset, dataLen];
+    }
+  }
+}
+
+// Helper to read values from payload using DataView for type safety
+export function readU8(payload: Uint8Array, offset: number): number {
+  return payloadView(payload).getUint8(offset);
+}
+
+export function readI8(payload: Uint8Array, offset: number): number {
+  return payloadView(payload).getInt8(offset);
+}
+
+export function readU16(payload: Uint8Array, offset: number): number {
+  return payloadView(payload).getUint16(offset, true);
+}
+
+export function readI16(payload: Uint8Array, offset: number): number {
+  return payloadView(payload).getInt16(offset, true);
+}
+
+export function readU32(payload: Uint8Array, offset: number): number {
+  return payloadView(payload).getUint32(offset, true);
+}
+
+export function readI32(payload: Uint8Array, offset: number): number {
+  return payloadView(payload).getInt32(offset, true);
+}
+
+export function readF32(payload: Uint8Array, offset: number): number {
+  return payloadView(payload).getFloat32(offset, true);
+}
+`;
+}
+function generateControlAccessors(ctrl) {
+  const pascal = toPascalCase(ctrl.name);
+  let out = `
+// ---------- ${ctrl.name} (index ${ctrl.index}, type ${ctrl.type}) ----------
+`;
+  switch (ctrl.type) {
+    case "flags8":
+      out += `
+/** Get ${ctrl.name} flags byte from payload, or 0 if not present. */
+export function get${pascal}FromPayload(payload: Uint8Array): number {
+  const offset = findControl(payload, ${ctrl.index});
+  if (offset < 0) {
+    return 0;
+  }
+  return readU8(payload, offset);
+}
+
+/** Check if a specific bit is set in ${ctrl.name}. */
+export function is${pascal}SetOnPayload(payload: Uint8Array, bit: number): boolean {
+  return (get${pascal}FromPayload(payload) & (1 << bit)) !== 0;
+}
+`;
+      break;
+    case "flags16":
+      out += `
+/** Get ${ctrl.name} flags word from payload, or 0 if not present. */
+export function get${pascal}FromPayload(payload: Uint8Array): number {
+  const offset = findControl(payload, ${ctrl.index});
+  if (offset < 0) {
+    return 0;
+  }
+  return readU16(payload, offset);
+}
+
+/** Check if a specific bit is set in ${ctrl.name}. */
+export function is${pascal}SetOnPayload(payload: Uint8Array, bit: number): boolean {
+  return (get${pascal}FromPayload(payload) & (1 << bit)) !== 0;
+}
+`;
+      break;
+    case "flags32":
+      out += `
+/** Get ${ctrl.name} flags dword from payload, or 0 if not present. */
+export function get${pascal}FromPayload(payload: Uint8Array): number {
+  const offset = findControl(payload, ${ctrl.index});
+  if (offset < 0) {
+    return 0;
+  }
+  return readU32(payload, offset);
+}
+
+/** Check if a specific bit is set in ${ctrl.name}. */
+export function is${pascal}SetOnPayload(payload: Uint8Array, bit: number): boolean {
+  return (get${pascal}FromPayload(payload) & (1 << bit)) !== 0;
+}
+`;
+      break;
+    case "bool":
+      out += `
+/** Get ${ctrl.name} boolean from payload, or false if not present. */
+export function get${pascal}FromPayload(payload: Uint8Array): boolean {
+  const offset = findControl(payload, ${ctrl.index});
+  if (offset < 0) {
+    return false;
+  }
+  return readU8(payload, offset) !== 0;
+}
+`;
+      break;
+    case "uint8":
+      out += `
+/** Get ${ctrl.name} value from payload, or 0 if not present. */
+export function get${pascal}FromPayload(payload: Uint8Array): number {
+  const offset = findControl(payload, ${ctrl.index});
+  if (offset < 0) {
+    return 0;
+  }
+  return readU8(payload, offset);
+}
+`;
+      break;
+    case "int8":
+      out += `
+/** Get ${ctrl.name} value from payload, or 0 if not present. */
+export function get${pascal}FromPayload(payload: Uint8Array): number {
+  const offset = findControl(payload, ${ctrl.index});
+  if (offset < 0) {
+    return 0;
+  }
+  return readI8(payload, offset);
+}
+`;
+      break;
+    case "uint16":
+      out += `
+/** Get ${ctrl.name} value from payload, or 0 if not present. */
+export function get${pascal}FromPayload(payload: Uint8Array): number {
+  const offset = findControl(payload, ${ctrl.index});
+  if (offset < 0) {
+    return 0;
+  }
+  return readU16(payload, offset);
+}
+`;
+      break;
+    case "int16":
+      out += `
+/** Get ${ctrl.name} value from payload, or 0 if not present. */
+export function get${pascal}FromPayload(payload: Uint8Array): number {
+  const offset = findControl(payload, ${ctrl.index});
+  if (offset < 0) {
+    return 0;
+  }
+  return readI16(payload, offset);
+}
+`;
+      break;
+    case "uint32":
+      out += `
+/** Get ${ctrl.name} value from payload, or 0 if not present. */
+export function get${pascal}FromPayload(payload: Uint8Array): number {
+  const offset = findControl(payload, ${ctrl.index});
+  if (offset < 0) {
+    return 0;
+  }
+  return readU32(payload, offset);
+}
+`;
+      break;
+    case "int32":
+      out += `
+/** Get ${ctrl.name} value from payload, or 0 if not present. */
+export function get${pascal}FromPayload(payload: Uint8Array): number {
+  const offset = findControl(payload, ${ctrl.index});
+  if (offset < 0) {
+    return 0;
+  }
+  return readI32(payload, offset);
+}
+`;
+      break;
+    case "f32":
+      out += `
+/** Get ${ctrl.name} value (f32) from payload, or 0 if not present. */
+export function get${pascal}FromPayload(payload: Uint8Array): number {
+  const offset = findControl(payload, ${ctrl.index});
+  if (offset < 0) {
+    return 0;
+  }
+  return readF32(payload, offset);
+}
+`;
+      break;
+    case "vec2":
+      out += `
+/** Get ${ctrl.name}.x (f32) from payload, or 0 if not present. */
+export function get${pascal}XFromPayload(payload: Uint8Array): number {
+  const offset = findControl(payload, ${ctrl.index});
+  if (offset < 0) {
+    return 0;
+  }
+  return readF32(payload, offset);
+}
+
+/** Get ${ctrl.name}.y (f32) from payload, or 0 if not present. */
+export function get${pascal}YFromPayload(payload: Uint8Array): number {
+  const offset = findControl(payload, ${ctrl.index});
+  if (offset < 0) {
+    return 0;
+  }
+  return readF32(payload, offset + 4);
+}
+
+/** Get ${ctrl.name} as [x, y] from payload, or [0, 0] if not present. */
+export function get${pascal}FromPayload(payload: Uint8Array): [number, number] {
+  const offset = findControl(payload, ${ctrl.index});
+  if (offset < 0) {
+    return [0, 0];
+  }
+  return [readF32(payload, offset), readF32(payload, offset + 4)];
+}
+`;
+      break;
+    case "vec3":
+      out += `
+/** Get ${ctrl.name}.x (f32) from payload, or 0 if not present. */
+export function get${pascal}XFromPayload(payload: Uint8Array): number {
+  const offset = findControl(payload, ${ctrl.index});
+  if (offset < 0) {
+    return 0;
+  }
+  return readF32(payload, offset);
+}
+
+/** Get ${ctrl.name}.y (f32) from payload, or 0 if not present. */
+export function get${pascal}YFromPayload(payload: Uint8Array): number {
+  const offset = findControl(payload, ${ctrl.index});
+  if (offset < 0) {
+    return 0;
+  }
+  return readF32(payload, offset + 4);
+}
+
+/** Get ${ctrl.name}.z (f32) from payload, or 0 if not present. */
+export function get${pascal}ZFromPayload(payload: Uint8Array): number {
+  const offset = findControl(payload, ${ctrl.index});
+  if (offset < 0) {
+    return 0;
+  }
+  return readF32(payload, offset + 8);
+}
+
+/** Get ${ctrl.name} as [x, y, z] from payload, or [0, 0, 0] if not present. */
+export function get${pascal}FromPayload(payload: Uint8Array): [number, number, number] {
+  const offset = findControl(payload, ${ctrl.index});
+  if (offset < 0) {
+    return [0, 0, 0];
+  }
+  return [readF32(payload, offset), readF32(payload, offset + 4), readF32(payload, offset + 8)];
+}
+`;
+      break;
+    case "quat":
+      out += `
+/** Get ${ctrl.name}.x (f32) from payload, or 0 if not present. */
+export function get${pascal}XFromPayload(payload: Uint8Array): number {
+  const offset = findControl(payload, ${ctrl.index});
+  if (offset < 0) {
+    return 0;
+  }
+  return readF32(payload, offset);
+}
+
+/** Get ${ctrl.name}.y (f32) from payload, or 0 if not present. */
+export function get${pascal}YFromPayload(payload: Uint8Array): number {
+  const offset = findControl(payload, ${ctrl.index});
+  if (offset < 0) {
+    return 0;
+  }
+  return readF32(payload, offset + 4);
+}
+
+/** Get ${ctrl.name}.z (f32) from payload, or 0 if not present. */
+export function get${pascal}ZFromPayload(payload: Uint8Array): number {
+  const offset = findControl(payload, ${ctrl.index});
+  if (offset < 0) {
+    return 0;
+  }
+  return readF32(payload, offset + 8);
+}
+
+/** Get ${ctrl.name}.w (f32) from payload, or 1 if not present (identity quaternion). */
+export function get${pascal}WFromPayload(payload: Uint8Array): number {
+  const offset = findControl(payload, ${ctrl.index});
+  if (offset < 0) {
+    return 1;
+  }
+  return readF32(payload, offset + 12);
+}
+
+/** Get ${ctrl.name} as [x, y, z, w] from payload, or [0, 0, 0, 1] if not present. */
+export function get${pascal}FromPayload(payload: Uint8Array): [number, number, number, number] {
+  const offset = findControl(payload, ${ctrl.index});
+  if (offset < 0) {
+    return [0, 0, 0, 1];
+  }
+  return [readF32(payload, offset), readF32(payload, offset + 4), readF32(payload, offset + 8), readF32(payload, offset + 12)];
+}
+`;
+      break;
+  }
+  return out;
+}
+function generateCommandAccessors(cmd) {
+  const pascal = toPascalCase(cmd.name);
+  let out = `
+// ---------- ${cmd.name} (index ${cmd.index}) ----------
+
+/** Check if ${cmd.name} command is present in payload. */
+export function has${pascal}OnPayload(payload: Uint8Array): boolean {
+  return findControl(payload, ${cmd.index}) >= 0;
+}
+`;
+  const iterTypes = [];
+  const iterVars = [];
+  const iterYields = [];
+  for (const arg of cmd.args) {
+    const camel = toCamelCase(arg.name);
+    if (arg.type === "vec2") {
+      iterTypes.push("number", "number");
+      iterVars.push(`    const ${camel}X = readF32(payload, dataOffset + ${arg.offset});`);
+      iterVars.push(`    const ${camel}Y = readF32(payload, dataOffset + ${arg.offset} + 4);`);
+      iterYields.push(`${camel}X`, `${camel}Y`);
+    } else if (arg.type === "vec3") {
+      iterTypes.push("number", "number", "number");
+      iterVars.push(`    const ${camel}X = readF32(payload, dataOffset + ${arg.offset});`);
+      iterVars.push(`    const ${camel}Y = readF32(payload, dataOffset + ${arg.offset} + 4);`);
+      iterVars.push(`    const ${camel}Z = readF32(payload, dataOffset + ${arg.offset} + 8);`);
+      iterYields.push(`${camel}X`, `${camel}Y`, `${camel}Z`);
+    } else if (arg.type === "quat") {
+      iterTypes.push("number", "number", "number", "number");
+      iterVars.push(`    const ${camel}X = readF32(payload, dataOffset + ${arg.offset});`);
+      iterVars.push(`    const ${camel}Y = readF32(payload, dataOffset + ${arg.offset} + 4);`);
+      iterVars.push(`    const ${camel}Z = readF32(payload, dataOffset + ${arg.offset} + 8);`);
+      iterVars.push(`    const ${camel}W = readF32(payload, dataOffset + ${arg.offset} + 12);`);
+      iterYields.push(`${camel}X`, `${camel}Y`, `${camel}Z`, `${camel}W`);
+    } else {
+      iterTypes.push(tsInputType(arg.type));
+      const readFn = arg.type === "f32" ? "readF32" : arg.type === "uint8" ? "readU8" : arg.type === "int8" ? "readI8" : arg.type === "uint16" ? "readU16" : arg.type === "int16" ? "readI16" : arg.type === "uint32" ? "readU32" : arg.type === "int32" ? "readI32" : "readU8";
+      iterVars.push(`    const ${camel} = ${readFn}(payload, dataOffset + ${arg.offset});`);
+      iterYields.push(camel);
+    }
+  }
+  if (cmd.args.length > 0) {
+    out += `
+/** Iterate all ${cmd.name} commands in a payload. */
+export function* iter${pascal}OnPayload(payload: Uint8Array): Generator<[${iterTypes.join(", ")}]> {
+  for (const [dataOffset, dataLen] of iterControlsWithIndex(payload, ${cmd.index})) {
+    if (dataLen < ${cmd.totalSize}) {
+      continue;
+    }
+${iterVars.join("\n")}
+    yield [${iterYields.join(", ")}];
+  }
+}
+`;
+  } else {
+    out += `
+/** Iterate all ${cmd.name} commands in a payload. */
+export function* iter${pascal}OnPayload(payload: Uint8Array): Generator<void> {
+  for (const [dataOffset, dataLen] of iterControlsWithIndex(payload, ${cmd.index})) {
+    if (dataLen < ${cmd.totalSize}) {
+      continue;
+    }
+    yield;
+  }
+}
+`;
+  }
+  for (const arg of cmd.args) {
+    const argPascal = toPascalCase(arg.name);
+    if (arg.type === "vec2") {
+      out += `
+/** Get ${cmd.name}.${arg.name}.x (f32), or 0 if command not present. */
+export function get${pascal}${argPascal}XFromPayload(payload: Uint8Array): number {
+  const offset = findControl(payload, ${cmd.index});
+  if (offset < 0) {
+    return 0;
+  }
+  return readF32(payload, offset + ${arg.offset});
+}
+
+/** Get ${cmd.name}.${arg.name}.y (f32), or 0 if command not present. */
+export function get${pascal}${argPascal}YFromPayload(payload: Uint8Array): number {
+  const offset = findControl(payload, ${cmd.index});
+  if (offset < 0) {
+    return 0;
+  }
+  return readF32(payload, offset + ${arg.offset} + 4);
+}
+`;
+    } else if (arg.type === "vec3") {
+      out += `
+/** Get ${cmd.name}.${arg.name}.x (f32), or 0 if command not present. */
+export function get${pascal}${argPascal}XFromPayload(payload: Uint8Array): number {
+  const offset = findControl(payload, ${cmd.index});
+  if (offset < 0) {
+    return 0;
+  }
+  return readF32(payload, offset + ${arg.offset});
+}
+
+/** Get ${cmd.name}.${arg.name}.y (f32), or 0 if command not present. */
+export function get${pascal}${argPascal}YFromPayload(payload: Uint8Array): number {
+  const offset = findControl(payload, ${cmd.index});
+  if (offset < 0) {
+    return 0;
+  }
+  return readF32(payload, offset + ${arg.offset} + 4);
+}
+
+/** Get ${cmd.name}.${arg.name}.z (f32), or 0 if command not present. */
+export function get${pascal}${argPascal}ZFromPayload(payload: Uint8Array): number {
+  const offset = findControl(payload, ${cmd.index});
+  if (offset < 0) {
+    return 0;
+  }
+  return readF32(payload, offset + ${arg.offset} + 8);
+}
+`;
+    } else if (arg.type === "quat") {
+      out += `
+/** Get ${cmd.name}.${arg.name}.x (f32), or 0 if command not present. */
+export function get${pascal}${argPascal}XFromPayload(payload: Uint8Array): number {
+  const offset = findControl(payload, ${cmd.index});
+  if (offset < 0) {
+    return 0;
+  }
+  return readF32(payload, offset + ${arg.offset});
+}
+
+/** Get ${cmd.name}.${arg.name}.y (f32), or 0 if command not present. */
+export function get${pascal}${argPascal}YFromPayload(payload: Uint8Array): number {
+  const offset = findControl(payload, ${cmd.index});
+  if (offset < 0) {
+    return 0;
+  }
+  return readF32(payload, offset + ${arg.offset} + 4);
+}
+
+/** Get ${cmd.name}.${arg.name}.z (f32), or 0 if command not present. */
+export function get${pascal}${argPascal}ZFromPayload(payload: Uint8Array): number {
+  const offset = findControl(payload, ${cmd.index});
+  if (offset < 0) {
+    return 0;
+  }
+  return readF32(payload, offset + ${arg.offset} + 8);
+}
+
+/** Get ${cmd.name}.${arg.name}.w (f32), or 1 if command not present (identity quaternion). */
+export function get${pascal}${argPascal}WFromPayload(payload: Uint8Array): number {
+  const offset = findControl(payload, ${cmd.index});
+  if (offset < 0) {
+    return 1;
+  }
+  return readF32(payload, offset + ${arg.offset} + 12);
+}
+`;
+    } else {
+      const readFn = arg.type === "f32" ? "readF32" : arg.type === "uint8" ? "readU8" : arg.type === "int8" ? "readI8" : arg.type === "uint16" ? "readU16" : arg.type === "int16" ? "readI16" : arg.type === "uint32" ? "readU32" : arg.type === "int32" ? "readI32" : "readU8";
+      out += `
+/** Get ${cmd.name}.${arg.name} value, or 0 if command not present. */
+export function get${pascal}${argPascal}FromPayload(payload: Uint8Array): ${tsInputType(arg.type)} {
+  const offset = findControl(payload, ${cmd.index});
+  if (offset < 0) {
+    return 0;
+  }
+  return ${readFn}(payload, offset + ${arg.offset});
+}
+`;
+    }
+  }
+  return out;
+}
+var TypeScriptGenerator = class {
+  language = "typescript";
+  opts;
+  constructor(opts = {}) {
+    this.opts = opts;
+  }
+  generateState(schema) {
+    let out = generateStateHeader(schema);
+    out += generateComponentOffsets(schema);
+    out += generateEntityHelpers();
+    out += generateIterationHelpers(schema);
+    out += generateQueryHelpers();
+    out += generateLifecycle(schema);
+    out += `
+// =============================================================================
+// Component Operations
+// =============================================================================
+`;
+    for (const comp of schema.entityComponents) {
+      out += generateComponentAccessors(comp);
+    }
+    if (schema.singletonComponents.length > 0) {
+      out += `
+// =============================================================================
+// Singleton Components
+// =============================================================================
+`;
+      for (const comp of schema.singletonComponents) {
+        out += generateSingletonAccessors(comp);
+      }
+    }
+    if (schema.events && schema.events.length > 0) {
+      out += `
+// =============================================================================
+// Events
+// =============================================================================
+`;
+      for (const event of schema.events) {
+        out += generateEventAccessors(event);
+      }
+    }
+    return out;
+  }
+  generateInput(schema) {
+    validateInputSchemaForCodegen(schema);
+    let out = generateInputHeader();
+    out += generateControlConstants(schema);
+    out += generateFlagConstants(schema);
+    out += generateTLVDecoders();
+    out += `
+// =============================================================================
+// Payload-Level Control Accessors
+// =============================================================================
+`;
+    for (const ctrl of schema.controls) {
+      out += generateControlAccessors(ctrl);
+    }
+    if (schema.commands.length > 0) {
+      out += `
+// =============================================================================
+// Command Index Constants
+// =============================================================================
+`;
+      for (const cmd of schema.commands) {
+        out += `export const COMMAND_${toUpperSnake(cmd.name)} = ${cmd.index};
+`;
+      }
+      out += `
+// =============================================================================
+// Payload-Level Command Accessors
+// =============================================================================
+`;
+      for (const cmd of schema.commands) {
+        out += generateCommandAccessors(cmd);
+      }
+    }
+    return out;
+  }
+  generateGame(state, input) {
+    return this.generateState(state) + "\n" + this.generateInput(input);
+  }
+};
+
+// src/codegen/rust.ts
+function rustType(field) {
+  if (field.arrayElementType) {
+    return rustTypeMapping(field.arrayElementType);
+  }
+  if (field.type === "vec2" || field.type === "vec3" || field.type === "quat") {
+    return "f32";
+  }
+  if (field.type === "enum") {
+    return "u8";
+  }
+  return rustTypeMapping(field.type);
+}
+function rustTypeMapping(typ) {
+  switch (typ) {
+    case "bool":
+      return "bool";
+    case "uint8":
+      return "u8";
+    case "int8":
+      return "i8";
+    case "uint16":
+      return "u16";
+    case "int16":
+      return "i16";
+    case "uint32":
+    case "entityRef":
+      return "u32";
+    case "int32":
+      return "i32";
+    case "f32":
+      return "f32";
+    default:
+      throw new Error(`Unknown type '${typ}' in Rust code generation`);
+  }
+}
+function rustInputType(typ) {
+  switch (typ) {
+    case "bool":
+      return "bool";
+    case "uint8":
+    case "flags8":
+      return "u8";
+    case "int8":
+      return "i8";
+    case "uint16":
+    case "flags16":
+      return "u16";
+    case "int16":
+      return "i16";
+    case "uint32":
+    case "flags32":
+      return "u32";
+    case "int32":
+      return "i32";
+    case "f32":
+    case "vec2":
+    case "vec3":
+    case "quat":
+      return "f32";
+    default:
+      throw new Error(`Unknown input type '${typ}' in Rust code generation`);
+  }
+}
+function loadFn(field) {
+  let typ = field.type;
+  if (field.arrayElementType) {
+    typ = field.arrayElementType;
+  }
+  if (typ === "vec2" || typ === "vec3" || typ === "quat") {
+    typ = "f32";
+  }
+  if (typ === "enum") {
+    typ = "uint8";
+  }
+  return loadFnForType(typ);
+}
+function loadFnForType(typ) {
+  switch (typ) {
+    case "bool":
+      return "load_bool";
+    case "uint8":
+      return "load_u8";
+    case "int8":
+      return "load_i8";
+    case "uint16":
+      return "load_u16";
+    case "int16":
+      return "load_i16";
+    case "uint32":
+    case "entityRef":
+      return "load_u32";
+    case "int32":
+      return "load_i32";
+    case "f32":
+      return "load_f32";
+    default:
+      throw new Error(`Unknown type '${typ}' in Rust load function generation`);
+  }
+}
+function storeFn(field) {
+  let typ = field.type;
+  if (field.arrayElementType) {
+    typ = field.arrayElementType;
+  }
+  if (typ === "vec2" || typ === "vec3" || typ === "quat") {
+    typ = "f32";
+  }
+  if (typ === "enum") {
+    typ = "uint8";
+  }
+  return storeFnForType(typ);
+}
+function storeFnForType(typ) {
+  switch (typ) {
+    case "bool":
+      return "store_bool";
+    case "uint8":
+      return "store_u8";
+    case "int8":
+      return "store_i8";
+    case "uint16":
+      return "store_u16";
+    case "int16":
+      return "store_i16";
+    case "uint32":
+    case "entityRef":
+      return "store_u32";
+    case "int32":
+      return "store_i32";
+    case "f32":
+      return "store_f32";
+    default:
+      throw new Error(`Unknown type '${typ}' in Rust store function generation`);
+  }
+}
+function fieldElemSize2(field) {
+  if (field.arrayElementType) {
+    return getElementSize(field.arrayElementType);
+  }
+  return getElementSize(field.type);
+}
+function generateStateHeader2(schema) {
+  return `// Language: Rust
+// MaxEntities: ${schema.maxEntities}
+// TotalSize: ${schema.totalSize} bytes
+
+use core::ptr;
+
+// =============================================================================
+// Constants
+// =============================================================================
+
+pub const MAX_ENTITIES: u32 = ${schema.maxEntities};
+pub const HEADER_SIZE: u32 = ${schema.headerSize};
+pub const ENTITY_TABLE_OFFSET: u32 = ${schema.entityTableOffset};
+pub const ENTITY_RECORD_SIZE: u32 = ${schema.entityRecordSize};
+pub const FREE_STACK_OFFSET: u32 = ${schema.freeStackOffset};
+pub const FREE_STACK_SIZE: u32 = ${schema.freeStackSize};
+pub const COMPONENT_STORAGE_OFFSET: u32 = ${schema.componentStorageOffset};
+pub const SINGLETON_STORAGE_OFFSET: u32 = ${schema.singletonStorageOffset};
+pub const BITMASK_SIZE: u32 = ${schema.bitmaskSize};
+
+// State ID location in header
+pub const STATE_ID_OFFSET: u32 = 8;
+pub const STATE_ID_SIZE: u32 = 32;
+
+// Tick location in header
+pub const TICK_OFFSET: u32 = 40;
+
+// Tick rate location in header (uses one of the reserved bytes)
+pub const TICK_RATE_OFFSET: u32 = 6;
+`;
+}
+function generateComponentOffsets2(schema) {
+  let out = `
+// =============================================================================
+// Component Offsets
+// =============================================================================
+`;
+  for (const comp of schema.components) {
+    if (!comp.isSingleton) {
+      out += `pub const ${toUpperSnake(comp.name)}_BIT: u8 = ${comp.index};
+`;
+    }
+    if (comp.size > 0) {
+      out += `const ${toUpperSnake(comp.name)}_OFFSET: u32 = ${comp.storageOffset};
+`;
+      out += `const ${toUpperSnake(comp.name)}_SIZE: u32 = ${comp.size};
+`;
+    }
+  }
+  out += `
+// Component bit constants for query() - PascalCase for API ergonomics
+`;
+  out += `#[allow(non_upper_case_globals)]
+`;
+  for (const comp of schema.entityComponents) {
+    out += `pub const ${comp.name}: u8 = ${toUpperSnake(comp.name)}_BIT;
+`;
+  }
+  return out;
+}
+function generateMemoryHelpers() {
+  return `
+// =============================================================================
+// Entity Reference
+// =============================================================================
+
+pub type EntityRef = u32;
+pub const NULL_ENTITY: EntityRef = 0xFFFFFFFF;
+
+/// Pack entity index and generation into an EntityRef
+#[inline]
+pub fn pack_ref(index: u16, generation: u16) -> EntityRef {
+    ((generation as u32) << 16) | (index as u32)
+}
+
+/// Extract entity index from EntityRef
+#[inline]
+pub fn unpack_index(entity: EntityRef) -> u16 {
+    (entity & 0xFFFF) as u16
+}
+
+/// Extract generation from EntityRef
+#[inline]
+pub fn unpack_generation(entity: EntityRef) -> u16 {
+    (entity >> 16) as u16
+}
+
+// =============================================================================
+// Low-Level Memory Access
+// =============================================================================
+
+#[inline]
+unsafe fn load_u8(ptr: *const u8) -> u8 {
+    ptr::read_unaligned(ptr)
+}
+
+#[inline]
+unsafe fn load_bool(ptr: *const u8) -> bool {
+    ptr::read_unaligned(ptr) != 0
+}
+
+#[inline]
+unsafe fn load_i8(ptr: *const u8) -> i8 {
+    ptr::read_unaligned(ptr as *const i8)
+}
+
+#[inline]
+unsafe fn load_u16(ptr: *const u8) -> u16 {
+    ptr::read_unaligned(ptr as *const u16)
+}
+
+#[inline]
+unsafe fn load_i16(ptr: *const u8) -> i16 {
+    ptr::read_unaligned(ptr as *const i16)
+}
+
+#[inline]
+unsafe fn load_u32(ptr: *const u8) -> u32 {
+    ptr::read_unaligned(ptr as *const u32)
+}
+
+#[inline]
+unsafe fn load_i32(ptr: *const u8) -> i32 {
+    ptr::read_unaligned(ptr as *const i32)
+}
+
+#[inline]
+unsafe fn store_u8(ptr: *mut u8, value: u8) {
+    ptr::write_unaligned(ptr, value);
+}
+
+#[inline]
+unsafe fn store_bool(ptr: *mut u8, value: bool) {
+    ptr::write_unaligned(ptr, value as u8);
+}
+
+#[inline]
+unsafe fn store_i8(ptr: *mut u8, value: i8) {
+    ptr::write_unaligned(ptr as *mut i8, value);
+}
+
+#[inline]
+unsafe fn store_u16(ptr: *mut u8, value: u16) {
+    ptr::write_unaligned(ptr as *mut u16, value);
+}
+
+#[inline]
+unsafe fn store_i16(ptr: *mut u8, value: i16) {
+    ptr::write_unaligned(ptr as *mut i16, value);
+}
+
+#[inline]
+unsafe fn store_u32(ptr: *mut u8, value: u32) {
+    ptr::write_unaligned(ptr as *mut u32, value);
+}
+
+#[inline]
+unsafe fn store_i32(ptr: *mut u8, value: i32) {
+    ptr::write_unaligned(ptr as *mut i32, value);
+}
+
+#[inline]
+unsafe fn load_f32(ptr: *const u8) -> f32 {
+    ptr::read_unaligned(ptr as *const f32)
+}
+
+#[inline]
+unsafe fn store_f32(ptr: *mut u8, value: f32) {
+    ptr::write_unaligned(ptr as *mut f32, value);
+}
+
+#[inline]
+unsafe fn mem_fill(ptr: *mut u8, value: u8, len: usize) {
+    ptr::write_bytes(ptr, value, len);
+}
+`;
+}
+function generateInternalHelpers() {
+  return `
+// =============================================================================
+// Internal Helpers
+// =============================================================================
+
+/// Get entity record offset in entity table
+#[inline]
+fn get_entity_record_offset(index: u16) -> u32 {
+    ENTITY_TABLE_OFFSET + (index as u32) * ENTITY_RECORD_SIZE
+}
+
+/// Get entity generation from state
+#[inline]
+unsafe fn get_entity_generation(state: *const u8, index: u16) -> u16 {
+    load_u16(state.add(get_entity_record_offset(index) as usize))
+}
+
+/// Set entity generation in state
+#[inline]
+unsafe fn set_entity_generation(state: *mut u8, index: u16, generation: u16) {
+    store_u16(state.add(get_entity_record_offset(index) as usize), generation);
+}
+
+/// Get alive count from header
+#[inline]
+unsafe fn get_alive_count(state: *const u8) -> u16 {
+    load_u16(state.add(4))
+}
+
+/// Set alive count in header
+#[inline]
+unsafe fn set_alive_count(state: *mut u8, count: u16) {
+    store_u16(state.add(4), count);
+}
+
+/// Get current tick from header
+#[inline]
+pub unsafe fn get_tick(state: *const u8) -> u32 {
+    load_u32(state.add(TICK_OFFSET as usize))
+}
+
+/// Set current tick in header
+#[inline]
+pub unsafe fn set_tick(state: *mut u8, tick: u32) {
+    store_u32(state.add(TICK_OFFSET as usize), tick);
+}
+
+/// Get tick rate from header (ticks per second)
+#[inline]
+pub unsafe fn get_tick_rate(state: *const u8) -> u8 {
+    load_u8(state.add(TICK_RATE_OFFSET as usize))
+}
+
+/// Get free stack count
+#[inline]
+unsafe fn get_free_stack_count(state: *const u8) -> u16 {
+    load_u16(state.add(FREE_STACK_OFFSET as usize))
+}
+
+/// Set free stack count
+#[inline]
+unsafe fn set_free_stack_count(state: *mut u8, count: u16) {
+    store_u16(state.add(FREE_STACK_OFFSET as usize), count);
+}
+
+/// Check if component bit is set for entity
+#[inline]
+unsafe fn has_bit(state: *const u8, index: u16, bit: u8) -> bool {
+    let bitmask_offset = get_entity_record_offset(index) + 2;
+    let byte_index = (bit >> 3) as u32;
+    let bit_index = bit & 7;
+    (load_u8(state.add((bitmask_offset + byte_index) as usize)) & (1 << bit_index)) != 0
+}
+
+/// Set component bit for entity
+#[inline]
+unsafe fn set_bit(state: *mut u8, index: u16, bit: u8) {
+    let bitmask_offset = get_entity_record_offset(index) + 2;
+    let byte_index = (bit >> 3) as u32;
+    let bit_index = bit & 7;
+    let ptr = state.add((bitmask_offset + byte_index) as usize);
+    let current = load_u8(ptr);
+    store_u8(ptr, current | (1 << bit_index));
+}
+
+/// Clear component bit for entity
+#[inline]
+unsafe fn clear_bit(state: *mut u8, index: u16, bit: u8) {
+    let bitmask_offset = get_entity_record_offset(index) + 2;
+    let byte_index = (bit >> 3) as u32;
+    let bit_index = bit & 7;
+    let ptr = state.add((bitmask_offset + byte_index) as usize);
+    let current = load_u8(ptr);
+    store_u8(ptr, current & !(1 << bit_index));
+}
+`;
+}
+function generateIterationHelpers2(schema) {
+  let out = `
+// =============================================================================
+// Entity Iteration Helpers
+// =============================================================================
+
+/// Get generation for a raw slot index
+#[inline]
+pub unsafe fn get_generation_at_slot(state: *const u8, index: u16) -> u16 {
+    get_entity_generation(state, index)
+}
+
+/// Build an EntityRef for a slot using its current generation
+#[inline]
+pub unsafe fn entity_at_slot(state: *const u8, index: u16) -> EntityRef {
+    pack_ref(index, get_entity_generation(state, index))
+}
+
+/// Check if a slot has any component bits set
+#[inline]
+unsafe fn has_any_component_at_slot(state: *const u8, index: u16) -> bool {
+    let bitmask_offset = get_entity_record_offset(index) + 2;
+    for i in 0..BITMASK_SIZE {
+        if load_u8(state.add((bitmask_offset + i) as usize)) != 0 {
+            return true;
+        }
+    }
+    false
+}
+
+// Per-component slot presence checks
+`;
+  for (const comp of schema.entityComponents) {
+    out += `#[inline]
+pub unsafe fn has_${toLowerSnake(comp.name)}_at_slot(state: *const u8, index: u16) -> bool {
+    has_bit(state, index, ${toUpperSnake(comp.name)}_BIT)
+}
+`;
+  }
+  return out;
+}
+function generateQueryHelpers2() {
+  return `
+// =============================================================================
+// Entity Queries (Zero-Allocation)
+// =============================================================================
+
+/// Build a query mask from component bits (const-evaluable)
+pub const fn query_mask(bits: &[u8]) -> u64 {
+    let mut mask = 0u64;
+    let mut i = 0;
+    while i < bits.len() {
+        mask |= 1u64 << bits[i];
+        i += 1;
+    }
+    mask
+}
+
+/// Load entity component mask as u64 (handles variable BITMASK_SIZE)
+#[inline]
+unsafe fn load_component_mask(state: *const u8, bitmask_offset: u32) -> u64 {
+    let mut mask = 0u64;
+    let mut i = 0u32;
+    while i < BITMASK_SIZE {
+        mask |= (load_u8(state.add((bitmask_offset + i) as usize)) as u64) << (i * 8);
+        i += 1;
+    }
+    mask
+}
+
+/// Check if entity has all bits in mask set
+#[inline]
+unsafe fn has_mask(state: *const u8, index: u16, mask: u64) -> bool {
+    let bitmask_offset = get_entity_record_offset(index) + 2;
+    let entity_mask = load_component_mask(state, bitmask_offset);
+    (entity_mask & mask) == mask
+}
+
+/// Zero-allocation entity query iterator
+pub struct QueryIter {
+    state: *const u8,
+    index: u16,
+    required_mask: u64,
+}
+
+impl Iterator for QueryIter {
+    type Item = EntityRef;
+
+    #[inline]
+    fn next(&mut self) -> Option<Self::Item> {
+        while self.index < MAX_ENTITIES as u16 {
+            let i = self.index;
+            self.index += 1;
+
+            // Fast path: skip empty slots
+            unsafe {
+                if !has_any_component_at_slot(self.state, i) {
+                    continue;
+                }
+
+                // Check if all required bits are set
+                if !has_mask(self.state, i, self.required_mask) {
+                    continue;
+                }
+
+                let entity = entity_at_slot(self.state, i);
+                if is_alive(self.state, entity) {
+                    return Some(entity);
+                }
+            }
+        }
+        None
+    }
+}
+
+/// Create iterator for entities matching mask (zero allocation)
+pub unsafe fn iter_query(state: *const u8, required_mask: u64) -> QueryIter {
+    QueryIter {
+        state,
+        index: 0,
+        required_mask,
+    }
+}
+`;
+}
+function generateLifecycle2(schema) {
+  let despawnZeroComponents = "";
+  for (const comp of schema.entityComponents) {
+    if (!comp.isTag && comp.size > 0) {
+      despawnZeroComponents += `    mem_fill(state.add((${toUpperSnake(comp.name)}_OFFSET + (index as u32) * ${toUpperSnake(comp.name)}_SIZE) as usize), 0, ${toUpperSnake(comp.name)}_SIZE as usize);
+`;
+    }
+  }
+  return `
+// =============================================================================
+// Entity Lifecycle
+// =============================================================================
+
+/// Check if entity reference is valid (alive)
+pub unsafe fn is_alive(state: *const u8, entity: EntityRef) -> bool {
+    if entity == NULL_ENTITY {
+        return false;
+    }
+    let index = unpack_index(entity);
+    if (index as u32) >= MAX_ENTITIES {
+        return false;
+    }
+    let expected_gen = unpack_generation(entity);
+    let current_gen = get_entity_generation(state, index);
+    current_gen == expected_gen
+}
+
+/// Spawn a new entity, returns EntityRef
+pub unsafe fn spawn(state: *mut u8) -> EntityRef {
+    let count = get_free_stack_count(state);
+    if count == 0 {
+        return NULL_ENTITY;
+    }
+
+    // Pop from free stack (LIFO)
+    let entry_offset = FREE_STACK_OFFSET + 2 + ((count - 1) as u32) * 2;
+    let index = load_u16(state.add(entry_offset as usize));
+    set_free_stack_count(state, count - 1);
+
+    // Get current generation
+    let generation = get_entity_generation(state, index);
+
+    // Increment alive count
+    set_alive_count(state, get_alive_count(state) + 1);
+
+    pack_ref(index, generation)
+}
+
+/// Despawn an entity
+pub unsafe fn despawn(state: *mut u8, entity: EntityRef) {
+    if !is_alive(state, entity) {
+        return;
+    }
+
+    let index = unpack_index(entity);
+
+    // Increment generation
+    let old_gen = get_entity_generation(state, index);
+    set_entity_generation(state, index, (old_gen + 1) & 0xFFFF);
+
+    // Clear component bitmask
+    let bitmask_offset = get_entity_record_offset(index) + 2;
+    mem_fill(state.add(bitmask_offset as usize), 0, BITMASK_SIZE as usize);
+
+    // Zero all component storage for this entity
+${despawnZeroComponents}
+    // Push index back onto free stack
+    let free_count = get_free_stack_count(state);
+    let entry_offset = FREE_STACK_OFFSET + 2 + (free_count as u32) * 2;
+    store_u16(state.add(entry_offset as usize), index);
+    set_free_stack_count(state, free_count + 1);
+
+    // Decrement alive count
+    set_alive_count(state, get_alive_count(state) - 1);
+}
+`;
+}
+function generateComponentAccessors2(comp) {
+  const UPPER = toUpperSnake(comp.name);
+  const lower = toLowerSnake(comp.name);
+  let out = `
+// ---------- ${comp.name} Component ----------
+`;
+  if (comp.isTag) {
+    out += `
+/// Check if entity has ${comp.name} tag
+#[inline]
+pub unsafe fn has_${lower}(state: *const u8, entity: EntityRef) -> bool {
+    has_bit(state, unpack_index(entity), ${UPPER}_BIT)
+}
+
+/// Add ${comp.name} tag to entity
+#[inline]
+pub unsafe fn add_${lower}(state: *mut u8, entity: EntityRef) {
+    set_bit(state, unpack_index(entity), ${UPPER}_BIT);
+}
+
+/// Remove ${comp.name} tag from entity
+#[inline]
+pub unsafe fn remove_${lower}(state: *mut u8, entity: EntityRef) {
+    clear_bit(state, unpack_index(entity), ${UPPER}_BIT);
+}
+`;
+    return out;
+  }
+  out += `
+/// Check if entity has ${comp.name} component
+#[inline]
+pub unsafe fn has_${lower}(state: *const u8, entity: EntityRef) -> bool {
+    has_bit(state, unpack_index(entity), ${UPPER}_BIT)
+}
+
+/// Add ${comp.name} component to entity
+#[inline]
+pub unsafe fn add_${lower}(state: *mut u8, entity: EntityRef) {
+    set_bit(state, unpack_index(entity), ${UPPER}_BIT);
+}
+
+/// Remove ${comp.name} component from entity
+#[inline]
+pub unsafe fn remove_${lower}(state: *mut u8, entity: EntityRef) {
+    let index = unpack_index(entity);
+    clear_bit(state, index, ${UPPER}_BIT);
+    mem_fill(state.add((${UPPER}_OFFSET + (index as u32) * ${UPPER}_SIZE) as usize), 0, ${UPPER}_SIZE as usize);
+}
+`;
+  for (const field of comp.fields) {
+    out += generateFieldAccessors2(comp, field, false);
+  }
+  return out;
+}
+function generateFieldAccessors2(comp, field, isSingleton) {
+  const UPPER = toUpperSnake(comp.name);
+  const lower = toLowerSnake(comp.name);
+  const isScalar = field.name === "";
+  const fieldLower = isScalar ? "" : `_${toLowerSnake(field.name)}`;
+  const baseOffset = isSingleton ? field.offset > 0 ? `${UPPER}_OFFSET + ${field.offset}` : `${UPPER}_OFFSET` : field.offset > 0 ? `${UPPER}_OFFSET + (unpack_index(entity) as u32) * ${UPPER}_SIZE + ${field.offset}` : `${UPPER}_OFFSET + (unpack_index(entity) as u32) * ${UPPER}_SIZE`;
+  const stateParam = isSingleton ? "state: *const u8" : "state: *const u8, entity: EntityRef";
+  const stateParamMut = isSingleton ? "state: *mut u8" : "state: *mut u8, entity: EntityRef";
+  if (field.arrayLength && field.arrayLength > 0) {
+    const elemSize = fieldElemSize2(field);
+    const isBoolArray = field.arrayElementType === "bool";
+    const defaultVal = isBoolArray ? "false" : "0";
+    return `
+/// Get ${comp.name}${isScalar ? "" : "." + field.name}[index]
+#[inline]
+pub unsafe fn get_${lower}${fieldLower}(${stateParam}, index: i32) -> ${rustType(field)} {
+    if (index as u32) >= ${field.arrayLength} {
+        return ${defaultVal};
+    }
+    ${loadFn(field)}(state.add((${baseOffset} + (index as u32) * ${elemSize}) as usize))
+}
+
+/// Set ${comp.name}${isScalar ? "" : "." + field.name}[index]
+#[inline]
+pub unsafe fn set_${lower}${fieldLower}(${stateParamMut}, index: i32, value: ${rustType(field)}) {
+    if (index as u32) >= ${field.arrayLength} {
+        return;
+    }
+    ${storeFn(field)}(state.add((${baseOffset} + (index as u32) * ${elemSize}) as usize), value);
+}
+`;
+  }
+  if (field.type === "vec2") {
+    return `
+/// Get ${comp.name}${isScalar ? "" : "." + field.name}.x
+#[inline]
+pub unsafe fn get_${lower}${fieldLower}_x(${stateParam}) -> f32 {
+    load_f32(state.add((${baseOffset}) as usize))
+}
+
+/// Set ${comp.name}${isScalar ? "" : "." + field.name}.x
+#[inline]
+pub unsafe fn set_${lower}${fieldLower}_x(${stateParamMut}, value: f32) {
+    store_f32(state.add((${baseOffset}) as usize), value);
+}
+
+/// Get ${comp.name}${isScalar ? "" : "." + field.name}.y
+#[inline]
+pub unsafe fn get_${lower}${fieldLower}_y(${stateParam}) -> f32 {
+    load_f32(state.add((${baseOffset} + 4) as usize))
+}
+
+/// Set ${comp.name}${isScalar ? "" : "." + field.name}.y
+#[inline]
+pub unsafe fn set_${lower}${fieldLower}_y(${stateParamMut}, value: f32) {
+    store_f32(state.add((${baseOffset} + 4) as usize), value);
+}
+`;
+  }
+  if (field.type === "vec3") {
+    return `
+/// Get ${comp.name}${isScalar ? "" : "." + field.name}.x
+#[inline]
+pub unsafe fn get_${lower}${fieldLower}_x(${stateParam}) -> f32 {
+    load_f32(state.add((${baseOffset}) as usize))
+}
+
+/// Set ${comp.name}${isScalar ? "" : "." + field.name}.x
+#[inline]
+pub unsafe fn set_${lower}${fieldLower}_x(${stateParamMut}, value: f32) {
+    store_f32(state.add((${baseOffset}) as usize), value);
+}
+
+/// Get ${comp.name}${isScalar ? "" : "." + field.name}.y
+#[inline]
+pub unsafe fn get_${lower}${fieldLower}_y(${stateParam}) -> f32 {
+    load_f32(state.add((${baseOffset} + 4) as usize))
+}
+
+/// Set ${comp.name}${isScalar ? "" : "." + field.name}.y
+#[inline]
+pub unsafe fn set_${lower}${fieldLower}_y(${stateParamMut}, value: f32) {
+    store_f32(state.add((${baseOffset} + 4) as usize), value);
+}
+
+/// Get ${comp.name}${isScalar ? "" : "." + field.name}.z
+#[inline]
+pub unsafe fn get_${lower}${fieldLower}_z(${stateParam}) -> f32 {
+    load_f32(state.add((${baseOffset} + 8) as usize))
+}
+
+/// Set ${comp.name}${isScalar ? "" : "." + field.name}.z
+#[inline]
+pub unsafe fn set_${lower}${fieldLower}_z(${stateParamMut}, value: f32) {
+    store_f32(state.add((${baseOffset} + 8) as usize), value);
+}
+`;
+  }
+  if (field.type === "quat") {
+    return `
+/// Get ${comp.name}${isScalar ? "" : "." + field.name}.x
+#[inline]
+pub unsafe fn get_${lower}${fieldLower}_x(${stateParam}) -> f32 {
+    load_f32(state.add((${baseOffset}) as usize))
+}
+
+/// Set ${comp.name}${isScalar ? "" : "." + field.name}.x
+#[inline]
+pub unsafe fn set_${lower}${fieldLower}_x(${stateParamMut}, value: f32) {
+    store_f32(state.add((${baseOffset}) as usize), value);
+}
+
+/// Get ${comp.name}${isScalar ? "" : "." + field.name}.y
+#[inline]
+pub unsafe fn get_${lower}${fieldLower}_y(${stateParam}) -> f32 {
+    load_f32(state.add((${baseOffset} + 4) as usize))
+}
+
+/// Set ${comp.name}${isScalar ? "" : "." + field.name}.y
+#[inline]
+pub unsafe fn set_${lower}${fieldLower}_y(${stateParamMut}, value: f32) {
+    store_f32(state.add((${baseOffset} + 4) as usize), value);
+}
+
+/// Get ${comp.name}${isScalar ? "" : "." + field.name}.z
+#[inline]
+pub unsafe fn get_${lower}${fieldLower}_z(${stateParam}) -> f32 {
+    load_f32(state.add((${baseOffset} + 8) as usize))
+}
+
+/// Set ${comp.name}${isScalar ? "" : "." + field.name}.z
+#[inline]
+pub unsafe fn set_${lower}${fieldLower}_z(${stateParamMut}, value: f32) {
+    store_f32(state.add((${baseOffset} + 8) as usize), value);
+}
+
+/// Get ${comp.name}${isScalar ? "" : "." + field.name}.w
+#[inline]
+pub unsafe fn get_${lower}${fieldLower}_w(${stateParam}) -> f32 {
+    load_f32(state.add((${baseOffset} + 12) as usize))
+}
+
+/// Set ${comp.name}${isScalar ? "" : "." + field.name}.w
+#[inline]
+pub unsafe fn set_${lower}${fieldLower}_w(${stateParamMut}, value: f32) {
+    store_f32(state.add((${baseOffset} + 12) as usize), value);
+}
+`;
+  }
+  if (field.type === "enum" && field.variants) {
+    let enumOut = `
+// ${comp.name}${isScalar ? "" : "." + field.name} enum values
+`;
+    for (let i = 0; i < field.variants.length; i++) {
+      const constName = isScalar ? `${UPPER}_${toUpperSnake(field.variants[i])}` : `${UPPER}_${toUpperSnake(field.name)}_${toUpperSnake(field.variants[i])}`;
+      enumOut += `pub const ${constName}: u8 = ${i};
+`;
+    }
+    enumOut += `
+/// Get ${comp.name}${isScalar ? "" : "." + field.name} value
+#[inline]
+pub unsafe fn get_${lower}${fieldLower}(${stateParam}) -> u8 {
+    load_u8(state.add((${baseOffset}) as usize))
+}
+
+/// Set ${comp.name}${isScalar ? "" : "." + field.name} value
+#[inline]
+pub unsafe fn set_${lower}${fieldLower}(${stateParamMut}, value: u8) {
+    store_u8(state.add((${baseOffset}) as usize), value);
+}
+`;
+    return enumOut;
+  }
+  return `
+/// Get ${comp.name}${isScalar ? "" : "." + field.name} value
+#[inline]
+pub unsafe fn get_${lower}${fieldLower}(${stateParam}) -> ${rustType(field)} {
+    ${loadFn(field)}(state.add((${baseOffset}) as usize))
+}
+
+/// Set ${comp.name}${isScalar ? "" : "." + field.name} value
+#[inline]
+pub unsafe fn set_${lower}${fieldLower}(${stateParamMut}, value: ${rustType(field)}) {
+    ${storeFn(field)}(state.add((${baseOffset}) as usize), value);
+}
+`;
+}
+function generateSingletonAccessors2(comp) {
+  let out = `
+// ---------- ${comp.name} Singleton ----------
+`;
+  for (const field of comp.fields) {
+    out += generateFieldAccessors2(comp, field, true);
+  }
+  return out;
+}
+function generateEventAccessors2(event) {
+  const UPPER = toUpperSnake(event.name);
+  const lower = toLowerSnake(event.name);
+  let out = `
+// ---------- ${event.name} Event ----------
+
+pub const ${UPPER}_MAX_EVENTS: u16 = ${event.maxEvents};
+pub const ${UPPER}_RECORD_SIZE: u32 = ${event.recordSize};
+const ${UPPER}_OFFSET: u32 = ${event.storageOffset};
+
+/// Clear all ${event.name} events (call at tick start)
+#[inline]
+pub unsafe fn clear_${lower}_events(state: *mut u8) {
+    store_u16(state.add(${UPPER}_OFFSET as usize), 0);
+}
+
+/// Get count of ${event.name} events this tick
+#[inline]
+pub unsafe fn get_${lower}_count(state: *const u8) -> u16 {
+    load_u16(state.add(${UPPER}_OFFSET as usize))
+}
+
+`;
+  const pushParams = [];
+  const pushWrites = [];
+  for (const field of event.fields) {
+    const fieldLower = toLowerSnake(field.name);
+    if (field.type === "vec2") {
+      pushParams.push(`${fieldLower}_x: f32`);
+      pushParams.push(`${fieldLower}_y: f32`);
+      pushWrites.push(`    store_f32(record_ptr.add(${field.offset}), ${fieldLower}_x);`);
+      pushWrites.push(`    store_f32(record_ptr.add(${field.offset} + 4), ${fieldLower}_y);`);
+    } else if (field.type === "vec3") {
+      pushParams.push(`${fieldLower}_x: f32`);
+      pushParams.push(`${fieldLower}_y: f32`);
+      pushParams.push(`${fieldLower}_z: f32`);
+      pushWrites.push(`    store_f32(record_ptr.add(${field.offset}), ${fieldLower}_x);`);
+      pushWrites.push(`    store_f32(record_ptr.add(${field.offset} + 4), ${fieldLower}_y);`);
+      pushWrites.push(`    store_f32(record_ptr.add(${field.offset} + 8), ${fieldLower}_z);`);
+    } else if (field.type === "quat") {
+      pushParams.push(`${fieldLower}_x: f32`);
+      pushParams.push(`${fieldLower}_y: f32`);
+      pushParams.push(`${fieldLower}_z: f32`);
+      pushParams.push(`${fieldLower}_w: f32`);
+      pushWrites.push(`    store_f32(record_ptr.add(${field.offset}), ${fieldLower}_x);`);
+      pushWrites.push(`    store_f32(record_ptr.add(${field.offset} + 4), ${fieldLower}_y);`);
+      pushWrites.push(`    store_f32(record_ptr.add(${field.offset} + 8), ${fieldLower}_z);`);
+      pushWrites.push(`    store_f32(record_ptr.add(${field.offset} + 12), ${fieldLower}_w);`);
+    } else {
+      pushParams.push(`${fieldLower}: ${rustType(field)}`);
+      pushWrites.push(`    ${storeFn(field)}(record_ptr.add(${field.offset}), ${fieldLower});`);
+    }
+  }
+  out += `/// Push a ${event.name} event. Returns false if buffer is full.
+#[inline]
+pub unsafe fn push_${lower}(
+    state: *mut u8,
+    ${pushParams.join(",\n    ")},
+) -> bool {
+    let count = load_u16(state.add(${UPPER}_OFFSET as usize));
+    if count >= ${UPPER}_MAX_EVENTS {
+        return false;
+    }
+    let record_ptr = state.add((${UPPER}_OFFSET + 2 + (count as u32) * ${UPPER}_RECORD_SIZE) as usize);
+${pushWrites.join("\n")}
+    store_u16(state.add(${UPPER}_OFFSET as usize), count + 1);
+    true
+}
+
+// Indexed field accessors for ${event.name}
+`;
+  for (const field of event.fields) {
+    const fieldLower = toLowerSnake(field.name);
+    if (field.type === "vec2") {
+      out += `
+/// Get ${event.name}.${field.name}.x at index
+#[inline]
+pub unsafe fn get_${lower}_${fieldLower}_x(state: *const u8, index: u16) -> f32 {
+    load_f32(state.add((${UPPER}_OFFSET + 2 + (index as u32) * ${UPPER}_RECORD_SIZE + ${field.offset}) as usize))
+}
+
+/// Get ${event.name}.${field.name}.y at index
+#[inline]
+pub unsafe fn get_${lower}_${fieldLower}_y(state: *const u8, index: u16) -> f32 {
+    load_f32(state.add((${UPPER}_OFFSET + 2 + (index as u32) * ${UPPER}_RECORD_SIZE + ${field.offset} + 4) as usize))
+}
+`;
+    } else if (field.type === "vec3") {
+      out += `
+/// Get ${event.name}.${field.name}.x at index
+#[inline]
+pub unsafe fn get_${lower}_${fieldLower}_x(state: *const u8, index: u16) -> f32 {
+    load_f32(state.add((${UPPER}_OFFSET + 2 + (index as u32) * ${UPPER}_RECORD_SIZE + ${field.offset}) as usize))
+}
+
+/// Get ${event.name}.${field.name}.y at index
+#[inline]
+pub unsafe fn get_${lower}_${fieldLower}_y(state: *const u8, index: u16) -> f32 {
+    load_f32(state.add((${UPPER}_OFFSET + 2 + (index as u32) * ${UPPER}_RECORD_SIZE + ${field.offset} + 4) as usize))
+}
+
+/// Get ${event.name}.${field.name}.z at index
+#[inline]
+pub unsafe fn get_${lower}_${fieldLower}_z(state: *const u8, index: u16) -> f32 {
+    load_f32(state.add((${UPPER}_OFFSET + 2 + (index as u32) * ${UPPER}_RECORD_SIZE + ${field.offset} + 8) as usize))
+}
+`;
+    } else if (field.type === "quat") {
+      out += `
+/// Get ${event.name}.${field.name}.x at index
+#[inline]
+pub unsafe fn get_${lower}_${fieldLower}_x(state: *const u8, index: u16) -> f32 {
+    load_f32(state.add((${UPPER}_OFFSET + 2 + (index as u32) * ${UPPER}_RECORD_SIZE + ${field.offset}) as usize))
+}
+
+/// Get ${event.name}.${field.name}.y at index
+#[inline]
+pub unsafe fn get_${lower}_${fieldLower}_y(state: *const u8, index: u16) -> f32 {
+    load_f32(state.add((${UPPER}_OFFSET + 2 + (index as u32) * ${UPPER}_RECORD_SIZE + ${field.offset} + 4) as usize))
+}
+
+/// Get ${event.name}.${field.name}.z at index
+#[inline]
+pub unsafe fn get_${lower}_${fieldLower}_z(state: *const u8, index: u16) -> f32 {
+    load_f32(state.add((${UPPER}_OFFSET + 2 + (index as u32) * ${UPPER}_RECORD_SIZE + ${field.offset} + 8) as usize))
+}
+
+/// Get ${event.name}.${field.name}.w at index
+#[inline]
+pub unsafe fn get_${lower}_${fieldLower}_w(state: *const u8, index: u16) -> f32 {
+    load_f32(state.add((${UPPER}_OFFSET + 2 + (index as u32) * ${UPPER}_RECORD_SIZE + ${field.offset} + 12) as usize))
+}
+`;
+    } else {
+      out += `
+/// Get ${event.name}.${field.name} at index
+#[inline]
+pub unsafe fn get_${lower}_${fieldLower}(state: *const u8, index: u16) -> ${rustType(field)} {
+    ${loadFn(field)}(state.add((${UPPER}_OFFSET + 2 + (index as u32) * ${UPPER}_RECORD_SIZE + ${field.offset}) as usize))
+}
+`;
+    }
+  }
+  const iterTypes = [];
+  const iterYields = [];
+  for (const field of event.fields) {
+    const fieldLower = toLowerSnake(field.name);
+    if (field.type === "vec2") {
+      iterTypes.push("f32", "f32");
+      iterYields.push(`get_${lower}_${fieldLower}_x(self.state, i)`);
+      iterYields.push(`get_${lower}_${fieldLower}_y(self.state, i)`);
+    } else if (field.type === "vec3") {
+      iterTypes.push("f32", "f32", "f32");
+      iterYields.push(`get_${lower}_${fieldLower}_x(self.state, i)`);
+      iterYields.push(`get_${lower}_${fieldLower}_y(self.state, i)`);
+      iterYields.push(`get_${lower}_${fieldLower}_z(self.state, i)`);
+    } else if (field.type === "quat") {
+      iterTypes.push("f32", "f32", "f32", "f32");
+      iterYields.push(`get_${lower}_${fieldLower}_x(self.state, i)`);
+      iterYields.push(`get_${lower}_${fieldLower}_y(self.state, i)`);
+      iterYields.push(`get_${lower}_${fieldLower}_z(self.state, i)`);
+      iterYields.push(`get_${lower}_${fieldLower}_w(self.state, i)`);
+    } else {
+      iterTypes.push(rustType(field));
+      iterYields.push(`get_${lower}_${fieldLower}(self.state, i)`);
+    }
+  }
+  out += `
+// Iterator for ${event.name} events
+pub struct ${event.name}Iter {
+    state: *const u8,
+    index: u16,
+    count: u16,
+}
+
+impl Iterator for ${event.name}Iter {
+    // Note: Single-element tuples require trailing comma: (T,)
+    type Item = (${iterTypes.join(", ")},);
+
+    fn next(&mut self) -> Option<Self::Item> {
+        if self.index >= self.count {
+            return None;
+        }
+        let i = self.index;
+        self.index += 1;
+        unsafe {
+            Some((
+                ${iterYields.join(",\n                ")},
+            ))
+        }
+    }
+}
+
+/// Create an iterator over ${event.name} events
+pub unsafe fn iter_${lower}(state: *const u8) -> ${event.name}Iter {
+    ${event.name}Iter {
+        state,
+        index: 0,
+        count: get_${lower}_count(state),
+    }
+}
+`;
+  return out;
+}
+function isArrayType2(type) {
+  return /^\w+\[\d+\]$/.test(type);
+}
+function validateInputSchemaForCodegen2(schema) {
+  for (const ctrl of schema.controls) {
+    if (isArrayType2(ctrl.type)) {
+      throw new Error(
+        `Input array types are not supported by codegen: control '${ctrl.name}' has type '${ctrl.type}'`
+      );
+    }
+  }
+  for (const cmd of schema.commands) {
+    for (const arg of cmd.args) {
+      if (isArrayType2(arg.type) || arg.arrayLength) {
+        throw new Error(
+          `Input array types are not supported by codegen: command '${cmd.name}' argument '${arg.name}' has type '${arg.type}'`
+        );
+      }
+    }
+  }
+}
+function generateInputHeader2() {
+  return `// Language: Rust
+// Input Schema - Control and Command Accessors
+//
+// Controls are decoded by the Executor and written to the Player component.
+// These accessors read from the Player component fields.
+//
+// Commands are decoded by the Executor and pushed to command events.
+// Use the generated event iterators (e.g., iter_move_command) to read commands.
+`;
+}
+function generateControlConstants2(schema) {
+  if (schema.controls.length === 0) {
+    return "";
+  }
+  let out = `
+// =============================================================================
+// Control Index Constants (for reference)
+// =============================================================================
+`;
+  for (const ctrl of schema.controls) {
+    out += `pub const CONTROL_${toUpperSnake(ctrl.name)}: u8 = ${ctrl.index};
+`;
+  }
+  return out;
+}
+function generateFlagConstants2(schema) {
+  let out = `
+// =============================================================================
+// Flag Bit Constants
+// =============================================================================
+`;
+  for (const ctrl of schema.controls) {
+    if (ctrl.options && ctrl.options.length > 0) {
+      out += `// ${ctrl.name} flags
+`;
+      for (let i = 0; i < ctrl.options.length; i++) {
+        out += `pub const ${toUpperSnake(ctrl.name)}_${toUpperSnake(ctrl.options[i])}: u8 = ${i};
+`;
+      }
+    }
+  }
+  return out;
+}
+function generateControlAccessors2(ctrl) {
+  const lower = toLowerSnake(ctrl.name);
+  const UPPER = toUpperSnake(ctrl.name);
+  let out = `
+// ---------- ${ctrl.name} (type ${ctrl.type}) ----------
+`;
+  switch (ctrl.type) {
+    case "flags8":
+      out += `
+/// Get ${ctrl.name} flags byte from Player component
+#[inline]
+pub unsafe fn get_${lower}(state: *const u8, entity: EntityRef) -> u8 {
+    get_player_${lower}(state, entity)
+}
+
+/// Check if a specific bit is set in ${ctrl.name}
+#[inline]
+pub unsafe fn is_${lower}_set(state: *const u8, entity: EntityRef, bit: u8) -> bool {
+    (get_${lower}(state, entity) & (1 << bit)) != 0
+}
+`;
+      if (ctrl.options) {
+        for (let i = 0; i < ctrl.options.length; i++) {
+          const optLower = toLowerSnake(ctrl.options[i]);
+          const optUpper = toUpperSnake(ctrl.options[i]);
+          out += `
+/// Check if ${ctrl.name}.${ctrl.options[i]} is set
+#[inline]
+pub unsafe fn is_${lower}_${optLower}(state: *const u8, entity: EntityRef) -> bool {
+    is_${lower}_set(state, entity, ${UPPER}_${optUpper})
+}
+`;
+        }
+      }
+      break;
+    case "flags16":
+      out += `
+/// Get ${ctrl.name} flags word from Player component
+#[inline]
+pub unsafe fn get_${lower}(state: *const u8, entity: EntityRef) -> u16 {
+    get_player_${lower}(state, entity)
+}
+
+/// Check if a specific bit is set in ${ctrl.name}
+#[inline]
+pub unsafe fn is_${lower}_set(state: *const u8, entity: EntityRef, bit: u8) -> bool {
+    (get_${lower}(state, entity) & (1 << bit)) != 0
+}
+`;
+      break;
+    case "flags32":
+      out += `
+/// Get ${ctrl.name} flags dword from Player component
+#[inline]
+pub unsafe fn get_${lower}(state: *const u8, entity: EntityRef) -> u32 {
+    get_player_${lower}(state, entity)
+}
+
+/// Check if a specific bit is set in ${ctrl.name}
+#[inline]
+pub unsafe fn is_${lower}_set(state: *const u8, entity: EntityRef, bit: u8) -> bool {
+    (get_${lower}(state, entity) & (1 << bit)) != 0
+}
+`;
+      break;
+    case "bool":
+      out += `
+/// Get ${ctrl.name} boolean from Player component
+#[inline]
+pub unsafe fn get_${lower}(state: *const u8, entity: EntityRef) -> bool {
+    get_player_${lower}(state, entity)
+}
+`;
+      break;
+    case "vec2":
+      out += `
+/// Get ${ctrl.name}.x from Player component
+#[inline]
+pub unsafe fn get_${lower}_x(state: *const u8, entity: EntityRef) -> f32 {
+    get_player_${lower}_x(state, entity)
+}
+
+/// Get ${ctrl.name}.y from Player component
+#[inline]
+pub unsafe fn get_${lower}_y(state: *const u8, entity: EntityRef) -> f32 {
+    get_player_${lower}_y(state, entity)
+}
+`;
+      break;
+    case "vec3":
+      out += `
+/// Get ${ctrl.name}.x from Player component
+#[inline]
+pub unsafe fn get_${lower}_x(state: *const u8, entity: EntityRef) -> f32 {
+    get_player_${lower}_x(state, entity)
+}
+
+/// Get ${ctrl.name}.y from Player component
+#[inline]
+pub unsafe fn get_${lower}_y(state: *const u8, entity: EntityRef) -> f32 {
+    get_player_${lower}_y(state, entity)
+}
+
+/// Get ${ctrl.name}.z from Player component
+#[inline]
+pub unsafe fn get_${lower}_z(state: *const u8, entity: EntityRef) -> f32 {
+    get_player_${lower}_z(state, entity)
+}
+`;
+      break;
+    case "quat":
+      out += `
+/// Get ${ctrl.name}.x from Player component
+#[inline]
+pub unsafe fn get_${lower}_x(state: *const u8, entity: EntityRef) -> f32 {
+    get_player_${lower}_x(state, entity)
+}
+
+/// Get ${ctrl.name}.y from Player component
+#[inline]
+pub unsafe fn get_${lower}_y(state: *const u8, entity: EntityRef) -> f32 {
+    get_player_${lower}_y(state, entity)
+}
+
+/// Get ${ctrl.name}.z from Player component
+#[inline]
+pub unsafe fn get_${lower}_z(state: *const u8, entity: EntityRef) -> f32 {
+    get_player_${lower}_z(state, entity)
+}
+
+/// Get ${ctrl.name}.w from Player component
+#[inline]
+pub unsafe fn get_${lower}_w(state: *const u8, entity: EntityRef) -> f32 {
+    get_player_${lower}_w(state, entity)
+}
+`;
+      break;
+    default:
+      out += `
+/// Get ${ctrl.name} value from Player component
+#[inline]
+pub unsafe fn get_${lower}(state: *const u8, entity: EntityRef) -> ${rustInputType(ctrl.type)} {
+    get_player_${lower}(state, entity)
+}
+`;
+      break;
+  }
+  return out;
+}
+function generateCommandConstants(schema) {
+  if (schema.commands.length === 0) {
+    return "";
+  }
+  let out = `
+// =============================================================================
+// Command Index Constants (for reference)
+// =============================================================================
+`;
+  for (const cmd of schema.commands) {
+    out += `pub const COMMAND_${toUpperSnake(cmd.name)}: u8 = ${cmd.index};
+`;
+  }
+  return out;
+}
+function generateGameAllocator() {
+  return `
+// =============================================================================
+// Global Allocator (host-managed for plugin architecture)
+// =============================================================================
+
+use std::alloc::{GlobalAlloc, Layout};
+
+// Host-provided allocator - enables shared memory across multiple WASM plugins.
+// The host maintains a single bump allocator and resets it between tick batches.
+extern "C" {
+    /// Host-provided allocation function. Returns pointer to aligned memory.
+    /// The host tracks arena position and handles memory growth.
+    fn host_alloc(size: usize, align: usize) -> *mut u8;
+}
+
+/// Allocator that delegates to host-provided \`host_alloc\` import.
+/// This enables multiple WASM modules to share the same memory without
+/// conflicting allocator state.
+struct HostAlloc;
+
+unsafe impl GlobalAlloc for HostAlloc {
+    unsafe fn alloc(&self, layout: Layout) -> *mut u8 {
+        host_alloc(layout.size(), layout.align())
+    }
+
+    unsafe fn dealloc(&self, _ptr: *mut u8, _layout: Layout) {
+        // No-op: arena is bulk-freed by host via reset_arena() between tick batches
+    }
+}
+
+#[global_allocator]
+static ALLOC: HostAlloc = HostAlloc;
+`;
+}
+var RustGenerator = class {
+  language = "rust";
+  opts;
+  constructor(opts = {}) {
+    this.opts = opts;
+  }
+  generateState(schema) {
+    let out = generateStateHeader2(schema);
+    out += generateComponentOffsets2(schema);
+    out += generateMemoryHelpers();
+    out += generateInternalHelpers();
+    out += generateIterationHelpers2(schema);
+    out += generateQueryHelpers2();
+    out += generateLifecycle2(schema);
+    out += `
+// =============================================================================
+// Component Operations
+// =============================================================================
+`;
+    for (const comp of schema.entityComponents) {
+      out += generateComponentAccessors2(comp);
+    }
+    if (schema.singletonComponents.length > 0) {
+      out += `
+// =============================================================================
+// Singleton Components
+// =============================================================================
+`;
+      for (const comp of schema.singletonComponents) {
+        out += generateSingletonAccessors2(comp);
+      }
+    }
+    if (schema.events && schema.events.length > 0) {
+      out += `
+// =============================================================================
+// Events
+// =============================================================================
+`;
+      for (const event of schema.events) {
+        out += generateEventAccessors2(event);
+      }
+    }
+    return out;
+  }
+  generateInput(schema) {
+    validateInputSchemaForCodegen2(schema);
+    let out = generateInputHeader2();
+    if (schema.controls.length > 0) {
+      out += generateControlConstants2(schema);
+      out += generateFlagConstants2(schema);
+      out += `
+// =============================================================================
+// Control Accessors (read from Player component)
+// =============================================================================
+`;
+      for (const ctrl of schema.controls) {
+        out += generateControlAccessors2(ctrl);
+      }
+    }
+    if (schema.commands.length > 0) {
+      out += generateCommandConstants(schema);
+    }
+    return out;
+  }
+  generateGame(state, input) {
+    let out = `// Combined Rust module: state accessors + input helpers + transition
+//
+// Generated code - do not edit manually.
+
+// --- State accessors --------------------------------------------------------
+`;
+    out += this.generateState(state);
+    out += `
+// --- Input helpers ---------------------------------------------------------
+`;
+    out += this.generateInput(input);
+    out += generateGameAllocator();
+    return out;
+  }
+};
+
+// src/schema.ts
+var HEADER_SIZE = 44;
+var TYPE_SIZES = {
+  bool: 1,
+  uint8: 1,
+  int8: 1,
+  uint16: 2,
+  int16: 2,
+  uint32: 4,
+  int32: 4,
+  entityRef: 4,
+  f32: 4,
+  vec2: 8,
+  vec3: 12,
+  quat: 16,
+  enum: 1
+};
+var INPUT_TYPE_SIZES = {
+  bool: 1,
+  uint8: 1,
+  int8: 1,
+  uint16: 2,
+  int16: 2,
+  uint32: 4,
+  int32: 4,
+  f32: 4,
+  flags8: 1,
+  flags16: 2,
+  flags32: 4,
+  vec2: 8,
+  vec3: 12,
+  quat: 16
+};
+var PRIMITIVE_TYPES = /* @__PURE__ */ new Set([
+  "bool",
+  "uint8",
+  "int8",
+  "uint16",
+  "int16",
+  "uint32",
+  "int32",
+  "entityRef",
+  "f32"
+]);
+var INPUT_PRIMITIVE_SCALAR_TYPES = /* @__PURE__ */ new Set([
+  "bool",
+  "uint8",
+  "int8",
+  "uint16",
+  "int16",
+  "uint32",
+  "int32",
+  "f32"
+]);
+var ENUM_VARIANT_NAME_RE = /^[A-Za-z][A-Za-z0-9_]*$/;
+function parseArrayType2(type) {
+  const match = type.match(/^(\w+)\[(\d+)\]$/);
+  if (!match || !match[1] || !match[2]) return null;
+  const elementType = match[1];
+  const length = parseInt(match[2], 10);
+  if (!PRIMITIVE_TYPES.has(elementType)) return null;
+  return { elementType, length };
+}
+function parseInputArrayType(type) {
+  const match = type.match(/^(\w+)\[(\d+)\]$/);
+  if (!match || !match[1] || !match[2]) return null;
+  const elementType = match[1];
+  const length = parseInt(match[2], 10);
+  if (!INPUT_PRIMITIVE_SCALAR_TYPES.has(elementType)) {
+    throw new Error(
+      `Invalid array element type '${elementType}': arrays only support primitive scalar types (bool, uint8, int8, uint16, int16, uint32, int32, f32)`
+    );
+  }
+  return { elementType, length };
+}
+function getTypeSize(type) {
+  const arrayInfo = parseArrayType2(type);
+  if (arrayInfo) {
+    const elementSize = TYPE_SIZES[arrayInfo.elementType];
+    if (elementSize === void 0) {
+      throw new Error(`Unknown element type: ${arrayInfo.elementType}`);
+    }
+    return elementSize * arrayInfo.length;
+  }
+  const size = TYPE_SIZES[type];
+  if (size === void 0) {
+    throw new Error(`Unknown type: ${type}`);
+  }
+  return size;
+}
+function getInputTypeSize(type) {
+  const arrayInfo = parseInputArrayType(type);
+  if (arrayInfo) {
+    const elementSize = INPUT_TYPE_SIZES[arrayInfo.elementType];
+    if (elementSize === void 0) {
+      throw new Error(`Unknown element type: ${arrayInfo.elementType}`);
+    }
+    return elementSize * arrayInfo.length;
+  }
+  const size = INPUT_TYPE_SIZES[type];
+  if (size === void 0) {
+    throw new Error(`Unknown type: ${type}`);
+  }
+  return size;
+}
+function getValidatedTypeSize(type, componentName, fieldName) {
+  try {
+    return getTypeSize(type);
+  } catch (error) {
+    const location = fieldName ? `${componentName}.${fieldName}` : componentName;
+    const message = error instanceof Error ? error.message : String(error);
+    throw new Error(`Invalid type '${type}' for '${location}': ${message}`);
+  }
+}
+function validateEnumVariants(rawVariants, subject) {
+  const variants = rawVariants ?? [];
+  if (!Array.isArray(variants)) {
+    throw new Error(`enum ${subject} must have at least one variant`);
+  }
+  if (variants.length === 0) {
+    throw new Error(`enum ${subject} must have at least one variant`);
+  }
+  if (variants.length > 256) {
+    throw new Error(`enum ${subject} has ${variants.length} variants, maximum is 256`);
+  }
+  const seen = /* @__PURE__ */ new Set();
+  const seenNormalized = /* @__PURE__ */ new Map();
+  for (const v of variants) {
+    if (typeof v !== "string" || v.trim().length === 0) {
+      throw new Error(`enum ${subject} has empty variant name`);
+    }
+    if (!ENUM_VARIANT_NAME_RE.test(v)) {
+      throw new Error(
+        `enum ${subject} has invalid variant name ${JSON.stringify(v)} (must match ${ENUM_VARIANT_NAME_RE})`
+      );
+    }
+    if (seen.has(v)) {
+      throw new Error(`enum ${subject} has duplicate variant '${v}'`);
+    }
+    seen.add(v);
+    const normalized = toUpperSnake2(v);
+    const prev = seenNormalized.get(normalized);
+    if (prev !== void 0) {
+      throw new Error(
+        `enum ${subject} has variants ${JSON.stringify(prev)} and ${JSON.stringify(v)} which collide as ${JSON.stringify(normalized)}`
+      );
+    }
+    seenNormalized.set(normalized, v);
+  }
+  return variants;
+}
+function toUpperSnake2(s) {
+  let result = "";
+  for (let i = 0; i < s.length; i++) {
+    const c = s[i];
+    if (i > 0 && c >= "A" && c <= "Z") {
+      result += "_";
+    }
+    result += c.toUpperCase();
+  }
+  return result;
+}
+function compileStateSchema(schema) {
+  const { maxEntities, components: componentDefs, events: eventDefs } = schema;
+  if (maxEntities <= 0 || maxEntities > 65535) {
+    throw new Error(`maxEntities must be between 1 and 65535, got ${maxEntities}`);
+  }
+  if (!Array.isArray(componentDefs)) {
+    throw new Error("schema.components must be an array to preserve deterministic ordering");
+  }
+  const numEntityComponents = componentDefs.filter((componentDef) => {
+    const singletonFlag = componentDef.singleton;
+    return singletonFlag !== true;
+  }).length;
+  const bitmaskSize = Math.ceil(numEntityComponents / 8);
+  const entityRecordSize = 2 + bitmaskSize;
+  const entityTableOffset = HEADER_SIZE;
+  const entityTableSize = maxEntities * entityRecordSize;
+  const freeStackOffset = entityTableOffset + entityTableSize;
+  const freeStackSize = 2 + maxEntities * 2;
+  const componentStorageOffset = freeStackOffset + freeStackSize;
+  const components = [];
+  const entityComponents = [];
+  const singletonComponents = [];
+  const componentByName = /* @__PURE__ */ new Map();
+  const seenComponentNames = /* @__PURE__ */ new Set();
+  let storageOffset = componentStorageOffset;
+  const pendingSingletons = [];
+  let bitIndex = 0;
+  for (let i = 0; i < componentDefs.length; i++) {
+    const componentDef = componentDefs[i];
+    if (componentDef === void 0 || componentDef === null || typeof componentDef !== "object") {
+      throw new Error(`Component at index ${i} must be an object`);
+    }
+    const rawName = componentDef.name;
+    if (typeof rawName !== "string" || rawName.trim().length === 0) {
+      throw new Error(`Component at index ${i} must have a non-empty string 'name'`);
+    }
+    const name = rawName;
+    if (seenComponentNames.has(name)) {
+      throw new Error(`Duplicate component name '${name}' in schema`);
+    }
+    seenComponentNames.add(name);
+    const rawType = componentDef.type;
+    if (typeof rawType !== "string" || rawType.trim().length === 0) {
+      throw new Error(`Component '${name}' must have a string 'type'`);
+    }
+    const componentType = rawType;
+    const fields = [];
+    let componentSize = 0;
+    let isTag = false;
+    const isSingleton = componentDef.singleton === true;
+    if (componentType === "tag") {
+      isTag = true;
+      if (isSingleton) {
+        throw new Error(`Component '${name}' cannot be a singleton tag`);
+      }
+    } else if (componentType === "compound") {
+      const rawFields = componentDef.fields;
+      if (!Array.isArray(rawFields)) {
+        throw new Error(`Component '${name}' with type 'compound' must declare a 'fields' array`);
+      }
+      const seenFieldNames = /* @__PURE__ */ new Set();
+      let fieldOffset = 0;
+      for (let fieldIndex = 0; fieldIndex < rawFields.length; fieldIndex++) {
+        const fieldDef = rawFields[fieldIndex];
+        if (fieldDef === void 0 || fieldDef === null || typeof fieldDef !== "object") {
+          throw new Error(`Component '${name}' has an invalid field at index ${fieldIndex}`);
+        }
+        const rawFieldName = fieldDef.name;
+        if (typeof rawFieldName !== "string" || rawFieldName.trim().length === 0) {
+          throw new Error(`Component '${name}' has a field with a missing or empty 'name'`);
+        }
+        if (seenFieldNames.has(rawFieldName)) {
+          throw new Error(`Component '${name}' has duplicate field '${rawFieldName}'`);
+        }
+        seenFieldNames.add(rawFieldName);
+        const rawFieldType = fieldDef.type;
+        if (typeof rawFieldType !== "string" || rawFieldType.trim().length === 0) {
+          throw new Error(`Field '${name}.${rawFieldName}' must have a string 'type'`);
+        }
+        const size = getValidatedTypeSize(rawFieldType, name, rawFieldName);
+        const arrayInfo = parseArrayType2(rawFieldType);
+        const compiledField = {
+          name: rawFieldName,
+          type: rawFieldType,
+          size,
+          offset: fieldOffset
+        };
+        if (arrayInfo) {
+          compiledField.arrayLength = arrayInfo.length;
+          compiledField.arrayElementType = arrayInfo.elementType;
+        }
+        if (rawFieldType === "enum") {
+          compiledField.variants = validateEnumVariants(
+            fieldDef.variants,
+            `field '${name}.${rawFieldName}'`
+          );
+        }
+        fields.push(compiledField);
+        fieldOffset += size;
+        componentSize += size;
+      }
+    } else {
+      const fieldType = componentType;
+      const size = getValidatedTypeSize(fieldType, name);
+      const arrayInfo = parseArrayType2(fieldType);
+      const compiledField = {
+        name: "",
+        type: fieldType,
+        size,
+        offset: 0
+      };
+      if (arrayInfo) {
+        compiledField.arrayLength = arrayInfo.length;
+        compiledField.arrayElementType = arrayInfo.elementType;
+      }
+      if (fieldType === "enum") {
+        compiledField.variants = validateEnumVariants(
+          componentDef.variants,
+          `component '${name}'`
+        );
+      }
+      fields.push(compiledField);
+      componentSize = size;
+    }
+    const compiled = {
+      name,
+      index: isSingleton ? -1 : bitIndex,
+      isTag,
+      isSingleton,
+      size: componentSize,
+      storageOffset: 0,
+      fields
+    };
+    components.push(compiled);
+    componentByName.set(name, compiled);
+    if (isSingleton) {
+      pendingSingletons.push(compiled);
+      singletonComponents.push(compiled);
+    } else {
+      if (!isTag && componentSize > 0) {
+        compiled.storageOffset = storageOffset;
+        storageOffset += maxEntities * componentSize;
+      } else {
+        compiled.storageOffset = 0;
+      }
+      entityComponents.push(compiled);
+      bitIndex += 1;
+    }
+  }
+  const singletonStorageOffset = storageOffset;
+  let singletonCursor = singletonStorageOffset;
+  for (const singleton of pendingSingletons) {
+    singleton.storageOffset = singletonCursor;
+    singletonCursor += singleton.size;
+  }
+  const singletonStorageSize = singletonCursor - singletonStorageOffset;
+  let totalSize = singletonCursor;
+  let events;
+  let eventByName;
+  let eventStorageOffset;
+  let eventStorageSize;
+  if (eventDefs && eventDefs.length > 0) {
+    events = [];
+    eventByName = /* @__PURE__ */ new Map();
+    eventStorageOffset = totalSize;
+    let eventCursor = eventStorageOffset;
+    const seenEventNames = /* @__PURE__ */ new Set();
+    for (let i = 0; i < eventDefs.length; i++) {
+      const eventDef = eventDefs[i];
+      if (typeof eventDef.name !== "string" || eventDef.name.trim().length === 0) {
+        throw new Error(`Event at index ${i} must have a non-empty string 'name'`);
+      }
+      if (seenEventNames.has(eventDef.name)) {
+        throw new Error(`Duplicate event name '${eventDef.name}' in schema`);
+      }
+      seenEventNames.add(eventDef.name);
+      if (seenComponentNames.has(eventDef.name)) {
+        throw new Error(`Event name '${eventDef.name}' conflicts with component name`);
+      }
+      if (!Array.isArray(eventDef.fields) || eventDef.fields.length === 0) {
+        throw new Error(`Event '${eventDef.name}' must have at least one field`);
+      }
+      const maxEvents = eventDef.maxEvents && eventDef.maxEvents > 0 ? eventDef.maxEvents : 64;
+      const eventFields = [];
+      let fieldOffset = 0;
+      const seenFieldNames = /* @__PURE__ */ new Set();
+      for (let fi = 0; fi < eventDef.fields.length; fi++) {
+        const fieldDef = eventDef.fields[fi];
+        if (typeof fieldDef.name !== "string" || fieldDef.name.trim().length === 0) {
+          throw new Error(`Event '${eventDef.name}' has a field with a missing or empty 'name' at index ${fi}`);
+        }
+        if (seenFieldNames.has(fieldDef.name)) {
+          throw new Error(`Event '${eventDef.name}' has duplicate field '${fieldDef.name}'`);
+        }
+        seenFieldNames.add(fieldDef.name);
+        if (typeof fieldDef.type !== "string" || fieldDef.type.trim().length === 0) {
+          throw new Error(`Event field '${eventDef.name}.${fieldDef.name}' must have a string 'type'`);
+        }
+        const arrayInfo = parseArrayType2(fieldDef.type);
+        if (arrayInfo) {
+          throw new Error(
+            `Event field '${eventDef.name}.${fieldDef.name}' has array type '${fieldDef.type}'; events do not support array types`
+          );
+        }
+        const size = getValidatedTypeSize(fieldDef.type, eventDef.name, fieldDef.name);
+        const compiledField = {
+          name: fieldDef.name,
+          type: fieldDef.type,
+          size,
+          offset: fieldOffset
+        };
+        if (fieldDef.type === "enum" && fieldDef.variants) {
+          compiledField.variants = validateEnumVariants(fieldDef.variants, `event field '${eventDef.name}.${fieldDef.name}'`);
+        }
+        eventFields.push(compiledField);
+        fieldOffset += size;
+      }
+      const recordSize = fieldOffset;
+      const bufferSize = 2 + maxEvents * recordSize;
+      const compiledEvent = {
+        name: eventDef.name,
+        index: i,
+        maxEvents,
+        recordSize,
+        storageOffset: eventCursor,
+        bufferSize,
+        fields: eventFields
+      };
+      events.push(compiledEvent);
+      eventByName.set(eventDef.name, compiledEvent);
+      eventCursor += bufferSize;
+    }
+    eventStorageSize = eventCursor - eventStorageOffset;
+    totalSize = eventCursor;
+  }
+  return {
+    maxEntities,
+    components,
+    entityComponents,
+    singletonComponents,
+    componentByName,
+    definition: schema,
+    events,
+    eventByName,
+    headerOffset: 0,
+    headerSize: HEADER_SIZE,
+    entityTableOffset,
+    entityRecordSize,
+    freeStackOffset,
+    freeStackSize,
+    componentStorageOffset,
+    singletonStorageOffset,
+    singletonStorageSize,
+    eventStorageOffset,
+    eventStorageSize,
+    totalSize,
+    bitmaskSize
+  };
+}
+function compileInputSchema(schema) {
+  const controls = [];
+  const commands = [];
+  const controlByName = /* @__PURE__ */ new Map();
+  const commandByName = /* @__PURE__ */ new Map();
+  const seenNames = /* @__PURE__ */ new Set();
+  let index = 0;
+  for (let i = 0; i < schema.controls.length; i++) {
+    const controlDef = schema.controls[i];
+    if (typeof controlDef.name !== "string" || controlDef.name.trim().length === 0) {
+      throw new Error(`Control at index ${i} must have a non-empty string 'name'`);
+    }
+    if (seenNames.has(controlDef.name)) {
+      throw new Error(`Duplicate control/command name '${controlDef.name}' in schema`);
+    }
+    seenNames.add(controlDef.name);
+    if (typeof controlDef.type !== "string" || controlDef.type.trim().length === 0) {
+      throw new Error(`Control '${controlDef.name}' must have a string 'type'`);
+    }
+    const size = getInputTypeSize(controlDef.type);
+    const compiled = {
+      name: controlDef.name,
+      index: index++,
+      type: controlDef.type,
+      size,
+      options: controlDef.options,
+      hint: controlDef.hint,
+      retain: controlDef.retain === "always" ? "always" : "tick"
+    };
+    controls.push(compiled);
+    controlByName.set(controlDef.name, compiled);
+    if (index > 255) {
+      throw new Error(`Too many controls/commands: index ${index} exceeds u8 limit (255)`);
+    }
+  }
+  for (let i = 0; i < schema.commands.length; i++) {
+    const commandDef = schema.commands[i];
+    if (typeof commandDef.name !== "string" || commandDef.name.trim().length === 0) {
+      throw new Error(`Command at index ${i} must have a non-empty string 'name'`);
+    }
+    if (seenNames.has(commandDef.name)) {
+      throw new Error(`Duplicate control/command name '${commandDef.name}' in schema`);
+    }
+    seenNames.add(commandDef.name);
+    const args = [];
+    let offset = 0;
+    for (let ai = 0; ai < commandDef.args.length; ai++) {
+      const argDef = commandDef.args[ai];
+      if (typeof argDef.name !== "string" || argDef.name.trim().length === 0) {
+        throw new Error(`Command '${commandDef.name}' has an argument with missing 'name' at index ${ai}`);
+      }
+      const size = getInputTypeSize(argDef.type);
+      const arrayInfo = parseInputArrayType(argDef.type);
+      const arg = {
+        name: argDef.name,
+        type: argDef.type,
+        size,
+        offset
+      };
+      if (arrayInfo) {
+        arg.arrayLength = arrayInfo.length;
+        arg.arrayElementType = arrayInfo.elementType;
+      }
+      args.push(arg);
+      offset += size;
+    }
+    const compiled = {
+      name: commandDef.name,
+      index: index++,
+      args,
+      totalSize: offset
+    };
+    commands.push(compiled);
+    commandByName.set(commandDef.name, compiled);
+    if (index > 255) {
+      throw new Error(`Too many controls/commands: index ${index} exceeds u8 limit (255)`);
+    }
+  }
+  return { controls, commands, controlByName, commandByName };
+}
+
+// src/vite/codegen-runner.ts
+async function runCodegen(configPath, options) {
+  const { generatedDir, verbose } = options;
+  const project = loadProject(configPath);
+  const graph = loadConfigGraph(project);
+  const merged = mergeConfigs(graph);
+  if (verbose) {
+    console.log(`[multitap] Loaded ${graph.order.length} plugin(s)`);
+  }
+  const compiledInput = compileInputSchema(merged.config.input);
+  const preparedState = prepareStateSchema(merged.config.state, compiledInput);
+  const compiledState = compileStateSchema(preparedState);
+  if (verbose) {
+    console.log(`[multitap] State buffer size: ${compiledState.totalSize} bytes`);
+  }
+  const tsGen = new TypeScriptGenerator();
+  const tsCode = tsGen.generateGame(compiledState, compiledInput);
+  await mkdir(generatedDir, { recursive: true });
+  const tsPath = join2(generatedDir, "state.ts");
+  await writeFile(tsPath, tsCode, "utf-8");
+  if (verbose) {
+    console.log(`[multitap] Generated ${tsPath}`);
+  }
+  const rustGen = new RustGenerator();
+  const rustCode = rustGen.generateGame(compiledState, compiledInput);
+  for (const pluginPath of merged.pluginOrder) {
+    const rustDir = join2(pluginPath, "src");
+    await mkdir(rustDir, { recursive: true });
+    const rustPath = join2(rustDir, "generated.rs");
+    await writeFile(rustPath, rustCode, "utf-8");
+    if (verbose) {
+      console.log(`[multitap] Generated ${rustPath}`);
+    }
+  }
+  return {
+    compiledState,
+    compiledInput,
+    mergedConfig: merged,
+    graph
+  };
+}
+
+// src/vite/wasm-compiler.ts
+import { spawn } from "node:child_process";
+import { readFile, readdir, stat } from "node:fs/promises";
+import { join as join3, basename, dirname as dirname2 } from "node:path";
+var WASM_PAGE_SIZE = 65536;
+async function findCargoToml(startDir) {
+  let dir = startDir;
+  while (true) {
+    const cargoPath = join3(dir, "Cargo.toml");
+    try {
+      await stat(cargoPath);
+      return dir;
+    } catch {
+      const parent = dirname2(dir);
+      if (parent === dir) {
+        throw new Error(`Cargo.toml not found starting from ${startDir}`);
+      }
+      dir = parent;
+    }
+  }
+}
+async function findWasmFile(targetDir) {
+  const wasmDir = join3(targetDir, "wasm32-unknown-unknown", "release");
+  const entries = await readdir(wasmDir);
+  for (const entry of entries) {
+    if (entry.endsWith(".wasm")) {
+      return join3(wasmDir, entry);
+    }
+  }
+  throw new Error(`No .wasm file found in ${wasmDir}`);
+}
+function runCommand(command, args, options) {
+  return new Promise((resolve3, reject) => {
+    const proc = spawn(command, args, {
+      cwd: options.cwd,
+      env: options.env,
+      stdio: options.verbose ? "inherit" : "pipe"
+    });
+    let stderr = "";
+    if (!options.verbose && proc.stderr) {
+      proc.stderr.on("data", (data) => {
+        stderr += data.toString();
+      });
+    }
+    proc.on("error", (err) => {
+      reject(new Error(`Failed to spawn ${command}: ${err.message}`));
+    });
+    proc.on("close", (code) => {
+      if (code !== 0) {
+        reject(new Error(`${command} exited with code ${code}
+${stderr}`));
+      } else {
+        resolve3();
+      }
+    });
+  });
+}
+async function compilePluginWasm(pluginPath, globalBase, verbose = false) {
+  const cargoDir = await findCargoToml(pluginPath);
+  const targetDir = join3(cargoDir, "target");
+  const rustFlags = `-C link-args=--import-memory -C link-args=--global-base=${globalBase} -C link-args=--stack-first`;
+  await runCommand(
+    "cargo",
+    ["build", "--release", "--target", "wasm32-unknown-unknown", "--target-dir", targetDir],
+    {
+      cwd: cargoDir,
+      env: { ...process.env, RUSTFLAGS: rustFlags },
+      verbose
+    }
+  );
+  const wasmPath = await findWasmFile(targetDir);
+  const wasmBytes = await readFile(wasmPath);
+  return {
+    name: basename(pluginPath),
+    wasmBytes: new Uint8Array(wasmBytes),
+    reservedBytes: 0
+    // Will be set by caller from config
+  };
+}
+function calculateGlobalBases(pluginOrder, reservedBytesMap) {
+  const bases = /* @__PURE__ */ new Map();
+  let offset = 0;
+  for (const pluginPath of pluginOrder) {
+    bases.set(pluginPath, offset);
+    const reservedBytes = reservedBytesMap.get(pluginPath) ?? 0;
+    const alignedSize = Math.ceil(reservedBytes / WASM_PAGE_SIZE) * WASM_PAGE_SIZE;
+    offset += alignedSize;
+  }
+  return bases;
+}
+
+// src/vite/module-builder.ts
+function bytesToBase64(data) {
+  return Buffer.from(data).toString("base64");
+}
+function prepareStateSchemaForSerialization(schema) {
+  return {
+    maxEntities: schema.maxEntities,
+    components: schema.components,
+    entityComponents: schema.entityComponents,
+    singletonComponents: schema.singletonComponents,
+    definition: schema.definition,
+    events: schema.events,
+    headerOffset: schema.headerOffset,
+    headerSize: schema.headerSize,
+    entityTableOffset: schema.entityTableOffset,
+    entityRecordSize: schema.entityRecordSize,
+    freeStackOffset: schema.freeStackOffset,
+    freeStackSize: schema.freeStackSize,
+    componentStorageOffset: schema.componentStorageOffset,
+    singletonStorageOffset: schema.singletonStorageOffset,
+    singletonStorageSize: schema.singletonStorageSize,
+    eventStorageOffset: schema.eventStorageOffset,
+    eventStorageSize: schema.eventStorageSize,
+    totalSize: schema.totalSize,
+    bitmaskSize: schema.bitmaskSize
+  };
+}
+function buildVirtualModule(options) {
+  const { config, plugins, compiledState } = options;
+  const lines = [];
+  lines.push("function base64ToUint8Array(b64) {");
+  lines.push("  const binary = atob(b64);");
+  lines.push("  const bytes = new Uint8Array(binary.length);");
+  lines.push("  for (let i = 0; i < binary.length; i++) bytes[i] = binary.charCodeAt(i);");
+  lines.push("  return bytes;");
+  lines.push("}");
+  lines.push("");
+  lines.push("const plugins = [");
+  for (const p of plugins) {
+    lines.push(
+      `  { name: ${JSON.stringify(p.name)}, wasmBytes: base64ToUint8Array(${JSON.stringify(bytesToBase64(p.wasmBytes))}), reservedBytes: ${p.reservedBytes} },`
+    );
+  }
+  lines.push("];");
+  lines.push("");
+  const stateJSON = JSON.stringify(prepareStateSchemaForSerialization(compiledState));
+  const inputJSON = JSON.stringify(config.input);
+  lines.push(`const schema = { state: ${stateJSON}, input: ${inputJSON} };`);
+  lines.push("");
+  lines.push("export default {");
+  lines.push(`  appID: ${JSON.stringify(config.appID)},`);
+  lines.push(`  tickRate: ${config.tickRate},`);
+  lines.push(`  maxTicks: ${config.maxTicks},`);
+  lines.push(`  maxParticipants: ${config.maxParticipants},`);
+  lines.push("  plugins,");
+  lines.push("  schema,");
+  lines.push("};");
+  return lines.join("\n");
+}
+
+// src/vite/plugin.ts
+var VIRTUAL_PREFIX = "\0multitap:";
+var IMPORT_PATTERN = /^multitap:(.+\.json)$/;
+function multitapPlugin(options = {}) {
+  const {
+    generatedDir = "./generated",
+    verbose = false,
+    skipWasm = false
+  } = options;
+  let resolvedConfig;
+  return {
+    name: "vite-plugin-multitap",
+    // Run before other plugins (especially vite:json) to intercept multitap: imports
+    enforce: "pre",
+    configResolved(config) {
+      resolvedConfig = config;
+    },
+    resolveId(source, importer) {
+      const match = source.match(IMPORT_PATTERN);
+      if (!match || !match[1]) return null;
+      const relativePath = match[1];
+      const resolveDir = importer ? dirname3(importer) : resolvedConfig.root;
+      const absolutePath = resolve2(resolveDir, relativePath);
+      return VIRTUAL_PREFIX + absolutePath.replace(/\.json$/, "");
+    },
+    async load(id) {
+      if (!id.startsWith(VIRTUAL_PREFIX)) return null;
+      const absoluteConfigPath = id.slice(VIRTUAL_PREFIX.length) + ".json";
+      if (verbose) {
+        console.log(`[multitap] Building config: ${absoluteConfigPath}`);
+      }
+      const codegenResult = await runCodegen(absoluteConfigPath, {
+        generatedDir: resolve2(resolvedConfig.root, generatedDir),
+        verbose
+      });
+      const plugins = [];
+      if (!skipWasm) {
+        const reservedBytesMap = /* @__PURE__ */ new Map();
+        for (const [pluginPath, node] of codegenResult.graph.plugins) {
+          reservedBytesMap.set(pluginPath, node.config.wasm.reservedBytes);
+        }
+        const globalBases = calculateGlobalBases(codegenResult.mergedConfig.pluginOrder, reservedBytesMap);
+        for (const pluginPath of codegenResult.mergedConfig.pluginOrder) {
+          const globalBase = globalBases.get(pluginPath);
+          const reservedBytes = reservedBytesMap.get(pluginPath);
+          if (verbose) {
+            console.log(`[multitap] Compiling ${pluginPath} (globalBase=${globalBase})`);
+          }
+          const result = await compilePluginWasm(pluginPath, globalBase, verbose);
+          result.reservedBytes = reservedBytes;
+          plugins.push(result);
+        }
+      }
+      const moduleCode = buildVirtualModule({
+        config: codegenResult.mergedConfig.config,
+        plugins,
+        compiledState: codegenResult.compiledState
+      });
+      if (verbose) {
+        console.log(`[multitap] Build complete`);
+      }
+      return moduleCode;
+    }
+  };
+}
+export {
+  multitapPlugin as default,
+  multitapPlugin
+};