@almadar/runtime 6.29.0 → 6.30.0

package/dist/OrbitalServerRuntime.js

@@ -1,5 +1,5 @@
-import { createTickScheduler, EventBus, createUnifiedLoader, MockPersistenceAdapter, InMemoryPersistence, preprocessSchema, normalizeCallSiteConfigToValues, StateMachineManager, parseDurationString, createContextFromBindings, validateEventPayload, formatPayloadValidationError, collectDeclaredConfigDefaults, collectDeclaredEntityDefaults, EffectExecutor } from './chunk-6YDQGA6X.js';
-export { InMemoryPersistence, collectDeclaredConfigDefaults } from './chunk-6YDQGA6X.js';
+import { createTickScheduler, EventBus, createUnifiedLoader, MockPersistenceAdapter, InMemoryPersistence, preprocessSchema, normalizeCallSiteConfigToValues, StateMachineManager, parseDurationString, createContextFromBindings, validateEventPayload, formatPayloadValidationError, collectDeclaredConfigDefaults, collectDeclaredEntityDefaults, EffectExecutor } from './chunk-TGL6XC6E.js';
+export { InMemoryPersistence, collectDeclaredConfigDefaults } from './chunk-TGL6XC6E.js';
 import { isValidCronExpression } from './chunk-U4PL237A.js';
 import './chunk-PZ5AY32C.js';
 import { createLogger } from '@almadar/logger';
@@ -138,7 +138,7 @@ var OrbitalServerRuntime = class {
     if (!isNodeEnv()) return;
     if (!this.substrateHandlersPromise) {
       this.substrateHandlersPromise = (async () => {
-        const { createAgentSubstrateHandlers } = await import('./createAgentSubstrateHandlers-WZCHKGU6.js');
+        const { createAgentSubstrateHandlers } = await import('./createAgentSubstrateHandlers-RUX4RFC6.js');
         this.substrateHandlers = createAgentSubstrateHandlers({
           emitEvent: (type, payload) => this.eventBus.emit(type, payload),
           services: this.config.substrateServices ?? {}

package/dist/{chunk-6YDQGA6X.js → chunk-TGL6XC6E.js}

@@ -1008,6 +1008,7 @@ var HANDLER_MANIFEST = {
 };
 var effectLog = createLogger("almadar:runtime:effects");
 setNamespaceLevel("almadar:runtime:effects", "WARN");
+var persistLog = createLogger("almadar:runtime:persist");
 function parseEffect(effect) {
   if (!Array.isArray(effect) || effect.length === 0) {
     return null;
@@ -1312,6 +1313,35 @@ var EffectExecutor = class _EffectExecutor {
       failure: emit.failure
     };
   }
+  /**
+   * Run a substrate (async) effect and dispatch the author's `emit.success`
+   * / `emit.failure` bus event when configured. Mirrors the compiled-path
+   * generic substrate dispatch (server.rs): uniform `{ result }` payload on
+   * success, `{ error }` on failure.
+   *
+   * When no `emit` config is present (fire-and-forget call) the op still runs
+   * but no event is dispatched and errors propagate (legacy behavior).
+   */
+  async runSubstrate(invoke, emitCfg) {
+    if (!emitCfg) {
+      await invoke();
+      return;
+    }
+    try {
+      const result = await invoke();
+      this.emitSuccess(emitCfg, "success", { result: result ?? null });
+    } catch (err) {
+      this.emitFailure(emitCfg, err);
+    }
+  }
+  /**
+   * Separate a trailing `{ emit: {...} }` options object from positional
+   * substrate-op args. Returns `[positionalArgs, emitConfig]`.
+   */
+  splitSubstrateEmit(args) {
+    const emitCfg = args.length > 0 ? this.extractEmitConfig(args[args.length - 1]) : void 0;
+    return emitCfg ? [args.slice(0, -1), emitCfg] : [args, void 0];
+  }
   // ==========================================================================
   // Effect Dispatch
   // ==========================================================================
@@ -1375,14 +1405,14 @@ var EffectExecutor = class _EffectExecutor {
         const action = args[0];
         const last = args[args.length - 1];
         const emitCfg = last && typeof last === "object" && !Array.isArray(last) && "emit" in last ? this.extractEmitConfig(last) : void 0;
-        effectLog.debug("persist:dispatch", {
+        persistLog.debug("persist:dispatch", {
           action,
           argCount: args.length,
           argTypes: args.map((a) => Array.isArray(a) ? "array" : a === null ? "null" : typeof a).join(","),
           traitName: this.context.traitName,
           transition: this.context.transition
         });
-        effectLog.debug("persist:emit-config", {
+        persistLog.debug("persist:emit-config", {
           action,
           hasEmitCfg: emitCfg !== void 0,
           success: emitCfg?.success,
@@ -1392,30 +1422,30 @@ var EffectExecutor = class _EffectExecutor {
           if (action === "batch") {
             const operations = args[1];
             await this.handlers.persist("batch", "", { operations });
-            effectLog.debug("persist:success", {
+            persistLog.debug("persist:success", {
               action,
               entityType: "batch",
               opCount: operations.length,
               willEmit: emitCfg?.success
             });
             this.emitSuccess(emitCfg, "success", operations);
-            effectLog.debug("persist:emit-fired", { action, eventName: emitCfg?.success });
+            persistLog.debug("persist:emit-fired", { action, eventName: emitCfg?.success });
           } else {
             const entityType = args[1];
             const data = args[2];
             await this.handlers.persist(action, entityType, data);
             const dataId = typeof data === "string" ? data : data && typeof data === "object" ? data.id : void 0;
-            effectLog.debug("persist:success", {
+            persistLog.debug("persist:success", {
               action,
               entityType,
               dataId,
               willEmit: emitCfg?.success
             });
             this.emitSuccess(emitCfg, "success", data);
-            effectLog.debug("persist:emit-fired", { action, eventName: emitCfg?.success });
+            persistLog.debug("persist:emit-fired", { action, eventName: emitCfg?.success });
           }
         } catch (err) {
-          effectLog.error("persist:error", {
+          persistLog.error("persist:error", {
             action,
             entityType: action === "batch" ? "batch" : args[1],
             error: err instanceof Error ? err.message : String(err)
@@ -1823,80 +1853,106 @@ var EffectExecutor = class _EffectExecutor {
         break;
       }
       // === Agent substrate operators (server-side, effect-position) ===
+      //
+      // Each honours a trailing `{ emit: { success, failure } }` options
+      // object (mirrors fetch/persist/call-service): on success the
+      // author's `emit.success` event fires with a uniform `{ result }`
+      // payload so `?result` captures the return value; on failure the
+      // `emit.failure` event fires with `{ error }`. Without an emit
+      // config the call is fire-and-forget (legacy).
       case "compose/compose-all": {
-        if (this.handlers.substrateComposeAll) {
-          const config = args[0];
-          await this.handlers.substrateComposeAll(config);
-        } else {
-          this.logUnsupported("compose/compose-all");
-        }
+        const [positional, emitCfg] = this.splitSubstrateEmit(args);
+        const config = positional[0];
+        await this.runSubstrate(async () => {
+          if (!this.handlers.substrateComposeAll) {
+            this.logUnsupported("compose/compose-all");
+            return null;
+          }
+          return this.handlers.substrateComposeAll(config);
+        }, emitCfg);
         break;
       }
       case "compose/compose-children": {
-        if (this.handlers.substrateComposeChildren) {
-          const parentName = args[0];
-          const children = args[1];
-          await this.handlers.substrateComposeChildren(parentName, children);
-        } else {
-          this.logUnsupported("compose/compose-children");
-        }
+        const [positional, emitCfg] = this.splitSubstrateEmit(args);
+        const parentName = positional[0];
+        const children = positional[1];
+        await this.runSubstrate(async () => {
+          if (!this.handlers.substrateComposeChildren) {
+            this.logUnsupported("compose/compose-children");
+            return null;
+          }
+          return this.handlers.substrateComposeChildren(parentName, children);
+        }, emitCfg);
         break;
       }
       case "behavior/instantiate": {
-        if (this.handlers.substrateInstantiate) {
-          const parentName = args[0];
-          const behavior = args[1];
-          const params = args.length > 2 ? args[2] : void 0;
-          await this.handlers.substrateInstantiate(parentName, behavior, params);
-        } else {
-          this.logUnsupported("behavior/instantiate");
-        }
+        const [positional, emitCfg] = this.splitSubstrateEmit(args);
+        const parentName = positional[0];
+        const behavior = positional[1];
+        const params = positional.length > 2 ? positional[2] : void 0;
+        await this.runSubstrate(async () => {
+          if (!this.handlers.substrateInstantiate) {
+            this.logUnsupported("behavior/instantiate");
+            return null;
+          }
+          return this.handlers.substrateInstantiate(parentName, behavior, params);
+        }, emitCfg);
         break;
       }
       case "behavior/call": {
-        if (this.handlers.substrateCall) {
-          const behavior = args[0];
-          const method = args[1];
-          const params = args.length > 2 ? args[2] : void 0;
-          await this.handlers.substrateCall(behavior, method, params);
-        } else {
-          this.logUnsupported("behavior/call");
-        }
+        const [positional, emitCfg] = this.splitSubstrateEmit(args);
+        const behavior = positional[0];
+        const method = positional[1];
+        const params = positional.length > 2 ? positional[2] : void 0;
+        await this.runSubstrate(async () => {
+          if (!this.handlers.substrateCall) {
+            this.logUnsupported("behavior/call");
+            return null;
+          }
+          return this.handlers.substrateCall(behavior, method, params);
+        }, emitCfg);
         break;
       }
       case "validate/validate": {
-        if (this.handlers.substrateValidate) {
-          const orbitalName = args[0];
-          await this.handlers.substrateValidate(orbitalName);
-        } else {
-          this.logUnsupported("validate/validate");
-        }
+        const [positional, emitCfg] = this.splitSubstrateEmit(args);
+        const orbitalName = positional[0];
+        await this.runSubstrate(async () => {
+          if (!this.handlers.substrateValidate) {
+            this.logUnsupported("validate/validate");
+            return null;
+          }
+          return this.handlers.substrateValidate(orbitalName);
+        }, emitCfg);
         break;
       }
       case "lolo/emit-body": {
-        if (this.handlers.substrateEmitBody) {
-          const orbitalName = args[0];
-          const loloSource = args[1];
-          await this.handlers.substrateEmitBody(orbitalName, loloSource);
-        } else {
-          this.logUnsupported("lolo/emit-body");
-        }
+        const [positional, emitCfg] = this.splitSubstrateEmit(args);
+        const orbitalName = positional[0];
+        const loloSource = positional[1];
+        await this.runSubstrate(async () => {
+          if (!this.handlers.substrateEmitBody) {
+            this.logUnsupported("lolo/emit-body");
+            return null;
+          }
+          return this.handlers.substrateEmitBody(orbitalName, loloSource);
+        }, emitCfg);
         break;
       }
       default: {
         if (operator.includes("/")) {
-          const ctx = createContextFromBindings(
-            this.bindings,
-            this.strictBindings,
-            this.contextExtensions
-          );
-          const result = this.getEvaluator().evaluate(
-            [operator, ...args],
-            ctx
-          );
-          if (result instanceof Promise) {
-            await result;
-          }
+          const [positional, emitCfg] = this.splitSubstrateEmit(args);
+          await this.runSubstrate(async () => {
+            const ctx = createContextFromBindings(
+              this.bindings,
+              this.strictBindings,
+              this.contextExtensions
+            );
+            const result = this.getEvaluator().evaluate(
+              [operator, ...positional],
+              ctx
+            );
+            return result instanceof Promise ? await result : result;
+          }, emitCfg);
         } else if (this.debug) {
           effectLog.warn("unknown-operator", { operator });
         }
@@ -3997,5 +4053,5 @@ var InMemoryPersistence = class {
 };
 
 export { EffectExecutor, EventBus, HANDLER_MANIFEST, InMemoryPersistence, MockPersistenceAdapter, StateMachineManager, TickScheduler, buildEmitsFromTraits, collectDeclaredConfigDefaults, collectDeclaredEntityDefaults, containsBindings, createContextFromBindings, createInitialTraitState, createMockPersistence, createTestExecutor, createTickScheduler, createUnifiedLoader, extractBindings, findInitialState, findTransition, formatPayloadValidationError, getIsolatedCollectionName, getNamespacedEvent, interpolateProps, interpolateValue, isBrowser, isElectron, isNamespacedEvent, isNode, isValidDurationString, normalizeCallSiteConfigToValues, normalizeEventKey, parseDurationString, parseNamespacedEvent, preprocessSchema, processEvent, validateEventPayload, validatePayloadShapes };
-//# sourceMappingURL=chunk-6YDQGA6X.js.map
-//# sourceMappingURL=chunk-6YDQGA6X.js.map
+//# sourceMappingURL=chunk-TGL6XC6E.js.map
+//# sourceMappingURL=chunk-TGL6XC6E.js.map