@holoscript/engine 6.0.3 → 6.0.4

package/dist/chunk-2CSNRI2N.js

@@ -0,0 +1,217 @@
+// src/gpu/WebGPUContext.ts
+var WebGPUContext = class {
+  adapter = null;
+  device = null;
+  limits = null;
+  features = /* @__PURE__ */ new Set();
+  options;
+  initialized = false;
+  constructor(options = {}) {
+    this.options = {
+      powerPreference: options.powerPreference ?? "high-performance",
+      requiredFeatures: options.requiredFeatures ?? [],
+      requiredLimits: options.requiredLimits ?? {},
+      fallbackToCPU: options.fallbackToCPU ?? true
+    };
+  }
+  /**
+   * Initialize WebGPU context
+   *
+   * @returns Promise that resolves when initialization is complete
+   * @throws Error if WebGPU is not supported and fallbackToCPU is false
+   */
+  async initialize() {
+    if (this.initialized) {
+      console.warn("WebGPUContext already initialized");
+      return;
+    }
+    if (!("gpu" in navigator)) {
+      this.handleUnsupported("WebGPU not supported in this browser");
+      return;
+    }
+    try {
+      this.adapter = await navigator.gpu.requestAdapter({
+        powerPreference: this.options.powerPreference
+      });
+      if (!this.adapter) {
+        this.handleUnsupported("Failed to get WebGPU adapter");
+        return;
+      }
+      this.limits = this.adapter.limits;
+      this.features = new Set(this.adapter.features);
+      const missingFeatures = this.options.requiredFeatures.filter(
+        (feature) => !this.features.has(feature)
+      );
+      if (missingFeatures.length > 0) {
+        throw new Error(`Missing required WebGPU features: ${missingFeatures.join(", ")}`);
+      }
+      const deviceDescriptor = {
+        requiredFeatures: this.options.requiredFeatures,
+        requiredLimits: this.options.requiredLimits
+      };
+      this.device = await this.adapter.requestDevice(deviceDescriptor);
+      this.device.lost.then((info) => {
+        console.error("WebGPU device lost:", info.message, info.reason);
+        if (info.reason !== "destroyed") {
+          this.handleDeviceLost(info);
+        }
+      });
+      this.device.addEventListener("uncapturederror", (event) => {
+        console.error("WebGPU uncaptured error:", event.error);
+      });
+      this.initialized = true;
+    } catch (error) {
+      this.handleUnsupported(`WebGPU initialization failed: ${error}`);
+    }
+  }
+  /**
+   * Check if WebGPU is supported and initialized
+   */
+  isSupported() {
+    return this.initialized && this.device !== null;
+  }
+  /**
+   * Get WebGPU device
+   * @throws Error if device is not initialized
+   */
+  getDevice() {
+    if (!this.device) {
+      throw new Error("WebGPU device not initialized. Call initialize() first.");
+    }
+    return this.device;
+  }
+  /**
+   * Get WebGPU adapter
+   * @throws Error if adapter is not available
+   */
+  getAdapter() {
+    if (!this.adapter) {
+      throw new Error("WebGPU adapter not available");
+    }
+    return this.adapter;
+  }
+  /**
+   * Get device limits
+   */
+  getLimits() {
+    if (!this.limits) {
+      throw new Error("WebGPU limits not available");
+    }
+    return this.limits;
+  }
+  /**
+   * Get supported features
+   */
+  getFeatures() {
+    return this.features;
+  }
+  /**
+   * Check if a specific feature is supported
+   */
+  hasFeature(feature) {
+    return this.features.has(feature);
+  }
+  /**
+   * Get capabilities object
+   */
+  getCapabilities() {
+    return {
+      supported: this.isSupported(),
+      adapter: this.adapter,
+      device: this.device,
+      limits: this.limits,
+      features: this.features
+    };
+  }
+  /**
+   * Get optimal workgroup size for compute shaders
+   *
+   * Returns a workgroup size that maximizes occupancy based on device limits.
+   * Common values: 64, 128, 256 (must be power of 2)
+   */
+  getOptimalWorkgroupSize() {
+    if (!this.limits) return 256;
+    const maxInvocations = this.limits.maxComputeInvocationsPerWorkgroup;
+    if (maxInvocations >= 256) return 256;
+    if (maxInvocations >= 128) return 128;
+    if (maxInvocations >= 64) return 64;
+    return 32;
+  }
+  /**
+   * Cleanup resources
+   */
+  destroy() {
+    if (this.device) {
+      this.device.destroy();
+      this.device = null;
+    }
+    this.adapter = null;
+    this.limits = null;
+    this.features.clear();
+    this.initialized = false;
+  }
+  /**
+   * Handle unsupported browser/device
+   */
+  handleUnsupported(reason) {
+    console.warn(`\u26A0\uFE0F  ${reason}`);
+    if (!this.options.fallbackToCPU) {
+      throw new Error(`WebGPU required but not available: ${reason}`);
+    }
+    console.warn("\u{1F4A1} Falling back to CPU-based physics simulation");
+    this.initialized = false;
+  }
+  /**
+   * Handle device lost event
+   */
+  handleDeviceLost(_info) {
+    console.error("WebGPU device lost, attempting to recreate...");
+    this.initialized = false;
+    this.initialize().catch((error) => {
+      console.error("Failed to reinitialize WebGPU device:", error);
+      if (this.options.fallbackToCPU) {
+        console.warn("Falling back to CPU physics");
+      }
+    });
+  }
+  /**
+   * Detect and log GPU information (for debugging)
+   */
+  async logGPUInfo() {
+    if (!this.adapter) {
+      console.warn("No adapter available");
+      return;
+    }
+    const info = await this.adapter.requestAdapterInfo?.();
+    if (info) {
+      void info;
+    }
+  }
+};
+var globalContext = null;
+function getGlobalWebGPUContext(options) {
+  if (!globalContext) {
+    globalContext = new WebGPUContext(options);
+  }
+  return globalContext;
+}
+async function createPhysicsSimulation(options) {
+  if (options.preferGPU !== false) {
+    try {
+      const context = new WebGPUContext({ fallbackToCPU: true });
+      await context.initialize();
+      if (context.isSupported()) {
+        return { usingGPU: true, context };
+      }
+    } catch (error) {
+      console.warn("GPU initialization failed, using CPU fallback:", error);
+    }
+  }
+  return { usingGPU: false };
+}
+
+export {
+  WebGPUContext,
+  getGlobalWebGPUContext,
+  createPhysicsSimulation
+};

package/dist/chunk-33T2WINR.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: { x: 0, y: 0, z: 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
+};