@holoscript/core 6.0.3 → 7.0.0

package/dist/chunk-C2QHVHZF.js

@@ -1,4066 +0,0 @@
-import { HoloScriptCodeParser } from './chunk-EPWRXL6S.js';
-import { mitosisHandler, orbitalHandler, WebSocketTransport } from './chunk-ENV7K6XA.js';
-import { logger } from './chunk-PHENW4MQ.js';
-import { __decorateClass } from './chunk-32TWR3HE.js';
-import { WebSocketServer, WebSocket } from 'ws';
-import { AttentionEngine, TimeManager } from '@holoscript/engine/orbital';
-import * as fs from 'fs';
-import * as path from 'path';
-import { stateMachineInterpreter } from '@holoscript/engine/runtime/StateMachineInterpreter';
-import { MemoryConsolidator } from '@holoscript/framework';
-import { BaseVoiceSynthesizer } from '@holoscript/engine/runtime/BaseVoiceSynthesizer';
-import { registerVoiceSynthesizer } from '@holoscript/engine/runtime/VoiceSynthesizer';
-import { LocalEmotionDetector } from '@holoscript/engine/runtime/LocalEmotionDetector';
-import { registerEmotionDetector } from '@holoscript/engine/runtime/EmotionDetector';
-import { MockSpeechRecognizer } from '@holoscript/engine/runtime/MockSpeechRecognizer';
-import { registerSpeechRecognizer } from '@holoscript/engine/runtime/SpeechRecognizer';
-import { MethodMemoize, ObjectPool } from '@holoscript/engine/runtime/RuntimeOptimization';
-
-// src/ReactiveState.ts
-var ReactiveState = class {
-  constructor(initialState = {}) {
-    this.subscribers = /* @__PURE__ */ new Set();
-    this.state = { ...initialState };
-    this.proxy = this.createReactiveProxy(this.state);
-  }
-  createReactiveProxy(target) {
-    const self = this;
-    return new Proxy(target, {
-      get(obj, key) {
-        const val = obj[key];
-        if (val && typeof val === "object" && !Array.isArray(val)) {
-          return self.createReactiveProxy(val);
-        }
-        return val;
-      },
-      set(obj, key, value) {
-        const oldVal = obj[key];
-        obj[key] = value;
-        if (oldVal !== value) {
-          self.notify();
-        }
-        return true;
-      }
-    });
-  }
-  get(key) {
-    return this.proxy[key];
-  }
-  set(key, value) {
-    this.proxy[key] = value;
-  }
-  has(key) {
-    return this.proxy[key] !== void 0;
-  }
-  update(updates) {
-    Object.assign(this.proxy, updates);
-  }
-  subscribe(callback) {
-    this.subscribers.add(callback);
-    return () => this.subscribers.delete(callback);
-  }
-  getSnapshot() {
-    return { ...this.state };
-  }
-  getProxy() {
-    return this.proxy;
-  }
-  notify() {
-    this.subscribers.forEach((cb) => cb(this.getSnapshot()));
-  }
-};
-var ExpressionEvaluator = class {
-  constructor(context = {}) {
-    this.context = context;
-  }
-  evaluate(expression) {
-    if (typeof expression !== "string") return expression;
-    const dangerousPatterns = [
-      /\beval\s*\(/,
-      /\brequire\s*\(/,
-      /\bimport\s*\(/,
-      /\bprocess\b/,
-      /\bglobalThis?\b/,
-      /\b__dirname\b/,
-      /\b__filename\b/,
-      /\bfs\b/,
-      /\bchild_process\b/,
-      // Prototype chain / constructor escape
-      /\bconstructor\b/,
-      /\b__proto__\b/,
-      /\bprototype\b/,
-      /\bObject\s*\.\s*(create|definePropert|getProto|assign|setProto)/,
-      /\bReflect\b/,
-      /\bProxy\b/,
-      /\bFunction\b/,
-      /\barguments\b/
-    ];
-    for (const pattern of dangerousPatterns) {
-      if (pattern.test(expression)) {
-        return void 0;
-      }
-    }
-    if (expression.includes("${")) {
-      const trimmed = expression.trim();
-      const match = trimmed.match(/^\$\{([^}]+)\}$/);
-      if (match) {
-        return this.evaluate(match[1]);
-      }
-      return this.interpolate(expression);
-    }
-    const keys = Object.keys(this.context);
-    const values = Object.values(this.context);
-    try {
-      const fn = new Function(...keys, `"use strict"; return (${expression});`);
-      return fn.call(null, ...values);
-    } catch (_e) {
-      return expression;
-    }
-  }
-  interpolate(str) {
-    return str.replace(/\$\{([^}]+)\}/g, (_, expr) => {
-      const val = this.evaluate(expr);
-      return val !== void 0 ? String(val) : "";
-    });
-  }
-  updateContext(updates) {
-    Object.assign(this.context, updates);
-  }
-  setContext(context) {
-    this.context = { ...context };
-  }
-};
-function createState(initial = {}) {
-  return new ReactiveState(initial);
-}
-
-// src/events/EventBus.ts
-var EventBus = class {
-  constructor() {
-    this.listeners = /* @__PURE__ */ new Map();
-    this.history = [];
-    this.maxHistory = 100;
-    this.nextId = 0;
-    this.paused = false;
-  }
-  /**
-   * Subscribe to an event.
-   */
-  on(event, callback, priority = 0) {
-    const id = this.nextId++;
-    const list = this.listeners.get(event) || [];
-    list.push({ callback, priority, once: false, id });
-    list.sort((a, b) => b.priority - a.priority);
-    this.listeners.set(event, list);
-    return id;
-  }
-  /**
-   * Subscribe to an event once (auto-removes after first fire).
-   */
-  once(event, callback, priority = 0) {
-    const id = this.nextId++;
-    const list = this.listeners.get(event) || [];
-    list.push({ callback, priority, once: true, id });
-    list.sort((a, b) => b.priority - a.priority);
-    this.listeners.set(event, list);
-    return id;
-  }
-  /**
-   * Unsubscribe by listener ID.
-   */
-  off(listenerId) {
-    for (const [event, list] of this.listeners) {
-      const idx = list.findIndex((l) => l.id === listenerId);
-      if (idx !== -1) {
-        list.splice(idx, 1);
-        return;
-      }
-    }
-  }
-  /**
-   * Unsubscribe all listeners for an event.
-   */
-  offAll(event) {
-    this.listeners.delete(event);
-  }
-  /**
-   * Emit an event to all subscribers.
-   */
-  emit(event, data) {
-    if (this.paused) return;
-    this.history.push({ event, data, timestamp: Date.now() });
-    if (this.history.length > this.maxHistory) this.history.shift();
-    const list = this.listeners.get(event);
-    if (list) {
-      const toRemove = [];
-      for (const listener of list) {
-        listener.callback(data);
-        if (listener.once) toRemove.push(listener.id);
-      }
-      for (const id of toRemove) {
-        const idx = list.findIndex((l) => l.id === id);
-        if (idx !== -1) list.splice(idx, 1);
-      }
-    }
-    if (event !== "*") {
-      const wildcardList = this.listeners.get("*");
-      if (wildcardList) {
-        for (const listener of wildcardList) {
-          listener.callback({ event, data });
-        }
-      }
-    }
-  }
-  /**
-   * Get event history.
-   */
-  getHistory() {
-    return [...this.history];
-  }
-  /**
-   * Get listener count for an event.
-   */
-  listenerCount(event) {
-    return this.listeners.get(event)?.length || 0;
-  }
-  /**
-   * Pause/resume event emission.
-   */
-  setPaused(paused) {
-    this.paused = paused;
-  }
-  /**
-   * Clear all listeners and history.
-   */
-  clear() {
-    this.listeners.clear();
-    this.history = [];
-  }
-};
-var sharedBus = null;
-function getSharedEventBus() {
-  if (!sharedBus) sharedBus = new EventBus();
-  return sharedBus;
-}
-function setSharedEventBus(bus) {
-  sharedBus = bus;
-}
-
-// src/network/PriorityScorer.ts
-var PriorityScorer = class {
-  /**
-   * Scores a raw delta based on simulated heuristics returning a priority class.
-   * Lower is more important.
-   */
-  static score(delta) {
-    let basePriority = 50;
-    if (delta.field === "x" || delta.field === "y" || delta.field === "z") {
-      basePriority -= 40;
-    }
-    if (delta.field === "health" || delta.field === "status") {
-      basePriority -= 50;
-    }
-    if (typeof delta.newValue === "string" && delta.newValue.length > 50) {
-      basePriority += 30;
-    }
-    basePriority = Math.max(0, Math.min(100, basePriority));
-    return {
-      ...delta,
-      priority: basePriority
-    };
-  }
-};
-
-// src/network/SpatialSharder.ts
-var SpatialSharder = class {
-  /**
-   * Maps an absolute position to a unique Shard ID string.
-   */
-  static getShardId(x, y, z) {
-    const sx = Math.floor(x / this.SHARD_SIZE);
-    const sy = Math.floor(y / this.SHARD_SIZE);
-    const sz = Math.floor(z / this.SHARD_SIZE);
-    return `shard_${sx}_${sy}_${sz}`;
-  }
-  /**
-   * Calculates all overlapping shards for a given bounding sphere or interaction radius.
-   */
-  static getOverlappingShards(x, y, z, radius) {
-    const shards = /* @__PURE__ */ new Set();
-    const minX = Math.floor((x - radius) / this.SHARD_SIZE);
-    const maxX = Math.floor((x + radius) / this.SHARD_SIZE);
-    const minY = Math.floor((y - radius) / this.SHARD_SIZE);
-    const maxY = Math.floor((y + radius) / this.SHARD_SIZE);
-    const minZ = Math.floor((z - radius) / this.SHARD_SIZE);
-    const maxZ = Math.floor((z + radius) / this.SHARD_SIZE);
-    for (let ix = minX; ix <= maxX; ix++) {
-      for (let iy = minY; iy <= maxY; iy++) {
-        for (let iz = minZ; iz <= maxZ; iz++) {
-          shards.add(`shard_${ix}_${iy}_${iz}`);
-        }
-      }
-    }
-    return Array.from(shards);
-  }
-};
-SpatialSharder.SHARD_SIZE = 100;
-var TransactionLog = class {
-  constructor(logPath) {
-    this.writeQueue = [];
-    this.isWriting = false;
-    this.sequenceId = 0;
-    this.logFile = logPath || path.resolve(process.cwd(), ".data", "state_transaction.wal");
-    const dir = path.dirname(this.logFile);
-    if (!fs.existsSync(dir)) {
-      fs.mkdirSync(dir, { recursive: true });
-    }
-  }
-  /**
-   * Appends an active delta directly to the offline WAL buffer.
-   */
-  append(delta) {
-    const stampedDelta = { ...delta, _seq: ++this.sequenceId };
-    this.writeQueue.push(stampedDelta);
-    this.flush();
-  }
-  async flush() {
-    if (this.isWriting || this.writeQueue.length === 0) return;
-    this.isWriting = true;
-    const toWrite = this.writeQueue.splice(0, this.writeQueue.length);
-    const dataStr = toWrite.map((d) => JSON.stringify(d)).join("\n") + "\n";
-    try {
-      await fs.promises.appendFile(this.logFile, dataStr, "utf-8");
-    } catch (error) {
-      this.writeQueue.unshift(...toWrite);
-    } finally {
-      this.isWriting = false;
-      if (this.writeQueue.length > 0) {
-        this.flush();
-      }
-    }
-  }
-  /**
-   * Recover the state strictly from the raw disk array.
-   */
-  async recover() {
-    if (!fs.existsSync(this.logFile)) {
-      return [];
-    }
-    try {
-      const data = await fs.promises.readFile(this.logFile, "utf-8");
-      const lines = data.split("\n").filter((l) => l.trim().length > 0);
-      const recoveredDeltas = lines.map((line) => {
-        const parsed = JSON.parse(line);
-        if (parsed._seq && parsed._seq > this.sequenceId) {
-          this.sequenceId = parsed._seq;
-        }
-        return parsed;
-      });
-      return recoveredDeltas;
-    } catch (error) {
-      return [];
-    }
-  }
-  async truncate() {
-    if (fs.existsSync(this.logFile)) {
-      await fs.promises.unlink(this.logFile);
-    }
-    this.sequenceId = 0;
-  }
-};
-
-// src/network/StateSynchronizer.ts
-var StateSynchronizer = class _StateSynchronizer {
-  constructor() {
-    // Subscriber maps bound by entity ID (who is interested in what)
-    this.globalSubscribers = /* @__PURE__ */ new Set();
-    this.subscriberOptions = /* @__PURE__ */ new Map();
-    this.entitySubscribers = /* @__PURE__ */ new Map();
-    // Spatial culling position tracking
-    this.entityPositions = /* @__PURE__ */ new Map();
-    this.entityShards = /* @__PURE__ */ new Map();
-    // Procedural Skill Syncer Mesh
-    this.skillSubscribers = /* @__PURE__ */ new Set();
-    // Adaptive Batching Metrics
-    this.pendingBatch = [];
-    this.batchTimer = null;
-    this.currentBatchWindowMs = 50;
-    // Persistent Storage (WAL)
-    this.wal = new TransactionLog();
-    // Active Transport Mesh
-    this.transport = null;
-    this.initializedMesh = false;
-  }
-  static getInstance() {
-    if (!_StateSynchronizer.instance) {
-      _StateSynchronizer.instance = new _StateSynchronizer();
-    }
-    return _StateSynchronizer.instance;
-  }
-  /**
-   * Bootstraps the local synchronization node over WebSockets.
-   */
-  initializeMesh() {
-    if (this.initializedMesh) return;
-    this.initializedMesh = true;
-    this.transport = new WebSocketTransport({
-      roomId: "local_actor",
-      serverUrl: "ws://127.0.0.1:8080"
-    });
-    this.transport.connect();
-    this.transport.onMessage("state-sync", (msg) => {
-      const payload = msg.payload;
-      if (payload && payload.agent_updates && Array.isArray(payload.agent_updates)) {
-        const inboundDeltas = [];
-        for (const update of payload.agent_updates) {
-          inboundDeltas.push({
-            entityId: update.id,
-            field: "x",
-            newValue: update.x,
-            oldValue: 0,
-            timestamp: payload.timestamp
-          });
-          inboundDeltas.push({
-            entityId: update.id,
-            field: "y",
-            newValue: update.y,
-            oldValue: 0,
-            timestamp: payload.timestamp
-          });
-          inboundDeltas.push({
-            entityId: update.id,
-            field: "z",
-            newValue: update.z,
-            oldValue: 0,
-            timestamp: payload.timestamp
-          });
-        }
-        if (inboundDeltas.length > 0) {
-          this.dispatchToSubscribers(inboundDeltas);
-        }
-      }
-    });
-  }
-  dispatchToSubscribers(deltas) {
-    const publicDeltasToDispatch = deltas.filter((delta) => {
-      const isPrivate = delta.field.includes("private_") || delta.field.includes("_secure");
-      return !isPrivate;
-    });
-    this.globalSubscribers.forEach((sub) => {
-      sub(publicDeltasToDispatch);
-    });
-    const entityGroups = /* @__PURE__ */ new Map();
-    for (const delta of deltas) {
-      let arr = entityGroups.get(delta.entityId);
-      if (!arr) {
-        arr = [];
-        entityGroups.set(delta.entityId, arr);
-      }
-      arr.push(delta);
-    }
-    for (const [entityId, entityDeltas] of entityGroups.entries()) {
-      const scopedListeners = this.entitySubscribers.get(entityId);
-      if (scopedListeners) {
-        scopedListeners.forEach((sub) => sub(entityDeltas));
-      }
-    }
-  }
-  /**
-   * Enqueue a burst of pre-computed deltas. Rather than instant transmission,
-   * they are loaded into an adaptive batch prioritized by the PriorityScorer.
-   */
-  broadcastDeltas(deltas) {
-    if (deltas.length === 0) return;
-    for (const delta of deltas) {
-      this.pendingBatch.push(PriorityScorer.score(delta));
-    }
-    if (!this.batchTimer) {
-      this.scheduleNextFlush();
-    }
-  }
-  scheduleNextFlush() {
-    if (this.pendingBatch.length > 500) {
-      this.currentBatchWindowMs = Math.min(200, this.currentBatchWindowMs + 10);
-    } else if (this.pendingBatch.length < 100) {
-      this.currentBatchWindowMs = Math.max(10, this.currentBatchWindowMs - 10);
-    }
-    this.batchTimer = setTimeout(() => this.flushDeltas(), this.currentBatchWindowMs);
-  }
-  flushDeltas() {
-    this.batchTimer = null;
-    if (this.pendingBatch.length === 0) return;
-    this.pendingBatch.sort((a, b) => a.priority - b.priority);
-    const deltasToDispatch = this.pendingBatch.splice(0, this.pendingBatch.length);
-    for (const delta of deltasToDispatch) {
-      if (delta.field === "x" || delta.field === "y" || delta.field === "z") {
-        let pos = this.entityPositions.get(delta.entityId);
-        if (!pos) {
-          pos = { x: 0, y: 0, z: 0 };
-          this.entityPositions.set(delta.entityId, pos);
-        }
-        pos[delta.field] = delta.newValue;
-        this.entityShards.set(delta.entityId, SpatialSharder.getShardId(pos.x, pos.y, pos.z));
-      }
-      this.wal.append(delta);
-    }
-    if (this.transport) {
-      this.transport.sendMessage({
-        type: "state-sync",
-        payload: {
-          deltas: deltasToDispatch.map((d) => ({
-            id: d.entityId,
-            field: d.field,
-            value: d.newValue,
-            time: d.timestamp
-          }))
-        }
-      });
-    }
-    const publicDeltasToDispatch = deltasToDispatch.filter((delta) => {
-      const isPrivate = delta.field.includes("private_") || delta.field.includes("_secure");
-      return !isPrivate;
-    });
-    this.globalSubscribers.forEach((sub) => {
-      const options = this.subscriberOptions.get(sub);
-      if (!options || !options.position || !options.interactionRadius) {
-        if (publicDeltasToDispatch.length > 0) sub(publicDeltasToDispatch);
-        return;
-      }
-      const targetShards = new Set(
-        SpatialSharder.getOverlappingShards(
-          options.position.x,
-          options.position.y,
-          options.position.z,
-          options.interactionRadius
-        )
-      );
-      const culledDeltas = publicDeltasToDispatch.filter((delta) => {
-        const entityPos = this.entityPositions.get(delta.entityId);
-        if (!entityPos) return true;
-        const entityShard = this.entityShards.get(delta.entityId);
-        if (entityShard && !targetShards.has(entityShard)) {
-          return false;
-        }
-        const dx = entityPos.x - options.position.x;
-        const dy = entityPos.y - options.position.y;
-        const dz = entityPos.z - options.position.z;
-        const distSq = dx * dx + dy * dy + dz * dz;
-        const r = options.interactionRadius;
-        return distSq <= r * r;
-      });
-      if (culledDeltas.length > 0) {
-        sub(culledDeltas);
-      }
-    });
-    const entityGroups = /* @__PURE__ */ new Map();
-    for (const delta of deltasToDispatch) {
-      let arr = entityGroups.get(delta.entityId);
-      if (!arr) {
-        arr = [];
-        entityGroups.set(delta.entityId, arr);
-      }
-      arr.push(delta);
-    }
-    for (const [entityId, entityDeltas] of entityGroups.entries()) {
-      const scopedListeners = this.entitySubscribers.get(entityId);
-      if (scopedListeners) {
-        scopedListeners.forEach((sub) => sub(entityDeltas));
-      }
-    }
-    if (this.pendingBatch.length > 0) {
-      this.scheduleNextFlush();
-    }
-  }
-  /**
-   * Subscribe to all global state deltas (e.g. Server sync bridges).
-   */
-  subscribeGlobal(callback, options) {
-    this.globalSubscribers.add(callback);
-    if (options) {
-      this.subscriberOptions.set(callback, options);
-    }
-    return () => {
-      this.globalSubscribers.delete(callback);
-      this.subscriberOptions.delete(callback);
-    };
-  }
-  /**
-   * Subscribe to targeted changes restricted strictly to a specific Entity.
-   */
-  subscribeEntity(entityId, callback) {
-    let scopedListeners = this.entitySubscribers.get(entityId);
-    if (!scopedListeners) {
-      scopedListeners = /* @__PURE__ */ new Set();
-      this.entitySubscribers.set(entityId, scopedListeners);
-    }
-    scopedListeners.add(callback);
-    return () => {
-      const listeners = this.entitySubscribers.get(entityId);
-      if (listeners) {
-        listeners.delete(callback);
-        if (listeners.size === 0) {
-          this.entitySubscribers.delete(entityId);
-        }
-      }
-    };
-  }
-  /**
-   * Broadcast a procedural skill mutation recursively so all agents merge success rates.
-   */
-  broadcastSkill(skill) {
-    this.skillSubscribers.forEach((sub) => sub(skill));
-  }
-  /**
-   * Listen globally for procedurally acquired skills bouncing across the instance.
-   */
-  subscribeSkills(callback) {
-    this.skillSubscribers.add(callback);
-    return () => this.skillSubscribers.delete(callback);
-  }
-  /**
-   * Recovery API reading `.wal` states sequentially mapping offline CRDT histories completely locally.
-   */
-  async recoverFromLog() {
-    const deltas = await this.wal.recover();
-    if (deltas.length > 0) {
-      for (const d of deltas) {
-        if (d.field === "x" || d.field === "y" || d.field === "z") {
-          let pos = this.entityPositions.get(d.entityId);
-          if (!pos) {
-            pos = { x: 0, y: 0, z: 0 };
-            this.entityPositions.set(d.entityId, pos);
-          }
-          pos[d.field] = d.newValue;
-        }
-      }
-    }
-    return deltas;
-  }
-  async clearLog() {
-    await this.wal.truncate();
-  }
-};
-
-// src/monitoring/telemetry.ts
-var TelemetryRegistry = class {
-  constructor() {
-    this.measurements = [];
-    this.maxHistory = 1e4;
-  }
-  /**
-   * Increments a monotonic counter (e.g., total_nodes_executed)
-   */
-  incrementCounter(name, value = 1, labels) {
-    this.measurements.push({
-      name,
-      type: "counter",
-      value,
-      labels,
-      timestamp: Date.now()
-    });
-    if (this.measurements.length > this.maxHistory) this.measurements.shift();
-  }
-  /**
-   * Records an instantaneous value (e.g., active_agents)
-   */
-  setGauge(name, value, labels) {
-    this.measurements.push({
-      name,
-      type: "gauge",
-      value,
-      labels,
-      timestamp: Date.now()
-    });
-    if (this.measurements.length > this.maxHistory) this.measurements.shift();
-  }
-  /**
-   * Wraps an async function and records its execution latency into a histogram.
-   */
-  async measureLatency(name, fn, labels) {
-    const start = performance.now();
-    try {
-      return await fn();
-    } finally {
-      const duration = performance.now() - start;
-      this.measurements.push({
-        name,
-        type: "histogram",
-        value: duration,
-        labels,
-        timestamp: Date.now()
-      });
-      if (this.measurements.length > this.maxHistory) this.measurements.shift();
-      if (duration > 500) {
-        this.measurements.push({
-          name: "slo_violation_count",
-          type: "counter",
-          value: 1,
-          labels: { ...labels, metric_name: name, threshold: "500ms" },
-          timestamp: Date.now()
-        });
-      }
-    }
-  }
-  /**
-   * Snapshots current aggregations for dashboard export.
-   */
-  getSnapshot() {
-    const snapshot = { counters: {}, histograms: {}, gauges: {} };
-    const histAggregations = {};
-    for (const m of this.measurements) {
-      const key = m.labels ? `${m.name}{${JSON.stringify(m.labels)}}` : m.name;
-      if (m.type === "counter") {
-        snapshot.counters[key] = (snapshot.counters[key] || 0) + m.value;
-      } else if (m.type === "gauge") {
-        snapshot.gauges[key] = m.value;
-      } else if (m.type === "histogram") {
-        if (!histAggregations[key]) histAggregations[key] = { count: 0, sum: 0, max: 0 };
-        histAggregations[key].count++;
-        histAggregations[key].sum += m.value;
-        if (m.value > histAggregations[key].max) histAggregations[key].max = m.value;
-      }
-    }
-    for (const [key, agg] of Object.entries(histAggregations)) {
-      snapshot.histograms[key] = {
-        count: agg.count,
-        sum: agg.sum,
-        avg: agg.count > 0 ? agg.sum / agg.count : 0,
-        max: agg.max
-      };
-    }
-    return snapshot;
-  }
-};
-var telemetry = new TelemetryRegistry();
-var HoloScriptAgentRuntime = class {
-  /**
-   * Creates a new HoloScript agent runtime instance.
-   *
-   * @param agentNode - The OrbNode representing the agent template
-   * @param parentRuntime - The parent runtime providing global context
-   *
-   * @example
-   * ```typescript
-   * const runtime = new HoloScriptAgentRuntime(miningAgentNode, mainRuntime);
-   * ```
-   */
-  constructor(agentNode, parentRuntime) {
-    this.runningActions = /* @__PURE__ */ new Map();
-    this.isDestroyed = false;
-    // Episodic Memory & Semantic Extraction (Phase 7)
-    this.rawEpisodes = [];
-    this.semanticFacts = [];
-    this.consolidationInterval = null;
-    if (!agentNode || !parentRuntime) {
-      return;
-    }
-    this.agentNode = agentNode;
-    this.parentRuntime = parentRuntime;
-    this.localState = new ReactiveState(agentNode.properties || {});
-    this.initializeAgentContext();
-  }
-  /**
-   * Reset the runtime for pooling reuse with new agent configuration.
-   *
-   * @param agentNode - New agent node to bind to this runtime
-   * @param parentRuntime - Parent runtime for global context
-   */
-  reset(agentNode, parentRuntime) {
-    this.agentNode = agentNode;
-    this.parentRuntime = parentRuntime;
-    this.localState = new ReactiveState(agentNode.properties || {});
-    this.runningActions.clear();
-    this.isDestroyed = false;
-    this.initializeAgentContext();
-  }
-  /**
-   * Initialize the agent's execution context and memory consolidation.
-   */
-  initializeAgentContext() {
-    ({
-      id: this.agentNode.id || this.agentNode.name,
-      type: this.agentNode.type,
-      state: this.localState.getSnapshot(),
-      properties: this.agentNode.properties});
-    if (!this.consolidationInterval) {
-      this.consolidationInterval = setInterval(() => this.consolidateMemory(), 3e4);
-    }
-  }
-  /**
-   * Records a raw episodic event into the agent's short-term history queue.
-   *
-   * @param action - The action that was performed
-   * @param outcome - The result or outcome of the action
-   * @param entitiesInvolved - List of entity IDs that were involved in the episode
-   *
-   * @example
-   * ```typescript
-   * agentRuntime.recordEpisode('mine_ore', 'collected 5 iron ore', ['ore_deposit_1', 'inventory']);
-   * ```
-   */
-  recordEpisode(action, outcome, entitiesInvolved) {
-    this.rawEpisodes.push({
-      id: `ep_${Date.now()}_${Math.random().toString(36).substring(7)}`,
-      timestamp: Date.now(),
-      action,
-      outcome,
-      entitiesInvolved
-    });
-  }
-  /**
-   * Internal idle tick leveraging the MemoryConsolidator subsystem to offload processing constraints.
-   */
-  consolidateMemory() {
-    if (this.isDestroyed || this.rawEpisodes.length < 5) return;
-    const { newFacts, prunedEpisodes } = MemoryConsolidator.compressEpisodes(this.rawEpisodes);
-    if (newFacts.length > 0) {
-      this.semanticFacts.push(...newFacts);
-      this.rawEpisodes = this.rawEpisodes.filter((e) => !prunedEpisodes.includes(e.id));
-    }
-  }
-  /**
-   * Execute an action (method) defined on the agent template.
-   *
-   * @param actionName - Name of the action/method to execute
-   * @param args - Arguments to pass to the action method
-   * @returns Promise resolving to execution result
-   * @throws {Error} When agent is destroyed or action execution fails
-   *
-   * @example
-   * ```typescript
-   * const result = await agentRuntime.executeAction('patrol', ['north_sector']);
-   * if (result.success) {
-   *   console.log('Patrol completed:', result.output);
-   * }
-   * ```
-   */
-  async executeAction(actionName, args = []) {
-    if (this.isDestroyed) return { success: false, error: "Agent destroyed" };
-    const directives = this.agentNode.directives;
-    const action = directives?.find((d) => d.type === "method" && d.name === actionName);
-    if (!action) {
-      return this.parentRuntime.callFunction(actionName, args);
-    }
-    logger.info(`[Agent:${this.agentNode.name}] Executing action: ${actionName}`);
-    const agentScope = {
-      variables: /* @__PURE__ */ new Map(),
-      parent: this.parentRuntime.getRootScope()
-    };
-    const agentData = this.parentRuntime.getVariable(this.agentNode.name);
-    if (agentData && !agentData.state) {
-      agentData.state = this.localState.getProxy();
-    }
-    agentScope.variables.set(
-      "this",
-      agentData || {
-        id: this.agentNode.name,
-        state: this.localState.getProxy(),
-        properties: this.agentNode.properties
-      }
-    );
-    if (action.parameters && args) {
-      action.parameters.forEach((param, i) => {
-        agentScope.variables.set(param.name, args[i]);
-      });
-    }
-    try {
-      if (Array.isArray(action.body)) {
-        const results = await this.parentRuntime.executeHoloProgram(action.body, agentScope);
-        const success = results.every((r) => r.success);
-        return {
-          success,
-          output: results[results.length - 1]?.output,
-          error: results.find((r) => !r.success)?.error
-        };
-      } else {
-        const results = await this.parentRuntime.executeProgram(action.body, 1);
-        const success = results.every((r) => r.success);
-        return {
-          success,
-          output: results[results.length - 1]?.output,
-          // @ts-expect-error During migration
-          error: results.find((r) => !r.success)?.error
-        };
-      }
-    } finally {
-      this.runningActions.delete(actionName);
-    }
-  }
-  /**
-   * Autonomous 'thinking' cycle using LLM for decision making.
-   *
-   * @param prompt - Optional specific prompt for the LLM, defaults to general decision prompt
-   * @returns Promise resolving to the LLM's decision as a string
-   *
-   * @example
-   * ```typescript
-   * const decision = await agentRuntime.think('Should I retreat or continue attacking?');
-   * console.log('Agent decision:', decision);
-   * ```
-   */
-  async think(prompt) {
-    logger.info(`[Agent:${this.agentNode.name}] Thinking...`);
-    const result = await this.parentRuntime.emit("agent_think", {
-      agentId: this.agentNode.name,
-      context: this.localState.getSnapshot(),
-      prompt: prompt || "Decide the next best action based on current state."
-    });
-    return result?.decision || "No clear decision made.";
-  }
-  /**
-   * Handle lifecycle events for this specific agent.
-   *
-   * @param eventType - The type of event being handled
-   * @param data - Event data to bind to the execution scope
-   *
-   * @example
-   * ```typescript
-   * await agentRuntime.onEvent('enemy_spotted', {
-   *   enemy: 'orc_warrior',
-   *   distance: 50
-   * });
-   * ```
-   */
-  async onEvent(eventType, data) {
-    if (this.isDestroyed) return;
-    const directives = this.agentNode.directives;
-    const handler = directives?.find((d) => d.type === "lifecycle" && d.hook === eventType);
-    if (handler) {
-      const eventScope = {
-        variables: /* @__PURE__ */ new Map(),
-        parent: this.parentRuntime.getRootScope()
-      };
-      if (data && typeof data === "object") {
-        for (const [key, val] of Object.entries(data)) {
-          eventScope.variables.set(key, val);
-        }
-      }
-      eventScope.variables.set("eventData", data);
-      directives?.forEach((d) => {
-        if (d.type === "method" && d.name) {
-          eventScope.variables.set(d.name, ((...args) => this.executeAction(d.name, args)));
-        }
-      });
-      const params = handler.parameters;
-      if (params && Array.isArray(params) && data && typeof data === "object") {
-        const dataRecord = data;
-        params.forEach((param) => {
-          if (dataRecord[param.name] !== void 0) {
-            eventScope.variables.set(param.name, dataRecord[param.name]);
-          }
-        });
-      }
-      const agentData = this.parentRuntime.getVariable(this.agentNode.name);
-      if (agentData && !agentData.state) {
-        agentData.state = this.localState.getProxy();
-      }
-      eventScope.variables.set(
-        "this",
-        agentData || {
-          id: this.agentNode.name,
-          state: this.localState.getProxy(),
-          properties: this.agentNode.properties
-        }
-      );
-      try {
-        if (Array.isArray(handler.body)) {
-          await this.parentRuntime.executeHoloProgram(handler.body, eventScope);
-        } else {
-          this.parentRuntime.evaluateExpression(handler.body);
-        }
-      } finally {
-      }
-    }
-  }
-  /**
-   * Clean up the agent runtime, stopping all running processes and timers.
-   */
-  destroy() {
-    this.isDestroyed = true;
-    this.runningActions.clear();
-    if (this.consolidationInterval) {
-      clearInterval(this.consolidationInterval);
-      this.consolidationInterval = null;
-    }
-    logger.info(`[Agent:${this.agentNode.name}] Runtime destroyed.`);
-  }
-  /**
-   * Get the agent's unique identifier.
-   *
-   * @returns The agent's ID or name
-   */
-  get id() {
-    return this.agentNode.id || this.agentNode.name;
-  }
-  /**
-   * Get the agent's current reactive state proxy.
-   *
-   * @returns Proxy object for the agent's state
-   */
-  get state() {
-    return this.localState.getProxy();
-  }
-  /**
-   * Get the agent's current reactive state proxy.
-   *
-   * @returns Proxy object for the agent's state
-   */
-  getState() {
-    return this.localState.getProxy();
-  }
-};
-
-// src/extensions/ExtensionRegistry.ts
-var ExtensionRegistry = class {
-  constructor(runtime) {
-    this.extensions = /* @__PURE__ */ new Map();
-    this.runtime = runtime;
-  }
-  /**
-   * Load an extension into the runtime
-   */
-  loadExtension(extension) {
-    if (this.extensions.has(extension.id)) {
-      logger.warn(`Extension ${extension.id} is already loaded.`);
-      return;
-    }
-    const context = {
-      registerTrait: (name, handler) => {
-        logger.info(`[Extension:${extension.id}] Registering trait: ${name}`);
-        this.runtime.registerTrait(name, handler);
-      },
-      registerFunction: (name, fn) => {
-        logger.info(`[Extension:${extension.id}] Registering function: ${name}`);
-        this.runtime.registerGlobalFunction(name, fn);
-      },
-      logger
-    };
-    try {
-      extension.onLoad(context);
-      this.extensions.set(extension.id, extension);
-      logger.info(`Extension loaded: ${extension.id} v${extension.version}`);
-    } catch (error) {
-      logger.error(`Failed to load extension ${extension.id}:`, {
-        error: error instanceof Error ? error.message : String(error)
-      });
-      throw error;
-    }
-  }
-  /**
-   * Unload an extension
-   */
-  unloadingExtension(id) {
-    const extension = this.extensions.get(id);
-    if (!extension) return;
-    try {
-      const context = {
-        registerTrait: () => {
-        },
-        registerFunction: () => {
-        },
-        logger
-      };
-      extension.onUnload(context);
-    } catch (e) {
-      logger.error(`Error unloading extension ${id}`, {
-        error: e instanceof Error ? e.message : String(e)
-      });
-    }
-    this.extensions.delete(id);
-    logger.info(`Extension unloaded: ${id}`);
-  }
-  getExtension(id) {
-    return this.extensions.get(id);
-  }
-};
-var RUNTIME_SECURITY_LIMITS = {
-  maxExecutionDepth: 50,
-  maxTotalNodes: 1e3,
-  maxExecutionTimeMs: 5e3,
-  maxParticlesPerSystem: 1e3,
-  maxCallStackDepth: 100
-};
-function isOrbData(v) {
-  return v !== null && typeof v === "object" && v.__type === "orb";
-}
-var HoloScriptRuntime = class {
-  constructor(_importLoader, customFunctions) {
-    this.particleSystems = /* @__PURE__ */ new Map();
-    this.executionHistory = [];
-    this.agentRuntimes = /* @__PURE__ */ new Map();
-    this.startTime = 0;
-    this.nodeCount = 0;
-    this.callStack = [];
-    this.eventHandlers = /* @__PURE__ */ new Map();
-    this.animations = /* @__PURE__ */ new Map();
-    this.uiElements = /* @__PURE__ */ new Map();
-    this.proceduralSkills = /* @__PURE__ */ new Map();
-    this.traitHandlers = /* @__PURE__ */ new Map();
-    this.context = this.createEmptyContext();
-    this.currentScope = { variables: this.context.variables };
-    this.builtinFunctions = this.initBuiltins(customFunctions);
-    this.agentPool = new ObjectPool(
-      () => new HoloScriptAgentRuntime(),
-      // Preallocation mode (optional args)
-      (agent) => agent.destroy(),
-      50
-    );
-    registerVoiceSynthesizer("default", new BaseVoiceSynthesizer());
-    registerEmotionDetector("default", new LocalEmotionDetector());
-    registerSpeechRecognizer("default", new MockSpeechRecognizer());
-    for (const [name, fn] of this.builtinFunctions) {
-      this.context.functions.set(name, ((...spreadArgs) => fn(spreadArgs)));
-    }
-    this.registerFunction("get_attended_entities", (args) => {
-      const topK = typeof args[0] === "number" ? args[0] : 10;
-      const selfRaw = this.context.variables.get("self");
-      const selfNode = isOrbData(selfRaw) ? selfRaw : void 0;
-      const observerPos = selfNode?.position ?? { x: 0, y: 0, z: 0 };
-      const entities = [];
-      this.context.spatialMemory.forEach((pos, id) => {
-        if (id !== selfNode?.name) {
-          const entityRaw = this.context.variables.get(id);
-          const entityOrb = isOrbData(entityRaw) ? entityRaw : void 0;
-          entities.push({
-            id,
-            position: pos,
-            velocity: entityOrb?.velocity,
-            saliencyBase: typeof entityOrb?.saliency === "number" ? entityOrb.saliency : void 0
-          });
-        }
-      });
-      return AttentionEngine.getTopKEntities(observerPos, entities, topK);
-    });
-    this.traitHandlers.set("mitosis", mitosisHandler);
-    this.traitHandlers.set("orbital", orbitalHandler);
-    this.extensionRegistry = new ExtensionRegistry(this);
-    stateMachineInterpreter.setHookExecutor(
-      (code, context) => {
-        for (const [key, value] of Object.entries(context)) {
-          this.context.variables.set(key, value);
-        }
-        return this.evaluateExpression(code);
-      }
-    );
-  }
-  /**
-   * Initialize built-in functions
-   */
-  initBuiltins(customFunctions) {
-    const builtins = /* @__PURE__ */ new Map();
-    if (customFunctions) {
-      for (const [name, func] of Object.entries(customFunctions)) {
-        builtins.set(name, func);
-      }
-    }
-    builtins.set("show", (args) => {
-      const target = String(args[0]);
-      const element = this.uiElements.get(target);
-      if (element) element.visible = true;
-      const hologram = this.context.hologramState.get(target);
-      if (hologram) {
-        this.createParticleEffect(`${target}_show`, { x: 0, y: 0, z: 0 }, hologram.color, 15);
-      }
-      logger.info("show", { target });
-      return { shown: target };
-    });
-    builtins.set("hide", (args) => {
-      const target = String(args[0]);
-      const element = this.uiElements.get(target);
-      if (element) element.visible = false;
-      logger.info("hide", { target });
-      return { hidden: target };
-    });
-    builtins.set("pulsate", (args) => {
-      const target = String(args[0]);
-      const options = args[1] || {};
-      const duration = Number(options.duration) || 1e3;
-      const color = String(options.color || "#ffffff");
-      const position = this.context.spatialMemory.get(target) || { x: 0, y: 0, z: 0 };
-      this.createParticleEffect(`${target}_pulse`, position, color, 30);
-      return { pulsing: target, duration };
-    });
-    builtins.set("animate", (args) => {
-      const target = String(args[0]);
-      const options = args[1] || {};
-      const animation = {
-        target,
-        property: String(options.property || "position.y"),
-        from: Number(options.from || 0),
-        to: Number(options.to || 1),
-        duration: Number(options.duration || 1e3),
-        startTime: Date.now(),
-        easing: String(options.easing || "linear"),
-        loop: Boolean(options.loop),
-        yoyo: Boolean(options.yoyo)
-      };
-      this.animations.set(`${target}_${animation.property}`, animation);
-      return { animating: target, animation };
-    });
-    builtins.set("spawn", async (args) => {
-      const config = args[0];
-      if (typeof config === "string") {
-        const target = config;
-        const position2 = args[1] || { x: 0, y: 0, z: 0 };
-        this.context.spatialMemory.set(target, position2);
-        this.createParticleEffect(`${target}_spawn`, position2, "#00ff00", 25);
-        return { spawned: target, at: position2 };
-      }
-      const spawnConfig = config;
-      const templateName = String(spawnConfig.template);
-      const id = String(spawnConfig.id || `${templateName}_${Date.now()}`);
-      const position = spawnConfig.position || { x: 0, y: 0, z: 0 };
-      const template = this.context.templates.get(templateName);
-      if (!template) {
-        logger.error(`[Mitosis] Template ${templateName} not found`);
-        return { error: `Template ${templateName} not found` };
-      }
-      const spawnNode = {
-        type: "orb",
-        name: id,
-        position,
-        properties: { ...spawnConfig.config || {} },
-        // Initial state from config
-        children: template.children,
-        traits: template.traits,
-        directives: template.directives
-      };
-      const holoTpl = template;
-      if (holoTpl.state) {
-        for (const prop of holoTpl.state.properties) {
-          if (spawnNode.properties[prop.key] === void 0) {
-            spawnNode.properties[prop.key] = this.resolveHoloValue(prop.value);
-          }
-        }
-      }
-      for (const prop of holoTpl.properties) {
-        if (spawnNode.properties[prop.key] === void 0) {
-          spawnNode.properties[prop.key] = this.resolveHoloValue(prop.value);
-        }
-      }
-      await this.executeOrb(spawnNode);
-      if (spawnConfig.parentId || spawnConfig.parent_id) {
-        const parentId = String(spawnConfig.parentId || spawnConfig.parent_id);
-        await this.emit(`mitosis_spawned`, { parentId, childId: id });
-        await this.emit(`${parentId}.mitosis_spawned`, { childId: id });
-      }
-      return { spawned: id, template: templateName };
-    });
-    builtins.set("notifyParent", async (args) => {
-      const parentId = String(args[0]);
-      const data = args[1];
-      await this.emit(`mitosis_child_complete`, {
-        parentId,
-        childId: args[2] || "unknown",
-        result: data
-      });
-      await this.emit(`${parentId}.mitosis_child_complete`, {
-        childId: args[2] || "unknown",
-        result: data
-      });
-      return { notified: parentId };
-    });
-    builtins.set("despawn", (args) => {
-      const target = String(args[0]);
-      if (this.context.hologramState.has(target)) {
-        const pos = this.context.spatialMemory.get(target) || { x: 0, y: 0, z: 0 };
-        this.createParticleEffect(`${target}_despawn`, pos, "#ff0000", 30);
-        this.context.hologramState.delete(target);
-        this.context.variables.delete(target);
-        this.context.spatialMemory.delete(target);
-        logger.info("despawn", { target });
-        return { despawned: target };
-      }
-      return { msg: "Target not found", target };
-    });
-    builtins.set("move", (args) => {
-      const target = String(args[0]);
-      const position = args[1] || { x: 0, y: 0, z: 0 };
-      const current = this.context.spatialMemory.get(target);
-      if (current) {
-        this.context.spatialMemory.set(target, position);
-        this.createConnectionStream(target, `${target}_dest`, current, position, "move");
-      }
-      return { moved: target, to: position };
-    });
-    builtins.set("set", (args) => {
-      const target = String(args[0]);
-      const value = args[1];
-      this.setVariable(target, value);
-      return { set: target, value };
-    });
-    builtins.set("get", (args) => {
-      const target = String(args[0]);
-      return this.getVariable(target);
-    });
-    builtins.set("add", (args) => Number(args[0]) + Number(args[1]));
-    builtins.set("subtract", (args) => Number(args[0]) - Number(args[1]));
-    builtins.set("multiply", (args) => Number(args[0]) * Number(args[1]));
-    builtins.set(
-      "divide",
-      (args) => Number(args[1]) !== 0 ? Number(args[0]) / Number(args[1]) : 0
-    );
-    builtins.set("mod", (args) => Number(args[0]) % Number(args[1]));
-    builtins.set("abs", (args) => Math.abs(Number(args[0])));
-    builtins.set("floor", (args) => Math.floor(Number(args[0])));
-    builtins.set("ceil", (args) => Math.ceil(Number(args[0])));
-    builtins.set("round", (args) => Math.round(Number(args[0])));
-    builtins.set("min", (args) => Math.min(...args.map(Number)));
-    builtins.set("max", (args) => Math.max(...args.map(Number)));
-    builtins.set("random", () => Math.random());
-    builtins.set("concat", (args) => args.map(String).join(""));
-    builtins.set("length", (args) => {
-      const val = args[0];
-      if (typeof val === "string") return val.length;
-      if (Array.isArray(val)) return val.length;
-      return 0;
-    });
-    builtins.set(
-      "substring",
-      (args) => String(args[0]).substring(Number(args[1]), Number(args[2]))
-    );
-    builtins.set("wait", async (args) => {
-      const ms = Number(args[0]) || 0;
-      await new Promise((resolve2) => setTimeout(resolve2, ms));
-      return { waited: ms };
-    });
-    builtins.set("print", (args) => {
-      console.log(`[HoloScript]`, ...args);
-      return { printed: args.join(" ") };
-    });
-    builtins.set("uppercase", (args) => String(args[0]).toUpperCase());
-    builtins.set("lowercase", (args) => String(args[0]).toLowerCase());
-    builtins.set("push", (args) => {
-      const arr = args[0];
-      if (Array.isArray(arr)) {
-        arr.push(args[1]);
-        return arr;
-      }
-      return [args[0], args[1]];
-    });
-    builtins.set("pop", (args) => {
-      const arr = args[0];
-      if (Array.isArray(arr)) return arr.pop();
-      return void 0;
-    });
-    builtins.set("at", (args) => {
-      const arr = args[0];
-      const index = Number(args[1]);
-      if (Array.isArray(arr)) return arr[index];
-      return void 0;
-    });
-    builtins.set("showSettings", () => {
-      this.emit("show-settings");
-      return true;
-    });
-    builtins.set("openChat", (args) => {
-      const config = args[0] || {};
-      this.emit("show-chat", config);
-      return true;
-    });
-    builtins.set("log", (args) => {
-      logger.info("HoloScript log", { args });
-      return args[0];
-    });
-    builtins.set("print", (args) => {
-      const message = args.map(String).join(" ");
-      logger.info("print", { message });
-      return message;
-    });
-    builtins.set("typeof", (args) => typeof args[0]);
-    builtins.set("isArray", (args) => Array.isArray(args[0]));
-    builtins.set(
-      "isNumber",
-      (args) => typeof args[0] === "number" && !isNaN(args[0])
-    );
-    builtins.set("isString", (args) => typeof args[0] === "string");
-    builtins.set("shop", (args) => this.handleShop(args));
-    builtins.set("inventory", (args) => this.handleInventory(args));
-    builtins.set("purchase", (args) => this.handlePurchase(args));
-    builtins.set("presence", (args) => this.handlePresence(args));
-    builtins.set("invite", (args) => this.handleInvite(args));
-    builtins.set("share", (args) => this.handleShare(args));
-    builtins.set("physics", (args) => this.handlePhysics(args));
-    builtins.set("gravity", (args) => this.handleGravity(args));
-    builtins.set("collide", (args) => this.handleCollide(args));
-    builtins.set("animate", (args) => this.handleAnimate(args));
-    builtins.set("calculate_arc", (args) => this.handleCalculateArc(args));
-    builtins.set(
-      "sleep",
-      (args) => new Promise((resolve2) => setTimeout(resolve2, Number(args[0]) || 0))
-    );
-    builtins.set("think", async (args) => {
-      const activeNode = this.context.executionStack[this.context.executionStack.length - 1];
-      if (!activeNode) return "No context";
-      const agentId = activeNode.name;
-      const agentRuntime = this.agentRuntimes.get(agentId);
-      if (agentRuntime) {
-        return await agentRuntime.think(String(args[0] || ""));
-      }
-      return "Thinking only available for agents.";
-    });
-    return builtins;
-  }
-  /**
-   * Register a global function from an extension
-   */
-  registerGlobalFunction(name, fn) {
-    this.context.functions.set(name, ((...spreadArgs) => fn(spreadArgs)));
-  }
-  /**
-   * Register a custom trait from an extension
-   */
-  registerTrait(name, handler) {
-    const vrName = name;
-    this.traitHandlers.set(vrName, handler);
-    logger.info(`Registered trait: ${name}`);
-  }
-  /**
-   * Get the extension registry
-   */
-  getExtensionRegistry() {
-    return this.extensionRegistry;
-  }
-  /**
-   * Execute a single AST node
-   */
-  async executeNode(node) {
-    const startTime = Date.now();
-    try {
-      this.context.executionStack.push(node);
-      let result;
-      const nodeType = node.type;
-      switch (nodeType) {
-        case "orb":
-        case "object":
-          result = await this.executeOrb(node);
-          break;
-        case "narrative":
-          result = await this.executeNarrative(node);
-          break;
-        case "quest":
-          result = await this.executeQuest(node);
-          break;
-        case "dialogue":
-          result = await this.executeDialogue(node);
-          break;
-        case "visual_metadata":
-          result = await this.executeVisualMetadata(node);
-          break;
-        case "method":
-        case "function":
-          result = await this.executeFunction(node);
-          break;
-        case "connection":
-          result = await this.executeConnection(node);
-          break;
-        case "gate":
-          result = await this.executeGate(node);
-          break;
-        case "stream":
-          result = await this.executeStream(node);
-          break;
-        case "call":
-          result = await this.executeCall(node);
-          break;
-        case "debug":
-          result = await this.executeDebug(node);
-          break;
-        case "visualize":
-          result = await this.executeVisualize(node);
-          break;
-        case "2d-element":
-          result = await this.executeUIElement(node);
-          break;
-        case "nexus":
-        case "building":
-          result = await this.executeStructure(node);
-          break;
-        case "assignment":
-          result = await this.executeAssignment(node);
-          break;
-        case "return":
-          result = await this.executeReturn(node);
-          break;
-        case "memory":
-          result = await this.executeMemory(node);
-          break;
-        case "semantic-memory":
-        case "episodic-memory":
-        case "procedural-memory":
-          result = await this.executeMemoryDefinition(
-            node
-          );
-          break;
-        case "generic":
-          result = await this.executeGeneric(node);
-          break;
-        case "expression-statement":
-          result = await this.executeExpressionStatement(node);
-          break;
-        case "scale":
-          result = await this.executeScale(node);
-          break;
-        case "focus":
-          result = await this.executeFocus(node);
-          break;
-        case "environment":
-          result = await this.executeEnvironment(node);
-          break;
-        case "composition":
-        case "Composition":
-          if (node.type === "Composition") {
-            result = await this.executeHoloComposition(node);
-          } else {
-            result = await this.executeComposition(node);
-          }
-          break;
-        case "template":
-        case "Template":
-          if (node.type === "Template") {
-            result = await this.executeHoloTemplate(node);
-          } else {
-            result = await this.executeTemplate(node);
-          }
-          break;
-        case "migration":
-          result = { success: true, output: "Migration block registered" };
-          break;
-        case "server":
-          result = await this.executeServerNode(node);
-          break;
-        case "database":
-          result = await this.executeDatabaseNode(node);
-          break;
-        case "fetch":
-          result = await this.executeFetchNode(node);
-          break;
-        case "execute":
-          result = await this.executeTarget(node);
-          break;
-        case "state-declaration":
-          result = await this.executeStateDeclaration(
-            node
-          );
-          break;
-        case "state-machine":
-          result = await this.executeStateMachine(node);
-          break;
-        case "system":
-          result = await this.executeSystem(node);
-          break;
-        case "core_config":
-          result = await this.executeCoreConfig(node);
-          break;
-        case "for":
-          result = await this.executeForLoop(
-            node
-          );
-          break;
-        case "forEach":
-          result = await this.executeForEachLoop(
-            node
-          );
-          break;
-        case "while":
-          result = await this.executeWhileLoop(
-            node
-          );
-          break;
-        case "if":
-          result = await this.executeIfStatement(
-            node
-          );
-          break;
-        case "match":
-          result = await this.executeMatch(
-            node
-          );
-          break;
-        default:
-          result = {
-            success: false,
-            error: `Unknown node type: ${node.type}`,
-            executionTime: Date.now() - startTime
-          };
-      }
-      result.executionTime = Date.now() - startTime;
-      this.executionHistory.push(result);
-      this.context.executionStack.pop();
-      return result;
-    } catch (error) {
-      const execTime = Date.now() - startTime;
-      const errorResult = {
-        success: false,
-        error: error instanceof Error ? error.message : String(error),
-        executionTime: execTime
-      };
-      this.executionHistory.push(errorResult);
-      this.context.executionStack.pop();
-      return errorResult;
-    }
-  }
-  /**
-   * Execute multiple nodes or a single node (unified entry point)
-   */
-  async execute(nodes) {
-    this.startTime = Date.now();
-    this.nodeCount = 0;
-    if (Array.isArray(nodes)) {
-      const results = await this.executeProgram(nodes);
-      const success = results.every((r) => r.success);
-      const lastResult = results[results.length - 1];
-      let output = success ? `Program executed (${results.length} nodes)` : "Program failed";
-      if (lastResult && lastResult.success && lastResult.output !== void 0) {
-        output = lastResult.output;
-      }
-      return {
-        success,
-        output,
-        error: results.find((r) => !r.success)?.error
-      };
-    } else {
-      return this.executeNode(nodes);
-    }
-  }
-  /**
-   * Execute multiple nodes in sequence
-   */
-  async executeProgram(nodes, depth = 0) {
-    if (depth === 0) {
-      this.startTime = Date.now();
-      this.nodeCount = 0;
-    }
-    if (depth > RUNTIME_SECURITY_LIMITS.maxExecutionDepth) {
-      logger.error("Max execution depth exceeded", { depth });
-      return [
-        {
-          success: false,
-          error: `Max execution depth exceeded (${RUNTIME_SECURITY_LIMITS.maxExecutionDepth})`,
-          executionTime: 0
-        }
-      ];
-    }
-    const results = [];
-    for (const node of nodes) {
-      this.nodeCount++;
-      if (this.nodeCount > RUNTIME_SECURITY_LIMITS.maxTotalNodes) {
-        logger.error("Max total nodes exceeded", { count: this.nodeCount });
-        results.push({
-          success: false,
-          error: "Max total nodes exceeded",
-          executionTime: Date.now() - this.startTime
-        });
-        break;
-      }
-      if (Date.now() - this.startTime > RUNTIME_SECURITY_LIMITS.maxExecutionTimeMs) {
-        logger.error("Execution timeout", { duration: Date.now() - this.startTime });
-        results.push({
-          success: false,
-          error: "Execution timeout",
-          executionTime: Date.now() - this.startTime
-        });
-        break;
-      }
-      const result = await this.executeNode(node);
-      results.push(result);
-      if (!result.success && node.type !== "visualize") {
-        break;
-      }
-      if (node.type === "return") {
-        break;
-      }
-    }
-    return results;
-  }
-  /**
-   * Call a function with arguments
-   */
-  async callFunction(name, args = []) {
-    const builtin = this.builtinFunctions.get(name);
-    if (builtin) {
-      try {
-        const result = await builtin(args);
-        return {
-          success: true,
-          output: result
-        };
-      } catch (error) {
-        return {
-          success: false,
-          error: `Built-in function ${name} failed: ${error}`
-        };
-      }
-    }
-    const func = this.context.functions.get(name);
-    if (!func) {
-      return {
-        success: false,
-        error: `Function '${name}' not found`
-      };
-    }
-    if (typeof func === "function") {
-      try {
-        const result = await func(...args);
-        return {
-          success: true,
-          output: result
-        };
-      } catch (error) {
-        return {
-          success: false,
-          error: `Extension function ${name} failed: ${error}`
-        };
-      }
-    }
-    if (this.callStack.length >= RUNTIME_SECURITY_LIMITS.maxCallStackDepth) {
-      return {
-        success: false,
-        error: `Max call stack depth exceeded (${RUNTIME_SECURITY_LIMITS.maxCallStackDepth})`
-      };
-    }
-    const parentScope = this.currentScope;
-    this.currentScope = {
-      variables: /* @__PURE__ */ new Map(),
-      parent: parentScope
-    };
-    func.parameters.forEach((param, index) => {
-      const value = index < args.length ? args[index] : param.defaultValue;
-      this.currentScope.variables.set(param.name, value);
-    });
-    this.callStack.push(name);
-    let returnValue = void 0;
-    try {
-      const results = await this.executeProgram(func.body, this.callStack.length);
-      const lastResult = results[results.length - 1];
-      if (lastResult?.output !== void 0) {
-        returnValue = lastResult.output;
-      }
-      this.createExecutionEffect(name, func.position || { x: 0, y: 0, z: 0 });
-      return {
-        success: results.every((r) => r.success),
-        output: returnValue,
-        hologram: func.hologram,
-        spatialPosition: func.position
-      };
-    } finally {
-      this.currentScope = parentScope;
-      this.callStack.pop();
-    }
-  }
-  /**
-   * Set a variable in current scope
-   */
-  setVariable(name, value, scopeOverride) {
-    if (name.includes(".")) {
-      const parts = name.split(".");
-      const objName = parts[0];
-      const propPath = parts.slice(1);
-      let obj = this.getVariable(objName, scopeOverride);
-      if (obj === void 0 || typeof obj !== "object" || obj === null) {
-        obj = {};
-        const scope = scopeOverride || this.currentScope;
-        scope.variables.set(objName, obj);
-      }
-      let current = obj;
-      for (let i = 0; i < propPath.length - 1; i++) {
-        if (current[propPath[i]] === void 0 || typeof current[propPath[i]] !== "object") {
-          current[propPath[i]] = {};
-        }
-        current = current[propPath[i]];
-      }
-      current[propPath[propPath.length - 1]] = value;
-    } else {
-      const scope = scopeOverride || this.currentScope;
-      scope.variables.set(name, value);
-    }
-    if (this.wss && typeof value === "object" && value !== null && value.__type === "orb") {
-      this.broadcast("orb_update", { orb: value });
-    } else if (this.wss && name.includes(".")) {
-      const root = name.split(".")[0];
-      const rootVar = this.getVariable(root, scopeOverride);
-      if (rootVar && typeof rootVar === "object" && rootVar.__type === "orb") {
-        this.broadcast("orb_update", { orb: rootVar });
-      }
-    }
-  }
-  /**
-   * Get a variable from scope chain
-   */
-  getVariable(name, scopeOverride) {
-    if (name.includes(".")) {
-      const parts = name.split(".");
-      let value = this.getVariable(parts[0], scopeOverride);
-      for (let i = 1; i < parts.length && value !== void 0; i++) {
-        if (typeof value === "object" && value !== null) {
-          value = value[parts[i]];
-        } else {
-          return void 0;
-        }
-      }
-      return value;
-    }
-    let scope = scopeOverride || this.currentScope;
-    while (scope) {
-      if (scope.variables.has(name)) {
-        return scope.variables.get(name);
-      }
-      scope = scope.parent;
-    }
-    if (this.context.variables.has(name)) {
-      return this.context.variables.get(name);
-    }
-    if (this.context.functions.has(name)) {
-      return this.context.functions.get(name);
-    }
-    return void 0;
-  }
-  /**
-   * Evaluate an expression in current context
-   */
-  evaluateExpression(expr) {
-    if (!expr || typeof expr !== "string") return expr;
-    const evaluator = new ExpressionEvaluator(this.context.state.getSnapshot());
-    const varContext = {};
-    this.context.variables.forEach((v, k) => varContext[k] = v);
-    evaluator.updateContext(varContext);
-    return evaluator.evaluate(expr);
-  }
-  // ============================================================================
-  // Node Executors
-  // ============================================================================
-  async executeOrb(node) {
-    const scale = this.context.currentScale || 1;
-    const existingRaw = this.context.variables.get(node.name);
-    const existingOrb = isOrbData(existingRaw) ? existingRaw : void 0;
-    const isUpdate = !!existingOrb;
-    let pos = { x: 0, y: 0, z: 0 };
-    if (Array.isArray(node.position)) {
-      pos = {
-        x: Number(node.position[0]) || 0,
-        y: Number(node.position[1]) || 0,
-        z: Number(node.position[2]) || 0
-      };
-    } else if (node.position) {
-      pos = {
-        x: Number(node.position.x) || 0,
-        y: Number(node.position.y) || 0,
-        z: Number(node.position.z) || 0
-      };
-    }
-    const adjustedPos = {
-      x: pos.x * scale,
-      y: pos.y * scale,
-      z: pos.z * scale
-    };
-    if (node.position) {
-      this.context.spatialMemory.set(node.name, adjustedPos);
-    }
-    const evaluatedProperties = {};
-    if (Array.isArray(node.properties)) {
-      for (const prop of node.properties) {
-        const key = prop.key;
-        const val = prop.value;
-        if (typeof val === "string") {
-          evaluatedProperties[key] = this.evaluateExpression(val);
-        } else {
-          evaluatedProperties[key] = val;
-        }
-      }
-    } else if (node.properties) {
-      for (const [key, val] of Object.entries(node.properties)) {
-        if (typeof val === "string") {
-          evaluatedProperties[key] = this.evaluateExpression(val);
-        } else {
-          evaluatedProperties[key] = val;
-        }
-      }
-    }
-    const orbNodeExt = node;
-    if (orbNodeExt.template) {
-      const tpl = this.context.templates.get(orbNodeExt.template);
-      if (tpl) {
-        if (tpl.properties) {
-          for (const [key, val] of Object.entries(tpl.properties)) {
-            if (evaluatedProperties[key] === void 0) {
-              if (typeof val === "string") {
-                evaluatedProperties[key] = this.evaluateExpression(val);
-              } else {
-                evaluatedProperties[key] = val;
-              }
-            }
-          }
-        }
-        if (tpl.directives) {
-          const existingDirectives = node.directives || [];
-          node.directives = [...tpl.directives, ...existingDirectives];
-        }
-      }
-    }
-    const hologram = node.hologram ? {
-      ...node.hologram,
-      size: (node.hologram.size || Number(evaluatedProperties.size) || Number(evaluatedProperties.scale) || 1) * scale
-    } : {
-      color: evaluatedProperties.color || "#ffffff",
-      size: (Number(evaluatedProperties.size) || Number(evaluatedProperties.scale) || 1) * scale,
-      shape: evaluatedProperties.geometry || "sphere",
-      glow: !!evaluatedProperties.glow,
-      interactive: !!evaluatedProperties.interactive
-    };
-    if (isUpdate && node.template) {
-      const tpl = this.context.templates.get(node.template);
-      const oldTpl = existingOrb?._templateRef;
-      if (tpl && oldTpl && tpl.version !== void 0 && oldTpl.version !== void 0) {
-        if (Number(tpl.version) > Number(oldTpl.version)) {
-          logger.info(
-            `Template version increase detected for ${node.name}: ${oldTpl.version} -> ${tpl.version}`
-          );
-          const migrations = tpl.migrations || [];
-          const migration = migrations.find((m) => m.fromVersion === Number(oldTpl.version));
-          if (migration) {
-            logger.info(`Executing migration from version ${oldTpl.version} for ${node.name}`);
-            await this.executeMigrationBlock(existingOrb, migration);
-          }
-        }
-      }
-    }
-    const orbData = isUpdate ? existingOrb : {
-      __type: "orb",
-      id: node.name,
-      name: node.name,
-      created: Date.now(),
-      // Methods bound to this orb
-      show: () => this.builtinFunctions.get("show")([node.name]),
-      hide: () => this.builtinFunctions.get("hide")([node.name]),
-      pulse: (opts) => this.builtinFunctions.get("pulse")([node.name, opts])
-    };
-    if (isUpdate) {
-      orbData.properties = {
-        // @ts-expect-error During migration
-        ...orbData.properties,
-        ...evaluatedProperties
-      };
-    } else {
-      orbData.properties = evaluatedProperties;
-    }
-    orbData.directives = node.directives || [];
-    orbData.position = adjustedPos;
-    orbData.hologram = hologram;
-    orbData._templateRef = node.template ? this.context.templates.get(node.template) : void 0;
-    if (!isUpdate) {
-      this.context.variables.set(node.name, orbData);
-    }
-    if (hologram) {
-      this.context.hologramState.set(node.name, hologram);
-    }
-    if (node.directives) {
-      this.applyDirectives(orbData);
-    }
-    if (!isUpdate) {
-      this.createParticleEffect(`${node.name}_creation`, adjustedPos, "#00ffff", 20);
-    }
-    if (this.isAgent(node)) {
-      if (!isUpdate || !this.agentRuntimes.has(node.name)) {
-        const agentRuntime = this.agentPool.acquire();
-        agentRuntime.reset(node, this);
-        this.agentRuntimes.set(node.name, agentRuntime);
-        orbData.state = agentRuntime.getState();
-        node.directives?.filter((d) => d.type === "method").forEach((m) => {
-          orbData[m.name] = (...args) => agentRuntime.executeAction(m.name, args);
-        });
-      }
-    }
-    logger.info(isUpdate ? "Orb updated" : "Orb created", {
-      name: node.name,
-      // @ts-expect-error During migration
-      properties: Object.keys(orbData.properties),
-      scale
-    });
-    this.broadcast(isUpdate ? "orb_updated" : "orb_created", {
-      orb: {
-        id: node.name,
-        name: node.name,
-        position: adjustedPos,
-        // @ts-expect-error During migration
-        properties: orbData.properties,
-        hologram,
-        traits: node.directives?.filter((d) => d.type === "trait").map((d) => d.name) || []
-      }
-    });
-    return {
-      success: true,
-      output: orbData,
-      hologram,
-      spatialPosition: adjustedPos
-    };
-  }
-  async executeFunction(node) {
-    this.context.functions.set(node.name, node);
-    const hologram = {
-      shape: "cube",
-      color: "#ff6b35",
-      size: 1.5,
-      glow: true,
-      interactive: true,
-      ...node.hologram
-    };
-    this.context.hologramState.set(node.name, hologram);
-    logger.info("Function defined", {
-      name: node.name,
-      params: node.parameters.map((p) => p.name)
-    });
-    return {
-      success: true,
-      output: `Function '${node.name}' defined with ${node.parameters.length} parameter(s)`,
-      hologram,
-      spatialPosition: node.position
-    };
-  }
-  async executeConnection(node) {
-    this.context.connections.push(node);
-    const fromPos = this.context.spatialMemory.get(node.from);
-    const toPos = this.context.spatialMemory.get(node.to);
-    if (fromPos && toPos) {
-      this.createConnectionStream(node.from, node.to, fromPos, toPos, node.dataType);
-    }
-    if (node.bidirectional) {
-      this.on(`${node.from}.changed`, async (data) => {
-        this.setVariable(node.to, data);
-        this.emit(`${node.to}.changed`, data);
-      });
-      this.on(`${node.to}.changed`, async (data) => {
-        this.setVariable(node.from, data);
-        this.emit(`${node.from}.changed`, data);
-      });
-    }
-    logger.info("Connection created", { from: node.from, to: node.to, dataType: node.dataType });
-    return {
-      success: true,
-      output: `Connected '${node.from}' to '${node.to}' (${node.dataType})`,
-      hologram: {
-        shape: "cylinder",
-        color: this.getDataTypeColor(node.dataType),
-        size: 0.1,
-        glow: true,
-        interactive: false
-      }
-    };
-  }
-  async executeGate(node) {
-    try {
-      const condition = this.evaluateCondition(node.condition);
-      const path2 = condition ? node.truePath : node.falsePath;
-      logger.info("Gate evaluation", { condition: node.condition, result: condition });
-      if (path2.length > 0) {
-        const subResults = await this.executeProgram(path2, this.callStack.length + 1);
-        const lastResult = subResults[subResults.length - 1];
-        if (lastResult && lastResult.success && lastResult.output !== void 0) {
-          return lastResult;
-        }
-      }
-      return {
-        success: true,
-        output: `Gate: took ${condition ? "true" : "false"} path`,
-        hologram: {
-          shape: "pyramid",
-          color: condition ? "#00ff00" : "#ff0000",
-          size: 1,
-          glow: true,
-          interactive: true
-        }
-      };
-    } catch (error) {
-      return {
-        success: false,
-        error: `Gate execution failed: ${error}`
-      };
-    }
-  }
-  async executeStream(node) {
-    let data = this.getVariable(node.source);
-    logger.info("Stream processing", {
-      name: node.name,
-      source: node.source,
-      transforms: node.transformations.length
-    });
-    for (const transform of node.transformations) {
-      data = await this.applyTransformation(data, transform);
-    }
-    this.setVariable(`${node.name}_result`, data);
-    this.createFlowingStream(node.name, node.position || { x: 0, y: 0, z: 0 }, data);
-    return {
-      success: true,
-      output: `Stream '${node.name}' processed ${Array.isArray(data) ? data.length : 1} item(s)`,
-      hologram: node.hologram,
-      spatialPosition: node.position
-    };
-  }
-  /**
-   * Execute State Machine declaration (Phase 13)
-   */
-  async executeStateMachine(node) {
-    this.context.stateMachines.set(node.name, node);
-    logger.info(`State machine registered: ${node.name}`);
-    return {
-      success: true,
-      output: { registered: node.name }
-    };
-  }
-  async executeExpressionStatement(node) {
-    const value = this.evaluateExpression(node.expression);
-    return {
-      success: true,
-      output: value
-    };
-  }
-  async executeCall(node) {
-    const funcName = node.target || "";
-    const args = node.args || [];
-    return this.callFunction(funcName, args);
-  }
-  async executeDebug(node) {
-    const debugInfo = {
-      variables: Object.fromEntries(this.currentScope.variables),
-      contextVariables: Object.fromEntries(this.context.variables),
-      functions: Array.from(this.context.functions.keys()),
-      connections: this.context.connections.length,
-      callStack: [...this.callStack],
-      uiElements: Array.from(this.uiElements.keys()),
-      animations: Array.from(this.animations.keys()),
-      executionHistory: this.executionHistory.slice(-10)
-    };
-    const debugOrb = {
-      shape: "pyramid",
-      color: "#ff1493",
-      size: 0.8,
-      glow: true,
-      interactive: true
-    };
-    this.context.hologramState.set(`debug_${node.target || "program"}`, debugOrb);
-    logger.info("Debug info", debugInfo);
-    return {
-      success: true,
-      output: debugInfo,
-      hologram: debugOrb
-    };
-  }
-  async executeVisualize(node) {
-    const target = node.target || "";
-    const data = this.getVariable(target);
-    if (data === void 0) {
-      return {
-        success: false,
-        error: `No data found for '${target}'`
-      };
-    }
-    const visHologram = {
-      shape: "cylinder",
-      color: "#32cd32",
-      size: 1.5,
-      glow: true,
-      interactive: true
-    };
-    this.createDataVisualization(target, data, node.position || { x: 0, y: 0, z: 0 });
-    return {
-      success: true,
-      output: { visualizing: target, data },
-      hologram: visHologram
-    };
-  }
-  async executeUIElement(node) {
-    const element = {
-      type: node.elementType,
-      name: node.name,
-      properties: { ...node.properties },
-      visible: true,
-      enabled: true
-    };
-    if (node.elementType === "textinput") {
-      element.value = node.properties.value || "";
-    } else if (node.elementType === "slider") {
-      element.value = node.properties.value || node.properties.min || 0;
-    } else if (node.elementType === "toggle") {
-      element.value = node.properties.checked || false;
-    }
-    this.uiElements.set(node.name, element);
-    if (node.events) {
-      for (const [eventName, handlerName] of Object.entries(node.events)) {
-        this.on(`${node.name}.${eventName}`, async () => {
-          await this.callFunction(handlerName);
-        });
-      }
-    }
-    logger.info("UI element created", { type: node.elementType, name: node.name });
-    return {
-      success: true,
-      output: element
-    };
-  }
-  /**
-   * Execute generic voice commands
-   * Handles commands like: show, hide, animate, pulse, create
-   */
-  async executeGeneric(_node) {
-    const genericNode = _node;
-    const command = String(genericNode.command || "").trim().toLowerCase();
-    const tokens = command.split(/\s+/);
-    const action = tokens[0];
-    const target = tokens[1];
-    logger.info("Executing generic command", { command, action, target });
-    try {
-      let result;
-      switch (action) {
-        case "show":
-          result = await this.executeShowCommand(target, genericNode);
-          break;
-        case "hide":
-          result = await this.executeHideCommand(target, genericNode);
-          break;
-        case "create":
-        case "summon":
-          result = await this.executeCreateCommand(tokens.slice(1), genericNode);
-          break;
-        case "animate":
-          result = await this.executeAnimateCommand(target, tokens.slice(2), genericNode);
-          break;
-        case "pulse":
-          result = await this.executePulseCommand(target, tokens.slice(2), genericNode);
-          break;
-        case "move":
-          result = await this.executeMoveCommand(target, tokens.slice(2), genericNode);
-          break;
-        case "delete":
-        case "remove":
-          result = await this.executeDeleteCommand(target, genericNode);
-          break;
-        default:
-          logger.warn("Unknown voice command action", { action, command });
-          result = {
-            executed: false,
-            message: `Unknown command: ${action}`
-          };
-      }
-      return {
-        success: true,
-        output: result
-      };
-    } catch (error) {
-      return {
-        success: false,
-        error: `Generic command execution failed: ${String(error)}`
-      };
-    }
-  }
-  /**
-   * Execute 'show' command
-   */
-  async executeShowCommand(target, _node) {
-    const hologram = _node.hologram || {
-      shape: "orb",
-      color: "#00ffff",
-      size: 0.8,
-      glow: true,
-      interactive: true
-    };
-    const position = _node.position || { x: 0, y: 0, z: 0 };
-    this.context.spatialMemory.set(target, position);
-    this.createParticleEffect(`${target}_show`, position, hologram.color, 15);
-    logger.info("Show command executed", { target, position });
-    return {
-      showed: target,
-      hologram,
-      position
-    };
-  }
-  /**
-   * Execute 'hide' command
-   */
-  async executeHideCommand(target, _node) {
-    const position = this.context.spatialMemory.get(target) || { x: 0, y: 0, z: 0 };
-    this.createParticleEffect(`${target}_hide`, position, "#ff0000", 10);
-    logger.info("Hide command executed", { target });
-    return {
-      hidden: target
-    };
-  }
-  /**
-   * Execute 'create' command
-   */
-  async executeCreateCommand(tokens, _node) {
-    if (tokens.length < 2) {
-      return { error: "Create command requires shape and name" };
-    }
-    const shape = tokens[0];
-    const name = tokens[1];
-    const position = _node.position || { x: 0, y: 0, z: 0 };
-    const hologram = {
-      shape,
-      color: _node.hologram?.color || "#00ffff",
-      size: _node.hologram?.size || 1,
-      glow: _node.hologram?.glow !== false,
-      interactive: _node.hologram?.interactive !== false
-    };
-    this.context.spatialMemory.set(name, position);
-    this.createParticleEffect(`${name}_create`, position, hologram.color, 20);
-    logger.info("Create command executed", { shape, name, position });
-    return {
-      created: name,
-      shape,
-      hologram,
-      position
-    };
-  }
-  /**
-   * Execute 'animate' command
-   */
-  async executeAnimateCommand(target, tokens, _node) {
-    const property = tokens[0] || "position.y";
-    const duration = parseInt(tokens[1] || "1000", 10);
-    const animation = {
-      target,
-      property,
-      from: 0,
-      to: 1,
-      duration,
-      startTime: Date.now(),
-      easing: "ease-in-out"
-    };
-    this.animations.set(`${target}_${property}`, animation);
-    logger.info("Animate command executed", { target, property, duration });
-    return {
-      animating: target,
-      animation
-    };
-  }
-  /**
-   * Execute 'pulse' command
-   */
-  async executePulseCommand(target, tokens, _node) {
-    const duration = parseInt(tokens[0] || "500", 10);
-    const position = this.context.spatialMemory.get(target) || { x: 0, y: 0, z: 0 };
-    this.createParticleEffect(`${target}_pulse`, position, "#ffff00", 30);
-    const animation = {
-      target,
-      property: "scale",
-      from: 1,
-      to: 1.5,
-      duration,
-      startTime: Date.now(),
-      easing: "sine",
-      yoyo: true,
-      loop: true
-    };
-    this.animations.set(`${target}_pulse`, animation);
-    logger.info("Pulse command executed", { target, duration });
-    return {
-      pulsing: target,
-      duration
-    };
-  }
-  /**
-   * Execute 'move' command
-   */
-  async executeMoveCommand(target, tokens, _node) {
-    const x = parseFloat(tokens[0] || "0");
-    const y = parseFloat(tokens[1] || "0");
-    const z = parseFloat(tokens[2] || "0");
-    const position = { x, y, z };
-    const current = this.context.spatialMemory.get(target);
-    if (current) {
-      this.context.spatialMemory.set(target, position);
-      this.createConnectionStream(target, `${target}_move`, current, position, "movement");
-    } else {
-      this.context.spatialMemory.set(target, position);
-    }
-    logger.info("Move command executed", { target, position });
-    return {
-      moved: target,
-      to: position
-    };
-  }
-  /**
-   * Execute 'delete' command
-   */
-  async executeDeleteCommand(target, _node) {
-    const position = this.context.spatialMemory.get(target);
-    if (position) {
-      this.createParticleEffect(`${target}_delete`, position, "#ff0000", 15);
-      this.context.spatialMemory.delete(target);
-    }
-    logger.info("Delete command executed", { target });
-    return {
-      deleted: target
-    };
-  }
-  async executeStructure(node) {
-    const hologram = node.hologram || {
-      shape: node.type === "nexus" ? "sphere" : "cube",
-      color: node.type === "nexus" ? "#9b59b6" : "#e74c3c",
-      size: node.type === "nexus" ? 3 : 4,
-      glow: true,
-      interactive: true
-    };
-    return {
-      success: true,
-      output: { type: node.type, created: true },
-      hologram,
-      spatialPosition: node.position
-    };
-  }
-  async executeAssignment(node) {
-    const value = this.evaluateExpression(String(node.value));
-    this.setVariable(node.name, value);
-    return {
-      success: true,
-      output: { assigned: node.name, value }
-    };
-  }
-  async executeReturn(node) {
-    const expr = String(node.value || node.expression || "");
-    const value = this.evaluateExpression(expr);
-    return {
-      success: true,
-      output: value
-    };
-  }
-  // ============================================================================
-  // Condition Evaluation
-  // ============================================================================
-  evaluateCondition(condition) {
-    if (!condition) return false;
-    const condStr = String(condition);
-    const suspiciousKeywords = ["eval", "process", "require", "__proto__", "constructor"];
-    if (suspiciousKeywords.some((kw) => condStr.toLowerCase().includes(kw))) {
-      logger.warn("Suspicious condition blocked", { condition });
-      return false;
-    }
-    try {
-      if (condStr.trim().toLowerCase() === "true") return true;
-      if (condStr.trim().toLowerCase() === "false") return false;
-      const comparisonPatterns = [
-        { regex: /^(.+?)\s*(===|!==)\s*(.+)$/ },
-        { regex: /^(.+?)\s*(==|!=|>=|<=|>|<)\s*(.+)$/ },
-        { regex: /^(.+?)\s*(&&)\s*(.+)$/, logical: "and" },
-        { regex: /^(.+?)\s*(\|\|)\s*(.+)$/, logical: "or" }
-      ];
-      for (const { regex, logical } of comparisonPatterns) {
-        const match = condStr.match(regex);
-        if (match) {
-          const [, leftExpr, operator, rightExpr] = match;
-          const left = this.evaluateExpression(leftExpr.trim());
-          const right = this.evaluateExpression(rightExpr.trim());
-          if (logical === "and") return Boolean(left) && Boolean(right);
-          if (logical === "or") return Boolean(left) || Boolean(right);
-          switch (operator) {
-            case "===":
-              return left === right;
-            case "!==":
-              return left !== right;
-            case "==":
-              return left == right;
-            case "!=":
-              return left != right;
-            case ">=":
-              return Number(left) >= Number(right);
-            case "<=":
-              return Number(left) <= Number(right);
-            case ">":
-              return Number(left) > Number(right);
-            case "<":
-              return Number(left) < Number(right);
-          }
-        }
-      }
-      if (condStr.startsWith("!")) {
-        return !this.evaluateCondition(condStr.slice(1).trim());
-      }
-      const value = this.evaluateExpression(condStr.trim());
-      return Boolean(value);
-    } catch (error) {
-      logger.error("Condition evaluation error", { condition, error });
-      return false;
-    }
-  }
-  // ============================================================================
-  // Transformation
-  // ============================================================================
-  async applyTransformation(data, transform) {
-    const params = transform.parameters || {};
-    switch (transform.operation) {
-      case "filter": {
-        if (!Array.isArray(data)) return data;
-        const predicate = params.predicate;
-        if (predicate) {
-          return data.filter((item) => {
-            this.setVariable("_item", item);
-            return this.evaluateCondition(predicate);
-          });
-        }
-        return data.filter((item) => item !== null && item !== void 0);
-      }
-      case "map": {
-        if (!Array.isArray(data)) return data;
-        const mapper = params.mapper;
-        if (mapper) {
-          return data.map((item) => {
-            this.setVariable("_item", item);
-            return this.evaluateExpression(mapper);
-          });
-        }
-        return data.map((item) => ({ value: item, processed: true }));
-      }
-      case "reduce": {
-        if (!Array.isArray(data)) return data;
-        const initial = params.initial ?? 0;
-        const reducer = params.reducer;
-        if (reducer) {
-          return data.reduce((acc, item) => {
-            this.setVariable("_acc", acc);
-            this.setVariable("_item", item);
-            return this.evaluateExpression(reducer);
-          }, initial);
-        }
-        return data.reduce((acc, item) => acc + (typeof item === "number" ? item : 0), 0);
-      }
-      case "sort": {
-        if (!Array.isArray(data)) return data;
-        const key = params.key;
-        const desc = params.descending;
-        const sorted = [...data].sort((a, b) => {
-          const aVal = key ? a[key] : a;
-          const bVal = key ? b[key] : b;
-          if (aVal < bVal) return desc ? 1 : -1;
-          if (aVal > bVal) return desc ? -1 : 1;
-          return 0;
-        });
-        return sorted;
-      }
-      case "sum":
-        return Array.isArray(data) ? data.reduce((sum, item) => sum + (typeof item === "number" ? item : 0), 0) : data;
-      case "count":
-        return Array.isArray(data) ? data.length : 1;
-      case "unique":
-        return Array.isArray(data) ? Array.from(new Set(data)) : data;
-      case "flatten":
-        return Array.isArray(data) ? data.flat() : data;
-      case "reverse":
-        return Array.isArray(data) ? [...data].reverse() : data;
-      case "take": {
-        if (!Array.isArray(data)) return data;
-        const count = Number(params.count) || 10;
-        return data.slice(0, count);
-      }
-      case "skip": {
-        if (!Array.isArray(data)) return data;
-        const count = Number(params.count) || 0;
-        return data.slice(count);
-      }
-      default:
-        logger.warn("Unknown transformation", { operation: transform.operation });
-        return data;
-    }
-  }
-  // ============================================================================
-  // Event System
-  // ============================================================================
-  /**
-   * Register event handler
-   */
-  on(event, handler) {
-    const handlers = this.eventHandlers.get(event) || [];
-    handlers.push(handler);
-    this.eventHandlers.set(event, handlers);
-  }
-  /**
-   * Register host function
-   */
-  registerFunction(name, handler) {
-    this.builtinFunctions.set(name, handler);
-    logger.info(`Host function registered: ${name}`);
-  }
-  /**
-   * Remove event handler
-   */
-  off(event, handler) {
-    if (!handler) {
-      this.eventHandlers.delete(event);
-    } else {
-      const handlers = this.eventHandlers.get(event) || [];
-      this.eventHandlers.set(
-        event,
-        handlers.filter((h) => h !== handler)
-      );
-    }
-  }
-  /**
-   * Emit event
-   */
-  async emit(event, data) {
-    logger.info(`[Runtime] Emitting event: ${event}`, data);
-    if (event.includes(".")) {
-      const [target, eventName] = event.split(".");
-      const agent = this.agentRuntimes.get(target);
-      if (agent) {
-        await agent.onEvent(eventName, data);
-      }
-      const orb = this.context.variables.get(target);
-      if (orb && typeof orb === "object" && orb.__type === "orb") {
-        this.forwardToTraits(orb, eventName, data);
-      }
-    }
-    const orbs = Array.from(this.context.variables.values()).filter(
-      (v) => v && typeof v === "object" && v.__type === "orb"
-    );
-    for (const agent of this.agentRuntimes.values()) {
-      await agent.onEvent(event, data);
-    }
-    for (const variable of orbs) {
-      await this.forwardToTraits(variable, event, data);
-    }
-    const handlers = this.eventHandlers.get(event) || [];
-    for (const handler of handlers) {
-      try {
-        await handler(data);
-      } catch (error) {
-        logger.error("Event handler error", { event, error });
-      }
-    }
-    await getSharedEventBus().emit(event, data);
-    if (data && typeof data === "object" && data.id) {
-      stateMachineInterpreter.sendEvent(data.id, event);
-    }
-  }
-  async forwardToTraits(orb, event, data) {
-    if (orb.directives) {
-      for (const d of orb.directives) {
-        if (d.type === "trait") {
-          const handler = this.traitHandlers.get(d.name);
-          if (handler && handler.onEvent) {
-            const traitNode = orb;
-            const eventPayload = {
-              type: event,
-              ...data && typeof data === "object" ? data : {}
-            };
-            await handler.onEvent(
-              traitNode,
-              d.config || {},
-              {
-                emit: async (e, p) => await this.emit(e, p),
-                getScaleMultiplier: () => this.context.currentScale || 1
-              },
-              eventPayload
-            );
-          }
-        }
-      }
-    }
-  }
-  /**
-   * Trigger UI event
-   */
-  async triggerUIEvent(elementName, eventType, data) {
-    const element = this.uiElements.get(elementName);
-    if (!element) {
-      logger.warn("UI element not found", { elementName });
-      return;
-    }
-    if (eventType === "change" && data !== void 0) {
-      element.value = data;
-    }
-    await this.emit(`${elementName}.${eventType}`, data);
-  }
-  // ============================================================================
-  // Animation System
-  // ============================================================================
-  /**
-   * Update all animations
-   */
-  updateAnimations() {
-    const now = Date.now();
-    for (const [key, anim] of this.animations) {
-      const elapsed = now - anim.startTime;
-      let progress = Math.min(elapsed / anim.duration, 1);
-      progress = this.applyEasing(progress, anim.easing);
-      const currentValue = anim.from + (anim.to - anim.from) * progress;
-      if (anim.yoyo && progress >= 1) {
-        anim.startTime = now;
-        [anim.from, anim.to] = [anim.to, anim.from];
-      }
-      this.setVariable(`${anim.target}.${anim.property}`, currentValue);
-      if (progress >= 1 && !anim.loop && !anim.yoyo) {
-        this.animations.delete(key);
-      } else if (progress >= 1 && anim.loop) {
-        anim.startTime = now;
-      }
-    }
-    this.updateSystemVariables();
-  }
-  /**
-   * Update real-life and system variables ($time, $user, etc.)
-   */
-  updateSystemVariables() {
-    const now = /* @__PURE__ */ new Date();
-    this.setVariable("$time", now.toLocaleTimeString());
-    this.setVariable("$date", now.toLocaleDateString());
-    this.setVariable("$timestamp", now.getTime());
-    this.setVariable("$hour", now.getHours());
-    this.setVariable("$minute", now.getMinutes());
-    this.setVariable("$second", now.getSeconds());
-    if (this.getVariable("$user") === void 0) {
-      this.setVariable("$user", {
-        id: "user_123",
-        name: "Alpha Explorer",
-        level: 42,
-        rank: "Legendary",
-        achievements: ["First World", "Spirit Guide"],
-        preferences: { theme: "holographic", language: "en" }
-      });
-    }
-    if (this.getVariable("$location") === void 0) {
-      this.setVariable("$location", {
-        city: "Neo Tokyo",
-        region: "Holo-Sector 7",
-        coordinates: { lat: 35.6895, lng: 139.6917 },
-        altitude: 450
-      });
-    }
-    if (this.getVariable("$weather") === void 0) {
-      this.setVariable("$weather", {
-        condition: "Neon Mist",
-        temperature: 24,
-        humidity: 65,
-        windSpeed: 12,
-        unit: "C"
-      });
-    }
-    if (this.getVariable("$wallet") === void 0) {
-      this.setVariable("$wallet", {
-        address: "0xHolo...42ff",
-        balance: 1337.5,
-        currency: "HOLO",
-        network: "MainNet"
-      });
-    }
-    if (this.getVariable("$ai_config") === void 0) {
-      const savedKeys = typeof localStorage !== "undefined" ? localStorage.getItem("brittney_api_keys") : null;
-      let configuredCount = 0;
-      if (savedKeys) {
-        try {
-          const keys = JSON.parse(savedKeys);
-          configuredCount = Object.values(keys).filter((k) => !!k).length;
-        } catch (_e) {
-        }
-      }
-      this.setVariable("$ai_config", {
-        status: configuredCount > 0 ? "configured" : "pending",
-        providerCount: configuredCount,
-        lastUpdated: Date.now()
-      });
-    }
-    if (this.getVariable("$chat_status") === void 0) {
-      this.setVariable("$chat_status", {
-        active: true,
-        typing: false,
-        version: "1.0.0-brittney"
-      });
-    }
-  }
-  // ==========================================================================
-  // COMMERCE PRIMITIVES
-  // ==========================================================================
-  handleShop(args) {
-    const config = args[0] || {};
-    this.emit("shop", config);
-    return { success: true, type: "shop", config };
-  }
-  handleInventory(args) {
-    const item = args[0];
-    const action = args[1] || "add";
-    this.emit("inventory", { item, action });
-    return { success: true, item, action };
-  }
-  handlePurchase(args) {
-    const productId = args[0];
-    this.emit("purchase", { productId });
-    return { success: true, productId, status: "pending" };
-  }
-  // ==========================================================================
-  // SOCIAL PRIMITIVES
-  // ==========================================================================
-  handlePresence(args) {
-    const config = args[0] || {};
-    this.emit("presence", config);
-    return { success: true, active: true };
-  }
-  handleInvite(args) {
-    const userId = args[0];
-    this.emit("invite", { userId });
-    return { success: true, userId };
-  }
-  handleShare(args) {
-    const scriptId = args[0];
-    const targetUserId = args[1];
-    this.emit("share", { scriptId, targetUserId });
-    return { success: true, scriptId };
-  }
-  // ==========================================================================
-  // PHYSICS PRIMITIVES
-  // ==========================================================================
-  handlePhysics(args) {
-    const config = args[0] || {};
-    this.emit("physics", config);
-    return { success: true, enabled: config.enabled !== false };
-  }
-  handleGravity(args) {
-    const value = args[0] ?? 9.81;
-    this.emit("gravity", { value });
-    return { success: true, value };
-  }
-  handleCollide(args) {
-    const target = args[0];
-    const handler = args[1];
-    this.emit("collide", { target, handler });
-    return { success: true, target };
-  }
-  /**
-   * Handle calculate_arc(start, end, speed)
-   */
-  handleCalculateArc(args) {
-    if (args.length < 3) return { x: 0, y: 0, z: 0 };
-    const start = args[0];
-    const end = args[1];
-    const speed = args[2];
-    const dx = end.x - start.x;
-    const dz = end.z - start.z;
-    const dy = end.y - start.y;
-    const dist = Math.sqrt(dx * dx + dz * dz);
-    if (dist < 0.1) return { x: 0, y: speed, z: 0 };
-    const t = dist / speed;
-    const vx = dx / t;
-    const vz = dz / t;
-    const vy = dy / t + 0.5 * 9.81 * t;
-    return { x: vx, y: vy, z: vz };
-  }
-  handleAnimate(args) {
-    const options = args[0] || {};
-    this.emit("animate", options);
-    return { success: true, options };
-  }
-  applyEasing(t, easing) {
-    switch (easing) {
-      case "easeIn":
-        return t * t;
-      case "easeOut":
-        return t * (2 - t);
-      case "easeInOut":
-        return t < 0.5 ? 2 * t * t : -1 + (4 - 2 * t) * t;
-      case "easeInQuad":
-        return t * t;
-      case "easeOutQuad":
-        return t * (2 - t);
-      case "easeInOutQuad":
-        return t < 0.5 ? 2 * t * t : -1 + (4 - 2 * t) * t;
-      case "linear":
-      default:
-        return t;
-    }
-  }
-  // ============================================================================
-  // Particle Effects
-  // ============================================================================
-  createParticleEffect(name, position, color, count) {
-    const limitedCount = Math.min(count, RUNTIME_SECURITY_LIMITS.maxParticlesPerSystem);
-    const particles = [];
-    for (let i = 0; i < limitedCount; i++) {
-      particles.push({
-        x: position.x + (Math.random() - 0.5) * 2,
-        y: position.y + (Math.random() - 0.5) * 2,
-        z: position.z + (Math.random() - 0.5) * 2
-      });
-    }
-    this.particleSystems.set(name, {
-      particles,
-      color,
-      lifetime: 3e3,
-      speed: 0.01
-    });
-  }
-  createConnectionStream(from, to, fromPos, toPos, dataType) {
-    const streamName = `connection_${from}_${to}`;
-    const particles = [];
-    const steps = 20;
-    for (let i = 0; i <= steps; i++) {
-      const t = i / steps;
-      particles.push({
-        x: fromPos.x + (toPos.x - fromPos.x) * t,
-        y: fromPos.y + (toPos.y - fromPos.y) * t,
-        z: fromPos.z + (toPos.z - fromPos.z) * t
-      });
-    }
-    this.particleSystems.set(streamName, {
-      particles,
-      color: this.getDataTypeColor(dataType),
-      lifetime: 5e3,
-      speed: 0.02
-    });
-  }
-  createFlowingStream(name, position, data) {
-    const count = Array.isArray(data) ? Math.min(data.length, 50) : 10;
-    this.createParticleEffect(`${name}_flow`, position, "#45b7d1", count);
-  }
-  createExecutionEffect(name, position) {
-    this.createParticleEffect(`${name}_execution`, position, "#ff4500", 30);
-  }
-  createDataVisualization(name, data, position) {
-    let count = 10;
-    if (Array.isArray(data)) {
-      count = Math.min(data.length, 100);
-    } else if (typeof data === "object" && data !== null) {
-      count = Math.min(Object.keys(data).length * 5, 50);
-    }
-    this.createParticleEffect(`${name}_visualization`, position, "#32cd32", count);
-  }
-  getDataTypeColor(dataType) {
-    const colors = {
-      string: "#ff6b35",
-      number: "#4ecdc4",
-      boolean: "#45b7d1",
-      object: "#96ceb4",
-      array: "#ffeaa7",
-      any: "#dda0dd",
-      move: "#ff69b4"
-    };
-    return colors[dataType] || "#ffffff";
-  }
-  // ============================================================================
-  // Visualizer Server
-  // ============================================================================
-  startVisualizationServer(port = 8080) {
-    try {
-      this.wss = new WebSocketServer({ port });
-      logger.info(`[Visualizer] WebSocket server started on port ${port}`);
-      this.timeManager = new TimeManager(/* @__PURE__ */ new Date());
-      this.timeManager.onUpdate((julianDate, date) => {
-        this.updateTraits(julianDate);
-        this.broadcast("time_update", {
-          julianDate,
-          date: date.toISOString(),
-          timeScale: this.timeManager.getTimeScale(),
-          isPaused: this.timeManager.getIsPaused()
-        });
-      });
-      this.timeManager.start();
-      this.updateTraits(this.timeManager.getJulianDate());
-      this.wss.on("connection", (ws) => {
-        logger.info("[Visualizer] Client connected");
-        const orbs = Array.from(this.context.variables.entries()).filter(
-          ([_, v]) => v && typeof v === "object" && v.__type === "orb"
-        ).map(([id, v]) => {
-          const orbData = v;
-          return {
-            id,
-            name: orbData.name || id,
-            position: Array.isArray(orbData.position) ? { x: orbData.position[0], y: orbData.position[1], z: orbData.position[2] } : orbData.position,
-            properties: orbData.properties || {},
-            hologram: orbData.hologram || (() => {
-              const props = orbData.properties;
-              return {
-                color: props?.color || "#ffffff",
-                size: props?.size || props?.scale || 1,
-                shape: props?.geometry || "sphere",
-                glow: props?.glow || false
-              };
-            })(),
-            traits: orbData.traits || []
-          };
-        });
-        ws.send(
-          JSON.stringify({
-            type: "init",
-            orbs,
-            time: this.timeManager ? this.timeManager.getState() : null
-          })
-        );
-        ws.on("message", (message) => {
-          try {
-            const data = JSON.parse(message.toString());
-            if (data.type === "time_control") {
-              this.handleTimeControl(data.command, data.value);
-            }
-          } catch (e) {
-            logger.error("[Visualizer] Failed to parse message", { error: String(e) });
-          }
-        });
-      });
-    } catch (error) {
-      logger.error("[Visualizer] Failed to start server", { error: String(error) });
-    }
-  }
-  /**
-   * Handle time control commands from visualizer
-   */
-  handleTimeControl(command, value) {
-    if (!this.timeManager) return;
-    switch (command) {
-      case "play":
-        this.timeManager.play();
-        break;
-      case "pause":
-        this.timeManager.pause();
-        break;
-      case "toggle":
-        this.timeManager.togglePause();
-        break;
-      case "setSpeed":
-        if (typeof value === "number") {
-          this.timeManager.setTimeScale(value);
-        }
-        break;
-      case "setDate":
-        if (value) {
-          this.timeManager.setDate(new Date(value));
-        }
-        break;
-      case "syncRealTime":
-        this.timeManager.setDate(/* @__PURE__ */ new Date());
-        this.timeManager.setTimeScale(1);
-        this.timeManager.play();
-        break;
-    }
-  }
-  broadcast(type, payload) {
-    if (!this.wss) return;
-    const message = JSON.stringify({ type, payload });
-    this.wss.clients.forEach((client) => {
-      if (client.readyState === WebSocket.OPEN) {
-        client.send(message);
-      }
-    });
-  }
-  // ============================================================================
-  // Public API
-  // ============================================================================
-  getParticleSystems() {
-    return new Map(this.particleSystems);
-  }
-  updateParticles(deltaTime) {
-    for (const [name, system] of this.particleSystems) {
-      system.lifetime -= deltaTime;
-      system.particles.forEach((particle) => {
-        particle.x += (Math.random() - 0.5) * system.speed;
-        particle.y += (Math.random() - 0.5) * system.speed;
-        particle.z += (Math.random() - 0.5) * system.speed;
-      });
-      if (system.lifetime <= 0) {
-        this.particleSystems.delete(name);
-      }
-    }
-  }
-  getContext() {
-    return { ...this.context };
-  }
-  getUIElements() {
-    return new Map(this.uiElements);
-  }
-  getUIElement(name) {
-    return this.uiElements.get(name);
-  }
-  getAnimations() {
-    return new Map(this.animations);
-  }
-  reset() {
-    this.context = this.createEmptyContext();
-    this.currentScope = { variables: this.context.variables };
-    this.callStack = [];
-    this.particleSystems.clear();
-    this.executionHistory = [];
-    this.eventHandlers.clear();
-    this.animations.clear();
-    this.uiElements.clear();
-  }
-  createEmptyContext() {
-    return {
-      variables: /* @__PURE__ */ new Map(),
-      functions: /* @__PURE__ */ new Map(),
-      exports: /* @__PURE__ */ new Map(),
-      connections: [],
-      spatialMemory: /* @__PURE__ */ new Map(),
-      hologramState: /* @__PURE__ */ new Map(),
-      executionStack: [],
-      currentScale: 1,
-      scaleMagnitude: "standard",
-      focusHistory: [],
-      environment: {},
-      templates: /* @__PURE__ */ new Map(),
-      // HS+ State
-      state: createState({}),
-      // Phase 13: State Machines
-      stateMachines: /* @__PURE__ */ new Map(),
-      // Narrative & Story State
-      quests: /* @__PURE__ */ new Map(),
-      completedQuests: /* @__PURE__ */ new Set()
-    };
-  }
-  async executeScale(node) {
-    const parentScale = this.context.currentScale;
-    this.context.currentScale *= node.multiplier;
-    this.context.scaleMagnitude = node.magnitude;
-    logger.info("Scale context entering", {
-      magnitude: node.magnitude,
-      multiplier: this.context.currentScale
-    });
-    this.emit("scale:change", { multiplier: this.context.currentScale, magnitude: node.magnitude });
-    const results = await this.executeProgram(node.body, this.context.executionStack.length);
-    this.context.currentScale = parentScale;
-    this.emit("scale:change", { multiplier: this.context.currentScale });
-    return {
-      success: results.every((r) => r.success),
-      output: `Executed scale block: ${node.magnitude}`
-    };
-  }
-  async executeFocus(node) {
-    this.context.focusHistory.push(node.target);
-    const results = await this.executeProgram(node.body, this.context.executionStack.length);
-    return {
-      success: results.every((r) => r.success),
-      output: `Focused on ${node.target}`
-    };
-  }
-  async executeEnvironment(node) {
-    this.context.environment = { ...this.context.environment, ...node.settings };
-    return { success: true, output: "Environment updated" };
-  }
-  async executeComposition(node) {
-    if (node.body) {
-      const systemResults = await this.executeProgram(
-        node.body.systems,
-        this.context.executionStack.length
-      );
-      const configResults = await this.executeProgram(
-        node.body.configs,
-        this.context.executionStack.length
-      );
-      const childrenResults = await this.executeProgram(
-        node.body.children,
-        this.context.executionStack.length
-      );
-      const allResults = [...systemResults, ...configResults, ...childrenResults];
-      return {
-        success: allResults.every((r) => r.success),
-        output: `Composition ${node.name} executed with specialized blocks`
-      };
-    }
-    return {
-      success: (await this.executeProgram(node.children, this.context.executionStack.length)).every(
-        (r) => r.success
-      ),
-      output: `Composition ${node.name} executed`
-    };
-  }
-  resolveHoloValue(value) {
-    if (value === null) return null;
-    if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
-      return value;
-    }
-    if (Array.isArray(value)) {
-      return value.map((e) => this.resolveHoloValue(e));
-    }
-    if (value.__bind) {
-      return value;
-    }
-    const obj = {};
-    for (const k in value) {
-      obj[k] = this.resolveHoloValue(value[k]);
-    }
-    return obj;
-  }
-  async executeHoloComposition(node) {
-    for (const template of node.templates) {
-      await this.executeHoloTemplate(template);
-    }
-    if (node.environment) {
-      const envSettings = {};
-      for (const prop of node.environment.properties) {
-        envSettings[prop.key] = this.resolveHoloValue(prop.value);
-      }
-      this.context.environment = { ...this.context.environment, ...envSettings };
-    }
-    const results = [];
-    for (const object of node.objects) {
-      results.push(await this.executeHoloObject(object));
-    }
-    return {
-      success: results.every((r) => r.success),
-      output: `HoloComposition ${node.name} executed`
-    };
-  }
-  async executeHoloTemplate(node) {
-    this.context.templates.set(node.name, node);
-    return { success: true, output: `Template ${node.name} registered` };
-  }
-  async executeHoloObject(node) {
-    const properties = {};
-    for (const prop of node.properties) {
-      properties[prop.key] = this.resolveHoloValue(prop.value);
-    }
-    if (node.state) {
-      for (const prop of node.state.properties) {
-        properties[prop.key] = this.resolveHoloValue(prop.value);
-      }
-    }
-    const position = properties.position;
-    const hologram = {
-      shape: properties.geometry || "sphere",
-      color: properties.color || "#ffffff",
-      size: properties.scale || properties.size || 1,
-      glow: properties.glow || false,
-      interactive: properties.interactive !== false
-    };
-    const orbNode = {
-      type: "orb",
-      name: node.name,
-      position,
-      // Direct property for executeOrb
-      hologram,
-      // Direct property for executeOrb
-      properties,
-      // @ts-expect-error
-      directives: [
-        ...node.directives || [],
-        ...(node.traits || []).map((t) => ({ type: "trait", name: t.name, ...t.config })),
-        ...node.template ? this.context.templates.get(node.template)?.directives || [] : []
-        // Inherit template directives/traits
-      ],
-      traits: new Map((node.traits || []).map((t) => [t.name, t.config])),
-      children: node.children || []
-    };
-    if (node.template) {
-      const tpl = this.context.templates.get(node.template);
-      if (tpl) {
-        if (tpl.state) {
-          for (const prop of tpl.state.properties) {
-            if (properties[prop.key] === void 0) {
-              properties[prop.key] = this.resolveHoloValue(prop.value);
-            }
-          }
-        }
-        for (const prop of tpl.properties) {
-          if (properties[prop.key] === void 0) {
-            properties[prop.key] = this.resolveHoloValue(prop.value);
-          }
-        }
-      }
-    }
-    return this.executeOrb(orbNode);
-  }
-  /**
-   * Execute a block of HoloStatements (HoloNode AST)
-   */
-  async executeHoloProgram(statements, scopeOverride) {
-    const results = [];
-    telemetry.setGauge("execution_depth", this.context.executionStack.length);
-    for (const stmt of statements) {
-      telemetry.incrementCounter("statements_executed", 1, { type: stmt.type });
-      const res = await telemetry.measureLatency(
-        `execute_stmt_${stmt.type}`,
-        () => this.executeHoloStatement(stmt, scopeOverride)
-      );
-      results.push(res);
-      const last = results[results.length - 1];
-      if (last.success && last.output !== void 0 && stmt.type === "ReturnStatement") {
-        break;
-      }
-    }
-    return results;
-  }
-  async executeHoloStatement(stmt, scopeOverride) {
-    try {
-      switch (stmt.type) {
-        case "Assignment": {
-          const value = await this.evaluateHoloExpression(stmt.value, scopeOverride);
-          let finalValue = value;
-          if (stmt.operator !== "=") {
-            const current = this.getVariable(stmt.target, scopeOverride);
-            if (stmt.operator === "+=")
-              finalValue = Number(current) + Number(value);
-            else if (stmt.operator === "-=")
-              finalValue = Number(current) - Number(value);
-            else if (stmt.operator === "*=")
-              finalValue = Number(current) * Number(value);
-            else if (stmt.operator === "/=")
-              finalValue = Number(current) / Number(value);
-          }
-          this.setVariable(stmt.target, finalValue, scopeOverride);
-          return { success: true };
-        }
-        case "IfStatement": {
-          const condition = await this.evaluateHoloExpression(stmt.condition, scopeOverride);
-          if (condition) {
-            await this.executeHoloProgram(stmt.consequent, scopeOverride);
-          } else if (stmt.alternate) {
-            await this.executeHoloProgram(stmt.alternate, scopeOverride);
-          }
-          return { success: true };
-        }
-        case "WhileStatement": {
-          const MAX_ITERATIONS = 1e3;
-          let iter = 0;
-          while (await this.evaluateHoloExpression(stmt.condition, scopeOverride)) {
-            if (iter++ > MAX_ITERATIONS) return { success: false, error: "Infinite loop" };
-            await this.executeHoloProgram(stmt.body, scopeOverride);
-          }
-          return { success: true };
-        }
-        case "ClassicForStatement": {
-          if (stmt.init) await this.executeHoloStatement(stmt.init, scopeOverride);
-          const MAX_ITERATIONS = 1e3;
-          let iter = 0;
-          while (!stmt.test || await this.evaluateHoloExpression(stmt.test, scopeOverride)) {
-            if (iter++ > MAX_ITERATIONS) return { success: false, error: "Infinite loop" };
-            await this.executeHoloProgram(stmt.body, scopeOverride);
-            if (stmt.update) await this.executeHoloStatement(stmt.update, scopeOverride);
-          }
-          return { success: true };
-        }
-        case "VariableDeclaration": {
-          const value = stmt.value ? await this.evaluateHoloExpression(stmt.value, scopeOverride) : void 0;
-          const scope = scopeOverride || this.currentScope;
-          scope.variables.set(stmt.name, value);
-          return { success: true };
-        }
-        case "EmitStatement": {
-          const data = stmt.data ? await this.evaluateHoloExpression(stmt.data, scopeOverride) : void 0;
-          this.emit(stmt.event, data);
-          return { success: true };
-        }
-        case "AwaitStatement": {
-          const value = await this.evaluateHoloExpression(stmt.expression, scopeOverride);
-          if (value instanceof Promise) await value;
-          return { success: true };
-        }
-        case "ReturnStatement": {
-          const value = stmt.value ? await this.evaluateHoloExpression(stmt.value, scopeOverride) : null;
-          return { success: true, output: value };
-        }
-        case "ExpressionStatement": {
-          const val = await this.evaluateHoloExpression(stmt.expression, scopeOverride);
-          return { success: true, output: val };
-        }
-        default:
-          return {
-            success: false,
-            error: `Unknown stmt type: ${stmt.type}`
-          };
-      }
-    } catch (err) {
-      const errMsg = err instanceof Error ? err.message : String(err);
-      console.error(`[EXEC_ERROR] Statement ${stmt.type} failed:`, errMsg);
-      return { success: false, error: errMsg };
-    }
-  }
-  async evaluateHoloExpression(expr, scopeOverride) {
-    switch (expr.type) {
-      case "Literal":
-        return expr.value;
-      case "Identifier":
-        return this.getVariable(expr.name, scopeOverride);
-      case "MemberExpression": {
-        const obj = await this.evaluateHoloExpression(expr.object, scopeOverride);
-        if (obj && typeof obj === "object") {
-          return obj[expr.property];
-        }
-        return void 0;
-      }
-      case "CallExpression": {
-        if (!Array.isArray(expr.arguments)) {
-          console.error("[CRITICAL] arguments is not an array for", JSON.stringify(expr));
-          return void 0;
-        }
-        const callee = await this.evaluateHoloExpression(expr.callee, scopeOverride);
-        const args = await Promise.all(
-          expr.arguments.map((a) => this.evaluateHoloExpression(a, scopeOverride))
-        );
-        if (typeof callee === "function") {
-          return callee(...args);
-        }
-        if (expr.callee.type === "Identifier") {
-          const result = await this.callFunction(expr.callee.name, args);
-          return result.output;
-        }
-        return void 0;
-      }
-      case "BinaryExpression": {
-        const left = await this.evaluateHoloExpression(expr.left, scopeOverride);
-        const right = await this.evaluateHoloExpression(expr.right, scopeOverride);
-        switch (expr.operator) {
-          case "+":
-            return Number(left) + Number(right);
-          case "-":
-            return Number(left) - Number(right);
-          case "*":
-            return Number(left) * Number(right);
-          case "/":
-            return Number(left) / Number(right);
-          case "==":
-            return left == right;
-          case "===":
-            return left === right;
-          case "!=":
-            return left != right;
-          case "!==":
-            return left !== right;
-          case "<":
-            return Number(left) < Number(right);
-          case ">":
-            return Number(left) > Number(right);
-          case "<=":
-            return Number(left) <= Number(right);
-          case ">=":
-            return Number(left) >= Number(right);
-          case "&&":
-            return left && right;
-          case "||":
-            return left || right;
-          default:
-            return void 0;
-        }
-      }
-      case "ConditionalExpression": {
-        const test = await this.evaluateHoloExpression(expr.test, scopeOverride);
-        return test ? await this.evaluateHoloExpression(expr.consequent, scopeOverride) : await this.evaluateHoloExpression(expr.alternate, scopeOverride);
-      }
-      case "UpdateExpression": {
-        const val = await this.evaluateHoloExpression(expr.argument, scopeOverride);
-        const newVal = expr.operator === "++" ? val + 1 : val - 1;
-        const path2 = this.getMemberPath(expr.argument);
-        if (path2) {
-          this.setVariable(path2, newVal, scopeOverride);
-        }
-        return expr.prefix ? newVal : val;
-      }
-      case "ArrayExpression": {
-        return await Promise.all(
-          expr.elements.map((e) => this.evaluateHoloExpression(e, scopeOverride))
-        );
-      }
-      case "ObjectExpression": {
-        const obj = {};
-        for (const prop of expr.properties) {
-          obj[prop.key] = await this.evaluateHoloExpression(prop.value, scopeOverride);
-        }
-        return obj;
-      }
-      default:
-        return void 0;
-    }
-  }
-  getMemberPath(expr) {
-    if (expr.type === "Identifier") return expr.name;
-    if (expr.type === "MemberExpression") {
-      const parentPath = this.getMemberPath(expr.object);
-      if (parentPath) return `${parentPath}.${expr.property}`;
-    }
-    return null;
-  }
-  async executeSystem(node) {
-    const startTime = Date.now();
-    const systemId = node.id;
-    const properties = node.properties;
-    logger.info(`[Zero-Config] Provisioning system: ${systemId}`, properties);
-    switch (systemId) {
-      case "Networking":
-        return this.setupNetworking(node);
-      case "Physics":
-        return this.setupPhysics(node);
-      default:
-        logger.warn(`[Zero-Config] Unknown system: ${systemId}`);
-        return {
-          success: true,
-          output: `System ${systemId} not recognized, skipping provisioning`,
-          executionTime: Date.now() - startTime
-        };
-    }
-  }
-  async executeCoreConfig(node) {
-    const startTime = Date.now();
-    logger.info("[Zero-Config] Applying core configuration", node.properties);
-    for (const [key, value] of Object.entries(node.properties)) {
-      this.context.environment[key] = value;
-    }
-    return {
-      success: true,
-      output: "Core configuration applied",
-      executionTime: Date.now() - startTime
-    };
-  }
-  // =========================================================================
-  // Control Flow Execution
-  // =========================================================================
-  /**
-   * Execute a for loop: @for item in collection { ... }
-   */
-  async executeForLoop(node) {
-    const startTime = Date.now();
-    const { variable, iterable, body } = node;
-    try {
-      const collection = this.evaluateExpression(String(iterable));
-      if (!Array.isArray(collection) && typeof collection !== "object") {
-        return {
-          success: false,
-          error: `Cannot iterate over non-iterable: ${typeof collection}`,
-          executionTime: Date.now() - startTime
-        };
-      }
-      const items = Array.isArray(collection) ? collection : collection && typeof collection === "object" ? Object.entries(collection) : [];
-      let lastResult = { success: true, output: null };
-      for (const item of items) {
-        this.context.variables.set(variable, item);
-        for (const bodyNode of body) {
-          lastResult = await this.executeNode(bodyNode);
-          if (!lastResult.success) break;
-        }
-        if (!lastResult.success) break;
-      }
-      this.context.variables.delete(variable);
-      return {
-        success: true,
-        output: lastResult.output,
-        executionTime: Date.now() - startTime
-      };
-    } catch (error) {
-      return {
-        success: false,
-        error: `For loop error: ${error instanceof Error ? error.message : String(error)}`,
-        executionTime: Date.now() - startTime
-      };
-    }
-  }
-  /**
-   * Execute a forEach loop: @forEach item in collection { ... }
-   */
-  async executeForEachLoop(node) {
-    return this.executeForLoop({
-      variable: node.variable,
-      iterable: node.collection,
-      body: node.body
-    });
-  }
-  /**
-   * Execute a while loop: @while condition { ... }
-   */
-  async executeWhileLoop(node) {
-    const startTime = Date.now();
-    const { condition, body } = node;
-    const MAX_ITERATIONS = 1e4;
-    try {
-      let iterations = 0;
-      let lastResult = { success: true, output: null };
-      while (this.evaluateCondition(String(condition))) {
-        iterations++;
-        if (iterations > MAX_ITERATIONS) {
-          return {
-            success: false,
-            error: `While loop exceeded maximum iterations (${MAX_ITERATIONS})`,
-            executionTime: Date.now() - startTime
-          };
-        }
-        for (const bodyNode of body) {
-          lastResult = await this.executeNode(bodyNode);
-          if (!lastResult.success) break;
-        }
-        if (!lastResult.success) break;
-      }
-      return {
-        success: true,
-        output: lastResult.output,
-        executionTime: Date.now() - startTime
-      };
-    } catch (error) {
-      return {
-        success: false,
-        error: `While loop error: ${error instanceof Error ? error.message : String(error)}`,
-        executionTime: Date.now() - startTime
-      };
-    }
-  }
-  /**
-   * Execute an if statement: @if condition { ... } @else { ... }
-   */
-  async executeIfStatement(node) {
-    const startTime = Date.now();
-    const { condition, body, elseBody } = node;
-    try {
-      const conditionResult = this.evaluateCondition(String(condition));
-      const branchToExecute = conditionResult ? body : elseBody || [];
-      let lastResult = { success: true, output: null };
-      for (const bodyNode of branchToExecute) {
-        lastResult = await this.executeNode(bodyNode);
-        if (!lastResult.success) break;
-      }
-      return {
-        success: true,
-        output: lastResult.output,
-        executionTime: Date.now() - startTime
-      };
-    } catch (error) {
-      return {
-        success: false,
-        error: `If statement error: ${error instanceof Error ? error.message : String(error)}`,
-        executionTime: Date.now() - startTime
-      };
-    }
-  }
-  /**
-   * Execute a match expression: @match subject { pattern => result, ... }
-   */
-  async executeMatch(node) {
-    const startTime = Date.now();
-    const { subject, cases } = node;
-    try {
-      const subjectValue = this.evaluateExpression(String(subject));
-      for (const matchCase of cases || []) {
-        const patternValue = this.evaluateExpression(String(matchCase.pattern));
-        if (this.patternMatches(patternValue, subjectValue)) {
-          if (matchCase.guard && !this.evaluateCondition(String(matchCase.guard))) {
-            continue;
-          }
-          if (Array.isArray(matchCase.body)) {
-            let lastResult = { success: true, output: null };
-            for (const bodyNode of matchCase.body) {
-              lastResult = await this.executeNode(bodyNode);
-              if (!lastResult.success) break;
-            }
-            return lastResult;
-          } else {
-            const result = this.evaluateExpression(String(matchCase.body));
-            return { success: true, output: result, executionTime: Date.now() - startTime };
-          }
-        }
-      }
-      return {
-        success: false,
-        error: "No pattern matched",
-        executionTime: Date.now() - startTime
-      };
-    } catch (error) {
-      return {
-        success: false,
-        error: `Match expression error: ${error instanceof Error ? error.message : String(error)}`,
-        executionTime: Date.now() - startTime
-      };
-    }
-  }
-  /**
-   * Check if a pattern matches a value
-   */
-  patternMatches(pattern, value) {
-    if (pattern === "_" || pattern === "else" || pattern === "default") {
-      return true;
-    }
-    if (pattern === value) {
-      return true;
-    }
-    if (pattern === "string" && typeof value === "string") return true;
-    if (pattern === "number" && typeof value === "number") return true;
-    if (pattern === "boolean" && typeof value === "boolean") return true;
-    if (pattern === "array" && Array.isArray(value)) return true;
-    if (pattern === "object" && typeof value === "object" && value !== null) return true;
-    if (Array.isArray(pattern) && pattern.length === 2) {
-      const [min, max] = pattern;
-      if (typeof value === "number" && typeof min === "number" && typeof max === "number" && value >= min && value <= max) {
-        return true;
-      }
-    }
-    return false;
-  }
-  async executeNarrative(node) {
-    const startTime = Date.now();
-    logger.info(`[Narrative] Initializing narrative: ${node.id}`);
-    for (const quest of node.quests) {
-      this.context.quests.set(quest.id, quest);
-    }
-    if (node.startNode) {
-      logger.info(`[Narrative] Auto-starting at node: ${node.startNode}`);
-    }
-    return {
-      success: true,
-      output: `Narrative ${node.id} initialized with ${node.quests.length} quests`,
-      executionTime: Date.now() - startTime
-    };
-  }
-  async executeQuest(node) {
-    const startTime = Date.now();
-    logger.info(`[Narrative] Starting quest: ${node.title}`, { questId: node.id });
-    this.context.activeQuestId = node.id;
-    this.context.quests.set(node.id, node);
-    return {
-      success: true,
-      output: `Quest ${node.id} started`,
-      executionTime: Date.now() - startTime
-    };
-  }
-  async executeDialogue(node) {
-    const startTime = Date.now();
-    logger.info(`[Narrative] Dialogue: ${node.speaker} says "${node.text}"`);
-    this.context.dialogueState = {
-      currentNodeId: node.id,
-      speaker: node.speaker
-    };
-    return {
-      success: true,
-      output: `Dialogue node ${node.id} executed`,
-      executionTime: Date.now() - startTime
-    };
-  }
-  async executeVisualMetadata(node) {
-    logger.info(`[Metadata] Visual metadata processed`, node.properties);
-    return { success: true, output: "Visual metadata applied" };
-  }
-  async setupNetworking(node) {
-    const startTime = Date.now();
-    logger.info("[Networking] Initializing multiplayer fabric...", node.properties);
-    return {
-      success: true,
-      output: "Networking system provisioned",
-      executionTime: Date.now() - startTime
-    };
-  }
-  async setupPhysics(node) {
-    const startTime = Date.now();
-    logger.info("[Physics] Initializing spatial simulation engine...", node.properties);
-    return {
-      success: true,
-      output: "Physics system provisioned",
-      executionTime: Date.now() - startTime
-    };
-  }
-  async executeTemplate(node) {
-    const existing = this.context.templates.get(node.name);
-    if (existing) {
-      node._previousVersion = existing.version;
-    }
-    this.context.templates.set(node.name, node);
-    return {
-      success: true,
-      output: `Template ${node.name} registered (v${node.version || "unknown"})`
-    };
-  }
-  /**
-   * Execute a migration script for an object
-   */
-  async executeMigrationBlock(orb, migration) {
-    logger.info(`Running migration for ${orb.name}...`);
-    const previousScope = this.currentScope;
-    this.currentScope = {
-      variables: /* @__PURE__ */ new Map([
-        ["this", orb],
-        ["self", orb]
-      ]),
-      parent: previousScope
-    };
-    try {
-      const parser = new HoloScriptCodeParser();
-      const result = parser.parse(migration.body);
-      if (result.errors.length > 0) {
-        logger.error(`Migration parse errors for ${orb.name}:`, { errors: result.errors });
-        return;
-      }
-      await this.executeProgram(result.ast, 0);
-    } finally {
-      this.currentScope = previousScope;
-    }
-    logger.info(`Migration complete for ${orb.name}`);
-  }
-  async executeServerNode(node) {
-    if (this.context.mode === "public") {
-      return {
-        success: false,
-        error: "SecurityViolation: Server creation blocked in public mode.",
-        executionTime: 0
-      };
-    }
-    logger.info(`Starting server on port ${node.port}`);
-    return {
-      success: true,
-      output: `Server listening on port ${node.port}`,
-      hologram: node.hologram,
-      executionTime: 0
-    };
-  }
-  async executeDatabaseNode(node) {
-    if (this.context.mode === "public") {
-      return {
-        success: false,
-        error: "SecurityViolation: DB access blocked in public mode.",
-        executionTime: 0
-      };
-    }
-    logger.info(`Executing Query: ${node.query}`);
-    return {
-      success: true,
-      output: `Query executed: ${node.query}`,
-      hologram: node.hologram,
-      executionTime: 0
-    };
-  }
-  async executeFetchNode(node) {
-    if (this.context.mode === "public") {
-      return {
-        success: false,
-        error: "SecurityViolation: External fetch blocked in public mode.",
-        executionTime: 0
-      };
-    }
-    logger.info(`Fetching: ${node.url}`);
-    return {
-      success: true,
-      output: `Fetched data from ${node.url}`,
-      hologram: node.hologram,
-      executionTime: 0
-    };
-  }
-  async executeTarget(node) {
-    const target = this.context.functions.get(node.target);
-    if (!target) {
-      return {
-        success: false,
-        error: `Function ${node.target} not found`,
-        executionTime: 0
-      };
-    }
-    const result = await this.executeFunction(target);
-    this.createExecutionEffect(node.target, target.position || { x: 0, y: 0, z: 0 });
-    return {
-      success: true,
-      output: `Executed ${node.target}`,
-      hologram: {
-        shape: "sphere",
-        color: "#ff4500",
-        size: 1.2,
-        glow: true,
-        interactive: false
-      },
-      executionTime: result.executionTime
-    };
-  }
-  async executeStateDeclaration(node) {
-    const stateDirective = node.directives?.find((d) => d.type === "state");
-    if (stateDirective) {
-      this.context.state.update(stateDirective.body);
-    }
-    return { success: true, output: "State updated" };
-  }
-  // ============================================================================
-  // Memory Syntactic Execution (Phase 7 / EVOLVE)
-  // ============================================================================
-  async executeMemory(node) {
-    const startTime = Date.now();
-    logger.info(`[Memory] Initializing memory block: ${node.name}`);
-    const memoryState = {
-      id: node.name,
-      type: "agent-memory"
-    };
-    if (node.semantic) {
-      const semResult = await this.executeNode(node.semantic);
-      if (semResult.success) memoryState.semantic = semResult.output;
-    }
-    if (node.episodic) {
-      const epResult = await this.executeNode(node.episodic);
-      if (epResult.success) memoryState.episodic = epResult.output;
-    }
-    if (node.procedural) {
-      const procResult = await this.executeNode(node.procedural);
-      if (procResult.success) memoryState.procedural = procResult.output;
-    }
-    this.context.variables.set(node.name, memoryState);
-    this.emit("memory_initialized", { memoryId: node.name, config: memoryState });
-    return {
-      success: true,
-      output: memoryState,
-      executionTime: Date.now() - startTime
-    };
-  }
-  loadSkill(skill) {
-    logger.info(`[Procedural] Loading skill: ${skill.name} (${skill.id})`);
-    const existing = this.proceduralSkills.get(skill.id);
-    if (existing) {
-      skill.successRate = (existing.successRate + (skill.successRate || 0)) / 2;
-    } else {
-      skill.successRate = skill.successRate || 0;
-    }
-    this.proceduralSkills.set(skill.id, skill);
-    StateSynchronizer.getInstance().broadcastSkill(skill);
-  }
-  async executeSkill(skillId, contextVariables = {}) {
-    const skill = this.proceduralSkills.get(skillId);
-    if (!skill) {
-      throw new Error(`[Procedural] Skill '${skillId}' not found.`);
-    }
-    logger.info(`[Procedural] Executing skill: ${skill.name}`);
-    const startTime = Date.now();
-    const previousScope = this.currentScope;
-    this.currentScope = { variables: new Map(previousScope.variables), parent: previousScope };
-    for (const [key, val] of Object.entries(contextVariables)) {
-      this.currentScope.variables.set(key, val);
-    }
-    try {
-      const result = await this.executeNode(skill.action);
-      if (result.success) {
-        skill.successRate = Math.min(100, skill.successRate + 1);
-      } else {
-        skill.successRate = Math.max(0, skill.successRate - 1);
-      }
-      StateSynchronizer.getInstance().broadcastSkill(skill);
-      return {
-        ...result,
-        executionTime: Date.now() - startTime
-      };
-    } finally {
-      this.currentScope = previousScope;
-    }
-  }
-  async executeMemoryDefinition(node) {
-    const startTime = Date.now();
-    const config = {};
-    for (const [key, val] of Object.entries(node.properties || {})) {
-      if (typeof val === "string") {
-        config[key] = this.evaluateExpression(val);
-      } else {
-        config[key] = val;
-      }
-    }
-    return {
-      success: true,
-      output: {
-        type: node.type,
-        config
-      },
-      executionTime: Date.now() - startTime
-    };
-  }
-  applyDirectives(node) {
-    if (!node.directives) return;
-    for (const d of node.directives) {
-      if (d.type === "trait") {
-        logger.info(`Applying trait ${d.name} to ${node.type}`);
-        const handler = this.traitHandlers.get(d.name);
-        if (handler) {
-          handler.onAttach?.(node, d.config || {}, {
-            emit: (event, payload) => this.emit(event, payload),
-            getScaleMultiplier: () => this.context.currentScale || 1
-          });
-        }
-        if (d.name === "chat") {
-          this.emit("show-chat", d.config);
-        }
-      } else if (d.type === "state") {
-        if (node && node.__type === "orb") {
-          const stateBody = d.body;
-          const existingProps = node.properties || {};
-          for (const [key, val] of Object.entries(stateBody)) {
-            if (existingProps[key] === void 0) {
-              existingProps[key] = val;
-            }
-          }
-          node.properties = existingProps;
-        }
-        this.context.state.update(d.body);
-      } else if (d.type === "lifecycle") {
-        if (d.hook === "on_mount" || d.hook === "mount") {
-          this.evaluateExpression(d.body);
-        }
-      }
-    }
-  }
-  getExecutionHistory() {
-    return [...this.executionHistory];
-  }
-  getHologramStates() {
-    return new Map(this.context.hologramState);
-  }
-  getCallStack() {
-    return [...this.callStack];
-  }
-  getState() {
-    return this.context.state.getSnapshot();
-  }
-  getRootScope() {
-    return this.currentScope;
-  }
-  isAgent(node) {
-    return !!node.directives?.some(
-      (d) => d.type === "trait" && (d.name === "llm_agent" || d.name === "agent" || d.name === "companion")
-    );
-  }
-  /**
-   * Get current simulation time (Julian date) for orbital calculations
-   */
-  getSimulationTime() {
-    return this.timeManager?.getJulianDate() || 0;
-  }
-  /**
-   * Set orb position and broadcast update
-   */
-  setOrbPosition(orbName, position) {
-    const orb = this.context.variables.get(orbName);
-    if (orb && typeof orb === "object" && orb.__type === "orb") {
-      orb.position = position;
-      this.broadcast("orb_update", {
-        orb: {
-          id: orbName,
-          name: orbName,
-          position
-        }
-      });
-    }
-  }
-  /**
-   * Update all orbs that have traits with an onUpdate method
-   */
-  updateTraits(julianDate) {
-    const delta = 1 / 60;
-    for (const [name, value] of this.context.variables.entries()) {
-      if (value && typeof value === "object" && value.__type === "orb") {
-        const orb = value;
-        if (orb.directives) {
-          for (const d of orb.directives || []) {
-            if (d.type === "trait") {
-              const handler = this.traitHandlers.get(d.name);
-              if (handler && handler.onUpdate) {
-                const traitNode = orb;
-                handler.onUpdate(
-                  traitNode,
-                  d.config || {},
-                  {
-                    emit: (event, payload) => {
-                      if (event === "position_update") {
-                        const posPayload = payload;
-                        if (posPayload?.position) {
-                          this.setOrbPosition(name, posPayload.position);
-                        }
-                      }
-                      return this.emit(event, payload);
-                    },
-                    getScaleMultiplier: () => this.context.currentScale || 1,
-                    julianDate,
-                    getNode: (nodeName) => this.context.variables.get(nodeName),
-                    getState: () => this.getState(),
-                    setState: (updates) => this.context.state.update(updates)
-                  },
-                  delta
-                );
-              }
-            }
-          }
-        }
-      }
-    }
-  }
-};
-__decorateClass([
-  MethodMemoize(500)
-], HoloScriptRuntime.prototype, "getMemberPath", 1);
-
-export { EventBus, HoloScriptRuntime, PriorityScorer, SpatialSharder, StateSynchronizer, TransactionLog, getSharedEventBus, setSharedEventBus, telemetry };
-//# sourceMappingURL=chunk-C2QHVHZF.js.map
-//# sourceMappingURL=chunk-C2QHVHZF.js.map