@holoscript/core 2.0.1 → 2.1.0

package/dist/chunk-AFFVFO4D.js

@@ -0,0 +1,1689 @@
+import { logger } from './chunk-SATNCODL.js';
+
+// 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;
+  }
+  update(updates) {
+    Object.assign(this.proxy, updates);
+  }
+  subscribe(callback) {
+    this.subscribers.add(callback);
+    return () => this.subscribers.delete(callback);
+  }
+  getSnapshot() {
+    return { ...this.state };
+  }
+  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\s*\./,
+      /\bglobal\s*\./,
+      /\b__dirname\b/,
+      /\b__filename\b/,
+      /\bfs\s*\./,
+      /\bchild_process\s*\./,
+      /\bfs\.writeFileSync/,
+      /\bfs\.readFileSync/
+    ];
+    for (const pattern of dangerousPatterns) {
+      if (pattern.test(expression)) {
+        console.warn(`Security: Blocked suspicious expression: ${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, `return (${expression})`);
+      return fn(...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/HoloScriptRuntime.ts
+var RUNTIME_SECURITY_LIMITS = {
+  maxExecutionDepth: 50,
+  maxTotalNodes: 1e3,
+  maxExecutionTimeMs: 5e3,
+  maxParticlesPerSystem: 1e3,
+  maxCallStackDepth: 100
+};
+var HoloScriptRuntime = class {
+  constructor(_importLoader, customFunctions) {
+    this.particleSystems = /* @__PURE__ */ new Map();
+    this.executionHistory = [];
+    this.startTime = 0;
+    this.nodeCount = 0;
+    this.callStack = [];
+    this.eventHandlers = /* @__PURE__ */ new Map();
+    this.animations = /* @__PURE__ */ new Map();
+    this.uiElements = /* @__PURE__ */ new Map();
+    this.context = this.createEmptyContext();
+    this.currentScope = { variables: this.context.variables };
+    this.builtinFunctions = this.initBuiltins(customFunctions);
+  }
+  /**
+   * 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", (args) => {
+      const target = String(args[0]);
+      const position = args[1] || { x: 0, y: 0, z: 0 };
+      this.context.spatialMemory.set(target, position);
+      this.createParticleEffect(`${target}_spawn`, position, "#00ff00", 25);
+      return { spawned: target, at: position };
+    });
+    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("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));
+    return builtins;
+  }
+  /**
+   * Execute a single AST node
+   */
+  async executeNode(node) {
+    const startTime = Date.now();
+    try {
+      this.context.executionStack.push(node);
+      let result;
+      switch (node.type) {
+        case "orb":
+          result = await this.executeOrb(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 "generic":
+          result = await this.executeGeneric(node);
+          break;
+        case "expression-statement":
+          result = await this.executeCall(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":
+          result = await this.executeComposition(node);
+          break;
+        case "template":
+          result = await this.executeTemplate(node);
+          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;
+        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) {
+    if (Array.isArray(nodes)) {
+      const results = await this.executeProgram(nodes);
+      const success = results.every((r) => r.success);
+      return {
+        success,
+        output: success ? `Program executed (${results.length} nodes)` : "Program failed",
+        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 = 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 (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) {
+    if (name.includes(".")) {
+      const parts = name.split(".");
+      const objName = parts[0];
+      const propPath = parts.slice(1);
+      let obj = this.getVariable(objName);
+      if (obj === void 0 || typeof obj !== "object" || obj === null) {
+        obj = {};
+        this.currentScope.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 {
+      this.currentScope.variables.set(name, value);
+    }
+  }
+  /**
+   * Get a variable from scope chain
+   */
+  getVariable(name) {
+    if (name.includes(".")) {
+      const parts = name.split(".");
+      let value = this.getVariable(parts[0]);
+      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 = 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
+   */
+  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 adjustedPos = node.position ? {
+      x: node.position.x * scale,
+      y: node.position.y * scale,
+      z: node.position.z * scale
+    } : { x: 0, y: 0, z: 0 };
+    if (node.position) {
+      this.context.spatialMemory.set(node.name, adjustedPos);
+    }
+    const hologram = node.hologram ? {
+      ...node.hologram,
+      size: (node.hologram.size || 1) * scale
+    } : void 0;
+    const evaluatedProperties = {};
+    for (const [key, val] of Object.entries(node.properties)) {
+      if (typeof val === "string") {
+        evaluatedProperties[key] = this.evaluateExpression(val);
+      } else {
+        evaluatedProperties[key] = val;
+      }
+    }
+    const orbData = {
+      __type: "orb",
+      name: node.name,
+      properties: evaluatedProperties,
+      traits: node.directives?.filter((d) => d.type === "trait").map((d) => d.name) || [],
+      directives: node.directives || [],
+      position: adjustedPos,
+      hologram,
+      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])
+    };
+    this.context.variables.set(node.name, orbData);
+    if (hologram) {
+      this.context.hologramState.set(node.name, hologram);
+    }
+    if (node.directives) {
+      this.applyDirectives(node);
+    }
+    this.createParticleEffect(`${node.name}_creation`, adjustedPos, "#00ffff", 20);
+    logger.info("Orb created", { name: node.name, properties: Object.keys(node.properties), scale });
+    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 path = condition ? node.truePath : node.falsePath;
+      logger.info("Gate evaluation", { condition: node.condition, result: condition });
+      if (path.length > 0) {
+        await this.executeProgram(path, this.callStack.length + 1);
+      }
+      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
+    };
+  }
+  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 value = this.evaluateExpression(String(node.value));
+    return {
+      success: true,
+      output: value
+    };
+  }
+  // ============================================================================
+  // Condition Evaluation
+  // ============================================================================
+  evaluateCondition(condition) {
+    if (!condition) return false;
+    const suspiciousKeywords = ["eval", "process", "require", "__proto__", "constructor"];
+    if (suspiciousKeywords.some((kw) => condition.toLowerCase().includes(kw))) {
+      logger.warn("Suspicious condition blocked", { condition });
+      return false;
+    }
+    try {
+      if (condition.trim().toLowerCase() === "true") return true;
+      if (condition.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 = condition.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 (condition.startsWith("!")) {
+        return !this.evaluateCondition(condition.slice(1).trim());
+      }
+      const value = this.evaluateExpression(condition.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) {
+    const handlers = this.eventHandlers.get(event) || [];
+    for (const handler of handlers) {
+      try {
+        await handler(data);
+      } catch (error) {
+        logger.error("Event handler error", { event, error });
+      }
+    }
+  }
+  /**
+   * 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);
+      let 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";
+  }
+  // ============================================================================
+  // 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(),
+      state: createState({})
+    };
+  }
+  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) {
+    return {
+      success: (await this.executeProgram(node.children, this.context.executionStack.length)).every((r) => r.success),
+      output: `Composition ${node.name} executed`
+    };
+  }
+  async executeTemplate(node) {
+    this.context.templates.set(node.name, node);
+    return { success: true, output: `Template ${node.name} registered` };
+  }
+  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" };
+  }
+  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}`);
+        if (d.name === "chat") {
+          this.emit("show-chat", d.config);
+        }
+      } else if (d.type === "state") {
+        this.context.state.update(d.body);
+      } else if (d.type === "lifecycle") {
+        if (d.hook === "on_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();
+  }
+};
+
+export { HoloScriptRuntime };
+//# sourceMappingURL=chunk-AFFVFO4D.js.map
+//# sourceMappingURL=chunk-AFFVFO4D.js.map