@almadar/runtime 3.1.0 → 3.1.2

package/dist/{chunk-HIM4HJAN.js → chunk-KCXJNXQZ.js}

@@ -403,12 +403,35 @@ function processEvent(options) {
     guardResult: transition.guard ? true : void 0
   };
 }
+var SINGLETON_SCOPE = "__singleton__";
+function scopeOf(entityData) {
+  const id = entityData && entityData["id"];
+  return id ?? SINGLETON_SCOPE;
+}
+function compositeKey(traitName, scope) {
+  return `${traitName}::${scope}`;
+}
 var StateMachineManager = class {
   traits = /* @__PURE__ */ new Map();
+  /**
+   * State map keyed by `${traitName}::${entityId | __singleton__}`.
+   *
+   * Each entity instance of an orbital gets its own copy of every
+   * trait's state machine. This is what enables N parallel subagents
+   * (one OrbitalProcess row per dispatched orbital) to all run their
+   * own Build/Validate/Fix cycle without colliding on shared trait
+   * state — the original cause of GAP-AGB-2.
+   *
+   * Initial state is created lazily on first event for each scope, so
+   * adding a trait does not pre-allocate state for every potential
+   * entity (and there's no need to know entity ids up front).
+   */
   states = /* @__PURE__ */ new Map();
   config;
   observer;
-  // Actor-model per-trait queues
+  // Actor-model queues, also keyed by `${traitName}::${entityId}` so
+  // each entity gets its own actor loop and concurrent subagents do
+  // not serialize through a shared queue.
   queues = /* @__PURE__ */ new Map();
   processing = /* @__PURE__ */ new Set();
   constructor(traits = [], config = {}, observer) {
@@ -431,33 +454,101 @@ var StateMachineManager = class {
    */
   addTrait(trait) {
     this.traits.set(trait.name, trait);
-    this.states.set(trait.name, createInitialTraitState(trait));
   }
   /**
    * Remove a trait from the manager.
    */
   removeTrait(traitName) {
     this.traits.delete(traitName);
-    this.states.delete(traitName);
+    const prefix = `${traitName}::`;
+    for (const key of [...this.states.keys()]) {
+      if (key.startsWith(prefix)) this.states.delete(key);
+    }
+    for (const key of [...this.queues.keys()]) {
+      if (key.startsWith(prefix)) this.queues.delete(key);
+    }
+    for (const key of [...this.processing]) {
+      if (key.startsWith(prefix)) this.processing.delete(key);
+    }
+  }
+  /**
+   * Get-or-init the state row for a (trait, entityId) pair.
+   * Returns undefined if the trait isn't registered.
+   */
+  getOrInitState(traitName, scope) {
+    const trait = this.traits.get(traitName);
+    if (!trait) return void 0;
+    const key = compositeKey(traitName, scope);
+    let state = this.states.get(key);
+    if (!state) {
+      state = createInitialTraitState(trait);
+      this.states.set(key, state);
+    }
+    return state;
   }
   /**
    * Get current state for a trait.
+   *
+   * For single-entity orbitals, omit `entityId` — returns the singleton
+   * scope. For multi-entity orbitals (e.g. agent OrbitalSubagent), pass
+   * the entity row id to look up that specific instance's state.
    */
-  getState(traitName) {
-    return this.states.get(traitName);
+  getState(traitName, entityId) {
+    const scope = entityId ?? SINGLETON_SCOPE;
+    const key = compositeKey(traitName, scope);
+    const existing = this.states.get(key);
+    if (existing) return existing;
+    return this.getOrInitState(traitName, scope);
   }
   /**
-   * Get all current states.
+   * Get a flat traitName→state map. For multi-entity orbitals this
+   * returns one entry per trait collapsed onto the singleton scope (or
+   * the first observed scope if singleton is empty). Use
+   * `getAllStatesByScope()` to get the full per-entity view.
    */
   getAllStates() {
-    return new Map(this.states);
+    const out = /* @__PURE__ */ new Map();
+    for (const traitName of this.traits.keys()) {
+      const singleton = this.states.get(compositeKey(traitName, SINGLETON_SCOPE));
+      if (singleton) {
+        out.set(traitName, singleton);
+        continue;
+      }
+      for (const [key, state] of this.states) {
+        if (key.startsWith(`${traitName}::`)) {
+          out.set(traitName, state);
+          break;
+        }
+      }
+    }
+    return out;
+  }
+  /**
+   * Get every per-entity state row, grouped by trait. Useful for
+   * inspecting parallel subagent state.
+   */
+  getAllStatesByScope() {
+    const grouped = /* @__PURE__ */ new Map();
+    for (const [key, state] of this.states) {
+      const sep = key.indexOf("::");
+      if (sep < 0) continue;
+      const traitName = key.slice(0, sep);
+      const scope = key.slice(sep + 2);
+      let bucket = grouped.get(traitName);
+      if (!bucket) {
+        bucket = /* @__PURE__ */ new Map();
+        grouped.set(traitName, bucket);
+      }
+      bucket.set(scope, state);
+    }
+    return grouped;
   }
   /**
    * Check if a trait can handle an event from its current state.
    */
-  canHandleEvent(traitName, eventKey) {
+  canHandleEvent(traitName, eventKey, entityId) {
     const trait = this.traits.get(traitName);
-    const state = this.states.get(traitName);
+    const state = this.getOrInitState(traitName, entityId ?? SINGLETON_SCOPE);
     if (!trait || !state) return false;
     return !!findTransition(trait, state.currentState, normalizeEventKey(eventKey));
   }
@@ -468,9 +559,11 @@ var StateMachineManager = class {
    */
   sendEvent(eventKey, payload, entityData) {
     const results = [];
+    const scope = scopeOf(entityData);
     for (const [traitName, trait] of this.traits) {
-      const traitState = this.states.get(traitName);
+      const traitState = this.getOrInitState(traitName, scope);
       if (!traitState) continue;
+      const key = compositeKey(traitName, scope);
       const result = processEvent({
         traitState,
         trait,
@@ -482,7 +575,7 @@ var StateMachineManager = class {
         contextExtensions: this.config.contextExtensions
       });
       if (result.executed) {
-        this.states.set(traitName, {
+        this.states.set(key, {
           ...traitState,
           currentState: result.newState,
           previousState: result.previousState,
@@ -516,31 +609,29 @@ var StateMachineManager = class {
    * at a time per trait, effects fully awaited before the next event).
    */
   enqueueEvent(eventKey, payload, entityData) {
+    const scope = scopeOf(entityData);
     for (const [traitName] of this.traits) {
-      const queue = this.queues.get(traitName) ?? [];
+      const key = compositeKey(traitName, scope);
+      const queue = this.queues.get(key) ?? [];
       queue.push({ eventKey, payload, entityData });
-      this.queues.set(traitName, queue);
+      this.queues.set(key, queue);
     }
   }
   /**
-   * Drain a single trait's event queue, processing events sequentially.
-   *
-   * This is the core actor loop: each event is fully processed (including
-   * awaiting all effects) before the next event is dequeued. If the queue
-   * is already being drained for this trait, this call is a no-op (the
-   * running drain will pick up newly enqueued events).
-   *
-   * @param traitName - Which trait's queue to drain
-   * @param executeEffects - Async callback to run effects for a successful transition
+   * Drain a single (trait, entity) pair's event queue, processing
+   * events sequentially. Pass `entityId` to drain a specific entity
+   * instance; omit it to drain the singleton scope.
    */
-  async drainQueue(traitName, executeEffects) {
-    if (this.processing.has(traitName)) return;
-    this.processing.add(traitName);
-    const queue = this.queues.get(traitName) ?? [];
+  async drainQueue(traitName, executeEffects, entityId) {
+    const scope = entityId ?? SINGLETON_SCOPE;
+    const key = compositeKey(traitName, scope);
+    if (this.processing.has(key)) return;
+    this.processing.add(key);
+    const queue = this.queues.get(key) ?? [];
     while (queue.length > 0) {
       const entry = queue.shift();
       const trait = this.traits.get(traitName);
-      const traitState = this.states.get(traitName);
+      const traitState = this.getOrInitState(traitName, scope);
       if (!trait || !traitState) continue;
       const result = processEvent({
         traitState,
@@ -553,7 +644,7 @@ var StateMachineManager = class {
         contextExtensions: this.config.contextExtensions
       });
       if (result.executed) {
-        this.states.set(traitName, {
+        this.states.set(key, {
           ...traitState,
           currentState: result.newState,
           previousState: result.previousState,
@@ -573,35 +664,51 @@ var StateMachineManager = class {
         await executeEffects(traitName, result, entry.payload);
       }
     }
-    this.processing.delete(traitName);
+    this.processing.delete(key);
   }
   /**
    * Check whether a trait's queue is currently being drained.
    */
-  isProcessing(traitName) {
-    return this.processing.has(traitName);
+  isProcessing(traitName, entityId) {
+    return this.processing.has(compositeKey(traitName, entityId ?? SINGLETON_SCOPE));
   }
   /**
    * Get the number of pending events in a trait's queue.
    */
-  getQueueLength(traitName) {
-    return this.queues.get(traitName)?.length ?? 0;
+  getQueueLength(traitName, entityId) {
+    return this.queues.get(compositeKey(traitName, entityId ?? SINGLETON_SCOPE))?.length ?? 0;
   }
   /**
    * Reset a trait to its initial state.
+   *
+   * If `entityId` is provided, resets only that entity's scope.
+   * Otherwise resets every entity scope known for the trait.
    */
-  resetTrait(traitName) {
+  resetTrait(traitName, entityId) {
     const trait = this.traits.get(traitName);
-    if (trait) {
-      this.states.set(traitName, createInitialTraitState(trait));
+    if (!trait) return;
+    if (entityId) {
+      this.states.set(compositeKey(traitName, entityId), createInitialTraitState(trait));
+      return;
+    }
+    const prefix = `${traitName}::`;
+    for (const key of [...this.states.keys()]) {
+      if (key.startsWith(prefix)) {
+        this.states.set(key, createInitialTraitState(trait));
+      }
     }
   }
   /**
-   * Reset all traits to initial states.
+   * Reset all traits to initial states (every entity scope).
    */
   resetAll() {
     for (const [traitName, trait] of this.traits) {
-      this.states.set(traitName, createInitialTraitState(trait));
+      const prefix = `${traitName}::`;
+      for (const key of [...this.states.keys()]) {
+        if (key.startsWith(prefix)) {
+          this.states.set(key, createInitialTraitState(trait));
+        }
+      }
     }
   }
 };
@@ -840,6 +947,10 @@ var EffectExecutor = class {
       case "set": {
         const [entityId, field, value] = args;
         this.handlers.set(entityId, field, value);
+        const entity = this.bindings.entity;
+        if (entity && entity["id"] === entityId) {
+          entity[field] = value;
+        }
         break;
       }
       case "persist": {
@@ -2393,5 +2504,5 @@ function parseNamespacedEvent(eventName) {
 }
 
 export { EffectExecutor, EventBus, HANDLER_MANIFEST, StateMachineManager, containsBindings, createContextFromBindings, createInitialTraitState, createTestExecutor, createUnifiedLoader, extractBindings, findInitialState, findTransition, getIsolatedCollectionName, getNamespacedEvent, interpolateProps, interpolateValue, isNamespacedEvent, normalizeEventKey, parseNamespacedEvent, preprocessSchema, processEvent };
-//# sourceMappingURL=chunk-HIM4HJAN.js.map
-//# sourceMappingURL=chunk-HIM4HJAN.js.map
+//# sourceMappingURL=chunk-KCXJNXQZ.js.map
+//# sourceMappingURL=chunk-KCXJNXQZ.js.map