@holoscript/engine 6.0.3 → 6.0.4

package/dist/chunk-SLTJRZ2N.js

@@ -0,0 +1,266 @@
+import {
+  __export
+} from "./chunk-AKLW2MUS.js";
+
+// src/vm-bridge/index.ts
+var vm_bridge_exports = {};
+__export(vm_bridge_exports, {
+  SpatialCognitiveAgent: () => SpatialCognitiveAgent,
+  applyActions: () => applyActions,
+  captureSceneSnapshot: () => captureSceneSnapshot
+});
+
+// src/vm-bridge/bridge.ts
+import { UAALOpCode, UAALCompiler } from "@holoscript/uaal";
+function captureSceneSnapshot(world) {
+  const entities = [];
+  for (const entity of world.getAllEntities()) {
+    const snapshot = {
+      id: entity.id,
+      name: entity.name,
+      parentId: entity.parentId,
+      childIds: [...entity.childIds],
+      traits: [...entity.traits]
+    };
+    const transform = world.getComponent(entity.id, 1);
+    if (transform) snapshot.transform = transform;
+    const geometry = world.getComponent(entity.id, 2);
+    if (geometry) snapshot.geometry = geometry;
+    const material = world.getComponent(entity.id, 3);
+    if (material) snapshot.material = material;
+    const rigidBody = world.getComponent(entity.id, 4);
+    if (rigidBody) snapshot.rigidBody = rigidBody;
+    entities.push(snapshot);
+  }
+  return {
+    entityCount: entities.length,
+    entities,
+    timestamp: Date.now()
+  };
+}
+function applyActions(world, actions) {
+  const spawnedIds = [];
+  for (const action of actions) {
+    switch (action.type) {
+      case "spawn": {
+        const id = world.spawn(action.name);
+        if (action.position) {
+          world.setComponent(id, 1, {
+            // ComponentType.Transform
+            position: action.position,
+            rotation: { x: 0, y: 0, z: 0, w: 1 },
+            scale: { x: 1, y: 1, z: 1 }
+          });
+        }
+        if (action.geometryType !== void 0) {
+          world.setComponent(id, 2, { type: action.geometryType, params: {} });
+        }
+        spawnedIds.push(id);
+        break;
+      }
+      case "despawn":
+        world.despawn(action.entityId);
+        break;
+      case "move": {
+        const existing = world.getComponent(action.entityId, 1);
+        const transform = existing ?? {
+          position: [0, 0, 0],
+          rotation: { x: 0, y: 0, z: 0, w: 1 },
+          scale: { x: 1, y: 1, z: 1 }
+        };
+        transform.position = action.position;
+        world.setComponent(action.entityId, 1, transform);
+        break;
+      }
+      case "setComponent":
+        world.setComponent(action.entityId, action.componentType, action.data);
+        break;
+      case "applyTrait": {
+        const entity = world.getEntity(action.entityId);
+        if (entity) {
+          entity.traits.add(action.traitId);
+          entity.dirty = true;
+        }
+        break;
+      }
+      case "removeTrait": {
+        const entity = world.getEntity(action.entityId);
+        if (entity) {
+          entity.traits.delete(action.traitId);
+          entity.dirty = true;
+        }
+        break;
+      }
+    }
+  }
+  return spawnedIds;
+}
+var SpatialCognitiveAgent = class {
+  world;
+  cognitiveVM;
+  compiler;
+  config;
+  lastCognitiveTickMs = -Infinity;
+  cognitiveIntervalMs;
+  pendingActions = [];
+  lastSnapshot = null;
+  tickCount = 0;
+  constructor(world, cognitiveVM, config = {}) {
+    this.world = world;
+    this.cognitiveVM = cognitiveVM;
+    this.compiler = new UAALCompiler();
+    this.config = {
+      cognitiveHz: config.cognitiveHz ?? 2,
+      enableLogging: config.enableLogging ?? false,
+      maxActionsPerTick: config.maxActionsPerTick ?? 50
+    };
+    this.cognitiveIntervalMs = 1e3 / this.config.cognitiveHz;
+    this.cognitiveVM.registerHandler(UAALOpCode.INTAKE, async (proxy) => {
+      const snapshot = this.perceive();
+      proxy.push(snapshot);
+    });
+    this.cognitiveVM.registerHandler(UAALOpCode.EXECUTE, async (proxy) => {
+      const actions = this.pendingActions.splice(0, this.config.maxActionsPerTick);
+      const spawned = this.mutate(actions);
+      proxy.push({
+        executed: true,
+        actionsApplied: actions.length,
+        spawnedIds: spawned
+      });
+    });
+    this.cognitiveVM.registerHandler(UAALOpCode.OP_EXECUTE_HOLOSCRIPT, async (proxy) => {
+      proxy.push(this.perceive());
+    });
+    this.cognitiveVM.registerHandler(
+      UAALOpCode.OP_SPATIAL_ANCHOR,
+      async (proxy, operands) => {
+        const name = operands?.[0] ?? "anchor";
+        const x = operands?.[1] ?? 0;
+        const y = operands?.[2] ?? 0;
+        const z = operands?.[3] ?? 0;
+        const id = this.world.spawn(name);
+        this.world.setComponent(id, 1, {
+          // ComponentType.Transform
+          position: { x, y, z },
+          rotation: { x: 0, y: 0, z: 0, w: 1 },
+          scale: { x: 1, y: 1, z: 1 }
+        });
+        proxy.push(id);
+      }
+    );
+    this.cognitiveVM.registerHandler(
+      UAALOpCode.OP_RENDER_HOLOGRAM,
+      async (proxy, operands) => {
+        const entityId = operands?.[0] ?? 0;
+        const geoType = operands?.[1] ?? 0;
+        const color = operands?.[2] ?? 65535;
+        this.world.setComponent(entityId, 2, { type: geoType, params: {} });
+        this.world.setComponent(entityId, 3, {
+          color,
+          metalness: 0.3,
+          roughness: 0.4,
+          emissive: 0,
+          opacity: 0.8
+        });
+        proxy.push({ rendered: true, entityId });
+      }
+    );
+    this.cognitiveVM.registerHandler(
+      UAALOpCode.OP_VR_TELEPORT,
+      async (proxy, operands) => {
+        const entityId = operands?.[0] ?? 0;
+        const x = operands?.[1] ?? 0;
+        const y = operands?.[2] ?? 0;
+        const z = operands?.[3] ?? 0;
+        this.world.setComponent(entityId, 1, {
+          // ComponentType.Transform
+          position: { x, y, z },
+          rotation: { x: 0, y: 0, z: 0, w: 1 },
+          scale: { x: 1, y: 1, z: 1 }
+        });
+        proxy.push({ teleported: true, entityId, position: { x, y, z } });
+      }
+    );
+    if (this.config.enableLogging) {
+      console.log(`[vm-bridge] Agent initialized (cognitive: ${this.config.cognitiveHz}Hz)`);
+    }
+  }
+  // ── Core API ──────────────────────────────────────────────────────────────
+  /**
+   * Snapshot the ECS world for agent perception
+   */
+  perceive() {
+    this.lastSnapshot = captureSceneSnapshot(this.world);
+    return this.lastSnapshot;
+  }
+  /**
+   * Run a cognitive cycle (7-phase) with the current scene as context
+   */
+  async decide(task) {
+    const bytecode = this.compiler.buildFullCycle(task);
+    const result = await this.cognitiveVM.execute(bytecode, {
+      task,
+      sceneEntityCount: this.world.entityCount,
+      timestamp: Date.now()
+    });
+    return result;
+  }
+  /**
+   * Apply agent actions to the ECS world
+   */
+  mutate(actions) {
+    return applyActions(this.world, actions);
+  }
+  /**
+   * Queue actions for the next cognitive tick
+   */
+  queueAction(action) {
+    this.pendingActions.push(action);
+  }
+  /**
+   * Queue multiple actions
+   */
+  queueActions(actions) {
+    this.pendingActions.push(...actions);
+  }
+  /**
+   * Main tick — called each frame. Runs cognitive cycle at configured frequency.
+   * Returns whether a cognitive tick was performed.
+   */
+  async tick(currentTimeMs) {
+    this.tickCount++;
+    const elapsed = currentTimeMs - this.lastCognitiveTickMs;
+    if (elapsed < this.cognitiveIntervalMs) {
+      return { perceived: false, decided: false, actionsApplied: 0 };
+    }
+    this.lastCognitiveTickMs = currentTimeMs;
+    const snapshot = this.perceive();
+    const cycleResult = await this.decide(`Tick ${this.tickCount}: observe and act`);
+    const actions = this.pendingActions.splice(0, this.config.maxActionsPerTick);
+    const _spawned = this.mutate(actions);
+    return {
+      perceived: true,
+      decided: true,
+      actionsApplied: actions.length,
+      sceneSnapshot: snapshot,
+      cycleResult
+    };
+  }
+  // ── Accessors ─────────────────────────────────────────────────────────────
+  getLastSnapshot() {
+    return this.lastSnapshot;
+  }
+  getPendingActionCount() {
+    return this.pendingActions.length;
+  }
+  getTickCount() {
+    return this.tickCount;
+  }
+};
+
+export {
+  captureSceneSnapshot,
+  applyActions,
+  SpatialCognitiveAgent,
+  vm_bridge_exports
+};