arvo-event-handler 3.0.22 → 3.0.25

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

@@ -29,4 +29,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

@@ -44,7 +44,7 @@ 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');
     }
@@ -68,7 +68,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

@@ -54,6 +54,7 @@ var createEmitableEvent_1 = require("../ArvoOrchestrationUtils/createEmitableEve
 var orchestrationExecutionWrapper_1 = require("../ArvoOrchestrationUtils/orchestrationExecutionWrapper");
 var SyncEventResource_1 = require("../SyncEventResource");
 var errors_1 = require("../errors");
+var ArvoDomain_1 = require("../ArvoDomain");
 /**
  * Orchestrates state machine execution and lifecycle management.
  *
@@ -64,15 +65,13 @@ var errors_1 = require("../errors");
 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.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", {
@@ -143,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),
@@ -173,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]
-                                            : [null],
+                                        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,
                                     });
                                 }
@@ -206,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(),
@@ -230,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.
  */
@@ -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.js

@@ -47,7 +47,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;
+    }>>;
 }

package/dist/ArvoResumable/index.js

@@ -55,6 +55,7 @@ var inputValidation_1 = require("../ArvoOrchestrationUtils/inputValidation");
 var orchestrationExecutionWrapper_1 = require("../ArvoOrchestrationUtils/orchestrationExecutionWrapper");
 var index_1 = require("../SyncEventResource/index");
 var errors_1 = require("../errors");
+var ArvoDomain_1 = require("../ArvoDomain");
 /**
  * ArvoResumable complements {@link ArvoOrchestrator} by providing imperative
  * handler functions for orchestration logic instead of declarative state machines.
@@ -68,16 +69,14 @@ var errors_1 = require("../errors");
 var ArvoResumable = /** @class */ (function () {
     function ArvoResumable(param) {
         var _a;
-        var _b, _c, _d;
-        /** Optional domains for routing system error events */
-        this.systemErrorDomain = undefined;
+        var _b, _c, _d, _e;
         this.executionunits = param.executionunits;
         this.source = param.contracts.self.type;
         this.syncEventResource = new index_1.SyncEventResource(param.memory, (_b = param.requiresResourceLocking) !== null && _b !== void 0 ? _b : true);
         this.contracts = param.contracts;
         this.handler = param.handler;
-        this.systemErrorDomain = param.systemErrorDomain;
-        this.spanOptions = __assign(__assign({ kind: api_1.SpanKind.PRODUCER }, param.spanOptions), { attributes: __assign(__assign((_a = {}, _a[arvo_core_1.ArvoExecution.ATTR_SPAN_KIND] = arvo_core_1.ArvoExecutionSpanKind.RESUMABLE, _a[arvo_core_1.OpenInference.ATTR_SPAN_KIND] = arvo_core_1.OpenInferenceSpanKind.CHAIN, _a), ((_d = (_c = param.spanOptions) === null || _c === void 0 ? void 0 : _c.attributes) !== null && _d !== void 0 ? _d : {})), { 'arvo.handler.source': this.source, 'arvo.contract.uri': this.contracts.self.uri }) });
+        this.defaultEventEmissionDomains = __assign({ systemError: [ArvoDomain_1.ArvoDomain.ORCHESTRATION_CONTEXT], services: [ArvoDomain_1.ArvoDomain.LOCAL], complete: [ArvoDomain_1.ArvoDomain.ORCHESTRATION_CONTEXT] }, ((_c = param.defaultEventEmissionDomains) !== null && _c !== void 0 ? _c : {}));
+        this.spanOptions = __assign(__assign({ kind: api_1.SpanKind.PRODUCER }, param.spanOptions), { attributes: __assign(__assign((_a = {}, _a[arvo_core_1.ArvoExecution.ATTR_SPAN_KIND] = arvo_core_1.ArvoExecutionSpanKind.RESUMABLE, _a[arvo_core_1.OpenInference.ATTR_SPAN_KIND] = arvo_core_1.OpenInferenceSpanKind.CHAIN, _a), ((_e = (_d = param.spanOptions) === null || _d === void 0 ? void 0 : _d.attributes) !== null && _e !== void 0 ? _e : {})), { 'arvo.handler.source': this.source, 'arvo.contract.uri': this.contracts.self.uri }) });
     }
     Object.defineProperty(ArvoResumable.prototype, "requiresResourceLocking", {
         /** Whether this resumable requires resource locking for concurrent safety */
@@ -155,15 +154,14 @@ var ArvoResumable = /** @class */ (function () {
                             source: this.source,
                             syncEventResource: this.syncEventResource,
                             executionunits: this.executionunits,
-                            systemErrorDomain: this.systemErrorDomain,
+                            systemErrorDomain: this.defaultEventEmissionDomains.systemError,
                             selfContract: this.contracts.self.version('latest'),
-                            domain: this.domain,
                         }, function (_a) { return __awaiter(_this, [_a], void 0, function (_b) {
-                            var inputValidation, contractType, eventTypeToExpectedEvent, _i, _c, _d, _, eventList, _e, eventList_1, _evt, handler, versionedSelfContract, executionResult, rawEvents, emittables, eventTrackingState, newState;
-                            var _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r, _s, _t, _u;
+                            var inputValidation, contractType, eventTypeToExpectedEvent, _i, _c, _d, _, eventList, _e, eventList_1, _evt, handler, versionedSelfContract, executionResult, rawEvents, i, emittables, eventTrackingState, newState;
+                            var _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r, _s, _t, _u, _v, _w, _x;
                             var span = _b.span, otelHeaders = _b.otelHeaders, orchestrationParentSubject = _b.orchestrationParentSubject, initEventId = _b.initEventId, parsedEventSubject = _b.parsedEventSubject, state = _b.state;
-                            return __generator(this, function (_v) {
-                                switch (_v.label) {
+                            return __generator(this, function (_y) {
+                                switch (_y.label) {
                                     case 0:
                                         (0, arvo_core_1.logToSpan)({
                                             level: 'INFO',
@@ -230,17 +228,18 @@ var ArvoResumable = /** @class */ (function () {
                                                 },
                                             })];
                                     case 1:
-                                        executionResult = _v.sent();
+                                        executionResult = _y.sent();
                                         rawEvents = (_o = executionResult === null || executionResult === void 0 ? void 0 : executionResult.services) !== null && _o !== void 0 ? _o : [];
+                                        for (i = 0; i < rawEvents.length; i++) {
+                                            rawEvents[i].domain = (_p = rawEvents[i].domain) !== null && _p !== void 0 ? _p : this.defaultEventEmissionDomains.services;
+                                        }
                                         if (executionResult === null || executionResult === void 0 ? void 0 : executionResult.output) {
                                             rawEvents.push({
                                                 id: executionResult.output.__id,
                                                 data: executionResult.output,
                                                 type: this.contracts.self.metadata.completeEventType,
-                                                to: (_q = (_p = parsedEventSubject.meta) === null || _p === void 0 ? void 0 : _p.redirectto) !== null && _q !== void 0 ? _q : parsedEventSubject.execution.initiator,
-                                                domain: orchestrationParentSubject
-                                                    ? [arvo_core_1.ArvoOrchestrationSubject.parse(orchestrationParentSubject).execution.domain]
-                                                    : [null],
+                                                to: (_r = (_q = parsedEventSubject.meta) === null || _q === void 0 ? void 0 : _q.redirectto) !== null && _r !== void 0 ? _r : parsedEventSubject.execution.initiator,
+                                                domain: (_t = (_s = executionResult.output) === null || _s === void 0 ? void 0 : _s.__domain) !== null && _t !== void 0 ? _t : this.defaultEventEmissionDomains.complete,
                                                 executionunits: executionResult.output.__executionunits,
                                             });
                                         }
@@ -263,7 +262,7 @@ var ArvoResumable = /** @class */ (function () {
                                             consumed: event.toJSON(),
                                             expected: emittables.length
                                                 ? Object.fromEntries(emittables.map(function (item) { return [item.id, []]; }))
-                                                : ((_s = (_r = state === null || state === void 0 ? void 0 : state.events) === null || _r === void 0 ? void 0 : _r.expected) !== null && _s !== void 0 ? _s : null),
+                                                : ((_v = (_u = state === null || state === void 0 ? void 0 : state.events) === null || _u === void 0 ? void 0 : _u.expected) !== null && _v !== void 0 ? _v : null),
                                             produced: emittables.map(function (item) { return item.toJSON(); }),
                                         };
                                         newState = {
@@ -273,7 +272,7 @@ var ArvoResumable = /** @class */ (function () {
                                             parentSubject: orchestrationParentSubject,
                                             subject: event.subject,
                                             events: eventTrackingState,
-                                            state$$: (_u = (_t = executionResult === null || executionResult === void 0 ? void 0 : executionResult.context) !== null && _t !== void 0 ? _t : state === null || state === void 0 ? void 0 : state.state$$) !== null && _u !== void 0 ? _u : null,
+                                            state$$: (_x = (_w = executionResult === null || executionResult === void 0 ? void 0 : executionResult.context) !== null && _w !== void 0 ? _w : state === null || state === void 0 ? void 0 : state.state$$) !== null && _x !== void 0 ? _x : null,
                                         };
                                         return [2 /*return*/, { emittables: emittables, newState: newState }];
                                 }
@@ -286,7 +285,7 @@ var ArvoResumable = /** @class */ (function () {
     };
     Object.defineProperty(ArvoResumable.prototype, "systemErrorSchema", {
         get: function () {
-            return __assign(__assign({}, this.contracts.self.systemError), { domain: this.systemErrorDomain });
+            return this.contracts.self.systemError;
         },
         enumerable: false,
         configurable: true

package/dist/ArvoResumable/types.d.ts

@@ -3,7 +3,7 @@ import type { ArvoContract, ArvoEvent, ArvoOrchestratorContract, ArvoSemanticVer
 import type { EnqueueArvoEventActionParam } from '../ArvoMachine/types';
 import type { OrchestrationExecutionMemoryRecord } from '../ArvoOrchestrationUtils/orchestrationExecutionState';
 import type { IMachineMemory } from '../MachineMemory/interface';
-import type { ArvoEventHandlerOtelSpanOptions } from '../types';
+import type { ArvoEventHandlerOtelSpanOptions, NonEmptyArray } from '../types';
 /**
  * Extracts all possible event types (including system errors) from service contracts.
  */
@@ -98,6 +98,7 @@ type Handler<TState extends ArvoResumableState<Record<string, any>>, TSelfContra
     }[keyof InferVersionedArvoContract<TSelfContract>['emits']] & {
         __id?: CreateArvoEvent<Record<string, unknown>, string>['id'];
         __executionunits?: CreateArvoEvent<Record<string, unknown>, string>['executionunits'];
+        __domain?: NonEmptyArray<string | null>;
     };
     /**
      * Service call events to emit.
@@ -219,10 +220,47 @@ export type ArvoResumableParam<TMemory extends Record<string, any>, TSelfContrac
      * Each contract version maps to its corresponding handler implementation.
      */
     handler: ArvoResumableHandler<ArvoResumableState<TMemory>, TSelfContract, TServiceContract>;
-    /** Optional domains for system error event routing */
-    systemErrorDomain?: (string | null)[];
+    /**
+     * Optional domains for system error event routing
+     *
+     * @default [ArvoDomain.FROM_PARENT_SUBJECT]
+     */
+    systemErrorDomain?: NonEmptyArray<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 ArvoResumable instance.
@@ -252,9 +290,8 @@ export type CreateArvoResumableParam<TMemory extends Record<string, any>, TSelfC
      * @default true if multiple service contracts, false otherwise
      */
     requiresResourceLocking?: boolean;
-    /** Optional domains for system error event routing */
-    systemErrorDomain?: (string | null)[];
     /** OpenTelemetry span configuration for distributed tracing */
     spanOptions?: ArvoEventHandlerOtelSpanOptions;
+    defaultEventEmissionDomains?: ArvoResumableParam<TMemory, TSelfContract, TServiceContract>['defaultEventEmissionDomains'];
 };
 export {};

package/dist/IArvoEventHandler/index.d.ts

@@ -42,9 +42,6 @@ export default interface IArvoEventHandler {
      *
      * @property type - The error event type identifier
      * @property schema - Zod schema defining the error event data structure
-     * @property domain - Optional domains for error event routing and distribution
      */
-    systemErrorSchema: ArvoContractRecord & {
-        domain?: (string | null)[];
-    };
+    systemErrorSchema: ArvoContractRecord;
 }

package/dist/types.d.ts

@@ -1,6 +1,7 @@
 import type { SpanOptions } from '@opentelemetry/api';
 import type { ArvoEvent } from 'arvo-core';
 import type IArvoEventHandler from './IArvoEventHandler';
+export type NonEmptyArray<T> = [T, ...T[]];
 /**
  * Makes properties optional except specified keys
  *

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "arvo-event-handler",
-  "version": "3.0.22",
+  "version": "3.0.25",
   "description": "A complete set of orthogonal event handler and orchestration primitives for Arvo based applications, featuring declarative state machines (XState), imperative resumables for agentic workflows, contract-based routing, OpenTelemetry observability, and in-memory event broker for building composable event-driven architectures.",
   "main": "dist/index.js",
   "repository": {
@@ -65,7 +65,7 @@
   "dependencies": {
     "@opentelemetry/api": "1.9.0",
     "@opentelemetry/core": "1.30.1",
-    "arvo-core": "3.0.22",
+    "arvo-core": "3.0.25",
     "uuid": "11.1.0",
     "xstate": "5.24.0",
     "zod": "3.25.74",