arvo-event-handler 3.0.23 → 3.0.26

package/dist/ArvoMachine/createMachine.d.ts

@@ -3,6 +3,7 @@ import { type ActionFunction, type MachineConfig, type MachineContext, type Meta
 import type { z } from 'zod';
 import ArvoMachine from '.';
 import type { EnqueueArvoEventActionParam, ExtractOrchestratorType, InferServiceContract, ToParameterizedObject, ToProvidedActor } from './types';
+import { NonEmptyArray } from '../types';
 /**
  * Establishes the foundation for creating Arvo-compatible state machines.
  *
@@ -133,20 +134,27 @@ export declare function setupArvoMachine<TContext extends MachineContext, TSelfC
     }>, ToParameterizedObject<TGuards>, never, TTag, InferVersionedArvoContract<TSelfContract>["accepts"], z.input<TSelfContract["emits"][ReturnType<typeof ArvoOrchestratorEventTypeGen.complete<ExtractOrchestratorType<TSelfContract["accepts"]["type"]>>>]> & {
         __id?: CreateArvoEvent<Record<string, unknown>, string>["id"];
         __executionunits?: CreateArvoEvent<Record<string, unknown>, string>["executionunits"];
+        __domain?: NonEmptyArray<string | null>;
     }, InferServiceContract<TServiceContracts>["emitted"], TMeta>>(config: TConfig & {
         id: string;
         version?: TSelfContract["version"];
-    }) => ArvoMachine<string, TSelfContract["version"], TSelfContract, TServiceContracts, import("xstate").StateMachine<TContext, { [K in keyof TServiceContracts]: import("./types").InferEmittableEventsFromVersionedArvoContract<TServiceContracts[K]>; }[keyof TServiceContracts], {}, never, import("xstate").IsNever<TActions & {
+    }) => ArvoMachine<string, TSelfContract["version"], TSelfContract, TServiceContracts, import("xstate").StateMachine<TContext, { [K in keyof TServiceContracts]: import("./types").InferEmittableEventsFromVersionedArvoContract<TServiceContracts[K]>; }[keyof TServiceContracts], {}, never, (TActions & {
         enqueueArvoEvent: EnqueueArvoEventActionParam;
-    }> extends true ? never : import("xstate").Values<{ [K_1 in (keyof TActions & string) | "enqueueArvoEvent"]: {
-        type: K_1;
-        params: (TActions & {
-            enqueueArvoEvent: EnqueueArvoEventActionParam;
-        })[K_1];
-    }; }>, import("xstate").IsNever<TGuards> extends true ? never : import("xstate").Values<{ [K_2 in keyof TGuards & string]: {
-        type: K_2;
+    } extends infer T extends Record<string, import("xstate").NonReducibleUnknown> ? { [K_1 in keyof T as K_1 & string]: {
+        type: K_1 & string;
+        params: T[K_1];
+    }; } : never)[keyof (TActions & {
+        enqueueArvoEvent: EnqueueArvoEventActionParam;
+    } extends infer T_1 extends Record<string, import("xstate").NonReducibleUnknown> ? { [K_1 in keyof T_1 as K_1 & string]: {
+        type: K_1 & string;
+        params: T_1[K_1];
+    }; } : never)], { [K_2 in keyof TGuards as K_2 & string]: {
+        type: K_2 & string;
+        params: TGuards[K_2];
+    }; }[keyof { [K_2 in keyof TGuards as K_2 & string]: {
+        type: K_2 & string;
         params: TGuards[K_2];
-    }; }>, never, {} | {
+    }; }], never, {} | {
         [x: string]: {} | /*elided*/ any | {
             [x: string]: {} | /*elided*/ any | /*elided*/ any;
         };
@@ -154,5 +162,8 @@ export declare function setupArvoMachine<TContext extends MachineContext, TSelfC
         [x: string]: {} | {
             [x: string]: {} | /*elided*/ any | /*elided*/ any;
         } | /*elided*/ any;
-    }, TTag, TSelfContract["accepts"]["schema"]["_output"], { [K_3 in string & keyof TSelfContract["emits"]]: import("arvo-core").InferArvoEvent<import("arvo-core").ArvoEvent<TSelfContract["emits"][K_3]["_output"], Record<string, any>, K_3>>; }[`arvo.orc.${ExtractOrchestratorType<TSelfContract["accepts"]["type"]>}.done`]["data"], { [K_4 in keyof TServiceContracts]: EnqueueArvoEventActionParam<z.input<TServiceContracts[K_4]["accepts"]["schema"]>, TServiceContracts[K_4]["accepts"]["type"], Record<string, string | number | boolean | null>>; }[keyof TServiceContracts], TMeta, any>>;
+    }, TTag, TSelfContract["accepts"]["schema"]["_output"], { [K_3 in string & keyof TSelfContract["emits"]]: import("arvo-core").InferArvoEvent<import("arvo-core").ArvoEvent<TSelfContract["emits"][K_3]["_output"], Record<string, any>, K_3>>; }[`arvo.orc.${ExtractOrchestratorType<TSelfContract["accepts"]["type"]>}.done`]["data"], { [K_4 in keyof TServiceContracts]: EnqueueArvoEventActionParam<z.input<TServiceContracts[K_4]["accepts"]["schema"]>, TServiceContracts[K_4]["accepts"]["type"], Record<string, string | number | boolean | null>>; }[keyof TServiceContracts], TMeta, {
+        id: any;
+        states: any;
+    }>>;
 };

package/dist/ArvoMachine/types.d.ts

@@ -1,6 +1,7 @@
 import type { ArvoContract, ArvoEventData, ArvoOrchestratorEventTypeGen, ArvoSemanticVersion, CloudEventExtension, CreateArvoEvent, InferVersionedArvoContract, VersionedArvoContract } from 'arvo-core';
 import type { Invert, IsNever, ParameterizedObject, UnknownActorLogic, Values } from 'xstate';
 import type { z } from 'zod';
+import { NonEmptyArray } from '../types';
 /**
  * Represents an extended context for Arvo XState machines, including additional properties
  * for volatile and internal data.
@@ -34,7 +35,7 @@ export type EnqueueArvoEventActionParam<TData extends ArvoEventData = ArvoEventD
     /**
      * The domain configuration for multi-domain event broadcasting.
      */
-    domain?: (string | null)[];
+    domain?: NonEmptyArray<string | null>;
     /**
      * Custom extensions for the CloudEvent.
      * Allows for additional metadata to be attached to the event.

package/dist/ArvoOrchestrationUtils/createEmitableEvent.js

@@ -39,6 +39,8 @@ var createEmittableEvent = function (_a, span) {
     var parentId = sourceEvent.id;
     var domain = (0, ArvoDomain_1.resolveEventDomain)({
         domainToResolve: _domain,
+        parentSubject: orchestrationParentSubject,
+        currentSubject: sourceEvent.subject,
         handlerSelfContract: selfContract,
         eventContract: null,
         triggeringEvent: sourceEvent,
@@ -54,6 +56,8 @@ var createEmittableEvent = function (_a, span) {
         parentId = initEventId;
         domain = (0, ArvoDomain_1.resolveEventDomain)({
             domainToResolve: _domain,
+            parentSubject: orchestrationParentSubject,
+            currentSubject: sourceEvent.subject,
             handlerSelfContract: selfContract,
             eventContract: selfContract,
             triggeringEvent: sourceEvent,
@@ -68,6 +72,8 @@ var createEmittableEvent = function (_a, span) {
         schema = serviceContractMap[event.type].accepts.schema;
         domain = (0, ArvoDomain_1.resolveEventDomain)({
             domainToResolve: _domain,
+            parentSubject: orchestrationParentSubject,
+            currentSubject: sourceEvent.subject,
             handlerSelfContract: selfContract,
             eventContract: contract,
             triggeringEvent: sourceEvent,

package/dist/ArvoOrchestrationUtils/handlerErrors.d.ts

@@ -3,6 +3,7 @@ import { type ArvoContract, type ArvoEvent, type ArvoSemanticVersion, type OpenT
 import type { SyncEventResource } from '../SyncEventResource';
 import type { OrchestrationExecutionMemoryRecord } from './orchestrationExecutionState';
 import { type ArvoOrchestrationHandlerType } from './types';
+import type { NonEmptyArray } from '../types';
 /**
  * Parameters for creating system error events during orchestration failures.
  */
@@ -20,13 +21,11 @@ export type CreateSystemErrorEventsParams = {
     /** Self contract defining error schema */
     selfContract: VersionedArvoContract<ArvoContract, ArvoSemanticVersion>;
     /** Optional domains for error event routing */
-    systemErrorDomain?: (string | null)[];
+    systemErrorDomain: NonEmptyArray<string | null>;
     /** Execution units for error events */
     executionunits: number;
     /** Source identifier */
     source: string;
-    /** Domain for error events */
-    domain: string | null;
     /** Type of handler reporting the error */
     handlerType: ArvoOrchestrationHandlerType;
 };
@@ -40,7 +39,7 @@ export type CreateSystemErrorEventsParams = {
  * @param params - Error event creation parameters
  * @returns Array of system error events for each configured domain
  */
-export declare const createSystemErrorEvents: ({ error, event, otelHeaders, orchestrationParentSubject: _orchestrationParentSubject, initEventId, selfContract, systemErrorDomain, executionunits, source, domain, handlerType, }: CreateSystemErrorEventsParams & {
+export declare const createSystemErrorEvents: ({ error, event, otelHeaders, orchestrationParentSubject: _orchestrationParentSubject, initEventId, selfContract, systemErrorDomain, executionunits, source, handlerType, }: CreateSystemErrorEventsParams & {
     error: Error;
 }) => ArvoEvent[];
 /**

package/dist/ArvoOrchestrationUtils/handlerErrors.js

@@ -66,7 +66,7 @@ var types_1 = require("./types");
  */
 var createSystemErrorEvents = function (_a) {
     var _b, _c, _d, _e, _f;
-    var error = _a.error, event = _a.event, otelHeaders = _a.otelHeaders, _orchestrationParentSubject = _a.orchestrationParentSubject, initEventId = _a.initEventId, selfContract = _a.selfContract, systemErrorDomain = _a.systemErrorDomain, executionunits = _a.executionunits, source = _a.source, domain = _a.domain, handlerType = _a.handlerType;
+    var error = _a.error, event = _a.event, otelHeaders = _a.otelHeaders, _orchestrationParentSubject = _a.orchestrationParentSubject, initEventId = _a.initEventId, selfContract = _a.selfContract, systemErrorDomain = _a.systemErrorDomain, executionunits = _a.executionunits, source = _a.source, handlerType = _a.handlerType;
     // In case of none transaction errors like errors from
     // the machine or the event creation etc, the are workflow
     // error and shuold be handled by the workflow. Then are
@@ -86,18 +86,18 @@ var createSystemErrorEvents = function (_a) {
             });
         }
     }
-    var domainSets = new Set((systemErrorDomain === null || systemErrorDomain === void 0 ? void 0 : systemErrorDomain.length)
-        ? systemErrorDomain.map(function (item) {
-            return (0, ArvoDomain_1.resolveEventDomain)({
-                domainToResolve: item,
-                handlerSelfContract: selfContract,
-                eventContract: selfContract,
-                triggeringEvent: event,
-            });
-        })
-        : [event.domain, domain, null]);
+    var domainSets = systemErrorDomain.map(function (item) {
+        return (0, ArvoDomain_1.resolveEventDomain)({
+            parentSubject: orchestrationParentSubject,
+            currentSubject: event.subject,
+            domainToResolve: item,
+            handlerSelfContract: selfContract,
+            eventContract: selfContract,
+            triggeringEvent: event,
+        });
+    });
     var result = [];
-    for (var _i = 0, _g = Array.from(domainSets); _i < _g.length; _i++) {
+    for (var _i = 0, _g = Array.from(new Set(domainSets)); _i < _g.length; _i++) {
         var _dom = _g[_i];
         var factoryBuilder = handlerType === 'handler' ? arvo_core_1.createArvoEventFactory : arvo_core_1.createArvoOrchestratorEventFactory;
         result.push(factoryBuilder(selfContract).systemError({

package/dist/ArvoOrchestrationUtils/orchestrationExecutionWrapper/index.d.ts

@@ -2,7 +2,7 @@ import { type Span } from '@opentelemetry/api';
 import { type ArvoEvent, type ArvoOrchestrationSubjectContent, type ArvoOrchestratorContract, type ArvoSemanticVersion, type OpenTelemetryHeaders, type VersionedArvoContract } from 'arvo-core';
 import type IArvoEventHandler from '../../IArvoEventHandler';
 import type { SyncEventResource } from '../../SyncEventResource';
-import type { ArvoEventHandlerOpenTelemetryOptions, ArvoEventHandlerOtelSpanOptions } from '../../types';
+import type { ArvoEventHandlerOpenTelemetryOptions, ArvoEventHandlerOtelSpanOptions, NonEmptyArray } from '../../types';
 import type { OrchestrationExecutionMemoryRecord } from '../orchestrationExecutionState';
 import type { ArvoOrchestrationHandlerType } from '../types';
 /**
@@ -21,11 +21,9 @@ export type OrchestrationExecutionContext<TState extends OrchestrationExecutionM
     /** Maximum execution units per cycle */
     executionunits: number;
     /** Optional domains for system error routing */
-    systemErrorDomain?: (string | null)[];
+    systemErrorDomain: NonEmptyArray<string | null>;
     /** Self contract defining orchestrator interface */
     selfContract: VersionedArvoContract<ArvoOrchestratorContract, ArvoSemanticVersion>;
-    /** Domain for event routing */
-    domain: string | null;
     /** Type of orchestration handler */
     _handlerType: ArvoOrchestrationHandlerType;
     /** OpenTelemetry span configuration */
@@ -78,4 +76,4 @@ export declare const returnEventsWithLogging: (param: Awaited<ReturnType<IArvoEv
  * while allowing custom core logic via the execution function parameter.
  * @returns Emitted events from successful execution or error handling
  */
-export declare const executeWithOrchestrationWrapper: <TState extends OrchestrationExecutionMemoryRecord<Record<string, any>>>({ event, opentelemetry, spanOptions, source, syncEventResource, executionunits, systemErrorDomain, selfContract, domain, _handlerType, }: OrchestrationExecutionContext<TState>, coreExecutionFn: CoreExecutionFn<TState>) => Promise<Awaited<ReturnType<IArvoEventHandler["execute"]>>>;
+export declare const executeWithOrchestrationWrapper: <TState extends OrchestrationExecutionMemoryRecord<Record<string, any>>>({ event, opentelemetry, spanOptions, source, syncEventResource, executionunits, systemErrorDomain, selfContract, _handlerType, }: OrchestrationExecutionContext<TState>, coreExecutionFn: CoreExecutionFn<TState>) => Promise<Awaited<ReturnType<IArvoEventHandler["execute"]>>>;

package/dist/ArvoOrchestrationUtils/orchestrationExecutionWrapper/index.js

@@ -84,7 +84,7 @@ exports.returnEventsWithLogging = returnEventsWithLogging;
  */
 var executeWithOrchestrationWrapper = function (_a, coreExecutionFn_1) { return __awaiter(void 0, [_a, coreExecutionFn_1], void 0, function (_b, coreExecutionFn) {
     var otelConfig;
-    var event = _b.event, opentelemetry = _b.opentelemetry, spanOptions = _b.spanOptions, source = _b.source, syncEventResource = _b.syncEventResource, executionunits = _b.executionunits, systemErrorDomain = _b.systemErrorDomain, selfContract = _b.selfContract, domain = _b.domain, _handlerType = _b._handlerType;
+    var event = _b.event, opentelemetry = _b.opentelemetry, spanOptions = _b.spanOptions, source = _b.source, syncEventResource = _b.syncEventResource, executionunits = _b.executionunits, systemErrorDomain = _b.systemErrorDomain, selfContract = _b.selfContract, _handlerType = _b._handlerType;
     return __generator(this, function (_c) {
         switch (_c.label) {
             case 0:
@@ -206,7 +206,6 @@ var executeWithOrchestrationWrapper = function (_a, coreExecutionFn_1) { return
                                                 systemErrorDomain: systemErrorDomain,
                                                 executionunits: executionunits,
                                                 source: source,
-                                                domain: domain,
                                                 syncEventResource: syncEventResource,
                                                 handlerType: _handlerType,
                                             }, span)];

package/dist/ArvoOrchestrator/factory.d.ts

@@ -18,7 +18,6 @@ import type { CreateArvoOrchestratorParam } from './types';
  * ```typescript
  * const orchestrator = createArvoOrchestrator({
  *   memory: new SimpleMachineMemory(),
- *   executionunits: 1,
  *   machines: [userOnboardingMachine, paymentMachine]
  * });
  *
@@ -29,4 +28,4 @@ import type { CreateArvoOrchestratorParam } from './types';
  * @see {@link setupArvoMachine} for creating machine definitions
  * @see {@link ArvoOrchestrator} for direct instantiation with custom components
  */
-export declare const createArvoOrchestrator: ({ executionunits, memory, machines, systemErrorDomain, spanOptions, requiresResourceLocking: _locking, }: CreateArvoOrchestratorParam) => ArvoOrchestrator;
+export declare const createArvoOrchestrator: ({ executionunits, memory, machines, defaultEventEmissionDomains, spanOptions, requiresResourceLocking: _locking, }: CreateArvoOrchestratorParam) => ArvoOrchestrator;

package/dist/ArvoOrchestrator/factory.js

@@ -32,7 +32,6 @@ var errors_1 = require("../errors");
  * ```typescript
  * const orchestrator = createArvoOrchestrator({
  *   memory: new SimpleMachineMemory(),
- *   executionunits: 1,
  *   machines: [userOnboardingMachine, paymentMachine]
  * });
  *
@@ -44,23 +43,23 @@ var errors_1 = require("../errors");
  * @see {@link ArvoOrchestrator} for direct instantiation with custom components
  */
 var createArvoOrchestrator = function (_a) {
-    var executionunits = _a.executionunits, memory = _a.memory, machines = _a.machines, systemErrorDomain = _a.systemErrorDomain, spanOptions = _a.spanOptions, _locking = _a.requiresResourceLocking;
+    var executionunits = _a.executionunits, memory = _a.memory, machines = _a.machines, defaultEventEmissionDomains = _a.defaultEventEmissionDomains, spanOptions = _a.spanOptions, _locking = _a.requiresResourceLocking;
     if (!(machines === null || machines === void 0 ? void 0 : machines.length)) {
         throw new Error('At least one machine must be provided');
     }
     var registry = new (MachineRegistry_1.MachineRegistry.bind.apply(MachineRegistry_1.MachineRegistry, __spreadArray([void 0], machines, false)))();
     var requiresResourceLocking = _locking !== null && _locking !== void 0 ? _locking : machines.some(function (machine) { return machine.requiresResourceLocking; });
     var representativeMachine = registry.machines[0];
-    var lastSeenVersions = [];
+    var lastSeenVersions = new Set();
     for (var _i = 0, _b = registry.machines; _i < _b.length; _i++) {
         var machine = _b[_i];
         if (representativeMachine.source !== machine.source) {
-            throw new errors_1.ConfigViolation("All the machines in the orchestrator must have type '".concat(representativeMachine.source, "'"));
+            throw new errors_1.ConfigViolation("All the machines in the orchestrator must have source '".concat(representativeMachine.source, "'. Make sure all machine are implementing versions of the same self contract"));
         }
-        if (lastSeenVersions.includes(machine.version)) {
+        if (lastSeenVersions.has(machine.version)) {
             throw new errors_1.ConfigViolation("An orchestrator must have unique machine versions. Machine ID:".concat(machine.id, " has duplicate version ").concat(machine.version, "."));
         }
-        lastSeenVersions.push(machine.version);
+        lastSeenVersions.add(machine.version);
     }
     return new _1.ArvoOrchestrator({
         executionunits: executionunits,
@@ -68,7 +67,7 @@ var createArvoOrchestrator = function (_a) {
         registry: registry,
         executionEngine: new MachineExecutionEngine_1.MachineExecutionEngine(),
         requiresResourceLocking: requiresResourceLocking,
-        systemErrorDomain: systemErrorDomain,
+        defaultEventEmissionDomains: defaultEventEmissionDomains,
         spanOptions: spanOptions,
     });
 };

package/dist/ArvoOrchestrator/index.d.ts

@@ -22,8 +22,8 @@ export declare class ArvoOrchestrator implements IArvoEventHandler {
     readonly executionEngine: IMachineExectionEngine;
     /** Resource manager for state synchronization and memory access */
     readonly syncEventResource: SyncEventResource<MachineMemoryRecord>;
-    /** Optional domains for routing system error events */
-    readonly systemErrorDomain?: (string | null)[];
+    /** Domains for routing events */
+    readonly defaultEventEmissionDomains: Required<NonNullable<ArvoOrchestratorParam['defaultEventEmissionDomains']>>;
     /** OpenTelemetry span configuration for observability */
     readonly spanOptions: ArvoEventHandlerOtelSpanOptions;
     /** Source identifier from the first registered machine */
@@ -34,7 +34,7 @@ export declare class ArvoOrchestrator implements IArvoEventHandler {
     get memory(): IMachineMemory<MachineMemoryRecord>;
     /** The contract-defined domain for the handler */
     get domain(): string | null;
-    constructor({ executionunits, memory, registry, executionEngine, requiresResourceLocking, systemErrorDomain, spanOptions, }: ArvoOrchestratorParam);
+    constructor({ executionunits, memory, registry, executionEngine, requiresResourceLocking, defaultEventEmissionDomains, spanOptions, }: ArvoOrchestratorParam);
     /**
      * Executes state machine orchestration for an incoming event.
      *
@@ -76,6 +76,5 @@ export declare class ArvoOrchestrator implements IArvoEventHandler {
             errorMessage: string;
             errorStack: string | null;
         }>;
-        domain: (string | null)[] | undefined;
     };
 }

package/dist/ArvoOrchestrator/index.js

@@ -65,15 +65,13 @@ var ArvoDomain_1 = require("../ArvoDomain");
 var ArvoOrchestrator = /** @class */ (function () {
     function ArvoOrchestrator(_a) {
         var _b;
-        var executionunits = _a.executionunits, memory = _a.memory, registry = _a.registry, executionEngine = _a.executionEngine, requiresResourceLocking = _a.requiresResourceLocking, systemErrorDomain = _a.systemErrorDomain, spanOptions = _a.spanOptions;
+        var executionunits = _a.executionunits, memory = _a.memory, registry = _a.registry, executionEngine = _a.executionEngine, requiresResourceLocking = _a.requiresResourceLocking, defaultEventEmissionDomains = _a.defaultEventEmissionDomains, spanOptions = _a.spanOptions;
         var _c, _d, _e, _f, _g, _h, _j;
-        /** Optional domains for routing system error events */
-        this.systemErrorDomain = undefined;
-        this.executionunits = executionunits;
+        this.executionunits = executionunits !== null && executionunits !== void 0 ? executionunits : 0;
         this.registry = registry;
         this.executionEngine = executionEngine;
         this.syncEventResource = new SyncEventResource_1.SyncEventResource(memory, requiresResourceLocking);
-        this.systemErrorDomain = systemErrorDomain;
+        this.defaultEventEmissionDomains = __assign({ systemError: [ArvoDomain_1.ArvoDomain.ORCHESTRATION_CONTEXT], services: [ArvoDomain_1.ArvoDomain.LOCAL], complete: [ArvoDomain_1.ArvoDomain.ORCHESTRATION_CONTEXT] }, (defaultEventEmissionDomains !== null && defaultEventEmissionDomains !== void 0 ? defaultEventEmissionDomains : {}));
         this.spanOptions = __assign(__assign({ kind: api_1.SpanKind.PRODUCER }, spanOptions), { attributes: __assign(__assign((_b = {}, _b[arvo_core_1.ArvoExecution.ATTR_SPAN_KIND] = arvo_core_1.ArvoExecutionSpanKind.ORCHESTRATOR, _b[arvo_core_1.OpenInference.ATTR_SPAN_KIND] = arvo_core_1.OpenInferenceSpanKind.CHAIN, _b), ((_c = spanOptions === null || spanOptions === void 0 ? void 0 : spanOptions.attributes) !== null && _c !== void 0 ? _c : {})), { 'arvo.handler.source': this.source, 'arvo.contract.uri': (_j = (_h = (_g = (_f = (_e = (_d = this === null || this === void 0 ? void 0 : this.registry) === null || _d === void 0 ? void 0 : _d.machines) === null || _e === void 0 ? void 0 : _e[0]) === null || _f === void 0 ? void 0 : _f.contracts) === null || _g === void 0 ? void 0 : _g.self) === null || _h === void 0 ? void 0 : _h.uri) !== null && _j !== void 0 ? _j : 'N/A' }) });
     }
     Object.defineProperty(ArvoOrchestrator.prototype, "source", {
@@ -144,14 +142,13 @@ var ArvoOrchestrator = /** @class */ (function () {
                             source: this.source,
                             syncEventResource: this.syncEventResource,
                             executionunits: this.executionunits,
-                            systemErrorDomain: this.systemErrorDomain,
+                            systemErrorDomain: this.defaultEventEmissionDomains.systemError,
                             selfContract: this.registry.machines[0].contracts.self,
-                            domain: this.domain,
                         }, function (_a) { return __awaiter(_this, [_a], void 0, function (_b) {
-                            var machine, inputValidation, executionResult, rawMachineEmittedEvents, emittables, newState;
-                            var _c, _d, _e, _f;
+                            var machine, inputValidation, executionResult, rawMachineEmittedEvents, i, emittables, newState;
+                            var _c, _d, _e, _f, _g, _h;
                             var span = _b.span, otelHeaders = _b.otelHeaders, orchestrationParentSubject = _b.orchestrationParentSubject, initEventId = _b.initEventId, parsedEventSubject = _b.parsedEventSubject, state = _b.state;
-                            return __generator(this, function (_g) {
+                            return __generator(this, function (_j) {
                                 (0, arvo_core_1.logToSpan)({
                                     level: 'INFO',
                                     message: "Resolving machine for event ".concat(event.type),
@@ -174,15 +171,22 @@ var ArvoOrchestrator = /** @class */ (function () {
                                 executionResult = this.executionEngine.execute({ state: (_c = state === null || state === void 0 ? void 0 : state.state) !== null && _c !== void 0 ? _c : null, event: event, machine: machine }, { inheritFrom: 'CONTEXT' });
                                 span.setAttribute('arvo.orchestration.status', executionResult.state.status);
                                 rawMachineEmittedEvents = executionResult.events;
+                                // For all the service events (non final output) make sure
+                                // that the default domain is this.defaultEventEmissionDomains.services.
+                                // This is because the assumption is that all the normal services
+                                // the orchestrator usually talks to are in the same local
+                                // domain.
+                                for (i = 0; i < rawMachineEmittedEvents.length; i++) {
+                                    rawMachineEmittedEvents[i].domain =
+                                        (_d = rawMachineEmittedEvents[i].domain) !== null && _d !== void 0 ? _d : this.defaultEventEmissionDomains.services;
+                                }
                                 if (executionResult.finalOutput) {
                                     rawMachineEmittedEvents.push({
                                         type: machine.contracts.self.metadata.completeEventType,
                                         id: executionResult.finalOutput.__id,
                                         data: executionResult.finalOutput,
-                                        to: (_e = (_d = parsedEventSubject.meta) === null || _d === void 0 ? void 0 : _d.redirectto) !== null && _e !== void 0 ? _e : parsedEventSubject.execution.initiator,
-                                        domain: orchestrationParentSubject
-                                            ? [arvo_core_1.ArvoOrchestrationSubject.parse(orchestrationParentSubject).execution.domain]
-                                            : [ArvoDomain_1.ArvoDomain.LOCAL],
+                                        to: (_f = (_e = parsedEventSubject.meta) === null || _e === void 0 ? void 0 : _e.redirectto) !== null && _f !== void 0 ? _f : parsedEventSubject.execution.initiator,
+                                        domain: (_g = executionResult.finalOutput.__domain) !== null && _g !== void 0 ? _g : this.defaultEventEmissionDomains.complete,
                                         executionunits: executionResult.finalOutput.__executionunits,
                                     });
                                 }
@@ -207,7 +211,7 @@ var ArvoOrchestrator = /** @class */ (function () {
                                     subject: event.subject,
                                     parentSubject: orchestrationParentSubject,
                                     status: executionResult.state.status,
-                                    value: (_f = executionResult.state.value) !== null && _f !== void 0 ? _f : null,
+                                    value: (_h = executionResult.state.value) !== null && _h !== void 0 ? _h : null,
                                     state: executionResult.state,
                                     events: {
                                         consumed: event.toJSON(),
@@ -231,7 +235,6 @@ var ArvoOrchestrator = /** @class */ (function () {
             return {
                 type: this.registry.machines[0].contracts.self.systemError.type,
                 schema: arvo_core_1.ArvoErrorSchema,
-                domain: this.systemErrorDomain,
             };
         },
         enumerable: false,

package/dist/ArvoOrchestrator/types.d.ts

@@ -5,7 +5,7 @@ import type { OrchestrationExecutionMemoryRecord } from '../ArvoOrchestrationUti
 import type { IMachineExectionEngine } from '../MachineExecutionEngine/interface';
 import type { IMachineMemory } from '../MachineMemory/interface';
 import type { IMachineRegistry } from '../MachineRegistry/interface';
-import type { ArvoEventHandlerOtelSpanOptions } from '../types';
+import type { ArvoEventHandlerOtelSpanOptions, NonEmptyArray } from '../types';
 /**
  * Discriminated union representing the result of a try operation.
  */
@@ -84,7 +84,7 @@ export type MachineMemoryRecord = OrchestrationExecutionMemoryRecord<{
  */
 export type ArvoOrchestratorParam = {
     /** Computational cost metric assigned to orchestrator operations */
-    executionunits: number;
+    executionunits?: number;
     /** Memory interface for state persistence and retrieval */
     memory: IMachineMemory<MachineMemoryRecord>;
     /** Registry for managing and resolving machine instances */
@@ -93,20 +93,41 @@ export type ArvoOrchestratorParam = {
     executionEngine: IMachineExectionEngine;
     /** Whether to enforce resource locking for concurrent safety */
     requiresResourceLocking: boolean;
-    /**
-     * Optional domains for system error event routing.
-     *
-     * Overrides the default fallback sequence of:
-     * `[event.domain, self.contract.domain, null]`
-     *
-     * Controls where structured `sys.*.error` events are emitted when
-     * uncaught exceptions occur. Supports symbolic constants from {@link ArvoDomain}.
-     *
-     * @default undefined - uses standard fallback broadcast domains
-     */
-    systemErrorDomain?: (string | null)[];
     /** OpenTelemetry span configuration for distributed tracing */
     spanOptions?: ArvoEventHandlerOtelSpanOptions;
+    /**
+     * Optional default domains for the events emitted
+     * by the orchestrator.
+     */
+    defaultEventEmissionDomains?: {
+        /**
+         * Default domains for system error events emitted by this orchestrator.
+         *
+         * System errors are routed through these domains when the handler encounters
+         * unhandled exceptions or critical failures.
+         *
+         * @default [ArvoDomain.ORCHESTRATION_CONTEXT]
+         */
+        systemError?: NonEmptyArray<string | null>;
+        /**
+         * Default domains for service events emitted by this orchestrator.
+         *
+         * The service xstate.emit function can over-ride this default.
+         *
+         * @default [ArvoDomain.LOCAL]
+         */
+        services?: NonEmptyArray<string | null>;
+        /**
+         * Defauld domain for the final completion event emitted by this orchestrator
+         *
+         * Completion event is routed through these domains when the orchestrator successfully
+         * processes an init event. The machine 'output' transform function implementations can override
+         * this default.
+         *
+         * @default [ArvoDomain.ORCHESTRATION_CONTEXT]
+         */
+        complete?: NonEmptyArray<string | null>;
+    };
 };
 /**
  * Configuration parameters for creating an orchestrator via factory function.
@@ -114,7 +135,7 @@ export type ArvoOrchestratorParam = {
  * Simplified interface for {@link createArvoOrchestrator} that automatically
  * constructs default registry and execution engine components.
  */
-export type CreateArvoOrchestratorParam = Pick<ArvoOrchestratorParam, 'memory' | 'executionunits' | 'spanOptions' | 'systemErrorDomain'> & {
+export type CreateArvoOrchestratorParam = Pick<ArvoOrchestratorParam, 'memory' | 'executionunits' | 'spanOptions' | 'defaultEventEmissionDomains'> & {
     /**
      * Optional override for resource locking requirement.
      *

package/dist/ArvoResumable/factory.d.ts

@@ -29,7 +29,6 @@ import type { CreateArvoResumableParam } from './types';
  *       // Handler implementation
  *     }
  *   },
- *   executionunits: 1
  * });
  * ```
  *

package/dist/ArvoResumable/factory.js

@@ -31,7 +31,6 @@ var servicesValidation_1 = require("../ArvoOrchestrationUtils/servicesValidation
  *       // Handler implementation
  *     }
  *   },
- *   executionunits: 1
  * });
  * ```
  *
@@ -47,7 +46,7 @@ var createArvoResumable = function (param) {
         handler: param.handler,
         executionunits: (_a = param.executionunits) !== null && _a !== void 0 ? _a : 0,
         requiresResourceLocking: (_b = param.requiresResourceLocking) !== null && _b !== void 0 ? _b : Object.keys(param.contracts.services).length > 1,
-        systemErrorDomain: param.systemErrorDomain,
+        defaultEventEmissionDomains: param.defaultEventEmissionDomains,
         spanOptions: param.spanOptions,
     });
 };

package/dist/ArvoResumable/index.d.ts

@@ -23,8 +23,8 @@ export declare class ArvoResumable<TMemory extends Record<string, any> = Record<
     readonly syncEventResource: SyncEventResource<ArvoResumableState<TMemory>>;
     /** Versioned handler map for processing workflow events. */
     readonly handler: ArvoResumableHandler<ArvoResumableState<TMemory>, TSelfContract, TServiceContract>;
-    /** Optional domains for routing system error events */
-    readonly systemErrorDomain?: (string | null)[];
+    /** Optional domains for routing events */
+    readonly defaultEventEmissionDomains: Required<NonNullable<ArvoResumableParam<TMemory, TSelfContract, TServiceContract>['defaultEventEmissionDomains']>>;
     /** OpenTelemetry span configuration for observability */
     readonly spanOptions: ArvoEventHandlerOtelSpanOptions;
     /** Source identifier from the first registered machine */
@@ -82,21 +82,17 @@ export declare class ArvoResumable<TMemory extends Record<string, any> = Record<
     execute(event: ArvoEvent, opentelemetry?: ArvoEventHandlerOpenTelemetryOptions): Promise<{
         events: ArvoEvent[];
     }>;
-    get systemErrorSchema(): {
-        domain: (string | null)[] | undefined;
-        type: `sys.arvo.orc.${string}.error`;
-        schema: import("zod").ZodObject<{
-            errorName: import("zod").ZodString;
-            errorMessage: import("zod").ZodString;
-            errorStack: import("zod").ZodNullable<import("zod").ZodString>;
-        }, "strip", import("zod").ZodTypeAny, {
-            errorName: string;
-            errorMessage: string;
-            errorStack: string | null;
-        }, {
-            errorName: string;
-            errorMessage: string;
-            errorStack: string | null;
-        }>;
-    };
+    get systemErrorSchema(): import("arvo-core").ArvoContractRecord<`sys.arvo.orc.${string}.error`, import("zod").ZodObject<{
+        errorName: import("zod").ZodString;
+        errorMessage: import("zod").ZodString;
+        errorStack: import("zod").ZodNullable<import("zod").ZodString>;
+    }, "strip", import("zod").ZodTypeAny, {
+        errorName: string;
+        errorMessage: string;
+        errorStack: string | null;
+    }, {
+        errorName: string;
+        errorMessage: string;
+        errorStack: string | null;
+    }>>;
 }