@holoscript/core 2.0.1 → 2.0.2

package/{src/HoloScriptRuntime.ts → dist/chunk-EU6CZMGJ.js}

@@ -1,116 +1,33 @@
-/**
- * HoloScript Runtime Engine
- *
- * Executes HoloScript AST in VR environment with spatial computation.
- * Supports:
- * - Orb creation and manipulation
- * - Function definition and invocation with arguments
- * - Connections and reactive data flow
- * - Gates (conditionals)
- * - Streams (data pipelines)
- * - 2D UI elements
- * - Built-in commands (show, hide, animate, pulse)
- * - Expression evaluation
- * - Event system
- */
+import { logger } from './chunk-SATNCODL.js';
 
-import { logger } from './logger';
-import type {
-  ASTNode,
-  OrbNode,
-  MethodNode,
-  ConnectionNode,
-  GateNode,
-  StreamNode,
-  SpatialPosition,
-  HologramProperties,
-  HologramShape,
-  RuntimeContext,
-  ExecutionResult,
-  ParticleSystem,
-  TransformationNode,
-  UI2DNode,
-} from './types';
-import type { ImportLoader } from './types';
-
-const RUNTIME_SECURITY_LIMITS = {
+// src/HoloScriptRuntime.ts
+var RUNTIME_SECURITY_LIMITS = {
   maxExecutionDepth: 50,
-  maxTotalNodes: 1000,
-  maxExecutionTimeMs: 5000,
-  maxParticlesPerSystem: 1000,
-  maxStringLength: 10000,
-  maxCallStackDepth: 100,
+  maxTotalNodes: 1e3,
+  maxExecutionTimeMs: 5e3,
+  maxParticlesPerSystem: 1e3,
+  maxCallStackDepth: 100
 };
-
-/**
- * Event handler type
- */
-type EventHandler = (data?: unknown) => void | Promise<void>;
-
-/**
- * Scope for variable resolution
- */
-interface Scope {
-  variables: Map<string, unknown>;
-  parent?: Scope;
-}
-
-/**
- * Animation state
- */
-interface Animation {
-  target: string;
-  property: string;
-  from: number;
-  to: number;
-  duration: number;
-  startTime: number;
-  easing: string;
-  loop?: boolean;
-  yoyo?: boolean;
-}
-
-/**
- * UI Element state
- */
-interface UIElementState {
-  type: string;
-  name: string;
-  properties: Record<string, unknown>;
-  value?: unknown;
-  visible: boolean;
-  enabled: boolean;
-}
-
-export class HoloScriptRuntime {
-  private context: RuntimeContext;
-  private particleSystems: Map<string, ParticleSystem> = new Map();
-  private executionHistory: ExecutionResult[] = [];
-  private startTime: number = 0;
-  private nodeCount: number = 0;
-
-  // Enhanced runtime state
-  private currentScope: Scope;
-  private callStack: string[] = [];
-  private eventHandlers: Map<string, EventHandler[]> = new Map();
-  private animations: Map<string, Animation> = new Map();
-  private uiElements: Map<string, UIElementState> = new Map();
-  private builtinFunctions: Map<string, (args: unknown[]) => unknown>;
-
-  constructor(_importLoader?: ImportLoader) {
+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
    */
-  private initBuiltins(): Map<string, (args: unknown[]) => unknown> {
-    const builtins = new Map<string, (args: unknown[]) => unknown>();
-
-    // Display commands
-    builtins.set('show', (args) => {
+  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;
@@ -118,116 +35,92 @@ export class HoloScriptRuntime {
       if (hologram) {
         this.createParticleEffect(`${target}_show`, { x: 0, y: 0, z: 0 }, hologram.color, 15);
       }
-      logger.info('show', { target });
+      logger.info("show", { target });
       return { shown: target };
     });
-
-    builtins.set('hide', (args) => {
+    builtins.set("hide", (args) => {
       const target = String(args[0]);
       const element = this.uiElements.get(target);
       if (element) element.visible = false;
-      logger.info('hide', { target });
+      logger.info("hide", { target });
       return { hidden: target };
     });
-
-    // Animation commands
-    builtins.set('pulse', (args) => {
+    builtins.set("pulse", (args) => {
       const target = String(args[0]);
-      const options = (args[1] as Record<string, unknown>) || {};
-      const duration = Number(options.duration) || 1000;
-      const color = String(options.color || '#ffffff');
-
+      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) => {
+    builtins.set("animate", (args) => {
       const target = String(args[0]);
-      const options = (args[1] as Record<string, unknown>) || {};
-
-      const animation: Animation = {
+      const options = args[1] || {};
+      const animation = {
         target,
-        property: String(options.property || 'position.y'),
+        property: String(options.property || "position.y"),
         from: Number(options.from || 0),
         to: Number(options.to || 1),
-        duration: Number(options.duration || 1000),
+        duration: Number(options.duration || 1e3),
         startTime: Date.now(),
-        easing: String(options.easing || 'linear'),
+        easing: String(options.easing || "linear"),
         loop: Boolean(options.loop),
-        yoyo: Boolean(options.yoyo),
+        yoyo: Boolean(options.yoyo)
       };
-
       this.animations.set(`${target}_${animation.property}`, animation);
       return { animating: target, animation };
     });
-
-    // Spatial commands
-    builtins.set('spawn', (args) => {
+    builtins.set("spawn", (args) => {
       const target = String(args[0]);
-      const position = (args[1] as SpatialPosition) || { x: 0, y: 0, z: 0 };
-
+      const position = args[1] || { x: 0, y: 0, z: 0 };
       this.context.spatialMemory.set(target, position);
-      this.createParticleEffect(`${target}_spawn`, position, '#00ff00', 25);
-
+      this.createParticleEffect(`${target}_spawn`, position, "#00ff00", 25);
       return { spawned: target, at: position };
     });
-
-    builtins.set('move', (args) => {
+    builtins.set("move", (args) => {
       const target = String(args[0]);
-      const position = (args[1] as SpatialPosition) || { x: 0, y: 0, z: 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');
+        this.createConnectionStream(target, `${target}_dest`, current, position, "move");
       }
-
       return { moved: target, to: position };
     });
-
-    // Data commands
-    builtins.set('set', (args) => {
+    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) => {
+    builtins.set("get", (args) => {
       const target = String(args[0]);
       return this.getVariable(target);
     });
-
-    // Math functions
-    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());
-
-    // String functions
-    builtins.set('concat', (args) => args.map(String).join(''));
-    builtins.set('length', (args) => {
+    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 (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());
-
-    // Array functions
-    builtins.set('push', (args) => {
+    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]);
@@ -235,377 +128,308 @@ export class HoloScriptRuntime {
       }
       return [args[0], args[1]];
     });
-    builtins.set('pop', (args) => {
+    builtins.set("pop", (args) => {
       const arr = args[0];
       if (Array.isArray(arr)) return arr.pop();
-      return undefined;
+      return void 0;
     });
-    builtins.set('at', (args) => {
+    builtins.set("at", (args) => {
       const arr = args[0];
       const index = Number(args[1]);
       if (Array.isArray(arr)) return arr[index];
-      return undefined;
+      return void 0;
     });
-
-    // Console/Debug
-    builtins.set('log', (args) => {
-      logger.info('HoloScript log', { args });
+    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 });
+    builtins.set("print", (args) => {
+      const message = args.map(String).join(" ");
+      logger.info("print", { message });
       return message;
     });
-
-    // Type checking
-    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] as number));
-    builtins.set('isString', (args) => typeof args[0] === 'string');
-
+    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: ASTNode): Promise<ExecutionResult> {
+  async executeNode(node) {
     const startTime = Date.now();
-
     try {
       this.context.executionStack.push(node);
-
-      let result: ExecutionResult;
-
+      let result;
       switch (node.type) {
-        case 'orb':
-          result = await this.executeOrb(node as OrbNode);
+        case "orb":
+          result = await this.executeOrb(node);
           break;
-        case 'method':
-        case 'function':
-          result = await this.executeFunction(node as MethodNode);
+        case "method":
+        case "function":
+          result = await this.executeFunction(node);
           break;
-        case 'connection':
-          result = await this.executeConnection(node as ConnectionNode);
+        case "connection":
+          result = await this.executeConnection(node);
           break;
-        case 'gate':
-          result = await this.executeGate(node as GateNode);
+        case "gate":
+          result = await this.executeGate(node);
           break;
-        case 'stream':
-          result = await this.executeStream(node as StreamNode);
+        case "stream":
+          result = await this.executeStream(node);
           break;
-        case 'execute':
-        case 'call':
-          result = await this.executeCall(node as ASTNode & { target?: string; args?: unknown[] });
+        case "execute":
+        case "call":
+          result = await this.executeCall(node);
           break;
-        case 'debug':
+        case "debug":
           result = await this.executeDebug(node);
           break;
-        case 'visualize':
+        case "visualize":
           result = await this.executeVisualize(node);
           break;
-        case '2d-element':
-          result = await this.executeUIElement(node as unknown as UI2DNode);
+        case "2d-element":
+          result = await this.executeUIElement(node);
           break;
-        case 'nexus':
-        case 'building':
+        case "nexus":
+        case "building":
           result = await this.executeStructure(node);
           break;
-        case 'assignment':
-          result = await this.executeAssignment(node as ASTNode & { name: string; value: unknown });
+        case "assignment":
+          result = await this.executeAssignment(node);
           break;
-        case 'return':
-          result = await this.executeReturn(node as ASTNode & { value: unknown });
+        case "return":
+          result = await this.executeReturn(node);
           break;
-        case 'generic':
+        case "generic":
           result = await this.executeGeneric(node);
           break;
-        case 'expression-statement':
+        case "expression-statement":
           result = await this.executeCall(node);
           break;
         default:
           result = {
             success: false,
             error: `Unknown node type: ${node.type}`,
-            executionTime: Date.now() - startTime,
+            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: ExecutionResult = {
+      const errorResult = {
         success: false,
         error: error instanceof Error ? error.message : String(error),
-        executionTime: execTime,
+        executionTime: execTime
       };
-
       this.executionHistory.push(errorResult);
       this.context.executionStack.pop();
-
       return errorResult;
     }
   }
-
   /**
    * Execute multiple nodes in sequence
    */
-  async executeProgram(nodes: ASTNode[], depth: number = 0): Promise<ExecutionResult[]> {
+  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 });
+      logger.error("Max execution depth exceeded", { depth });
       return [{
         success: false,
         error: `Max execution depth exceeded (${RUNTIME_SECURITY_LIMITS.maxExecutionDepth})`,
-        executionTime: 0,
+        executionTime: 0
       }];
     }
-
-    const results: ExecutionResult[] = [];
-
+    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 });
+        logger.error("Max total nodes exceeded", { count: this.nodeCount });
         results.push({
           success: false,
-          error: 'Max total nodes exceeded',
-          executionTime: Date.now() - this.startTime,
+          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 });
+        logger.error("Execution timeout", { duration: Date.now() - this.startTime });
         results.push({
           success: false,
-          error: 'Execution timeout',
-          executionTime: Date.now() - this.startTime,
+          error: "Execution timeout",
+          executionTime: Date.now() - this.startTime
         });
         break;
       }
-
       const result = await this.executeNode(node);
       results.push(result);
-
-      // Stop on error (except visualize) or return statement
-      if (!result.success && node.type !== 'visualize') {
+      if (!result.success && node.type !== "visualize") {
         break;
       }
-      if (node.type === 'return') {
+      if (node.type === "return") {
         break;
       }
     }
-
     return results;
   }
-
   /**
    * Call a function with arguments
    */
-  async callFunction(name: string, args: unknown[] = []): Promise<ExecutionResult> {
-    // Check built-in functions first
+  async callFunction(name, args = []) {
     const builtin = this.builtinFunctions.get(name);
     if (builtin) {
       try {
         const result = builtin(args);
         return {
           success: true,
-          output: result,
+          output: result
         };
       } catch (error) {
         return {
           success: false,
-          error: `Built-in function ${name} failed: ${error}`,
+          error: `Built-in function ${name} failed: ${error}`
         };
       }
     }
-
-    // Check user-defined functions
     const func = this.context.functions.get(name);
     if (!func) {
       return {
         success: false,
-        error: `Function '${name}' not found`,
+        error: `Function '${name}' not found`
       };
     }
-
-    // Check call stack depth
     if (this.callStack.length >= RUNTIME_SECURITY_LIMITS.maxCallStackDepth) {
       return {
         success: false,
-        error: `Max call stack depth exceeded (${RUNTIME_SECURITY_LIMITS.maxCallStackDepth})`,
+        error: `Max call stack depth exceeded (${RUNTIME_SECURITY_LIMITS.maxCallStackDepth})`
       };
     }
-
-    // Create new scope
     const parentScope = this.currentScope;
     this.currentScope = {
-      variables: new Map(),
-      parent: parentScope,
+      variables: /* @__PURE__ */ new Map(),
+      parent: parentScope
     };
-
-    // Bind parameters
     func.parameters.forEach((param, index) => {
       const value = index < args.length ? args[index] : param.defaultValue;
       this.currentScope.variables.set(param.name, value);
     });
-
-    // Push to call stack
     this.callStack.push(name);
-
-    // Execute function body
-    let returnValue: unknown = undefined;
+    let returnValue = void 0;
     try {
       const results = await this.executeProgram(func.body, this.callStack.length);
       const lastResult = results[results.length - 1];
-
-      if (lastResult?.output !== undefined) {
+      if (lastResult?.output !== void 0) {
         returnValue = lastResult.output;
       }
-
-      // Visual effect
       this.createExecutionEffect(name, func.position || { x: 0, y: 0, z: 0 });
-
       return {
-        success: results.every(r => r.success),
+        success: results.every((r) => r.success),
         output: returnValue,
         hologram: func.hologram,
-        spatialPosition: func.position,
+        spatialPosition: func.position
       };
     } finally {
-      // Restore scope
       this.currentScope = parentScope;
       this.callStack.pop();
     }
   }
-
   /**
    * Set a variable in current scope
    */
-  setVariable(name: string, value: unknown): void {
-    // Handle property access (e.g., "obj.prop")
-    if (name.includes('.')) {
-      const parts = name.split('.');
+  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 === undefined || typeof obj !== 'object' || obj === null) {
+      if (obj === void 0 || typeof obj !== "object" || obj === null) {
         obj = {};
         this.currentScope.variables.set(objName, obj);
       }
-
-      let current = obj as Record<string, unknown>;
+      let current = obj;
       for (let i = 0; i < propPath.length - 1; i++) {
-        if (current[propPath[i]] === undefined || typeof current[propPath[i]] !== 'object') {
+        if (current[propPath[i]] === void 0 || typeof current[propPath[i]] !== "object") {
           current[propPath[i]] = {};
         }
-        current = current[propPath[i]] as Record<string, unknown>;
+        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: string): unknown {
-    // Handle property access (e.g., "obj.prop")
-    if (name.includes('.')) {
-      const parts = name.split('.');
+  getVariable(name) {
+    if (name.includes(".")) {
+      const parts = name.split(".");
       let value = this.getVariable(parts[0]);
-
-      for (let i = 1; i < parts.length && value !== undefined; i++) {
-        if (typeof value === 'object' && value !== null) {
-          value = (value as Record<string, unknown>)[parts[i]];
+      for (let i = 1; i < parts.length && value !== void 0; i++) {
+        if (typeof value === "object" && value !== null) {
+          value = value[parts[i]];
         } else {
-          return undefined;
+          return void 0;
         }
       }
       return value;
     }
-
-    // Walk scope chain
-    let scope: Scope | undefined = this.currentScope;
+    let scope = this.currentScope;
     while (scope) {
       if (scope.variables.has(name)) {
         return scope.variables.get(name);
       }
       scope = scope.parent;
     }
-
-    // Check context variables
     if (this.context.variables.has(name)) {
       return this.context.variables.get(name);
     }
-
-    // Fallback to functions map (for imported functions)
     if (this.context.functions.has(name)) {
       return this.context.functions.get(name);
     }
-
-    return undefined;
+    return void 0;
   }
-
   /**
    * Evaluate an expression
    */
-  evaluateExpression(expr: string): unknown {
-    if (!expr || typeof expr !== 'string') return expr;
-
+  evaluateExpression(expr) {
+    if (!expr || typeof expr !== "string") return expr;
     expr = expr.trim();
-
-    // Security check
-    const suspicious = ['eval', 'process', 'require', '__proto__', 'constructor', 'Function'];
-    if (suspicious.some(kw => expr.toLowerCase().includes(kw))) {
-      logger.warn('Suspicious expression blocked', { expr });
-      return undefined;
+    const suspicious = ["eval", "process", "require", "__proto__", "constructor", "Function"];
+    if (suspicious.some((kw) => expr.toLowerCase().includes(kw))) {
+      logger.warn("Suspicious expression blocked", { expr });
+      return void 0;
     }
-
-    // String literal
-    if ((expr.startsWith('"') && expr.endsWith('"')) || (expr.startsWith("'") && expr.endsWith("'"))) {
+    if (expr.startsWith('"') && expr.endsWith('"') || expr.startsWith("'") && expr.endsWith("'")) {
       return expr.slice(1, -1);
     }
-
-    // Number literal
     if (/^-?\d+(\.\d+)?$/.test(expr)) {
       return parseFloat(expr);
     }
-
-    // Boolean literal
-    if (expr === 'true') return true;
-    if (expr === 'false') return false;
-    if (expr === 'null') return null;
-    if (expr === 'undefined') return undefined;
-
-    // Array literal [a, b, c]
-    if (expr.startsWith('[') && expr.endsWith(']')) {
+    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()));
+      return elements.map((e) => this.evaluateExpression(e.trim()));
     }
-
-    // Object literal {a: 1, b: 2}
-    if (expr.startsWith('{') && expr.endsWith('}')) {
+    if (expr.startsWith("{") && expr.endsWith("}")) {
       const inner = expr.slice(1, -1);
       if (!inner.trim()) return {};
       const pairs = this.splitByComma(inner);
-      const obj: Record<string, unknown> = {};
+      const obj = {};
       for (const pair of pairs) {
-        const colonIndex = pair.indexOf(':');
+        const colonIndex = pair.indexOf(":");
         if (colonIndex > 0) {
           const key = pair.slice(0, colonIndex).trim();
           const value = pair.slice(colonIndex + 1).trim();
@@ -614,37 +438,26 @@ export class HoloScriptRuntime {
       }
       return obj;
     }
-
-    // Function call: name(args)
     const funcMatch = expr.match(/^(\w+)\s*\((.*)?\)$/);
     if (funcMatch) {
       const [, funcName, argsStr] = funcMatch;
-      const args = argsStr ? this.splitByComma(argsStr).map(a => this.evaluateExpression(a.trim())) : [];
-
-      // Check builtins
+      const args = argsStr ? this.splitByComma(argsStr).map((a) => this.evaluateExpression(a.trim())) : [];
       const builtin = this.builtinFunctions.get(funcName);
       if (builtin) {
         return builtin(args);
       }
-
-      // Check user functions (but don't execute - just reference)
       if (this.context.functions.has(funcName)) {
-        // For async execution, return a promise marker
         return { __holoCall: funcName, args };
       }
-
-      return undefined;
+      return void 0;
     }
-
-    // Binary operations: a + b, a - b, etc.
     const binaryOps = [
-      { pattern: /(.+)\s*\+\s*(.+)/, op: (a: unknown, b: unknown) => (typeof a === 'string' || typeof b === 'string') ? String(a) + String(b) : Number(a) + Number(b) },
-      { pattern: /(.+)\s*-\s*(.+)/, op: (a: unknown, b: unknown) => Number(a) - Number(b) },
-      { pattern: /(.+)\s*\*\s*(.+)/, op: (a: unknown, b: unknown) => Number(a) * Number(b) },
-      { pattern: /(.+)\s*\/\s*(.+)/, op: (a: unknown, b: unknown) => Number(b) !== 0 ? Number(a) / Number(b) : 0 },
-      { pattern: /(.+)\s*%\s*(.+)/, op: (a: unknown, b: unknown) => Number(a) % Number(b) },
+      { 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) {
@@ -653,214 +466,169 @@ export class HoloScriptRuntime {
         return op(left, right);
       }
     }
-
-    // Variable reference
     return this.getVariable(expr);
   }
-
   /**
    * Split string by comma, respecting nesting
    */
-  private splitByComma(str: string): string[] {
-    const parts: string[] = [];
-    let current = '';
+  splitByComma(str) {
+    const parts = [];
+    let current = "";
     let depth = 0;
     let inString = false;
-    let stringChar = '';
-
+    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] !== '\\') {
+      } 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) {
+        if (char === "(" || char === "[" || char === "{") depth++;
+        if (char === ")" || char === "]" || char === "}") depth--;
+        if (char === "," && depth === 0) {
           parts.push(current.trim());
-          current = '';
+          current = "";
           continue;
         }
       }
-
       current += char;
     }
-
     if (current.trim()) {
       parts.push(current.trim());
     }
-
     return parts;
   }
-
   // ============================================================================
   // Node Executors
   // ============================================================================
-
-  private async executeOrb(node: OrbNode): Promise<ExecutionResult> {
+  async executeOrb(node) {
     if (node.position) {
       this.context.spatialMemory.set(node.name, node.position);
     }
-
-    // Create orb object with reactive properties
     const orbData = {
-      __type: 'orb',
+      __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?: Record<string, unknown>) => this.builtinFunctions.get('pulse')!([node.name, opts]),
+      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);
-
-    logger.info('Orb created', { name: node.name, properties: Object.keys(node.properties) });
-
+    this.createParticleEffect(`${node.name}_creation`, node.position || { x: 0, y: 0, z: 0 }, "#00ffff", 20);
+    logger.info("Orb created", { name: node.name, properties: Object.keys(node.properties) });
     return {
       success: true,
       output: orbData,
       hologram: node.hologram,
-      spatialPosition: node.position,
+      spatialPosition: node.position
     };
   }
-
-  private async executeFunction(node: MethodNode): Promise<ExecutionResult> {
+  async executeFunction(node) {
     this.context.functions.set(node.name, node);
-
-    const hologram: HologramProperties = {
-      shape: 'cube',
-      color: '#ff6b35',
+    const hologram = {
+      shape: "cube",
+      color: "#ff6b35",
       size: 1.5,
       glow: true,
       interactive: true,
-      ...node.hologram,
+      ...node.hologram
     };
-
     this.context.hologramState.set(node.name, hologram);
-
-    logger.info('Function defined', { name: node.name, params: node.parameters.map(p => p.name) });
-
+    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,
+      spatialPosition: node.position
     };
   }
-
-  private async executeConnection(node: ConnectionNode): Promise<ExecutionResult> {
+  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);
     }
-
-    // Set up reactive binding if bidirectional
     if (node.bidirectional) {
-      // When 'from' changes, update 'to'
       this.on(`${node.from}.changed`, async (data) => {
         this.setVariable(node.to, data);
         this.emit(`${node.to}.changed`, data);
       });
-      // When 'to' changes, update 'from'
       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 });
-
+    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',
+        shape: "cylinder",
         color: this.getDataTypeColor(node.dataType),
         size: 0.1,
         glow: true,
-        interactive: false,
-      },
+        interactive: false
+      }
     };
   }
-
-  private async executeGate(node: GateNode): Promise<ExecutionResult> {
+  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 });
-
+      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`,
+        output: `Gate: took ${condition ? "true" : "false"} path`,
         hologram: {
-          shape: 'pyramid',
-          color: condition ? '#00ff00' : '#ff0000',
+          shape: "pyramid",
+          color: condition ? "#00ff00" : "#ff0000",
           size: 1,
           glow: true,
-          interactive: true,
-        },
+          interactive: true
+        }
       };
     } catch (error) {
       return {
         success: false,
-        error: `Gate execution failed: ${error}`,
+        error: `Gate execution failed: ${error}`
       };
     }
   }
-
-  private async executeStream(node: StreamNode): Promise<ExecutionResult> {
+  async executeStream(node) {
     let data = this.getVariable(node.source);
-
-    logger.info('Stream processing', { name: node.name, source: node.source, transforms: node.transformations.length });
-
+    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,
+      spatialPosition: node.position
     };
   }
-
-  private async executeCall(node: ASTNode & { target?: string; args?: unknown[] }): Promise<ExecutionResult> {
-    const funcName = node.target || '';
+  async executeCall(node) {
+    const funcName = node.target || "";
     const args = node.args || [];
-
     return this.callFunction(funcName, args);
   }
-
-  private async executeDebug(node: ASTNode & { target?: string }): Promise<ExecutionResult> {
+  async executeDebug(node) {
     const debugInfo = {
       variables: Object.fromEntries(this.currentScope.variables),
       contextVariables: Object.fromEntries(this.context.variables),
@@ -869,77 +637,62 @@ export class HoloScriptRuntime {
       callStack: [...this.callStack],
       uiElements: Array.from(this.uiElements.keys()),
       animations: Array.from(this.animations.keys()),
-      executionHistory: this.executionHistory.slice(-10),
+      executionHistory: this.executionHistory.slice(-10)
     };
-
-    const debugOrb: HologramProperties = {
-      shape: 'pyramid',
-      color: '#ff1493',
+    const debugOrb = {
+      shape: "pyramid",
+      color: "#ff1493",
       size: 0.8,
       glow: true,
-      interactive: true,
+      interactive: true
     };
-
-    this.context.hologramState.set(`debug_${node.target || 'program'}`, debugOrb);
-
-    logger.info('Debug info', debugInfo);
-
+    this.context.hologramState.set(`debug_${node.target || "program"}`, debugOrb);
+    logger.info("Debug info", debugInfo);
     return {
       success: true,
       output: debugInfo,
-      hologram: debugOrb,
+      hologram: debugOrb
     };
   }
-
-  private async executeVisualize(node: ASTNode & { target?: string }): Promise<ExecutionResult> {
-    const target = node.target || '';
+  async executeVisualize(node) {
+    const target = node.target || "";
     const data = this.getVariable(target);
-
-    if (data === undefined) {
+    if (data === void 0) {
       return {
         success: false,
-        error: `No data found for '${target}'`,
+        error: `No data found for '${target}'`
       };
     }
-
-    const visHologram: HologramProperties = {
-      shape: 'cylinder',
-      color: '#32cd32',
+    const visHologram = {
+      shape: "cylinder",
+      color: "#32cd32",
       size: 1.5,
       glow: true,
-      interactive: true,
+      interactive: true
     };
-
     this.createDataVisualization(target, data, node.position || { x: 0, y: 0, z: 0 });
-
     return {
       success: true,
       output: { visualizing: target, data },
-      hologram: visHologram,
+      hologram: visHologram
     };
   }
-
-  private async executeUIElement(node: UI2DNode): Promise<ExecutionResult> {
-    const element: UIElementState = {
+  async executeUIElement(node) {
+    const element = {
       type: node.elementType,
       name: node.name,
       properties: { ...node.properties },
       visible: true,
-      enabled: true,
+      enabled: true
     };
-
-    // Set initial value based on element type
-    if (node.elementType === 'textinput') {
-      element.value = node.properties.value || '';
-    } else if (node.elementType === 'slider') {
+    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') {
+    } else if (node.elementType === "toggle") {
       element.value = node.properties.checked || false;
     }
-
     this.uiElements.set(node.name, element);
-
-    // Register event handlers
     if (node.events) {
       for (const [eventName, handlerName] of Object.entries(node.events)) {
         this.on(`${node.name}.${eventName}`, async () => {
@@ -947,531 +700,441 @@ export class HoloScriptRuntime {
         });
       }
     }
-
-    logger.info('UI element created', { type: node.elementType, name: node.name });
-
+    logger.info("UI element created", { type: node.elementType, name: node.name });
     return {
       success: true,
-      output: element,
+      output: element
     };
   }
-
   /**
    * Execute generic voice commands
    * Handles commands like: show, hide, animate, pulse, create
    */
-  private async executeGeneric(_node: ASTNode): Promise<ExecutionResult> {
-    const genericNode = _node as any;
-    const command = String(genericNode.command || '').trim().toLowerCase();
+  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 });
-
+    logger.info("Executing generic command", { command, action, target });
     try {
-      let result: any;
-
+      let result;
       switch (action) {
-        case 'show':
+        case "show":
           result = await this.executeShowCommand(target, genericNode);
           break;
-        case 'hide':
+        case "hide":
           result = await this.executeHideCommand(target, genericNode);
           break;
-        case 'create':
-        case 'summon':
+        case "create":
+        case "summon":
           result = await this.executeCreateCommand(tokens.slice(1), genericNode);
           break;
-        case 'animate':
+        case "animate":
           result = await this.executeAnimateCommand(target, tokens.slice(2), genericNode);
           break;
-        case 'pulse':
+        case "pulse":
           result = await this.executePulseCommand(target, tokens.slice(2), genericNode);
           break;
-        case 'move':
+        case "move":
           result = await this.executeMoveCommand(target, tokens.slice(2), genericNode);
           break;
-        case 'delete':
-        case 'remove':
+        case "delete":
+        case "remove":
           result = await this.executeDeleteCommand(target, genericNode);
           break;
         default:
-          // Default: create visual representation of the generic command
-          logger.warn('Unknown voice command action', { action, command });
+          logger.warn("Unknown voice command action", { action, command });
           result = {
             executed: false,
-            message: `Unknown command: ${action}`,
+            message: `Unknown command: ${action}`
           };
       }
-
       return {
         success: true,
-        output: result,
+        output: result
       };
     } catch (error) {
       return {
         success: false,
-        error: `Generic command execution failed: ${String(error)}`,
+        error: `Generic command execution failed: ${String(error)}`
       };
     }
   }
-
   /**
    * Execute 'show' command
    */
-  private async executeShowCommand(target: string, _node: any): Promise<any> {
-    // Create or show orb for this target
+  async executeShowCommand(target, _node) {
     const hologram = _node.hologram || {
-      shape: 'orb',
-      color: '#00ffff',
+      shape: "orb",
+      color: "#00ffff",
       size: 0.8,
       glow: true,
-      interactive: 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 });
-
+    logger.info("Show command executed", { target, position });
     return {
       showed: target,
       hologram,
-      position,
+      position
     };
   }
-
   /**
    * Execute 'hide' command
    */
-  private async executeHideCommand(target: string, _node: any): Promise<any> {
+  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 });
-
+    this.createParticleEffect(`${target}_hide`, position, "#ff0000", 10);
+    logger.info("Hide command executed", { target });
     return {
-      hidden: target,
+      hidden: target
     };
   }
-
   /**
    * Execute 'create' command
    */
-  private async executeCreateCommand(tokens: string[], _node: any): Promise<any> {
+  async executeCreateCommand(tokens, _node) {
     if (tokens.length < 2) {
-      return { error: 'Create command requires shape and name' };
+      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: HologramProperties = {
-      shape: shape as HologramShape,
-      color: _node.hologram?.color || '#00ffff',
+    const hologram = {
+      shape,
+      color: _node.hologram?.color || "#00ffff",
       size: _node.hologram?.size || 1,
       glow: _node.hologram?.glow !== false,
-      interactive: _node.hologram?.interactive !== 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 });
-
+    logger.info("Create command executed", { shape, name, position });
     return {
       created: name,
       shape,
       hologram,
-      position,
+      position
     };
   }
-
   /**
    * Execute 'animate' command
    */
-  private async executeAnimateCommand(target: string, tokens: string[], _node: any): Promise<any> {
-    const property = tokens[0] || 'position.y';
-    const duration = parseInt(tokens[1] || '1000', 10);
-    
-    const animation: Animation = {
+  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',
+      easing: "ease-in-out"
     };
-
     this.animations.set(`${target}_${property}`, animation);
-
-    logger.info('Animate command executed', { target, property, duration });
-
+    logger.info("Animate command executed", { target, property, duration });
     return {
       animating: target,
-      animation,
+      animation
     };
   }
-
   /**
    * Execute 'pulse' command
    */
-  private async executePulseCommand(target: string, tokens: string[], _node: any): Promise<any> {
-    const duration = parseInt(tokens[0] || '500', 10);
+  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 };
-
-    // Create pulsing particle effect
-    this.createParticleEffect(`${target}_pulse`, position, '#ffff00', 30);
-
-    // Create animation for scale
-    const animation: Animation = {
+    this.createParticleEffect(`${target}_pulse`, position, "#ffff00", 30);
+    const animation = {
       target,
-      property: 'scale',
+      property: "scale",
       from: 1,
       to: 1.5,
       duration,
       startTime: Date.now(),
-      easing: 'sine',
+      easing: "sine",
       yoyo: true,
-      loop: true,
+      loop: true
     };
-
     this.animations.set(`${target}_pulse`, animation);
-
-    logger.info('Pulse command executed', { target, duration });
-
+    logger.info("Pulse command executed", { target, duration });
     return {
       pulsing: target,
-      duration,
+      duration
     };
   }
-
   /**
    * Execute 'move' command
    */
-  private async executeMoveCommand(target: string, tokens: string[], _node: any): Promise<any> {
-    const x = parseFloat(tokens[0] || '0');
-    const y = parseFloat(tokens[1] || '0');
-    const z = parseFloat(tokens[2] || '0');
-    const position: SpatialPosition = { x, y, z };
-
+  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');
+      this.createConnectionStream(target, `${target}_move`, current, position, "movement");
     } else {
       this.context.spatialMemory.set(target, position);
     }
-
-    logger.info('Move command executed', { target, position });
-
+    logger.info("Move command executed", { target, position });
     return {
       moved: target,
-      to: position,
+      to: position
     };
   }
-
   /**
    * Execute 'delete' command
    */
-  private async executeDeleteCommand(target: string, _node: any): Promise<any> {
+  async executeDeleteCommand(target, _node) {
     const position = this.context.spatialMemory.get(target);
     if (position) {
-      this.createParticleEffect(`${target}_delete`, position, '#ff0000', 15);
+      this.createParticleEffect(`${target}_delete`, position, "#ff0000", 15);
       this.context.spatialMemory.delete(target);
     }
-
-    logger.info('Delete command executed', { target });
-
+    logger.info("Delete command executed", { target });
     return {
-      deleted: target,
+      deleted: target
     };
   }
-
-  private async executeStructure(node: ASTNode): Promise<ExecutionResult> {
-    // Handle nexus, building, and other structural elements
-    const hologram: HologramProperties = node.hologram || {
-      shape: node.type === 'nexus' ? 'sphere' : 'cube',
-      color: node.type === 'nexus' ? '#9b59b6' : '#e74c3c',
-      size: node.type === 'nexus' ? 3 : 4,
+  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,
+      interactive: true
     };
-
     return {
       success: true,
       output: { type: node.type, created: true },
       hologram,
-      spatialPosition: node.position,
+      spatialPosition: node.position
     };
   }
-
-  private async executeAssignment(node: ASTNode & { name: string; value: unknown }): Promise<ExecutionResult> {
+  async executeAssignment(node) {
     const value = this.evaluateExpression(String(node.value));
     this.setVariable(node.name, value);
-
     return {
       success: true,
-      output: { assigned: node.name, value },
+      output: { assigned: node.name, value }
     };
   }
-
-  private async executeReturn(node: ASTNode & { value: unknown }): Promise<ExecutionResult> {
+  async executeReturn(node) {
     const value = this.evaluateExpression(String(node.value));
-
     return {
       success: true,
-      output: value,
+      output: value
     };
   }
-
   // ============================================================================
   // Condition Evaluation
   // ============================================================================
-
-  private evaluateCondition(condition: string): boolean {
+  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 });
+    const suspiciousKeywords = ["eval", "process", "require", "__proto__", "constructor"];
+    if (suspiciousKeywords.some((kw) => condition.toLowerCase().includes(kw))) {
+      logger.warn("Suspicious condition blocked", { condition });
       return false;
     }
-
     try {
-      // Boolean literals
-      if (condition.trim().toLowerCase() === 'true') return true;
-      if (condition.trim().toLowerCase() === 'false') return false;
-
-      // Comparison operators
-      const comparisonPatterns: Array<{ regex: RegExp; logical?: string }> = [
+      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' },
+        { 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);
-
+          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);
+            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);
           }
         }
       }
-
-      // Negation
-      if (condition.startsWith('!')) {
+      if (condition.startsWith("!")) {
         return !this.evaluateCondition(condition.slice(1).trim());
       }
-
-      // Variable truthiness
       const value = this.evaluateExpression(condition.trim());
       return Boolean(value);
     } catch (error) {
-      logger.error('Condition evaluation error', { condition, error });
+      logger.error("Condition evaluation error", { condition, error });
       return false;
     }
   }
-
   // ============================================================================
   // Transformation
   // ============================================================================
-
-  private async applyTransformation(data: unknown, transform: TransformationNode): Promise<unknown> {
+  async applyTransformation(data, transform) {
     const params = transform.parameters || {};
-
     switch (transform.operation) {
-      case 'filter': {
+      case "filter": {
         if (!Array.isArray(data)) return data;
-        const predicate = params.predicate as string;
+        const predicate = params.predicate;
         if (predicate) {
-          return data.filter(item => {
-            this.setVariable('_item', item);
+          return data.filter((item) => {
+            this.setVariable("_item", item);
             return this.evaluateCondition(predicate);
           });
         }
-        return data.filter(item => item !== null && item !== undefined);
+        return data.filter((item) => item !== null && item !== void 0);
       }
-
-      case 'map': {
+      case "map": {
         if (!Array.isArray(data)) return data;
-        const mapper = params.mapper as string;
+        const mapper = params.mapper;
         if (mapper) {
-          return data.map(item => {
-            this.setVariable('_item', item);
+          return data.map((item) => {
+            this.setVariable("_item", item);
             return this.evaluateExpression(mapper);
           });
         }
-        return data.map(item => ({ value: item, processed: true }));
+        return data.map((item) => ({ value: item, processed: true }));
       }
-
-      case 'reduce': {
+      case "reduce": {
         if (!Array.isArray(data)) return data;
         const initial = params.initial ?? 0;
-        const reducer = params.reducer as string;
+        const reducer = params.reducer;
         if (reducer) {
           return data.reduce((acc, item) => {
-            this.setVariable('_acc', acc);
-            this.setVariable('_item', 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);
+        return data.reduce((acc, item) => acc + (typeof item === "number" ? item : 0), 0);
       }
-
-      case 'sort': {
+      case "sort": {
         if (!Array.isArray(data)) return data;
-        const key = params.key as string;
-        const desc = params.descending as boolean;
+        const key = params.key;
+        const desc = params.descending;
         const sorted = [...data].sort((a, b) => {
-          const aVal = key ? (a as Record<string, unknown>)[key] : a;
-          const bVal = key ? (b as Record<string, unknown>)[key] : 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':
+      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':
+      case "unique":
         return Array.isArray(data) ? [...new Set(data)] : data;
-
-      case 'flatten':
+      case "flatten":
         return Array.isArray(data) ? data.flat() : data;
-
-      case 'reverse':
+      case "reverse":
         return Array.isArray(data) ? [...data].reverse() : data;
-
-      case 'take': {
+      case "take": {
         if (!Array.isArray(data)) return data;
         const count = Number(params.count) || 10;
         return data.slice(0, count);
       }
-
-      case 'skip': {
+      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 });
+        logger.warn("Unknown transformation", { operation: transform.operation });
         return data;
     }
   }
-
   // ============================================================================
   // Event System
   // ============================================================================
-
   /**
    * Register event handler
    */
-  on(event: string, handler: EventHandler): void {
+  on(event, handler) {
     const handlers = this.eventHandlers.get(event) || [];
     handlers.push(handler);
     this.eventHandlers.set(event, handlers);
   }
-
   /**
    * Remove event handler
    */
-  off(event: string, handler?: EventHandler): void {
+  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));
+      this.eventHandlers.set(event, handlers.filter((h) => h !== handler));
     }
   }
-
   /**
    * Emit event
    */
-  async emit(event: string, data?: unknown): Promise<void> {
+  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 });
+        logger.error("Event handler error", { event, error });
       }
     }
   }
-
   /**
    * Trigger UI event
    */
-  async triggerUIEvent(elementName: string, eventType: string, data?: unknown): Promise<void> {
+  async triggerUIEvent(elementName, eventType, data) {
     const element = this.uiElements.get(elementName);
     if (!element) {
-      logger.warn('UI element not found', { elementName });
+      logger.warn("UI element not found", { elementName });
       return;
     }
-
-    // Update element state based on event
-    if (eventType === 'change' && data !== undefined) {
+    if (eventType === "change" && data !== void 0) {
       element.value = data;
     }
-
     await this.emit(`${elementName}.${eventType}`, data);
   }
-
   // ============================================================================
   // Animation System
   // ============================================================================
-
   /**
    * Update all animations
    */
-  updateAnimations(): void {
+  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);
-
-      // Apply easing
       progress = this.applyEasing(progress, anim.easing);
-
-      // Calculate current value
       let currentValue = anim.from + (anim.to - anim.from) * progress;
-
-      // Handle yoyo
       if (anim.yoyo && progress >= 1) {
         anim.startTime = now;
         [anim.from, anim.to] = [anim.to, anim.from];
       }
-
-      // Update the property
       this.setVariable(`${anim.target}.${anim.property}`, currentValue);
-
-      // Remove completed non-looping animations
       if (progress >= 1 && !anim.loop && !anim.yoyo) {
         this.animations.delete(key);
       } else if (progress >= 1 && anim.loop) {
@@ -1479,117 +1142,102 @@ export class HoloScriptRuntime {
       }
     }
   }
-
-  private applyEasing(t: number, easing: string): number {
+  applyEasing(t, easing) {
     switch (easing) {
-      case 'easeIn':
+      case "easeIn":
         return t * t;
-      case 'easeOut':
+      case "easeOut":
         return t * (2 - t);
-      case 'easeInOut':
+      case "easeInOut":
         return t < 0.5 ? 2 * t * t : -1 + (4 - 2 * t) * t;
-      case 'easeInQuad':
+      case "easeInQuad":
         return t * t;
-      case 'easeOutQuad':
+      case "easeOutQuad":
         return t * (2 - t);
-      case 'easeInOutQuad':
+      case "easeInOutQuad":
         return t < 0.5 ? 2 * t * t : -1 + (4 - 2 * t) * t;
-      case 'linear':
+      case "linear":
       default:
         return t;
     }
   }
-
   // ============================================================================
   // Particle Effects
   // ============================================================================
-
-  private createParticleEffect(name: string, position: SpatialPosition, color: string, count: number): void {
+  createParticleEffect(name, position, color, count) {
     const limitedCount = Math.min(count, RUNTIME_SECURITY_LIMITS.maxParticlesPerSystem);
-    const particles: SpatialPosition[] = [];
-
+    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,
+        z: position.z + (Math.random() - 0.5) * 2
       });
     }
-
     this.particleSystems.set(name, {
       particles,
       color,
-      lifetime: 3000,
-      speed: 0.01,
+      lifetime: 3e3,
+      speed: 0.01
     });
   }
-
-  private createConnectionStream(from: string, to: string, fromPos: SpatialPosition, toPos: SpatialPosition, dataType: string): void {
+  createConnectionStream(from, to, fromPos, toPos, dataType) {
     const streamName = `connection_${from}_${to}`;
-    const particles: SpatialPosition[] = [];
+    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,
+        z: fromPos.z + (toPos.z - fromPos.z) * t
       });
     }
-
     this.particleSystems.set(streamName, {
       particles,
       color: this.getDataTypeColor(dataType),
-      lifetime: 5000,
-      speed: 0.02,
+      lifetime: 5e3,
+      speed: 0.02
     });
   }
-
-  private createFlowingStream(name: string, position: SpatialPosition, data: unknown): void {
+  createFlowingStream(name, position, data) {
     const count = Array.isArray(data) ? Math.min(data.length, 50) : 10;
-    this.createParticleEffect(`${name}_flow`, position, '#45b7d1', count);
+    this.createParticleEffect(`${name}_flow`, position, "#45b7d1", count);
   }
-
-  private createExecutionEffect(name: string, position: SpatialPosition): void {
-    this.createParticleEffect(`${name}_execution`, position, '#ff4500', 30);
+  createExecutionEffect(name, position) {
+    this.createParticleEffect(`${name}_execution`, position, "#ff4500", 30);
   }
-
-  private createDataVisualization(name: string, data: unknown, position: SpatialPosition): void {
+  createDataVisualization(name, data, position) {
     let count = 10;
     if (Array.isArray(data)) {
       count = Math.min(data.length, 100);
-    } else if (typeof data === 'object' && data !== null) {
+    } else if (typeof data === "object" && data !== null) {
       count = Math.min(Object.keys(data).length * 5, 50);
     }
-    this.createParticleEffect(`${name}_visualization`, position, '#32cd32', count);
+    this.createParticleEffect(`${name}_visualization`, position, "#32cd32", count);
   }
-
-  private getDataTypeColor(dataType: string): string {
-    const colors: Record<string, string> = {
-      'string': '#ff6b35',
-      'number': '#4ecdc4',
-      'boolean': '#45b7d1',
-      'object': '#96ceb4',
-      'array': '#ffeaa7',
-      'any': '#dda0dd',
-      'move': '#ff69b4',
+  getDataTypeColor(dataType) {
+    const colors = {
+      "string": "#ff6b35",
+      "number": "#4ecdc4",
+      "boolean": "#45b7d1",
+      "object": "#96ceb4",
+      "array": "#ffeaa7",
+      "any": "#dda0dd",
+      "move": "#ff69b4"
     };
-    return colors[dataType] || '#ffffff';
+    return colors[dataType] || "#ffffff";
   }
-
   // ============================================================================
   // Public API
   // ============================================================================
-
-  getParticleSystems(): Map<string, ParticleSystem> {
+  getParticleSystems() {
     return new Map(this.particleSystems);
   }
-
-  updateParticles(deltaTime: number): void {
+  updateParticles(deltaTime) {
     for (const [name, system] of this.particleSystems) {
       system.lifetime -= deltaTime;
-      system.particles.forEach(particle => {
+      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;
@@ -1599,24 +1247,19 @@ export class HoloScriptRuntime {
       }
     }
   }
-
-  getContext(): RuntimeContext {
+  getContext() {
     return { ...this.context };
   }
-
-  getUIElements(): Map<string, UIElementState> {
+  getUIElements() {
     return new Map(this.uiElements);
   }
-
-  getUIElement(name: string): UIElementState | undefined {
+  getUIElement(name) {
     return this.uiElements.get(name);
   }
-
-  getAnimations(): Map<string, Animation> {
+  getAnimations() {
     return new Map(this.animations);
   }
-
-  reset(): void {
+  reset() {
     this.context = this.createEmptyContext();
     this.currentScope = { variables: this.context.variables };
     this.callStack = [];
@@ -1626,28 +1269,28 @@ export class HoloScriptRuntime {
     this.animations.clear();
     this.uiElements.clear();
   }
-
-  private createEmptyContext(): RuntimeContext {
+  createEmptyContext() {
     return {
-      variables: new Map(),
-      functions: new Map(),
-      exports: new Map(),
+      variables: /* @__PURE__ */ new Map(),
+      functions: /* @__PURE__ */ new Map(),
+      exports: /* @__PURE__ */ new Map(),
       connections: [],
-      spatialMemory: new Map(),
-      hologramState: new Map(),
-      executionStack: [],
+      spatialMemory: /* @__PURE__ */ new Map(),
+      hologramState: /* @__PURE__ */ new Map(),
+      executionStack: []
     };
   }
-
-  getExecutionHistory(): ExecutionResult[] {
+  getExecutionHistory() {
     return [...this.executionHistory];
   }
-
-  getHologramStates(): Map<string, HologramProperties> {
+  getHologramStates() {
     return new Map(this.context.hologramState);
   }
-
-  getCallStack(): string[] {
+  getCallStack() {
     return [...this.callStack];
   }
-}
+};
+
+export { HoloScriptRuntime };
+//# sourceMappingURL=chunk-EU6CZMGJ.js.map
+//# sourceMappingURL=chunk-EU6CZMGJ.js.map