@holoscript/core 2.0.2 → 2.1.0

package/dist/{chunk-EU6CZMGJ.js → chunk-AFFVFO4D.js}

@@ -1,5 +1,111 @@
 import { logger } from './chunk-SATNCODL.js';
 
+// src/ReactiveState.ts
+var ReactiveState = class {
+  constructor(initialState = {}) {
+    this.subscribers = /* @__PURE__ */ new Set();
+    this.state = { ...initialState };
+    this.proxy = this.createReactiveProxy(this.state);
+  }
+  createReactiveProxy(target) {
+    const self = this;
+    return new Proxy(target, {
+      get(obj, key) {
+        const val = obj[key];
+        if (val && typeof val === "object" && !Array.isArray(val)) {
+          return self.createReactiveProxy(val);
+        }
+        return val;
+      },
+      set(obj, key, value) {
+        const oldVal = obj[key];
+        obj[key] = value;
+        if (oldVal !== value) {
+          self.notify();
+        }
+        return true;
+      }
+    });
+  }
+  get(key) {
+    return this.proxy[key];
+  }
+  set(key, value) {
+    this.proxy[key] = value;
+  }
+  update(updates) {
+    Object.assign(this.proxy, updates);
+  }
+  subscribe(callback) {
+    this.subscribers.add(callback);
+    return () => this.subscribers.delete(callback);
+  }
+  getSnapshot() {
+    return { ...this.state };
+  }
+  notify() {
+    this.subscribers.forEach((cb) => cb(this.getSnapshot()));
+  }
+};
+var ExpressionEvaluator = class {
+  constructor(context = {}) {
+    this.context = context;
+  }
+  evaluate(expression) {
+    if (typeof expression !== "string") return expression;
+    const dangerousPatterns = [
+      /\beval\s*\(/,
+      /\brequire\s*\(/,
+      /\bimport\s*\(/,
+      /\bprocess\s*\./,
+      /\bglobal\s*\./,
+      /\b__dirname\b/,
+      /\b__filename\b/,
+      /\bfs\s*\./,
+      /\bchild_process\s*\./,
+      /\bfs\.writeFileSync/,
+      /\bfs\.readFileSync/
+    ];
+    for (const pattern of dangerousPatterns) {
+      if (pattern.test(expression)) {
+        console.warn(`Security: Blocked suspicious expression: ${expression}`);
+        return void 0;
+      }
+    }
+    if (expression.includes("${")) {
+      const trimmed = expression.trim();
+      const match = trimmed.match(/^\$\{([^}]+)\}$/);
+      if (match) {
+        return this.evaluate(match[1]);
+      }
+      return this.interpolate(expression);
+    }
+    const keys = Object.keys(this.context);
+    const values = Object.values(this.context);
+    try {
+      const fn = new Function(...keys, `return (${expression})`);
+      return fn(...values);
+    } catch (e) {
+      return expression;
+    }
+  }
+  interpolate(str) {
+    return str.replace(/\$\{([^}]+)\}/g, (_, expr) => {
+      const val = this.evaluate(expr);
+      return val !== void 0 ? String(val) : "";
+    });
+  }
+  updateContext(updates) {
+    Object.assign(this.context, updates);
+  }
+  setContext(context) {
+    this.context = { ...context };
+  }
+};
+function createState(initial = {}) {
+  return new ReactiveState(initial);
+}
+
 // src/HoloScriptRuntime.ts
 var RUNTIME_SECURITY_LIMITS = {
   maxExecutionDepth: 50,
@@ -9,7 +115,7 @@ var RUNTIME_SECURITY_LIMITS = {
   maxCallStackDepth: 100
 };
 var HoloScriptRuntime = class {
-  constructor(_importLoader) {
+  constructor(_importLoader, customFunctions) {
     this.particleSystems = /* @__PURE__ */ new Map();
     this.executionHistory = [];
     this.startTime = 0;
@@ -20,13 +126,18 @@ var HoloScriptRuntime = class {
     this.uiElements = /* @__PURE__ */ new Map();
     this.context = this.createEmptyContext();
     this.currentScope = { variables: this.context.variables };
-    this.builtinFunctions = this.initBuiltins();
+    this.builtinFunctions = this.initBuiltins(customFunctions);
   }
   /**
    * Initialize built-in functions
    */
-  initBuiltins() {
+  initBuiltins(customFunctions) {
     const builtins = /* @__PURE__ */ new Map();
+    if (customFunctions) {
+      for (const [name, func] of Object.entries(customFunctions)) {
+        builtins.set(name, func);
+      }
+    }
     builtins.set("show", (args) => {
       const target = String(args[0]);
       const element = this.uiElements.get(target);
@@ -45,7 +156,7 @@ var HoloScriptRuntime = class {
       logger.info("hide", { target });
       return { hidden: target };
     });
-    builtins.set("pulse", (args) => {
+    builtins.set("pulsate", (args) => {
       const target = String(args[0]);
       const options = args[1] || {};
       const duration = Number(options.duration) || 1e3;
@@ -139,6 +250,15 @@ var HoloScriptRuntime = class {
       if (Array.isArray(arr)) return arr[index];
       return void 0;
     });
+    builtins.set("showSettings", () => {
+      this.emit("show-settings");
+      return true;
+    });
+    builtins.set("openChat", (args) => {
+      const config = args[0] || {};
+      this.emit("show-chat", config);
+      return true;
+    });
     builtins.set("log", (args) => {
       logger.info("HoloScript log", { args });
       return args[0];
@@ -152,6 +272,17 @@ var HoloScriptRuntime = class {
     builtins.set("isArray", (args) => Array.isArray(args[0]));
     builtins.set("isNumber", (args) => typeof args[0] === "number" && !isNaN(args[0]));
     builtins.set("isString", (args) => typeof args[0] === "string");
+    builtins.set("shop", (args) => this.handleShop(args));
+    builtins.set("inventory", (args) => this.handleInventory(args));
+    builtins.set("purchase", (args) => this.handlePurchase(args));
+    builtins.set("presence", (args) => this.handlePresence(args));
+    builtins.set("invite", (args) => this.handleInvite(args));
+    builtins.set("share", (args) => this.handleShare(args));
+    builtins.set("physics", (args) => this.handlePhysics(args));
+    builtins.set("gravity", (args) => this.handleGravity(args));
+    builtins.set("collide", (args) => this.handleCollide(args));
+    builtins.set("animate", (args) => this.handleAnimate(args));
+    builtins.set("calculate_arc", (args) => this.handleCalculateArc(args));
     return builtins;
   }
   /**
@@ -179,7 +310,6 @@ var HoloScriptRuntime = class {
         case "stream":
           result = await this.executeStream(node);
           break;
-        case "execute":
         case "call":
           result = await this.executeCall(node);
           break;
@@ -208,6 +338,36 @@ var HoloScriptRuntime = class {
         case "expression-statement":
           result = await this.executeCall(node);
           break;
+        case "scale":
+          result = await this.executeScale(node);
+          break;
+        case "focus":
+          result = await this.executeFocus(node);
+          break;
+        case "environment":
+          result = await this.executeEnvironment(node);
+          break;
+        case "composition":
+          result = await this.executeComposition(node);
+          break;
+        case "template":
+          result = await this.executeTemplate(node);
+          break;
+        case "server":
+          result = await this.executeServerNode(node);
+          break;
+        case "database":
+          result = await this.executeDatabaseNode(node);
+          break;
+        case "fetch":
+          result = await this.executeFetchNode(node);
+          break;
+        case "execute":
+          result = await this.executeTarget(node);
+          break;
+        case "state-declaration":
+          result = await this.executeStateDeclaration(node);
+          break;
         default:
           result = {
             success: false,
@@ -231,6 +391,22 @@ var HoloScriptRuntime = class {
       return errorResult;
     }
   }
+  /**
+   * Execute multiple nodes or a single node (unified entry point)
+   */
+  async execute(nodes) {
+    if (Array.isArray(nodes)) {
+      const results = await this.executeProgram(nodes);
+      const success = results.every((r) => r.success);
+      return {
+        success,
+        output: success ? `Program executed (${results.length} nodes)` : "Program failed",
+        error: results.find((r) => !r.success)?.error
+      };
+    } else {
+      return this.executeNode(nodes);
+    }
+  }
   /**
    * Execute multiple nodes in sequence
    */
@@ -401,119 +577,45 @@ var HoloScriptRuntime = class {
    */
   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))) {
-      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;
+    const evaluator = new ExpressionEvaluator(this.context.state.getSnapshot());
+    const varContext = {};
+    this.context.variables.forEach((v, k) => varContext[k] = v);
+    evaluator.updateContext(varContext);
+    return evaluator.evaluate(expr);
   }
   // ============================================================================
   // Node Executors
   // ============================================================================
   async executeOrb(node) {
+    const scale = this.context.currentScale || 1;
+    const adjustedPos = node.position ? {
+      x: node.position.x * scale,
+      y: node.position.y * scale,
+      z: node.position.z * scale
+    } : { x: 0, y: 0, z: 0 };
     if (node.position) {
-      this.context.spatialMemory.set(node.name, node.position);
+      this.context.spatialMemory.set(node.name, adjustedPos);
+    }
+    const hologram = node.hologram ? {
+      ...node.hologram,
+      size: (node.hologram.size || 1) * scale
+    } : void 0;
+    const evaluatedProperties = {};
+    for (const [key, val] of Object.entries(node.properties)) {
+      if (typeof val === "string") {
+        evaluatedProperties[key] = this.evaluateExpression(val);
+      } else {
+        evaluatedProperties[key] = val;
+      }
     }
     const orbData = {
       __type: "orb",
       name: node.name,
-      properties: { ...node.properties },
-      position: node.position || { x: 0, y: 0, z: 0 },
-      hologram: node.hologram,
+      properties: evaluatedProperties,
+      traits: node.directives?.filter((d) => d.type === "trait").map((d) => d.name) || [],
+      directives: node.directives || [],
+      position: adjustedPos,
+      hologram,
       created: Date.now(),
       // Methods bound to this orb
       show: () => this.builtinFunctions.get("show")([node.name]),
@@ -521,16 +623,19 @@ var HoloScriptRuntime = class {
       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);
+    if (hologram) {
+      this.context.hologramState.set(node.name, hologram);
+    }
+    if (node.directives) {
+      this.applyDirectives(node);
     }
-    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`, adjustedPos, "#00ffff", 20);
+    logger.info("Orb created", { name: node.name, properties: Object.keys(node.properties), scale });
     return {
       success: true,
       output: orbData,
-      hologram: node.hologram,
-      spatialPosition: node.position
+      hologram,
+      spatialPosition: adjustedPos
     };
   }
   async executeFunction(node) {
@@ -1048,7 +1153,7 @@ var HoloScriptRuntime = class {
       case "count":
         return Array.isArray(data) ? data.length : 1;
       case "unique":
-        return Array.isArray(data) ? [...new Set(data)] : data;
+        return Array.isArray(data) ? Array.from(new Set(data)) : data;
       case "flatten":
         return Array.isArray(data) ? data.flat() : data;
       case "reverse":
@@ -1079,6 +1184,13 @@ var HoloScriptRuntime = class {
     handlers.push(handler);
     this.eventHandlers.set(event, handlers);
   }
+  /**
+   * Register host function
+   */
+  registerFunction(name, handler) {
+    this.builtinFunctions.set(name, handler);
+    logger.info(`Host function registered: ${name}`);
+  }
   /**
    * Remove event handler
    */
@@ -1141,6 +1253,158 @@ var HoloScriptRuntime = class {
         anim.startTime = now;
       }
     }
+    this.updateSystemVariables();
+  }
+  /**
+   * Update real-life and system variables ($time, $user, etc.)
+   */
+  updateSystemVariables() {
+    const now = /* @__PURE__ */ new Date();
+    this.setVariable("$time", now.toLocaleTimeString());
+    this.setVariable("$date", now.toLocaleDateString());
+    this.setVariable("$timestamp", now.getTime());
+    this.setVariable("$hour", now.getHours());
+    this.setVariable("$minute", now.getMinutes());
+    this.setVariable("$second", now.getSeconds());
+    if (this.getVariable("$user") === void 0) {
+      this.setVariable("$user", {
+        id: "user_123",
+        name: "Alpha Explorer",
+        level: 42,
+        rank: "Legendary",
+        achievements: ["First World", "Spirit Guide"],
+        preferences: { theme: "holographic", language: "en" }
+      });
+    }
+    if (this.getVariable("$location") === void 0) {
+      this.setVariable("$location", {
+        city: "Neo Tokyo",
+        region: "Holo-Sector 7",
+        coordinates: { lat: 35.6895, lng: 139.6917 },
+        altitude: 450
+      });
+    }
+    if (this.getVariable("$weather") === void 0) {
+      this.setVariable("$weather", {
+        condition: "Neon Mist",
+        temperature: 24,
+        humidity: 65,
+        windSpeed: 12,
+        unit: "C"
+      });
+    }
+    if (this.getVariable("$wallet") === void 0) {
+      this.setVariable("$wallet", {
+        address: "0xHolo...42ff",
+        balance: 1337.5,
+        currency: "HOLO",
+        network: "MainNet"
+      });
+    }
+    if (this.getVariable("$ai_config") === void 0) {
+      const savedKeys = typeof localStorage !== "undefined" ? localStorage.getItem("brittney_api_keys") : null;
+      let configuredCount = 0;
+      if (savedKeys) {
+        try {
+          const keys = JSON.parse(savedKeys);
+          configuredCount = Object.values(keys).filter((k) => !!k).length;
+        } catch (e) {
+        }
+      }
+      this.setVariable("$ai_config", {
+        status: configuredCount > 0 ? "configured" : "pending",
+        providerCount: configuredCount,
+        lastUpdated: Date.now()
+      });
+    }
+    if (this.getVariable("$chat_status") === void 0) {
+      this.setVariable("$chat_status", {
+        active: true,
+        typing: false,
+        version: "1.0.0-brittney"
+      });
+    }
+  }
+  // ==========================================================================
+  // COMMERCE PRIMITIVES
+  // ==========================================================================
+  handleShop(args) {
+    const config = args[0] || {};
+    this.emit("shop", config);
+    return { success: true, type: "shop", config };
+  }
+  handleInventory(args) {
+    const item = args[0];
+    const action = args[1] || "add";
+    this.emit("inventory", { item, action });
+    return { success: true, item, action };
+  }
+  handlePurchase(args) {
+    const productId = args[0];
+    this.emit("purchase", { productId });
+    return { success: true, productId, status: "pending" };
+  }
+  // ==========================================================================
+  // SOCIAL PRIMITIVES
+  // ==========================================================================
+  handlePresence(args) {
+    const config = args[0] || {};
+    this.emit("presence", config);
+    return { success: true, active: true };
+  }
+  handleInvite(args) {
+    const userId = args[0];
+    this.emit("invite", { userId });
+    return { success: true, userId };
+  }
+  handleShare(args) {
+    const scriptId = args[0];
+    const targetUserId = args[1];
+    this.emit("share", { scriptId, targetUserId });
+    return { success: true, scriptId };
+  }
+  // ==========================================================================
+  // PHYSICS PRIMITIVES
+  // ==========================================================================
+  handlePhysics(args) {
+    const config = args[0] || {};
+    this.emit("physics", config);
+    return { success: true, enabled: config.enabled !== false };
+  }
+  handleGravity(args) {
+    const value = args[0] ?? 9.81;
+    this.emit("gravity", { value });
+    return { success: true, value };
+  }
+  handleCollide(args) {
+    const target = args[0];
+    const handler = args[1];
+    this.emit("collide", { target, handler });
+    return { success: true, target };
+  }
+  /**
+   * Handle calculate_arc(start, end, speed)
+   */
+  handleCalculateArc(args) {
+    if (args.length < 3) return { x: 0, y: 0, z: 0 };
+    const start = args[0];
+    const end = args[1];
+    const speed = args[2];
+    const dx = end.x - start.x;
+    const dz = end.z - start.z;
+    const dy = end.y - start.y;
+    const dist = Math.sqrt(dx * dx + dz * dz);
+    if (dist < 0.1) return { x: 0, y: speed, z: 0 };
+    const t = dist / speed;
+    const vx = dx / t;
+    const vz = dz / t;
+    const vy = dy / t + 0.5 * 9.81 * t;
+    return { x: vx, y: vy, z: vz };
+  }
+  handleAnimate(args) {
+    const options = args[0] || {};
+    this.emit("animate", options);
+    return { success: true, options };
   }
   applyEasing(t, easing) {
     switch (easing) {
@@ -1277,9 +1541,135 @@ var HoloScriptRuntime = class {
       connections: [],
       spatialMemory: /* @__PURE__ */ new Map(),
       hologramState: /* @__PURE__ */ new Map(),
-      executionStack: []
+      executionStack: [],
+      currentScale: 1,
+      scaleMagnitude: "standard",
+      focusHistory: [],
+      environment: {},
+      templates: /* @__PURE__ */ new Map(),
+      state: createState({})
+    };
+  }
+  async executeScale(node) {
+    const parentScale = this.context.currentScale;
+    this.context.currentScale *= node.multiplier;
+    this.context.scaleMagnitude = node.magnitude;
+    logger.info("Scale context entering", { magnitude: node.magnitude, multiplier: this.context.currentScale });
+    this.emit("scale:change", { multiplier: this.context.currentScale, magnitude: node.magnitude });
+    const results = await this.executeProgram(node.body, this.context.executionStack.length);
+    this.context.currentScale = parentScale;
+    this.emit("scale:change", { multiplier: this.context.currentScale });
+    return {
+      success: results.every((r) => r.success),
+      output: `Executed scale block: ${node.magnitude}`
     };
   }
+  async executeFocus(node) {
+    this.context.focusHistory.push(node.target);
+    const results = await this.executeProgram(node.body, this.context.executionStack.length);
+    return {
+      success: results.every((r) => r.success),
+      output: `Focused on ${node.target}`
+    };
+  }
+  async executeEnvironment(node) {
+    this.context.environment = { ...this.context.environment, ...node.settings };
+    return { success: true, output: "Environment updated" };
+  }
+  async executeComposition(node) {
+    return {
+      success: (await this.executeProgram(node.children, this.context.executionStack.length)).every((r) => r.success),
+      output: `Composition ${node.name} executed`
+    };
+  }
+  async executeTemplate(node) {
+    this.context.templates.set(node.name, node);
+    return { success: true, output: `Template ${node.name} registered` };
+  }
+  async executeServerNode(node) {
+    if (this.context.mode === "public") {
+      return { success: false, error: "SecurityViolation: Server creation blocked in public mode.", executionTime: 0 };
+    }
+    logger.info(`Starting server on port ${node.port}`);
+    return {
+      success: true,
+      output: `Server listening on port ${node.port}`,
+      hologram: node.hologram,
+      executionTime: 0
+    };
+  }
+  async executeDatabaseNode(node) {
+    if (this.context.mode === "public") {
+      return { success: false, error: "SecurityViolation: DB access blocked in public mode.", executionTime: 0 };
+    }
+    logger.info(`Executing Query: ${node.query}`);
+    return {
+      success: true,
+      output: `Query executed: ${node.query}`,
+      hologram: node.hologram,
+      executionTime: 0
+    };
+  }
+  async executeFetchNode(node) {
+    if (this.context.mode === "public") {
+      return { success: false, error: "SecurityViolation: External fetch blocked in public mode.", executionTime: 0 };
+    }
+    logger.info(`Fetching: ${node.url}`);
+    return {
+      success: true,
+      output: `Fetched data from ${node.url}`,
+      hologram: node.hologram,
+      executionTime: 0
+    };
+  }
+  async executeTarget(node) {
+    const target = this.context.functions.get(node.target);
+    if (!target) {
+      return {
+        success: false,
+        error: `Function ${node.target} not found`,
+        executionTime: 0
+      };
+    }
+    const result = await this.executeFunction(target);
+    this.createExecutionEffect(node.target, target.position || { x: 0, y: 0, z: 0 });
+    return {
+      success: true,
+      output: `Executed ${node.target}`,
+      hologram: {
+        shape: "sphere",
+        color: "#ff4500",
+        size: 1.2,
+        glow: true,
+        interactive: false
+      },
+      executionTime: result.executionTime
+    };
+  }
+  async executeStateDeclaration(node) {
+    const stateDirective = node.directives?.find((d) => d.type === "state");
+    if (stateDirective) {
+      this.context.state.update(stateDirective.body);
+    }
+    return { success: true, output: "State updated" };
+  }
+  applyDirectives(node) {
+    if (!node.directives) return;
+    for (const d of node.directives) {
+      if (d.type === "trait") {
+        logger.info(`Applying trait ${d.name} to ${node.type}`);
+        if (d.name === "chat") {
+          this.emit("show-chat", d.config);
+        }
+      } else if (d.type === "state") {
+        this.context.state.update(d.body);
+      } else if (d.type === "lifecycle") {
+        if (d.hook === "on_mount") {
+          this.evaluateExpression(d.body);
+        }
+      }
+    }
+  }
   getExecutionHistory() {
     return [...this.executionHistory];
   }
@@ -1289,8 +1679,11 @@ var HoloScriptRuntime = class {
   getCallStack() {
     return [...this.callStack];
   }
+  getState() {
+    return this.context.state.getSnapshot();
+  }
 };
 
 export { HoloScriptRuntime };
-//# sourceMappingURL=chunk-EU6CZMGJ.js.map
-//# sourceMappingURL=chunk-EU6CZMGJ.js.map
+//# sourceMappingURL=chunk-AFFVFO4D.js.map
+//# sourceMappingURL=chunk-AFFVFO4D.js.map