@multitapio/multitap 0.0.13 → 0.0.14

package/dist/vite/index.js

@@ -137,8 +137,10 @@ function topologicalSort(plugins) {
 function mergeConfigs(graph) {
   const componentOwners = /* @__PURE__ */ new Map();
   const eventOwners = /* @__PURE__ */ new Map();
+  const dataOwners = /* @__PURE__ */ new Map();
   const mergedComponents = [];
   const mergedEvents = [];
+  const mergedData = [];
   for (const pluginPath of graph.order) {
     const node = graph.plugins.get(pluginPath);
     for (const comp of node.config.state.components ?? []) {
@@ -177,6 +179,25 @@ function mergeConfigs(graph) {
     eventOwners.set(event.name, graph.root.dir);
     mergedEvents.push(event);
   }
+  for (const pluginPath of graph.order) {
+    const node = graph.plugins.get(pluginPath);
+    for (const data of node.config.data ?? []) {
+      if (dataOwners.has(data.name)) {
+        const owner = dataOwners.get(data.name);
+        throw new Error(`Data item "${data.name}" defined in both ${owner} and ${pluginPath}`);
+      }
+      dataOwners.set(data.name, pluginPath);
+      mergedData.push(data);
+    }
+  }
+  for (const data of graph.root.config.data ?? []) {
+    if (dataOwners.has(data.name)) {
+      const owner = dataOwners.get(data.name);
+      throw new Error(`Data item "${data.name}" defined in both ${owner} and root config`);
+    }
+    dataOwners.set(data.name, graph.root.dir);
+    mergedData.push(data);
+  }
   const mergedState = {
     maxEntities: graph.root.config.state.maxEntities,
     components: mergedComponents
@@ -200,10 +221,14 @@ function mergeConfigs(graph) {
   if (graph.root.config.fixtures !== void 0) {
     mergedConfig.fixtures = graph.root.config.fixtures;
   }
+  if (mergedData.length > 0) {
+    mergedConfig.data = mergedData;
+  }
   return {
     config: mergedConfig,
     pluginOrder: graph.order,
-    componentOwners
+    componentOwners,
+    dataOwners
   };
 }
 
@@ -425,118 +450,796 @@ function getElementSize(type) {
   }
 }
 
-// src/codegen/typescript.ts
-function tsType(field) {
-  if (field.arrayElementType) {
-    return tsTypeMapping(field.arrayElementType);
+// 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 parseArrayType(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)`
+    );
   }
-  if (field.type === "vec2" || field.type === "vec3" || field.type === "quat") {
-    return "number";
+  return { elementType, length };
+}
+function getTypeSize(type) {
+  const arrayInfo = parseArrayType(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;
   }
-  if (field.type === "enum") {
-    return "number";
+  const size = TYPE_SIZES[type];
+  if (size === void 0) {
+    throw new Error(`Unknown type: ${type}`);
   }
-  return tsTypeMapping(field.type);
+  return size;
 }
-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 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 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 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 tsLoadFn(field) {
-  let typ = field.type;
-  if (field.arrayElementType) {
-    typ = field.arrayElementType;
+function validateEnumVariants(rawVariants, subject) {
+  const variants = rawVariants ?? [];
+  if (!Array.isArray(variants)) {
+    throw new Error(`enum ${subject} must have at least one variant`);
   }
-  if (typ === "vec2" || typ === "vec3" || typ === "quat") {
-    typ = "f32";
+  if (variants.length === 0) {
+    throw new Error(`enum ${subject} must have at least one variant`);
   }
-  if (typ === "enum") {
-    typ = "uint8";
+  if (variants.length > 256) {
+    throw new Error(`enum ${subject} has ${variants.length} variants, maximum is 256`);
   }
-  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`);
+  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 tsStoreFn(field) {
-  let typ = field.type;
-  if (field.arrayElementType) {
-    typ = field.arrayElementType;
+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();
   }
-  if (typ === "vec2" || typ === "vec3" || typ === "quat") {
-    typ = "f32";
+  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 (typ === "enum") {
-    typ = "uint8";
+  if (!Array.isArray(componentDefs)) {
+    throw new Error("schema.components must be an array to preserve deterministic ordering");
   }
-  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":
+  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;
+    let isBlob = false;
+    let blobMaxSize;
+    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 = parseArrayType(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 if (componentType === "blob") {
+      if (!isSingleton) {
+        throw new Error(`Component '${name}' with type 'blob' must be a singleton`);
+      }
+      const maxSize = componentDef.maxSize;
+      if (typeof maxSize !== "number" || maxSize <= 0) {
+        throw new Error(`Component '${name}' with type 'blob' requires positive 'maxSize'`);
+      }
+      componentSize = 4 + maxSize;
+      isBlob = true;
+      blobMaxSize = maxSize;
+    } else {
+      const fieldType = componentType;
+      const size = getValidatedTypeSize(fieldType, name);
+      const arrayInfo = parseArrayType(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
+    };
+    if (isBlob) {
+      compiled.isBlob = true;
+      compiled.blobMaxSize = blobMaxSize;
+    }
+    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 = parseArrayType(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
+  };
+}
+var INIT_DATA_MAGIC = 1297369412;
+var INIT_DATA_HEADER_SIZE = 8;
+var MAX_INIT_DATA_ARRAY_LENGTH = 65536;
+function getInitDataTypeSize(type) {
+  const quatArrayMatch = type.match(/^quat\[(\d+)\]$/);
+  if (quatArrayMatch) {
+    throw new Error(`Quat arrays are not supported in init data. Use individual quat fields or a different data structure.`);
+  }
+  const vec3ArrayMatch = type.match(/^vec3\[(\d+)\]$/);
+  if (vec3ArrayMatch?.[1]) {
+    const length = parseInt(vec3ArrayMatch[1], 10);
+    if (length > MAX_INIT_DATA_ARRAY_LENGTH) {
+      throw new Error(`Array length ${length} exceeds maximum ${MAX_INIT_DATA_ARRAY_LENGTH}`);
+    }
+    return 12 * length;
+  }
+  const vec2ArrayMatch = type.match(/^vec2\[(\d+)\]$/);
+  if (vec2ArrayMatch?.[1]) {
+    const length = parseInt(vec2ArrayMatch[1], 10);
+    if (length > MAX_INIT_DATA_ARRAY_LENGTH) {
+      throw new Error(`Array length ${length} exceeds maximum ${MAX_INIT_DATA_ARRAY_LENGTH}`);
+    }
+    return 8 * length;
+  }
+  const arrayInfo = parseArrayType(type);
+  if (arrayInfo) {
+    if (arrayInfo.length > MAX_INIT_DATA_ARRAY_LENGTH) {
+      throw new Error(`Array length ${arrayInfo.length} exceeds maximum ${MAX_INIT_DATA_ARRAY_LENGTH}`);
+    }
+    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 parseVec3ArrayType(type) {
+  const match = type.match(/^vec3\[(\d+)\]$/);
+  if (!match?.[1]) return null;
+  return { elementType: "vec3", length: parseInt(match[1], 10) };
+}
+function parseVec2ArrayType(type) {
+  const match = type.match(/^vec2\[(\d+)\]$/);
+  if (!match?.[1]) return null;
+  return { elementType: "vec2", length: parseInt(match[1], 10) };
+}
+function compileInitDataSchema(items) {
+  const compiledItems = [];
+  const itemByName = /* @__PURE__ */ new Map();
+  const seenNames = /* @__PURE__ */ new Set();
+  let offset = INIT_DATA_HEADER_SIZE;
+  for (let i = 0; i < items.length; i++) {
+    const item = items[i];
+    if (!item) continue;
+    if (typeof item.name !== "string" || item.name.trim().length === 0) {
+      throw new Error(`Init data item at index ${i} must have a non-empty string 'name'`);
+    }
+    if (seenNames.has(item.name)) {
+      throw new Error(`Duplicate init data item name '${item.name}'`);
+    }
+    seenNames.add(item.name);
+    if (item.type !== "compound" && item.type !== "blob") {
+      throw new Error(`Init data item '${item.name}' must have type 'compound' or 'blob'`);
+    }
+    let itemSize = 0;
+    const fields = [];
+    if (item.type === "blob") {
+      if (typeof item.maxSize !== "number" || item.maxSize <= 0) {
+        throw new Error(`Init data item '${item.name}' with type 'blob' requires positive 'maxSize'`);
+      }
+      itemSize = 4 + item.maxSize;
+      const compiled = {
+        name: item.name,
+        type: "blob",
+        size: itemSize,
+        storageOffset: offset,
+        fields: [],
+        isBlob: true,
+        blobMaxSize: item.maxSize
+      };
+      compiledItems.push(compiled);
+      itemByName.set(item.name, compiled);
+    } else {
+      if (!Array.isArray(item.fields) || item.fields.length === 0) {
+        throw new Error(`Init data item '${item.name}' with type 'compound' must have non-empty 'fields' array`);
+      }
+      const seenFieldNames = /* @__PURE__ */ new Set();
+      let fieldOffset = 0;
+      for (let fi = 0; fi < item.fields.length; fi++) {
+        const field = item.fields[fi];
+        if (!field) continue;
+        if (typeof field.name !== "string" || field.name.trim().length === 0) {
+          throw new Error(`Init data item '${item.name}' has field with missing name at index ${fi}`);
+        }
+        if (seenFieldNames.has(field.name)) {
+          throw new Error(`Init data item '${item.name}' has duplicate field '${field.name}'`);
+        }
+        seenFieldNames.add(field.name);
+        if (typeof field.type !== "string" || field.type.trim().length === 0) {
+          throw new Error(`Init data field '${item.name}.${field.name}' must have a string 'type'`);
+        }
+        let fieldSize;
+        try {
+          fieldSize = getInitDataTypeSize(field.type);
+        } catch (error) {
+          const message = error instanceof Error ? error.message : String(error);
+          throw new Error(`Invalid type '${field.type}' for init data field '${item.name}.${field.name}': ${message}`);
+        }
+        const compiledField = {
+          name: field.name,
+          type: field.type,
+          size: fieldSize,
+          offset: fieldOffset
+        };
+        const vec3Array = parseVec3ArrayType(field.type);
+        if (vec3Array) {
+          compiledField.arrayLength = vec3Array.length;
+          compiledField.arrayElementType = "f32";
+        } else {
+          const vec2Array = parseVec2ArrayType(field.type);
+          if (vec2Array) {
+            compiledField.arrayLength = vec2Array.length;
+            compiledField.arrayElementType = "f32";
+          } else {
+            const primArray = parseArrayType(field.type);
+            if (primArray) {
+              compiledField.arrayLength = primArray.length;
+              compiledField.arrayElementType = primArray.elementType;
+            }
+          }
+        }
+        fields.push(compiledField);
+        fieldOffset += fieldSize;
+        itemSize += fieldSize;
+      }
+      const compiled = {
+        name: item.name,
+        type: "compound",
+        size: itemSize,
+        storageOffset: offset,
+        fields
+      };
+      compiledItems.push(compiled);
+      itemByName.set(item.name, compiled);
+    }
+    offset += itemSize;
+  }
+  return {
+    items: compiledItems,
+    itemByName,
+    headerSize: INIT_DATA_HEADER_SIZE,
+    totalSize: offset
+  };
+}
+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/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":
@@ -1938,40 +2641,278 @@ export function get${pascal}${argPascal}YFromPayload(payload: Uint8Array): numbe
   if (offset < 0) {
     return 0;
   }
-  return readF32(payload, offset + ${arg.offset} + 4);
+  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;
+}
+function generateInitDataHeader(schema) {
+  return `// =============================================================================
+// Init Data Bindings
+// =============================================================================
+
+// Init data is read-only constant data set once per session.
+// The data is shared by all clients and hashed into session identification.
+
+/** Init data buffer magic number */
+export const INIT_DATA_MAGIC = 0x${INIT_DATA_MAGIC.toString(16)};
+
+/** Init data header size in bytes */
+export const INIT_DATA_HEADER_SIZE = ${INIT_DATA_HEADER_SIZE};
+
+/** Total init data buffer size in bytes */
+export const INIT_DATA_TOTAL_SIZE = ${schema.totalSize};
+
+/** Internal DataView for init data - set via setInitData() */
+let _initDataView: DataView | null = null;
+
+/** Set init data buffer. Called by executor during initialization. */
+export function setInitData(data: Uint8Array): void {
+  if (data.length !== INIT_DATA_TOTAL_SIZE) {
+    throw new Error(\`Init data size mismatch: expected \${INIT_DATA_TOTAL_SIZE}, got \${data.length}\`);
+  }
+  _initDataView = new DataView(data.buffer, data.byteOffset, data.byteLength);
+
+  // Verify magic number
+  const magic = _initDataView.getUint32(0, true);
+  if (magic !== INIT_DATA_MAGIC) {
+    throw new Error(\`Invalid init data magic: expected 0x\${INIT_DATA_MAGIC.toString(16)}, got 0x\${magic.toString(16)}\`);
+  }
+}
+
+/** Check if init data has been set */
+export function hasInitData(): boolean {
+  return _initDataView !== null;
+}
+
+/** Get the init data DataView (throws if not set) */
+function getInitDataView(): DataView {
+  if (!_initDataView) {
+    throw new Error('Init data not set. Call setInitData() first.');
+  }
+  return _initDataView;
+}
+`;
+}
+function generateInitDataItemOffsets(schema) {
+  let out = `// =============================================================================
+// Init Data Item Offsets
+// =============================================================================
+
+`;
+  for (const item of schema.items) {
+    const UPPER = toUpperSnake(item.name);
+    out += `const INIT_${UPPER}_OFFSET = ${item.storageOffset};
+`;
+    if (item.isBlob) {
+      out += `export const INIT_${UPPER}_MAX_SIZE = ${item.blobMaxSize};
+`;
+    }
+  }
+  return out;
+}
+function generateInitDataAccessor(field, itemName, itemOffset) {
+  const fieldPascal = toPascalCase(field.name);
+  const funcName = `get${toPascalCase(itemName)}${fieldPascal}`;
+  const offset = itemOffset + field.offset;
+  const vec3Array = parseVec3ArrayType(field.type);
+  if (vec3Array) {
+    const count = vec3Array.length;
+    return `
+/** Get ${itemName}.${field.name}[index].x (max index: ${count - 1}) */
+export function ${funcName}X(index: number): number {
+  if (index < 0 || index >= ${count}) return 0;
+  return getInitDataView().getFloat32(${offset} + index * 12, true);
+}
+
+/** Get ${itemName}.${field.name}[index].y (max index: ${count - 1}) */
+export function ${funcName}Y(index: number): number {
+  if (index < 0 || index >= ${count}) return 0;
+  return getInitDataView().getFloat32(${offset} + index * 12 + 4, true);
+}
+
+/** Get ${itemName}.${field.name}[index].z (max index: ${count - 1}) */
+export function ${funcName}Z(index: number): number {
+  if (index < 0 || index >= ${count}) return 0;
+  return getInitDataView().getFloat32(${offset} + index * 12 + 8, true);
+}
+`;
+  }
+  const vec2Array = parseVec2ArrayType(field.type);
+  if (vec2Array) {
+    const count = vec2Array.length;
+    return `
+/** Get ${itemName}.${field.name}[index].x (max index: ${count - 1}) */
+export function ${funcName}X(index: number): number {
+  if (index < 0 || index >= ${count}) return 0;
+  return getInitDataView().getFloat32(${offset} + index * 8, true);
+}
+
+/** Get ${itemName}.${field.name}[index].y (max index: ${count - 1}) */
+export function ${funcName}Y(index: number): number {
+  if (index < 0 || index >= ${count}) return 0;
+  return getInitDataView().getFloat32(${offset} + index * 8 + 4, true);
+}
+`;
+  }
+  if (field.type === "vec3") {
+    return `
+/** Get ${itemName}.${field.name}.x */
+export function ${funcName}X(): number {
+  return getInitDataView().getFloat32(${offset}, true);
+}
+
+/** Get ${itemName}.${field.name}.y */
+export function ${funcName}Y(): number {
+  return getInitDataView().getFloat32(${offset + 4}, true);
+}
+
+/** Get ${itemName}.${field.name}.z */
+export function ${funcName}Z(): number {
+  return getInitDataView().getFloat32(${offset + 8}, true);
+}
+`;
+  }
+  if (field.type === "vec2") {
+    return `
+/** Get ${itemName}.${field.name}.x */
+export function ${funcName}X(): number {
+  return getInitDataView().getFloat32(${offset}, true);
+}
+
+/** Get ${itemName}.${field.name}.y */
+export function ${funcName}Y(): number {
+  return getInitDataView().getFloat32(${offset + 4}, true);
+}
+`;
+  }
+  if (field.type === "quat") {
+    return `
+/** Get ${itemName}.${field.name}.x */
+export function ${funcName}X(): number {
+  return getInitDataView().getFloat32(${offset}, true);
 }
 
-/** 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 ${itemName}.${field.name}.y */
+export function ${funcName}Y(): number {
+  return getInitDataView().getFloat32(${offset + 4}, true);
 }
 
-/** 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;
+/** Get ${itemName}.${field.name}.z */
+export function ${funcName}Z(): number {
+  return getInitDataView().getFloat32(${offset + 8}, true);
+}
+
+/** Get ${itemName}.${field.name}.w */
+export function ${funcName}W(): number {
+  return getInitDataView().getFloat32(${offset + 12}, true);
+}
+`;
   }
-  return readF32(payload, offset + ${arg.offset} + 12);
+  if (field.arrayLength !== void 0 && field.arrayElementType) {
+    const loadFn3 = tsLoadFnForType(field.arrayElementType);
+    const elemSize = getElementSize(field.arrayElementType);
+    const needsLE2 = needsEndian(field.arrayElementType);
+    const tsTyp2 = tsTypeMapping(field.arrayElementType);
+    const leArg2 = needsLE2 ? ", true" : "";
+    const defaultVal = tsTyp2 === "boolean" ? "false" : "0";
+    const count = field.arrayLength;
+    return `
+/** Get ${itemName}.${field.name}[index] (max index: ${count - 1}) */
+export function ${funcName}(index: number): ${tsTyp2} {
+  if (index < 0 || index >= ${count}) return ${defaultVal};
+  return getInitDataView().${loadFn3}(${offset} + index * ${elemSize}${leArg2});
 }
 `;
-    } 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});
+  const loadFn2 = tsLoadFnForType(field.type);
+  const needsLE = needsEndian(field.type);
+  const tsTyp = tsTypeMapping(field.type);
+  const leArg = needsLE ? ", true" : "";
+  const retExpr = field.type === "bool" ? `getInitDataView().${loadFn2}(${offset}) !== 0` : `getInitDataView().${loadFn2}(${offset}${leArg})`;
+  return `
+/** Get ${itemName}.${field.name} */
+export function ${funcName}(): ${tsTyp} {
+  return ${retExpr};
 }
 `;
-    }
+}
+function generateInitDataItemAccessors(item) {
+  if (item.isBlob) {
+    const UPPER = toUpperSnake(item.name);
+    const funcName = `get${toPascalCase(item.name)}`;
+    return `
+// ---------- ${item.name} (blob) ----------
+
+/** Get current length of ${item.name} blob */
+export function ${funcName}Length(): number {
+  return getInitDataView().getUint32(INIT_${UPPER}_OFFSET, true);
+}
+
+/**
+ * Get ${item.name} blob data as a Uint8Array view.
+ *
+ * WARNING: This returns a view into the init data buffer, not a copy.
+ * Init data is read-only - do NOT mutate the returned array.
+ * Modifying it will corrupt shared init data used by all game logic.
+ */
+export function ${funcName}(): Uint8Array {
+  const view = getInitDataView();
+  const length = view.getUint32(INIT_${UPPER}_OFFSET, true);
+  return new Uint8Array(view.buffer, view.byteOffset + INIT_${UPPER}_OFFSET + 4, length);
+}
+`;
+  }
+  let out = `
+// ---------- ${item.name} ----------
+`;
+  for (const field of item.fields) {
+    out += generateInitDataAccessor(field, item.name, item.storageOffset);
+  }
+  return out;
+}
+function generateInitData(schema) {
+  if (schema.items.length === 0) {
+    return "";
+  }
+  let out = generateInitDataHeader(schema);
+  out += "\n";
+  out += generateInitDataItemOffsets(schema);
+  out += "\n";
+  for (const item of schema.items) {
+    out += generateInitDataItemAccessors(item);
   }
   return out;
 }
@@ -2059,8 +3000,18 @@ var TypeScriptGenerator = class {
     }
     return out;
   }
-  generateGame(state, input) {
-    return this.generateState(state) + "\n" + this.generateInput(input);
+  generateInitData(schema) {
+    if (!schema || schema.items.length === 0) {
+      return "";
+    }
+    return generateInitData(schema);
+  }
+  generateGame(state, input, initData) {
+    let out = this.generateState(state) + "\n" + this.generateInput(input);
+    if (initData && initData.items.length > 0) {
+      out += "\n" + this.generateInitData(initData);
+    }
+    return out;
   }
 };
 
@@ -3420,611 +4371,357 @@ function generateGameAllocator() {
 static ALLOCATOR: talc::TalckWasm = unsafe { talc::TalckWasm::new_global() };
 `;
 }
-var RustGenerator = class {
-  language = "rust";
-  opts;
-  maxParticipants;
-  constructor(opts = {}) {
-    this.opts = opts;
-    this.maxParticipants = opts.maxParticipants ?? 8;
-  }
-  generateState(schema) {
-    let out = generateStateHeader2(schema, this.maxParticipants);
-    out += generateComponentOffsets2(schema);
-    out += generateMemoryHelpers();
-    out += generateInternalHelpers();
-    out += generateIterationHelpers2(schema);
-    out += generateQueryHelpers2();
-    out += generateLifecycle2(schema);
-    out += `
-// =============================================================================
-// Component Operations
+function generateRustInitDataHeader(schema) {
+  return `// =============================================================================
+// Init Data Bindings
 // =============================================================================
+
+// Init data is read-only constant data set once per session.
+// The data is shared by all clients and hashed into session identification.
+//
+// SAFETY: Init data accessors must only be called after set_init_data_ptr() has
+// been called. The host runtime guarantees this is done before apply() is called.
+// Calling accessors before initialization will result in null pointer access.
+//
+// To explicitly check if init data is available, use has_init_data().
+// This is not normally needed since the runtime guarantees initialization order.
+
+/// Init data buffer magic number
+pub const INIT_DATA_MAGIC: u32 = 0x${INIT_DATA_MAGIC.toString(16)};
+
+/// Init data header size in bytes
+pub const INIT_DATA_HEADER_SIZE: u32 = ${INIT_DATA_HEADER_SIZE};
+
+/// Total init data buffer size in bytes
+pub const INIT_DATA_TOTAL_SIZE: u32 = ${schema.totalSize};
+
+/// Static pointer to init data buffer - set via set_init_data_ptr()
+///
+/// SAFETY: This pointer is initialized to null and must be set via set_init_data_ptr()
+/// before any init data accessors are called. The runtime guarantees this happens
+/// before apply() is invoked.
+static mut INIT_DATA_PTR: *const u8 = core::ptr::null();
+
+/// Set init data pointer. Called by host during WASM initialization.
+///
+/// # Safety
+/// The provided pointer must point to a valid init data buffer of size INIT_DATA_TOTAL_SIZE.
+/// This function must be called exactly once before any init data accessors are used.
+///
+/// # Panics (debug builds only)
+/// Panics if called more than once, indicating a bug in the runtime.
+#[no_mangle]
+pub unsafe extern "C" fn set_init_data_ptr(ptr: *const u8) {
+    debug_assert!(INIT_DATA_PTR.is_null(), "set_init_data_ptr called more than once");
+    INIT_DATA_PTR = ptr;
+}
+
+/// Check if init data pointer has been set.
+///
+/// Returns true if init data is available, false otherwise.
+/// This can be used to guard against accessing init data before initialization,
+/// though this is not normally needed since the runtime guarantees initialization order.
+#[inline]
+pub fn has_init_data() -> bool {
+    unsafe { !INIT_DATA_PTR.is_null() }
+}
 `;
-    for (const comp of schema.entityComponents) {
-      out += generateComponentAccessors2(comp);
-    }
-    if (schema.singletonComponents.length > 0) {
-      out += `
+}
+function generateRustInitDataItemOffsets(schema) {
+  let out = `
 // =============================================================================
-// Singleton Components
+// Init Data Item Offsets
 // =============================================================================
+
 `;
-      for (const comp of schema.singletonComponents) {
-        if (comp.isBlob) {
-          out += generateBlobAccessors2(comp);
-        } else {
-          out += generateSingletonAccessors2(comp);
-        }
-      }
-    }
-    if (schema.events && schema.events.length > 0) {
-      out += `
-// =============================================================================
-// Events
-// =============================================================================
+  for (const item of schema.items) {
+    const UPPER = toUpperSnake(item.name);
+    out += `const INIT_${UPPER}_OFFSET: u32 = ${item.storageOffset};
 `;
-      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)
-// =============================================================================
+    if (item.isBlob) {
+      out += `pub const INIT_${UPPER}_MAX_SIZE: u32 = ${item.blobMaxSize};
 `;
-      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.
+  return out;
+}
+function generateRustInitDataAccessor(field, itemName, itemOffset) {
+  const ITEM_LOWER = toLowerSnake(itemName);
+  const fieldLower = toLowerSnake(field.name);
+  const funcName = `get_${ITEM_LOWER}_${fieldLower}`;
+  const offset = itemOffset + field.offset;
+  const vec3Array = parseVec3ArrayType(field.type);
+  if (vec3Array) {
+    const count = vec3Array.length;
+    return `
+/// Get ${itemName}.${field.name}[index].x
+#[inline]
+pub unsafe fn ${funcName}_x(index: i32) -> f32 {
+    if (index as u32) >= ${count} { return 0.0; }
+    load_f32(INIT_DATA_PTR.add((${offset} + (index as u32) * 12) as usize))
+}
 
-// --- State accessors --------------------------------------------------------
-`;
-    out += this.generateState(state);
-    out += `
-// --- Input helpers ---------------------------------------------------------
+/// Get ${itemName}.${field.name}[index].y
+#[inline]
+pub unsafe fn ${funcName}_y(index: i32) -> f32 {
+    if (index as u32) >= ${count} { return 0.0; }
+    load_f32(INIT_DATA_PTR.add((${offset} + (index as u32) * 12 + 4) as usize))
+}
+
+/// Get ${itemName}.${field.name}[index].z
+#[inline]
+pub unsafe fn ${funcName}_z(index: i32) -> f32 {
+    if (index as u32) >= ${count} { return 0.0; }
+    load_f32(INIT_DATA_PTR.add((${offset} + (index as u32) * 12 + 8) as usize))
+}
 `;
-    out += this.generateInput(input);
-    out += generateGameAllocator();
-    return out;
   }
-};
+  const vec2Array = parseVec2ArrayType(field.type);
+  if (vec2Array) {
+    const count = vec2Array.length;
+    return `
+/// Get ${itemName}.${field.name}[index].x
+#[inline]
+pub unsafe fn ${funcName}_x(index: i32) -> f32 {
+    if (index as u32) >= ${count} { return 0.0; }
+    load_f32(INIT_DATA_PTR.add((${offset} + (index as u32) * 8) as usize))
+}
 
-// 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 };
+/// Get ${itemName}.${field.name}[index].y
+#[inline]
+pub unsafe fn ${funcName}_y(index: i32) -> f32 {
+    if (index as u32) >= ${count} { return 0.0; }
+    load_f32(INIT_DATA_PTR.add((${offset} + (index as u32) * 8 + 4) as usize))
 }
-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 };
+  if (field.type === "vec3") {
+    return `
+/// Get ${itemName}.${field.name}.x
+#[inline]
+pub unsafe fn ${funcName}_x() -> f32 {
+    load_f32(INIT_DATA_PTR.add(${offset}))
 }
-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;
+
+/// Get ${itemName}.${field.name}.y
+#[inline]
+pub unsafe fn ${funcName}_y() -> f32 {
+    load_f32(INIT_DATA_PTR.add(${offset + 4}))
 }
-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}`);
+
+/// Get ${itemName}.${field.name}.z
+#[inline]
+pub unsafe fn ${funcName}_z() -> f32 {
+    load_f32(INIT_DATA_PTR.add(${offset + 8}))
+}
+`;
   }
-  return size;
+  if (field.type === "vec2") {
+    return `
+/// Get ${itemName}.${field.name}.x
+#[inline]
+pub unsafe fn ${funcName}_x() -> f32 {
+    load_f32(INIT_DATA_PTR.add(${offset}))
 }
-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}`);
+
+/// Get ${itemName}.${field.name}.y
+#[inline]
+pub unsafe fn ${funcName}_y() -> f32 {
+    load_f32(INIT_DATA_PTR.add(${offset + 4}))
+}
+`;
   }
+  if (field.type === "quat") {
+    return `
+/// Get ${itemName}.${field.name}.x
+#[inline]
+pub unsafe fn ${funcName}_x() -> f32 {
+    load_f32(INIT_DATA_PTR.add(${offset}))
 }
-function validateEnumVariants(rawVariants, subject) {
-  const variants = rawVariants ?? [];
-  if (!Array.isArray(variants)) {
-    throw new Error(`enum ${subject} must have at least one variant`);
+
+/// Get ${itemName}.${field.name}.y
+#[inline]
+pub unsafe fn ${funcName}_y() -> f32 {
+    load_f32(INIT_DATA_PTR.add(${offset + 4}))
+}
+
+/// Get ${itemName}.${field.name}.z
+#[inline]
+pub unsafe fn ${funcName}_z() -> f32 {
+    load_f32(INIT_DATA_PTR.add(${offset + 8}))
+}
+
+/// Get ${itemName}.${field.name}.w
+#[inline]
+pub unsafe fn ${funcName}_w() -> f32 {
+    load_f32(INIT_DATA_PTR.add(${offset + 12}))
+}
+`;
   }
-  if (variants.length === 0) {
-    throw new Error(`enum ${subject} must have at least one variant`);
+  if (field.arrayLength !== void 0 && field.arrayElementType) {
+    const loadFunc2 = loadFnForType(field.arrayElementType);
+    const elemSize = getElementSize(field.arrayElementType);
+    const rustTyp2 = rustTypeMapping(field.arrayElementType);
+    const defaultVal = rustTyp2 === "bool" ? "false" : `0${rustTyp2 === "f32" ? ".0" : ""}`;
+    const count = field.arrayLength;
+    return `
+/// Get ${itemName}.${field.name}[index]
+#[inline]
+pub unsafe fn ${funcName}(index: i32) -> ${rustTyp2} {
+    if (index as u32) >= ${count} { return ${defaultVal}; }
+    ${loadFunc2}(INIT_DATA_PTR.add((${offset} + (index as u32) * ${elemSize}) as usize))
+}
+`;
   }
-  if (variants.length > 256) {
-    throw new Error(`enum ${subject} has ${variants.length} variants, maximum is 256`);
+  const loadFunc = loadFnForType(field.type);
+  const rustTyp = rustTypeMapping(field.type);
+  return `
+/// Get ${itemName}.${field.name}
+#[inline]
+pub unsafe fn ${funcName}() -> ${rustTyp} {
+    ${loadFunc}(INIT_DATA_PTR.add(${offset}))
+}
+`;
+}
+function generateRustInitDataItemAccessors(item) {
+  if (item.isBlob) {
+    const UPPER = toUpperSnake(item.name);
+    const funcNameLower = toLowerSnake(item.name);
+    return `
+// ---------- ${item.name} (blob) ----------
+
+/// Get current length of ${item.name} blob
+#[inline]
+pub unsafe fn get_${funcNameLower}_len() -> u32 {
+    load_u32(INIT_DATA_PTR.add(INIT_${UPPER}_OFFSET as usize))
+}
+
+/// Get pointer to ${item.name} blob data
+#[inline]
+pub unsafe fn get_${funcNameLower}_ptr() -> *const u8 {
+    INIT_DATA_PTR.add(INIT_${UPPER}_OFFSET as usize + 4)
+}
+`;
   }
-  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);
+  let out = `
+// ---------- ${item.name} ----------
+`;
+  for (const field of item.fields) {
+    out += generateRustInitDataAccessor(field, item.name, item.storageOffset);
   }
-  return variants;
+  return out;
 }
-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();
+function generateRustInitData(schema) {
+  if (schema.items.length === 0) {
+    return "";
   }
-  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}`);
+  let out = generateRustInitDataHeader(schema);
+  out += "\n";
+  out += generateRustInitDataItemOffsets(schema);
+  out += "\n";
+  for (const item of schema.items) {
+    out += generateRustInitDataItemAccessors(item);
   }
-  if (!Array.isArray(componentDefs)) {
-    throw new Error("schema.components must be an array to preserve deterministic ordering");
+  return out;
+}
+var RustGenerator = class {
+  language = "rust";
+  opts;
+  maxParticipants;
+  constructor(opts = {}) {
+    this.opts = opts;
+    this.maxParticipants = opts.maxParticipants ?? 8;
   }
-  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;
-    let isBlob = false;
-    let blobMaxSize;
-    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 if (componentType === "blob") {
-      if (!isSingleton) {
-        throw new Error(`Component '${name}' with type 'blob' must be a singleton`);
-      }
-      const maxSize = componentDef.maxSize;
-      if (typeof maxSize !== "number" || maxSize <= 0) {
-        throw new Error(`Component '${name}' with type 'blob' requires positive 'maxSize'`);
-      }
-      componentSize = 4 + maxSize;
-      isBlob = true;
-      blobMaxSize = maxSize;
-    } 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
-    };
-    if (isBlob) {
-      compiled.isBlob = true;
-      compiled.blobMaxSize = blobMaxSize;
+  generateState(schema) {
+    let out = generateStateHeader2(schema, this.maxParticipants);
+    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);
     }
-    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;
+    if (schema.singletonComponents.length > 0) {
+      out += `
+// =============================================================================
+// Singleton Components
+// =============================================================================
+`;
+      for (const comp of schema.singletonComponents) {
+        if (comp.isBlob) {
+          out += generateBlobAccessors2(comp);
+        } else {
+          out += generateSingletonAccessors2(comp);
+        }
       }
-      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;
+    if (schema.events && schema.events.length > 0) {
+      out += `
+// =============================================================================
+// Events
+// =============================================================================
+`;
+      for (const event of schema.events) {
+        out += generateEventAccessors2(event);
       }
-      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 out;
   }
-  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'`);
+  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);
+      }
     }
-    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)`);
+    if (schema.commands.length > 0) {
+      out += generateCommandConstants(schema);
     }
+    return out;
   }
-  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;
+  generateInitData(schema) {
+    if (!schema || schema.items.length === 0) {
+      return "";
     }
-    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 generateRustInitData(schema);
+  }
+  generateGame(state, input, initData) {
+    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);
+    if (initData && initData.items.length > 0) {
+      out += `
+// --- Init data accessors ---------------------------------------------------
+`;
+      out += this.generateInitData(initData);
     }
+    out += generateGameAllocator();
+    return out;
   }
-  return { controls, commands, controlByName, commandByName };
-}
+};
 
 // src/vite/codegen-runner.ts
 async function runCodegen(configPath, options) {
@@ -4038,11 +4735,15 @@ async function runCodegen(configPath, options) {
   const compiledInput = compileInputSchema(merged.config.input);
   const preparedState = prepareStateSchema(merged.config.state, compiledInput);
   const compiledState = compileStateSchema(preparedState);
+  const compiledInitData = merged.config.data && merged.config.data.length > 0 ? compileInitDataSchema(merged.config.data) : void 0;
   if (verbose) {
     console.log(`[multitap] State buffer size: ${compiledState.totalSize} bytes`);
+    if (compiledInitData) {
+      console.log(`[multitap] Init data buffer size: ${compiledInitData.totalSize} bytes`);
+    }
   }
   const tsGen = new TypeScriptGenerator({ maxParticipants: merged.config.maxParticipants });
-  const tsCode = tsGen.generateGame(compiledState, compiledInput);
+  const tsCode = tsGen.generateGame(compiledState, compiledInput, compiledInitData);
   await mkdir(generatedDir, { recursive: true });
   const tsPath = join2(generatedDir, "state.ts");
   await writeFile(tsPath, tsCode, "utf-8");
@@ -4050,7 +4751,7 @@ async function runCodegen(configPath, options) {
     console.log(`[multitap] Generated ${tsPath}`);
   }
   const rustGen = new RustGenerator({ maxParticipants: merged.config.maxParticipants });
-  const rustCode = rustGen.generateGame(compiledState, compiledInput);
+  const rustCode = rustGen.generateGame(compiledState, compiledInput, compiledInitData);
   for (const pluginPath of merged.pluginOrder) {
     const rustDir = join2(pluginPath, "src");
     await mkdir(rustDir, { recursive: true });
@@ -4063,6 +4764,7 @@ async function runCodegen(configPath, options) {
   return {
     compiledState,
     compiledInput,
+    compiledInitData,
     mergedConfig: merged,
     graph
   };
@@ -4186,8 +4888,15 @@ function prepareStateSchemaForSerialization(schema) {
     bitmaskSize: schema.bitmaskSize
   };
 }
+function prepareInitDataSchemaForSerialization(schema) {
+  return {
+    items: schema.items,
+    headerSize: schema.headerSize,
+    totalSize: schema.totalSize
+  };
+}
 function buildVirtualModule(options) {
-  const { config, plugins, compiledState } = options;
+  const { config, plugins, compiledState, compiledInitData } = options;
   const lines = [];
   lines.push("function base64ToUint8Array(b64) {");
   lines.push("  const binary = atob(b64);");
@@ -4206,7 +4915,8 @@ function buildVirtualModule(options) {
   lines.push("");
   const stateJSON = JSON.stringify(prepareStateSchemaForSerialization(compiledState));
   const inputJSON = JSON.stringify(config.input);
-  lines.push(`const schema = { state: ${stateJSON}, input: ${inputJSON} };`);
+  const initDataJSON = compiledInitData ? JSON.stringify(prepareInitDataSchemaForSerialization(compiledInitData)) : "undefined";
+  lines.push(`const schema = { state: ${stateJSON}, input: ${inputJSON}, initData: ${initDataJSON} };`);
   lines.push("");
   lines.push("export default {");
   lines.push(`  appID: ${JSON.stringify(config.appID)},`);
@@ -4275,7 +4985,8 @@ function multitapPlugin(options = {}) {
       const moduleCode = buildVirtualModule({
         config: codegenResult.mergedConfig.config,
         plugins,
-        compiledState: codegenResult.compiledState
+        compiledState: codegenResult.compiledState,
+        compiledInitData: codegenResult.compiledInitData
       });
       if (verbose) {
         console.log(`[multitap] Build complete`);