@holoscript/engine 6.0.3 → 6.0.4

package/dist/chunk-HYXNV36F.js

@@ -0,0 +1,1256 @@
+import {
+  __export
+} from "./chunk-AKLW2MUS.js";
+
+// src/vm/index.ts
+var vm_exports = {};
+__export(vm_exports, {
+  AssetType: () => AssetType,
+  BodyType: () => BodyType,
+  ColliderShape: () => ColliderShape,
+  ComponentType: () => ComponentType,
+  ECSWorld: () => ECSWorld,
+  GeometryType: () => GeometryType,
+  HOLOB_MAGIC: () => HOLOB_MAGIC,
+  HOLOB_VERSION: () => HOLOB_VERSION,
+  HoloBytecodeBuilder: () => HoloBytecodeBuilder,
+  HoloFunctionBuilder: () => HoloFunctionBuilder,
+  HoloOpCode: () => HoloOpCode,
+  HoloVM: () => HoloVM,
+  HolobFlags: () => HolobFlags,
+  LightType: () => LightType,
+  SyncTier: () => SyncTier,
+  VMStatus: () => VMStatus,
+  ValueType: () => ValueType,
+  getOpcodeFamily: () => getOpcodeFamily,
+  getOpcodeName: () => getOpcodeName,
+  isControlFlow: () => isControlFlow
+});
+
+// src/vm/opcodes.ts
+var HoloOpCode = /* @__PURE__ */ ((HoloOpCode2) => {
+  HoloOpCode2[HoloOpCode2["SPAWN"] = 1] = "SPAWN";
+  HoloOpCode2[HoloOpCode2["DESPAWN"] = 2] = "DESPAWN";
+  HoloOpCode2[HoloOpCode2["CLONE"] = 3] = "CLONE";
+  HoloOpCode2[HoloOpCode2["SET_COMPONENT"] = 4] = "SET_COMPONENT";
+  HoloOpCode2[HoloOpCode2["GET_COMPONENT"] = 5] = "GET_COMPONENT";
+  HoloOpCode2[HoloOpCode2["REMOVE_COMPONENT"] = 6] = "REMOVE_COMPONENT";
+  HoloOpCode2[HoloOpCode2["SET_PARENT"] = 7] = "SET_PARENT";
+  HoloOpCode2[HoloOpCode2["QUERY"] = 8] = "QUERY";
+  HoloOpCode2[HoloOpCode2["TRANSFORM"] = 16] = "TRANSFORM";
+  HoloOpCode2[HoloOpCode2["TRANSLATE"] = 17] = "TRANSLATE";
+  HoloOpCode2[HoloOpCode2["ROTATE"] = 18] = "ROTATE";
+  HoloOpCode2[HoloOpCode2["LOOK_AT"] = 19] = "LOOK_AT";
+  HoloOpCode2[HoloOpCode2["RAYCAST"] = 20] = "RAYCAST";
+  HoloOpCode2[HoloOpCode2["QUERY_BOX"] = 21] = "QUERY_BOX";
+  HoloOpCode2[HoloOpCode2["QUERY_SPHERE"] = 22] = "QUERY_SPHERE";
+  HoloOpCode2[HoloOpCode2["FIND_PATH"] = 23] = "FIND_PATH";
+  HoloOpCode2[HoloOpCode2["GET_ZONE"] = 24] = "GET_ZONE";
+  HoloOpCode2[HoloOpCode2["ADD_RIGIDBODY"] = 32] = "ADD_RIGIDBODY";
+  HoloOpCode2[HoloOpCode2["APPLY_FORCE"] = 33] = "APPLY_FORCE";
+  HoloOpCode2[HoloOpCode2["APPLY_IMPULSE"] = 34] = "APPLY_IMPULSE";
+  HoloOpCode2[HoloOpCode2["SET_VELOCITY"] = 35] = "SET_VELOCITY";
+  HoloOpCode2[HoloOpCode2["ADD_COLLIDER"] = 36] = "ADD_COLLIDER";
+  HoloOpCode2[HoloOpCode2["ADD_JOINT"] = 37] = "ADD_JOINT";
+  HoloOpCode2[HoloOpCode2["SET_GRAVITY"] = 38] = "SET_GRAVITY";
+  HoloOpCode2[HoloOpCode2["PHYSICS_STEP"] = 39] = "PHYSICS_STEP";
+  HoloOpCode2[HoloOpCode2["SET_GEOMETRY"] = 48] = "SET_GEOMETRY";
+  HoloOpCode2[HoloOpCode2["SET_MATERIAL"] = 49] = "SET_MATERIAL";
+  HoloOpCode2[HoloOpCode2["SET_VISIBLE"] = 50] = "SET_VISIBLE";
+  HoloOpCode2[HoloOpCode2["SET_LOD"] = 51] = "SET_LOD";
+  HoloOpCode2[HoloOpCode2["SET_LIGHT"] = 52] = "SET_LIGHT";
+  HoloOpCode2[HoloOpCode2["SET_ANIMATION"] = 53] = "SET_ANIMATION";
+  HoloOpCode2[HoloOpCode2["SET_GAUSSIAN_SPLAT"] = 54] = "SET_GAUSSIAN_SPLAT";
+  HoloOpCode2[HoloOpCode2["SET_PARTICLE_SYSTEM"] = 55] = "SET_PARTICLE_SYSTEM";
+  HoloOpCode2[HoloOpCode2["APPLY_TRAIT"] = 64] = "APPLY_TRAIT";
+  HoloOpCode2[HoloOpCode2["REMOVE_TRAIT"] = 65] = "REMOVE_TRAIT";
+  HoloOpCode2[HoloOpCode2["RESOLVE_TRAITS"] = 66] = "RESOLVE_TRAITS";
+  HoloOpCode2[HoloOpCode2["EMIT_EVENT"] = 67] = "EMIT_EVENT";
+  HoloOpCode2[HoloOpCode2["ON_EVENT"] = 68] = "ON_EVENT";
+  HoloOpCode2[HoloOpCode2["EVAL_CONDITION"] = 69] = "EVAL_CONDITION";
+  HoloOpCode2[HoloOpCode2["LOAD_ASSET"] = 80] = "LOAD_ASSET";
+  HoloOpCode2[HoloOpCode2["PLAY_AUDIO"] = 81] = "PLAY_AUDIO";
+  HoloOpCode2[HoloOpCode2["NET_SYNC"] = 82] = "NET_SYNC";
+  HoloOpCode2[HoloOpCode2["NET_SEND"] = 83] = "NET_SEND";
+  HoloOpCode2[HoloOpCode2["NET_RECV"] = 84] = "NET_RECV";
+  HoloOpCode2[HoloOpCode2["XR_INPUT"] = 85] = "XR_INPUT";
+  HoloOpCode2[HoloOpCode2["HAPTIC"] = 86] = "HAPTIC";
+  HoloOpCode2[HoloOpCode2["NOP"] = 96] = "NOP";
+  HoloOpCode2[HoloOpCode2["JUMP"] = 97] = "JUMP";
+  HoloOpCode2[HoloOpCode2["JUMP_IF"] = 98] = "JUMP_IF";
+  HoloOpCode2[HoloOpCode2["CALL"] = 99] = "CALL";
+  HoloOpCode2[HoloOpCode2["RETURN"] = 100] = "RETURN";
+  HoloOpCode2[HoloOpCode2["PUSH"] = 101] = "PUSH";
+  HoloOpCode2[HoloOpCode2["POP"] = 102] = "POP";
+  HoloOpCode2[HoloOpCode2["STORE"] = 103] = "STORE";
+  HoloOpCode2[HoloOpCode2["LOAD"] = 104] = "LOAD";
+  HoloOpCode2[HoloOpCode2["HALT"] = 105] = "HALT";
+  HoloOpCode2[HoloOpCode2["YIELD"] = 106] = "YIELD";
+  HoloOpCode2[HoloOpCode2["TIMER"] = 107] = "TIMER";
+  HoloOpCode2[HoloOpCode2["ADD"] = 108] = "ADD";
+  HoloOpCode2[HoloOpCode2["SUB"] = 109] = "SUB";
+  HoloOpCode2[HoloOpCode2["MUL"] = 110] = "MUL";
+  HoloOpCode2[HoloOpCode2["DIV"] = 111] = "DIV";
+  HoloOpCode2[HoloOpCode2["AGENT_INVOKE"] = 112] = "AGENT_INVOKE";
+  HoloOpCode2[HoloOpCode2["AGENT_READ"] = 113] = "AGENT_READ";
+  HoloOpCode2[HoloOpCode2["AGENT_SUBSCRIBE"] = 114] = "AGENT_SUBSCRIBE";
+  HoloOpCode2[HoloOpCode2["DIALOG_SHOW"] = 115] = "DIALOG_SHOW";
+  HoloOpCode2[HoloOpCode2["QUEST_UPDATE"] = 116] = "QUEST_UPDATE";
+  HoloOpCode2[HoloOpCode2["CMP_EQ"] = 128] = "CMP_EQ";
+  HoloOpCode2[HoloOpCode2["CMP_LT"] = 129] = "CMP_LT";
+  HoloOpCode2[HoloOpCode2["CMP_GT"] = 130] = "CMP_GT";
+  HoloOpCode2[HoloOpCode2["NOT"] = 131] = "NOT";
+  return HoloOpCode2;
+})(HoloOpCode || {});
+var ComponentType = /* @__PURE__ */ ((ComponentType2) => {
+  ComponentType2[ComponentType2["Transform"] = 1] = "Transform";
+  ComponentType2[ComponentType2["Geometry"] = 2] = "Geometry";
+  ComponentType2[ComponentType2["Material"] = 3] = "Material";
+  ComponentType2[ComponentType2["RigidBody"] = 4] = "RigidBody";
+  ComponentType2[ComponentType2["Collider"] = 5] = "Collider";
+  ComponentType2[ComponentType2["Light"] = 6] = "Light";
+  ComponentType2[ComponentType2["Animation"] = 7] = "Animation";
+  ComponentType2[ComponentType2["Audio"] = 8] = "Audio";
+  ComponentType2[ComponentType2["Network"] = 9] = "Network";
+  ComponentType2[ComponentType2["Trait"] = 10] = "Trait";
+  ComponentType2[ComponentType2["ParticleSystem"] = 11] = "ParticleSystem";
+  ComponentType2[ComponentType2["GaussianSplat"] = 12] = "GaussianSplat";
+  ComponentType2[ComponentType2["LOD"] = 13] = "LOD";
+  ComponentType2[ComponentType2["Custom"] = 255] = "Custom";
+  return ComponentType2;
+})(ComponentType || {});
+var GeometryType = /* @__PURE__ */ ((GeometryType2) => {
+  GeometryType2[GeometryType2["Cube"] = 1] = "Cube";
+  GeometryType2[GeometryType2["Sphere"] = 2] = "Sphere";
+  GeometryType2[GeometryType2["Cylinder"] = 3] = "Cylinder";
+  GeometryType2[GeometryType2["Plane"] = 4] = "Plane";
+  GeometryType2[GeometryType2["Cone"] = 5] = "Cone";
+  GeometryType2[GeometryType2["Torus"] = 6] = "Torus";
+  GeometryType2[GeometryType2["Capsule"] = 7] = "Capsule";
+  GeometryType2[GeometryType2["Mesh"] = 8] = "Mesh";
+  GeometryType2[GeometryType2["Text3D"] = 9] = "Text3D";
+  GeometryType2[GeometryType2["Portal"] = 10] = "Portal";
+  GeometryType2[GeometryType2["Terrain"] = 11] = "Terrain";
+  GeometryType2[GeometryType2["Skybox"] = 12] = "Skybox";
+  GeometryType2[GeometryType2["Billboard"] = 13] = "Billboard";
+  GeometryType2[GeometryType2["Line"] = 14] = "Line";
+  return GeometryType2;
+})(GeometryType || {});
+var BodyType = /* @__PURE__ */ ((BodyType2) => {
+  BodyType2[BodyType2["Static"] = 0] = "Static";
+  BodyType2[BodyType2["Dynamic"] = 1] = "Dynamic";
+  BodyType2[BodyType2["Kinematic"] = 2] = "Kinematic";
+  return BodyType2;
+})(BodyType || {});
+var ColliderShape = /* @__PURE__ */ ((ColliderShape2) => {
+  ColliderShape2[ColliderShape2["Box"] = 1] = "Box";
+  ColliderShape2[ColliderShape2["Sphere"] = 2] = "Sphere";
+  ColliderShape2[ColliderShape2["Capsule"] = 3] = "Capsule";
+  ColliderShape2[ColliderShape2["Cylinder"] = 4] = "Cylinder";
+  ColliderShape2[ColliderShape2["ConvexHull"] = 5] = "ConvexHull";
+  ColliderShape2[ColliderShape2["TriMesh"] = 6] = "TriMesh";
+  return ColliderShape2;
+})(ColliderShape || {});
+var LightType = /* @__PURE__ */ ((LightType2) => {
+  LightType2[LightType2["Directional"] = 1] = "Directional";
+  LightType2[LightType2["Point"] = 2] = "Point";
+  LightType2[LightType2["Spot"] = 3] = "Spot";
+  LightType2[LightType2["Ambient"] = 4] = "Ambient";
+  LightType2[LightType2["Area"] = 5] = "Area";
+  return LightType2;
+})(LightType || {});
+var SyncTier = /* @__PURE__ */ ((SyncTier2) => {
+  SyncTier2[SyncTier2["Physics"] = 0] = "Physics";
+  SyncTier2[SyncTier2["Movement"] = 1] = "Movement";
+  SyncTier2[SyncTier2["AIAgent"] = 2] = "AIAgent";
+  SyncTier2[SyncTier2["Cosmetic"] = 3] = "Cosmetic";
+  return SyncTier2;
+})(SyncTier || {});
+var ValueType = /* @__PURE__ */ ((ValueType2) => {
+  ValueType2[ValueType2["Null"] = 0] = "Null";
+  ValueType2[ValueType2["Bool"] = 1] = "Bool";
+  ValueType2[ValueType2["I32"] = 2] = "I32";
+  ValueType2[ValueType2["F32"] = 3] = "F32";
+  ValueType2[ValueType2["F64"] = 4] = "F64";
+  ValueType2[ValueType2["String"] = 5] = "String";
+  ValueType2[ValueType2["Vec3"] = 6] = "Vec3";
+  ValueType2[ValueType2["Quat"] = 7] = "Quat";
+  ValueType2[ValueType2["EntityRef"] = 8] = "EntityRef";
+  ValueType2[ValueType2["Array"] = 9] = "Array";
+  return ValueType2;
+})(ValueType || {});
+var FAMILY_NAMES = {
+  0: "Entity",
+  1: "Spatial",
+  2: "Physics",
+  3: "Rendering",
+  4: "Trait",
+  5: "I/O",
+  6: "Control",
+  7: "Agent",
+  8: "Comparison"
+};
+function getOpcodeFamily(opcode) {
+  const familyByte = opcode >> 4 & 15;
+  return FAMILY_NAMES[familyByte] ?? "Unknown";
+}
+function getOpcodeName(opcode) {
+  return HoloOpCode[opcode] ?? `UNKNOWN_0x${opcode.toString(16).padStart(2, "0")}`;
+}
+function isControlFlow(opcode) {
+  return opcode === 97 /* JUMP */ || opcode === 98 /* JUMP_IF */ || opcode === 99 /* CALL */ || opcode === 100 /* RETURN */ || opcode === 105 /* HALT */ || opcode === 106 /* YIELD */;
+}
+
+// src/vm/bytecode.ts
+var HOLOB_MAGIC = 1213156418;
+var HOLOB_VERSION = 1;
+var HolobFlags = /* @__PURE__ */ ((HolobFlags2) => {
+  HolobFlags2[HolobFlags2["None"] = 0] = "None";
+  HolobFlags2[HolobFlags2["Debug"] = 1] = "Debug";
+  HolobFlags2[HolobFlags2["SIMD"] = 2] = "SIMD";
+  HolobFlags2[HolobFlags2["Threads"] = 4] = "Threads";
+  HolobFlags2[HolobFlags2["Networking"] = 8] = "Networking";
+  HolobFlags2[HolobFlags2["Physics"] = 16] = "Physics";
+  return HolobFlags2;
+})(HolobFlags || {});
+var AssetType = /* @__PURE__ */ ((AssetType2) => {
+  AssetType2[AssetType2["Mesh"] = 1] = "Mesh";
+  AssetType2[AssetType2["Texture"] = 2] = "Texture";
+  AssetType2[AssetType2["Audio"] = 3] = "Audio";
+  AssetType2[AssetType2["Animation"] = 4] = "Animation";
+  AssetType2[AssetType2["GaussianSplat"] = 5] = "GaussianSplat";
+  AssetType2[AssetType2["Font"] = 6] = "Font";
+  AssetType2[AssetType2["Script"] = 7] = "Script";
+  return AssetType2;
+})(AssetType || {});
+var HoloBytecodeBuilder = class {
+  strings = /* @__PURE__ */ new Map();
+  stringList = [];
+  assets = [];
+  traits = [];
+  functions = [];
+  entities = [];
+  events = [];
+  flags = 0 /* None */;
+  /**
+   * Intern a string and return its index
+   */
+  internString(str) {
+    const existing = this.strings.get(str);
+    if (existing !== void 0) return existing;
+    const idx = this.stringList.length;
+    this.stringList.push(str);
+    this.strings.set(str, idx);
+    return idx;
+  }
+  /**
+   * Add a feature flag
+   */
+  addFlag(flag) {
+    this.flags |= flag;
+    return this;
+  }
+  /**
+   * Add an asset reference
+   */
+  addAsset(uri, type) {
+    const idx = this.assets.length;
+    this.assets.push({ uriIndex: this.internString(uri), type });
+    return idx;
+  }
+  /**
+   * Add a trait definition
+   */
+  addTrait(name, deps = [], initFunc = -1) {
+    const idx = this.traits.length;
+    this.traits.push({
+      nameIndex: this.internString(name),
+      dependencies: deps,
+      initFunctionIndex: initFunc,
+      eventHandlers: /* @__PURE__ */ new Map()
+    });
+    return idx;
+  }
+  /**
+   * Begin building a function
+   */
+  addFunction(name, paramCount = 0) {
+    const idx = this.functions.length;
+    const fn = {
+      nameIndex: this.internString(name),
+      instructions: [],
+      registerCount: 0,
+      paramCount
+    };
+    this.functions.push(fn);
+    return new HoloFunctionBuilder(fn, this, idx);
+  }
+  /**
+   * Add an entity definition
+   */
+  addEntity(name, archetype = 0, parentIndex = -1) {
+    const idx = this.entities.length;
+    this.entities.push({
+      nameIndex: this.internString(name),
+      archetype,
+      components: [],
+      parentIndex
+    });
+    return idx;
+  }
+  /**
+   * Add component data to an entity
+   */
+  addComponentToEntity(entityIdx, componentType, values) {
+    this.entities[entityIdx].components.push({ componentType, values });
+    return this;
+  }
+  /**
+   * Add an event binding
+   */
+  addEvent(eventType, handlerFunctionIndex, entityFilter = -1) {
+    this.events.push({ eventType, handlerFunctionIndex, entityFilter });
+    return this;
+  }
+  /**
+   * Build the final bytecode module
+   */
+  build() {
+    return {
+      magic: HOLOB_MAGIC,
+      version: HOLOB_VERSION,
+      flags: this.flags,
+      strings: [...this.stringList],
+      assets: [...this.assets],
+      traits: [...this.traits],
+      functions: [...this.functions],
+      entities: [...this.entities],
+      events: [...this.events]
+    };
+  }
+};
+var HoloFunctionBuilder = class {
+  constructor(func, parent, index) {
+    this.func = func;
+    this.parent = parent;
+    this.index = index;
+  }
+  func;
+  parent;
+  index;
+  emit(opcode, ...operands) {
+    this.func.instructions.push({ opcode, operands });
+    return this;
+  }
+  // ── Entity ────────────────────────────────────────────────────────────────
+  spawn(entityType, name) {
+    return this.emit(1 /* SPAWN */, entityType, this.parent.internString(name));
+  }
+  despawn(entityId) {
+    return this.emit(2 /* DESPAWN */, entityId);
+  }
+  setComponent(entityId, compType, ...data) {
+    return this.emit(4 /* SET_COMPONENT */, entityId, compType, ...data);
+  }
+  getComponent(entityId, compType) {
+    return this.emit(5 /* GET_COMPONENT */, entityId, compType);
+  }
+  setParent(childId, parentId) {
+    return this.emit(7 /* SET_PARENT */, childId, parentId);
+  }
+  query(archetypeMask) {
+    return this.emit(8 /* QUERY */, archetypeMask);
+  }
+  // ── Spatial ───────────────────────────────────────────────────────────────
+  transform(entityId, x, y, z) {
+    return this.emit(16 /* TRANSFORM */, entityId, x, y, z, 0, 0, 0, 1, 1, 1, 1);
+  }
+  translate(entityId, dx, dy, dz) {
+    return this.emit(17 /* TRANSLATE */, entityId, dx, dy, dz);
+  }
+  rotate(entityId, qx, qy, qz, qw) {
+    return this.emit(18 /* ROTATE */, entityId, qx, qy, qz, qw);
+  }
+  lookAt(entityId, tx, ty, tz) {
+    return this.emit(19 /* LOOK_AT */, entityId, tx, ty, tz);
+  }
+  raycast(ox, oy, oz, dx, dy, dz, maxDist) {
+    return this.emit(20 /* RAYCAST */, ox, oy, oz, dx, dy, dz, maxDist);
+  }
+  // ── Physics ───────────────────────────────────────────────────────────────
+  addRigidbody(entityId, mass, bodyType) {
+    return this.emit(32 /* ADD_RIGIDBODY */, entityId, mass, bodyType);
+  }
+  applyForce(entityId, fx, fy, fz) {
+    return this.emit(33 /* APPLY_FORCE */, entityId, fx, fy, fz);
+  }
+  applyImpulse(entityId, ix, iy, iz) {
+    return this.emit(34 /* APPLY_IMPULSE */, entityId, ix, iy, iz);
+  }
+  setGravity(gx, gy, gz) {
+    return this.emit(38 /* SET_GRAVITY */, gx, gy, gz);
+  }
+  physicsStep(dt) {
+    return this.emit(39 /* PHYSICS_STEP */, dt);
+  }
+  // ── Rendering Hints ───────────────────────────────────────────────────────
+  setGeometry(entityId, geoType) {
+    return this.emit(48 /* SET_GEOMETRY */, entityId, geoType);
+  }
+  setMaterial(entityId, ...desc) {
+    return this.emit(49 /* SET_MATERIAL */, entityId, ...desc);
+  }
+  setVisible(entityId, visible) {
+    return this.emit(50 /* SET_VISIBLE */, entityId, visible ? 1 : 0);
+  }
+  setLight(entityId, lightType, ...params) {
+    return this.emit(52 /* SET_LIGHT */, entityId, lightType, ...params);
+  }
+  setAnimation(entityId, animId) {
+    return this.emit(53 /* SET_ANIMATION */, entityId, animId);
+  }
+  // ── Trait ─────────────────────────────────────────────────────────────────
+  applyTrait(entityId, traitId) {
+    return this.emit(64 /* APPLY_TRAIT */, entityId, traitId);
+  }
+  removeTrait(entityId, traitId) {
+    return this.emit(65 /* REMOVE_TRAIT */, entityId, traitId);
+  }
+  emitEvent(eventType, ...payload) {
+    return this.emit(67 /* EMIT_EVENT */, eventType, ...payload);
+  }
+  onEvent(eventType, handlerOffset) {
+    return this.emit(68 /* ON_EVENT */, eventType, handlerOffset);
+  }
+  // ── I/O ───────────────────────────────────────────────────────────────────
+  loadAsset(uri, assetType) {
+    return this.emit(80 /* LOAD_ASSET */, this.parent.internString(uri), assetType);
+  }
+  playAudio(soundId, x, y, z) {
+    return this.emit(81 /* PLAY_AUDIO */, soundId, x, y, z);
+  }
+  netSync(entityId, syncTier) {
+    return this.emit(82 /* NET_SYNC */, entityId, syncTier);
+  }
+  // ── Control Flow ──────────────────────────────────────────────────────────
+  nop() {
+    return this.emit(96 /* NOP */);
+  }
+  jump(offset) {
+    return this.emit(97 /* JUMP */, offset);
+  }
+  jumpIf(offset) {
+    return this.emit(98 /* JUMP_IF */, offset);
+  }
+  call(funcIdx) {
+    return this.emit(99 /* CALL */, funcIdx);
+  }
+  ret() {
+    return this.emit(100 /* RETURN */);
+  }
+  push(value) {
+    return this.emit(101 /* PUSH */, value);
+  }
+  pop() {
+    return this.emit(102 /* POP */);
+  }
+  store(registerIdx) {
+    this.func.registerCount = Math.max(this.func.registerCount, registerIdx + 1);
+    return this.emit(103 /* STORE */, registerIdx);
+  }
+  load(registerIdx) {
+    return this.emit(104 /* LOAD */, registerIdx);
+  }
+  halt() {
+    return this.emit(105 /* HALT */);
+  }
+  yieldTick() {
+    return this.emit(106 /* YIELD */);
+  }
+  timer(delayMs, handlerOffset) {
+    return this.emit(107 /* TIMER */, delayMs, handlerOffset);
+  }
+  // ── Arithmetic ────────────────────────────────────────────────────────────
+  add() {
+    return this.emit(108 /* ADD */);
+  }
+  sub() {
+    return this.emit(109 /* SUB */);
+  }
+  mul() {
+    return this.emit(110 /* MUL */);
+  }
+  div() {
+    return this.emit(111 /* DIV */);
+  }
+  // ── Comparison ────────────────────────────────────────────────────────────
+  cmpEq() {
+    return this.emit(128 /* CMP_EQ */);
+  }
+  cmpLt() {
+    return this.emit(129 /* CMP_LT */);
+  }
+  cmpGt() {
+    return this.emit(130 /* CMP_GT */);
+  }
+  not() {
+    return this.emit(131 /* NOT */);
+  }
+  // ── Agent Bridge ──────────────────────────────────────────────────────────
+  agentInvoke(agentId, actionIdx) {
+    return this.emit(112 /* AGENT_INVOKE */, agentId, actionIdx);
+  }
+  agentRead(agentId, fieldIdx) {
+    return this.emit(113 /* AGENT_READ */, agentId, fieldIdx);
+  }
+  dialogShow(npcId, dialogTreeId) {
+    return this.emit(115 /* DIALOG_SHOW */, npcId, dialogTreeId);
+  }
+  questUpdate(questId, state) {
+    return this.emit(116 /* QUEST_UPDATE */, questId, state);
+  }
+  /** Get the current instruction count (useful for jump targets) */
+  get instructionCount() {
+    return this.func.instructions.length;
+  }
+};
+
+// src/vm/executor.ts
+var ECSWorld = class {
+  entities = /* @__PURE__ */ new Map();
+  nextEntityId = 1;
+  archetypeIndex = /* @__PURE__ */ new Map();
+  /**
+   * Spawn a new entity
+   */
+  spawn(name, archetype = 0) {
+    const id = this.nextEntityId++;
+    const entity = {
+      id,
+      name,
+      parentId: -1,
+      childIds: [],
+      components: /* @__PURE__ */ new Map(),
+      traits: /* @__PURE__ */ new Set(),
+      alive: true,
+      dirty: true
+    };
+    this.entities.set(id, entity);
+    if (!this.archetypeIndex.has(archetype)) {
+      this.archetypeIndex.set(archetype, /* @__PURE__ */ new Set());
+    }
+    this.archetypeIndex.get(archetype).add(id);
+    return id;
+  }
+  /**
+   * Despawn an entity and its children
+   */
+  despawn(entityId) {
+    const entity = this.entities.get(entityId);
+    if (!entity) return false;
+    for (const childId of [...entity.childIds]) {
+      this.despawn(childId);
+    }
+    if (entity.parentId !== -1) {
+      const parent = this.entities.get(entity.parentId);
+      if (parent) {
+        parent.childIds = parent.childIds.filter((id) => id !== entityId);
+      }
+    }
+    entity.alive = false;
+    this.entities.delete(entityId);
+    return true;
+  }
+  /**
+   * Set a component on an entity
+   */
+  setComponent(entityId, componentType, data) {
+    const entity = this.entities.get(entityId);
+    if (!entity) return false;
+    entity.components.set(componentType, data);
+    entity.dirty = true;
+    return true;
+  }
+  /**
+   * Get a component from an entity
+   */
+  getComponent(entityId, componentType) {
+    const entity = this.entities.get(entityId);
+    if (!entity) return void 0;
+    return entity.components.get(componentType);
+  }
+  /**
+   * Remove a component from an entity
+   */
+  removeComponent(entityId, componentType) {
+    const entity = this.entities.get(entityId);
+    if (!entity) return false;
+    entity.dirty = true;
+    return entity.components.delete(componentType);
+  }
+  /**
+   * Set parent-child relationship
+   */
+  setParent(childId, parentId) {
+    const child = this.entities.get(childId);
+    const parent = this.entities.get(parentId);
+    if (!child || !parent) return false;
+    if (child.parentId !== -1) {
+      const oldParent = this.entities.get(child.parentId);
+      if (oldParent) {
+        oldParent.childIds = oldParent.childIds.filter((id) => id !== childId);
+      }
+    }
+    child.parentId = parentId;
+    parent.childIds.push(childId);
+    child.dirty = true;
+    return true;
+  }
+  /**
+   * Query entities by archetype mask
+   */
+  queryArchetype(mask) {
+    const set = this.archetypeIndex.get(mask);
+    return set ? [...set] : [];
+  }
+  /**
+   * Get entity by ID
+   */
+  getEntity(entityId) {
+    return this.entities.get(entityId);
+  }
+  /**
+   * Get all dirty entities and clear dirty flags
+   */
+  flushDirty() {
+    const dirty = [];
+    for (const entity of this.entities.values()) {
+      if (entity.dirty) {
+        dirty.push(entity);
+        entity.dirty = false;
+      }
+    }
+    return dirty;
+  }
+  /**
+   * Get all living entities
+   */
+  getAllEntities() {
+    return [...this.entities.values()];
+  }
+  /**
+   * Get entity count
+   */
+  get entityCount() {
+    return this.entities.size;
+  }
+};
+var VMStatus = /* @__PURE__ */ ((VMStatus2) => {
+  VMStatus2["Idle"] = "IDLE";
+  VMStatus2["Running"] = "RUNNING";
+  VMStatus2["Yielded"] = "YIELDED";
+  VMStatus2["Halted"] = "HALTED";
+  VMStatus2["Error"] = "ERROR";
+  return VMStatus2;
+})(VMStatus || {});
+var HoloVM = class {
+  // Core state
+  bytecode = null;
+  world = new ECSWorld();
+  // Execution state
+  stack = [];
+  callStack = [];
+  status = "IDLE" /* Idle */;
+  tickCount = 0;
+  // Timer system
+  timers = [];
+  currentTimeMs = 0;
+  // Event queue
+  eventQueue = [];
+  // Limits
+  maxStackSize = 4096;
+  maxCallDepth = 256;
+  maxInstructionsPerTick = 1e4;
+  /**
+   * Load a bytecode module into the VM
+   */
+  load(bytecode) {
+    this.bytecode = bytecode;
+    this.reset();
+    this.initializeEntities();
+  }
+  /**
+   * Reset VM state without unloading bytecode
+   */
+  reset() {
+    this.stack = [];
+    this.callStack = [];
+    this.status = "IDLE" /* Idle */;
+    this.tickCount = 0;
+    this.timers = [];
+    this.currentTimeMs = 0;
+    this.eventQueue = [];
+  }
+  /**
+   * Initialize entities from the bytecode's init section
+   */
+  initializeEntities() {
+    if (!this.bytecode) return;
+    for (const entityDef of this.bytecode.entities) {
+      const name = this.bytecode.strings[entityDef.nameIndex] ?? `entity_${entityDef.nameIndex}`;
+      const entityId = this.world.spawn(name, entityDef.archetype);
+      for (const comp of entityDef.components) {
+        this.world.setComponent(entityId, comp.componentType, comp.values);
+      }
+      if (entityDef.parentIndex >= 0) {
+        this.world.setParent(entityId, entityDef.parentIndex + 1);
+      }
+    }
+  }
+  /**
+   * Execute one tick of the VM (called at ~90fps)
+   *
+   * Each tick:
+   * 1. Process expired timers
+   * 2. Dispatch queued events
+   * 3. Resume execution from yield point (or run init)
+   * 4. Return dirty entities for rendering
+   */
+  tick(deltaMs) {
+    if (!this.bytecode) {
+      return {
+        status: "ERROR" /* Error */,
+        stackTop: null,
+        tickCount: this.tickCount,
+        entityCount: 0,
+        error: "No bytecode loaded"
+      };
+    }
+    this.tickCount++;
+    this.currentTimeMs += deltaMs;
+    this.processTimers();
+    this.dispatchEvents();
+    if (this.status === "YIELDED" /* Yielded */) {
+      this.status = "RUNNING" /* Running */;
+      this.executeInstructions();
+    } else if (this.status === "IDLE" /* Idle */ && this.bytecode.functions.length > 0) {
+      this.callFunction(0);
+      this.executeInstructions();
+    }
+    return {
+      status: this.status,
+      stackTop: this.stack.length > 0 ? this.stack[this.stack.length - 1] : null,
+      tickCount: this.tickCount,
+      entityCount: this.world.entityCount
+    };
+  }
+  /**
+   * Main execution loop — runs until YIELD, HALT, or instruction limit
+   */
+  executeInstructions() {
+    if (!this.bytecode) return;
+    let instructionsExecuted = 0;
+    while (this.status === "RUNNING" /* Running */ && instructionsExecuted < this.maxInstructionsPerTick) {
+      const frame = this.currentFrame;
+      if (!frame) {
+        this.status = "HALTED" /* Halted */;
+        break;
+      }
+      const func = this.bytecode.functions[frame.functionIndex];
+      if (!func || frame.pc >= func.instructions.length) {
+        this.callStack.pop();
+        if (this.callStack.length === 0) {
+          this.status = "HALTED" /* Halted */;
+        }
+        break;
+      }
+      const instr = func.instructions[frame.pc];
+      frame.pc++;
+      instructionsExecuted++;
+      try {
+        this.executeInstruction(instr, frame);
+      } catch (_err) {
+        this.status = "ERROR" /* Error */;
+        break;
+      }
+      if (this.status !== "RUNNING" /* Running */) break;
+    }
+  }
+  /**
+   * Execute a single instruction
+   */
+  executeInstruction(instr, frame) {
+    const op = instr.opcode;
+    const operands = instr.operands;
+    switch (op) {
+      // ── Entity Operations ───────────────────────────────────────────────
+      case 1 /* SPAWN */: {
+        const entityType = operands[0];
+        const nameIdx = operands[1];
+        const name = this.getString(nameIdx);
+        const id = this.world.spawn(name, entityType);
+        this.push(id);
+        break;
+      }
+      case 2 /* DESPAWN */: {
+        const entityId = operands[0];
+        this.world.despawn(entityId);
+        break;
+      }
+      case 4 /* SET_COMPONENT */: {
+        const entityId = operands[0];
+        const compType = operands[1];
+        const data = operands.slice(2);
+        this.world.setComponent(entityId, compType, data);
+        break;
+      }
+      case 5 /* GET_COMPONENT */: {
+        const entityId = operands[0];
+        const compType = operands[1];
+        const data = this.world.getComponent(entityId, compType);
+        this.push(data ?? null);
+        break;
+      }
+      case 6 /* REMOVE_COMPONENT */: {
+        const entityId = operands[0];
+        const compType = operands[1];
+        this.world.removeComponent(entityId, compType);
+        break;
+      }
+      case 7 /* SET_PARENT */: {
+        const childId = operands[0];
+        const parentId = operands[1];
+        this.world.setParent(childId, parentId);
+        break;
+      }
+      case 8 /* QUERY */: {
+        const mask = operands[0];
+        const entities = this.world.queryArchetype(mask);
+        this.push(entities);
+        break;
+      }
+      // ── Spatial Operations ──────────────────────────────────────────────
+      case 16 /* TRANSFORM */: {
+        const entityId = operands[0];
+        const transform = {
+          position: { x: operands[1], y: operands[2], z: operands[3] },
+          rotation: {
+            x: operands[4],
+            y: operands[5],
+            z: operands[6],
+            w: operands[7]
+          },
+          scale: { x: operands[8], y: operands[9], z: operands[10] }
+        };
+        this.world.setComponent(entityId, 1 /* Transform */, transform);
+        break;
+      }
+      case 17 /* TRANSLATE */: {
+        const entityId = operands[0];
+        const existing = this.world.getComponent(
+          entityId,
+          1 /* Transform */
+        );
+        if (existing) {
+          existing.position.x += operands[1];
+          existing.position.y += operands[2];
+          existing.position.z += operands[3];
+          this.world.setComponent(entityId, 1 /* Transform */, existing);
+        }
+        break;
+      }
+      case 18 /* ROTATE */: {
+        const entityId = operands[0];
+        this.world.setComponent(entityId, 1 /* Transform */, {
+          position: [0, 0, 0],
+          rotation: {
+            x: operands[1],
+            y: operands[2],
+            z: operands[3],
+            w: operands[4]
+          },
+          scale: { x: 1, y: 1, z: 1 }
+        });
+        break;
+      }
+      case 48 /* SET_GEOMETRY */: {
+        const entityId = operands[0];
+        const geoType = operands[1];
+        this.world.setComponent(entityId, 2 /* Geometry */, { type: geoType, params: {} });
+        break;
+      }
+      case 49 /* SET_MATERIAL */: {
+        const entityId = operands[0];
+        const material = {
+          color: operands[1] ?? 16777215,
+          metalness: operands[2] ?? 0,
+          roughness: operands[3] ?? 0.5,
+          emissive: operands[4] ?? 0,
+          opacity: operands[5] ?? 1
+        };
+        this.world.setComponent(entityId, 3 /* Material */, material);
+        break;
+      }
+      case 50 /* SET_VISIBLE */: {
+        const entityId = operands[0];
+        const _visible = operands[1] !== 0;
+        const entity = this.world.getEntity(entityId);
+        if (entity) entity.dirty = true;
+        break;
+      }
+      case 52 /* SET_LIGHT */: {
+        const entityId = operands[0];
+        const lightType = operands[1];
+        this.world.setComponent(entityId, 6 /* Light */, {
+          type: lightType,
+          params: operands.slice(2)
+        });
+        break;
+      }
+      // ── Physics Operations ──────────────────────────────────────────────
+      case 32 /* ADD_RIGIDBODY */: {
+        const entityId = operands[0];
+        const rb = {
+          mass: operands[1],
+          bodyType: operands[2],
+          velocity: { x: 0, y: 0, z: 0 },
+          angularVelocity: { x: 0, y: 0, z: 0 }
+        };
+        this.world.setComponent(entityId, 4 /* RigidBody */, rb);
+        break;
+      }
+      case 33 /* APPLY_FORCE */: {
+        const entityId = operands[0];
+        const rb = this.world.getComponent(entityId, 4 /* RigidBody */);
+        if (rb && rb.mass > 0) {
+          const dt = 1 / 90;
+          rb.velocity.x += operands[1] / rb.mass * dt;
+          rb.velocity.y += operands[2] / rb.mass * dt;
+          rb.velocity.z += operands[3] / rb.mass * dt;
+          this.world.setComponent(entityId, 4 /* RigidBody */, rb);
+        }
+        break;
+      }
+      case 34 /* APPLY_IMPULSE */: {
+        const entityId = operands[0];
+        const rb = this.world.getComponent(entityId, 4 /* RigidBody */);
+        if (rb && rb.mass > 0) {
+          rb.velocity.x += operands[1] / rb.mass;
+          rb.velocity.y += operands[2] / rb.mass;
+          rb.velocity.z += operands[3] / rb.mass;
+          this.world.setComponent(entityId, 4 /* RigidBody */, rb);
+        }
+        break;
+      }
+      case 35 /* SET_VELOCITY */: {
+        const entityId = operands[0];
+        const rb = this.world.getComponent(entityId, 4 /* RigidBody */);
+        if (rb) {
+          rb.velocity = {
+            x: operands[1],
+            y: operands[2],
+            z: operands[3]
+          };
+          this.world.setComponent(entityId, 4 /* RigidBody */, rb);
+        }
+        break;
+      }
+      case 38 /* SET_GRAVITY */: {
+        this.world.setComponent(0, 255, { x: operands[0], y: operands[1], z: operands[2] });
+        break;
+      }
+      // ── Trait Operations ────────────────────────────────────────────────
+      case 64 /* APPLY_TRAIT */: {
+        const entityId = operands[0];
+        const traitId = operands[1];
+        const entity = this.world.getEntity(entityId);
+        if (entity) {
+          entity.traits.add(traitId);
+          entity.dirty = true;
+        }
+        break;
+      }
+      case 65 /* REMOVE_TRAIT */: {
+        const entityId = operands[0];
+        const traitId = operands[1];
+        const entity = this.world.getEntity(entityId);
+        if (entity) {
+          entity.traits.delete(traitId);
+          entity.dirty = true;
+        }
+        break;
+      }
+      case 67 /* EMIT_EVENT */: {
+        const eventType = operands[0];
+        const payload = operands.slice(1);
+        this.eventQueue.push({ eventType, payload });
+        break;
+      }
+      // ── Control Flow ────────────────────────────────────────────────────
+      case 96 /* NOP */:
+        break;
+      case 97 /* JUMP */: {
+        frame.pc = operands[0];
+        break;
+      }
+      case 98 /* JUMP_IF */: {
+        const condition = this.pop();
+        if (condition) {
+          frame.pc = operands[0];
+        }
+        break;
+      }
+      case 99 /* CALL */: {
+        const funcIdx = operands[0];
+        this.callFunction(funcIdx);
+        break;
+      }
+      case 100 /* RETURN */: {
+        this.callStack.pop();
+        if (this.callStack.length === 0) {
+          this.status = "HALTED" /* Halted */;
+        }
+        break;
+      }
+      case 101 /* PUSH */: {
+        this.push(operands[0]);
+        break;
+      }
+      case 102 /* POP */: {
+        this.pop();
+        break;
+      }
+      case 103 /* STORE */: {
+        const regIdx = operands[0];
+        const value = this.pop();
+        if (regIdx < frame.registers.length) {
+          frame.registers[regIdx] = value;
+        }
+        break;
+      }
+      case 104 /* LOAD */: {
+        const regIdx = operands[0];
+        if (regIdx < frame.registers.length) {
+          this.push(frame.registers[regIdx]);
+        } else {
+          this.push(null);
+        }
+        break;
+      }
+      case 105 /* HALT */: {
+        this.status = "HALTED" /* Halted */;
+        break;
+      }
+      case 106 /* YIELD */: {
+        this.status = "YIELDED" /* Yielded */;
+        break;
+      }
+      case 107 /* TIMER */: {
+        const delayMs = operands[0];
+        const handlerFunc = operands[1];
+        this.timers.push({
+          triggerTimeMs: this.currentTimeMs + delayMs,
+          handlerFunctionIndex: handlerFunc
+        });
+        break;
+      }
+      // ── Arithmetic ──────────────────────────────────────────────────────
+      case 108 /* ADD */: {
+        const b = this.pop();
+        const a = this.pop();
+        this.push((a ?? 0) + (b ?? 0));
+        break;
+      }
+      case 109 /* SUB */: {
+        const b = this.pop();
+        const a = this.pop();
+        this.push((a ?? 0) - (b ?? 0));
+        break;
+      }
+      case 110 /* MUL */: {
+        const b = this.pop();
+        const a = this.pop();
+        this.push((a ?? 0) * (b ?? 0));
+        break;
+      }
+      case 111 /* DIV */: {
+        const b = this.pop();
+        const a = this.pop();
+        this.push(b !== 0 ? (a ?? 0) / b : 0);
+        break;
+      }
+      // ── Comparison ──────────────────────────────────────────────────────
+      case 128 /* CMP_EQ */: {
+        const b = this.pop();
+        const a = this.pop();
+        this.push(a === b ? 1 : 0);
+        break;
+      }
+      case 129 /* CMP_LT */: {
+        const b = this.pop();
+        const a = this.pop();
+        this.push(a < b ? 1 : 0);
+        break;
+      }
+      case 130 /* CMP_GT */: {
+        const b = this.pop();
+        const a = this.pop();
+        this.push(a > b ? 1 : 0);
+        break;
+      }
+      case 131 /* NOT */: {
+        const val = this.pop();
+        this.push(val ? 0 : 1);
+        break;
+      }
+      // ── Agent Bridge (stubs — filled in by host integration) ────────────
+      case 112 /* AGENT_INVOKE */:
+      case 113 /* AGENT_READ */:
+      case 114 /* AGENT_SUBSCRIBE */:
+      case 115 /* DIALOG_SHOW */:
+      case 116 /* QUEST_UPDATE */:
+        this.push(null);
+        break;
+      // ── I/O (stubs — filled in by host integration) ─────────────────────
+      case 80 /* LOAD_ASSET */:
+      case 81 /* PLAY_AUDIO */:
+      case 82 /* NET_SYNC */:
+      case 83 /* NET_SEND */:
+      case 84 /* NET_RECV */:
+      case 85 /* XR_INPUT */:
+      case 86 /* HAPTIC */:
+        this.push(null);
+        break;
+      // ── Spatial queries (stubs — need spatial index) ─────────────────────
+      case 20 /* RAYCAST */:
+      case 21 /* QUERY_BOX */:
+      case 22 /* QUERY_SPHERE */:
+      case 23 /* FIND_PATH */:
+      case 24 /* GET_ZONE */:
+        this.push(null);
+        break;
+      default:
+        break;
+    }
+  }
+  // ── Stack operations ──────────────────────────────────────────────────────
+  push(value) {
+    if (this.stack.length >= this.maxStackSize) {
+      this.status = "ERROR" /* Error */;
+      return;
+    }
+    this.stack.push(value);
+  }
+  pop() {
+    return this.stack.pop() ?? null;
+  }
+  // ── Call frame management ─────────────────────────────────────────────────
+  get currentFrame() {
+    return this.callStack[this.callStack.length - 1];
+  }
+  callFunction(funcIdx) {
+    if (!this.bytecode) return;
+    if (this.callStack.length >= this.maxCallDepth) {
+      this.status = "ERROR" /* Error */;
+      return;
+    }
+    const func = this.bytecode.functions[funcIdx];
+    if (!func) {
+      this.status = "ERROR" /* Error */;
+      return;
+    }
+    const frame = {
+      functionIndex: funcIdx,
+      pc: 0,
+      registers: new Array(func.registerCount).fill(null),
+      stackBase: this.stack.length
+    };
+    this.callStack.push(frame);
+    this.status = "RUNNING" /* Running */;
+  }
+  // ── Timer processing ──────────────────────────────────────────────────────
+  processTimers() {
+    const expired = [];
+    this.timers = this.timers.filter((t) => {
+      if (t.triggerTimeMs <= this.currentTimeMs) {
+        expired.push(t);
+        return false;
+      }
+      return true;
+    });
+    for (const timer of expired) {
+      this.callFunction(timer.handlerFunctionIndex);
+      this.executeInstructions();
+    }
+  }
+  // ── Event dispatch ────────────────────────────────────────────────────────
+  dispatchEvents() {
+    if (!this.bytecode) return;
+    const events = [...this.eventQueue];
+    this.eventQueue = [];
+    for (const event of events) {
+      for (const binding of this.bytecode.events) {
+        if (binding.eventType === event.eventType) {
+          for (const p of event.payload) {
+            this.push(p);
+          }
+          this.callFunction(binding.handlerFunctionIndex);
+          this.executeInstructions();
+        }
+      }
+    }
+  }
+  // ── Utility ───────────────────────────────────────────────────────────────
+  getString(index) {
+    if (!this.bytecode) return "";
+    return this.bytecode.strings[index] ?? `str_${index}`;
+  }
+  /**
+   * Get current VM status
+   */
+  getStatus() {
+    return this.status;
+  }
+  /**
+   * Get current stack snapshot (for debugging)
+   */
+  getStack() {
+    return [...this.stack];
+  }
+  /**
+   * Get the tick count
+   */
+  getTickCount() {
+    return this.tickCount;
+  }
+  /**
+   * Queue an external event (e.g., from user input or network)
+   */
+  queueEvent(eventType, ...payload) {
+    this.eventQueue.push({ eventType, payload });
+  }
+};
+
+export {
+  HoloOpCode,
+  ComponentType,
+  GeometryType,
+  BodyType,
+  ColliderShape,
+  LightType,
+  SyncTier,
+  ValueType,
+  getOpcodeFamily,
+  getOpcodeName,
+  isControlFlow,
+  HOLOB_MAGIC,
+  HOLOB_VERSION,
+  HolobFlags,
+  AssetType,
+  HoloBytecodeBuilder,
+  HoloFunctionBuilder,
+  ECSWorld,
+  VMStatus,
+  HoloVM,
+  vm_exports
+};