@holoscript/core 6.0.2 → 6.0.4

package/dist/{chunk-C2QHVHZF.js → chunk-LSW7P7ML.js}

@@ -1,13 +1,12 @@
-import { HoloScriptCodeParser } from './chunk-EPWRXL6S.js';
-import { mitosisHandler, orbitalHandler, WebSocketTransport } from './chunk-ENV7K6XA.js';
+import { HoloScriptCodeParser } from './chunk-BU7VWW2K.js';
+import { mitosisHandler, orbitalHandler } from './chunk-WGMEAYBG.js';
 import { logger } from './chunk-PHENW4MQ.js';
-import { __decorateClass } from './chunk-32TWR3HE.js';
+import { __decorateClass } from './chunk-2CWOLHTE.js';
 import { WebSocketServer, WebSocket } from 'ws';
 import { AttentionEngine, TimeManager } from '@holoscript/engine/orbital';
-import * as fs from 'fs';
-import * as path from 'path';
+import { StateSynchronizer } from '@holoscript/mesh';
 import { stateMachineInterpreter } from '@holoscript/engine/runtime/StateMachineInterpreter';
-import { MemoryConsolidator } from '@holoscript/framework';
+import { MemoryConsolidator } from '@holoscript/framework/learning';
 import { BaseVoiceSynthesizer } from '@holoscript/engine/runtime/BaseVoiceSynthesizer';
 import { registerVoiceSynthesizer } from '@holoscript/engine/runtime/VoiceSynthesizer';
 import { LocalEmotionDetector } from '@holoscript/engine/runtime/LocalEmotionDetector';
@@ -246,401 +245,6 @@ function setSharedEventBus(bus) {
   sharedBus = bus;
 }
 
-// src/network/PriorityScorer.ts
-var PriorityScorer = class {
-  /**
-   * Scores a raw delta based on simulated heuristics returning a priority class.
-   * Lower is more important.
-   */
-  static score(delta) {
-    let basePriority = 50;
-    if (delta.field === "x" || delta.field === "y" || delta.field === "z") {
-      basePriority -= 40;
-    }
-    if (delta.field === "health" || delta.field === "status") {
-      basePriority -= 50;
-    }
-    if (typeof delta.newValue === "string" && delta.newValue.length > 50) {
-      basePriority += 30;
-    }
-    basePriority = Math.max(0, Math.min(100, basePriority));
-    return {
-      ...delta,
-      priority: basePriority
-    };
-  }
-};
-
-// src/network/SpatialSharder.ts
-var SpatialSharder = class {
-  /**
-   * Maps an absolute position to a unique Shard ID string.
-   */
-  static getShardId(x, y, z) {
-    const sx = Math.floor(x / this.SHARD_SIZE);
-    const sy = Math.floor(y / this.SHARD_SIZE);
-    const sz = Math.floor(z / this.SHARD_SIZE);
-    return `shard_${sx}_${sy}_${sz}`;
-  }
-  /**
-   * Calculates all overlapping shards for a given bounding sphere or interaction radius.
-   */
-  static getOverlappingShards(x, y, z, radius) {
-    const shards = /* @__PURE__ */ new Set();
-    const minX = Math.floor((x - radius) / this.SHARD_SIZE);
-    const maxX = Math.floor((x + radius) / this.SHARD_SIZE);
-    const minY = Math.floor((y - radius) / this.SHARD_SIZE);
-    const maxY = Math.floor((y + radius) / this.SHARD_SIZE);
-    const minZ = Math.floor((z - radius) / this.SHARD_SIZE);
-    const maxZ = Math.floor((z + radius) / this.SHARD_SIZE);
-    for (let ix = minX; ix <= maxX; ix++) {
-      for (let iy = minY; iy <= maxY; iy++) {
-        for (let iz = minZ; iz <= maxZ; iz++) {
-          shards.add(`shard_${ix}_${iy}_${iz}`);
-        }
-      }
-    }
-    return Array.from(shards);
-  }
-};
-SpatialSharder.SHARD_SIZE = 100;
-var TransactionLog = class {
-  constructor(logPath) {
-    this.writeQueue = [];
-    this.isWriting = false;
-    this.sequenceId = 0;
-    this.logFile = logPath || path.resolve(process.cwd(), ".data", "state_transaction.wal");
-    const dir = path.dirname(this.logFile);
-    if (!fs.existsSync(dir)) {
-      fs.mkdirSync(dir, { recursive: true });
-    }
-  }
-  /**
-   * Appends an active delta directly to the offline WAL buffer.
-   */
-  append(delta) {
-    const stampedDelta = { ...delta, _seq: ++this.sequenceId };
-    this.writeQueue.push(stampedDelta);
-    this.flush();
-  }
-  async flush() {
-    if (this.isWriting || this.writeQueue.length === 0) return;
-    this.isWriting = true;
-    const toWrite = this.writeQueue.splice(0, this.writeQueue.length);
-    const dataStr = toWrite.map((d) => JSON.stringify(d)).join("\n") + "\n";
-    try {
-      await fs.promises.appendFile(this.logFile, dataStr, "utf-8");
-    } catch (error) {
-      this.writeQueue.unshift(...toWrite);
-    } finally {
-      this.isWriting = false;
-      if (this.writeQueue.length > 0) {
-        this.flush();
-      }
-    }
-  }
-  /**
-   * Recover the state strictly from the raw disk array.
-   */
-  async recover() {
-    if (!fs.existsSync(this.logFile)) {
-      return [];
-    }
-    try {
-      const data = await fs.promises.readFile(this.logFile, "utf-8");
-      const lines = data.split("\n").filter((l) => l.trim().length > 0);
-      const recoveredDeltas = lines.map((line) => {
-        const parsed = JSON.parse(line);
-        if (parsed._seq && parsed._seq > this.sequenceId) {
-          this.sequenceId = parsed._seq;
-        }
-        return parsed;
-      });
-      return recoveredDeltas;
-    } catch (error) {
-      return [];
-    }
-  }
-  async truncate() {
-    if (fs.existsSync(this.logFile)) {
-      await fs.promises.unlink(this.logFile);
-    }
-    this.sequenceId = 0;
-  }
-};
-
-// src/network/StateSynchronizer.ts
-var StateSynchronizer = class _StateSynchronizer {
-  constructor() {
-    // Subscriber maps bound by entity ID (who is interested in what)
-    this.globalSubscribers = /* @__PURE__ */ new Set();
-    this.subscriberOptions = /* @__PURE__ */ new Map();
-    this.entitySubscribers = /* @__PURE__ */ new Map();
-    // Spatial culling position tracking
-    this.entityPositions = /* @__PURE__ */ new Map();
-    this.entityShards = /* @__PURE__ */ new Map();
-    // Procedural Skill Syncer Mesh
-    this.skillSubscribers = /* @__PURE__ */ new Set();
-    // Adaptive Batching Metrics
-    this.pendingBatch = [];
-    this.batchTimer = null;
-    this.currentBatchWindowMs = 50;
-    // Persistent Storage (WAL)
-    this.wal = new TransactionLog();
-    // Active Transport Mesh
-    this.transport = null;
-    this.initializedMesh = false;
-  }
-  static getInstance() {
-    if (!_StateSynchronizer.instance) {
-      _StateSynchronizer.instance = new _StateSynchronizer();
-    }
-    return _StateSynchronizer.instance;
-  }
-  /**
-   * Bootstraps the local synchronization node over WebSockets.
-   */
-  initializeMesh() {
-    if (this.initializedMesh) return;
-    this.initializedMesh = true;
-    this.transport = new WebSocketTransport({
-      roomId: "local_actor",
-      serverUrl: "ws://127.0.0.1:8080"
-    });
-    this.transport.connect();
-    this.transport.onMessage("state-sync", (msg) => {
-      const payload = msg.payload;
-      if (payload && payload.agent_updates && Array.isArray(payload.agent_updates)) {
-        const inboundDeltas = [];
-        for (const update of payload.agent_updates) {
-          inboundDeltas.push({
-            entityId: update.id,
-            field: "x",
-            newValue: update.x,
-            oldValue: 0,
-            timestamp: payload.timestamp
-          });
-          inboundDeltas.push({
-            entityId: update.id,
-            field: "y",
-            newValue: update.y,
-            oldValue: 0,
-            timestamp: payload.timestamp
-          });
-          inboundDeltas.push({
-            entityId: update.id,
-            field: "z",
-            newValue: update.z,
-            oldValue: 0,
-            timestamp: payload.timestamp
-          });
-        }
-        if (inboundDeltas.length > 0) {
-          this.dispatchToSubscribers(inboundDeltas);
-        }
-      }
-    });
-  }
-  dispatchToSubscribers(deltas) {
-    const publicDeltasToDispatch = deltas.filter((delta) => {
-      const isPrivate = delta.field.includes("private_") || delta.field.includes("_secure");
-      return !isPrivate;
-    });
-    this.globalSubscribers.forEach((sub) => {
-      sub(publicDeltasToDispatch);
-    });
-    const entityGroups = /* @__PURE__ */ new Map();
-    for (const delta of deltas) {
-      let arr = entityGroups.get(delta.entityId);
-      if (!arr) {
-        arr = [];
-        entityGroups.set(delta.entityId, arr);
-      }
-      arr.push(delta);
-    }
-    for (const [entityId, entityDeltas] of entityGroups.entries()) {
-      const scopedListeners = this.entitySubscribers.get(entityId);
-      if (scopedListeners) {
-        scopedListeners.forEach((sub) => sub(entityDeltas));
-      }
-    }
-  }
-  /**
-   * Enqueue a burst of pre-computed deltas. Rather than instant transmission,
-   * they are loaded into an adaptive batch prioritized by the PriorityScorer.
-   */
-  broadcastDeltas(deltas) {
-    if (deltas.length === 0) return;
-    for (const delta of deltas) {
-      this.pendingBatch.push(PriorityScorer.score(delta));
-    }
-    if (!this.batchTimer) {
-      this.scheduleNextFlush();
-    }
-  }
-  scheduleNextFlush() {
-    if (this.pendingBatch.length > 500) {
-      this.currentBatchWindowMs = Math.min(200, this.currentBatchWindowMs + 10);
-    } else if (this.pendingBatch.length < 100) {
-      this.currentBatchWindowMs = Math.max(10, this.currentBatchWindowMs - 10);
-    }
-    this.batchTimer = setTimeout(() => this.flushDeltas(), this.currentBatchWindowMs);
-  }
-  flushDeltas() {
-    this.batchTimer = null;
-    if (this.pendingBatch.length === 0) return;
-    this.pendingBatch.sort((a, b) => a.priority - b.priority);
-    const deltasToDispatch = this.pendingBatch.splice(0, this.pendingBatch.length);
-    for (const delta of deltasToDispatch) {
-      if (delta.field === "x" || delta.field === "y" || delta.field === "z") {
-        let pos = this.entityPositions.get(delta.entityId);
-        if (!pos) {
-          pos = { x: 0, y: 0, z: 0 };
-          this.entityPositions.set(delta.entityId, pos);
-        }
-        pos[delta.field] = delta.newValue;
-        this.entityShards.set(delta.entityId, SpatialSharder.getShardId(pos.x, pos.y, pos.z));
-      }
-      this.wal.append(delta);
-    }
-    if (this.transport) {
-      this.transport.sendMessage({
-        type: "state-sync",
-        payload: {
-          deltas: deltasToDispatch.map((d) => ({
-            id: d.entityId,
-            field: d.field,
-            value: d.newValue,
-            time: d.timestamp
-          }))
-        }
-      });
-    }
-    const publicDeltasToDispatch = deltasToDispatch.filter((delta) => {
-      const isPrivate = delta.field.includes("private_") || delta.field.includes("_secure");
-      return !isPrivate;
-    });
-    this.globalSubscribers.forEach((sub) => {
-      const options = this.subscriberOptions.get(sub);
-      if (!options || !options.position || !options.interactionRadius) {
-        if (publicDeltasToDispatch.length > 0) sub(publicDeltasToDispatch);
-        return;
-      }
-      const targetShards = new Set(
-        SpatialSharder.getOverlappingShards(
-          options.position.x,
-          options.position.y,
-          options.position.z,
-          options.interactionRadius
-        )
-      );
-      const culledDeltas = publicDeltasToDispatch.filter((delta) => {
-        const entityPos = this.entityPositions.get(delta.entityId);
-        if (!entityPos) return true;
-        const entityShard = this.entityShards.get(delta.entityId);
-        if (entityShard && !targetShards.has(entityShard)) {
-          return false;
-        }
-        const dx = entityPos.x - options.position.x;
-        const dy = entityPos.y - options.position.y;
-        const dz = entityPos.z - options.position.z;
-        const distSq = dx * dx + dy * dy + dz * dz;
-        const r = options.interactionRadius;
-        return distSq <= r * r;
-      });
-      if (culledDeltas.length > 0) {
-        sub(culledDeltas);
-      }
-    });
-    const entityGroups = /* @__PURE__ */ new Map();
-    for (const delta of deltasToDispatch) {
-      let arr = entityGroups.get(delta.entityId);
-      if (!arr) {
-        arr = [];
-        entityGroups.set(delta.entityId, arr);
-      }
-      arr.push(delta);
-    }
-    for (const [entityId, entityDeltas] of entityGroups.entries()) {
-      const scopedListeners = this.entitySubscribers.get(entityId);
-      if (scopedListeners) {
-        scopedListeners.forEach((sub) => sub(entityDeltas));
-      }
-    }
-    if (this.pendingBatch.length > 0) {
-      this.scheduleNextFlush();
-    }
-  }
-  /**
-   * Subscribe to all global state deltas (e.g. Server sync bridges).
-   */
-  subscribeGlobal(callback, options) {
-    this.globalSubscribers.add(callback);
-    if (options) {
-      this.subscriberOptions.set(callback, options);
-    }
-    return () => {
-      this.globalSubscribers.delete(callback);
-      this.subscriberOptions.delete(callback);
-    };
-  }
-  /**
-   * Subscribe to targeted changes restricted strictly to a specific Entity.
-   */
-  subscribeEntity(entityId, callback) {
-    let scopedListeners = this.entitySubscribers.get(entityId);
-    if (!scopedListeners) {
-      scopedListeners = /* @__PURE__ */ new Set();
-      this.entitySubscribers.set(entityId, scopedListeners);
-    }
-    scopedListeners.add(callback);
-    return () => {
-      const listeners = this.entitySubscribers.get(entityId);
-      if (listeners) {
-        listeners.delete(callback);
-        if (listeners.size === 0) {
-          this.entitySubscribers.delete(entityId);
-        }
-      }
-    };
-  }
-  /**
-   * Broadcast a procedural skill mutation recursively so all agents merge success rates.
-   */
-  broadcastSkill(skill) {
-    this.skillSubscribers.forEach((sub) => sub(skill));
-  }
-  /**
-   * Listen globally for procedurally acquired skills bouncing across the instance.
-   */
-  subscribeSkills(callback) {
-    this.skillSubscribers.add(callback);
-    return () => this.skillSubscribers.delete(callback);
-  }
-  /**
-   * Recovery API reading `.wal` states sequentially mapping offline CRDT histories completely locally.
-   */
-  async recoverFromLog() {
-    const deltas = await this.wal.recover();
-    if (deltas.length > 0) {
-      for (const d of deltas) {
-        if (d.field === "x" || d.field === "y" || d.field === "z") {
-          let pos = this.entityPositions.get(d.entityId);
-          if (!pos) {
-            pos = { x: 0, y: 0, z: 0 };
-            this.entityPositions.set(d.entityId, pos);
-          }
-          pos[d.field] = d.newValue;
-        }
-      }
-    }
-    return deltas;
-  }
-  async clearLog() {
-    await this.wal.truncate();
-  }
-};
-
 // src/monitoring/telemetry.ts
 var TelemetryRegistry = class {
   constructor() {
@@ -1321,7 +925,7 @@ var HoloScriptRuntime = class {
     );
     builtins.set("wait", async (args) => {
       const ms = Number(args[0]) || 0;
-      await new Promise((resolve2) => setTimeout(resolve2, ms));
+      await new Promise((resolve) => setTimeout(resolve, ms));
       return { waited: ms };
     });
     builtins.set("print", (args) => {
@@ -1387,7 +991,7 @@ var HoloScriptRuntime = class {
     builtins.set("calculate_arc", (args) => this.handleCalculateArc(args));
     builtins.set(
       "sleep",
-      (args) => new Promise((resolve2) => setTimeout(resolve2, Number(args[0]) || 0))
+      (args) => new Promise((resolve) => setTimeout(resolve, Number(args[0]) || 0))
     );
     builtins.set("think", async (args) => {
       const activeNode = this.context.executionStack[this.context.executionStack.length - 1];
@@ -2049,10 +1653,10 @@ var HoloScriptRuntime = class {
   async executeGate(node) {
     try {
       const condition = this.evaluateCondition(node.condition);
-      const path2 = condition ? node.truePath : node.falsePath;
+      const path = condition ? node.truePath : node.falsePath;
       logger.info("Gate evaluation", { condition: node.condition, result: condition });
-      if (path2.length > 0) {
-        const subResults = await this.executeProgram(path2, this.callStack.length + 1);
+      if (path.length > 0) {
+        const subResults = await this.executeProgram(path, this.callStack.length + 1);
         const lastResult = subResults[subResults.length - 1];
         if (lastResult && lastResult.success && lastResult.output !== void 0) {
           return lastResult;
@@ -3432,9 +3036,9 @@ var HoloScriptRuntime = class {
       case "UpdateExpression": {
         const val = await this.evaluateHoloExpression(expr.argument, scopeOverride);
         const newVal = expr.operator === "++" ? val + 1 : val - 1;
-        const path2 = this.getMemberPath(expr.argument);
-        if (path2) {
-          this.setVariable(path2, newVal, scopeOverride);
+        const path = this.getMemberPath(expr.argument);
+        if (path) {
+          this.setVariable(path, newVal, scopeOverride);
         }
         return expr.prefix ? newVal : val;
       }
@@ -3762,7 +3366,9 @@ var HoloScriptRuntime = class {
       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 });
+        logger.error(`Migration parse errors for ${orb.name}:`, {
+          errors: result.errors
+        });
         return;
       }
       await this.executeProgram(result.ast, 0);
@@ -4036,7 +3642,10 @@ var HoloScriptRuntime = class {
                       if (event === "position_update") {
                         const posPayload = payload;
                         if (posPayload?.position) {
-                          this.setOrbPosition(name, posPayload.position);
+                          this.setOrbPosition(
+                            name,
+                            posPayload.position
+                          );
                         }
                       }
                       return this.emit(event, payload);
@@ -4061,6 +3670,6 @@ __decorateClass([
   MethodMemoize(500)
 ], HoloScriptRuntime.prototype, "getMemberPath", 1);
 
-export { EventBus, HoloScriptRuntime, PriorityScorer, SpatialSharder, StateSynchronizer, TransactionLog, getSharedEventBus, setSharedEventBus, telemetry };
-//# sourceMappingURL=chunk-C2QHVHZF.js.map
-//# sourceMappingURL=chunk-C2QHVHZF.js.map
+export { EventBus, HoloScriptRuntime, getSharedEventBus, setSharedEventBus, telemetry };
+//# sourceMappingURL=chunk-LSW7P7ML.js.map
+//# sourceMappingURL=chunk-LSW7P7ML.js.map