@holoscript/core 2.0.0 → 2.0.2

package/dist/chunk-3N67RLQP.cjs

@@ -0,0 +1,1298 @@
+'use strict';
+
+var chunk3X2EGU7Z_cjs = require('./chunk-3X2EGU7Z.cjs');
+
+// src/HoloScriptRuntime.ts
+var RUNTIME_SECURITY_LIMITS = {
+  maxExecutionDepth: 50,
+  maxTotalNodes: 1e3,
+  maxExecutionTimeMs: 5e3,
+  maxParticlesPerSystem: 1e3,
+  maxCallStackDepth: 100
+};
+var HoloScriptRuntime = class {
+  constructor(_importLoader) {
+    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();
+  }
+  /**
+   * Initialize built-in functions
+   */
+  initBuiltins() {
+    const builtins = /* @__PURE__ */ new Map();
+    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);
+      }
+      chunk3X2EGU7Z_cjs.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;
+      chunk3X2EGU7Z_cjs.logger.info("hide", { target });
+      return { hidden: target };
+    });
+    builtins.set("pulse", (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("log", (args) => {
+      chunk3X2EGU7Z_cjs.logger.info("HoloScript log", { args });
+      return args[0];
+    });
+    builtins.set("print", (args) => {
+      const message = args.map(String).join(" ");
+      chunk3X2EGU7Z_cjs.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");
+    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 "execute":
+        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;
+        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 in sequence
+   */
+  async executeProgram(nodes, depth = 0) {
+    if (depth === 0) {
+      this.startTime = Date.now();
+      this.nodeCount = 0;
+    }
+    if (depth > RUNTIME_SECURITY_LIMITS.maxExecutionDepth) {
+      chunk3X2EGU7Z_cjs.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) {
+        chunk3X2EGU7Z_cjs.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) {
+        chunk3X2EGU7Z_cjs.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;
+    expr = expr.trim();
+    const suspicious = ["eval", "process", "require", "__proto__", "constructor", "Function"];
+    if (suspicious.some((kw) => expr.toLowerCase().includes(kw))) {
+      chunk3X2EGU7Z_cjs.logger.warn("Suspicious expression blocked", { expr });
+      return void 0;
+    }
+    if (expr.startsWith('"') && expr.endsWith('"') || expr.startsWith("'") && expr.endsWith("'")) {
+      return expr.slice(1, -1);
+    }
+    if (/^-?\d+(\.\d+)?$/.test(expr)) {
+      return parseFloat(expr);
+    }
+    if (expr === "true") return true;
+    if (expr === "false") return false;
+    if (expr === "null") return null;
+    if (expr === "undefined") return void 0;
+    if (expr.startsWith("[") && expr.endsWith("]")) {
+      const inner = expr.slice(1, -1);
+      if (!inner.trim()) return [];
+      const elements = this.splitByComma(inner);
+      return elements.map((e) => this.evaluateExpression(e.trim()));
+    }
+    if (expr.startsWith("{") && expr.endsWith("}")) {
+      const inner = expr.slice(1, -1);
+      if (!inner.trim()) return {};
+      const pairs = this.splitByComma(inner);
+      const obj = {};
+      for (const pair of pairs) {
+        const colonIndex = pair.indexOf(":");
+        if (colonIndex > 0) {
+          const key = pair.slice(0, colonIndex).trim();
+          const value = pair.slice(colonIndex + 1).trim();
+          obj[key] = this.evaluateExpression(value);
+        }
+      }
+      return obj;
+    }
+    const funcMatch = expr.match(/^(\w+)\s*\((.*)?\)$/);
+    if (funcMatch) {
+      const [, funcName, argsStr] = funcMatch;
+      const args = argsStr ? this.splitByComma(argsStr).map((a) => this.evaluateExpression(a.trim())) : [];
+      const builtin = this.builtinFunctions.get(funcName);
+      if (builtin) {
+        return builtin(args);
+      }
+      if (this.context.functions.has(funcName)) {
+        return { __holoCall: funcName, args };
+      }
+      return void 0;
+    }
+    const binaryOps = [
+      { pattern: /(.+)\s*\+\s*(.+)/, op: (a, b) => typeof a === "string" || typeof b === "string" ? String(a) + String(b) : Number(a) + Number(b) },
+      { pattern: /(.+)\s*-\s*(.+)/, op: (a, b) => Number(a) - Number(b) },
+      { pattern: /(.+)\s*\*\s*(.+)/, op: (a, b) => Number(a) * Number(b) },
+      { pattern: /(.+)\s*\/\s*(.+)/, op: (a, b) => Number(b) !== 0 ? Number(a) / Number(b) : 0 },
+      { pattern: /(.+)\s*%\s*(.+)/, op: (a, b) => Number(a) % Number(b) }
+    ];
+    for (const { pattern, op } of binaryOps) {
+      const match = expr.match(pattern);
+      if (match) {
+        const left = this.evaluateExpression(match[1]);
+        const right = this.evaluateExpression(match[2]);
+        return op(left, right);
+      }
+    }
+    return this.getVariable(expr);
+  }
+  /**
+   * Split string by comma, respecting nesting
+   */
+  splitByComma(str) {
+    const parts = [];
+    let current = "";
+    let depth = 0;
+    let inString = false;
+    let stringChar = "";
+    for (let i = 0; i < str.length; i++) {
+      const char = str[i];
+      if (!inString && (char === '"' || char === "'")) {
+        inString = true;
+        stringChar = char;
+      } else if (inString && char === stringChar && str[i - 1] !== "\\") {
+        inString = false;
+      }
+      if (!inString) {
+        if (char === "(" || char === "[" || char === "{") depth++;
+        if (char === ")" || char === "]" || char === "}") depth--;
+        if (char === "," && depth === 0) {
+          parts.push(current.trim());
+          current = "";
+          continue;
+        }
+      }
+      current += char;
+    }
+    if (current.trim()) {
+      parts.push(current.trim());
+    }
+    return parts;
+  }
+  // ============================================================================
+  // Node Executors
+  // ============================================================================
+  async executeOrb(node) {
+    if (node.position) {
+      this.context.spatialMemory.set(node.name, node.position);
+    }
+    const orbData = {
+      __type: "orb",
+      name: node.name,
+      properties: { ...node.properties },
+      position: node.position || { x: 0, y: 0, z: 0 },
+      hologram: node.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 (node.hologram) {
+      this.context.hologramState.set(node.name, node.hologram);
+    }
+    this.createParticleEffect(`${node.name}_creation`, node.position || { x: 0, y: 0, z: 0 }, "#00ffff", 20);
+    chunk3X2EGU7Z_cjs.logger.info("Orb created", { name: node.name, properties: Object.keys(node.properties) });
+    return {
+      success: true,
+      output: orbData,
+      hologram: node.hologram,
+      spatialPosition: node.position
+    };
+  }
+  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);
+    chunk3X2EGU7Z_cjs.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);
+      });
+    }
+    chunk3X2EGU7Z_cjs.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;
+      chunk3X2EGU7Z_cjs.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);
+    chunk3X2EGU7Z_cjs.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);
+    chunk3X2EGU7Z_cjs.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);
+        });
+      }
+    }
+    chunk3X2EGU7Z_cjs.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];
+    chunk3X2EGU7Z_cjs.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:
+          chunk3X2EGU7Z_cjs.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);
+    chunk3X2EGU7Z_cjs.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);
+    chunk3X2EGU7Z_cjs.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);
+    chunk3X2EGU7Z_cjs.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);
+    chunk3X2EGU7Z_cjs.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);
+    chunk3X2EGU7Z_cjs.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);
+    }
+    chunk3X2EGU7Z_cjs.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);
+    }
+    chunk3X2EGU7Z_cjs.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))) {
+      chunk3X2EGU7Z_cjs.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) {
+      chunk3X2EGU7Z_cjs.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) ? [...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:
+        chunk3X2EGU7Z_cjs.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);
+  }
+  /**
+   * 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) {
+        chunk3X2EGU7Z_cjs.logger.error("Event handler error", { event, error });
+      }
+    }
+  }
+  /**
+   * Trigger UI event
+   */
+  async triggerUIEvent(elementName, eventType, data) {
+    const element = this.uiElements.get(elementName);
+    if (!element) {
+      chunk3X2EGU7Z_cjs.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;
+      }
+    }
+  }
+  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: []
+    };
+  }
+  getExecutionHistory() {
+    return [...this.executionHistory];
+  }
+  getHologramStates() {
+    return new Map(this.context.hologramState);
+  }
+  getCallStack() {
+    return [...this.callStack];
+  }
+};
+
+exports.HoloScriptRuntime = HoloScriptRuntime;
+//# sourceMappingURL=chunk-3N67RLQP.cjs.map
+//# sourceMappingURL=chunk-3N67RLQP.cjs.map