@holoscript/engine 6.0.3 → 6.0.4

package/dist/index.js

@@ -1,14 +1,43 @@
+import {
+  simulation_exports
+} from "./chunk-TQB3GJGM.js";
+import "./chunk-BL7IDTHE.js";
+import {
+  terrain_exports
+} from "./chunk-PYCOIDT2.js";
+import {
+  tilemap_exports
+} from "./chunk-3JORF6V4.js";
+import {
+  vm_exports
+} from "./chunk-HYXNV36F.js";
+import {
+  vm_bridge_exports
+} from "./chunk-SLTJRZ2N.js";
 import {
   vr_exports
-} from "./chunk-FTINXFRJ.js";
+} from "./chunk-KBVD5K7E.js";
 import {
   world_exports
-} from "./chunk-HW57JP55.js";
+} from "./chunk-PRRB5TTA.js";
+import {
+  PhysicsWorldImpl,
+  VRPhysicsBridge,
+  physics_exports
+} from "./chunk-VMGJQST6.js";
+import {
+  particles_exports
+} from "./chunk-Q2XBVS2K.js";
+import {
+  procedural_exports
+} from "./chunk-HCFPELPY.js";
+import {
+  scene_exports
+} from "./chunk-RNWOZ6WQ.js";
 import {
   AdvancedLightingManager,
   AdvancedPBRMaterial,
   BVH,
-  BloomEffect,
   CloudRenderer,
   ColorGrading,
   DecalBatcher,
@@ -20,10 +49,7 @@ import {
   MATERIAL_PRESETS2,
   MaterialLibrary,
   MaterialSystem,
-  PP_PRESETS,
   PhysicsDebugDrawer,
-  PostProcessStack,
-  PostProcessingStack,
   ProjectorLight,
   PuppeteerRenderer,
   RayTracer,
@@ -93,7 +119,6 @@ import {
   packRect,
   parseIESProfile,
   pathTrace,
-  postprocess_exports,
   prerenderHTML,
   rectSolidAngle,
   renderPDF,
@@ -110,73 +135,65 @@ import {
   sheenVisibility,
   thinSlabTransmission,
   triplanarWeights
-} from "./chunk-5M7G5AFS.js";
+} from "./chunk-TKCA3WZ5.js";
 import {
-  procedural_exports
-} from "./chunk-VSFEPRSB.js";
+  BloomEffect,
+  PP_PRESETS,
+  PostProcessStack,
+  PostProcessingStack,
+  postprocess_exports
+} from "./chunk-EJSLOOW2.js";
 import {
+  eventBus,
   runtime_exports
-} from "./chunk-HWUUFZKL.js";
-import {
-  scene_exports
-} from "./chunk-HWEANAXF.js";
-import {
-  terrain_exports
-} from "./chunk-HLZJ37AZ.js";
-import {
-  tilemap_exports
-} from "./chunk-3JORF6V4.js";
-import {
-  vm_bridge_exports
-} from "./chunk-RN5CTZ6Q.js";
-import {
-  vm_exports
-} from "./chunk-PXUX4KT5.js";
+} from "./chunk-CZYJE7IH.js";
+import "./chunk-5V6HOU72.js";
 import {
   ecs_exports
-} from "./chunk-D2SAKYOU.js";
+} from "./chunk-IB7KHVFY.js";
+import {
+  environment_exports
+} from "./chunk-ZIFROE75.js";
 import {
   gameplay_exports
 } from "./chunk-RCQHJUSC.js";
+import {
+  GaussianSplatExtractor
+} from "./chunk-HNEE36PY.js";
+import "./chunk-TUFGXG6K.js";
+import "./chunk-2CSNRI2N.js";
 import {
   hologram_exports
-} from "./chunk-DBDXVKCH.js";
+} from "./chunk-7VPUC62U.js";
 import {
   input_exports
-} from "./chunk-6PT5NOF7.js";
+} from "./chunk-U6KMTGQJ.js";
 import {
   navigation_exports
 } from "./chunk-4YSUBXFR.js";
 import {
   orbital_exports
-} from "./chunk-UUSS3ONQ.js";
-import {
-  particles_exports
-} from "./chunk-DWP6F6V4.js";
-import {
-  physics_exports
-} from "./chunk-JQIUSARK.js";
+} from "./chunk-LY4T37YK.js";
 import {
+  AnimationEngine,
+  TransitionSystem,
   animation_exports
-} from "./chunk-QJR7PURY.js";
+} from "./chunk-F53SFGW5.js";
 import {
   audio_exports
-} from "./chunk-UK53LWFY.js";
+} from "./chunk-SRUS5XSU.js";
 import {
   camera_exports
-} from "./chunk-OK3BGLJQ.js";
+} from "./chunk-MGCDP6VU.js";
 import {
   character_exports
-} from "./chunk-COLFS4LL.js";
+} from "./chunk-ZIJQYHSQ.js";
 import {
   combat_exports
-} from "./chunk-GJE5WTO6.js";
+} from "./chunk-OWSN2Q3Q.js";
 import {
   dialogue_exports
 } from "./chunk-2MUNCP4Y.js";
-import {
-  environment_exports
-} from "./chunk-CRVDNMZI.js";
 import {
   __export
 } from "./chunk-AKLW2MUS.js";
@@ -1465,7 +1482,7 @@ var LODManager = class {
   /**
    * Process transition queue (max transitions per frame to prevent stuttering)
    */
-  processTransitionQueue(deltaTime) {
+  processTransitionQueue(_deltaTime) {
     this.transitionQueue.sort((a, b) => b.priority - a.priority);
     const transitionsToProcess = this.transitionQueue.slice(0, this.maxTransitionsPerFrame);
     for (const { objectId, level } of transitionsToProcess) {
@@ -2644,7 +2661,7 @@ var TransitionScheduler = class {
   /**
    * Record actual GPU cost for a transition (for budget tuning)
    */
-  recordCost(entityId, actualCostMs) {
+  recordCost(entityId, _actualCostMs) {
     if (this.activatedThisFrame.has(entityId)) {
     }
   }
@@ -2809,7 +2826,7 @@ var LODMemoryPool = class {
     }
     this.stats.defragmentationCount++;
     this.updateStatistics();
-    const duration = performance.now() - startTime;
+    const _duration = performance.now() - startTime;
   }
   /**
    * Check memory pressure and trigger callbacks
@@ -3163,7 +3180,7 @@ var LODPerformanceMetrics = class {
   /**
    * Start profiling a code section
    */
-  startProfile(name) {
+  startProfile(_name) {
     if (!this.enabled) return 0;
     return performance.now();
   }
@@ -3690,6 +3707,2993 @@ function createMeshletGenerator(options) {
 function generateMeshlets(mesh, options) {
   return new MeshletGenerator(options).generate(mesh);
 }
+
+// src/simulation/TetGenWasmMesher.ts
+var TetGenWasmMesher = class {
+  wasmModule = null;
+  constructor() {
+  }
+  async initialize() {
+    if (this.wasmModule) return;
+    console.log("TetGenWasmMesher: Initializing WASM binary...");
+  }
+  async tetrahedralize(surface, options) {
+    await this.initialize();
+    console.log(`TetGenWasmMesher: Tetrahedralizing surface with ${surface.triangles.length / 3} faces...`);
+    const flags = options?.quality ? `-pq${options.quality}` : "-pq";
+    console.log(`TetGenWasmMesher: Using flags ${flags}`);
+    const { meshBox } = await import("./AutoMesher-CK47F6AV.js");
+    return meshBox({
+      size: [1, 1, 1],
+      // Placeholder
+      divisions: [10, 10, 10]
+    });
+  }
+};
+
+// src/runtime/HoloScriptPlusRuntime.ts
+import { createState, ExpressionEvaluator } from "@holoscript/core";
+import { vrTraitRegistry } from "@holoscript/core";
+
+// src/runtime/loader.ts
+var ChunkLoader = class {
+  runtime;
+  manifest = null;
+  loadedChunks = /* @__PURE__ */ new Set();
+  loadingChunks = /* @__PURE__ */ new Set();
+  options;
+  constructor(runtime, options) {
+    this.runtime = runtime;
+    this.options = options;
+  }
+  /**
+   * Initialize the loader by fetching the manifest
+   */
+  async init() {
+    try {
+      const response = await fetch(this.options.manifestUrl);
+      this.manifest = await response.json();
+    } catch (e) {
+      console.error("[ChunkLoader] Failed to load manifest", e);
+    }
+  }
+  /**
+   * Update the loader (check for spatial triggers)
+   */
+  update() {
+    if (!this.manifest) return;
+    const playerPos = this.runtime.vrContext.headset.position;
+    if (!playerPos) return;
+    for (const [chunkId, info] of Object.entries(this.manifest.chunks)) {
+      if (this.loadedChunks.has(chunkId) || this.loadingChunks.has(chunkId)) continue;
+      if (info.bounds && this.isPointInBounds(playerPos, info.bounds)) {
+        this.loadChunk(chunkId);
+      }
+    }
+  }
+  /**
+   * Manually load a chunk
+   */
+  async loadChunk(chunkId) {
+    if (!this.manifest || !this.manifest.chunks[chunkId]) return;
+    if (this.loadedChunks.has(chunkId) || this.loadingChunks.has(chunkId)) return;
+    this.loadingChunks.add(chunkId);
+    try {
+      const info = this.manifest.chunks[chunkId];
+      const url = this.options.baseUrl ? `${this.options.baseUrl}/${info.file}` : info.file;
+      const response = await fetch(url);
+      const chunkData = await response.json();
+      await this.integrateChunk(chunkData);
+      this.loadedChunks.add(chunkId);
+    } catch (e) {
+      console.error(`[ChunkLoader] Failed to load chunk ${chunkId}`, e);
+    } finally {
+      this.loadingChunks.delete(chunkId);
+    }
+  }
+  async integrateChunk(chunk) {
+    const objects = chunk.objects;
+    if (!objects) return;
+    const extRuntime = this.runtime;
+    for (const obj of objects) {
+      if (extRuntime.mountObject) {
+        extRuntime.mountObject(obj);
+      } else if (extRuntime.instantiateNode) {
+        extRuntime.instantiateNode(obj, extRuntime.rootInstance);
+      }
+    }
+  }
+  isPointInBounds(point, bounds) {
+    if (bounds.length < 2) return false;
+    const [min, max] = bounds;
+    return point[0] >= min[0] && point[0] <= max[0] && point[1] >= min[1] && point[1] <= max[1] && point[2] >= min[2] && point[2] <= max[2];
+  }
+};
+
+// src/runtime/HotReloader.ts
+import {
+  diffState,
+  buildMigrationChain,
+  snapshotState,
+  applyAutoMigration
+} from "@holoscript/core";
+var HotReloader = class {
+  templates = /* @__PURE__ */ new Map();
+  instances = /* @__PURE__ */ new Map();
+  devMode;
+  onWarning;
+  onReload;
+  onRollback;
+  migrationExecutor = null;
+  constructor(options = {}) {
+    this.devMode = options.devMode ?? false;
+    this.onWarning = options.onWarning ?? (() => {
+    });
+    this.onReload = options.onReload ?? (() => {
+    });
+    this.onRollback = options.onRollback ?? (() => {
+    });
+  }
+  /**
+   * Set the migration executor — the function that runs migration statement bodies.
+   * This decouples the HotReloader from the runtime's statement interpreter.
+   */
+  setMigrationExecutor(executor) {
+    this.migrationExecutor = executor;
+  }
+  /**
+   * Register a template. Called on initial load.
+   */
+  registerTemplate(template) {
+    this.templates.set(template.name, template);
+    if (!this.instances.has(template.name)) {
+      this.instances.set(template.name, []);
+    }
+  }
+  /**
+   * Register a live instance of a template.
+   */
+  registerInstance(instance) {
+    const list = this.instances.get(instance.templateName);
+    if (list) {
+      list.push(instance);
+    } else {
+      this.instances.set(instance.templateName, [instance]);
+    }
+  }
+  /**
+   * Unregister an instance (e.g., on destroy).
+   */
+  unregisterInstance(holoId) {
+    for (const [, list] of this.instances) {
+      const idx = list.findIndex((i) => i.__holo_id === holoId);
+      if (idx !== -1) {
+        list.splice(idx, 1);
+        return;
+      }
+    }
+  }
+  /**
+   * Hot-reload a template. This is the main entry point.
+   *
+   * Steps:
+   * 1. Snapshot all instances of the template
+   * 2. Diff old vs new state schema
+   * 3. Build migration chain if needed
+   * 4. Apply migrations to all instances
+   * 5. Validate and swap
+   * 6. Rollback on failure
+   */
+  async reload(newTemplate) {
+    const warnings = [];
+    const templateName = newTemplate.name;
+    const oldTemplate = this.templates.get(templateName);
+    const oldVersion = oldTemplate?.version ?? 0;
+    const newVersion = newTemplate.version ?? 0;
+    const instanceList = this.instances.get(templateName) ?? [];
+    const snapshots = /* @__PURE__ */ new Map();
+    for (const instance of instanceList) {
+      snapshots.set(instance.__holo_id, snapshotState(instance.state));
+    }
+    const diff = diffState(oldTemplate?.state, newTemplate.state);
+    if (!diff.hasChanges && oldVersion === newVersion) {
+      this.templates.set(templateName, newTemplate);
+      const result = {
+        success: true,
+        templateName,
+        oldVersion,
+        newVersion,
+        diff,
+        migrationChain: null,
+        instancesMigrated: 0,
+        rollback: false,
+        warnings
+      };
+      this.onReload(result);
+      return result;
+    }
+    let migrationChain = null;
+    if (newVersion > oldVersion || diff.requiresMigration) {
+      migrationChain = buildMigrationChain(newTemplate, oldVersion, newVersion);
+      if (!migrationChain) {
+        if (diff.typeChanged.length > 0) {
+          const error = `Missing migration chain from v${oldVersion} to v${newVersion} for template "${templateName}". ${diff.typeChanged.length} field(s) changed type: ${diff.typeChanged.map((c) => c.key).join(", ")}`;
+          const result = {
+            success: false,
+            templateName,
+            oldVersion,
+            newVersion,
+            diff,
+            migrationChain: null,
+            instancesMigrated: 0,
+            rollback: true,
+            error,
+            warnings
+          };
+          this.onRollback(result);
+          return result;
+        }
+      }
+    }
+    const oldDefaults = /* @__PURE__ */ new Map();
+    if (oldTemplate?.state?.properties) {
+      for (const prop of oldTemplate.state.properties) {
+        oldDefaults.set(prop.key, prop.value);
+      }
+    }
+    let migrated = 0;
+    try {
+      for (const instance of instanceList) {
+        applyAutoMigration(instance.state, diff, oldDefaults);
+        if (migrationChain && this.migrationExecutor) {
+          for (const step of migrationChain.steps) {
+            await this.migrationExecutor(instance, step.body);
+          }
+        }
+        instance.version = newVersion;
+        migrated++;
+      }
+      if (this.devMode) {
+        for (const change of diff.removed) {
+          warnings.push(`Field "${change.key}" removed from template "${templateName}"`);
+        }
+        for (const change of diff.reactiveChanged) {
+          warnings.push(
+            `Reactivity changed for field "${change.key}" in template "${templateName}"`
+          );
+        }
+      }
+      if (newTemplate.state?.properties) {
+        for (const instance of instanceList) {
+          for (const prop of newTemplate.state.properties) {
+            if (!instance.state.has(prop.key)) {
+              warnings.push(
+                `Instance ${instance.__holo_id}: missing field "${prop.key}" after migration`
+              );
+            }
+          }
+        }
+      }
+      this.templates.set(templateName, newTemplate);
+      const result = {
+        success: true,
+        templateName,
+        oldVersion,
+        newVersion,
+        diff,
+        migrationChain,
+        instancesMigrated: migrated,
+        rollback: false,
+        warnings
+      };
+      this.onReload(result);
+      return result;
+    } catch (err) {
+      for (const instance of instanceList) {
+        const snapshot = snapshots.get(instance.__holo_id);
+        if (snapshot) {
+          instance.state = snapshot;
+          instance.version = oldVersion;
+        }
+      }
+      const result = {
+        success: false,
+        templateName,
+        oldVersion,
+        newVersion,
+        diff,
+        migrationChain,
+        instancesMigrated: 0,
+        rollback: true,
+        error: err instanceof Error ? err.message : String(err),
+        warnings
+      };
+      this.onRollback(result);
+      return result;
+    }
+  }
+  /**
+   * Get all registered templates.
+   */
+  getTemplates() {
+    return this.templates;
+  }
+  /**
+   * Get all instances of a template.
+   */
+  getInstances(templateName) {
+    return this.instances.get(templateName) ?? [];
+  }
+};
+
+// src/runtime/NetworkPredictor.ts
+var NetworkPredictor = class {
+  inputBuffer = [];
+  stateBuffer = [];
+  lastConfirmedSequence = -1;
+  predictedState;
+  confirmedState;
+  rtt = 0;
+  jitter = 0;
+  lastPingTime = 0;
+  constructor(initialState) {
+    this.predictedState = { ...initialState };
+    this.confirmedState = { ...initialState };
+    this.stateBuffer.push({ sequenceNumber: 0, state: { ...initialState } });
+  }
+  /**
+   * Add a local input and predict the resulting state immediately.
+   */
+  predict(input, applyFn) {
+    const seq = ++this.lastConfirmedSequence;
+    const networkInput = {
+      sequenceNumber: seq,
+      timestamp: performance.now(),
+      data: input
+    };
+    this.inputBuffer.push(networkInput);
+    applyFn(this.predictedState, input);
+    this.stateBuffer.push({
+      sequenceNumber: seq,
+      state: JSON.parse(JSON.stringify(this.predictedState))
+    });
+    if (this.stateBuffer.length > 120) {
+      this.stateBuffer.shift();
+    }
+    return this.predictedState;
+  }
+  /**
+   * Reconcile local state with authoritative server state.
+   */
+  reconcile(serverState, applyFn) {
+    this.confirmedState = JSON.parse(JSON.stringify(serverState.state));
+    this.inputBuffer = this.inputBuffer.filter(
+      (i) => i.sequenceNumber > serverState.sequenceNumber
+    );
+    const newState = JSON.parse(JSON.stringify(this.confirmedState));
+    for (const input of this.inputBuffer) {
+      applyFn(newState, input.data);
+    }
+    this.predictedState = newState;
+    return this.predictedState;
+  }
+  /**
+   * Update network metrics for adaptive prediction.
+   */
+  updateMetrics(serverTimestamp) {
+    const now = performance.now();
+    const currentRtt = now - serverTimestamp;
+    this.jitter = Math.abs(currentRtt - this.rtt) * 0.1 + this.jitter * 0.9;
+    this.rtt = currentRtt * 0.1 + this.rtt * 0.9;
+  }
+  getPredictionHorizon() {
+    return this.rtt / 2 + this.jitter * 2;
+  }
+  getPredictedState() {
+    return this.predictedState;
+  }
+};
+
+// src/runtime/MovementPredictor.ts
+var MovementPredictor = class {
+  lastPosition = { x: 0, y: 0, z: 0 };
+  velocity = { x: 0, y: 0, z: 0 };
+  history = [];
+  maxHistory = 60;
+  // 1 second at 60fps
+  intent = null;
+  /**
+   * Convert Vector3 to tuple for consistent handling
+   */
+  toTuple(v) {
+    return Array.isArray(v) ? [v[0], v[1], v[2]] : [v.x, v.y, v.z];
+  }
+  /**
+   * Update internal state with current player transform
+   */
+  update(position, dt) {
+    const currentPos = this.toTuple(position);
+    if (dt > 0) {
+      const lastPos = this.toTuple(this.lastPosition);
+      this.velocity = {
+        x: (currentPos[0] - lastPos[0]) / dt,
+        y: (currentPos[1] - lastPos[1]) / dt,
+        z: (currentPos[2] - lastPos[2]) / dt
+      };
+    }
+    this.lastPosition = { x: currentPos[0], y: currentPos[1], z: currentPos[2] };
+    this.history.push({ x: currentPos[0], y: currentPos[1], z: currentPos[2] });
+    if (this.history.length > this.maxHistory) {
+      this.history.shift();
+    }
+  }
+  /**
+   * Set the player's current intent signal (Tier 3)
+   */
+  setIntent(intent) {
+    this.intent = intent;
+  }
+  /**
+   * Tier 1: Linear Extrapolation
+   */
+  predictLinear(lookahead) {
+    const lastPosTuple = this.toTuple(this.lastPosition);
+    const velTuple = this.toTuple(this.velocity);
+    return [
+      lastPosTuple[0] + velTuple[0] * lookahead,
+      lastPosTuple[1] + velTuple[1] * lookahead,
+      lastPosTuple[2] + velTuple[2] * lookahead
+    ];
+  }
+  /**
+   * Tier 2: Non-linear pathing (Bezier-based extrapolation)
+   * Analyzes path curvature to predict smooth turns.
+   */
+  predictRecurrent(lookahead) {
+    if (this.history.length < 5) return this.predictLinear(lookahead);
+    const p2 = this.toTuple(this.history[this.history.length - 1]);
+    const p1 = this.toTuple(this.history[this.history.length - 3]);
+    const p0 = this.toTuple(this.history[this.history.length - 5]);
+    const v1 = [p2[0] - p1[0], p2[1] - p1[1], p2[2] - p1[2]];
+    const v0 = [p1[0] - p0[0], p1[1] - p0[1], p1[2] - p0[2]];
+    const acc = [v1[0] - v0[0], v1[1] - v0[1], v1[2] - v0[2]];
+    return [
+      p2[0] + v1[0] * lookahead + 0.5 * acc[0] * lookahead ** 2,
+      p2[1] + v1[1] * lookahead + 0.5 * acc[1] * lookahead ** 2,
+      p2[2] + v1[2] * lookahead + 0.5 * acc[2] * lookahead ** 2
+    ];
+  }
+  /**
+   * Tier 3: Intent-based biasing
+   */
+  predictIntent(lookahead) {
+    const recurrent = this.predictRecurrent(lookahead);
+    if (!this.intent) return recurrent;
+    const targetPos = this.intent.target;
+    const weight = this.intent.weight;
+    const targetPosTuple = this.toTuple(targetPos);
+    return [
+      recurrent[0] * (1 - weight) + targetPosTuple[0] * weight,
+      recurrent[1] * (1 - weight) + targetPosTuple[1] * weight,
+      recurrent[2] * (1 - weight) + targetPosTuple[2] * weight
+    ];
+  }
+  /**
+   * Get predictive windows for asset pre-fetching.
+   * Combines all tiers into a prioritized set of windows.
+   */
+  getPredictiveWindows(lookaheadSeconds) {
+    const windows = [];
+    windows.push({
+      center: this.toTuple(this.lastPosition),
+      radius: 10,
+      likelihood: 1
+    });
+    const speed = Math.sqrt(
+      (this.velocity.x ?? 0) ** 2 + (this.velocity.y ?? 0) ** 2 + (this.velocity.z ?? 0) ** 2
+    );
+    if (speed > 0.5) {
+      windows.push({
+        center: this.predictLinear(lookaheadSeconds),
+        radius: speed * lookaheadSeconds * 0.3 + 5,
+        likelihood: 0.9
+      });
+      const ensembleCenter = this.predictIntent(lookaheadSeconds);
+      windows.push({
+        center: ensembleCenter,
+        radius: speed * lookaheadSeconds * 0.6 + 8,
+        likelihood: 0.7
+      });
+    }
+    return windows;
+  }
+};
+
+// src/runtime/WebXRManager.ts
+var WebXRManager = class {
+  session = null;
+  referenceSpace = null;
+  glBinding = null;
+  projectionLayer = null;
+  context;
+  onSessionStart = null;
+  onSessionEnd = null;
+  onInputSourcesChange = null;
+  constructor(context) {
+    this.context = context;
+  }
+  /**
+   * Check if WebXR is supported
+   */
+  static async isSupported() {
+    if (typeof navigator !== "undefined" && "xr" in navigator) {
+      return await navigator.xr.isSessionSupported("immersive-vr");
+    }
+    return false;
+  }
+  /**
+   * Instance method to check if a specific session mode is supported.
+   */
+  async isSessionSupported(mode = "immersive-vr") {
+    if (typeof navigator !== "undefined" && "xr" in navigator) {
+      return await navigator.xr.isSessionSupported(mode);
+    }
+    return false;
+  }
+  /**
+   * Trigger haptic pulse on a controller
+   */
+  triggerHaptic(hand, intensity, duration) {
+    if (!this.session) return;
+    for (const source of this.session.inputSources) {
+      if (source.handedness === hand && source.gamepad) {
+        const actuators = source.gamepad.hapticActuators;
+        if (actuators && actuators.length > 0) {
+          actuators[0].pulse(intensity, duration);
+        }
+      }
+    }
+  }
+  /**
+   * Request an immersive VR session
+   */
+  async requestSession(config = {}) {
+    if (this.session) {
+      console.warn("WebXR session already active");
+      return this.session;
+    }
+    const sessionInit = {
+      requiredFeatures: ["local-floor"],
+      optionalFeatures: ["hand-tracking", "layers", ...config.features || []]
+    };
+    try {
+      this.session = await navigator.xr.requestSession(
+        "immersive-vr",
+        sessionInit
+      );
+      this.session.addEventListener("end", this.handleSessionEnd);
+      this.session.addEventListener(
+        "inputsourceschange",
+        this.handleInputSourcesChange
+      );
+      const g = globalThis;
+      if (typeof g.XRWebGPUBinding !== "undefined") {
+        this.glBinding = new g.XRWebGPUBinding(this.session, this.context.device);
+      } else {
+        console.warn("XRWebGPUBinding not found. Rendering may fail.");
+      }
+      this.referenceSpace = await this.session.requestReferenceSpace("local-floor");
+      if (this.glBinding) {
+        this.projectionLayer = this.glBinding.createProjectionLayer({
+          colorFormat: this.context.format,
+          depthStencilFormat: "depth24plus"
+        });
+        this.session.updateRenderState({ layers: [this.projectionLayer] });
+      }
+      this.onSessionStart?.(this.session);
+      return this.session;
+    } catch (error) {
+      console.error("Failed to start WebXR session:", error);
+      throw error;
+    }
+  }
+  /**
+   * Set a callback to be invoked each XR frame.
+   */
+  setAnimationLoop(callback) {
+    this.animationLoopCallback = callback;
+    if (this.session && callback) {
+      const loop = (time, frame) => {
+        if (this.animationLoopCallback) {
+          this.animationLoopCallback(time, frame);
+          this.session?.requestAnimationFrame?.(loop);
+        }
+      };
+      this.session.requestAnimationFrame?.(loop);
+    }
+  }
+  animationLoopCallback = null;
+  /**
+   * End the current session
+   */
+  async endSession() {
+    if (this.session) {
+      this.animationLoopCallback = null;
+      await this.session.end();
+    }
+  }
+  /**
+   * Get the current XRSession
+   */
+  getSession() {
+    return this.session;
+  }
+  /**
+   * Get the current Reference Space
+   */
+  getReferenceSpace() {
+    return this.referenceSpace;
+  }
+  /**
+   * Get the WebGPU Binding
+   */
+  getBinding() {
+    return this.glBinding;
+  }
+  /**
+   * Get the active Projection Layer
+   */
+  getProjectionLayer() {
+    return this.projectionLayer;
+  }
+  // ==========================================================================
+  // HANDLERS
+  // ==========================================================================
+  handleSessionEnd = () => {
+    this.session = null;
+    this.referenceSpace = null;
+    this.glBinding = null;
+    this.projectionLayer = null;
+    this.onSessionEnd?.();
+  };
+  handleInputSourcesChange = (event) => {
+    this.onInputSourcesChange?.(event.added, event.removed);
+  };
+};
+
+// src/runtime/KeyboardSystem.ts
+var KeyboardSystem = class _KeyboardSystem {
+  runtime;
+  focusedInputId = null;
+  cursorIndex = 0;
+  static CHAR_WIDTH = 0.048;
+  // Monospace approximation for fontSize 0.08
+  static START_X = -0.2;
+  constructor(runtime) {
+    this.runtime = runtime;
+    this.setupListeners();
+  }
+  setupListeners() {
+  }
+  handleEvent(event, payload) {
+    if (event === "ui_press_end") {
+      const nodeId = payload.nodeId;
+      if (nodeId.includes("_key_")) {
+        const key = nodeId.split("_key_")[1];
+        this.handleKeyPress(key);
+      } else if (nodeId.includes("input")) {
+        if (this.focusedInputId && this.focusedInputId !== nodeId) {
+          this.setCursorVisible(this.focusedInputId, false);
+        }
+        this.focusedInputId = nodeId;
+        const text = this.getText(nodeId);
+        this.cursorIndex = text.length;
+        this.setCursorVisible(nodeId, true);
+        this.updateCursorVisuals(nodeId);
+      }
+    }
+  }
+  handleKeyPress(key) {
+    if (!this.focusedInputId) return;
+    let currentText = this.getText(this.focusedInputId);
+    switch (key) {
+      case "LEFT":
+        this.cursorIndex = Math.max(0, this.cursorIndex - 1);
+        break;
+      case "RIGHT":
+        this.cursorIndex = Math.min(currentText.length, this.cursorIndex + 1);
+        break;
+      case "BACKSPACE":
+        if (this.cursorIndex > 0) {
+          const before = currentText.slice(0, this.cursorIndex - 1);
+          const after = currentText.slice(this.cursorIndex);
+          currentText = before + after;
+          this.cursorIndex--;
+        }
+        break;
+      case "SPACE":
+        currentText = this.insertAtCursor(currentText, " ");
+        this.cursorIndex++;
+        break;
+      default:
+        if (key.length === 1) {
+          currentText = this.insertAtCursor(currentText, key);
+          this.cursorIndex++;
+        }
+        break;
+    }
+    this.updateInputState(this.focusedInputId, currentText);
+  }
+  insertAtCursor(text, char) {
+    const before = text.slice(0, this.cursorIndex);
+    const after = text.slice(this.cursorIndex);
+    return before + char + after;
+  }
+  getText(nodeId) {
+    const instance = this.runtime.findInstanceById(nodeId);
+    return String(instance && instance.node.properties.text || "");
+  }
+  updateInputState(nodeId, text) {
+    this.runtime.updateNodeProperty(nodeId, "text", text);
+    const instance = this.runtime.findInstanceById(nodeId);
+    if (instance && instance.children) {
+      const textChild = instance.children.find(
+        (c) => c.node.type === "text"
+      );
+      if (textChild) {
+        this.runtime.updateNodeProperty(textChild.node.id, "text", text);
+      }
+    }
+    this.updateCursorVisuals(nodeId);
+  }
+  setCursorVisible(nodeId, visible) {
+    const instance = this.runtime.findInstanceById(nodeId);
+    if (instance && instance.children) {
+      const cursorChild = instance.children.find(
+        (c) => c.node.properties.tag === "cursor"
+      );
+      if (cursorChild) {
+        this.runtime.updateNodeProperty(cursorChild.node.id, "visible", visible);
+      }
+    }
+  }
+  updateCursorVisuals(nodeId) {
+    const instance = this.runtime.findInstanceById(nodeId);
+    if (!instance || !instance.children) return;
+    const cursorChild = instance.children.find(
+      (c) => c.node.properties.tag === "cursor"
+    );
+    if (cursorChild) {
+      const newX = _KeyboardSystem.START_X + this.cursorIndex * _KeyboardSystem.CHAR_WIDTH;
+      const currentPos = cursorChild.node.properties.position || { x: 0, y: 0, z: 0 };
+      const newPos = { ...currentPos, x: newX };
+      this.runtime.updateNodeProperty(cursorChild.node.id, "position", newPos);
+    }
+  }
+};
+
+// src/runtime/HandMenuSystem.ts
+var createUIButton = (id, props) => ({ id, type: "button", properties: props });
+var createUIPanel = (id, props, children) => ({ id, type: "panel", properties: props, children });
+var HandMenuSystem = class {
+  constructor(runtime, engine) {
+    this.runtime = runtime;
+    this.transitions = new TransitionSystem(engine || new AnimationEngine());
+  }
+  runtime;
+  menuNodeId = null;
+  menuNode = null;
+  isMenuVisible = false;
+  isTransitioning = false;
+  lastToggleTime = 0;
+  transitions;
+  update(delta) {
+    this.transitions.update(delta);
+    const leftHand = this.runtime.vrContext?.hands?.left;
+    if (!leftHand) return;
+    if (this.checkPalmFacingUser(leftHand)) {
+      if (!this.isMenuVisible && !this.isTransitioning && Date.now() - this.lastToggleTime > 1e3) {
+        this.showMenu(leftHand);
+      }
+    } else {
+      if (this.isMenuVisible && !this.isTransitioning) {
+        this.hideMenu();
+      }
+    }
+  }
+  // Check if palm normal points to headset
+  checkPalmFacingUser(_hand) {
+    return false;
+  }
+  showMenu(hand) {
+    if (this.menuNodeId) return;
+    const menuId = "hand_menu_" + Date.now();
+    const menu = createUIPanel(
+      menuId,
+      {
+        width: 0.2,
+        height: 0.15,
+        color: "#1a1a1a"
+      },
+      [
+        createUIButton(`${menuId}_btn1`, {
+          text: "Home",
+          position: [0, 0.03, 0.01],
+          width: 0.18,
+          height: 0.04,
+          data: { action: "home" }
+        }),
+        createUIButton(`${menuId}_btn2`, {
+          text: "Settings",
+          position: [0, -0.03, 0.01],
+          width: 0.18,
+          height: 0.04,
+          data: { action: "settings" }
+        })
+      ]
+    );
+    menu.properties.position = {
+      x: hand.position.x,
+      y: hand.position.y + 0.1,
+      z: hand.position.z
+    };
+    menu.properties.opacity = 0;
+    menu.properties.scale = 0;
+    this.runtime.mountObject(menu);
+    this.menuNodeId = menuId;
+    this.menuNode = menu;
+    this.isMenuVisible = true;
+    this.isTransitioning = true;
+    this.lastToggleTime = Date.now();
+    this.transitions.popIn(
+      menuId,
+      (s) => {
+        if (this.menuNode?.properties) this.menuNode.properties.scale = s;
+      },
+      (o) => {
+        if (this.menuNode?.properties) this.menuNode.properties.opacity = o;
+      },
+      {
+        duration: 0.35,
+        onComplete: () => {
+          this.isTransitioning = false;
+        }
+      }
+    );
+  }
+  hideMenu() {
+    if (!this.menuNodeId || !this.menuNode) return;
+    this.isTransitioning = true;
+    const nodeIdToRemove = this.menuNodeId;
+    this.transitions.popOut(
+      nodeIdToRemove,
+      (s) => {
+        if (this.menuNode?.properties) this.menuNode.properties.scale = s;
+      },
+      (o) => {
+        if (this.menuNode?.properties) this.menuNode.properties.opacity = o;
+      },
+      {
+        duration: 0.25,
+        onComplete: () => {
+          this.runtime.unmountObject(nodeIdToRemove);
+          this.isTransitioning = false;
+        }
+      }
+    );
+    this.menuNodeId = null;
+    this.menuNode = null;
+    this.isMenuVisible = false;
+    this.lastToggleTime = Date.now();
+  }
+};
+
+// src/runtime/HoloScriptPlusRuntime.ts
+var StateSync = class {
+  constructor(_options) {
+  }
+  getInterpolatedState(_id) {
+    return null;
+  }
+};
+var HoloScriptPlusRuntimeImpl = class {
+  ast;
+  options;
+  state;
+  evaluator;
+  builtins;
+  traitRegistry;
+  rootInstance = null;
+  eventHandlers = /* @__PURE__ */ new Map();
+  templates = /* @__PURE__ */ new Map();
+  updateLoopId = null;
+  lastUpdateTime = 0;
+  companions;
+  networkSync;
+  mounted = false;
+  scaleMultiplier = 1;
+  chunkLoader = null;
+  hotReloader;
+  networkPredictor = null;
+  movementPredictor;
+  // Optimization: Flat list for iteration
+  _flatEntities = [];
+  // AI Copilot integration
+  _copilot = null;
+  /**
+   * Set the AI Copilot for generate directive processing.
+   */
+  setCopilot(copilot) {
+    this._copilot = copilot;
+  }
+  // VR context
+  vrContext = {
+    hands: {
+      left: null,
+      right: null
+    },
+    headset: {
+      position: { x: 0, y: 1.6, z: 0 },
+      rotation: { x: 0, y: 0, z: 0 }
+    },
+    controllers: {
+      left: null,
+      right: null
+    }
+  };
+  // WebXR Manager
+  webXrManager = null;
+  isXRSessionActive = false;
+  // Physics World
+  physicsWorld;
+  vrPhysicsBridge;
+  debugDrawer = null;
+  keyboardSystem;
+  handMenuSystem;
+  constructor(ast, options = {}) {
+    this.ast = ast;
+    this.options = options;
+    console.log("[[TYPE OF PW]]", typeof PhysicsWorldImpl, PhysicsWorldImpl);
+    this.physicsWorld = new PhysicsWorldImpl({
+      gravity: { x: 0, y: -9.81, z: 0 },
+      maxSubsteps: 2
+    });
+    this.vrPhysicsBridge = new VRPhysicsBridge(this.physicsWorld, (hand, intensity, duration) => {
+      if (this.webXrManager) {
+        this.webXrManager.triggerHaptic(hand, intensity, duration);
+      }
+    });
+    if (options.renderer instanceof WebGPURenderer) {
+      this.debugDrawer = new PhysicsDebugDrawer(this.physicsWorld, options.renderer);
+    }
+    this.keyboardSystem = new KeyboardSystem(this);
+    this.handMenuSystem = new HandMenuSystem(this);
+    this.on("physics_grab", (payload) => {
+      const { nodeId, hand } = payload;
+      const handBodyId = this.vrPhysicsBridge.getHandBodyId(hand);
+      const objectBody = this.physicsWorld.getBody(nodeId);
+      if (handBodyId && objectBody) {
+        this.physicsWorld.createConstraint({
+          type: "fixed",
+          id: `grab_${handBodyId}_${nodeId}`,
+          bodyA: handBodyId,
+          bodyB: nodeId,
+          pivotA: { x: 0, y: 0, z: 0 },
+          // Center of hand
+          pivotB: { x: 0, y: 0, z: 0 }
+          // Should be relative offset
+          // For simplicity, we snap center-to-center or need to calculate offset based on current positions
+        });
+      }
+    });
+    this.on("physics_release", (payload) => {
+      const { nodeId, velocity } = payload;
+      this.physicsWorld.removeConstraint(`grab_${nodeId}`);
+      if (velocity) {
+        const body = this.physicsWorld.getBody(nodeId);
+        if (body) {
+          body.velocity = { x: velocity[0], y: velocity[1], z: velocity[2] };
+        }
+      }
+    });
+    this.on("ui_press_end", (payload) => {
+      this.keyboardSystem.handleEvent("ui_press_end", payload);
+    });
+    this.on("physics_add_constraint", (payload) => {
+      const { type, nodeId, axis, min, max, spring } = payload;
+      this.physicsWorld.createConstraint({
+        type: "slider",
+        // Mapped to slider for prismatic capability
+        id: `constraint_slider_${nodeId}`,
+        bodyA: "WORLD_ANCHOR",
+        // Placeholder for "Static Anchor at start pos"
+        bodyB: nodeId,
+        pivotA: { x: 0, y: 0, z: 0 },
+        axisA: axis || { x: 0, y: 1, z: 0 },
+        limits: { low: min || 0, high: max || 0 }
+      });
+    });
+    if (options.renderer && options.renderer.context && options.vrEnabled) {
+    }
+    const isNetworked = ast.root.traits?.has("networked") || ast.root.directives?.some(
+      (d) => d.type === "sync" || d.type === "networked"
+    );
+    const _syncId = isNetworked ? ast.root.id || "global_session" : void 0;
+    this.state = createState({});
+    this.traitRegistry = vrTraitRegistry;
+    this.companions = options.companions || {};
+    this.builtins = createBuiltins(this);
+    this.networkSync = new StateSync({ interpolation: true });
+    this.evaluator = new ExpressionEvaluator(
+      // @ts-expect-error - TS2554 structural type mismatch
+      this.state.getSnapshot(),
+      this.builtins
+    );
+    this.initializeState();
+    this.loadImports();
+    this.movementPredictor = new MovementPredictor();
+    if (isNetworked) {
+      this.networkPredictor = new NetworkPredictor(this.state.getSnapshot());
+    }
+    this.hotReloader = new HotReloader({ devMode: true });
+    this.hotReloader.setMigrationExecutor(async (instance, body) => {
+      let nodeInstance = this.findInstanceById(instance.__holo_id);
+      if (!nodeInstance && instance.templateName === "@program" && this.rootInstance) {
+        nodeInstance = this.rootInstance;
+      }
+      if (nodeInstance) {
+        this.executeMigrationCode(nodeInstance, body);
+      }
+    });
+    const self = this;
+    if (this.ast.version !== void 0) {
+      this.hotReloader.registerTemplate({
+        type: "template",
+        name: "@program",
+        version: this.ast.version || 0,
+        migrations: this.ast.migrations || [],
+        state: { properties: [] }
+      });
+      const stateBridge = this.createStateMapProxy();
+      this.hotReloader.registerInstance({
+        __holo_id: "root",
+        templateName: "@program",
+        get version() {
+          return self.ast.version || 0;
+        },
+        set version(v) {
+          self.ast.version = v;
+        },
+        state: stateBridge
+      });
+    }
+    const initialTemplates = this.findAllTemplates(this.ast.root);
+    for (const [name, node] of initialTemplates) {
+      this.templates.set(name, node);
+      this.hotReloader.registerTemplate(node);
+    }
+    if (this.options.manifestUrl) {
+      this.chunkLoader = new ChunkLoader(this, {
+        manifestUrl: this.options.manifestUrl,
+        baseUrl: this.options.baseUrl
+      });
+      this.chunkLoader.init();
+    }
+  }
+  // ==========================================================================
+  // WEBXR INTEGRATION
+  // ==========================================================================
+  async enterVR() {
+    if (!this.options.vrEnabled) {
+      console.warn("VR is not enabled in runtime options");
+      return;
+    }
+    const renderer = this.options.renderer;
+    if (!renderer) {
+      console.error("Cannot enter VR: No renderer found");
+      return;
+    }
+    if (!this.webXrManager) {
+      const context = renderer.getContext ? renderer.getContext() : renderer.context;
+      if (!context) {
+        console.error("WebGPU context not found on renderer");
+        return;
+      }
+      const ManagerClass = this.options.webXrManagerClass || WebXRManager;
+      this.webXrManager = new ManagerClass(context);
+      this.webXrManager.onSessionStart = (session) => {
+        this.isXRSessionActive = true;
+        this.stopUpdateLoop();
+        if (renderer.setXRSession) {
+          renderer.setXRSession(
+            session,
+            this.webXrManager.getBinding(),
+            this.webXrManager.getProjectionLayer()
+          );
+        }
+        this.webXrManager.setAnimationLoop(this.xrLoop.bind(this));
+      };
+      this.webXrManager.onSessionEnd = () => {
+        this.isXRSessionActive = false;
+        if (renderer.setXRSession) {
+          renderer.setXRSession(null, null, null);
+        }
+        this.startUpdateLoop();
+      };
+    }
+    if (await this.webXrManager.isSessionSupported("immersive-vr")) {
+      await this.webXrManager.requestSession();
+    } else {
+      console.warn("WebXR not supported in this environment");
+    }
+  }
+  /**
+   * Main XR Loop - called by WebXRManager
+   */
+  xrLoop(time, frame) {
+    const now = performance.now();
+    const delta = (now - this.lastUpdateTime) / 1e3;
+    this.lastUpdateTime = now;
+    this.updateVRInput(frame);
+    this.update(delta);
+    if (this.handMenuSystem) this.handMenuSystem.update(delta);
+    const renderer = this.options.renderer;
+    if (renderer?.renderXR) {
+      renderer.renderXR(frame);
+    }
+  }
+  async exitVR() {
+    if (this.webXrManager) {
+      await this.webXrManager.endSession();
+    }
+  }
+  /**
+   * Convert Quaternion to Euler Angles (YXZ sequence)
+   */
+  quaternionToEuler(q) {
+    const x = q[0], y = q[1], z = q[2], w = q[3];
+    const t0 = 2 * (w * y - z * x);
+    const ry = Math.asin(Math.max(-1, Math.min(1, t0)));
+    const t1 = 2 * (w * x + y * z);
+    const t2 = 1 - 2 * (x * x + y * y);
+    const rx = Math.atan2(t1, t2);
+    const t3 = 2 * (w * z + x * y);
+    const t4 = 1 - 2 * (y * y + z * z);
+    const rz = Math.atan2(t3, t4);
+    return { x: rx, y: ry, z: rz };
+  }
+  updateVRInput(frame) {
+    if (!this.isXRSessionActive || !this.webXrManager) return;
+    const session = frame ? frame.session : this.webXrManager.getSession();
+    const refSpace = this.webXrManager.getReferenceSpace();
+    if (!session || !refSpace) return;
+    if (frame) {
+      const viewerPose = frame.getViewerPose(refSpace);
+      if (viewerPose) {
+        const { position, orientation } = viewerPose.transform;
+        this.vrContext.headset.position = { x: position.x, y: position.y, z: position.z };
+        const eulerH = this.quaternionToEuler([
+          orientation.x,
+          orientation.y,
+          orientation.z,
+          orientation.w
+        ]);
+        this.vrContext.headset.rotation = { x: eulerH[0], y: eulerH[1], z: eulerH[2] };
+      }
+    }
+    for (const source of session.inputSources) {
+      if (!source.gripSpace) continue;
+      let pose;
+      if (frame) {
+        pose = frame.getPose(source.gripSpace, refSpace) ?? void 0;
+      }
+      if (pose) {
+        const { position, orientation } = pose.transform;
+        const handSide = source.handedness;
+        const handData = {
+          id: `${handSide}_hand`,
+          grip: 0,
+          trigger: 0,
+          position: [position.x, position.y, position.z],
+          rotation: this.quaternionToEuler([
+            orientation.x,
+            orientation.y,
+            orientation.z,
+            orientation.w
+          ]),
+          velocity: { x: 0, y: 0, z: 0 },
+          // Not provided by WebXR directly without previous frame diff
+          pinchStrength: 0,
+          gripStrength: 0
+        };
+        if (source.gamepad) {
+          if (source.gamepad.buttons.length > 0) {
+            handData.pinchStrength = source.gamepad.buttons[0].value;
+          }
+          if (source.gamepad.buttons.length > 1) {
+            handData.gripStrength = source.gamepad.buttons[1].value;
+          }
+        }
+        const prevHand = handSide === "left" ? this.vrContext.hands.left : this.vrContext.hands.right;
+        if (prevHand) {
+        }
+        if (handSide === "left") {
+          this.vrContext.hands.left = handData;
+        } else if (handSide === "right") {
+          this.vrContext.hands.right = handData;
+        }
+      }
+    }
+  }
+  // ==========================================================================
+  // INITIALIZATION
+  // ==========================================================================
+  initializeState() {
+    const stateDirective = (this.ast.root.directives || []).find(
+      (d) => d.type === "state"
+    );
+    if (stateDirective && stateDirective.type === "state") {
+      this.state.update(stateDirective.body);
+    }
+  }
+  loadImports() {
+    for (const imp of this.ast.imports || []) {
+      const alias = imp.alias || imp.source || imp.path;
+      if (this.companions[alias]) {
+        continue;
+      }
+      console.warn(
+        `Import ${imp.path || imp.source} not found. Provide via companions option.`
+      );
+    }
+  }
+  // ==========================================================================
+  // MOUNTING
+  // ==========================================================================
+  mount(container) {
+    if (this.mounted) {
+      console.warn("Runtime already mounted");
+      return;
+    }
+    this.mounted = true;
+    this.rootInstance = this.instantiateNode(this.ast.root, null);
+    if (this.options.renderer && this.rootInstance) {
+      this.options.renderer.appendChild(container, this.rootInstance.renderedNode);
+    }
+    this.callLifecycle(this.rootInstance, "on_mount");
+    this.startUpdateLoop();
+  }
+  unmount() {
+    if (!this.mounted) return;
+    this.stopUpdateLoop();
+    if (this.rootInstance) {
+      this.callLifecycle(this.rootInstance, "on_unmount");
+      this.destroyInstance(this.rootInstance);
+    }
+    this.rootInstance = null;
+    this.mounted = false;
+  }
+  /**
+   * Scans the AST for all template definitions, including nested ones.
+   */
+  findAllTemplates(node, templates = /* @__PURE__ */ new Map()) {
+    if (node.type === "template" && node.name) {
+      templates.set(node.name, node);
+    }
+    if (node.children) {
+      for (const child of node.children) {
+        this.findAllTemplates(child, templates);
+      }
+    }
+    if (node.type === "composition") {
+      const comp = node;
+      if (comp.children) {
+        for (const child of comp.children) {
+          this.findAllTemplates(child, templates);
+        }
+      }
+    }
+    return templates;
+  }
+  /**
+   * Dynamically mount a new object into the scene (e.g. from a lazy-loaded chunk)
+   */
+  mountObject(node, parent = null) {
+    const targetParent = parent || this.rootInstance;
+    const instance = this.instantiateNode(node, targetParent);
+    if (targetParent) {
+      targetParent.children.push(instance);
+      if (this.options.renderer && targetParent.renderedNode && instance.renderedNode) {
+        this.options.renderer.appendChild(targetParent.renderedNode, instance.renderedNode);
+      }
+    }
+    this.callLifecycle(instance, "on_mount");
+    return instance;
+  }
+  unmountObject(idOrInstance) {
+    let instance;
+    if (typeof idOrInstance === "string") {
+      instance = this._flatEntities.find(
+        (n) => n.node.id === idOrInstance || n.__holo_id === idOrInstance
+      );
+    } else {
+      instance = idOrInstance;
+    }
+    if (!instance) return;
+    if (instance.parent) {
+      const idx = instance.parent.children.indexOf(instance);
+      if (idx > -1) instance.parent.children.splice(idx, 1);
+    }
+    const flatIdx = this._flatEntities.indexOf(instance);
+    if (flatIdx > -1) this._flatEntities.splice(flatIdx, 1);
+    if (this.options.renderer && instance.renderedNode) {
+      this.options.renderer.destroy(instance.renderedNode);
+    }
+    this.callLifecycle(instance, "on_unmount");
+  }
+  // ==========================================================================
+  // NODE INSTANTIATION
+  // ==========================================================================
+  _holoIdCounter = 0;
+  generateHoloId(node) {
+    const name = node.name || node.type || "obj";
+    return `${name}_${++this._holoIdCounter}_${Date.now().toString(36)}`;
+  }
+  instantiateNode(node, parent) {
+    const instance = {
+      __holo_id: this.generateHoloId(node),
+      node,
+      get properties() {
+        return this.node.properties || {};
+      },
+      renderedNode: null,
+      lifecycleHandlers: /* @__PURE__ */ new Map(),
+      children: [],
+      parent,
+      destroyed: false,
+      dirty: true,
+      hasTraits: !!(node.traits && node.traits.size > 0)
+    };
+    this._flatEntities.push(instance);
+    let templateName = node.template || node.properties && node.properties.__templateRef;
+    if (!templateName && this.templates.has(node.type)) {
+      templateName = node.type;
+    }
+    if (templateName) {
+      instance.templateName = templateName;
+      const templateNode = this.templates.get(templateName);
+      instance.templateVersion = templateNode?.version || node.version || 0;
+      const stateBridge = this.createStateMapProxy();
+      const _self = this;
+      this.hotReloader.registerInstance({
+        __holo_id: instance.__holo_id,
+        templateName: instance.templateName,
+        get version() {
+          return instance.templateVersion || 0;
+        },
+        set version(v) {
+          instance.templateVersion = v;
+        },
+        state: stateBridge
+      });
+    }
+    const templateNodeForDirectives = templateName ? this.templates.get(templateName) : null;
+    this.processDirectives(instance, templateNodeForDirectives?.directives);
+    if (this.options.renderer) {
+      const properties = node.properties ? this.evaluateProperties(node.properties) : {};
+      instance.renderedNode = this.options.renderer.createElement(node.type, properties);
+    }
+    if (node.traits) {
+      for (const [traitName, config] of node.traits) {
+        this.traitRegistry.attachTrait(node, traitName, config, this.createTraitContext(instance));
+      }
+    }
+    const childrenNodes = node.children || node.body || [];
+    const children = this.processControlFlow(childrenNodes, node.directives || []);
+    for (const childNode of children) {
+      const childInstance = this.instantiateNode(childNode, instance);
+      instance.children.push(childInstance);
+      if (this.options.renderer && instance.renderedNode) {
+        this.options.renderer.appendChild(instance.renderedNode, childInstance.renderedNode);
+      }
+    }
+    return instance;
+  }
+  getNode(id) {
+    const instance = this._flatEntities.find((n) => n.node.id === id || n.__holo_id === id);
+    return instance ? instance.node : void 0;
+  }
+  processDirectives(instance, extraDirectives) {
+    const directives = [...instance.node.directives || [], ...extraDirectives || []];
+    for (const directive of directives) {
+      if (directive.type === "lifecycle") {
+        this.registerLifecycleHandler(instance, directive);
+      } else if (directive.type === "state") {
+        const stateBody = directive.body || {};
+        for (const [key, value] of Object.entries(stateBody)) {
+          if (!this.state.has(key)) {
+            this.state.set(key, value);
+          }
+        }
+      }
+    }
+  }
+  registerLifecycleHandler(instance, directive) {
+    const { hook, params, body } = directive;
+    const handler = (...args) => {
+      const paramContext = {};
+      if (params) {
+        params.forEach((param, i) => {
+          paramContext[param] = args[i];
+        });
+      }
+      this.evaluator.updateContext({
+        ...this.state.getSnapshot(),
+        ...paramContext,
+        node: instance.node,
+        self: instance.node
+      });
+      try {
+        if (body.includes(";") || body.includes("{")) {
+          new Function(
+            ...Object.keys(this.builtins),
+            ...Object.keys(paramContext),
+            "state",
+            "node",
+            body
+          )(
+            ...Object.values(this.builtins),
+            ...Object.values(paramContext),
+            this.state,
+            instance.node
+          );
+        } else {
+          this.evaluator.evaluate(body);
+        }
+      } catch (error) {
+        console.error(`Error in lifecycle handler ${hook}:`, error);
+      }
+    };
+    if (!instance.lifecycleHandlers.has(hook)) {
+      instance.lifecycleHandlers.set(hook, []);
+    }
+    instance.lifecycleHandlers.get(hook).push(handler);
+  }
+  // ==========================================================================
+  // CONTROL FLOW
+  // ==========================================================================
+  processControlFlow(children, directives) {
+    const result = [];
+    for (const directive of directives) {
+      if (directive.type === "for") {
+        const items = this.evaluateExpression(directive.iterable);
+        if (Array.isArray(items)) {
+          items.forEach((item, index) => {
+            const iterContext = {
+              [directive.variable]: item,
+              index,
+              first: index === 0,
+              last: index === items.length - 1,
+              even: index % 2 === 0,
+              odd: index % 2 !== 0
+            };
+            for (const bodyNode of directive.body) {
+              const cloned = this.cloneNodeWithContext(bodyNode, iterContext);
+              result.push(cloned);
+            }
+          });
+        }
+      } else if (directive.type === "forEach") {
+        const items = this.evaluateExpression(
+          directive.collection
+        );
+        if (Array.isArray(items)) {
+          items.forEach((item, index) => {
+            const iterContext = {
+              [directive.variable]: item,
+              index,
+              first: index === 0,
+              last: index === items.length - 1,
+              even: index % 2 === 0,
+              odd: index % 2 !== 0
+            };
+            for (const bodyNode of directive.body) {
+              const cloned = this.cloneNodeWithContext(bodyNode, iterContext);
+              result.push(cloned);
+            }
+          });
+        }
+      } else if (directive.type === "while") {
+        const MAX_ITERATIONS = 1e3;
+        let iterations = 0;
+        while (iterations < MAX_ITERATIONS) {
+          const condition = this.evaluateExpression(
+            directive.condition
+          );
+          if (!condition) break;
+          const iterContext = {
+            iteration: iterations,
+            index: iterations
+          };
+          for (const bodyNode of directive.body) {
+            const cloned = this.cloneNodeWithContext(bodyNode, iterContext);
+            result.push(cloned);
+          }
+          iterations++;
+        }
+        if (iterations >= MAX_ITERATIONS) {
+          console.warn("@while loop hit maximum iteration limit (1000)");
+        }
+      } else if (directive.type === "if") {
+        const condition = this.evaluateExpression(
+          directive.condition
+        );
+        if (condition) {
+          result.push(...directive.body);
+        } else if (directive.else) {
+          result.push(...directive.else);
+        }
+      }
+    }
+    result.push(...children);
+    return result;
+  }
+  cloneNodeWithContext(node, context) {
+    const cloned = {
+      type: node.type,
+      id: node.id ? this.interpolateString(node.id, context) : void 0,
+      properties: node.properties ? this.interpolateProperties(node.properties, context) : {},
+      directives: node.directives ? [...node.directives] : [],
+      children: (node.children || []).map(
+        (child) => this.cloneNodeWithContext(child, context)
+      ),
+      traits: node.traits ? new Map(node.traits) : /* @__PURE__ */ new Map(),
+      loc: node.loc
+    };
+    return cloned;
+  }
+  interpolateString(str, context) {
+    return str.replace(/\$\{([^}]+)\}/g, (_match, expr) => {
+      this.evaluator.updateContext(context);
+      const value = this.evaluator.evaluate(expr);
+      return String(value ?? "");
+    });
+  }
+  interpolateProperties(properties, context) {
+    const result = {};
+    for (const [key, value] of Object.entries(properties)) {
+      if (typeof value === "string") {
+        result[key] = this.interpolateString(value, context);
+      } else if (value && typeof value === "object" && "__expr" in value) {
+        this.evaluator.updateContext(context);
+        result[key] = this.evaluator.evaluate(value.__raw);
+      } else {
+        result[key] = value;
+      }
+    }
+    return result;
+  }
+  // ==========================================================================
+  // EXPRESSION EVALUATION
+  // ==========================================================================
+  evaluateExpression(expr) {
+    this.evaluator.updateContext(this.state.getSnapshot());
+    return this.evaluator.evaluate(expr);
+  }
+  evaluateProperties(properties) {
+    const expandedProperties = this.expandPropertySpreads(properties);
+    const result = {};
+    for (const [key, value] of Object.entries(expandedProperties)) {
+      if (value && typeof value === "object" && "__expr" in value) {
+        result[key] = this.evaluateExpression(value.__raw);
+      } else if (value && typeof value === "object" && "__ref" in value) {
+        const ref = value.__ref;
+        result[key] = this.state.get(ref) ?? ref;
+      } else if (typeof value === "string" && value.includes("${")) {
+        result[key] = this.interpolateString(value, this.state.getSnapshot());
+      } else {
+        result[key] = value;
+      }
+    }
+    return result;
+  }
+  /**
+   * Expands spread expressions in a properties object.
+   * Spread keys are formatted as __spread_N with value { type: 'spread', argument: ... }
+   */
+  expandPropertySpreads(properties) {
+    const result = {};
+    const spreadKeys = [];
+    for (const [key, value] of Object.entries(properties)) {
+      if (key.startsWith("__spread_")) {
+        spreadKeys.push(key);
+      } else if (value && typeof value === "object" && "type" in value && value.type === "spread") {
+        spreadKeys.push(key);
+      } else {
+        if (value && typeof value === "object" && !Array.isArray(value) && !("__ref" in value) && !("__expr" in value)) {
+          result[key] = this.expandPropertySpreads(value);
+        } else if (Array.isArray(value)) {
+          result[key] = this.expandArraySpreads(value);
+        } else {
+          result[key] = value;
+        }
+      }
+    }
+    for (const spreadKey of spreadKeys) {
+      const spreadValue = properties[spreadKey];
+      if (spreadValue && typeof spreadValue === "object" && "type" in spreadValue && spreadValue.type === "spread") {
+        const resolved = this.resolveSpreadArgument(
+          spreadValue.argument
+        );
+        if (resolved && typeof resolved === "object" && !Array.isArray(resolved)) {
+          Object.assign(result, this.expandPropertySpreads(resolved));
+        }
+      }
+    }
+    for (const [key, value] of Object.entries(properties)) {
+      if (!key.startsWith("__spread_") && !(value && typeof value === "object" && "type" in value && value.type === "spread")) {
+        if (value && typeof value === "object" && !Array.isArray(value) && !("__ref" in value) && !("__expr" in value)) {
+          result[key] = this.expandPropertySpreads(value);
+        } else if (Array.isArray(value)) {
+          result[key] = this.expandArraySpreads(value);
+        } else {
+          result[key] = value;
+        }
+      }
+    }
+    return result;
+  }
+  /**
+   * Expands spread expressions within an array.
+   */
+  expandArraySpreads(arr) {
+    const result = [];
+    for (const item of arr) {
+      if (item && typeof item === "object" && "type" in item && item.type === "spread") {
+        const resolved = this.resolveSpreadArgument(item.argument);
+        if (Array.isArray(resolved)) {
+          result.push(...resolved);
+        } else if (resolved !== void 0 && resolved !== null) {
+          result.push(resolved);
+        }
+      } else if (item && typeof item === "object" && !Array.isArray(item)) {
+        result.push(this.expandPropertySpreads(item));
+      } else {
+        result.push(item);
+      }
+    }
+    return result;
+  }
+  /**
+   * Resolves a spread argument to its runtime value.
+   */
+  resolveSpreadArgument(argument) {
+    if (argument === null || argument === void 0) {
+      return void 0;
+    }
+    if (typeof argument === "object" && !("__ref" in argument)) {
+      return argument;
+    }
+    if (typeof argument === "object" && "__ref" in argument) {
+      const ref = argument.__ref;
+      const stateValue = this.state.get(ref);
+      if (stateValue !== void 0) {
+        return stateValue;
+      }
+      if (ref.includes(".")) {
+        const snapshot = this.state.getSnapshot();
+        const parts = ref.split(".");
+        let value = snapshot;
+        for (const part of parts) {
+          if (value && typeof value === "object" && part in value) {
+            value = value[part];
+          } else {
+            return void 0;
+          }
+        }
+        return value;
+      }
+      return void 0;
+    }
+    if (typeof argument === "string") {
+      return this.state.get(argument);
+    }
+    return argument;
+  }
+  // ==========================================================================
+  // LIFECYCLE
+  // ==========================================================================
+  callLifecycle(instance, hook, ...args) {
+    if (!instance || instance.destroyed) return;
+    const handlers = instance.lifecycleHandlers.get(hook);
+    if (handlers) {
+      handlers.forEach((handler) => {
+        try {
+          handler(...args);
+        } catch (error) {
+          console.error(`Error in lifecycle ${hook}:`, error);
+        }
+      });
+    }
+    for (const child of instance.children) {
+      this.callLifecycle(child, hook, ...args);
+    }
+  }
+  // ==========================================================================
+  // UPDATE LOOP
+  // ==========================================================================
+  startUpdateLoop() {
+    const raf = typeof requestAnimationFrame !== "undefined" ? requestAnimationFrame : (cb) => setTimeout(() => cb(performance.now()), 16);
+    this.lastUpdateTime = performance.now();
+    const update = () => {
+      const now = performance.now();
+      const delta = (now - this.lastUpdateTime) / 1e3;
+      this.lastUpdateTime = now;
+      this.updateVRInput();
+      this.update(delta);
+      this.updateLoopId = raf(update);
+    };
+    this.updateLoopId = raf(update);
+  }
+  stopUpdateLoop() {
+    if (this.updateLoopId !== null) {
+      if (typeof cancelAnimationFrame !== "undefined") {
+        cancelAnimationFrame(this.updateLoopId);
+      } else {
+        clearTimeout(this.updateLoopId);
+      }
+      this.updateLoopId = null;
+    }
+  }
+  update(delta) {
+    if (!this.rootInstance) return;
+    try {
+      this.vrPhysicsBridge.update(this.vrContext, delta);
+    } catch (e) {
+      console.error("[Runtime] Error in vrPhysicsBridge.update:", e);
+    }
+    this.physicsWorld.step(delta);
+    if (this.debugDrawer) {
+      this.debugDrawer.update();
+    }
+    const count = this._flatEntities.length;
+    for (let i = 0; i < count; i++) {
+      this.updateInstance(this._flatEntities[i], delta);
+    }
+    this.callLifecycle(this.rootInstance, "on_update", delta);
+    if (this.chunkLoader) {
+      if (this.chunkLoader) this.chunkLoader.update();
+    }
+  }
+  /**
+   * Authoritative server sync for networked state.
+   */
+  onNetworkStateUpdate(serverState) {
+    if (this.networkPredictor) {
+      const reconciled = this.networkPredictor.reconcile(serverState, (state, input) => {
+        if (input.type === "state_update") {
+          Object.assign(state, input.payload);
+        }
+      });
+      this.state.update(reconciled);
+      this.networkPredictor.updateMetrics(performance.now() - 100);
+    }
+  }
+  updateInstance(instance, delta) {
+    if (instance.destroyed) return;
+    if (instance.hasTraits) {
+      const traitContext = this.createTraitContext(instance);
+      this.traitRegistry.updateAllTraits(instance.node, traitContext, delta);
+    }
+    if (instance.node.type === "avatar") {
+      this.syncAvatarParts(instance);
+    }
+    if (instance.node.traits?.has("networked")) {
+      const interpolated = this.networkSync.getInterpolatedState(
+        instance.node.id || ""
+      );
+      const body = this.physicsWorld.getBody(instance.node.id || "");
+      if (interpolated && instance.node.properties) {
+        instance.dirty = true;
+        if (interpolated.position) {
+          instance.node.properties.position = [
+            interpolated.position.x,
+            interpolated.position.y,
+            interpolated.position.z
+          ];
+        }
+        if (interpolated.rotation) {
+          instance.node.properties.rotation = [
+            interpolated.rotation.x,
+            interpolated.rotation.y,
+            interpolated.rotation.z
+          ];
+        }
+        if (body) {
+          if (body.type !== "kinematic") {
+            if (!instance.node.__originalPhysicsType) {
+              instance.node.__originalPhysicsType = body.type;
+            }
+            body.type = "kinematic";
+          }
+          if (interpolated.position) {
+            const pos = interpolated.position;
+            body.position = {
+              x: pos.x,
+              y: pos.y,
+              z: pos.z
+            };
+            body.velocity = { x: 0, y: 0, z: 0 };
+          }
+          if (interpolated.rotation) {
+            const rot = interpolated.rotation;
+            body.rotation = {
+              x: rot.x,
+              y: rot.y,
+              z: rot.z,
+              w: rot.w || 1
+            };
+            body.angularVelocity = { x: 0, y: 0, z: 0 };
+          }
+        }
+      } else if (!interpolated && body && instance.node.__originalPhysicsType) {
+        if (body.type === "kinematic" && instance.node.__originalPhysicsType !== "kinematic") {
+          body.type = instance.node.__originalPhysicsType;
+        }
+      }
+    }
+    if (instance.dirty && this.options.renderer && instance.renderedNode) {
+      const properties = this.evaluateProperties(instance.node.properties || {});
+      this.options.renderer.updateElement(instance.renderedNode, properties);
+      instance.dirty = false;
+    }
+    this.updateExternalApis(instance, delta);
+    this.processGenerateDirectives(instance);
+  }
+  syncAvatarParts(instance) {
+    const vrHands = this.vrContext.hands;
+    const vrHead = this.vrContext.headset;
+    if (instance.node.id === "local_player" && instance.node.properties) {
+      instance.node.properties.position = vrHead.position;
+      instance.node.properties.rotation = vrHead.rotation;
+      instance.children.forEach((child) => {
+        if (child.node.id === "left_hand" && vrHands.left && child.node.properties) {
+          child.node.properties.position = vrHands.left.position;
+          child.node.properties.rotation = vrHands.left.rotation;
+        } else if (child.node.id === "right_hand" && vrHands.right && child.node.properties) {
+          child.node.properties.position = vrHands.right.position;
+          child.node.properties.rotation = vrHands.right.rotation;
+        }
+      });
+      if (instance.node.traits?.has("networked")) {
+        this.emit("network_snapshot", {
+          objectId: instance.node.id,
+          position: [
+            instance.node.properties.position[0],
+            instance.node.properties.position[1],
+            instance.node.properties.position[2]
+          ],
+          rotation: [
+            instance.node.properties.rotation[0],
+            instance.node.properties.rotation[1],
+            instance.node.properties.rotation[2]
+          ]
+        });
+      }
+    }
+  }
+  generatedNodes = /* @__PURE__ */ new Set();
+  processGenerateDirectives(instance) {
+    if (!instance.node.directives) return;
+    const generateDirectives = instance.node.directives.filter((d) => d.type === "generate");
+    for (const d of generateDirectives) {
+      const directive = d;
+      const genId = `${instance.node.id || "node"}_${directive.prompt.substring(0, 10)}`;
+      if (this.generatedNodes.has(genId)) continue;
+      if (this._copilot && this._copilot.isReady()) {
+        this._copilot.generateFromPrompt(directive.prompt, {
+          context: directive.context
+        }).then((response) => {
+          this.emit("generate_complete", {
+            id: genId,
+            nodeId: instance.node.id,
+            result: response
+          });
+        }).catch(() => {
+        });
+      } else {
+        this.emit("generate_request", {
+          id: genId,
+          nodeId: instance.node.id,
+          prompt: directive.prompt,
+          context: directive.context,
+          target: directive.target || "children"
+        });
+      }
+      this.generatedNodes.add(genId);
+    }
+  }
+  apiPollingTimers = /* @__PURE__ */ new Map();
+  updateExternalApis(instance, _delta) {
+    if (!instance.node.directives) return;
+    const apiDirectives = instance.node.directives.filter((d) => d.type === "external_api");
+    for (const d of apiDirectives) {
+      const directive = d;
+      if (directive.type !== "external_api") continue;
+      const intervalStr = directive.interval || "0s";
+      const intervalMs = this.parseDurationToMs(String(intervalStr));
+      if (intervalMs <= 0) continue;
+      const lastTime = this.apiPollingTimers.get(instance) || 0;
+      const now = performance.now();
+      if (now - lastTime >= intervalMs) {
+        this.apiPollingTimers.set(instance, now);
+        this.executeExternalApi(instance, directive);
+      }
+    }
+  }
+  async executeExternalApi(instance, directive) {
+    try {
+      const apiCall = this.builtins["api_call"];
+      const data = apiCall ? await apiCall(String(directive.url), String(directive.method || "GET")) : void 0;
+      this.state.set("api_data", data);
+      this.updateData(data);
+    } catch (error) {
+      console.error(`External API error for ${directive.url}:`, error);
+    }
+  }
+  parseDurationToMs(duration) {
+    const match = duration.match(/^(\d+)(ms|s|m)$/);
+    if (!match) return 0;
+    const value = parseInt(match[1], 10);
+    const unit = match[2];
+    switch (unit) {
+      case "ms":
+        return value;
+      case "s":
+        return value * 1e3;
+      case "m":
+        return value * 6e4;
+      default:
+        return 0;
+    }
+  }
+  // ==========================================================================
+  // TRAIT CONTEXT
+  // ==========================================================================
+  createTraitContext(_instance) {
+    return {
+      vr: {
+        hands: this.vrContext.hands,
+        headset: this.vrContext.headset,
+        getPointerRay: (hand) => {
+          const vrHand = hand === "left" ? this.vrContext.hands.left : this.vrContext.hands.right;
+          if (!vrHand) return null;
+          return {
+            origin: vrHand.position,
+            direction: { x: 0, y: 0, z: -1 }
+            // Forward direction - should be calculated from rotation
+          };
+        },
+        getDominantHand: () => this.vrContext.hands.right || this.vrContext.hands.left
+      },
+      physics: {
+        applyVelocity: (node, velocity) => {
+          const body = this.physicsWorld.getBody(node.id || "");
+          if (body) {
+            body.velocity = {
+              x: velocity[0],
+              y: velocity[1],
+              z: velocity[2]
+            };
+          }
+        },
+        applyAngularVelocity: (node, angularVelocity) => {
+          const body = this.physicsWorld.getBody(node.id || "");
+          if (body) {
+            body.angularVelocity = {
+              x: angularVelocity[0],
+              y: angularVelocity[1],
+              z: angularVelocity[2]
+            };
+          }
+        },
+        setKinematic: (node, kinematic) => {
+          const body = this.physicsWorld.getBody(node.id || "");
+          if (body) {
+            body.type = kinematic ? "kinematic" : "dynamic";
+          }
+        },
+        raycast: (origin, direction, maxDistance) => {
+          const hit = this.physicsWorld.raycastClosest({
+            origin: { x: origin[0], y: origin[1], z: origin[2] },
+            direction: {
+              x: direction[0],
+              y: direction[1],
+              z: direction[2]
+            },
+            maxDistance
+          });
+          if (hit) {
+            const h = hit;
+            return {
+              point: { x: h.point.x || 0, y: h.point.y || 0, z: h.point.z || 0 },
+              normal: { x: h.normal.x || 0, y: h.normal.y || 0, z: h.normal.z || 0 },
+              distance: h.distance,
+              bodyId: h.bodyId,
+              nodeId: h.bodyId,
+              node: h.bodyId
+            };
+          }
+          return null;
+        },
+        getBodyPosition: (nodeId) => {
+          const body = this.physicsWorld.getBody(nodeId);
+          if (body && body.position) return { x: body.position.x || 0, y: body.position.y || 0, z: body.position.z || 0 };
+          return null;
+        },
+        getBodyVelocity: (nodeId) => {
+          const body = this.physicsWorld.getBody(nodeId);
+          if (body && body.velocity) return { x: body.velocity.x || 0, y: body.velocity.y || 0, z: body.velocity.z || 0 };
+          return null;
+        }
+      },
+      audio: {
+        playSound: (source, options) => {
+          this.emit("play_sound", { source, ...options });
+        }
+      },
+      haptics: {
+        pulse: (hand, intensity, duration) => {
+          this.emit("haptic", { hand, intensity, duration, type: "pulse" });
+        },
+        rumble: (hand, intensity) => {
+          this.emit("haptic", { hand, intensity, type: "rumble" });
+        }
+      },
+      emit: this.emit.bind(this),
+      getState: () => this.state.getSnapshot(),
+      setState: (updates) => this.state.update(updates),
+      getScaleMultiplier: () => this.scaleMultiplier,
+      setScaleContext: (magnitude) => {
+        const multipliers = {
+          galactic: 1e6,
+          macro: 1e3,
+          standard: 1,
+          micro: 1e-3,
+          atomic: 1e-6
+        };
+        const newMultiplier = multipliers[magnitude] || 1;
+        if (this.scaleMultiplier !== newMultiplier) {
+          this.scaleMultiplier = newMultiplier;
+          this.emit("scale_change", { magnitude, multiplier: newMultiplier });
+        }
+      }
+    };
+  }
+  // ==========================================================================
+  // NODE DESTRUCTION
+  // ==========================================================================
+  destroyInstance(instance) {
+    if (instance.destroyed) return;
+    instance.destroyed = true;
+    for (const child of instance.children) {
+      this.destroyInstance(child);
+    }
+    const traitContext = this.createTraitContext(instance);
+    if (instance.node.traits) {
+      for (const traitName of instance.node.traits.keys()) {
+        this.traitRegistry.detachTrait(instance.node, traitName, traitContext);
+      }
+    }
+    if (this.options.renderer && instance.renderedNode) {
+      this.options.renderer.destroy(instance.renderedNode);
+    }
+    instance.lifecycleHandlers.clear();
+    instance.children = [];
+    const index = this._flatEntities.indexOf(instance);
+    if (index !== -1) {
+      this._flatEntities.splice(index, 1);
+    }
+  }
+  // ==========================================================================
+  // PUBLIC API
+  // ==========================================================================
+  togglePhysicsDebug(enabled) {
+    if (this.debugDrawer) {
+      this.debugDrawer.setEnabled(enabled);
+    }
+  }
+  updateData(data) {
+    this.state.set("data", data);
+    this.callLifecycle(this.rootInstance, "on_data_update", data);
+  }
+  updateNodeProperty(nodeId, property, value) {
+    const instance = this.findInstanceById(nodeId);
+    if (instance && instance.node.properties) {
+      instance.node.properties[property] = value;
+      if (this.options.renderer && instance.renderedNode) {
+        instance.dirty = true;
+      }
+      this.emit("property_update", { nodeId, property, value });
+    }
+  }
+  getState() {
+    return this.state.getSnapshot();
+  }
+  // ==========================================================================
+  // COMPATIBILITY METHODS
+  // ==========================================================================
+  getVariable(name) {
+    return this.state.get(name);
+  }
+  setVariable(name, value) {
+    this.state.set(name, value);
+  }
+  getContext() {
+    const spatialMemory = /* @__PURE__ */ new Map();
+    const hologramState = /* @__PURE__ */ new Map();
+    const traverse = (instance) => {
+      if (instance.node.id && instance.node.properties) {
+        spatialMemory.set(
+          instance.node.id,
+          instance.node.properties.position || { x: 0, y: 0, z: 0 }
+        );
+        hologramState.set(instance.node.id, {
+          shape: instance.node.properties.shape || instance.node.type,
+          color: instance.node.properties.color,
+          size: instance.node.properties.size,
+          glow: instance.node.properties.glow,
+          interactive: instance.node.properties.interactive
+        });
+      }
+      instance.children.forEach(traverse);
+    };
+    if (this.rootInstance) traverse(this.rootInstance);
+    return {
+      spatialMemory,
+      hologramState,
+      state: this.state,
+      builtins: this.builtins,
+      vr: this.vrContext
+    };
+  }
+  reset() {
+    this.unmount();
+    this.state = createState({});
+    this.mounted = false;
+  }
+  updateAnimations() {
+    this.update(1 / 60);
+  }
+  updateParticles(delta) {
+    this.update(delta);
+  }
+  getHologramStates() {
+    return this.getContext().hologramState;
+  }
+  setState(updates) {
+    this.state.update(updates);
+  }
+  emit(event, payload) {
+    const handlers = this.eventHandlers.get(event);
+    if (handlers) {
+      handlers.forEach((handler) => {
+        try {
+          handler(payload);
+        } catch (error) {
+          console.error(`Error in event handler for ${event}:`, error);
+        }
+      });
+    }
+    eventBus.emit(event, payload);
+  }
+  updateEntity(id, properties) {
+    if (!this.rootInstance) return false;
+    let found = false;
+    const traverse = (instance) => {
+      if (instance.node.id === id) {
+        instance.node.properties = { ...instance.node.properties, ...properties };
+        if (this.options.renderer && instance.renderedNode) {
+          this.options.renderer.updateElement(instance.renderedNode, properties);
+        }
+        found = true;
+      }
+      instance.children.forEach(traverse);
+    };
+    traverse(this.rootInstance);
+    return found;
+  }
+  on(event, handler) {
+    if (!this.eventHandlers.has(event)) {
+      this.eventHandlers.set(event, /* @__PURE__ */ new Set());
+    }
+    this.eventHandlers.get(event).add(handler);
+    return () => {
+      this.eventHandlers.get(event)?.delete(handler);
+    };
+  }
+  // ==========================================================================
+  // HOT-RELOAD & MIGRATION
+  // ==========================================================================
+  async hotReload(newAst) {
+    const newTemplates = this.findAllTemplates(newAst.root);
+    for (const [name, newNode] of newTemplates) {
+      const oldNode = this.templates.get(name);
+      if (oldNode && newNode.version !== oldNode.version) {
+        const result = await this.hotReloader.reload(newNode);
+        if (result.success) {
+          this.templates.set(name, newNode);
+        } else {
+          console.error(`[Hot-Reload] Failed for template "${name}":`, result.error);
+        }
+      } else {
+        this.templates.set(name, newNode);
+        this.hotReloader.registerTemplate(newNode);
+      }
+    }
+    if (newAst.version !== void 0 && newAst.version !== this.ast.version) {
+      const result = await this.hotReloader.reload({
+        type: "Template",
+        name: "@program",
+        version: newAst.version,
+        migrations: newAst.migrations,
+        state: { type: "State", properties: [] },
+        properties: [],
+        actions: [],
+        traits: []
+      });
+      if (!result.success) {
+        console.error(`[Hot-Reload] Global program migration failed:`, result.error);
+      } else {
+      }
+    }
+    this.ast = newAst;
+  }
+  /**
+   * Creates a Map proxy that reflects the reactive state.
+   * This allowed the HotReloader (designed for Map-based state) to work with
+   * the runtime's Record-based reactive state.
+   */
+  createStateMapProxy() {
+    const runtime = this;
+    return {
+      get(key) {
+        return runtime.state.get(key);
+      },
+      set(key, value) {
+        runtime.state.set(key, value);
+        return this;
+      },
+      has(key) {
+        return runtime.state.get(key) !== void 0;
+      },
+      delete(key) {
+        runtime.state.set(key, void 0);
+        return true;
+      },
+      clear() {
+      },
+      get size() {
+        return Object.keys(runtime.state.getSnapshot()).length;
+      },
+      forEach(cb) {
+        const snap = runtime.state.getSnapshot();
+        Object.entries(snap).forEach(([k, v]) => cb(v, k, this));
+      },
+      [Symbol.iterator]() {
+        const snap = runtime.state.getSnapshot();
+        return Object.entries(snap)[Symbol.iterator]();
+      },
+      entries() {
+        const snap = runtime.state.getSnapshot();
+        return Object.entries(snap)[Symbol.iterator]();
+      },
+      keys() {
+        const snap = runtime.state.getSnapshot();
+        return Object.keys(snap)[Symbol.iterator]();
+      },
+      values() {
+        const snap = runtime.state.getSnapshot();
+        return Object.values(snap)[Symbol.iterator]();
+      }
+    };
+  }
+  findInstanceById(id, root = this.rootInstance) {
+    if (!root) return null;
+    if (root.__holo_id === id || root.node.id === id) return root;
+    for (const child of root.children) {
+      const found = this.findInstanceById(id, child);
+      if (found) return found;
+    }
+    return null;
+  }
+  /**
+   * Executes a block of HoloScript+ statements
+   */
+  async executeStatementBlock(instance, body) {
+    for (const stmt of body) {
+      await this.executeStatement(instance, stmt);
+    }
+  }
+  /**
+   * Executes a single HoloScript+ statement
+   */
+  async executeStatement(instance, stmt) {
+    const context = {
+      ...this.state.getSnapshot(),
+      node: instance.node,
+      self: instance.node,
+      props: instance.node.properties || {}
+    };
+    this.evaluator.updateContext(context);
+    try {
+      switch (stmt.type) {
+        case "Assignment": {
+          const value = this.evaluator.evaluate(String(stmt.value));
+          const target = stmt.target;
+          if (target.startsWith("props.")) {
+            const propName = target.split(".")[1];
+            if (instance.node.properties) {
+              instance.node.properties[propName] = value;
+            }
+          } else if (target.startsWith("state.")) {
+            const stateKey = target.split(".")[1];
+            this.state.set(stateKey, value);
+          } else {
+            context[target] = value;
+          }
+          break;
+        }
+        case "MethodCall": {
+          const args = (stmt.arguments || []).map((arg) => this.evaluator.evaluate(String(arg)));
+          const method = this.builtins[stmt.method];
+          if (typeof method === "function") {
+            await method(...args);
+          }
+          break;
+        }
+        case "IfStatement": {
+          const condition = this.evaluator.evaluate(String(stmt.condition));
+          if (condition) {
+            await this.executeStatementBlock(instance, stmt.consequent);
+          } else if (stmt.alternate) {
+            await this.executeStatementBlock(instance, stmt.alternate);
+          }
+          break;
+        }
+        case "EmitStatement": {
+          const data = stmt.data ? this.evaluator.evaluate(String(stmt.data)) : void 0;
+          this.emit(stmt.event, data);
+          break;
+        }
+        // Add more statement types as needed
+        default:
+          console.warn(`[Runtime] Unsupported statement type: ${stmt.type}`);
+      }
+    } catch (error) {
+      console.error(`[Runtime] Execution error in statement ${stmt.type}:`, error);
+    }
+  }
+  migrateInstancesOfTemplate(name, oldVersion, newTemplate) {
+    const instances = this.findAllInstancesOfTemplate(name);
+    for (const instance of instances) {
+      this.migrateInstance(instance, oldVersion, newTemplate);
+    }
+  }
+  findAllInstancesOfTemplate(name, root = this.rootInstance) {
+    if (!root) return [];
+    const results = [];
+    if (root.templateName === name) {
+      results.push(root);
+    }
+    for (const child of root.children) {
+      results.push(...this.findAllInstancesOfTemplate(name, child));
+    }
+    return results;
+  }
+  migrateInstance(instance, oldVersion, newTemplate) {
+    const _context = this.createTraitContext(instance);
+    const currentProperties = { ...instance.node.properties || {} };
+    const newNode = this.cloneNodeWithContext(newTemplate, {
+      position: currentProperties.position
+    });
+    const oldNode = instance.node;
+    Object.keys(oldNode).forEach(
+      (key) => delete oldNode[key]
+    );
+    Object.assign(oldNode, newNode);
+    oldNode.properties = { ...oldNode.properties || {}, ...currentProperties };
+    instance.templateVersion = newTemplate.version;
+    const migrations = newTemplate.migrations || [];
+    const migration = migrations.find((m) => m.fromVersion === oldVersion);
+    if (migration && migration.body) {
+      this.executeMigrationCode(instance, migration.body);
+    }
+    if (this.options.renderer && instance.renderedNode) {
+      const properties = this.evaluateProperties(instance.node.properties || {});
+      this.options.renderer.updateElement(instance.renderedNode, properties);
+    }
+  }
+  executeMigrationCode(instance, code) {
+    const stateProxy = new Proxy(this.state, {
+      get: (target, prop) => {
+        if (typeof prop === "string" && prop in target && typeof target[prop] === "function") {
+          return target[prop].bind(target);
+        }
+        return target.get(String(prop));
+      },
+      set: (target, prop, value) => {
+        target.set(String(prop), value);
+        return true;
+      }
+    });
+    const sandbox = {
+      ...this.builtins,
+      state: stateProxy,
+      node: instance.node,
+      self: instance.node,
+      props: instance.node.properties || {},
+      renameProperty: (oldName, newName) => {
+        if (instance.node.properties && instance.node.properties[oldName] !== void 0) {
+          instance.node.properties[newName] = instance.node.properties[oldName];
+          delete instance.node.properties[oldName];
+        }
+      }
+    };
+    try {
+      const fn = new Function(...Object.keys(sandbox), code);
+      fn(...Object.values(sandbox));
+    } catch (error) {
+      console.error(`[Runtime] Migration execution failed in "${instance.templateName}":`, error);
+    }
+  }
+  // ==========================================================================
+  // VR INTEGRATION
+  // ==========================================================================
+  updateVRContext(context) {
+    this.vrContext = context;
+  }
+  handleVREvent(event, node) {
+    const instance = this.findInstance(node);
+    if (!instance) return;
+    const traitContext = this.createTraitContext(instance);
+    this.traitRegistry.handleEventForAllTraits(node, traitContext, event);
+    const hookMapping = {
+      grab_start: "on_grab",
+      grab_end: "on_release",
+      hover_enter: "on_hover_enter",
+      hover_exit: "on_hover_exit",
+      point_enter: "on_point_enter",
+      point_exit: "on_point_exit",
+      collision: "on_collision",
+      trigger_enter: "on_trigger_enter",
+      trigger_exit: "on_trigger_exit",
+      click: "on_click"
+    };
+    const hook = hookMapping[event.type];
+    if (hook) {
+      this.callLifecycle(instance, hook, event);
+    }
+  }
+  findInstance(node, root = this.rootInstance) {
+    if (!root) return null;
+    if (root.node === node) return root;
+    for (const child of root.children) {
+      const found = this.findInstance(node, child);
+      if (found) return found;
+    }
+    return null;
+  }
+  // ==========================================================================
+  // TEMPLATES & SPAWNING
+  // ==========================================================================
+  registerTemplate(name, node) {
+    this.templates.set(name, node);
+  }
+  spawnTemplate(name, position) {
+    const template = this.templates.get(name);
+    if (!template) {
+      throw new Error(`Template "${name}" not found`);
+    }
+    const cloned = this.cloneNodeWithContext(template, { position });
+    if (!cloned.properties) cloned.properties = {};
+    cloned.properties.position = position;
+    if (this.rootInstance) {
+      const instance = this.instantiateNode(cloned, this.rootInstance);
+      instance.templateName = name;
+      instance.templateVersion = typeof template.version === "number" ? template.version : parseInt(template.version || "0");
+      this.rootInstance.children.push(instance);
+      if (this.options.renderer && this.rootInstance.renderedNode) {
+        this.options.renderer.appendChild(this.rootInstance.renderedNode, instance.renderedNode);
+      }
+      this.callLifecycle(instance, "on_mount");
+    }
+    return cloned;
+  }
+  destroyNode(node) {
+    const instance = this.findInstance(node);
+    if (!instance) return;
+    this.callLifecycle(instance, "on_unmount");
+    if (instance.parent) {
+      const index = instance.parent.children.indexOf(instance);
+      if (index > -1) {
+        instance.parent.children.splice(index, 1);
+      }
+      if (this.options.renderer && instance.parent.renderedNode && instance.renderedNode) {
+        this.options.renderer.removeChild(instance.parent.renderedNode, instance.renderedNode);
+      }
+    }
+    this.destroyInstance(instance);
+  }
+};
+function createBuiltins(runtime) {
+  return {
+    log: (...args) => console.log("[HoloScript]", ...args),
+    warn: (...args) => console.warn("[HoloScript]", ...args),
+    error: (...args) => console.error("[HoloScript]", ...args),
+    Math,
+    range: (start, end, step = 1) => {
+      const result = [];
+      if (step > 0) {
+        for (let i = start; i < end; i += step) {
+          result.push(i);
+        }
+      } else if (step < 0) {
+        for (let i = start; i > end; i += step) {
+          result.push(i);
+        }
+      }
+      return result;
+    },
+    interpolate_color: (t, from, to) => {
+      const parseHex = (hex) => {
+        const clean = hex.replace("#", "");
+        return [
+          parseInt(clean.substring(0, 2), 16),
+          parseInt(clean.substring(2, 4), 16),
+          parseInt(clean.substring(4, 6), 16)
+        ];
+      };
+      const toHex = (r, g, b) => {
+        const clamp = (v) => Math.max(0, Math.min(255, Math.round(v)));
+        return `#${clamp(r).toString(16).padStart(2, "0")}${clamp(g).toString(16).padStart(2, "0")}${clamp(b).toString(16).padStart(2, "0")}`;
+      };
+      const [r1, g1, b1] = typeof from === "string" ? parseHex(from) : [from.r || 0, from.g || 0, from.b || 0];
+      const [r2, g2, b2] = typeof to === "string" ? parseHex(to) : [to.r || 0, to.g || 0, to.b || 0];
+      return toHex(r1 + (r2 - r1) * t, g1 + (g2 - g1) * t, b1 + (b2 - b1) * t);
+    },
+    distance_to: (point) => {
+      const viewer = runtime.vrContext.headset.position;
+      return Math.sqrt(
+        Math.pow(point.x - viewer.x, 2) + Math.pow(point.y - viewer.y, 2) + Math.pow(point.z - viewer.z, 2)
+      );
+    },
+    distance_to_viewer: () => {
+      return 0;
+    },
+    hand_position: (handId) => {
+      const hand = handId === "left" ? runtime.vrContext.hands.left : runtime.vrContext.hands.right;
+      return hand?.position || { x: 0, y: 0, z: 0 };
+    },
+    hand_velocity: (handId) => {
+      const hand = handId === "left" ? runtime.vrContext.hands.left : runtime.vrContext.hands.right;
+      return hand?.velocity || { x: 0, y: 0, z: 0 };
+    },
+    dominant_hand: () => {
+      return runtime.vrContext.hands.right || runtime.vrContext.hands.left || {
+        id: "right",
+        position: [0, 0, 0],
+        rotation: { x: 0, y: 0, z: 0 },
+        velocity: { x: 0, y: 0, z: 0 },
+        gripStrength: 0,
+        pinchStrength: 0
+      };
+    },
+    play_sound: (source, options) => {
+      runtime.emit("play_sound", { source, ...options });
+    },
+    haptic_feedback: (hand, intensity) => {
+      const handId = typeof hand === "string" ? hand : hand.id;
+      runtime.emit("haptic", { hand: handId, intensity });
+    },
+    haptic_pulse: (intensity) => {
+      runtime.emit("haptic", { hand: "both", intensity });
+    },
+    apply_velocity: (node, velocity) => {
+      runtime.emit("apply_velocity", { node, velocity });
+    },
+    spawn: (template, position) => {
+      return runtime.spawnTemplate(template, position);
+    },
+    assistant_generate: (prompt, context) => {
+      runtime.emit("assistant_generate", { prompt, context });
+    },
+    destroy: (node) => {
+      runtime.destroyNode(node);
+    },
+    api_call: async (url, method, body) => {
+      const response = await fetch(url, {
+        method,
+        headers: body ? { "Content-Type": "application/json" } : void 0,
+        body: body ? JSON.stringify(body) : void 0
+      });
+      return response.json();
+    },
+    open_modal: (modalId) => {
+      runtime.emit("open_modal", { id: modalId });
+    },
+    close_modal: (modalId) => {
+      runtime.emit("close_modal", { id: modalId });
+    },
+    setTimeout: (callback, delay) => {
+      return window.setTimeout(callback, delay);
+    },
+    clearTimeout: (id) => {
+      window.clearTimeout(id);
+    },
+    animate: (node, properties, options = {}) => {
+      if (options.sync) {
+        runtime.emit("network_animation", {
+          objectId: node.id,
+          properties,
+          options,
+          timestamp: Date.now()
+        });
+      }
+      if (node.properties) {
+        Object.assign(node.properties, properties);
+      }
+      runtime.emit("animate", { node, properties, options });
+    },
+    transition: (targetScene, options = {}) => {
+      if (options.audio) {
+        runtime.emit("play_sound", { source: options.audio });
+      }
+      runtime.emit("scene_transition", { target: targetScene, options });
+    }
+  };
+}
+function createRuntime(ast, options = {}) {
+  return new HoloScriptPlusRuntimeImpl(ast, options);
+}
+
+// src/runtime/InstancedRenderer.ts
+function getThree() {
+  return globalThis.THREE;
+}
+var InstancedRenderer = class {
+  batches = /* @__PURE__ */ new Map();
+  objects = /* @__PURE__ */ new Map();
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  scene;
+  // THREE.Scene
+  maxInstancesPerBatch = 1e3;
+  // Configurable
+  enabled = true;
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  constructor(scene, maxInstancesPerBatch = 1e3) {
+    this.scene = scene;
+    this.maxInstancesPerBatch = maxInstancesPerBatch;
+  }
+  /**
+   * Add object to instanced rendering
+   */
+  addInstance(id, geometryType, materialType, position, rotation = [0, 0, 0], scale = [1, 1, 1], color) {
+    if (!this.enabled) return false;
+    const batchKey = `${geometryType}_${materialType}`;
+    let batch = this.batches.get(batchKey);
+    if (!batch) {
+      const newBatch = this.createBatch(batchKey, geometryType, materialType);
+      if (!newBatch) return false;
+      batch = newBatch;
+    }
+    if (batch.count >= batch.maxInstances && batch.freeIndices.length === 0) {
+      console.warn(
+        `[InstancedRenderer] Batch ${batchKey} is full (${batch.maxInstances} instances)`
+      );
+      return false;
+    }
+    const instanceIndex = batch.freeIndices.length > 0 ? batch.freeIndices.pop() : batch.count++;
+    const matrix = this.createTransformMatrix(position, rotation, scale);
+    const instance = {
+      id,
+      batchKey,
+      instanceIndex,
+      matrix,
+      color,
+      visible: true
+    };
+    this.objects.set(id, instance);
+    batch.instanceMap.set(id, instanceIndex);
+    batch.instancedMesh.setMatrixAt(instanceIndex, this.arrayToMatrix4(matrix));
+    if (color && batch.instancedMesh.instanceColor) {
+      const THREE = getThree();
+      batch.instancedMesh.setColorAt(instanceIndex, new THREE.Color(color[0], color[1], color[2]));
+    }
+    batch.needsUpdate = true;
+    return true;
+  }
+  /**
+   * Remove instance from rendering
+   */
+  removeInstance(id) {
+    const instance = this.objects.get(id);
+    if (!instance) return false;
+    const batch = this.batches.get(instance.batchKey);
+    if (!batch) return false;
+    const matrix = this.createTransformMatrix([999999, 999999, 999999], [0, 0, 0], [0, 0, 0]);
+    batch.instancedMesh.setMatrixAt(instance.instanceIndex, this.arrayToMatrix4(matrix));
+    batch.needsUpdate = true;
+    batch.freeIndices.push(instance.instanceIndex);
+    batch.instanceMap.delete(id);
+    this.objects.delete(id);
+    return true;
+  }
+  /**
+   * Update instance transform
+   */
+  updateInstance(id, position, rotation, scale) {
+    const instance = this.objects.get(id);
+    if (!instance) return false;
+    const batch = this.batches.get(instance.batchKey);
+    if (!batch) return false;
+    const current = this.matrixToTransform(instance.matrix);
+    const newPosition = position || current.position;
+    const newRotation = rotation || current.rotation;
+    const newScale = scale || current.scale;
+    const matrix = this.createTransformMatrix(newPosition, newRotation, newScale);
+    instance.matrix = matrix;
+    batch.instancedMesh.setMatrixAt(instance.instanceIndex, this.arrayToMatrix4(matrix));
+    batch.needsUpdate = true;
+    return true;
+  }
+  /**
+   * Update instance color
+   */
+  updateInstanceColor(id, color) {
+    const instance = this.objects.get(id);
+    if (!instance) return false;
+    const batch = this.batches.get(instance.batchKey);
+    if (!batch || !batch.instancedMesh.instanceColor) return false;
+    const THREE = getThree();
+    batch.instancedMesh.setColorAt(
+      instance.instanceIndex,
+      new THREE.Color(color[0], color[1], color[2])
+    );
+    instance.color = color;
+    batch.needsUpdate = true;
+    return true;
+  }
+  /**
+   * Update all batches (call once per frame)
+   */
+  update() {
+    for (const batch of this.batches.values()) {
+      if (batch.needsUpdate) {
+        batch.instancedMesh.instanceMatrix.needsUpdate = true;
+        if (batch.instancedMesh.instanceColor) {
+          batch.instancedMesh.instanceColor.needsUpdate = true;
+        }
+        batch.needsUpdate = false;
+      }
+    }
+  }
+  /**
+   * Create a new batch
+   */
+  createBatch(key, geometryType, materialType) {
+    if (!getThree()) return null;
+    const THREE = getThree();
+    const geometry = this.createGeometry(geometryType);
+    if (!geometry) return null;
+    const material = this.createMaterial(materialType);
+    if (!material) return null;
+    const instancedMesh = new THREE.InstancedMesh(geometry, material, this.maxInstancesPerBatch);
+    instancedMesh.instanceMatrix.setUsage(THREE.DynamicDrawUsage);
+    instancedMesh.castShadow = true;
+    instancedMesh.receiveShadow = true;
+    instancedMesh.instanceColor = new THREE.InstancedBufferAttribute(
+      new Float32Array(this.maxInstancesPerBatch * 3),
+      3
+    );
+    this.scene.add(instancedMesh);
+    const batch = {
+      key,
+      geometryType,
+      materialType,
+      instancedMesh,
+      maxInstances: this.maxInstancesPerBatch,
+      count: 0,
+      instanceMap: /* @__PURE__ */ new Map(),
+      freeIndices: [],
+      needsUpdate: false
+    };
+    this.batches.set(key, batch);
+    return batch;
+  }
+  /**
+   * Create geometry by type
+   */
+  createGeometry(type) {
+    const THREE = getThree();
+    const geometryMap = {
+      // ===== CORE PRIMITIVES =====
+      box: () => new THREE.BoxGeometry(1, 1, 1),
+      sphere: () => new THREE.SphereGeometry(0.5, 16, 16),
+      cylinder: () => new THREE.CylinderGeometry(0.5, 0.5, 1, 16),
+      cone: () => new THREE.ConeGeometry(0.5, 1, 16),
+      plane: () => new THREE.PlaneGeometry(1, 1),
+      torus: () => new THREE.TorusGeometry(0.5, 0.2, 16, 50),
+      ring: () => new THREE.RingGeometry(0.25, 0.5, 16),
+      circle: () => new THREE.CircleGeometry(0.5, 16),
+      // ===== ADVANCED GEOMETRIES =====
+      capsule: () => new THREE.CapsuleGeometry(0.25, 0.5, 4, 8),
+      torusknot: () => new THREE.TorusKnotGeometry(0.5, 0.15, 64, 8, 2, 3),
+      // ===== POLYHEDRONS =====
+      dodecahedron: () => new THREE.DodecahedronGeometry(0.5, 0),
+      icosahedron: () => new THREE.IcosahedronGeometry(0.5, 0),
+      octahedron: () => new THREE.OctahedronGeometry(0.5, 0),
+      tetrahedron: () => new THREE.TetrahedronGeometry(0.5, 0)
+    };
+    return geometryMap[type]?.() || new THREE.BoxGeometry(1, 1, 1);
+  }
+  /**
+   * Create material by type
+   */
+  createMaterial(_type) {
+    const THREE = getThree();
+    return new THREE.MeshStandardMaterial({
+      color: 16777215,
+      roughness: 0.7,
+      metalness: 0.3,
+      vertexColors: true
+      // Enable per-instance colors
+    });
+  }
+  /**
+   * Create transform matrix from position, rotation, scale
+   */
+  createTransformMatrix(position, rotation, scale) {
+    const matrix = new Float32Array(16);
+    const cx = Math.cos(rotation[0]);
+    const sx = Math.sin(rotation[0]);
+    const cy = Math.cos(rotation[1]);
+    const sy = Math.sin(rotation[1]);
+    const cz = Math.cos(rotation[2]);
+    const sz = Math.sin(rotation[2]);
+    matrix[0] = cy * cz * scale[0];
+    matrix[1] = cy * sz * scale[0];
+    matrix[2] = -sy * scale[0];
+    matrix[3] = 0;
+    matrix[4] = (sx * sy * cz - cx * sz) * scale[1];
+    matrix[5] = (sx * sy * sz + cx * cz) * scale[1];
+    matrix[6] = sx * cy * scale[1];
+    matrix[7] = 0;
+    matrix[8] = (cx * sy * cz + sx * sz) * scale[2];
+    matrix[9] = (cx * sy * sz - sx * cz) * scale[2];
+    matrix[10] = cx * cy * scale[2];
+    matrix[11] = 0;
+    matrix[12] = position[0];
+    matrix[13] = position[1];
+    matrix[14] = position[2];
+    matrix[15] = 1;
+    return matrix;
+  }
+  /**
+   * Convert Float32Array to THREE.Matrix4
+   */
+  arrayToMatrix4(array) {
+    const THREE = getThree();
+    const matrix = new THREE.Matrix4();
+    matrix.fromArray(array);
+    return matrix;
+  }
+  /**
+   * Extract transform from matrix
+   */
+  matrixToTransform(matrix) {
+    const THREE = getThree();
+    if (THREE) {
+      const m = new THREE.Matrix4().fromArray(matrix);
+      const pos = new THREE.Vector3();
+      const quat = new THREE.Quaternion();
+      const scl = new THREE.Vector3();
+      m.decompose(pos, quat, scl);
+      const euler = new THREE.Euler().setFromQuaternion(quat, "XYZ");
+      return {
+        position: [pos.x, pos.y, pos.z],
+        rotation: [euler.x, euler.y, euler.z],
+        scale: [scl.x, scl.y, scl.z]
+      };
+    }
+    const position = [matrix[12], matrix[13], matrix[14]];
+    const sx = Math.sqrt(matrix[0] * matrix[0] + matrix[1] * matrix[1] + matrix[2] * matrix[2]);
+    const sy = Math.sqrt(matrix[4] * matrix[4] + matrix[5] * matrix[5] + matrix[6] * matrix[6]);
+    const sz = Math.sqrt(matrix[8] * matrix[8] + matrix[9] * matrix[9] + matrix[10] * matrix[10]);
+    const scale = [sx, sy, sz];
+    let rx = 0, ry = 0, rz = 0;
+    if (sx !== 0 && sy !== 0 && sz !== 0) {
+      const m13 = matrix[8] / sz;
+      ry = Math.asin(Math.max(-1, Math.min(1, m13)));
+      if (Math.abs(m13) < 0.999999) {
+        rx = Math.atan2(-matrix[9] / sz, matrix[10] / sz);
+        rz = Math.atan2(-matrix[4] / sy, matrix[0] / sx);
+      } else {
+        rx = Math.atan2(matrix[6] / sy, matrix[5] / sy);
+        rz = 0;
+      }
+    }
+    const rotation = [rx, ry, rz];
+    return { position, rotation, scale };
+  }
+  /**
+   * Get statistics
+   */
+  getStatistics() {
+    let totalInstances = 0;
+    let memoryUsage = 0;
+    for (const batch of this.batches.values()) {
+      totalInstances += batch.count - batch.freeIndices.length;
+      memoryUsage += batch.count * 76 / (1024 * 1024);
+    }
+    const drawCalls = this.batches.size;
+    const nonInstancedDrawCalls = totalInstances;
+    const improvement = nonInstancedDrawCalls > 0 ? `${((1 - drawCalls / nonInstancedDrawCalls) * 100).toFixed(1)}% fewer draw calls` : "N/A";
+    return {
+      batchCount: this.batches.size,
+      totalInstances,
+      drawCalls,
+      memoryUsage: parseFloat(memoryUsage.toFixed(2)),
+      improvement
+    };
+  }
+  /**
+   * Enable/disable instanced rendering
+   */
+  setEnabled(enabled) {
+    this.enabled = enabled;
+  }
+  /**
+   * Clear all batches
+   */
+  clear() {
+    for (const batch of this.batches.values()) {
+      this.scene.remove(batch.instancedMesh);
+      batch.instancedMesh.geometry.dispose();
+      batch.instancedMesh.material.dispose();
+    }
+    this.batches.clear();
+    this.objects.clear();
+  }
+  /**
+   * Get batch for inspection
+   */
+  getBatch(key) {
+    return this.batches.get(key);
+  }
+  /**
+   * Get all batch keys
+   */
+  getBatchKeys() {
+    return Array.from(this.batches.keys());
+  }
+};
+
+// src/runtime/AssetStreamer.ts
+var StreamPriority = /* @__PURE__ */ ((StreamPriority2) => {
+  StreamPriority2[StreamPriority2["IMMEDIATE"] = 0] = "IMMEDIATE";
+  StreamPriority2[StreamPriority2["PREDICTIVE_HIGH"] = 1] = "PREDICTIVE_HIGH";
+  StreamPriority2[StreamPriority2["PREDICTIVE_LOW"] = 2] = "PREDICTIVE_LOW";
+  StreamPriority2[StreamPriority2["BACKGROUND"] = 3] = "BACKGROUND";
+  return StreamPriority2;
+})(StreamPriority || {});
+var assetStreamerRegistry = /* @__PURE__ */ new Map();
+function registerAssetStreamer(name, streamer) {
+  assetStreamerRegistry.set(name, streamer);
+}
+function getAssetStreamer(name) {
+  return assetStreamerRegistry.get(name);
+}
 export {
   MATERIAL_PRESETS as ADVANCED_PBR_PRESETS,
   AdvancedLightingManager,
@@ -3716,8 +6720,11 @@ export {
   FogSystem,
   GIProbeGrid,
   gameplay_exports as Gameplay,
+  GaussianSplatExtractor,
+  HoloScriptPlusRuntimeImpl,
   hologram_exports as Hologram,
   input_exports as Input,
+  InstancedRenderer,
   lod_exports as LOD,
   LODBridge,
   LODGenerator,
@@ -3757,8 +6764,11 @@ export {
   STANDARD_VERTEX_SHADER,
   scene_exports as Scene,
   ShaderGraph,
+  simulation_exports as Simulation,
   SpatialEngine,
+  StreamPriority,
   terrain_exports as Terrain,
+  TetGenWasmMesher,
   tilemap_exports as Tilemap,
   TransitionScheduler,
   UNLIT_FRAGMENT_SHADER,
@@ -3779,6 +6789,7 @@ export {
   applyFilmGrain,
   applyMotionBlur,
   applyVignette,
+  assetStreamerRegistry,
   blendDetailNormal,
   blendTAA,
   buildCircleCookie,
@@ -3812,6 +6823,7 @@ export {
   createMeshletGenerator,
   createMobileLODManager,
   createMobileMemoryPool,
+  createRuntime,
   createSH9,
   createSolidTexture,
   createStandardLODConfig,
@@ -3832,6 +6844,7 @@ export {
   generateLODs,
   generateMeshlets,
   geometrySmith,
+  getAssetStreamer,
   getAtlasEfficiency,
   getRecommendedLODCount,
   getRectUV,
@@ -3848,6 +6861,7 @@ export {
   pathTrace,
   prerenderHTML,
   rectSolidAngle,
+  registerAssetStreamer,
   renderPDF,
   renderScreenshot,
   rgbaToHex,