@holoscript/core 6.0.4 → 6.1.2

package/dist/chunk-IHESJZSW.js

@@ -0,0 +1,4490 @@
+import { HoloScriptCodeParser } from './chunk-URG2SJLK.js';
+import { ReactiveState, ExpressionEvaluator, createState } from './chunk-XL6INWKT.js';
+import { JEPAPredictor, jepObjectiveHandler, mitosisHandler, orbitalHandler } from './chunk-77V4GTCA.js';
+import { logger } from './chunk-PHENW4MQ.js';
+import { init_safeJsonParse, readJson } from './chunk-VVKVQZI6.js';
+import { WebSocketServer, WebSocket } from 'ws';
+import { AttentionEngine, TimeManager } from '@holoscript/engine/orbital';
+import { StateSynchronizer } from '@holoscript/mesh';
+import * as engineRuntime from '@holoscript/engine/runtime';
+import { MemoryConsolidator } from '@holoscript/framework/learning';
+
+// src/HoloScriptRuntime.ts
+init_safeJsonParse();
+
+// src/runtime/physics-math.ts
+var GRAVITY = 9.81;
+var ARC_MIN_DISTANCE = 0.1;
+function calculateArc(start, end, speed) {
+  const dx = end[0] - start[0];
+  const dz = end[2] - start[2];
+  const dy = end[1] - start[1];
+  const dist = Math.sqrt(dx * dx + dz * dz);
+  if (dist < ARC_MIN_DISTANCE) return [0, speed, 0];
+  const t = dist / speed;
+  const vx = dx / t;
+  const vz = dz / t;
+  const vy = dy / t + 0.5 * GRAVITY * t;
+  return [vx, vy, vz];
+}
+
+// src/runtime/condition-evaluator.ts
+var SUSPICIOUS_KEYWORDS = [
+  "eval",
+  "process",
+  "require",
+  "__proto__",
+  "constructor"
+];
+function evaluateCondition(condition, evaluate) {
+  if (!condition) return false;
+  const condStr = String(condition);
+  if (SUSPICIOUS_KEYWORDS.some((kw) => condStr.toLowerCase().includes(kw))) {
+    logger.warn("Suspicious condition blocked", { condition });
+    return false;
+  }
+  try {
+    if (condStr.trim().toLowerCase() === "true") return true;
+    if (condStr.trim().toLowerCase() === "false") return false;
+    const comparisonPatterns = [
+      { regex: /^(.+?)\s*(===|!==)\s*(.+)$/ },
+      { regex: /^(.+?)\s*(==|!=|>=|<=|>|<)\s*(.+)$/ },
+      { regex: /^(.+?)\s*(&&)\s*(.+)$/, logical: "and" },
+      { regex: /^(.+?)\s*(\|\|)\s*(.+)$/, logical: "or" }
+    ];
+    for (const { regex, logical } of comparisonPatterns) {
+      const match = condStr.match(regex);
+      if (match) {
+        const [, leftExpr, operator, rightExpr] = match;
+        const left = evaluate(leftExpr.trim());
+        const right = evaluate(rightExpr.trim());
+        if (logical === "and") return Boolean(left) && Boolean(right);
+        if (logical === "or") return Boolean(left) || Boolean(right);
+        switch (operator) {
+          case "===":
+            return left === right;
+          case "!==":
+            return left !== right;
+          case "==":
+            return left == right;
+          case "!=":
+            return left != right;
+          case ">=":
+            return Number(left) >= Number(right);
+          case "<=":
+            return Number(left) <= Number(right);
+          case ">":
+            return Number(left) > Number(right);
+          case "<":
+            return Number(left) < Number(right);
+        }
+      }
+    }
+    if (condStr.startsWith("!")) {
+      return !evaluateCondition(condStr.slice(1).trim(), evaluate);
+    }
+    const value = evaluate(condStr.trim());
+    return Boolean(value);
+  } catch (error) {
+    logger.error("Condition evaluation error", { condition, error });
+    return false;
+  }
+}
+
+// src/runtime/particle-effects.ts
+var DATA_TYPE_COLORS = {
+  string: "#ff6b35",
+  number: "#4ecdc4",
+  boolean: "#45b7d1",
+  object: "#96ceb4",
+  array: "#ffeaa7",
+  any: "#dda0dd",
+  move: "#ff69b4"
+};
+var DEFAULT_DATA_TYPE_COLOR = "#ffffff";
+var CONNECTION_STREAM_STEPS = 20;
+var FLOW_STREAM_MAX_COUNT = 50;
+var DATAVIZ_ARRAY_MAX = 100;
+var DATAVIZ_OBJECT_MAX = 50;
+var DATAVIZ_OBJECT_KEY_MULT = 5;
+var FLOW_STREAM_DEFAULT_COUNT = 10;
+var DATAVIZ_DEFAULT_COUNT = 10;
+var EXECUTION_EFFECT_COUNT = 30;
+var CONNECTION_STREAM_LIFETIME_MS = 5e3;
+var PARTICLE_DEFAULT_LIFETIME_MS = 3e3;
+var PARTICLE_DEFAULT_SPEED = 0.01;
+var CONNECTION_STREAM_SPEED = 0.02;
+var FLOW_STREAM_COLOR = "#45b7d1";
+var EXECUTION_EFFECT_COLOR = "#ff4500";
+var DATAVIZ_COLOR = "#32cd32";
+function getDataTypeColor(dataType) {
+  return DATA_TYPE_COLORS[dataType] ?? DEFAULT_DATA_TYPE_COLOR;
+}
+function createParticleEffect(particleSystems, name, position, color, count, maxParticlesPerSystem) {
+  const limitedCount = Math.min(count, maxParticlesPerSystem);
+  const particles = [];
+  for (let i = 0; i < limitedCount; i++) {
+    particles.push([
+      position[0] + (Math.random() - 0.5) * 2,
+      position[1] + (Math.random() - 0.5) * 2,
+      position[2] + (Math.random() - 0.5) * 2
+    ]);
+  }
+  particleSystems.set(name, {
+    particles,
+    color,
+    lifetime: PARTICLE_DEFAULT_LIFETIME_MS,
+    speed: PARTICLE_DEFAULT_SPEED
+  });
+}
+function createConnectionStream(particleSystems, from, to, fromPos, toPos, dataType) {
+  const streamName = `connection_${from}_${to}`;
+  const particles = [];
+  for (let i = 0; i <= CONNECTION_STREAM_STEPS; i++) {
+    const t = i / CONNECTION_STREAM_STEPS;
+    particles.push([
+      fromPos[0] + (toPos[0] - fromPos[0]) * t,
+      fromPos[1] + (toPos[1] - fromPos[1]) * t,
+      fromPos[2] + (toPos[2] - fromPos[2]) * t
+    ]);
+  }
+  particleSystems.set(streamName, {
+    particles,
+    color: getDataTypeColor(dataType),
+    lifetime: CONNECTION_STREAM_LIFETIME_MS,
+    speed: CONNECTION_STREAM_SPEED
+  });
+}
+function createFlowingStream(particleSystems, name, position, data, maxParticlesPerSystem) {
+  const count = Array.isArray(data) ? Math.min(data.length, FLOW_STREAM_MAX_COUNT) : FLOW_STREAM_DEFAULT_COUNT;
+  createParticleEffect(
+    particleSystems,
+    `${name}_flow`,
+    position,
+    FLOW_STREAM_COLOR,
+    count,
+    maxParticlesPerSystem
+  );
+}
+function createExecutionEffect(particleSystems, name, position, maxParticlesPerSystem) {
+  createParticleEffect(
+    particleSystems,
+    `${name}_execution`,
+    position,
+    EXECUTION_EFFECT_COLOR,
+    EXECUTION_EFFECT_COUNT,
+    maxParticlesPerSystem
+  );
+}
+function updateParticles(particleSystems, deltaTime) {
+  for (const [name, system] of particleSystems) {
+    system.lifetime -= deltaTime;
+    system.particles.forEach((particle) => {
+      particle[0] += (Math.random() - 0.5) * system.speed;
+      particle[1] += (Math.random() - 0.5) * system.speed;
+      particle[2] += (Math.random() - 0.5) * system.speed;
+    });
+    if (system.lifetime <= 0) {
+      particleSystems.delete(name);
+    }
+  }
+}
+function createDataVisualization(particleSystems, name, data, position, maxParticlesPerSystem) {
+  let count = DATAVIZ_DEFAULT_COUNT;
+  if (Array.isArray(data)) {
+    count = Math.min(data.length, DATAVIZ_ARRAY_MAX);
+  } else if (typeof data === "object" && data !== null) {
+    count = Math.min(Object.keys(data).length * DATAVIZ_OBJECT_KEY_MULT, DATAVIZ_OBJECT_MAX);
+  }
+  createParticleEffect(
+    particleSystems,
+    `${name}_visualization`,
+    position,
+    DATAVIZ_COLOR,
+    count,
+    maxParticlesPerSystem
+  );
+}
+
+// src/runtime/transformation.ts
+var TAKE_DEFAULT_COUNT = 10;
+async function applyTransformation(data, transform, ctx) {
+  const params = transform.parameters || {};
+  switch (transform.operation) {
+    case "filter": {
+      if (!Array.isArray(data)) return data;
+      const predicate = params.predicate;
+      if (predicate) {
+        return data.filter((item) => {
+          ctx.setVariable("_item", item);
+          return ctx.evaluateCondition(predicate);
+        });
+      }
+      return data.filter((item) => item !== null && item !== void 0);
+    }
+    case "map": {
+      if (!Array.isArray(data)) return data;
+      const mapper = params.mapper;
+      if (mapper) {
+        return data.map((item) => {
+          ctx.setVariable("_item", item);
+          return ctx.evaluateExpression(mapper);
+        });
+      }
+      return data.map((item) => ({ value: item, processed: true }));
+    }
+    case "reduce": {
+      if (!Array.isArray(data)) return data;
+      const initial = params.initial ?? 0;
+      const reducer = params.reducer;
+      if (reducer) {
+        return data.reduce((acc, item) => {
+          ctx.setVariable("_acc", acc);
+          ctx.setVariable("_item", item);
+          return ctx.evaluateExpression(reducer);
+        }, initial);
+      }
+      return data.reduce((acc, item) => acc + (typeof item === "number" ? item : 0), 0);
+    }
+    case "sort": {
+      if (!Array.isArray(data)) return data;
+      const key = params.key;
+      const desc = params.descending;
+      const sorted = [...data].sort((a, b) => {
+        const aVal = key ? a[key] : a;
+        const bVal = key ? b[key] : b;
+        if (aVal < bVal) return desc ? 1 : -1;
+        if (aVal > bVal) return desc ? -1 : 1;
+        return 0;
+      });
+      return sorted;
+    }
+    case "sum":
+      return Array.isArray(data) ? data.reduce((sum, item) => sum + (typeof item === "number" ? item : 0), 0) : data;
+    case "count":
+      return Array.isArray(data) ? data.length : 1;
+    case "unique":
+      return Array.isArray(data) ? Array.from(new Set(data)) : data;
+    case "flatten":
+      return Array.isArray(data) ? data.flat() : data;
+    case "reverse":
+      return Array.isArray(data) ? [...data].reverse() : data;
+    case "take": {
+      if (!Array.isArray(data)) return data;
+      const count = Number(params.count) || TAKE_DEFAULT_COUNT;
+      return data.slice(0, count);
+    }
+    case "skip": {
+      if (!Array.isArray(data)) return data;
+      const count = Number(params.count) || 0;
+      return data.slice(count);
+    }
+    default:
+      logger.warn("Unknown transformation", { operation: transform.operation });
+      return data;
+  }
+}
+
+// src/runtime/easing.ts
+function applyEasing(t, easing) {
+  switch (easing) {
+    case "easeIn":
+      return t * t;
+    case "easeOut":
+      return t * (2 - t);
+    case "easeInOut":
+      return t < 0.5 ? 2 * t * t : -1 + (4 - 2 * t) * t;
+    case "easeInQuad":
+      return t * t;
+    case "easeOutQuad":
+      return t * (2 - t);
+    case "easeInOutQuad":
+      return t < 0.5 ? 2 * t * t : -1 + (4 - 2 * t) * t;
+    case "linear":
+    default:
+      return t;
+  }
+}
+
+// src/runtime/animation-system.ts
+function updateAnimations(animations, setVariable, now) {
+  for (const [key, anim] of animations) {
+    const elapsed = now - anim.startTime;
+    let progress = Math.min(elapsed / anim.duration, 1);
+    progress = applyEasing(progress, anim.easing);
+    const currentValue = anim.from + (anim.to - anim.from) * progress;
+    if (anim.yoyo && progress >= 1) {
+      anim.startTime = now;
+      [anim.from, anim.to] = [anim.to, anim.from];
+    }
+    setVariable(`${anim.target}.${anim.property}`, currentValue);
+    if (progress >= 1 && !anim.loop && !anim.yoyo) {
+      animations.delete(key);
+    } else if (progress >= 1 && anim.loop) {
+      anim.startTime = now;
+    }
+  }
+}
+function broadcast(wss, type, payload) {
+  if (!wss) return;
+  const message = JSON.stringify({ type, payload });
+  wss.clients.forEach((client) => {
+    if (client.readyState === WebSocket.OPEN) {
+      client.send(message);
+    }
+  });
+}
+function handleTimeControl(timeManager, command, value) {
+  if (!timeManager) return;
+  switch (command) {
+    case "play":
+      timeManager.play();
+      break;
+    case "pause":
+      timeManager.pause();
+      break;
+    case "toggle":
+      timeManager.togglePause();
+      break;
+    case "setSpeed":
+      if (typeof value === "number") {
+        timeManager.setTimeScale(value);
+      }
+      break;
+    case "setDate":
+      if (value) {
+        timeManager.setDate(new Date(value));
+      }
+      break;
+    case "syncRealTime":
+      timeManager.setDate(/* @__PURE__ */ new Date());
+      timeManager.setTimeScale(1);
+      timeManager.play();
+      break;
+  }
+}
+
+// src/runtime/holo-statement-executor.ts
+var MAX_ITERATIONS = 1e3;
+async function executeHoloProgram(statements, scopeOverride, ctx) {
+  const results = [];
+  ctx.telemetry.setGauge("execution_depth", ctx.telemetry.executionDepth());
+  for (const stmt of statements) {
+    ctx.telemetry.incrementCounter("statements_executed", 1, { type: stmt.type });
+    const res = await ctx.telemetry.measureLatency(
+      `execute_stmt_${stmt.type}`,
+      () => executeHoloStatement(stmt, scopeOverride, ctx)
+    );
+    results.push(res);
+    const last = results[results.length - 1];
+    if (last.success && last.output !== void 0 && stmt.type === "ReturnStatement") {
+      break;
+    }
+  }
+  return results;
+}
+async function executeHoloStatement(stmt, scopeOverride, ctx) {
+  try {
+    switch (stmt.type) {
+      case "Assignment": {
+        const value = await ctx.evaluateHoloExpression(stmt.value, scopeOverride);
+        let finalValue = value;
+        if (stmt.operator !== "=") {
+          const current = ctx.getVariable(stmt.target, scopeOverride);
+          if (stmt.operator === "+=")
+            finalValue = Number(current) + Number(value);
+          else if (stmt.operator === "-=")
+            finalValue = Number(current) - Number(value);
+          else if (stmt.operator === "*=")
+            finalValue = Number(current) * Number(value);
+          else if (stmt.operator === "/=")
+            finalValue = Number(current) / Number(value);
+        }
+        ctx.setVariable(stmt.target, finalValue, scopeOverride);
+        return { success: true };
+      }
+      case "IfStatement": {
+        const condition = await ctx.evaluateHoloExpression(stmt.condition, scopeOverride);
+        if (condition) {
+          await executeHoloProgram(stmt.consequent, scopeOverride, ctx);
+        } else if (stmt.alternate) {
+          await executeHoloProgram(stmt.alternate, scopeOverride, ctx);
+        }
+        return { success: true };
+      }
+      case "WhileStatement": {
+        let iter = 0;
+        while (await ctx.evaluateHoloExpression(stmt.condition, scopeOverride)) {
+          if (iter++ > MAX_ITERATIONS) return { success: false, error: "Infinite loop" };
+          await executeHoloProgram(stmt.body, scopeOverride, ctx);
+        }
+        return { success: true };
+      }
+      case "ClassicForStatement": {
+        if (stmt.init) await executeHoloStatement(stmt.init, scopeOverride, ctx);
+        let iter = 0;
+        while (!stmt.test || await ctx.evaluateHoloExpression(stmt.test, scopeOverride)) {
+          if (iter++ > MAX_ITERATIONS) return { success: false, error: "Infinite loop" };
+          await executeHoloProgram(stmt.body, scopeOverride, ctx);
+          if (stmt.update) await executeHoloStatement(stmt.update, scopeOverride, ctx);
+        }
+        return { success: true };
+      }
+      case "VariableDeclaration": {
+        const value = stmt.value ? await ctx.evaluateHoloExpression(stmt.value, scopeOverride) : void 0;
+        const scope = scopeOverride || ctx.currentScope;
+        scope.variables.set(stmt.name, value);
+        return { success: true };
+      }
+      case "EmitStatement": {
+        const data = stmt.data ? await ctx.evaluateHoloExpression(stmt.data, scopeOverride) : void 0;
+        ctx.emit(stmt.event, data);
+        return { success: true };
+      }
+      case "AwaitStatement": {
+        const value = await ctx.evaluateHoloExpression(stmt.expression, scopeOverride);
+        if (value instanceof Promise) await value;
+        return { success: true };
+      }
+      case "ReturnStatement": {
+        const value = stmt.value ? await ctx.evaluateHoloExpression(stmt.value, scopeOverride) : null;
+        return { success: true, output: value };
+      }
+      case "ExpressionStatement": {
+        const val = await ctx.evaluateHoloExpression(stmt.expression, scopeOverride);
+        return { success: true, output: val };
+      }
+      default:
+        return {
+          success: false,
+          error: `Unknown stmt type: ${stmt.type}`
+        };
+    }
+  } catch (err) {
+    const errMsg = err instanceof Error ? err.message : String(err);
+    console.error(`[EXEC_ERROR] Statement ${stmt.type} failed:`, errMsg);
+    return { success: false, error: errMsg };
+  }
+}
+
+// src/runtime/debug-executor.ts
+var DEBUG_HOLOGRAM = {
+  shape: "pyramid",
+  color: "#ff1493",
+  size: 0.8,
+  glow: true,
+  interactive: true
+};
+async function executeDebug(node, ctx) {
+  const debugInfo = {
+    variables: Object.fromEntries(ctx.scopeVariables),
+    contextVariables: Object.fromEntries(ctx.contextVariables),
+    functions: Array.from(ctx.functions.keys()),
+    connections: ctx.connections.length,
+    callStack: [...ctx.callStack],
+    uiElements: Array.from(ctx.uiElements.keys()),
+    animations: Array.from(ctx.animations.keys()),
+    executionHistory: ctx.executionHistory.slice(-10)
+  };
+  const debugOrb = { ...DEBUG_HOLOGRAM };
+  ctx.setHologramState(`debug_${node.target || "program"}`, debugOrb);
+  ctx.logInfo("Debug info", debugInfo);
+  return {
+    success: true,
+    output: debugInfo,
+    hologram: debugOrb
+  };
+}
+
+// src/runtime/io-node-executors.ts
+async function executeServerNode(node, ctx) {
+  if (ctx.isPublicMode) {
+    return {
+      success: false,
+      error: "SecurityViolation: Server creation blocked in public mode.",
+      executionTime: 0
+    };
+  }
+  ctx.logInfo(`Starting server on port ${node.port}`);
+  return {
+    success: true,
+    output: `Server listening on port ${node.port}`,
+    hologram: node.hologram,
+    executionTime: 0
+  };
+}
+async function executeDatabaseNode(node, ctx) {
+  if (ctx.isPublicMode) {
+    return {
+      success: false,
+      error: "SecurityViolation: DB access blocked in public mode.",
+      executionTime: 0
+    };
+  }
+  ctx.logInfo(`Executing Query: ${node.query}`);
+  return {
+    success: true,
+    output: `Query executed: ${node.query}`,
+    hologram: node.hologram,
+    executionTime: 0
+  };
+}
+async function executeFetchNode(node, ctx) {
+  if (ctx.isPublicMode) {
+    return {
+      success: false,
+      error: "SecurityViolation: External fetch blocked in public mode.",
+      executionTime: 0
+    };
+  }
+  ctx.logInfo(`Fetching: ${node.url}`);
+  return {
+    success: true,
+    output: `Fetched data from ${node.url}`,
+    hologram: node.hologram,
+    executionTime: 0
+  };
+}
+
+// src/runtime/declaration-executors.ts
+async function executeStateDeclaration(node, ctx) {
+  const stateDirective = node.directives?.find((d) => d.type === "state");
+  if (stateDirective) {
+    ctx.updateState(stateDirective.body);
+  }
+  return { success: true, output: "State updated" };
+}
+async function executeMemoryDefinition(node, ctx) {
+  const startTime = Date.now();
+  const config = {};
+  for (const [key, val] of Object.entries(node.properties || {})) {
+    if (typeof val === "string") {
+      config[key] = ctx.evaluateExpression(val);
+    } else {
+      config[key] = val;
+    }
+  }
+  return {
+    success: true,
+    output: {
+      type: node.type,
+      config
+    },
+    executionTime: Date.now() - startTime
+  };
+}
+
+// src/runtime/orb-executor.ts
+function isOrbData(v) {
+  return v !== null && typeof v === "object" && v.__type === "orb";
+}
+var DEFAULT_HOLOGRAM_COLOR = "#ffffff";
+var DEFAULT_HOLOGRAM_SIZE = 1;
+var DEFAULT_HOLOGRAM_SHAPE = "sphere";
+var CREATION_PUFF_COLOR = "#00ffff";
+var CREATION_PUFF_COUNT = 20;
+function normalizePosition(position) {
+  if (!position) return [0, 0, 0];
+  if (Array.isArray(position)) {
+    return [
+      Number(position[0]) || 0,
+      Number(position[1]) || 0,
+      Number(position[2]) || 0
+    ];
+  }
+  const p = position;
+  return [Number(p[0]) || 0, Number(p[1]) || 0, Number(p[2]) || 0];
+}
+async function executeOrb(node, ctx) {
+  const scale = ctx.getCurrentScale() || 1;
+  const existingRaw = ctx.getVariable(node.name);
+  const existingOrb = isOrbData(existingRaw) ? existingRaw : void 0;
+  const isUpdate = !!existingOrb;
+  const pos = normalizePosition(node.position);
+  const adjustedPos = [pos[0] * scale, pos[1] * scale, pos[2] * scale];
+  if (node.position) {
+    ctx.setSpatialPosition(node.name, adjustedPos);
+  }
+  const evaluatedProperties = {};
+  if (Array.isArray(node.properties)) {
+    for (const prop of node.properties) {
+      const val = prop.value;
+      evaluatedProperties[prop.key] = typeof val === "string" ? ctx.evaluateExpression(val) : val;
+    }
+  } else if (node.properties) {
+    for (const [key, val] of Object.entries(node.properties)) {
+      evaluatedProperties[key] = typeof val === "string" ? ctx.evaluateExpression(val) : val;
+    }
+  }
+  const orbNodeExt = node;
+  if (orbNodeExt.template) {
+    const tpl = ctx.getTemplate(orbNodeExt.template);
+    if (tpl) {
+      if (tpl.properties) {
+        for (const [key, val] of Object.entries(tpl.properties)) {
+          if (evaluatedProperties[key] === void 0) {
+            evaluatedProperties[key] = typeof val === "string" ? ctx.evaluateExpression(val) : val;
+          }
+        }
+      }
+      if (tpl.directives) {
+        const existingDirectives = node.directives || [];
+        node.directives = [...tpl.directives, ...existingDirectives];
+      }
+    }
+  }
+  const hologram = node.hologram ? {
+    ...node.hologram,
+    size: (node.hologram.size || Number(evaluatedProperties.size) || Number(evaluatedProperties.scale) || DEFAULT_HOLOGRAM_SIZE) * scale
+  } : {
+    color: evaluatedProperties.color || DEFAULT_HOLOGRAM_COLOR,
+    size: (Number(evaluatedProperties.size) || Number(evaluatedProperties.scale) || DEFAULT_HOLOGRAM_SIZE) * scale,
+    shape: evaluatedProperties.geometry || DEFAULT_HOLOGRAM_SHAPE,
+    glow: !!evaluatedProperties.glow,
+    interactive: !!evaluatedProperties.interactive
+  };
+  if (isUpdate && node.template) {
+    const tpl = ctx.getTemplate(node.template);
+    const oldTpl = existingOrb?._templateRef;
+    if (tpl && oldTpl && tpl.version !== void 0 && oldTpl.version !== void 0) {
+      if (Number(tpl.version) > Number(oldTpl.version)) {
+        logger.info(
+          `Template version increase detected for ${node.name}: ${oldTpl.version} -> ${tpl.version}`
+        );
+        const migrations = tpl.migrations || [];
+        const migration = migrations.find((m) => m.fromVersion === Number(oldTpl.version));
+        if (migration) {
+          logger.info(`Executing migration from version ${oldTpl.version} for ${node.name}`);
+          await ctx.executeMigrationBlock(
+            existingOrb,
+            migration
+          );
+        }
+      }
+    }
+  }
+  const orbData = isUpdate ? existingOrb : {
+    __type: "orb",
+    id: node.name,
+    name: node.name,
+    created: Date.now(),
+    // Methods bound to this orb — fire-and-forget through builtins registry
+    show: () => ctx.getBuiltinFunction("show")([node.name]),
+    hide: () => ctx.getBuiltinFunction("hide")([node.name]),
+    pulse: (opts) => ctx.getBuiltinFunction("pulse")([node.name, opts])
+  };
+  if (isUpdate) {
+    orbData.properties = {
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      ...orbData.properties,
+      ...evaluatedProperties
+    };
+  } else {
+    orbData.properties = evaluatedProperties;
+  }
+  orbData.directives = node.directives || [];
+  orbData.position = adjustedPos;
+  orbData.hologram = hologram;
+  orbData._templateRef = node.template ? ctx.getTemplate(node.template) : void 0;
+  if (!isUpdate) {
+    ctx.setVariable(node.name, orbData);
+  }
+  if (hologram) {
+    ctx.setHologramState(node.name, hologram);
+  }
+  if (node.directives) {
+    ctx.applyDirectives(orbData);
+  }
+  if (!isUpdate) {
+    ctx.createParticleEffect(`${node.name}_creation`, adjustedPos, CREATION_PUFF_COLOR, CREATION_PUFF_COUNT);
+  }
+  if (ctx.isAgent(node)) {
+    if (!isUpdate || !ctx.getAgentRuntime(node.name)) {
+      const agentRuntime = ctx.acquireAgentRuntime();
+      agentRuntime.reset(node, ctx.parentRuntime);
+      ctx.setAgentRuntime(node.name, agentRuntime);
+      orbData.state = agentRuntime.getState();
+      node.directives?.filter((d) => d.type === "method").forEach((m) => {
+        orbData[m.name] = (...args) => agentRuntime.executeAction(m.name, args);
+      });
+    }
+  }
+  logger.info(isUpdate ? "Orb updated" : "Orb created", {
+    name: node.name,
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    properties: Object.keys(orbData.properties),
+    scale
+  });
+  ctx.broadcast(isUpdate ? "orb_updated" : "orb_created", {
+    orb: {
+      id: node.name,
+      name: node.name,
+      position: adjustedPos,
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      properties: orbData.properties,
+      hologram,
+      traits: node.directives?.filter((d) => d.type === "trait").map((d) => d.name) || []
+    }
+  });
+  return {
+    success: true,
+    output: orbData,
+    hologram,
+    spatialPosition: adjustedPos
+  };
+}
+
+// src/runtime/narrative-executors.ts
+async function executeNarrative(node, ctx) {
+  const startTime = Date.now();
+  logger.info(`[Narrative] Initializing narrative: ${node.id}`);
+  for (const quest of node.quests) {
+    ctx.quests.set(quest.id, quest);
+  }
+  if (node.startNode) {
+    logger.info(`[Narrative] Auto-starting at node: ${node.startNode}`);
+  }
+  return {
+    success: true,
+    output: `Narrative ${node.id} initialized with ${node.quests.length} quests`,
+    executionTime: Date.now() - startTime
+  };
+}
+async function executeQuest(node, ctx) {
+  const startTime = Date.now();
+  logger.info(`[Narrative] Starting quest: ${node.title}`, { questId: node.id });
+  ctx.setActiveQuestId(node.id);
+  ctx.quests.set(node.id, node);
+  return {
+    success: true,
+    output: `Quest ${node.id} started`,
+    executionTime: Date.now() - startTime
+  };
+}
+async function executeDialogue(node, ctx) {
+  const startTime = Date.now();
+  logger.info(`[Narrative] Dialogue: ${node.speaker} says "${node.text}"`);
+  ctx.setDialogueState({
+    currentNodeId: node.id,
+    speaker: node.speaker
+  });
+  return {
+    success: true,
+    output: `Dialogue node ${node.id} executed`,
+    executionTime: Date.now() - startTime
+  };
+}
+
+// src/runtime/graph-executors.ts
+var FUNCTION_DEFAULT_HOLOGRAM = {
+  shape: "cube",
+  color: "#ff6b35",
+  size: 1.5,
+  glow: true,
+  interactive: true
+};
+var CONNECTION_HOLOGRAM_SIZE = 0.1;
+var GATE_HOLOGRAM_SIZE = 1;
+async function executeFunction(node, ctx) {
+  ctx.functions.set(node.name, node);
+  const hologram = {
+    ...FUNCTION_DEFAULT_HOLOGRAM,
+    ...node.hologram
+  };
+  ctx.hologramState.set(node.name, hologram);
+  logger.info("Function defined", {
+    name: node.name,
+    params: node.parameters.map((p) => p.name)
+  });
+  return {
+    success: true,
+    output: `Function '${node.name}' defined with ${node.parameters.length} parameter(s)`,
+    hologram,
+    spatialPosition: node.position
+  };
+}
+async function executeConnection(node, ctx) {
+  ctx.connections.push(node);
+  const fromPos = ctx.spatialMemory.get(node.from);
+  const toPos = ctx.spatialMemory.get(node.to);
+  if (fromPos && toPos) {
+    ctx.createConnectionStream(node.from, node.to, fromPos, toPos, node.dataType);
+  }
+  if (node.bidirectional) {
+    ctx.on(`${node.from}.changed`, async (data) => {
+      ctx.setVariable(node.to, data);
+      ctx.emit(`${node.to}.changed`, data);
+    });
+    ctx.on(`${node.to}.changed`, async (data) => {
+      ctx.setVariable(node.from, data);
+      ctx.emit(`${node.from}.changed`, data);
+    });
+  }
+  logger.info("Connection created", { from: node.from, to: node.to, dataType: node.dataType });
+  return {
+    success: true,
+    output: `Connected '${node.from}' to '${node.to}' (${node.dataType})`,
+    hologram: {
+      shape: "cylinder",
+      color: ctx.getDataTypeColor(node.dataType),
+      size: CONNECTION_HOLOGRAM_SIZE,
+      glow: true,
+      interactive: false
+    }
+  };
+}
+async function executeGate(node, ctx) {
+  try {
+    const condition = ctx.evaluateCondition(node.condition);
+    const path = condition ? node.truePath : node.falsePath;
+    logger.info("Gate evaluation", { condition: node.condition, result: condition });
+    if (path.length > 0) {
+      const subResults = await ctx.executeProgram(path, ctx.callStackDepth() + 1);
+      const lastResult = subResults[subResults.length - 1];
+      const selectedPathContainsReturn = path.some((n) => n.type === "return");
+      if (selectedPathContainsReturn && lastResult?.success && lastResult.output !== void 0) {
+        return lastResult;
+      }
+    }
+    return {
+      success: true,
+      output: `Gate: took ${condition ? "true" : "false"} path`,
+      hologram: {
+        shape: "pyramid",
+        color: condition ? "#00ff00" : "#ff0000",
+        size: GATE_HOLOGRAM_SIZE,
+        glow: true,
+        interactive: true
+      }
+    };
+  } catch (error) {
+    return {
+      success: false,
+      error: `Gate execution failed: ${error}`
+    };
+  }
+}
+async function executeStream(node, ctx) {
+  let data = ctx.getVariable(node.source);
+  logger.info("Stream processing", {
+    name: node.name,
+    source: node.source,
+    transforms: node.transformations.length
+  });
+  for (const transform of node.transformations) {
+    data = await ctx.applyTransformation(data, transform);
+  }
+  ctx.setVariable(`${node.name}_result`, data);
+  ctx.createFlowingStream(node.name, node.position || [0, 0, 0], data);
+  return {
+    success: true,
+    output: `Stream '${node.name}' processed ${Array.isArray(data) ? data.length : 1} item(s)`,
+    hologram: node.hologram,
+    spatialPosition: node.position
+  };
+}
+
+// src/runtime/simple-executors.ts
+async function executeStateMachine(node, ctx) {
+  ctx.stateMachines.set(node.name, node);
+  return {
+    success: true,
+    output: { registered: node.name }
+  };
+}
+async function executeExpressionStatement(node, ctx) {
+  const value = ctx.evaluateExpression(node.expression);
+  return {
+    success: true,
+    output: value
+  };
+}
+async function executeCall(node, ctx) {
+  const funcName = node.target || "";
+  const args = node.args || [];
+  return ctx.callFunction(funcName, args);
+}
+async function executeEnvironment(node, ctx) {
+  ctx.setEnvironment({
+    ...ctx.getEnvironment(),
+    ...node.settings
+  });
+  return { success: true, output: "Environment updated" };
+}
+async function executeHoloTemplate(node, ctx) {
+  ctx.templates.set(node.name, node);
+  return { success: true, output: `Template ${node.name} registered` };
+}
+var NEXUS_HOLOGRAM = {
+  shape: "sphere",
+  color: "#9b59b6",
+  size: 3,
+  glow: true,
+  interactive: true
+};
+var STRUCTURE_HOLOGRAM = {
+  shape: "cube",
+  color: "#e74c3c",
+  size: 4,
+  glow: true,
+  interactive: true
+};
+async function executeStructure(node) {
+  const hologram = node.hologram || (node.type === "nexus" ? NEXUS_HOLOGRAM : STRUCTURE_HOLOGRAM);
+  return {
+    success: true,
+    output: { type: node.type, created: true },
+    hologram,
+    spatialPosition: node.position
+  };
+}
+async function executeAssignment(node, ctx) {
+  const value = ctx.evaluateExpression(String(node.value));
+  ctx.setVariable(node.name, value);
+  return {
+    success: true,
+    output: { assigned: node.name, value }
+  };
+}
+async function executeReturn(node, ctx) {
+  const expr = String(node.value || node.expression || "");
+  const value = ctx.evaluateExpression(expr);
+  return {
+    success: true,
+    output: value
+  };
+}
+async function executeScale(node, ctx) {
+  const parent = ctx.getScale();
+  const newMultiplier = parent.multiplier * node.multiplier;
+  ctx.setScale(newMultiplier, node.magnitude);
+  logger.info("Scale context entering", {
+    magnitude: node.magnitude,
+    multiplier: newMultiplier
+  });
+  ctx.emit("scale:change", { multiplier: newMultiplier, magnitude: node.magnitude });
+  const results = await ctx.executeProgram(node.body, ctx.executionStackDepth());
+  ctx.setScale(parent.multiplier, parent.magnitude);
+  ctx.emit("scale:change", { multiplier: parent.multiplier });
+  return {
+    success: results.every((r) => r.success),
+    output: `Executed scale block: ${node.magnitude}`
+  };
+}
+async function executeComposition(node, ctx) {
+  if (node.body) {
+    const systemResults = await ctx.executeProgram(node.body.systems, ctx.executionStackDepth());
+    const configResults = await ctx.executeProgram(node.body.configs, ctx.executionStackDepth());
+    const childrenResults = await ctx.executeProgram(node.body.children, ctx.executionStackDepth());
+    const allResults = [...systemResults, ...configResults, ...childrenResults];
+    return {
+      success: allResults.every((r) => r.success),
+      output: `Composition ${node.name} executed with specialized blocks`
+    };
+  }
+  return {
+    success: (await ctx.executeProgram(node.children, ctx.executionStackDepth())).every(
+      (r) => r.success
+    ),
+    output: `Composition ${node.name} executed`
+  };
+}
+async function executeFocus(node, ctx) {
+  ctx.focusHistory.push(node.target);
+  const results = await ctx.executeProgram(node.body, ctx.executionStackDepth());
+  return {
+    success: results.every((r) => r.success),
+    output: `Focused on ${node.target}`
+  };
+}
+
+// src/runtime/info-executors.ts
+var VISUALIZE_HOLOGRAM = {
+  shape: "cylinder",
+  color: "#32cd32",
+  size: 1.5,
+  glow: true,
+  interactive: true
+};
+async function executeVisualize(node, ctx) {
+  const target = node.target || "";
+  const data = ctx.getVariable(target);
+  if (data === void 0) {
+    return {
+      success: false,
+      error: `No data found for '${target}'`
+    };
+  }
+  ctx.createDataVisualization(target, data, node.position || [0, 0, 0]);
+  return {
+    success: true,
+    output: { visualizing: target, data },
+    hologram: VISUALIZE_HOLOGRAM
+  };
+}
+async function executeUIElement(node, ctx) {
+  const element = {
+    type: node.elementType,
+    name: node.name,
+    properties: { ...node.properties },
+    visible: true,
+    enabled: true
+  };
+  if (node.elementType === "textinput") {
+    element.value = node.properties.value || "";
+  } else if (node.elementType === "slider") {
+    element.value = node.properties.value || node.properties.min || 0;
+  } else if (node.elementType === "toggle") {
+    element.value = node.properties.checked || false;
+  }
+  ctx.uiElements.set(node.name, element);
+  if (node.events) {
+    for (const [eventName, handlerName] of Object.entries(node.events)) {
+      ctx.on(`${node.name}.${eventName}`, async () => {
+        await ctx.callFunction(handlerName);
+      });
+    }
+  }
+  logger.info("UI element created", { type: node.elementType, name: node.name });
+  return {
+    success: true,
+    output: element
+  };
+}
+
+// src/runtime/holo-value.ts
+function resolveHoloValue(value) {
+  if (value === null) return null;
+  if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
+    return value;
+  }
+  if (Array.isArray(value)) {
+    return value.map((e) => resolveHoloValue(e));
+  }
+  if (value.__bind) {
+    return value;
+  }
+  const obj = {};
+  for (const k in value) {
+    obj[k] = resolveHoloValue(value[k]);
+  }
+  return obj;
+}
+
+// src/runtime/holo-composition-executor.ts
+async function executeHoloComposition(node, ctx) {
+  for (const template of node.templates) {
+    await executeHoloTemplate(
+      template,
+      ctx.simpleExecutorContext
+    );
+  }
+  if (node.environment) {
+    const envSettings = {};
+    for (const prop of node.environment.properties) {
+      envSettings[prop.key] = resolveHoloValue(prop.value);
+    }
+    ctx.setEnvironment({ ...ctx.getEnvironment(), ...envSettings });
+  }
+  const results = [];
+  for (const object of node.objects) {
+    results.push(await ctx.executeHoloObject(object));
+  }
+  return {
+    success: results.every((r) => r.success),
+    output: `HoloComposition ${node.name} executed`
+  };
+}
+
+// src/runtime/system-executors.ts
+async function setupNetworking(node) {
+  const startTime = Date.now();
+  logger.info("[Networking] Initializing multiplayer fabric...", node.properties);
+  return {
+    success: true,
+    output: "Networking system provisioned",
+    executionTime: Date.now() - startTime
+  };
+}
+async function setupPhysics(node) {
+  const startTime = Date.now();
+  logger.info("[Physics] Initializing spatial simulation engine...", node.properties);
+  return {
+    success: true,
+    output: "Physics system provisioned",
+    executionTime: Date.now() - startTime
+  };
+}
+async function executeSystem(node) {
+  const startTime = Date.now();
+  const systemId = node.id;
+  const properties = node.properties;
+  logger.info(`[Zero-Config] Provisioning system: ${systemId}`, properties);
+  switch (systemId) {
+    case "Networking":
+      return setupNetworking(node);
+    case "Physics":
+      return setupPhysics(node);
+    default:
+      logger.warn(`[Zero-Config] Unknown system: ${systemId}`);
+      return {
+        success: true,
+        output: `System ${systemId} not recognized, skipping provisioning`,
+        executionTime: Date.now() - startTime
+      };
+  }
+}
+async function executeCoreConfig(node, environment) {
+  const startTime = Date.now();
+  logger.info("[Zero-Config] Applying core configuration", node.properties);
+  for (const [key, value] of Object.entries(node.properties)) {
+    environment[key] = value;
+  }
+  return {
+    success: true,
+    output: "Core configuration applied",
+    executionTime: Date.now() - startTime
+  };
+}
+async function executeVisualMetadata(node) {
+  logger.info(`[Metadata] Visual metadata processed`, node.properties);
+  return { success: true, output: "Visual metadata applied" };
+}
+
+// src/runtime/node-type-registry.ts
+var NODE_TYPE_HANDLERS = {
+  // Orbs / objects (same handler, both keys)
+  orb: (node, r) => executeOrb(node, r.buildOrbExecutorContext()),
+  object: (node, r) => executeOrb(node, r.buildOrbExecutorContext()),
+  // Narrative family
+  narrative: (node, r) => executeNarrative(node, r.buildNarrativeContext()),
+  quest: (node, r) => executeQuest(node, r.buildNarrativeContext()),
+  dialogue: (node, r) => executeDialogue(node, r.buildNarrativeContext()),
+  visual_metadata: (node) => executeVisualMetadata(node),
+  // Graph family
+  method: (node, r) => executeFunction(node, r.buildGraphExecutorContext()),
+  function: (node, r) => executeFunction(node, r.buildGraphExecutorContext()),
+  connection: (node, r) => executeConnection(node, r.buildGraphExecutorContext()),
+  gate: (node, r) => executeGate(node, r.buildGraphExecutorContext()),
+  stream: (node, r) => executeStream(node, r.buildGraphExecutorContext()),
+  // Simple / expression family
+  call: (node, r) => executeCall(
+    node,
+    r.buildSimpleExecutorContext()
+  ),
+  assignment: (node, r) => executeAssignment(
+    node,
+    r.buildSimpleExecutorContext()
+  ),
+  return: (node, r) => executeReturn(node, r.buildSimpleExecutorContext()),
+  "expression-statement": (node, r) => executeExpressionStatement(
+    node,
+    r.buildSimpleExecutorContext()
+  ),
+  scale: (node, r) => executeScale(node, r.buildSimpleExecutorContext()),
+  focus: (node, r) => executeFocus(node, r.buildSimpleExecutorContext()),
+  environment: (node, r) => executeEnvironment(node, r.buildSimpleExecutorContext()),
+  // Info / UI family
+  visualize: (node, r) => executeVisualize(node, r.buildInfoExecutorContext()),
+  "2d-element": (node, r) => executeUIElement(node, r.buildInfoExecutorContext()),
+  // Structure family (nexus + building = same handler)
+  nexus: (node) => executeStructure(node),
+  building: (node) => executeStructure(node),
+  // Capitalization-sensitive branches (composition vs Composition, template vs Template)
+  composition: (node, r) => executeComposition(node, r.buildSimpleExecutorContext()),
+  Composition: (node, r) => executeHoloComposition(
+    node,
+    r.buildHoloCompositionContext()
+  ),
+  template: (node, r) => r.executeTemplate(node),
+  Template: (node, r) => executeHoloTemplate(
+    node,
+    r.buildSimpleExecutorContext()
+  ),
+  // State family
+  "state-machine": (node, r) => executeStateMachine(node, r.buildSimpleExecutorContext()),
+  "state-declaration": (node, r) => r.executeStateDeclaration(
+    node
+  ),
+  // System
+  system: (node) => executeSystem(node),
+  core_config: (node, r) => executeCoreConfig(
+    node,
+    r.context.environment
+  ),
+  // Migration: accepted but no executor — plain success record
+  migration: async () => ({
+    success: true,
+    output: "Migration block registered"
+  }),
+  // IO family (slice 32 delegates)
+  server: (node, r) => r.executeServerNode(node),
+  database: (node, r) => r.executeDatabaseNode(node),
+  fetch: (node, r) => r.executeFetchNode(node),
+  execute: (node, r) => r.executeTarget(node),
+  // Memory family
+  memory: (node, r) => r.executeMemory(node),
+  "semantic-memory": (node, r) => r.executeMemoryDefinition(
+    node
+  ),
+  "episodic-memory": (node, r) => r.executeMemoryDefinition(
+    node
+  ),
+  "procedural-memory": (node, r) => r.executeMemoryDefinition(
+    node
+  ),
+  // Control-flow family
+  for: (node, r) => r.executeForLoop(
+    node
+  ),
+  forEach: (node, r) => r.executeForEachLoop(
+    node
+  ),
+  while: (node, r) => r.executeWhileLoop(
+    node
+  ),
+  if: (node, r) => r.executeIfStatement(
+    node
+  ),
+  match: (node, r) => r.executeMatch(
+    node
+  ),
+  // Debug + generic
+  debug: (node, r) => r.executeDebug(node),
+  generic: (node, r) => r.executeGeneric(node)
+};
+async function dispatchNode(node, runtime) {
+  const nodeType = node.type;
+  const handler = NODE_TYPE_HANDLERS[nodeType];
+  if (!handler) {
+    return {
+      success: false,
+      error: `Unknown node type: ${node.type}`
+    };
+  }
+  return handler(node, runtime);
+}
+
+// src/runtime/system-variables.ts
+init_safeJsonParse();
+var DEFAULT_USER = {
+  id: "user_123",
+  name: "Alpha Explorer",
+  level: 42,
+  rank: "Legendary",
+  achievements: ["First World", "Spirit Guide"],
+  preferences: { theme: "holographic", language: "en" }
+};
+var DEFAULT_LOCATION = {
+  city: "Neo Tokyo",
+  region: "Holo-Sector 7",
+  coordinates: { lat: 35.6895, lng: 139.6917 },
+  altitude: 450
+};
+var DEFAULT_WEATHER = {
+  condition: "Neon Mist",
+  temperature: 24,
+  humidity: 65,
+  windSpeed: 12,
+  unit: "C"
+};
+var DEFAULT_WALLET = {
+  address: "0xHolo...42ff",
+  balance: 1337.5,
+  currency: "HOLO",
+  network: "MainNet"
+};
+var DEFAULT_CHAT_STATUS = {
+  active: true,
+  typing: false,
+  version: "1.0.0-brittney"
+};
+function updateSystemVariables(ctx) {
+  const now = /* @__PURE__ */ new Date();
+  ctx.setVariable("$time", now.toLocaleTimeString());
+  ctx.setVariable("$date", now.toLocaleDateString());
+  ctx.setVariable("$timestamp", now.getTime());
+  ctx.setVariable("$hour", now.getHours());
+  ctx.setVariable("$minute", now.getMinutes());
+  ctx.setVariable("$second", now.getSeconds());
+  if (ctx.getVariable("$user") === void 0) {
+    ctx.setVariable("$user", DEFAULT_USER);
+  }
+  if (ctx.getVariable("$location") === void 0) {
+    ctx.setVariable("$location", DEFAULT_LOCATION);
+  }
+  if (ctx.getVariable("$weather") === void 0) {
+    ctx.setVariable("$weather", DEFAULT_WEATHER);
+  }
+  if (ctx.getVariable("$wallet") === void 0) {
+    ctx.setVariable("$wallet", DEFAULT_WALLET);
+  }
+  if (ctx.getVariable("$ai_config") === void 0) {
+    let configuredCount = 0;
+    if (ctx.brittneyApiKeysJson) {
+      try {
+        const keys = readJson(ctx.brittneyApiKeysJson);
+        configuredCount = Object.values(keys).filter((k) => !!k).length;
+      } catch (_e) {
+      }
+    }
+    ctx.setVariable("$ai_config", {
+      status: configuredCount > 0 ? "configured" : "pending",
+      providerCount: configuredCount,
+      lastUpdated: Date.now()
+    });
+  }
+  if (ctx.getVariable("$chat_status") === void 0) {
+    ctx.setVariable("$chat_status", DEFAULT_CHAT_STATUS);
+  }
+}
+
+// src/runtime/context-factory.ts
+function createEmptyContext() {
+  return {
+    variables: /* @__PURE__ */ new Map(),
+    functions: /* @__PURE__ */ new Map(),
+    exports: /* @__PURE__ */ new Map(),
+    connections: [],
+    spatialMemory: /* @__PURE__ */ new Map(),
+    hologramState: /* @__PURE__ */ new Map(),
+    executionStack: [],
+    currentScale: 1,
+    scaleMagnitude: "standard",
+    focusHistory: [],
+    environment: {},
+    templates: /* @__PURE__ */ new Map(),
+    // HS+ State
+    state: createState({}),
+    // Phase 13: State Machines
+    stateMachines: /* @__PURE__ */ new Map(),
+    // Narrative & Story State
+    quests: /* @__PURE__ */ new Map(),
+    completedQuests: /* @__PURE__ */ new Set()
+  };
+}
+
+// src/runtime/holo-object-executor.ts
+var DEFAULT_SHAPE = "sphere";
+var DEFAULT_COLOR = "#ffffff";
+var DEFAULT_SIZE = 1;
+async function executeHoloObject(node, ctx) {
+  const properties = {};
+  for (const prop of node.properties) {
+    properties[prop.key] = resolveHoloValue(prop.value);
+  }
+  if (node.state) {
+    for (const prop of node.state.properties) {
+      properties[prop.key] = resolveHoloValue(prop.value);
+    }
+  }
+  const position = properties.position;
+  const hologram = {
+    shape: properties.geometry || DEFAULT_SHAPE,
+    color: properties.color || DEFAULT_COLOR,
+    size: properties.scale || properties.size || DEFAULT_SIZE,
+    glow: properties.glow || false,
+    // interactive defaults to true unless explicitly set false
+    interactive: properties.interactive !== false
+  };
+  const template = node.template ? ctx.getTemplate(node.template) : void 0;
+  const orbNode = {
+    type: "orb",
+    name: node.name,
+    position,
+    hologram,
+    properties,
+    // @ts-expect-error — directive shape is intentionally loose here;
+    //   downstream dispatch normalizes.
+    directives: [
+      ...node.directives || [],
+      ...(node.traits || []).map((t) => ({
+        type: "trait",
+        name: t.name,
+        ...t.config
+      })),
+      ...template?.directives || []
+    ],
+    traits: new Map(
+      (node.traits || []).map((t) => [t.name, t.config])
+    ),
+    children: node.children || []
+  };
+  if (template) {
+    if (template.state) {
+      for (const prop of template.state.properties) {
+        if (properties[prop.key] === void 0) {
+          properties[prop.key] = resolveHoloValue(prop.value);
+        }
+      }
+    }
+    for (const prop of template.properties) {
+      if (properties[prop.key] === void 0) {
+        properties[prop.key] = resolveHoloValue(prop.value);
+      }
+    }
+  }
+  return ctx.executeOrb(orbNode);
+}
+
+// src/runtime/skills-directives.ts
+var TRAIT_UPDATE_DT = 1 / 60;
+function loadSkill(skill, ctx) {
+  logger.info(`[Procedural] Loading skill: ${skill.name} (${skill.id})`);
+  const existing = ctx.proceduralSkills.get(skill.id);
+  if (existing) {
+    skill.successRate = (existing.successRate + (skill.successRate || 0)) / 2;
+  } else {
+    skill.successRate = skill.successRate || 0;
+  }
+  ctx.proceduralSkills.set(skill.id, skill);
+  ctx.broadcastSkill(skill);
+}
+var AGENT_TRAIT_NAMES = /* @__PURE__ */ new Set(["llm_agent", "agent", "companion"]);
+function isAgent(node) {
+  return !!node.directives?.some(
+    (d) => d.type === "trait" && AGENT_TRAIT_NAMES.has(d.name)
+  );
+}
+function applyDirectives(node, ctx) {
+  if (!node.directives) return;
+  for (const d of node.directives) {
+    if (d.type === "trait") {
+      logger.info(`Applying trait ${d.name} to ${node.type}`);
+      const handler = ctx.traitHandlers.get(d.name);
+      if (handler) {
+        handler.onAttach?.(node, d.config || {}, {
+          emit: (event, payload) => ctx.emit(event, payload),
+          getScaleMultiplier: () => ctx.getCurrentScale() || 1
+        });
+      }
+      if (d.name === "chat") {
+        ctx.emit("show-chat", d.config);
+      }
+    } else if (d.type === "state") {
+      if (node && node.__type === "orb") {
+        const stateBody = d.body;
+        const existingProps = node.properties || {};
+        for (const [key, val] of Object.entries(stateBody)) {
+          if (existingProps[key] === void 0) {
+            existingProps[key] = val;
+          }
+        }
+        node.properties = existingProps;
+      }
+      ctx.state.update(d.body);
+    } else if (d.type === "lifecycle") {
+      if (d.hook === "on_mount" || d.hook === "mount") {
+        ctx.evaluateExpression(d.body);
+      }
+    }
+  }
+}
+function updateTraits(julianDate, ctx) {
+  const delta = TRAIT_UPDATE_DT;
+  for (const [name, value] of ctx.variables.entries()) {
+    if (value && typeof value === "object" && value.__type === "orb") {
+      const orb = value;
+      if (!orb.directives) continue;
+      for (const d of orb.directives || []) {
+        if (d.type !== "trait") continue;
+        const handler = ctx.traitHandlers.get(d.name);
+        if (!handler || !handler.onUpdate) continue;
+        const traitNode = orb;
+        handler.onUpdate(
+          traitNode,
+          d.config || {},
+          {
+            emit: (event, payload) => {
+              if (event === "position_update") {
+                const posPayload = payload;
+                if (posPayload?.position) {
+                  const p = posPayload.position;
+                  const tuple = Array.isArray(p) ? p : [p[0], p[1], p[2]];
+                  ctx.setOrbPosition(name, tuple);
+                }
+              }
+              return ctx.emit(event, payload);
+            },
+            getScaleMultiplier: () => ctx.getCurrentScale() || 1,
+            julianDate,
+            getNode: (nodeName) => ctx.variables.get(nodeName),
+            getState: () => ctx.getState(),
+            setState: (updates) => ctx.setState(updates)
+          },
+          delta
+        );
+      }
+    }
+  }
+}
+
+// src/runtime/primitives.ts
+function handleShop(args, emit2) {
+  const config = args[0] || {};
+  emit2("shop", config);
+  return { success: true, type: "shop", config };
+}
+function handleInventory(args, emit2) {
+  const item = args[0];
+  const action = args[1] || "add";
+  emit2("inventory", { item, action });
+  return { success: true, item, action };
+}
+function handlePurchase(args, emit2) {
+  const productId = args[0];
+  emit2("purchase", { productId });
+  return { success: true, productId, status: "pending" };
+}
+function handlePresence(args, emit2) {
+  const config = args[0] || {};
+  emit2("presence", config);
+  return { success: true, active: true };
+}
+function handleInvite(args, emit2) {
+  const userId = args[0];
+  emit2("invite", { userId });
+  return { success: true, userId };
+}
+function handleShare(args, emit2) {
+  const scriptId = args[0];
+  const targetUserId = args[1];
+  emit2("share", { scriptId, targetUserId });
+  return { success: true, scriptId };
+}
+function handlePhysics(args, emit2) {
+  const config = args[0] || {};
+  emit2("physics", config);
+  return {
+    success: true,
+    enabled: config.enabled !== false
+  };
+}
+function handleGravity(args, emit2) {
+  const value = args[0] ?? 9.81;
+  emit2("gravity", { value });
+  return { success: true, value };
+}
+function handleCollide(args, emit2) {
+  const target = args[0];
+  const handler = args[1];
+  emit2("collide", { target, handler });
+  return { success: true, target };
+}
+function handleAnimate(args, emit2) {
+  const options = args[0] || {};
+  emit2("animate", options);
+  return { success: true, options };
+}
+
+// src/runtime/builtins-registry.ts
+var SHOW_PARTICLES = 15;
+var PULSATE_PARTICLES = 30;
+var SPAWN_PARTICLES = 25;
+var DESPAWN_PARTICLES = 30;
+var DEFAULT_PULSATE_DURATION_MS = 1e3;
+var DEFAULT_PULSATE_COLOR = "#ffffff";
+var SPAWN_COLOR = "#00ff00";
+var DESPAWN_COLOR = "#ff0000";
+function createBuiltinsMap(ctx, 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 = ctx.uiElements.get(target);
+    if (element) element.visible = true;
+    const hologram = ctx.hologramState.get(target);
+    if (hologram) {
+      ctx.createParticleEffect(`${target}_show`, [0, 0, 0], hologram.color, SHOW_PARTICLES);
+    }
+    logger.info("show", { target });
+    return { shown: target };
+  });
+  builtins.set("hide", (args) => {
+    const target = String(args[0]);
+    const element = ctx.uiElements.get(target);
+    if (element) element.visible = false;
+    logger.info("hide", { target });
+    return { hidden: target };
+  });
+  builtins.set("pulsate", (args) => {
+    const target = String(args[0]);
+    const options = args[1] || {};
+    const duration = Number(options.duration) || DEFAULT_PULSATE_DURATION_MS;
+    const color = String(options.color || DEFAULT_PULSATE_COLOR);
+    const position = ctx.spatialMemory.get(target) || [0, 0, 0];
+    ctx.createParticleEffect(`${target}_pulse`, position, color, PULSATE_PARTICLES);
+    return { pulsing: target, duration };
+  });
+  builtins.set("animate", (args) => {
+    const target = String(args[0]);
+    const options = args[1] || {};
+    const animation = {
+      target,
+      property: String(options.property || "position[1]"),
+      from: Number(options.from || 0),
+      to: Number(options.to || 1),
+      duration: Number(options.duration || 1e3),
+      startTime: Date.now(),
+      easing: String(options.easing || "linear"),
+      loop: Boolean(options.loop),
+      yoyo: Boolean(options.yoyo)
+    };
+    ctx.animations.set(`${target}_${animation.property}`, animation);
+    return { animating: target, animation };
+  });
+  builtins.set("spawn", async (args) => {
+    const config = args[0];
+    if (typeof config === "string") {
+      const target = config;
+      const position2 = args[1] || [0, 0, 0];
+      ctx.spatialMemory.set(target, position2);
+      ctx.createParticleEffect(`${target}_spawn`, position2, SPAWN_COLOR, SPAWN_PARTICLES);
+      return { spawned: target, at: position2 };
+    }
+    const spawnConfig = config;
+    const templateName = String(spawnConfig.template);
+    const id = String(spawnConfig.id || `${templateName}_${Date.now()}`);
+    const position = spawnConfig.position || [0, 0, 0];
+    const template = ctx.templates.get(templateName);
+    if (!template) {
+      logger.error(`[Mitosis] Template ${templateName} not found`);
+      return { error: `Template ${templateName} not found` };
+    }
+    const spawnNode = {
+      type: "orb",
+      name: id,
+      position,
+      properties: { ...spawnConfig.config || {} },
+      children: template.children,
+      traits: template.traits,
+      directives: template.directives
+    };
+    const holoTpl = template;
+    if (holoTpl.state) {
+      for (const prop of holoTpl.state.properties) {
+        if (spawnNode.properties[prop.key] === void 0) {
+          spawnNode.properties[prop.key] = resolveHoloValue(prop.value);
+        }
+      }
+    }
+    for (const prop of holoTpl.properties) {
+      if (spawnNode.properties[prop.key] === void 0) {
+        spawnNode.properties[prop.key] = resolveHoloValue(prop.value);
+      }
+    }
+    await ctx.executeOrb(spawnNode);
+    if (spawnConfig.parentId || spawnConfig.parent_id) {
+      const parentId = String(spawnConfig.parentId || spawnConfig.parent_id);
+      await ctx.emit(`mitosis_spawned`, { parentId, childId: id });
+      await ctx.emit(`${parentId}.mitosis_spawned`, { childId: id });
+    }
+    return { spawned: id, template: templateName };
+  });
+  builtins.set("notifyParent", async (args) => {
+    const parentId = String(args[0]);
+    const data = args[1];
+    await ctx.emit(`mitosis_child_complete`, {
+      parentId,
+      childId: args[2] || "unknown",
+      result: data
+    });
+    await ctx.emit(`${parentId}.mitosis_child_complete`, {
+      childId: args[2] || "unknown",
+      result: data
+    });
+    return { notified: parentId };
+  });
+  builtins.set("despawn", (args) => {
+    const target = String(args[0]);
+    if (ctx.hologramState.has(target)) {
+      const pos = ctx.spatialMemory.get(target) || [0, 0, 0];
+      ctx.createParticleEffect(`${target}_despawn`, pos, DESPAWN_COLOR, DESPAWN_PARTICLES);
+      ctx.hologramState.delete(target);
+      ctx.variables.delete(target);
+      ctx.spatialMemory.delete(target);
+      logger.info("despawn", { target });
+      return { despawned: target };
+    }
+    return { msg: "Target not found", target };
+  });
+  builtins.set("move", (args) => {
+    const target = String(args[0]);
+    const position = args[1] || [0, 0, 0];
+    const current = ctx.spatialMemory.get(target);
+    if (current) {
+      ctx.spatialMemory.set(target, position);
+      ctx.createConnectionStream(target, `${target}_dest`, current, position, "move");
+    }
+    return { moved: target, to: position };
+  });
+  builtins.set("set", (args) => {
+    const target = String(args[0]);
+    const value = args[1];
+    ctx.setVariable(target, value);
+    return { set: target, value };
+  });
+  builtins.set("get", (args) => {
+    const target = String(args[0]);
+    return ctx.getVariable(target);
+  });
+  builtins.set("add", (args) => Number(args[0]) + Number(args[1]));
+  builtins.set("subtract", (args) => Number(args[0]) - Number(args[1]));
+  builtins.set("multiply", (args) => Number(args[0]) * Number(args[1]));
+  builtins.set(
+    "divide",
+    (args) => Number(args[1]) !== 0 ? Number(args[0]) / Number(args[1]) : 0
+  );
+  builtins.set("mod", (args) => Number(args[0]) % Number(args[1]));
+  builtins.set("abs", (args) => Math.abs(Number(args[0])));
+  builtins.set("floor", (args) => Math.floor(Number(args[0])));
+  builtins.set("ceil", (args) => Math.ceil(Number(args[0])));
+  builtins.set("round", (args) => Math.round(Number(args[0])));
+  builtins.set("min", (args) => Math.min(...args.map(Number)));
+  builtins.set("max", (args) => Math.max(...args.map(Number)));
+  builtins.set("random", () => Math.random());
+  builtins.set("concat", (args) => args.map(String).join(""));
+  builtins.set("length", (args) => {
+    const val = args[0];
+    if (typeof val === "string") return val.length;
+    if (Array.isArray(val)) return val.length;
+    return 0;
+  });
+  builtins.set(
+    "substring",
+    (args) => String(args[0]).substring(Number(args[1]), Number(args[2]))
+  );
+  builtins.set("wait", async (args) => {
+    const ms = Number(args[0]) || 0;
+    await new Promise((resolve) => setTimeout(resolve, ms));
+    return { waited: ms };
+  });
+  builtins.set("print", (args) => {
+    console.log(`[HoloScript]`, ...args);
+    return { printed: args.join(" ") };
+  });
+  builtins.set("uppercase", (args) => String(args[0]).toUpperCase());
+  builtins.set("lowercase", (args) => String(args[0]).toLowerCase());
+  builtins.set("push", (args) => {
+    const arr = args[0];
+    if (Array.isArray(arr)) {
+      arr.push(args[1]);
+      return arr;
+    }
+    return [args[0], args[1]];
+  });
+  builtins.set("pop", (args) => {
+    const arr = args[0];
+    if (Array.isArray(arr)) return arr.pop();
+    return void 0;
+  });
+  builtins.set("at", (args) => {
+    const arr = args[0];
+    const index = Number(args[1]);
+    if (Array.isArray(arr)) return arr[index];
+    return void 0;
+  });
+  builtins.set("showSettings", () => {
+    void ctx.emit("show-settings");
+    return true;
+  });
+  builtins.set("openChat", (args) => {
+    const config = args[0] || {};
+    void ctx.emit("show-chat", config);
+    return true;
+  });
+  builtins.set("log", (args) => {
+    logger.info("HoloScript log", { args });
+    return args[0];
+  });
+  builtins.set("print", (args) => {
+    const message = args.map(String).join(" ");
+    logger.info("print", { message });
+    return message;
+  });
+  builtins.set("typeof", (args) => typeof args[0]);
+  builtins.set("isArray", (args) => Array.isArray(args[0]));
+  builtins.set(
+    "isNumber",
+    (args) => typeof args[0] === "number" && !isNaN(args[0])
+  );
+  builtins.set("isString", (args) => typeof args[0] === "string");
+  const emitFn = (event, data) => {
+    void ctx.emit(event, data);
+  };
+  builtins.set("shop", (args) => handleShop(args, emitFn));
+  builtins.set("inventory", (args) => handleInventory(args, emitFn));
+  builtins.set("purchase", (args) => handlePurchase(args, emitFn));
+  builtins.set("presence", (args) => handlePresence(args, emitFn));
+  builtins.set("invite", (args) => handleInvite(args, emitFn));
+  builtins.set("share", (args) => handleShare(args, emitFn));
+  builtins.set("physics", (args) => handlePhysics(args, emitFn));
+  builtins.set("gravity", (args) => handleGravity(args, emitFn));
+  builtins.set("collide", (args) => handleCollide(args, emitFn));
+  builtins.set("animate", (args) => handleAnimate(args, emitFn));
+  builtins.set("calculate_arc", (args) => ctx.calculateArc(args));
+  builtins.set(
+    "sleep",
+    (args) => new Promise((resolve) => setTimeout(resolve, Number(args[0]) || 0))
+  );
+  builtins.set("think", async (args) => {
+    const activeNode = ctx.executionStack[ctx.executionStack.length - 1];
+    if (!activeNode) return "No context";
+    const agentId = activeNode.name;
+    const agentRuntime = ctx.agentRuntimes.get(agentId);
+    if (agentRuntime) {
+      return await agentRuntime.think(String(args[0] || ""));
+    }
+    return "Thinking only available for agents.";
+  });
+  return builtins;
+}
+
+// src/runtime/event-system.ts
+function onEvent(event, handler, ctx) {
+  const handlers = ctx.eventHandlers.get(event) || [];
+  handlers.push(handler);
+  ctx.eventHandlers.set(event, handlers);
+}
+function offEvent(event, handler, ctx) {
+  if (!handler) {
+    ctx.eventHandlers.delete(event);
+  } else {
+    const handlers = ctx.eventHandlers.get(event) || [];
+    ctx.eventHandlers.set(
+      event,
+      handlers.filter((h) => h !== handler)
+    );
+  }
+}
+async function emit(event, data, ctx) {
+  logger.info(`[Runtime] Emitting event: ${event}`, data);
+  if (event.includes(".")) {
+    const [target, eventName] = event.split(".");
+    const agent = ctx.agentRuntimes.get(target);
+    if (agent) {
+      await agent.onEvent(eventName, data);
+    }
+    const orb = ctx.variables.get(target);
+    if (orb && typeof orb === "object" && orb.__type === "orb") {
+      await forwardToTraits(orb, eventName, data, ctx);
+    }
+  }
+  const orbs = Array.from(ctx.variables.values()).filter(
+    (v) => v && typeof v === "object" && v.__type === "orb"
+  );
+  for (const agent of ctx.agentRuntimes.values()) {
+    await agent.onEvent(event, data);
+  }
+  for (const variable of orbs) {
+    await forwardToTraits(variable, event, data, ctx);
+  }
+  const handlers = ctx.eventHandlers.get(event) || [];
+  for (const handler of handlers) {
+    try {
+      await handler(data);
+    } catch (error) {
+      logger.error("Event handler error", { event, error });
+    }
+  }
+  await ctx.globalBusEmit(event, data);
+  if (data && typeof data === "object" && data.id) {
+    ctx.sendStateMachineEvent(data.id, event);
+  }
+}
+async function forwardToTraits(orb, event, data, ctx) {
+  if (!orb.directives) return;
+  for (const d of orb.directives) {
+    if (d.type !== "trait") continue;
+    const handler = ctx.traitHandlers.get(d.name);
+    if (!handler || !handler.onEvent) continue;
+    const traitNode = orb;
+    const eventPayload = {
+      type: event,
+      ...data && typeof data === "object" ? data : {}
+    };
+    await handler.onEvent(
+      traitNode,
+      d.config || {},
+      {
+        emit: async (e, p) => await emit(e, p, ctx),
+        getScaleMultiplier: () => ctx.getCurrentScale() || 1
+      },
+      eventPayload
+    );
+  }
+}
+async function triggerUIEvent(elementName, eventType, data, ctx) {
+  const element = ctx.uiElements.get(elementName);
+  if (!element) {
+    logger.warn("UI element not found", { elementName });
+    return;
+  }
+  if (eventType === "change" && data !== void 0) {
+    element.value = data;
+  }
+  await emit(`${elementName}.${eventType}`, data, ctx);
+}
+
+// src/runtime/state-invalidation.ts
+var StateInvalidationRegistry = class {
+  constructor() {
+    this.records = /* @__PURE__ */ new Map();
+  }
+  /** Record an invalidation for `key`. No-op on an empty/invalid key. */
+  record(key, nodeId) {
+    if (typeof key !== "string" || key.length === 0) return;
+    this.records.set(key, { key, at: Date.now(), nodeId });
+  }
+  /** True if `key` has an outstanding (unacknowledged) invalidation. */
+  wasInvalidated(key) {
+    return this.records.has(key);
+  }
+  /** Peek the invalidation record without acknowledging it. */
+  get(key) {
+    return this.records.get(key);
+  }
+  /**
+   * Read-and-clear: returns the record (if any) and removes it, so a reader
+   * that has refetched the value acknowledges the invalidation exactly once.
+   */
+  consume(key) {
+    const record = this.records.get(key);
+    this.records.delete(key);
+    return record;
+  }
+  /** All outstanding invalidations. */
+  list() {
+    return Array.from(this.records.values());
+  }
+  /** Drop all outstanding invalidations. */
+  clear() {
+    this.records.clear();
+  }
+  /** Count of outstanding invalidations. */
+  get size() {
+    return this.records.size;
+  }
+};
+var defaultStateInvalidationRegistry = new StateInvalidationRegistry();
+function makeStateInvalidationHandler(registry) {
+  return (data) => {
+    const payload = data ?? {};
+    if (typeof payload.key === "string") {
+      const nodeId = payload.node && typeof payload.node.id === "string" ? payload.node.id : void 0;
+      registry.record(payload.key, nodeId);
+    }
+  };
+}
+function attachStateInvalidationConsumer(ctx, registry = defaultStateInvalidationRegistry) {
+  onEvent("persistent_expired", makeStateInvalidationHandler(registry), ctx);
+  return registry;
+}
+
+// src/runtime/ui-commands.ts
+var SHOW_PARTICLE_COUNT = 15;
+var HIDE_PARTICLE_COUNT = 10;
+var CREATE_PARTICLE_COUNT = 20;
+var PULSE_PARTICLE_COUNT = 30;
+var DELETE_PARTICLE_COUNT = 15;
+var HIDE_COLOR = "#ff0000";
+var DELETE_COLOR = "#ff0000";
+var PULSE_COLOR = "#ffff00";
+var DEFAULT_SHOW_HOLOGRAM = {
+  shape: "orb",
+  color: "#00ffff",
+  size: 0.8,
+  glow: true,
+  interactive: true
+};
+var DEFAULT_CREATE_COLOR = "#00ffff";
+var DEFAULT_CREATE_SIZE = 1;
+var DEFAULT_ANIMATE_PROPERTY = "position[1]";
+var DEFAULT_ANIMATE_DURATION_MS = 1e3;
+var DEFAULT_PULSE_DURATION_MS = 500;
+var PULSE_SCALE_FROM = 1;
+var PULSE_SCALE_TO = 1.5;
+async function executeShowCommand(target, node, ctx) {
+  const hologram = node.hologram || DEFAULT_SHOW_HOLOGRAM;
+  const position = node.position || [0, 0, 0];
+  ctx.spatialMemory.set(target, position);
+  ctx.createParticleEffect(`${target}_show`, position, hologram.color, SHOW_PARTICLE_COUNT);
+  logger.info("Show command executed", { target, position });
+  return { showed: target, hologram, position };
+}
+async function executeHideCommand(target, _node, ctx) {
+  const position = ctx.spatialMemory.get(target) || [0, 0, 0];
+  ctx.createParticleEffect(`${target}_hide`, position, HIDE_COLOR, HIDE_PARTICLE_COUNT);
+  logger.info("Hide command executed", { target });
+  return { hidden: target };
+}
+async function executeCreateCommand(tokens, node, ctx) {
+  if (tokens.length < 2) {
+    return { error: "Create command requires shape and name" };
+  }
+  const shape = tokens[0];
+  const name = tokens[1];
+  const position = node.position || [0, 0, 0];
+  const hologram = {
+    shape,
+    color: node.hologram?.color || DEFAULT_CREATE_COLOR,
+    size: node.hologram?.size || DEFAULT_CREATE_SIZE,
+    glow: node.hologram?.glow !== false,
+    interactive: node.hologram?.interactive !== false
+  };
+  ctx.spatialMemory.set(name, position);
+  ctx.createParticleEffect(`${name}_create`, position, hologram.color, CREATE_PARTICLE_COUNT);
+  logger.info("Create command executed", { shape, name, position });
+  return { created: name, shape, hologram, position };
+}
+async function executeAnimateCommand(target, tokens, _node, ctx) {
+  const property = tokens[0] || DEFAULT_ANIMATE_PROPERTY;
+  const duration = parseInt(tokens[1] || String(DEFAULT_ANIMATE_DURATION_MS), 10);
+  const animation = {
+    target,
+    property,
+    from: 0,
+    to: 1,
+    duration,
+    startTime: Date.now(),
+    easing: "ease-in-out"
+  };
+  ctx.animations.set(`${target}_${property}`, animation);
+  logger.info("Animate command executed", { target, property, duration });
+  return { animating: target, animation };
+}
+async function executePulseCommand(target, tokens, _node, ctx) {
+  const duration = parseInt(tokens[0] || String(DEFAULT_PULSE_DURATION_MS), 10);
+  const position = ctx.spatialMemory.get(target) || [0, 0, 0];
+  ctx.createParticleEffect(`${target}_pulse`, position, PULSE_COLOR, PULSE_PARTICLE_COUNT);
+  const animation = {
+    target,
+    property: "scale",
+    from: PULSE_SCALE_FROM,
+    to: PULSE_SCALE_TO,
+    duration,
+    startTime: Date.now(),
+    easing: "sine",
+    yoyo: true,
+    loop: true
+  };
+  ctx.animations.set(`${target}_pulse`, animation);
+  logger.info("Pulse command executed", { target, duration });
+  return { pulsing: target, duration };
+}
+async function executeMoveCommand(target, tokens, _node, ctx) {
+  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 = ctx.spatialMemory.get(target);
+  if (current) {
+    ctx.spatialMemory.set(target, position);
+    ctx.createConnectionStream(target, `${target}_move`, current, position, "movement");
+  } else {
+    ctx.spatialMemory.set(target, position);
+  }
+  logger.info("Move command executed", { target, position });
+  return { moved: target, to: position };
+}
+async function executeDeleteCommand(target, _node, ctx) {
+  const position = ctx.spatialMemory.get(target);
+  if (position) {
+    ctx.createParticleEffect(`${target}_delete`, position, DELETE_COLOR, DELETE_PARTICLE_COUNT);
+    ctx.spatialMemory.delete(target);
+  }
+  logger.info("Delete command executed", { target });
+  return { deleted: target };
+}
+
+// src/runtime/pattern-match.ts
+var WILDCARD_PATTERNS = /* @__PURE__ */ new Set(["_", "else", "default"]);
+var TYPE_PATTERNS = {
+  string: (v) => typeof v === "string",
+  number: (v) => typeof v === "number",
+  boolean: (v) => typeof v === "boolean",
+  array: (v) => Array.isArray(v),
+  object: (v) => typeof v === "object" && v !== null
+};
+function patternMatches(pattern, value) {
+  if (typeof pattern === "string" && WILDCARD_PATTERNS.has(pattern)) {
+    return true;
+  }
+  if (pattern === value) {
+    return true;
+  }
+  if (typeof pattern === "string" && pattern in TYPE_PATTERNS) {
+    return TYPE_PATTERNS[pattern](value);
+  }
+  if (Array.isArray(pattern) && pattern.length === 2) {
+    const [min, max] = pattern;
+    if (typeof value === "number" && typeof min === "number" && typeof max === "number" && value >= min && value <= max) {
+      return true;
+    }
+  }
+  return false;
+}
+
+// src/runtime/control-flow.ts
+var WHILE_MAX_ITERATIONS = 1e4;
+async function executeForLoop(node, ctx) {
+  const startTime = Date.now();
+  const { variable, iterable, body } = node;
+  try {
+    const collection = ctx.evaluateExpression(String(iterable));
+    if (!Array.isArray(collection) && typeof collection !== "object") {
+      return {
+        success: false,
+        error: `Cannot iterate over non-iterable: ${typeof collection}`,
+        executionTime: Date.now() - startTime
+      };
+    }
+    const items = Array.isArray(collection) ? collection : collection && typeof collection === "object" ? Object.entries(collection) : [];
+    let lastResult = { success: true, output: null };
+    for (const item of items) {
+      ctx.variables.set(variable, item);
+      for (const bodyNode of body) {
+        lastResult = await ctx.executeNode(bodyNode);
+        if (!lastResult.success) break;
+      }
+      if (!lastResult.success) break;
+    }
+    ctx.variables.delete(variable);
+    return {
+      success: true,
+      output: lastResult.output,
+      executionTime: Date.now() - startTime
+    };
+  } catch (error) {
+    return {
+      success: false,
+      error: `For loop error: ${error instanceof Error ? error.message : String(error)}`,
+      executionTime: Date.now() - startTime
+    };
+  }
+}
+async function executeForEachLoop(node, ctx) {
+  return executeForLoop(
+    { variable: node.variable, iterable: node.collection, body: node.body },
+    ctx
+  );
+}
+async function executeWhileLoop(node, ctx) {
+  const startTime = Date.now();
+  const { condition, body } = node;
+  try {
+    let iterations = 0;
+    let lastResult = { success: true, output: null };
+    while (ctx.evaluateCondition(String(condition))) {
+      iterations++;
+      if (iterations > WHILE_MAX_ITERATIONS) {
+        return {
+          success: false,
+          error: `While loop exceeded maximum iterations (${WHILE_MAX_ITERATIONS})`,
+          executionTime: Date.now() - startTime
+        };
+      }
+      for (const bodyNode of body) {
+        lastResult = await ctx.executeNode(bodyNode);
+        if (!lastResult.success) break;
+      }
+      if (!lastResult.success) break;
+    }
+    return {
+      success: true,
+      output: lastResult.output,
+      executionTime: Date.now() - startTime
+    };
+  } catch (error) {
+    return {
+      success: false,
+      error: `While loop error: ${error instanceof Error ? error.message : String(error)}`,
+      executionTime: Date.now() - startTime
+    };
+  }
+}
+async function executeIfStatement(node, ctx) {
+  const startTime = Date.now();
+  const { condition, body, elseBody } = node;
+  try {
+    const conditionResult = ctx.evaluateCondition(String(condition));
+    const branchToExecute = conditionResult ? body : elseBody || [];
+    let lastResult = { success: true, output: null };
+    for (const bodyNode of branchToExecute) {
+      lastResult = await ctx.executeNode(bodyNode);
+      if (!lastResult.success) break;
+    }
+    return {
+      success: true,
+      output: lastResult.output,
+      executionTime: Date.now() - startTime
+    };
+  } catch (error) {
+    return {
+      success: false,
+      error: `If statement error: ${error instanceof Error ? error.message : String(error)}`,
+      executionTime: Date.now() - startTime
+    };
+  }
+}
+async function executeMatch(node, ctx) {
+  const startTime = Date.now();
+  const { subject, cases } = node;
+  try {
+    const subjectValue = ctx.evaluateExpression(String(subject));
+    for (const matchCase of cases || []) {
+      const patternValue = ctx.evaluateExpression(String(matchCase.pattern));
+      if (patternMatches(patternValue, subjectValue)) {
+        if (matchCase.guard && !ctx.evaluateCondition(String(matchCase.guard))) {
+          continue;
+        }
+        if (Array.isArray(matchCase.body)) {
+          let lastResult = { success: true, output: null };
+          for (const bodyNode of matchCase.body) {
+            lastResult = await ctx.executeNode(bodyNode);
+            if (!lastResult.success) break;
+          }
+          return lastResult;
+        } else {
+          const result = ctx.evaluateExpression(String(matchCase.body));
+          return { success: true, output: result, executionTime: Date.now() - startTime };
+        }
+      }
+    }
+    return {
+      success: false,
+      error: "No pattern matched",
+      executionTime: Date.now() - startTime
+    };
+  } catch (error) {
+    return {
+      success: false,
+      error: `Match expression error: ${error instanceof Error ? error.message : String(error)}`,
+      executionTime: Date.now() - startTime
+    };
+  }
+}
+
+// src/runtime/holo-expression.ts
+var GET_MEMBER_PATH_CACHE = /* @__PURE__ */ new Map();
+var GET_MEMBER_PATH_MAX = 500;
+function getMemberPath(expr) {
+  const key = JSON.stringify(expr);
+  const cached = GET_MEMBER_PATH_CACHE.get(key);
+  if (cached !== void 0 || GET_MEMBER_PATH_CACHE.has(key)) {
+    return cached ?? null;
+  }
+  let result = null;
+  if (expr.type === "Identifier") {
+    result = expr.name;
+  } else if (expr.type === "MemberExpression") {
+    const parentPath = getMemberPath(expr.object);
+    if (parentPath) result = `${parentPath}.${expr.property}`;
+  }
+  if (GET_MEMBER_PATH_CACHE.size >= GET_MEMBER_PATH_MAX) {
+    const firstKey = GET_MEMBER_PATH_CACHE.keys().next().value;
+    if (firstKey !== void 0) GET_MEMBER_PATH_CACHE.delete(firstKey);
+  }
+  GET_MEMBER_PATH_CACHE.set(key, result);
+  return result;
+}
+async function evaluateHoloExpression(expr, scopeOverride, ctx) {
+  switch (expr.type) {
+    case "Literal":
+      return expr.value;
+    case "Identifier":
+      return ctx.getVariable(expr.name, scopeOverride);
+    case "MemberExpression": {
+      const obj = await evaluateHoloExpression(expr.object, scopeOverride, ctx);
+      if (obj && typeof obj === "object") {
+        return obj[expr.property];
+      }
+      return void 0;
+    }
+    case "CallExpression": {
+      if (!Array.isArray(expr.arguments)) {
+        console.error("[CRITICAL] arguments is not an array for", JSON.stringify(expr));
+        return void 0;
+      }
+      const callee = await evaluateHoloExpression(expr.callee, scopeOverride, ctx);
+      const args = await Promise.all(
+        expr.arguments.map(
+          (a) => evaluateHoloExpression(a, scopeOverride, ctx)
+        )
+      );
+      if (typeof callee === "function") {
+        return callee(...args);
+      }
+      if (expr.callee.type === "Identifier") {
+        const result = await ctx.callFunction(expr.callee.name, args);
+        return result.output;
+      }
+      return void 0;
+    }
+    case "BinaryExpression": {
+      const left = await evaluateHoloExpression(expr.left, scopeOverride, ctx);
+      const right = await evaluateHoloExpression(expr.right, scopeOverride, ctx);
+      switch (expr.operator) {
+        case "+":
+          return Number(left) + Number(right);
+        case "-":
+          return Number(left) - Number(right);
+        case "*":
+          return Number(left) * Number(right);
+        case "/":
+          return Number(left) / Number(right);
+        case "==":
+          return left == right;
+        case "===":
+          return left === right;
+        case "!=":
+          return left != right;
+        case "!==":
+          return left !== right;
+        case "<":
+          return Number(left) < Number(right);
+        case ">":
+          return Number(left) > Number(right);
+        case "<=":
+          return Number(left) <= Number(right);
+        case ">=":
+          return Number(left) >= Number(right);
+        case "&&":
+          return left && right;
+        case "||":
+          return left || right;
+        default:
+          return void 0;
+      }
+    }
+    case "ConditionalExpression": {
+      const test = await evaluateHoloExpression(expr.test, scopeOverride, ctx);
+      return test ? await evaluateHoloExpression(expr.consequent, scopeOverride, ctx) : await evaluateHoloExpression(expr.alternate, scopeOverride, ctx);
+    }
+    case "UpdateExpression": {
+      const val = await evaluateHoloExpression(expr.argument, scopeOverride, ctx);
+      const newVal = expr.operator === "++" ? val + 1 : val - 1;
+      const path = getMemberPath(expr.argument);
+      if (path) {
+        ctx.setVariable(path, newVal, scopeOverride);
+      }
+      return expr.prefix ? newVal : val;
+    }
+    case "ArrayExpression": {
+      return await Promise.all(
+        expr.elements.map((e) => evaluateHoloExpression(e, scopeOverride, ctx))
+      );
+    }
+    case "ObjectExpression": {
+      const obj = {};
+      for (const prop of expr.properties) {
+        obj[prop.key] = await evaluateHoloExpression(prop.value, scopeOverride, ctx);
+      }
+      return obj;
+    }
+    default:
+      return void 0;
+  }
+}
+
+// src/events/EventBus.ts
+var EventBus = class {
+  constructor() {
+    this.listeners = /* @__PURE__ */ new Map();
+    this.history = [];
+    this.maxHistory = 100;
+    this.nextId = 0;
+    this.paused = false;
+  }
+  /**
+   * Subscribe to an event.
+   */
+  on(event, callback, priority = 0) {
+    const id = this.nextId++;
+    const list = this.listeners.get(event) || [];
+    list.push({ callback, priority, once: false, id });
+    list.sort((a, b) => b.priority - a.priority);
+    this.listeners.set(event, list);
+    return id;
+  }
+  /**
+   * Subscribe to an event once (auto-removes after first fire).
+   */
+  once(event, callback, priority = 0) {
+    const id = this.nextId++;
+    const list = this.listeners.get(event) || [];
+    list.push({ callback, priority, once: true, id });
+    list.sort((a, b) => b.priority - a.priority);
+    this.listeners.set(event, list);
+    return id;
+  }
+  /**
+   * Unsubscribe by listener ID.
+   */
+  off(listenerId) {
+    for (const [event, list] of this.listeners) {
+      const idx = list.findIndex((l) => l.id === listenerId);
+      if (idx !== -1) {
+        list.splice(idx, 1);
+        return;
+      }
+    }
+  }
+  /**
+   * Unsubscribe all listeners for an event.
+   */
+  offAll(event) {
+    this.listeners.delete(event);
+  }
+  /**
+   * Emit an event to all subscribers.
+   */
+  emit(event, data) {
+    if (this.paused) return;
+    this.history.push({ event, data, timestamp: Date.now() });
+    if (this.history.length > this.maxHistory) this.history.shift();
+    const list = this.listeners.get(event);
+    if (list) {
+      const toRemove = [];
+      for (const listener of list) {
+        listener.callback(data);
+        if (listener.once) toRemove.push(listener.id);
+      }
+      for (const id of toRemove) {
+        const idx = list.findIndex((l) => l.id === id);
+        if (idx !== -1) list.splice(idx, 1);
+      }
+    }
+    if (event !== "*") {
+      const wildcardList = this.listeners.get("*");
+      if (wildcardList) {
+        for (const listener of wildcardList) {
+          listener.callback({ event, data });
+        }
+      }
+    }
+  }
+  /**
+   * Get event history.
+   */
+  getHistory() {
+    return [...this.history];
+  }
+  /**
+   * Get listener count for an event.
+   */
+  listenerCount(event) {
+    return this.listeners.get(event)?.length || 0;
+  }
+  /**
+   * Pause/resume event emission.
+   */
+  setPaused(paused) {
+    this.paused = paused;
+  }
+  /**
+   * Clear all listeners and history.
+   */
+  clear() {
+    this.listeners.clear();
+    this.history = [];
+  }
+};
+var sharedBus = null;
+function getSharedEventBus() {
+  if (!sharedBus) sharedBus = new EventBus();
+  return sharedBus;
+}
+function setSharedEventBus(bus) {
+  sharedBus = bus;
+}
+
+// src/monitoring/telemetry.ts
+var TelemetryRegistry = class {
+  constructor() {
+    this.measurements = [];
+    this.maxHistory = 1e4;
+  }
+  /**
+   * Increments a monotonic counter (e.g., total_nodes_executed)
+   */
+  incrementCounter(name, value = 1, labels) {
+    this.measurements.push({
+      name,
+      type: "counter",
+      value,
+      labels,
+      timestamp: Date.now()
+    });
+    if (this.measurements.length > this.maxHistory) this.measurements.shift();
+  }
+  /**
+   * Records an instantaneous value (e.g., active_agents)
+   */
+  setGauge(name, value, labels) {
+    this.measurements.push({
+      name,
+      type: "gauge",
+      value,
+      labels,
+      timestamp: Date.now()
+    });
+    if (this.measurements.length > this.maxHistory) this.measurements.shift();
+  }
+  /**
+   * Wraps an async function and records its execution latency into a histogram.
+   */
+  async measureLatency(name, fn, labels) {
+    const start = performance.now();
+    try {
+      return await fn();
+    } finally {
+      const duration = performance.now() - start;
+      this.measurements.push({
+        name,
+        type: "histogram",
+        value: duration,
+        labels,
+        timestamp: Date.now()
+      });
+      if (this.measurements.length > this.maxHistory) this.measurements.shift();
+      if (duration > 500) {
+        this.measurements.push({
+          name: "slo_violation_count",
+          type: "counter",
+          value: 1,
+          labels: { ...labels, metric_name: name, threshold: "500ms" },
+          timestamp: Date.now()
+        });
+      }
+    }
+  }
+  /**
+   * Snapshots current aggregations for dashboard export.
+   */
+  getSnapshot() {
+    const snapshot = { counters: {}, histograms: {}, gauges: {} };
+    const histAggregations = {};
+    for (const m of this.measurements) {
+      const key = m.labels ? `${m.name}{${JSON.stringify(m.labels)}}` : m.name;
+      if (m.type === "counter") {
+        snapshot.counters[key] = (snapshot.counters[key] || 0) + m.value;
+      } else if (m.type === "gauge") {
+        snapshot.gauges[key] = m.value;
+      } else if (m.type === "histogram") {
+        if (!histAggregations[key]) histAggregations[key] = { count: 0, sum: 0, max: 0 };
+        histAggregations[key].count++;
+        histAggregations[key].sum += m.value;
+        if (m.value > histAggregations[key].max) histAggregations[key].max = m.value;
+      }
+    }
+    for (const [key, agg] of Object.entries(histAggregations)) {
+      snapshot.histograms[key] = {
+        count: agg.count,
+        sum: agg.sum,
+        avg: agg.count > 0 ? agg.sum / agg.count : 0,
+        max: agg.max
+      };
+    }
+    return snapshot;
+  }
+};
+var telemetry = new TelemetryRegistry();
+function stringProperty(value) {
+  return typeof value === "string" ? value : void 0;
+}
+function createDetachedParentRuntime() {
+  const rootScope = { variables: /* @__PURE__ */ new Map() };
+  return {
+    async callFunction(functionName) {
+      return {
+        success: false,
+        error: `Detached hydrated agent cannot call function: ${functionName}`
+      };
+    },
+    getRootScope: () => rootScope,
+    getVariable: () => void 0,
+    async executeProgram() {
+      return [{ success: false, error: "Detached hydrated agent cannot execute programs" }];
+    },
+    emit: async () => void 0,
+    async executeHoloProgram() {
+      return [{ success: false, error: "Detached hydrated agent cannot execute Holo programs" }];
+    },
+    evaluateExpression: () => void 0
+  };
+}
+function textToEmbeddingFloat32(text, dim) {
+  const out = new Float32Array(dim);
+  let h = 5381;
+  for (let i = 0; i < text.length; i++) {
+    h = Math.imul(h, 33) ^ text.charCodeAt(i);
+    h = h >>> 0;
+  }
+  for (let d = 0; d < dim; d++) {
+    h = Math.imul(h, 1664525) + 1013904223;
+    h = h >>> 0;
+    out[d] = h / 4294967296 * 2 - 1;
+  }
+  return out;
+}
+var HoloScriptAgentRuntime = class _HoloScriptAgentRuntime {
+  /**
+   * Creates a new HoloScript agent runtime instance.
+   *
+   * @param agentNode - The OrbNode representing the agent template
+   * @param parentRuntime - The parent runtime providing global context
+   *
+   * @example
+   * ```typescript
+   * const runtime = new HoloScriptAgentRuntime(miningAgentNode, mainRuntime);
+   * ```
+   */
+  constructor(agentNode, parentRuntime) {
+    this.runningActions = /* @__PURE__ */ new Map();
+    this.isDestroyed = false;
+    // Episodic Memory & Semantic Extraction (Phase 7)
+    this.rawEpisodes = [];
+    this.semanticFacts = [];
+    this.consolidationInterval = null;
+    // JEPA action-planning loop (Phase 8)
+    // Default latentDim=64, condDim=16 (action conditioning). Caller can swap
+    // weights externally via this.jepaPredictor.setWeights() after training.
+    this.jepaPredictor = new JEPAPredictor({ latentDim: 64, condDim: 16 });
+    this.jepaObjectiveNode = {};
+    this.jepaObjectiveAttached = false;
+    if (!agentNode || !parentRuntime) {
+      return;
+    }
+    this.agentNode = agentNode;
+    this.parentRuntime = parentRuntime;
+    this.localState = new ReactiveState(agentNode.properties || {});
+    this.bindDurableIdentity(agentNode.properties || {});
+    this.initializeAgentContext();
+  }
+  /**
+   * Rehydrate an agent identity from substrate-anchored seed data without relying
+   * on the previous neural map. Reactive state, running actions, and episodes
+   * start empty; only durable identity fields and semantic facts are replayed.
+   */
+  static hydrate(seed, parentRuntime = createDetachedParentRuntime()) {
+    const agentNode = {
+      type: "orb",
+      id: seed.handle,
+      name: seed.handle,
+      template: seed.brainCompositionRef,
+      properties: {},
+      directives: []
+    };
+    const runtime = new _HoloScriptAgentRuntime(agentNode, parentRuntime);
+    runtime.applySeed(seed);
+    return runtime;
+  }
+  /**
+   * Reset the runtime for pooling reuse with new agent configuration.
+   *
+   * @param agentNode - New agent node to bind to this runtime
+   * @param parentRuntime - Parent runtime for global context
+   */
+  reset(agentNode, parentRuntime) {
+    this.agentNode = agentNode;
+    this.parentRuntime = parentRuntime;
+    this.localState = new ReactiveState(agentNode.properties || {});
+    this.runningActions.clear();
+    this.isDestroyed = false;
+    this.bindDurableIdentity(agentNode.properties || {});
+    this.initializeAgentContext();
+  }
+  bindDurableIdentity(properties) {
+    this.wallet = stringProperty(properties.wallet);
+    this.handle = stringProperty(properties.handle) ?? this.agentNode.name;
+    this.brainCompositionRef = stringProperty(properties.brainCompositionRef) ?? this.agentNode.template ?? this.agentNode.name;
+    this.memorySnapshotHash = stringProperty(properties.memorySnapshotHash);
+    this.resumeStepId = stringProperty(properties.resumeStepId);
+  }
+  applySeed(seed) {
+    this.wallet = seed.wallet;
+    this.handle = seed.handle;
+    this.brainCompositionRef = seed.brainCompositionRef;
+    this.memorySnapshotHash = seed.memorySnapshotHash;
+    this.resumeStepId = seed.resumeStepId;
+    this.semanticFacts = [...seed.semanticFacts ?? []];
+    this.rawEpisodes = [];
+    this.runningActions.clear();
+  }
+  durable() {
+    return {
+      wallet: this.wallet,
+      handle: this.handle,
+      brainCompositionRef: this.brainCompositionRef,
+      memorySnapshotHash: this.memorySnapshotHash,
+      resumeStepId: this.resumeStepId,
+      semanticFacts: [...this.semanticFacts],
+      annotations: {
+        wallet: "durable",
+        handle: "durable",
+        brainCompositionRef: "durable",
+        memorySnapshotHash: "durable",
+        resumeStepId: "durable",
+        semanticFacts: "durable"
+      }
+    };
+  }
+  losable() {
+    return {
+      reactiveState: this.localState.getSnapshot(),
+      runningActions: Array.from(this.runningActions.keys()),
+      rawEpisodes: [...this.rawEpisodes],
+      annotations: {
+        reactiveState: "losable",
+        runningActions: "losable",
+        rawEpisodes: "losable"
+      }
+    };
+  }
+  /**
+   * Initialize the agent's execution context and memory consolidation.
+   */
+  initializeAgentContext() {
+    ({
+      id: this.agentNode.id || this.agentNode.name,
+      type: this.agentNode.type,
+      state: this.localState.getSnapshot(),
+      properties: this.agentNode.properties});
+    if (!this.consolidationInterval) {
+      this.consolidationInterval = setInterval(() => this.consolidateMemory(), 3e4);
+    }
+  }
+  /**
+   * Records a raw episodic event into the agent's short-term history queue.
+   *
+   * @param action - The action that was performed
+   * @param outcome - The result or outcome of the action
+   * @param entitiesInvolved - List of entity IDs that were involved in the episode
+   *
+   * @example
+   * ```typescript
+   * agentRuntime.recordEpisode('mine_ore', 'collected 5 iron ore', ['ore_deposit_1', 'inventory']);
+   * ```
+   */
+  recordEpisode(action, outcome, entitiesInvolved) {
+    this.rawEpisodes.push({
+      id: `ep_${Date.now()}_${Math.random().toString(36).substring(7)}`,
+      timestamp: Date.now(),
+      action,
+      outcome,
+      entitiesInvolved
+    });
+  }
+  /**
+   * Internal idle tick leveraging the MemoryConsolidator subsystem to offload processing constraints.
+   */
+  consolidateMemory() {
+    if (this.isDestroyed || this.rawEpisodes.length < 5) return;
+    const { newFacts, prunedEpisodes } = MemoryConsolidator.compressEpisodes(this.rawEpisodes);
+    if (newFacts.length > 0) {
+      this.semanticFacts.push(...newFacts);
+      this.rawEpisodes = this.rawEpisodes.filter((e) => !prunedEpisodes.includes(e.id));
+    }
+    this.semanticFacts = MemoryConsolidator.pruneStaleFacts(this.semanticFacts);
+  }
+  /**
+   * Lazily attach the JEPAObjective trait on first use so constructor stays fast.
+   */
+  ensureJepaObjectiveAttached() {
+    if (!this.jepaObjectiveAttached) {
+      const config = this.getJepaObjectiveConfig();
+      jepObjectiveHandler.onAttach?.(
+        this.jepaObjectiveNode,
+        config,
+        this.buildJepaTraitContext()
+      );
+      this.jepaObjectiveAttached = true;
+    }
+  }
+  getJepaObjectiveConfig() {
+    const config = jepObjectiveHandler.defaultConfig;
+    if (!config) {
+      throw new Error("JEPAObjective handler defaultConfig is required for offline training");
+    }
+    return config;
+  }
+  /**
+   * Build a minimal TraitContext for the offline JEPA training call.
+   * Losses are logged via the runtime logger; no external emit dependency.
+   */
+  buildJepaTraitContext() {
+    const agentName = this.agentNode?.name ?? "agent";
+    return {
+      vr: null,
+      physics: null,
+      audio: null,
+      haptics: null,
+      emit: (eventName, payload) => {
+        if (eventName === "jepa:loss") {
+          const p = payload;
+          logger.info(`[JEPA:${agentName}] step=${p.step} totalLoss=${p.totalLoss.toFixed(4)}`);
+        } else if (eventName === "jepa:error") {
+          const e = payload;
+          logger.warn(`[JEPA:${agentName}] error code=${e.code} ${e.message}`);
+        }
+      },
+      getState: () => ({}),
+      setState: () => {
+      },
+      getScaleMultiplier: () => 1,
+      setScaleContext: () => {
+      }
+    };
+  }
+  /**
+   * Store a JEPA training episode and trigger an offline JEPAObjective training
+   * step. Called after each executeAction() to ensure every agent run generates
+   * JEPA training data automatically.
+   *
+   * The (state, action, outcome) tuple is encoded as a `jepa:encode_pair` event
+   * where context = JSON.stringify(state + action) and targetVec is derived from
+   * the outcome string deterministically (same hash used by JEPAPredictor.plan).
+   */
+  trainJepaOffline(stateBefore, action, outcome) {
+    this.ensureJepaObjectiveAttached();
+    const contextStr = JSON.stringify({ state: stateBefore, action });
+    const config = this.getJepaObjectiveConfig();
+    const latentDim = config.latentDim;
+    const outcomeStr = outcome.success ? `success:${String(outcome.output ?? "")}` : `failure:${String(outcome.error ?? "")}`;
+    const targetVec = textToEmbeddingFloat32(outcomeStr, latentDim);
+    jepObjectiveHandler.onEvent?.(
+      this.jepaObjectiveNode,
+      config,
+      this.buildJepaTraitContext(),
+      {
+        type: "jepa:encode_pair",
+        context: contextStr,
+        targetVec,
+        conditioning: void 0
+      }
+    );
+  }
+  /**
+   * Lightweight fork-detection heuristic for runtime adapters.
+   * Scans brain composition ref, template, and string properties for
+   * HS010-blocked keywords, unknown compiler versions, non-canonical imports,
+   * and no-op security traits.  Self-contained (no mcp-server imports).
+   */
+  checkForkSandbox() {
+    const sources = [];
+    if (this.brainCompositionRef) sources.push(this.brainCompositionRef);
+    if (this.agentNode.template) sources.push(this.agentNode.template);
+    for (const val of Object.values(this.agentNode.properties || {})) {
+      if (typeof val === "string") sources.push(val);
+    }
+    const directives = this.agentNode.directives;
+    if (directives) {
+      for (const d of directives) {
+        if (typeof d.body === "string") sources.push(d.body);
+      }
+    }
+    const blockedKeywords = [
+      "process",
+      "fs",
+      "require",
+      "eval",
+      "exec",
+      "spawn",
+      "child_process",
+      "constructor",
+      "prototype",
+      "globalThis"
+    ];
+    const canonicalVersions = ["7.0.0", "6.0.2", "6.0.1", "6.0.0"];
+    for (const src of sources) {
+      for (const kw of blockedKeywords) {
+        if (new RegExp(`\\b${kw}\\b`).test(src)) {
+          return { allowed: false, reason: `HS010-blocked-keyword:${kw}` };
+        }
+      }
+      const versionMatch = src.match(/@compiler\s+version\s+["']?([\d.]+)["']?/i);
+      if (versionMatch) {
+        const claimed = versionMatch[1];
+        if (!canonicalVersions.includes(claimed)) {
+          return { allowed: false, reason: `unknown-compiler-version:${claimed}` };
+        }
+      }
+      if (/\bfrom\s+['"](?!@holoscript\/)[@\w\/-]+['"]/.test(src)) {
+        return { allowed: false, reason: "non-canonical-import" };
+      }
+      if (/(?:^|\s)@security_sandbox\b/.test(src) && !/\bimport\s+.*security-sandbox/.test(src)) {
+        return { allowed: false, reason: "no-op-security-trait" };
+      }
+    }
+    return { allowed: true };
+  }
+  /**
+   * Execute an action (method) defined on the agent template.
+   *
+   * @param actionName - Name of the action/method to execute
+   * @param args - Arguments to pass to the action method
+   * @returns Promise resolving to execution result
+   * @throws {Error} When agent is destroyed or action execution fails
+   *
+   * @example
+   * ```typescript
+   * const result = await agentRuntime.executeAction('patrol', ['north_sector']);
+   * if (result.success) {
+   *   console.log('Patrol completed:', result.output);
+   * }
+   * ```
+   */
+  async executeAction(actionName, args = []) {
+    if (this.isDestroyed) return { success: false, error: "Agent destroyed" };
+    const forkCheck = this.checkForkSandbox();
+    if (!forkCheck.allowed) {
+      logger.warn(`[Agent:${this.agentNode.name}] ForkSandboxGate blocked action "${actionName}": ${forkCheck.reason}`);
+      return { success: false, error: `ForkSandboxGate: ${forkCheck.reason}` };
+    }
+    const directives = this.agentNode.directives;
+    const action = directives?.find((d) => d.type === "method" && d.name === actionName);
+    if (!action) {
+      return this.parentRuntime.callFunction(actionName, args);
+    }
+    logger.info(`[Agent:${this.agentNode.name}] Executing action: ${actionName}`);
+    const stateBefore = this.localState.getSnapshot();
+    const agentScope = {
+      variables: /* @__PURE__ */ new Map(),
+      parent: this.parentRuntime.getRootScope()
+    };
+    const agentData = this.parentRuntime.getVariable(this.agentNode.name);
+    if (agentData && !agentData.state) {
+      agentData.state = this.localState.getProxy();
+    }
+    agentScope.variables.set(
+      "this",
+      agentData || {
+        id: this.agentNode.name,
+        state: this.localState.getProxy(),
+        properties: this.agentNode.properties
+      }
+    );
+    if (action.parameters && args) {
+      action.parameters.forEach((param, i) => {
+        agentScope.variables.set(param.name, args[i]);
+      });
+    }
+    let executionResult = { success: false, error: "Action did not complete" };
+    try {
+      if (Array.isArray(action.body)) {
+        const results = await this.parentRuntime.executeHoloProgram(action.body, agentScope);
+        const success = results.every((r) => r.success);
+        executionResult = {
+          success,
+          output: results[results.length - 1]?.output,
+          error: results.find((r) => !r.success)?.error
+        };
+      } else {
+        const results = await this.parentRuntime.executeProgram(action.body, 1);
+        const success = results.every((r) => r.success);
+        executionResult = {
+          success,
+          output: results[results.length - 1]?.output,
+          error: results.find((r) => !r.success)?.error
+        };
+      }
+    } finally {
+      this.runningActions.delete(actionName);
+    }
+    const outcomeStr = executionResult.success ? `success:${String(executionResult.output ?? "")}` : `failure:${String(executionResult.error ?? "")}`;
+    this.recordEpisode(actionName, outcomeStr, [this.agentNode.name]);
+    try {
+      this.trainJepaOffline(stateBefore, actionName, executionResult);
+    } catch (trainErr) {
+      logger.warn(
+        `[JEPA:${this.agentNode.name}] trainJepaOffline error: ${String(trainErr)}`
+      );
+    }
+    return executionResult;
+  }
+  /**
+   * Autonomous 'thinking' cycle using LLM for decision making.
+   *
+   * @param prompt - Optional specific prompt for the LLM, defaults to general decision prompt
+   * @returns Promise resolving to the LLM's decision as a string
+   *
+   * @example
+   * ```typescript
+   * const decision = await agentRuntime.think('Should I retreat or continue attacking?');
+   * console.log('Agent decision:', decision);
+   * ```
+   */
+  async think(prompt) {
+    logger.info(`[Agent:${this.agentNode.name}] Thinking...`);
+    const directives = this.agentNode.directives;
+    const candidateActions = (directives ?? []).filter((d) => d.type === "method" && d.name).map((d) => d.name);
+    let jepaSuggestion;
+    if (candidateActions.length > 0) {
+      const stateSnapshot = JSON.stringify(this.localState.getSnapshot());
+      const planResult = this.jepaPredictor.plan(stateSnapshot, candidateActions);
+      jepaSuggestion = planResult.action;
+      logger.info(
+        `[JEPA:${this.agentNode.name}] plan() \u2192 "${planResult.action}" confidence=${planResult.confidence.toFixed(4)}`
+      );
+    }
+    const effectivePrompt = jepaSuggestion ? `${prompt ?? "Decide the next best action based on current state."} JEPA predictor suggests: "${jepaSuggestion}".` : prompt ?? "Decide the next best action based on current state.";
+    const result = await this.parentRuntime.emit("agent_think", {
+      agentId: this.agentNode.name,
+      context: this.localState.getSnapshot(),
+      prompt: effectivePrompt,
+      jepaSuggestion
+    });
+    return result?.decision || jepaSuggestion || "No clear decision made.";
+  }
+  /**
+   * Handle lifecycle events for this specific agent.
+   *
+   * @param eventType - The type of event being handled
+   * @param data - Event data to bind to the execution scope
+   *
+   * @example
+   * ```typescript
+   * await agentRuntime.onEvent('enemy_spotted', {
+   *   enemy: 'orc_warrior',
+   *   distance: 50
+   * });
+   * ```
+   */
+  async onEvent(eventType, data) {
+    if (this.isDestroyed) return;
+    const directives = this.agentNode.directives;
+    const handler = directives?.find((d) => d.type === "lifecycle" && d.hook === eventType);
+    if (handler) {
+      const eventScope = {
+        variables: /* @__PURE__ */ new Map(),
+        parent: this.parentRuntime.getRootScope()
+      };
+      if (data && typeof data === "object") {
+        for (const [key, val] of Object.entries(data)) {
+          eventScope.variables.set(key, val);
+        }
+      }
+      eventScope.variables.set("eventData", data);
+      directives?.forEach((d) => {
+        if (d.type === "method" && d.name) {
+          eventScope.variables.set(d.name, ((...args) => this.executeAction(d.name, args)));
+        }
+      });
+      const params = handler.parameters;
+      if (params && Array.isArray(params) && data && typeof data === "object") {
+        const dataRecord = data;
+        params.forEach((param) => {
+          if (dataRecord[param.name] !== void 0) {
+            eventScope.variables.set(param.name, dataRecord[param.name]);
+          }
+        });
+      }
+      const agentData = this.parentRuntime.getVariable(this.agentNode.name);
+      if (agentData && !agentData.state) {
+        agentData.state = this.localState.getProxy();
+      }
+      eventScope.variables.set(
+        "this",
+        agentData || {
+          id: this.agentNode.name,
+          state: this.localState.getProxy(),
+          properties: this.agentNode.properties
+        }
+      );
+      try {
+        if (Array.isArray(handler.body)) {
+          await this.parentRuntime.executeHoloProgram(handler.body, eventScope);
+        } else {
+          this.parentRuntime.evaluateExpression(handler.body);
+        }
+      } finally {
+      }
+    }
+  }
+  /**
+   * Clean up the agent runtime, stopping all running processes and timers.
+   */
+  destroy() {
+    this.isDestroyed = true;
+    this.runningActions.clear();
+    if (this.consolidationInterval) {
+      clearInterval(this.consolidationInterval);
+      this.consolidationInterval = null;
+    }
+    logger.info(`[Agent:${this.agentNode?.name ?? "unbound"}] Runtime destroyed.`);
+  }
+  /**
+   * Get the agent's unique identifier.
+   *
+   * @returns The agent's ID or name
+   */
+  get id() {
+    return this.agentNode.id || this.agentNode.name;
+  }
+  /**
+   * Get the agent's current reactive state proxy.
+   *
+   * @returns Proxy object for the agent's state
+   */
+  get state() {
+    return this.localState.getProxy();
+  }
+  /**
+   * Get the agent's current reactive state proxy.
+   *
+   * @returns Proxy object for the agent's state
+   */
+  getState() {
+    return this.localState.getProxy();
+  }
+};
+
+// src/extensions/ExtensionRegistry.ts
+var ExtensionRegistry = class {
+  constructor(runtime) {
+    this.extensions = /* @__PURE__ */ new Map();
+    this.runtime = runtime;
+  }
+  /**
+   * Load an extension into the runtime
+   */
+  loadExtension(extension) {
+    if (this.extensions.has(extension.id)) {
+      logger.warn(`Extension ${extension.id} is already loaded.`);
+      return;
+    }
+    const context = {
+      registerTrait: (name, handler) => {
+        logger.info(`[Extension:${extension.id}] Registering trait: ${name}`);
+        this.runtime.registerTrait(name, handler);
+      },
+      registerFunction: (name, fn) => {
+        logger.info(`[Extension:${extension.id}] Registering function: ${name}`);
+        this.runtime.registerGlobalFunction(name, fn);
+      },
+      logger
+    };
+    try {
+      extension.onLoad(context);
+      this.extensions.set(extension.id, extension);
+      logger.info(`Extension loaded: ${extension.id} v${extension.version}`);
+    } catch (error) {
+      logger.error(`Failed to load extension ${extension.id}:`, {
+        error: error instanceof Error ? error.message : String(error)
+      });
+      throw error;
+    }
+  }
+  /**
+   * Unload an extension
+   */
+  unloadingExtension(id) {
+    const extension = this.extensions.get(id);
+    if (!extension) return;
+    try {
+      const context = {
+        registerTrait: () => {
+        },
+        registerFunction: () => {
+        },
+        logger
+      };
+      extension.onUnload(context);
+    } catch (e) {
+      logger.error(`Error unloading extension ${id}`, {
+        error: e instanceof Error ? e.message : String(e)
+      });
+    }
+    this.extensions.delete(id);
+    logger.info(`Extension unloaded: ${id}`);
+  }
+  getExtension(id) {
+    return this.extensions.get(id);
+  }
+};
+
+// src/HoloScriptRuntime.ts
+var RUNTIME_SECURITY_LIMITS = {
+  maxExecutionDepth: 50,
+  maxTotalNodes: 1e3,
+  maxExecutionTimeMs: 5e3,
+  maxParticlesPerSystem: 1e3,
+  maxCallStackDepth: 100
+};
+function isOrbData2(v) {
+  return v !== null && typeof v === "object" && v.__type === "orb";
+}
+var HoloScriptRuntime = class {
+  constructor(_importLoader, customFunctions) {
+    this.particleSystems = /* @__PURE__ */ new Map();
+    this.executionHistory = [];
+    this.agentRuntimes = /* @__PURE__ */ new Map();
+    this.startTime = 0;
+    this.nodeCount = 0;
+    this.callStack = [];
+    this.eventHandlers = /* @__PURE__ */ new Map();
+    this.animations = /* @__PURE__ */ new Map();
+    this.uiElements = /* @__PURE__ */ new Map();
+    this.proceduralSkills = /* @__PURE__ */ new Map();
+    this.traitHandlers = /* @__PURE__ */ new Map();
+    this.context = createEmptyContext();
+    this.currentScope = { variables: this.context.variables };
+    this.builtinFunctions = this.initBuiltins(customFunctions);
+    this.agentPool = new engineRuntime.ObjectPool(
+      () => new HoloScriptAgentRuntime(),
+      // Preallocation mode (optional args)
+      (agent) => agent.destroy(),
+      50
+    );
+    engineRuntime.registerVoiceSynthesizer("default", new engineRuntime.BaseVoiceSynthesizer());
+    engineRuntime.registerEmotionDetector("default", new engineRuntime.LocalEmotionDetector());
+    engineRuntime.registerSpeechRecognizer("default", new engineRuntime.MockSpeechRecognizer());
+    for (const [name, fn] of this.builtinFunctions) {
+      this.context.functions.set(name, ((...spreadArgs) => fn(spreadArgs)));
+    }
+    attachStateInvalidationConsumer(this.buildEventSystemContext(), defaultStateInvalidationRegistry);
+    this.registerFunction("get_attended_entities", (args) => {
+      const topK = typeof args[0] === "number" ? args[0] : 10;
+      const selfRaw = this.context.variables.get("self");
+      const selfNode = isOrbData2(selfRaw) ? selfRaw : void 0;
+      const observerPos = selfNode?.position ?? [0, 0, 0];
+      const entities = [];
+      this.context.spatialMemory.forEach((pos, id) => {
+        if (id !== selfNode?.name) {
+          const entityRaw = this.context.variables.get(id);
+          const entityOrb = isOrbData2(entityRaw) ? entityRaw : void 0;
+          entities.push({
+            id,
+            position: pos,
+            velocity: entityOrb?.velocity,
+            saliencyBase: typeof entityOrb?.saliency === "number" ? entityOrb.saliency : void 0
+          });
+        }
+      });
+      return AttentionEngine.getTopKEntities(
+        observerPos,
+        entities,
+        topK
+      );
+    });
+    this.traitHandlers.set("mitosis", mitosisHandler);
+    this.traitHandlers.set("orbital", orbitalHandler);
+    this.extensionRegistry = new ExtensionRegistry(this);
+    engineRuntime.stateMachineInterpreter.setHookExecutor((code) => this.evaluateExpression(code));
+    engineRuntime.stateMachineInterpreter.setGuardEvaluator((expr) => this.evaluateExpression(expr));
+  }
+  /**
+   * Initialize built-in functions
+   */
+  /** Construct a BuiltinsContext bound to this runtime. (Slice 28) */
+  buildBuiltinsContext() {
+    return {
+      uiElements: this.uiElements,
+      hologramState: this.context.hologramState,
+      spatialMemory: this.context.spatialMemory,
+      animations: this.animations,
+      variables: this.context.variables,
+      templates: this.context.templates,
+      executionStack: this.context.executionStack,
+      agentRuntimes: this.agentRuntimes,
+      createParticleEffect: (name, position, color, count) => this.createParticleEffect(name, position, color, count),
+      createConnectionStream: (from, to, fromPos, toPos, dataType) => this.createConnectionStream(from, to, fromPos, toPos, dataType),
+      emit: (event, data) => this.emit(event, data),
+      setVariable: (name, value) => this.setVariable(name, value),
+      getVariable: (name) => this.getVariable(name),
+      executeOrb: (orbNode) => executeOrb(orbNode, this.buildOrbExecutorContext()),
+      calculateArc: (args) => this.handleCalculateArc(args)
+    };
+  }
+  /**
+   * Initialize built-in functions (W1-T4 slice 28: impl extracted to
+   * ./runtime/builtins-registry). Thin wrapper that constructs the
+   * context bag + delegates to createBuiltinsMap.
+   */
+  initBuiltins(customFunctions) {
+    return createBuiltinsMap(this.buildBuiltinsContext(), customFunctions);
+  }
+  /**
+   * Register a global function from an extension
+   */
+  registerGlobalFunction(name, fn) {
+    this.context.functions.set(name, ((...spreadArgs) => fn(spreadArgs)));
+  }
+  /**
+   * Register a custom trait from an extension
+   */
+  registerTrait(name, handler) {
+    const vrName = name;
+    this.traitHandlers.set(vrName, handler);
+    logger.info(`Registered trait: ${name}`);
+  }
+  /**
+   * Get the extension registry
+   */
+  getExtensionRegistry() {
+    return this.extensionRegistry;
+  }
+  /**
+   * Execute a single AST node.
+   *
+   * W1-T4 slice 34: the 225-LOC switch that used to live here is now a
+   * Map<nodeType, handler> in ./runtime/node-type-registry. This method
+   * keeps only the bookkeeping (executionStack push/pop, executionHistory
+   * append, startTime/executionTime, error catch) — dispatch is a table
+   * lookup. Adding a new node type is a one-line registry entry.
+   */
+  async executeNode(node) {
+    const startTime = Date.now();
+    try {
+      this.context.executionStack.push(node);
+      const result = await dispatchNode(
+        node,
+        this
+      );
+      result.executionTime = Date.now() - startTime;
+      this.executionHistory.push(result);
+      this.context.executionStack.pop();
+      return result;
+    } catch (error) {
+      const execTime = Date.now() - startTime;
+      const errorResult = {
+        success: false,
+        error: error instanceof Error ? error.message : String(error),
+        executionTime: execTime
+      };
+      this.executionHistory.push(errorResult);
+      this.context.executionStack.pop();
+      return errorResult;
+    }
+  }
+  /**
+   * Execute multiple nodes or a single node (unified entry point)
+   */
+  async execute(nodes) {
+    this.startTime = Date.now();
+    this.nodeCount = 0;
+    if (Array.isArray(nodes)) {
+      const results = await this.executeProgram(nodes);
+      const success = results.every((r) => r.success);
+      const lastResult = results[results.length - 1];
+      let output = success ? `Program executed (${results.length} nodes)` : "Program failed";
+      if (lastResult && lastResult.success && lastResult.output !== void 0) {
+        output = lastResult.output;
+      }
+      return {
+        success,
+        output,
+        error: results.find((r) => !r.success)?.error
+      };
+    } else {
+      return this.executeNode(nodes);
+    }
+  }
+  /**
+   * Execute multiple nodes in sequence
+   */
+  async executeProgram(nodes, depth = 0) {
+    if (depth === 0) {
+      this.startTime = Date.now();
+      this.nodeCount = 0;
+    }
+    if (depth > RUNTIME_SECURITY_LIMITS.maxExecutionDepth) {
+      logger.error("Max execution depth exceeded", { depth });
+      return [
+        {
+          success: false,
+          error: `Max execution depth exceeded (${RUNTIME_SECURITY_LIMITS.maxExecutionDepth})`,
+          executionTime: 0
+        }
+      ];
+    }
+    const results = [];
+    for (const node of nodes) {
+      this.nodeCount++;
+      if (this.nodeCount > RUNTIME_SECURITY_LIMITS.maxTotalNodes) {
+        logger.error("Max total nodes exceeded", { count: this.nodeCount });
+        results.push({
+          success: false,
+          error: "Max total nodes exceeded",
+          executionTime: Date.now() - this.startTime
+        });
+        break;
+      }
+      if (Date.now() - this.startTime > RUNTIME_SECURITY_LIMITS.maxExecutionTimeMs) {
+        logger.error("Execution timeout", { duration: Date.now() - this.startTime });
+        results.push({
+          success: false,
+          error: "Execution timeout",
+          executionTime: Date.now() - this.startTime
+        });
+        break;
+      }
+      const result = await this.executeNode(node);
+      results.push(result);
+      if (!result.success && node.type !== "visualize") {
+        break;
+      }
+      if (node.type === "return") {
+        break;
+      }
+    }
+    return results;
+  }
+  /**
+   * Call a function with arguments
+   */
+  async callFunction(name, args = []) {
+    const builtin = this.builtinFunctions.get(name);
+    if (builtin) {
+      try {
+        const result = await builtin(args);
+        return {
+          success: true,
+          output: result
+        };
+      } catch (error) {
+        return {
+          success: false,
+          error: `Built-in function ${name} failed: ${error}`
+        };
+      }
+    }
+    const func = this.context.functions.get(name);
+    if (!func) {
+      return {
+        success: false,
+        error: `Function '${name}' not found`
+      };
+    }
+    if (typeof func === "function") {
+      try {
+        const result = await func(...args);
+        return {
+          success: true,
+          output: result
+        };
+      } catch (error) {
+        return {
+          success: false,
+          error: `Extension function ${name} failed: ${error}`
+        };
+      }
+    }
+    if (this.callStack.length >= RUNTIME_SECURITY_LIMITS.maxCallStackDepth) {
+      return {
+        success: false,
+        error: `Max call stack depth exceeded (${RUNTIME_SECURITY_LIMITS.maxCallStackDepth})`
+      };
+    }
+    const parentScope = this.currentScope;
+    this.currentScope = {
+      variables: /* @__PURE__ */ new Map(),
+      parent: parentScope
+    };
+    func.parameters.forEach((param, index) => {
+      const value = index < args.length ? args[index] : param.defaultValue;
+      this.currentScope.variables.set(param.name, value);
+    });
+    this.callStack.push(name);
+    let returnValue = void 0;
+    try {
+      const results = await this.executeProgram(func.body, this.callStack.length);
+      const lastResult = results[results.length - 1];
+      if (lastResult?.output !== void 0) {
+        returnValue = lastResult.output;
+      }
+      this.createExecutionEffect(name, func.position || [0, 0, 0]);
+      return {
+        success: results.every((r) => r.success),
+        output: returnValue,
+        hologram: func.hologram,
+        spatialPosition: func.position
+      };
+    } finally {
+      this.currentScope = parentScope;
+      this.callStack.pop();
+    }
+  }
+  /**
+   * Set a variable in current scope
+   */
+  setVariable(name, value, scopeOverride) {
+    if (name.includes(".")) {
+      const parts = name.split(".");
+      const objName = parts[0];
+      const propPath = parts.slice(1);
+      let obj = this.getVariable(objName, scopeOverride);
+      if (obj === void 0 || typeof obj !== "object" || obj === null) {
+        obj = {};
+        const scope = scopeOverride || this.currentScope;
+        scope.variables.set(objName, obj);
+      }
+      let current = obj;
+      for (let i = 0; i < propPath.length - 1; i++) {
+        if (current[propPath[i]] === void 0 || typeof current[propPath[i]] !== "object") {
+          current[propPath[i]] = {};
+        }
+        current = current[propPath[i]];
+      }
+      current[propPath[propPath.length - 1]] = value;
+    } else {
+      const scope = scopeOverride || this.currentScope;
+      scope.variables.set(name, value);
+    }
+    if (this.wss && typeof value === "object" && value !== null && value.__type === "orb") {
+      this.broadcast("orb_update", { orb: value });
+    } else if (this.wss && name.includes(".")) {
+      const root = name.split(".")[0];
+      const rootVar = this.getVariable(root, scopeOverride);
+      if (rootVar && typeof rootVar === "object" && rootVar.__type === "orb") {
+        this.broadcast("orb_update", { orb: rootVar });
+      }
+    }
+  }
+  /**
+   * Get a variable from scope chain
+   */
+  getVariable(name, scopeOverride) {
+    if (name.includes(".")) {
+      const parts = name.split(".");
+      let value = this.getVariable(parts[0], scopeOverride);
+      for (let i = 1; i < parts.length && value !== void 0; i++) {
+        if (typeof value === "object" && value !== null) {
+          value = value[parts[i]];
+        } else {
+          return void 0;
+        }
+      }
+      return value;
+    }
+    let scope = scopeOverride || this.currentScope;
+    while (scope) {
+      if (scope.variables.has(name)) {
+        return scope.variables.get(name);
+      }
+      scope = scope.parent;
+    }
+    if (this.context.variables.has(name)) {
+      return this.context.variables.get(name);
+    }
+    if (this.context.functions.has(name)) {
+      return this.context.functions.get(name);
+    }
+    return void 0;
+  }
+  /**
+   * Evaluate an expression in current context
+   */
+  evaluateExpression(expr) {
+    if (!expr || typeof expr !== "string") return expr;
+    const evaluator = new ExpressionEvaluator(this.context.state.getSnapshot());
+    const varContext = {};
+    this.context.variables.forEach((v, k) => varContext[k] = v);
+    evaluator.updateContext(varContext);
+    return evaluator.evaluate(expr);
+  }
+  // ============================================================================
+  // Node Executors
+  // ============================================================================
+  // W1-T4 slice 26: executeOrb extracted to ./runtime/orb-executor.
+  // Closes board task task_1776940471985_57z8.
+  // W1-T4 slice 20: executeFunction / executeConnection / executeGate /
+  // executeStream extracted to ./runtime/graph-executors.
+  /**
+   * Execute State Machine declaration (Phase 13)
+   */
+  // W1-T4 slice 17: executeStateMachine / executeExpressionStatement /
+  // executeCall extracted to ./runtime/simple-executors.
+  // W1-T4 slice 31: executeDebug extracted to ./runtime/debug-executor.
+  // Thin wrapper binds runtime state-map references + logger into a
+  // DebugExecutorContext and forwards to the pure executor.
+  async executeDebug(node) {
+    return executeDebug(node, this.buildDebugExecutorContext());
+  }
+  buildDebugExecutorContext() {
+    return {
+      scopeVariables: this.currentScope.variables,
+      contextVariables: this.context.variables,
+      functions: this.context.functions,
+      connections: this.context.connections,
+      callStack: this.callStack,
+      uiElements: this.uiElements,
+      animations: this.animations,
+      executionHistory: this.executionHistory,
+      setHologramState: (key, hologram) => {
+        this.context.hologramState.set(key, hologram);
+      },
+      logInfo: (message, payload) => {
+        logger.info(message, payload);
+      }
+    };
+  }
+  // W1-T4 slice 22: executeVisualize / executeUIElement extracted to ./runtime/info-executors.
+  /**
+   * Execute generic voice commands
+   * Handles commands like: show, hide, animate, pulse, create
+   */
+  async executeGeneric(_node) {
+    const genericNode = _node;
+    const command = String(genericNode.command || "").trim().toLowerCase();
+    const tokens = command.split(/\s+/);
+    const action = tokens[0];
+    const target = tokens[1];
+    logger.info("Executing generic command", { command, action, target });
+    try {
+      let result;
+      const uiCtx = this.buildUICommandContext();
+      switch (action) {
+        case "show":
+          result = await executeShowCommand(target, genericNode, uiCtx);
+          break;
+        case "hide":
+          result = await executeHideCommand(target, genericNode, uiCtx);
+          break;
+        case "create":
+        case "summon":
+          result = await executeCreateCommand(tokens.slice(1), genericNode, uiCtx);
+          break;
+        case "animate":
+          result = await executeAnimateCommand(target, tokens.slice(2), genericNode, uiCtx);
+          break;
+        case "pulse":
+          result = await executePulseCommand(target, tokens.slice(2), genericNode, uiCtx);
+          break;
+        case "move":
+          result = await executeMoveCommand(target, tokens.slice(2), genericNode, uiCtx);
+          break;
+        case "delete":
+        case "remove":
+          result = await executeDeleteCommand(target, genericNode, uiCtx);
+          break;
+        default:
+          logger.warn("Unknown voice command action", { action, command });
+          result = {
+            executed: false,
+            message: `Unknown command: ${action}`
+          };
+      }
+      return {
+        success: true,
+        output: result
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: `Generic command execution failed: ${String(error)}`
+      };
+    }
+  }
+  // W1-T4 slice 18: show/hide/create/animate/pulse/move/delete commands
+  // extracted to ./runtime/ui-commands. Methods deleted — dispatch is
+  // inlined above using buildUICommandContext().
+  // W1-T4 slice 19: executeStructure / executeAssignment / executeReturn
+  // added to ./runtime/simple-executors.
+  // ============================================================================
+  // Condition Evaluation
+  // ============================================================================
+  /**
+   * Thin wrapper over the extracted pure evaluator (W1-T4 slice 3,
+   * see ./runtime/condition-evaluator). Callers pass the runtime's
+   * `evaluateExpression` as the expression-resolution callback.
+   */
+  evaluateCondition(condition) {
+    return evaluateCondition(condition, (expr) => this.evaluateExpression(expr));
+  }
+  // ============================================================================
+  // Transformation
+  // ============================================================================
+  /**
+   * Thin wrapper over the extracted pure transformation operations
+   * (W1-T4 slice 5, see ./runtime/transformation). Threads
+   * setVariable / evaluateCondition / evaluateExpression through
+   * a context object so the pure module stays free of `this` binding.
+   */
+  async applyTransformation(data, transform) {
+    return applyTransformation(data, transform, {
+      setVariable: (name, value) => this.setVariable(name, value),
+      evaluateCondition: (expr) => this.evaluateCondition(expr),
+      evaluateExpression: (expr) => this.evaluateExpression(expr)
+    });
+  }
+  // ============================================================================
+  // Event System
+  // ============================================================================
+  /**
+   * Outstanding state invalidations (PersistentTrait TTL expiries). A reader
+   * checks `stateInvalidations.wasInvalidated(key)` before trusting a cached
+   * value and `consume(key)` once it has refetched. Closes the
+   * `persistent_expired`-into-void capability gap.
+   */
+  get stateInvalidations() {
+    return defaultStateInvalidationRegistry;
+  }
+  /** Construct an EventSystemContext bound to this runtime. (Slice 29) */
+  buildEventSystemContext() {
+    return {
+      eventHandlers: this.eventHandlers,
+      agentRuntimes: this.agentRuntimes,
+      variables: this.context.variables,
+      traitHandlers: this.traitHandlers,
+      uiElements: this.uiElements,
+      getCurrentScale: () => this.context.currentScale,
+      // EventBus.emit is sync (returns void) but the EventSystemContext
+      // contract requires Promise<void> so trait-side emits can `await`
+      // through a unified interface. Wrap with Promise.resolve.
+      globalBusEmit: (event, data) => {
+        getSharedEventBus().emit(event, data);
+        return Promise.resolve();
+      },
+      sendStateMachineEvent: (id, event) => engineRuntime.stateMachineInterpreter.sendEvent(id, event)
+    };
+  }
+  /**
+   * Register event handler.
+   * (W1-T4 slice 29: impl extracted to ./runtime/event-system.)
+   */
+  on(event, handler) {
+    onEvent(event, handler, this.buildEventSystemContext());
+  }
+  /**
+   * Register host function. Stays in HSR — direct builtinFunctions
+   * write, not part of the event-system concern.
+   */
+  registerFunction(name, handler) {
+    this.builtinFunctions.set(name, handler);
+    logger.info(`Host function registered: ${name}`);
+  }
+  /**
+   * Remove event handler.
+   * (W1-T4 slice 29: impl extracted to ./runtime/event-system.)
+   */
+  off(event, handler) {
+    offEvent(event, handler, this.buildEventSystemContext());
+  }
+  /**
+   * Emit event through the full 5-stage dispatch.
+   * (W1-T4 slice 29: impl extracted to ./runtime/event-system.)
+   */
+  async emit(event, data) {
+    return emit(event, data, this.buildEventSystemContext());
+  }
+  /**
+   * Trigger UI event — update element.value + fire dotted event.
+   * (W1-T4 slice 29: impl extracted to ./runtime/event-system.)
+   */
+  async triggerUIEvent(elementName, eventType, data) {
+    return triggerUIEvent(elementName, eventType, data, this.buildEventSystemContext());
+  }
+  // W1-T4 slice 29: forwardToTraits extracted to ./runtime/event-system
+  // (private in HSR, now a module function; no wrapper needed — the only
+  //  former caller is emit, which now calls the extracted forwardToTraits directly).
+  // ============================================================================
+  // Animation System
+  // ============================================================================
+  /**
+   * Update all animations (W1-T4 slice 6: per-tick lerp extracted to
+   * ./runtime/animation-system). Also ticks system variables — that
+   * coupling lives in HSR because `updateSystemVariables` touches
+   * too much runtime state to cleanly extract yet.
+   */
+  updateAnimations() {
+    updateAnimations(
+      this.animations,
+      (name, value) => this.setVariable(name, value),
+      Date.now()
+    );
+    this.updateSystemVariables();
+  }
+  /**
+   * Update real-life and system variables ($time, $user, etc.)
+   */
+  /**
+   * Update real-life and system variables ($time, $user, etc.)
+   * (W1-T4 slice 9: impl extracted to ./runtime/system-variables).
+   * Threads setVariable/getVariable callbacks plus the already-read
+   * brittney_api_keys JSON string so the pure module has no
+   * hidden dependency on browser `localStorage`.
+   */
+  updateSystemVariables() {
+    const brittneyApiKeysJson = typeof localStorage !== "undefined" ? localStorage.getItem("brittney_api_keys") : null;
+    updateSystemVariables({
+      setVariable: (name, value) => this.setVariable(name, value),
+      getVariable: (name) => this.getVariable(name),
+      brittneyApiKeysJson
+    });
+  }
+  // ==========================================================================
+  // COMMERCE / SOCIAL / PHYSICS / ANIMATION PRIMITIVES
+  // (W1-T4 slice 8: extracted to ./runtime/primitives, registered
+  //  inline in initBuiltins via emit-injection — no wrappers needed)
+  //
+  // handleCalculateArc (below) stays — it's structured differently
+  // from the emit-pattern primitives: it does real math via
+  // calculateArc (slice 2), not an event dispatch.
+  // ==========================================================================
+  /**
+   * Handle calculate_arc(start, end, speed)
+   * W1-T4 slice 2: math extracted to ./runtime/physics-math.calculateArc
+   */
+  handleCalculateArc(args) {
+    if (args.length < 3) return [0, 0, 0];
+    const start = args[0];
+    const end = args[1];
+    const speed = args[2];
+    return calculateArc(start, end, speed);
+  }
+  // ============================================================================
+  // Particle Effects (W1-T4 slice 4: impls extracted to ./runtime/particle-effects)
+  //
+  // Methods below are thin wrappers that thread `this.particleSystems`
+  // (the Map) and the security limit into the pure implementations.
+  // Call sites elsewhere in HSR remain unchanged.
+  // ============================================================================
+  createParticleEffect(name, position, color, count) {
+    createParticleEffect(
+      this.particleSystems,
+      name,
+      position,
+      color,
+      count,
+      RUNTIME_SECURITY_LIMITS.maxParticlesPerSystem
+    );
+  }
+  createConnectionStream(from, to, fromPos, toPos, dataType) {
+    createConnectionStream(this.particleSystems, from, to, fromPos, toPos, dataType);
+  }
+  createFlowingStream(name, position, data) {
+    createFlowingStream(
+      this.particleSystems,
+      name,
+      position,
+      data,
+      RUNTIME_SECURITY_LIMITS.maxParticlesPerSystem
+    );
+  }
+  createExecutionEffect(name, position) {
+    createExecutionEffect(
+      this.particleSystems,
+      name,
+      position,
+      RUNTIME_SECURITY_LIMITS.maxParticlesPerSystem
+    );
+  }
+  createDataVisualization(name, data, position) {
+    createDataVisualization(
+      this.particleSystems,
+      name,
+      data,
+      position,
+      RUNTIME_SECURITY_LIMITS.maxParticlesPerSystem
+    );
+  }
+  getDataTypeColor(dataType) {
+    return getDataTypeColor(dataType);
+  }
+  // ============================================================================
+  // Visualizer Server
+  // ============================================================================
+  startVisualizationServer(port = 8080) {
+    try {
+      this.wss = new WebSocketServer({ port });
+      logger.info(`[Visualizer] WebSocket server started on port ${port}`);
+      this.timeManager = new TimeManager(/* @__PURE__ */ new Date());
+      this.timeManager.onUpdate((julianDate, date) => {
+        this.updateTraits(julianDate);
+        this.broadcast("time_update", {
+          julianDate,
+          date: date.toISOString(),
+          timeScale: this.timeManager.getTimeScale(),
+          isPaused: this.timeManager.getIsPaused()
+        });
+      });
+      this.timeManager.start();
+      this.updateTraits(this.timeManager.getJulianDate());
+      this.wss.on("connection", (ws) => {
+        logger.info("[Visualizer] Client connected");
+        const orbs = Array.from(this.context.variables.entries()).filter(
+          ([_, v]) => v && typeof v === "object" && v.__type === "orb"
+        ).map(([id, v]) => {
+          const orbData = v;
+          return {
+            id,
+            name: orbData.name || id,
+            position: Array.isArray(orbData.position) ? [orbData.position[0], orbData.position[1], orbData.position[2]] : orbData.position,
+            properties: orbData.properties || {},
+            hologram: orbData.hologram || (() => {
+              const props = orbData.properties;
+              return {
+                color: props?.color || "#ffffff",
+                size: props?.size || props?.scale || 1,
+                shape: props?.geometry || "sphere",
+                glow: props?.glow || false
+              };
+            })(),
+            traits: orbData.traits || []
+          };
+        });
+        ws.send(
+          JSON.stringify({
+            type: "init",
+            orbs,
+            time: this.timeManager ? this.timeManager.getState() : null
+          })
+        );
+        ws.on("message", (message) => {
+          try {
+            const data = readJson(message.toString());
+            if (data.type === "time_control") {
+              if (typeof data.command === "string") {
+                this.handleTimeControl(data.command, data.value);
+              }
+            }
+          } catch (e) {
+            logger.error("[Visualizer] Failed to parse message", { error: String(e) });
+          }
+        });
+      });
+    } catch (error) {
+      logger.error("[Visualizer] Failed to start server", { error: String(error) });
+    }
+  }
+  /**
+   * Handle time control commands from visualizer
+   * (W1-T4 slice 7: impl extracted to ./runtime/visualizer-server)
+   */
+  handleTimeControl(command, value) {
+    handleTimeControl(this.timeManager, command, value);
+  }
+  /**
+   * Broadcast a typed message to all connected WebSocket clients.
+   * (W1-T4 slice 7: impl extracted to ./runtime/visualizer-server)
+   */
+  broadcast(type, payload) {
+    broadcast(this.wss, type, payload);
+  }
+  // ============================================================================
+  // Public API
+  // ============================================================================
+  getParticleSystems() {
+    return new Map(this.particleSystems);
+  }
+  /**
+   * Advance all particle systems by deltaTime.
+   * (W1-T4 slice 14: impl extracted to ./runtime/particle-effects)
+   */
+  updateParticles(deltaTime) {
+    updateParticles(this.particleSystems, deltaTime);
+  }
+  getContext() {
+    return { ...this.context };
+  }
+  getUIElements() {
+    return new Map(this.uiElements);
+  }
+  getUIElement(name) {
+    return this.uiElements.get(name);
+  }
+  getAnimations() {
+    return new Map(this.animations);
+  }
+  reset() {
+    this.context = createEmptyContext();
+    this.currentScope = { variables: this.context.variables };
+    this.callStack = [];
+    this.particleSystems.clear();
+    this.executionHistory = [];
+    this.eventHandlers.clear();
+    this.animations.clear();
+    this.uiElements.clear();
+  }
+  // W1-T4 slice 10: createEmptyContext extracted to ./runtime/context-factory
+  // (was a private method here; now called directly as module function
+  //  at the 2 internal call sites — no wrapper needed).
+  // W1-T4 slice 21: executeScale added to ./runtime/simple-executors.
+  // W1-T4 slice 17: executeFocus / executeEnvironment extracted to ./runtime/simple-executors.
+  // W1-T4 slice 21: executeComposition added to ./runtime/simple-executors.
+  // W1-T4 slice 13: resolveHoloValue extracted to ./runtime/holo-value
+  // (pure recursive helper; private method deleted — 4 internal call
+  //  sites now use the imported function directly).
+  // W1-T4 slice 24: executeHoloComposition extracted to ./runtime/holo-composition-executor.
+  // W1-T4 slice 17: executeHoloTemplate extracted to ./runtime/simple-executors.
+  // W1-T4 slice 25: executeHoloObject extracted to ./runtime/holo-object-executor.
+  // Closes board task task_1776940617322_ee53.
+  /**
+   * Execute a block of HoloStatements (HoloNode AST)
+   */
+  // W1-T4 slice 30: executeHoloProgram + executeHoloStatement extracted
+  // to ./runtime/holo-statement-executor. Thin wrappers bind this
+  // runtime's getVariable/setVariable/emit/evaluateHoloExpression +
+  // telemetry into a HoloStatementContext and forward to the pure
+  // recursive executor.
+  async executeHoloProgram(statements, scopeOverride) {
+    return executeHoloProgram(statements, scopeOverride, this.buildHoloStatementContext());
+  }
+  async executeHoloStatement(stmt, scopeOverride) {
+    return executeHoloStatement(stmt, scopeOverride, this.buildHoloStatementContext());
+  }
+  buildHoloStatementContext() {
+    return {
+      currentScope: this.currentScope,
+      getVariable: (name, scope) => this.getVariable(name, scope),
+      setVariable: (name, value, scope) => {
+        this.setVariable(name, value, scope);
+      },
+      emit: (event, data) => {
+        void this.emit(event, data);
+      },
+      evaluateHoloExpression: (expr, scopeOverride) => this.evaluateHoloExpression(expr, scopeOverride),
+      telemetry: {
+        setGauge: (name, value) => {
+          telemetry.setGauge(name, value);
+        },
+        incrementCounter: (name, value, labels) => {
+          telemetry.incrementCounter(name, value, labels);
+        },
+        measureLatency: (name, fn) => telemetry.measureLatency(name, fn),
+        executionDepth: () => this.context.executionStack.length
+      }
+    };
+  }
+  // W1-T4 slice: evaluateHoloExpression + getMemberPath extracted to
+  // ./runtime/holo-expression. Thin wrapper binds this runtime's
+  // getVariable/setVariable/callFunction into a HoloExpressionContext
+  // and forwards to the pure recursive evaluator. Memoization (max 500,
+  // FIFO) is preserved via a module-level cache in the pure module.
+  evaluateHoloExpression(expr, scopeOverride) {
+    return evaluateHoloExpression(expr, scopeOverride, this.buildHoloExpressionContext());
+  }
+  buildHoloExpressionContext() {
+    return {
+      getVariable: (name, scope) => this.getVariable(name, scope),
+      setVariable: (name, value, scope) => this.setVariable(name, value, scope),
+      callFunction: (name, args) => this.callFunction(name, args)
+    };
+  }
+  // W1-T4 slice 16: executeSystem / setupNetworking / setupPhysics /
+  // executeCoreConfig extracted to ./runtime/system-executors. Methods
+  // deleted; dispatch calls the pure functions inline.
+  // =========================================================================
+  // Control Flow Execution (W1-T4 slice 12: impls extracted to
+  // ./runtime/control-flow — wrappers below share a ControlFlowContext
+  // that threads evaluateExpression / evaluateCondition / executeNode /
+  // variables through a narrow boundary).
+  // =========================================================================
+  /** Construct a ControlFlowContext bound to this runtime's state. */
+  buildControlFlowContext() {
+    return {
+      evaluateExpression: (expr) => this.evaluateExpression(expr),
+      evaluateCondition: (expr) => this.evaluateCondition(expr),
+      executeNode: (n) => this.executeNode(n),
+      variables: this.context.variables
+    };
+  }
+  /** @for item in iterable { body } */
+  async executeForLoop(node) {
+    return executeForLoop(node, this.buildControlFlowContext());
+  }
+  /** @forEach item in collection { body } */
+  async executeForEachLoop(node) {
+    return executeForEachLoop(node, this.buildControlFlowContext());
+  }
+  /** @while condition { body } (10k-iteration safety cap) */
+  async executeWhileLoop(node) {
+    return executeWhileLoop(node, this.buildControlFlowContext());
+  }
+  /** @if condition { body } @else { elseBody } */
+  async executeIfStatement(node) {
+    return executeIfStatement(node, this.buildControlFlowContext());
+  }
+  /** @match subject { pattern => result, ... } */
+  async executeMatch(node) {
+    return executeMatch(node, this.buildControlFlowContext());
+  }
+  // W1-T4 slice 11: patternMatches extracted to ./runtime/pattern-match
+  // (pure helper; deleted method — only caller is executeMatch above,
+  //  now using patternMatchesPure directly).
+  // W1-T4 slice 15: executeNarrative / executeQuest / executeDialogue
+  // extracted to ./runtime/narrative-executors. Methods deleted —
+  // dispatch calls the pure functions directly with a shared context.
+  /** Construct an OrbExecutorContext bound to this runtime. (Slice 26) */
+  buildOrbExecutorContext() {
+    return {
+      getCurrentScale: () => this.context.currentScale,
+      getVariable: (name) => this.getVariable(name),
+      setVariable: (name, value) => this.setVariable(name, value),
+      setSpatialPosition: (name, pos) => {
+        this.context.spatialMemory.set(name, pos);
+      },
+      evaluateExpression: (expr) => this.evaluateExpression(expr),
+      getTemplate: (name) => this.context.templates.get(name),
+      setHologramState: (name, hologram) => {
+        this.context.hologramState.set(name, hologram);
+      },
+      executeMigrationBlock: (existingOrb, migration) => this.executeMigrationBlock(existingOrb, migration),
+      getBuiltinFunction: (name) => this.builtinFunctions.get(name),
+      applyDirectives: (node) => this.applyDirectives(node),
+      isAgent: (node) => this.isAgent(node),
+      getAgentRuntime: (name) => this.agentRuntimes.get(name),
+      setAgentRuntime: (name, runtime) => {
+        this.agentRuntimes.set(name, runtime);
+      },
+      acquireAgentRuntime: () => this.agentPool.acquire(),
+      parentRuntime: this,
+      createParticleEffect: (name, position, color, count) => this.createParticleEffect(name, position, color, count),
+      broadcast: (event, payload) => this.broadcast(event, payload)
+    };
+  }
+  /** Construct a HoloObjectContext bound to this runtime. (Slice 25) */
+  buildHoloObjectContext() {
+    return {
+      getTemplate: (name) => this.context.templates.get(name),
+      executeOrb: (orbNode) => executeOrb(orbNode, this.buildOrbExecutorContext())
+    };
+  }
+  /** Construct a HoloCompositionContext bound to this runtime. (Slice 24) */
+  buildHoloCompositionContext() {
+    return {
+      simpleExecutorContext: this.buildSimpleExecutorContext(),
+      executeHoloObject: (node) => executeHoloObject(node, this.buildHoloObjectContext()),
+      getEnvironment: () => this.context.environment,
+      setEnvironment: (env) => {
+        this.context.environment = env;
+      }
+    };
+  }
+  /** Construct an InfoExecutorContext bound to this runtime. (Slice 22) */
+  buildInfoExecutorContext() {
+    return {
+      getVariable: (name) => this.getVariable(name),
+      createDataVisualization: (name, data, position) => this.createDataVisualization(name, data, position),
+      uiElements: this.uiElements,
+      on: (event, handler) => this.on(event, handler),
+      callFunction: (name) => this.callFunction(name)
+    };
+  }
+  /** Construct a GraphExecutorContext bound to this runtime. (Slice 20) */
+  buildGraphExecutorContext() {
+    return {
+      functions: this.context.functions,
+      connections: this.context.connections,
+      hologramState: this.context.hologramState,
+      spatialMemory: this.context.spatialMemory,
+      on: (event, handler) => this.on(event, handler),
+      emit: (event, data) => {
+        void this.emit(event, data);
+      },
+      getVariable: (name) => this.getVariable(name),
+      setVariable: (name, value) => this.setVariable(name, value),
+      createConnectionStream: (from, to, fromPos, toPos, dataType) => this.createConnectionStream(from, to, fromPos, toPos, dataType),
+      createFlowingStream: (name, position, data) => this.createFlowingStream(name, position, data),
+      getDataTypeColor: (dataType) => this.getDataTypeColor(dataType),
+      evaluateCondition: (expr) => this.evaluateCondition(expr),
+      executeProgram: (nodes, depth) => this.executeProgram(nodes, depth),
+      callStackDepth: () => this.callStack.length,
+      applyTransformation: (data, transform) => this.applyTransformation(data, transform)
+    };
+  }
+  /** Construct a UICommandContext bound to this runtime. (Slice 18) */
+  buildUICommandContext() {
+    return {
+      spatialMemory: this.context.spatialMemory,
+      animations: this.animations,
+      createParticleEffect: (name, position, color, count) => this.createParticleEffect(name, position, color, count),
+      createConnectionStream: (from, to, fromPos, toPos, dataType) => this.createConnectionStream(from, to, fromPos, toPos, dataType)
+    };
+  }
+  /** Construct a SimpleExecutorContext bound to this runtime. (Slice 17) */
+  buildSimpleExecutorContext() {
+    return {
+      stateMachines: this.context.stateMachines,
+      templates: this.context.templates,
+      getEnvironment: () => this.context.environment,
+      setEnvironment: (env) => {
+        this.context.environment = env;
+      },
+      focusHistory: this.context.focusHistory,
+      executionStackDepth: () => this.context.executionStack.length,
+      evaluateExpression: (expr) => this.evaluateExpression(expr),
+      callFunction: (name, args) => this.callFunction(name, args),
+      executeProgram: (nodes, depth) => this.executeProgram(nodes, depth),
+      setVariable: (name, value) => this.setVariable(name, value),
+      setScale: (multiplier, magnitude) => {
+        this.context.currentScale = multiplier;
+        this.context.scaleMagnitude = magnitude;
+      },
+      getScale: () => ({
+        multiplier: this.context.currentScale,
+        magnitude: this.context.scaleMagnitude
+      }),
+      emit: (event, data) => {
+        void this.emit(event, data);
+      }
+    };
+  }
+  /** Construct a NarrativeContext bound to this runtime's quest/dialogue state. */
+  buildNarrativeContext() {
+    return {
+      quests: this.context.quests,
+      setActiveQuestId: (id) => {
+        this.context.activeQuestId = id;
+      },
+      setDialogueState: (state) => {
+        this.context.dialogueState = state;
+      }
+    };
+  }
+  // W1-T4 slice 16: executeVisualMetadata / setupNetworking / setupPhysics
+  // extracted to ./runtime/system-executors.
+  async executeTemplate(node) {
+    const existing = this.context.templates.get(node.name);
+    if (existing) {
+      node._previousVersion = existing.version;
+    }
+    this.context.templates.set(node.name, node);
+    return {
+      success: true,
+      output: `Template ${node.name} registered (v${node.version || "unknown"})`
+    };
+  }
+  /**
+   * Execute a migration script for an object
+   */
+  async executeMigrationBlock(orb, migration) {
+    logger.info(`Running migration for ${orb.name}...`);
+    const previousScope = this.currentScope;
+    this.currentScope = {
+      variables: /* @__PURE__ */ new Map([
+        ["this", orb],
+        ["self", orb]
+      ]),
+      parent: previousScope
+    };
+    try {
+      const parser = new HoloScriptCodeParser();
+      const result = parser.parse(migration.body);
+      if (result.errors.length > 0) {
+        logger.error(`Migration parse errors for ${orb.name}:`, {
+          errors: result.errors
+        });
+        return;
+      }
+      await this.executeProgram(result.ast, 0);
+    } finally {
+      this.currentScope = previousScope;
+    }
+    logger.info(`Migration complete for ${orb.name}`);
+  }
+  // W1-T4 slice 32: server/database/fetch executors extracted to
+  // ./runtime/io-node-executors. Thin wrappers thread the public-mode
+  // gate + logger into an IoNodeContext and forward to pure functions.
+  async executeServerNode(node) {
+    return executeServerNode(node, this.buildIoNodeContext());
+  }
+  async executeDatabaseNode(node) {
+    return executeDatabaseNode(node, this.buildIoNodeContext());
+  }
+  async executeFetchNode(node) {
+    return executeFetchNode(node, this.buildIoNodeContext());
+  }
+  buildIoNodeContext() {
+    return {
+      isPublicMode: this.context.mode === "public",
+      logInfo: (msg) => {
+        logger.info(msg);
+      }
+    };
+  }
+  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 executeFunction(target, this.buildGraphExecutorContext());
+    this.createExecutionEffect(node.target, target.position || [0, 0, 0]);
+    return {
+      success: true,
+      output: `Executed ${node.target}`,
+      hologram: {
+        shape: "sphere",
+        color: "#ff4500",
+        size: 1.2,
+        glow: true,
+        interactive: false
+      },
+      executionTime: result.executionTime
+    };
+  }
+  // W1-T4 slice 33: executeStateDeclaration extracted to
+  // ./runtime/declaration-executors. Thin wrapper.
+  async executeStateDeclaration(node) {
+    return executeStateDeclaration(node, this.buildDeclarationContext());
+  }
+  // ============================================================================
+  // Memory Syntactic Execution (Phase 7 / EVOLVE)
+  // ============================================================================
+  async executeMemory(node) {
+    const startTime = Date.now();
+    logger.info(`[Memory] Initializing memory block: ${node.name}`);
+    const memoryState = {
+      id: node.name,
+      type: "agent-memory"
+    };
+    if (node.semantic) {
+      const semResult = await this.executeNode(node.semantic);
+      if (semResult.success) memoryState.semantic = semResult.output;
+    }
+    if (node.episodic) {
+      const epResult = await this.executeNode(node.episodic);
+      if (epResult.success) memoryState.episodic = epResult.output;
+    }
+    if (node.procedural) {
+      const procResult = await this.executeNode(node.procedural);
+      if (procResult.success) memoryState.procedural = procResult.output;
+    }
+    this.context.variables.set(node.name, memoryState);
+    this.emit("memory_initialized", { memoryId: node.name, config: memoryState });
+    return {
+      success: true,
+      output: memoryState,
+      executionTime: Date.now() - startTime
+    };
+  }
+  /**
+   * Load a procedural skill (W1-T4 slice 27: impl extracted to
+   * ./runtime/skills-directives). Kept as public wrapper so external
+   * callers still hit HSR's API surface.
+   */
+  loadSkill(skill) {
+    loadSkill(skill, {
+      proceduralSkills: this.proceduralSkills,
+      broadcastSkill: (s) => StateSynchronizer.getInstance().broadcastSkill(s)
+    });
+  }
+  async executeSkill(skillId, contextVariables = {}) {
+    const skill = this.proceduralSkills.get(skillId);
+    if (!skill) {
+      throw new Error(`[Procedural] Skill '${skillId}' not found.`);
+    }
+    logger.info(`[Procedural] Executing skill: ${skill.name}`);
+    const startTime = Date.now();
+    const previousScope = this.currentScope;
+    this.currentScope = { variables: new Map(previousScope.variables), parent: previousScope };
+    for (const [key, val] of Object.entries(contextVariables)) {
+      this.currentScope.variables.set(key, val);
+    }
+    try {
+      const result = await this.executeNode(skill.action);
+      if (result.success) {
+        skill.successRate = Math.min(100, skill.successRate + 1);
+      } else {
+        skill.successRate = Math.max(0, skill.successRate - 1);
+      }
+      StateSynchronizer.getInstance().broadcastSkill(skill);
+      return {
+        ...result,
+        executionTime: Date.now() - startTime
+      };
+    } finally {
+      this.currentScope = previousScope;
+    }
+  }
+  // W1-T4 slice 33: executeMemoryDefinition extracted to
+  // ./runtime/declaration-executors. Thin wrapper.
+  async executeMemoryDefinition(node) {
+    return executeMemoryDefinition(node, this.buildDeclarationContext());
+  }
+  buildDeclarationContext() {
+    return {
+      updateState: (body) => {
+        this.context.state.update(body);
+      },
+      evaluateExpression: (expr) => this.evaluateExpression(expr)
+    };
+  }
+  /**
+   * Walk orb directives applying trait / state / lifecycle handlers.
+   * (W1-T4 slice 27: impl extracted to ./runtime/skills-directives.)
+   */
+  applyDirectives(node) {
+    applyDirectives(node, {
+      traitHandlers: this.traitHandlers,
+      emit: (event, payload) => {
+        void this.emit(event, payload);
+      },
+      getCurrentScale: () => this.context.currentScale,
+      state: this.context.state,
+      evaluateExpression: (expr) => this.evaluateExpression(expr)
+    });
+  }
+  getExecutionHistory() {
+    return [...this.executionHistory];
+  }
+  getHologramStates() {
+    return new Map(this.context.hologramState);
+  }
+  getCallStack() {
+    return [...this.callStack];
+  }
+  getState() {
+    return this.context.state.getSnapshot();
+  }
+  getRootScope() {
+    return this.currentScope;
+  }
+  /**
+   * Predicate: is this orb an agent? (W1-T4 slice 27: extracted.)
+   */
+  isAgent(node) {
+    return isAgent(node);
+  }
+  /**
+   * Get current simulation time (Julian date) for orbital calculations
+   */
+  getSimulationTime() {
+    return this.timeManager?.getJulianDate() || 0;
+  }
+  /**
+   * Set orb position and broadcast update
+   */
+  setOrbPosition(orbName, position) {
+    const orb = this.context.variables.get(orbName);
+    if (orb && typeof orb === "object" && orb.__type === "orb") {
+      orb.position = position;
+      this.broadcast("orb_update", {
+        orb: {
+          id: orbName,
+          name: orbName,
+          position
+        }
+      });
+    }
+  }
+  /**
+   * Per-frame trait update — dispatches onUpdate on all active
+   * orbs (W1-T4 slice 27: impl extracted to ./runtime/skills-directives).
+   */
+  updateTraits(julianDate) {
+    updateTraits(julianDate, {
+      variables: this.context.variables,
+      traitHandlers: this.traitHandlers,
+      emit: (event, payload) => this.emit(event, payload),
+      getCurrentScale: () => this.context.currentScale,
+      setOrbPosition: (name, position) => this.setOrbPosition(name, position),
+      getState: () => this.getState(),
+      setState: (updates) => this.context.state.update(updates)
+    });
+  }
+};
+
+export { EventBus, HoloScriptAgentRuntime, HoloScriptRuntime, getSharedEventBus, setSharedEventBus, telemetry };
+//# sourceMappingURL=chunk-IHESJZSW.js.map
+//# sourceMappingURL=chunk-IHESJZSW.js.map