arvo-event-handler 3.0.23 → 3.0.25

package/dist/ArvoDomain.d.ts

@@ -1,4 +1,4 @@
-import type { ArvoEvent, VersionedArvoContract } from 'arvo-core';
+import { type ArvoEvent, type VersionedArvoContract } from 'arvo-core';
 /**
  * Symbolic constants for domain resolution in Arvo event emission.
  *
@@ -7,57 +7,75 @@ import type { ArvoEvent, VersionedArvoContract } from 'arvo-core';
  */
 export declare const ArvoDomain: {
     /**
-     * Resolve the domain from the emitting handler’s own contract (`handlerSelfContract.domain`).
+     * Resolve domain from the handler's contract.
      *
-     * Use this when the handler’s contract defines a stable domain that should apply
-     * to all emitted events, regardless of the triggering context.
+     * Uses `handlerSelfContract.domain` for all emitted events.
      */
     readonly FROM_SELF_CONTRACT: "domain.contract.self.inherit";
     /**
-     * Resolve the domain from the contract that defines the event being emitted (`eventContract.domain`).
+     * Resolve domain from the event's contract.
      *
-     * In `ArvoResumable` and `ArvoMachine`, this is typically used when emitting service events
-     * (not the completion event). In `ArvoEventHandler`, where only the self contract exists,
-     * this resolves to the same value as `FROM_SELF_CONTRACT`.
-     *
-     * For orchestration `complete` events, this behaves identically to `FROM_SELF_CONTRACT`
-     * since the emitting contract is also the self contract.
+     * For orchestrators, uses the service contract's domain.
+     * For handlers, behaves the same as FROM_SELF_CONTRACT.
      */
     readonly FROM_EVENT_CONTRACT: "domain.contract.inherit";
     /**
-     * Resolve the domain from the triggering event’s `domain` field (`triggeringEvent.domain`).
+     * Resolve domain from the triggering event's domain field.
      *
-     * Use this when you want to preserve the domain context of the incoming event
-     * and carry it forward through event emissions.
+     * Preserves the domain context of the incoming event.
      */
     readonly FROM_TRIGGERING_EVENT: "domain.event.inherit";
     /**
-     * Keep the event in the current execution context (null domain).
+     * Extract domain from the current event's subject.
+     *
+     * Parses the subject to retrieve `execution.domain`.
+     * Falls back to LOCAL if subject is not a valid ArvoOrchestrationSubject.
+     */
+    readonly FROM_CURRENT_SUBJECT: "domain.event.current.subject";
+    /**
+     * Extract domain from the parent orchestration subject.
+     *
+     * Parses the parent subject to retrieve `execution.domain`.
+     * Falls back to LOCAL if subject is not a valid ArvoOrchestrationSubject.
+     */
+    readonly FROM_PARENT_SUBJECT: "domain.parent.subject";
+    /**
+     * Resolve domain based on orchestration context.
+     *
+     * Routes responses and completions back through the orchestration chain:
+     * - For handlers: routes back to the orchestration's domain
+     * - For child orchestrations: routes to parent's domain if different, LOCAL if same
+     * - For root orchestrations: routes to own domain if cross-domain call, LOCAL otherwise
+     *
+     * This is the recommended default for maintaining domain coherence in orchestration workflows.
+     */
+    readonly ORCHESTRATION_CONTEXT: "domain.orchestration.context";
+    /**
+     * Stay in the current execution context (null domain).
      *
-     * Use this when the event should remain local to the current domain without
-     * crossing execution boundaries through the exchange layer.
+     * Event remains local without crossing domain boundaries.
      */
     readonly LOCAL: null;
 };
 /**
- * Resolves a symbolic or static domain value into a concrete domain string or `null`.
+ * Resolves symbolic domain constants to concrete domain values.
  *
- * Used internally in the Arvo execution model to interpret symbolic domain constants
- * at the moment an event is emitted. Supports resolution from:
- * - the emitting handler's own contract
- * - the emitted event’s associated contract
- * - the triggering event’s `domain` field
+ * Interprets domain resolution symbols and returns the appropriate domain string or null.
+ * Static domain strings pass through unchanged.
  *
- * @param param - Parameters for resolving the domain.
- * @param param.domainToResolve - Either a static domain string, symbolic value, or null.
- * @param param.handlerSelfContract - The contract of the handler currently emitting the event.
- * @param param.eventContract - The contract of the event being emitted (optional).
- * @param param.triggeringEvent - The triggering event that caused this emission.
+ * @param param.domainToResolve - Domain string or symbolic constant to resolve
+ * @param param.parentSubject - Parent orchestration subject (null for root orchestrations or handlers)
+ * @param param.currentSubject - Current event subject
+ * @param param.handlerSelfContract - Contract of the handler emitting the event
+ * @param param.eventContract - Contract of the event being emitted (optional)
+ * @param param.triggeringEvent - Event that triggered this emission
  *
- * @returns A resolved domain string, or `null` if no valid domain is found.
+ * @returns Resolved domain string or null
  */
 export declare const resolveEventDomain: (param: {
     domainToResolve: string | null;
+    parentSubject: string | null;
+    currentSubject: string;
     handlerSelfContract: VersionedArvoContract<any, any>;
     eventContract: VersionedArvoContract<any, any> | null;
     triggeringEvent: ArvoEvent;

package/dist/ArvoDomain.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.resolveEventDomain = exports.ArvoDomain = void 0;
+var arvo_core_1 = require("arvo-core");
 /**
  * Symbolic constants for domain resolution in Arvo event emission.
  *
@@ -9,70 +10,138 @@ exports.resolveEventDomain = exports.ArvoDomain = void 0;
  */
 exports.ArvoDomain = {
     /**
-     * Resolve the domain from the emitting handler’s own contract (`handlerSelfContract.domain`).
+     * Resolve domain from the handler's contract.
      *
-     * Use this when the handler’s contract defines a stable domain that should apply
-     * to all emitted events, regardless of the triggering context.
+     * Uses `handlerSelfContract.domain` for all emitted events.
      */
     FROM_SELF_CONTRACT: 'domain.contract.self.inherit',
     /**
-     * Resolve the domain from the contract that defines the event being emitted (`eventContract.domain`).
+     * Resolve domain from the event's contract.
      *
-     * In `ArvoResumable` and `ArvoMachine`, this is typically used when emitting service events
-     * (not the completion event). In `ArvoEventHandler`, where only the self contract exists,
-     * this resolves to the same value as `FROM_SELF_CONTRACT`.
-     *
-     * For orchestration `complete` events, this behaves identically to `FROM_SELF_CONTRACT`
-     * since the emitting contract is also the self contract.
+     * For orchestrators, uses the service contract's domain.
+     * For handlers, behaves the same as FROM_SELF_CONTRACT.
      */
     FROM_EVENT_CONTRACT: 'domain.contract.inherit',
     /**
-     * Resolve the domain from the triggering event’s `domain` field (`triggeringEvent.domain`).
+     * Resolve domain from the triggering event's domain field.
      *
-     * Use this when you want to preserve the domain context of the incoming event
-     * and carry it forward through event emissions.
+     * Preserves the domain context of the incoming event.
      */
     FROM_TRIGGERING_EVENT: 'domain.event.inherit',
     /**
-     * Keep the event in the current execution context (null domain).
+     * Extract domain from the current event's subject.
+     *
+     * Parses the subject to retrieve `execution.domain`.
+     * Falls back to LOCAL if subject is not a valid ArvoOrchestrationSubject.
+     */
+    FROM_CURRENT_SUBJECT: 'domain.event.current.subject',
+    /**
+     * Extract domain from the parent orchestration subject.
      *
-     * Use this when the event should remain local to the current domain without
-     * crossing execution boundaries through the exchange layer.
+     * Parses the parent subject to retrieve `execution.domain`.
+     * Falls back to LOCAL if subject is not a valid ArvoOrchestrationSubject.
      */
-    LOCAL: null
+    FROM_PARENT_SUBJECT: 'domain.parent.subject',
+    /**
+     * Resolve domain based on orchestration context.
+     *
+     * Routes responses and completions back through the orchestration chain:
+     * - For handlers: routes back to the orchestration's domain
+     * - For child orchestrations: routes to parent's domain if different, LOCAL if same
+     * - For root orchestrations: routes to own domain if cross-domain call, LOCAL otherwise
+     *
+     * This is the recommended default for maintaining domain coherence in orchestration workflows.
+     */
+    ORCHESTRATION_CONTEXT: 'domain.orchestration.context',
+    /**
+     * Stay in the current execution context (null domain).
+     *
+     * Event remains local without crossing domain boundaries.
+     */
+    LOCAL: null,
 };
 /**
- * Resolves a symbolic or static domain value into a concrete domain string or `null`.
+ * Extracts the domain from an ArvoOrchestrationSubject string.
  *
- * Used internally in the Arvo execution model to interpret symbolic domain constants
- * at the moment an event is emitted. Supports resolution from:
- * - the emitting handler's own contract
- * - the emitted event’s associated contract
- * - the triggering event’s `domain` field
+ * @param subject - Orchestration subject string or null
+ * @returns Domain from subject's execution context, or null if parsing fails
+ */
+var getDomainFromArvoSubject = function (subject) {
+    if (subject === null)
+        return null;
+    try {
+        var parsedSubject = arvo_core_1.ArvoOrchestrationSubject.parse(subject);
+        return parsedSubject.execution.domain;
+    }
+    catch (e) {
+        (0, arvo_core_1.exceptionToSpan)(new Error("Unable to parse the provided subject. Falling back to ArvoDomain.LOCAL. Error: ".concat(e.message)));
+    }
+    return null;
+};
+/**
+ * Resolves symbolic domain constants to concrete domain values.
  *
- * @param param - Parameters for resolving the domain.
- * @param param.domainToResolve - Either a static domain string, symbolic value, or null.
- * @param param.handlerSelfContract - The contract of the handler currently emitting the event.
- * @param param.eventContract - The contract of the event being emitted (optional).
- * @param param.triggeringEvent - The triggering event that caused this emission.
+ * Interprets domain resolution symbols and returns the appropriate domain string or null.
+ * Static domain strings pass through unchanged.
  *
- * @returns A resolved domain string, or `null` if no valid domain is found.
+ * @param param.domainToResolve - Domain string or symbolic constant to resolve
+ * @param param.parentSubject - Parent orchestration subject (null for root orchestrations or handlers)
+ * @param param.currentSubject - Current event subject
+ * @param param.handlerSelfContract - Contract of the handler emitting the event
+ * @param param.eventContract - Contract of the event being emitted (optional)
+ * @param param.triggeringEvent - Event that triggered this emission
+ *
+ * @returns Resolved domain string or null
  */
 var resolveEventDomain = function (param) {
     var _a, _b;
-    var ArvoDomainValues = Object.values(exports.ArvoDomain);
-    if (param.domainToResolve && ArvoDomainValues.includes(param.domainToResolve)) {
-        var domainToResolve = param.domainToResolve;
-        if (domainToResolve === exports.ArvoDomain.FROM_EVENT_CONTRACT) {
-            return (_b = (_a = param.eventContract) === null || _a === void 0 ? void 0 : _a.domain) !== null && _b !== void 0 ? _b : null;
-        }
-        if (domainToResolve === exports.ArvoDomain.FROM_SELF_CONTRACT) {
-            return param.handlerSelfContract.domain;
+    if (!param.domainToResolve) {
+        return null;
+    }
+    if (param.domainToResolve === exports.ArvoDomain.LOCAL) {
+        return null;
+    }
+    if (param.domainToResolve === exports.ArvoDomain.FROM_EVENT_CONTRACT) {
+        return (_b = (_a = param.eventContract) === null || _a === void 0 ? void 0 : _a.domain) !== null && _b !== void 0 ? _b : null;
+    }
+    if (param.domainToResolve === exports.ArvoDomain.FROM_SELF_CONTRACT) {
+        return param.handlerSelfContract.domain;
+    }
+    if (param.domainToResolve === exports.ArvoDomain.FROM_TRIGGERING_EVENT) {
+        return param.triggeringEvent.domain;
+    }
+    if (param.domainToResolve === exports.ArvoDomain.FROM_CURRENT_SUBJECT) {
+        return getDomainFromArvoSubject(param.currentSubject);
+    }
+    if (param.domainToResolve === exports.ArvoDomain.FROM_PARENT_SUBJECT) {
+        return getDomainFromArvoSubject(param.parentSubject);
+    }
+    if (param.domainToResolve === exports.ArvoDomain.ORCHESTRATION_CONTEXT) {
+        var currentDomain = getDomainFromArvoSubject(param.currentSubject);
+        var parentDomain = getDomainFromArvoSubject(param.parentSubject);
+        var triggeringDomain = param.triggeringEvent.domain;
+        // No parent orchestration (root orchestration or handler)
+        if (param.parentSubject === null) {
+            // Triggering event is local
+            if (triggeringDomain === null) {
+                return null;
+            }
+            // Current and triggering domains match
+            if (currentDomain === triggeringDomain) {
+                return null;
+            }
+            // Cross-domain call - route back to orchestration's domain
+            return currentDomain;
         }
-        if (domainToResolve === exports.ArvoDomain.FROM_TRIGGERING_EVENT) {
-            return param.triggeringEvent.domain;
+        // Has parent orchestration
+        // Child and parent in same domain
+        if (currentDomain === parentDomain) {
+            return null;
         }
+        // Child in different domain - route to parent's domain
+        return parentDomain;
     }
+    // Static domain string
     return param.domainToResolve;
 };
 exports.resolveEventDomain = resolveEventDomain;

package/dist/ArvoEventHandler/index.d.ts

@@ -17,8 +17,8 @@ export default class ArvoEventHandler<TContract extends ArvoContract> implements
     readonly handler: ArvoEventHandlerFunction<TContract>;
     /** The source identifier for events produced by this handler */
     get source(): TContract['type'];
-    /** Optional domains for routing system error events */
-    readonly systemErrorDomain?: (string | null)[];
+    /** Domains for routing events */
+    readonly defaultEventEmissionDomains: Required<NonNullable<ArvoEventHandlerParam<TContract>['defaultEventEmissionDomains']>>;
     /** The contract-defined domain for the handler */
     get domain(): string | null;
     constructor(param: ArvoEventHandlerParam<TContract>);
@@ -40,21 +40,17 @@ export default class ArvoEventHandler<TContract extends ArvoContract> implements
     /**
      * Provides access to the system error event schema configuration.
      */
-    get systemErrorSchema(): {
-        domain: (string | null)[] | undefined;
-        type: `sys.${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.${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/ArvoEventHandler/index.js

@@ -72,20 +72,18 @@ var utils_1 = require("../utils");
 var ArvoEventHandler = /** @class */ (function () {
     function ArvoEventHandler(param) {
         var _a;
-        var _b, _c;
-        /** Optional domains for routing system error events */
-        this.systemErrorDomain = undefined;
+        var _b, _c, _d;
         this.contract = param.contract;
         this.executionunits = param.executionunits;
         this.handler = param.handler;
-        this.systemErrorDomain = param.systemErrorDomain;
-        for (var _i = 0, _d = Object.keys(this.contract.versions); _i < _d.length; _i++) {
-            var contractVersions = _d[_i];
+        this.defaultEventEmissionDomains = __assign({ systemError: [ArvoDomain_1.ArvoDomain.ORCHESTRATION_CONTEXT], emits: [ArvoDomain_1.ArvoDomain.ORCHESTRATION_CONTEXT] }, ((_b = param.defaultEventEmissionDomains) !== null && _b !== void 0 ? _b : {}));
+        for (var _i = 0, _e = Object.keys(this.contract.versions); _i < _e.length; _i++) {
+            var contractVersions = _e[_i];
             if (!this.handler[contractVersions]) {
                 throw new Error("Contract ".concat(this.contract.uri, " requires handler implementation for version ").concat(contractVersions));
             }
         }
-        this.spanOptions = __assign(__assign({ kind: api_1.SpanKind.CONSUMER }, param.spanOptions), { attributes: __assign(__assign((_a = {}, _a[arvo_core_1.ArvoExecution.ATTR_SPAN_KIND] = arvo_core_1.ArvoExecutionSpanKind.EVENT_HANDLER, _a[arvo_core_1.OpenInference.ATTR_SPAN_KIND] = arvo_core_1.OpenInferenceSpanKind.CHAIN, _a), ((_c = (_b = param.spanOptions) === null || _b === void 0 ? void 0 : _b.attributes) !== null && _c !== void 0 ? _c : {})), { 'arvo.handler.source': this.source, 'arvo.contract.uri': this.contract.uri }) });
+        this.spanOptions = __assign(__assign({ kind: api_1.SpanKind.CONSUMER }, param.spanOptions), { attributes: __assign(__assign((_a = {}, _a[arvo_core_1.ArvoExecution.ATTR_SPAN_KIND] = arvo_core_1.ArvoExecutionSpanKind.EVENT_HANDLER, _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.contract.uri }) });
     }
     Object.defineProperty(ArvoEventHandler.prototype, "source", {
         /** The source identifier for events produced by this handler */
@@ -127,14 +125,14 @@ var ArvoEventHandler = /** @class */ (function () {
                             "Handler<".concat(this.contract.uri, ">"), this.spanOptions, opentelemetry !== null && opentelemetry !== void 0 ? opentelemetry : { inheritFrom: 'EVENT' }, event);
                         return [4 /*yield*/, arvo_core_1.ArvoOpenTelemetry.getInstance().startActiveSpan(__assign(__assign({}, otelConfig), { fn: function (span) { return __awaiter(_this, void 0, void 0, function () {
                                     var otelSpanHeaders, _i, _a, _b, key, value, parsedDataSchema, handlerContract_1, inputEventValidation, _handleOutput, outputs, result, _c, outputs_1, item, __extensions, handlerResult, domains, _d, _e, _dom, _f, _g, _h, key, value, error_1, errorEvents, _j, _k, _l, errEvtIdx, errEvt, _m, _o, _p, key, value;
-                                    var _q, _r, _s, _t, _u, _v;
-                                    return __generator(this, function (_w) {
-                                        switch (_w.label) {
+                                    var _q, _r, _s, _t, _u;
+                                    return __generator(this, function (_v) {
+                                        switch (_v.label) {
                                             case 0:
                                                 otelSpanHeaders = (0, arvo_core_1.currentOpenTelemetryHeaders)();
-                                                _w.label = 1;
+                                                _v.label = 1;
                                             case 1:
-                                                _w.trys.push([1, 3, 4, 5]);
+                                                _v.trys.push([1, 3, 4, 5]);
                                                 span.setAttribute('arvo.handler.execution.status', 'normal');
                                                 span.setAttribute('arvo.handler.execution.type', 'handler');
                                                 span.setStatus({ code: api_1.SpanStatusCode.OK });
@@ -165,7 +163,7 @@ var ArvoEventHandler = /** @class */ (function () {
                                                 try {
                                                     handlerContract_1 = this.contract.version((_q = parsedDataSchema === null || parsedDataSchema === void 0 ? void 0 : parsedDataSchema.version) !== null && _q !== void 0 ? _q : 'latest');
                                                 }
-                                                catch (_x) {
+                                                catch (_w) {
                                                     throw new errors_1.ConfigViolation("Invalid contract version: ".concat(parsedDataSchema === null || parsedDataSchema === void 0 ? void 0 : parsedDataSchema.version, ". Available versions: ").concat(Object.keys(this.contract.versions).join(', ')));
                                                 }
                                                 (0, arvo_core_1.logToSpan)({
@@ -196,7 +194,7 @@ var ArvoEventHandler = /** @class */ (function () {
                                                         spanHeaders: otelSpanHeaders,
                                                     })];
                                             case 2:
-                                                _handleOutput = _w.sent();
+                                                _handleOutput = _v.sent();
                                                 if (!_handleOutput)
                                                     return [2 /*return*/, {
                                                             events: [],
@@ -213,20 +211,22 @@ var ArvoEventHandler = /** @class */ (function () {
                                                     item = outputs_1[_c];
                                                     try {
                                                         __extensions = item.__extensions, handlerResult = __rest(item, ["__extensions"]);
-                                                        domains = (_s = (_r = handlerResult.domain) === null || _r === void 0 ? void 0 : _r.map(function (item) {
+                                                        domains = ((_r = handlerResult.domain) !== null && _r !== void 0 ? _r : this.defaultEventEmissionDomains.emits).map(function (item) {
                                                             return (0, ArvoDomain_1.resolveEventDomain)({
+                                                                parentSubject: null,
+                                                                currentSubject: event.subject,
                                                                 domainToResolve: item,
                                                                 handlerSelfContract: handlerContract_1,
                                                                 eventContract: handlerContract_1,
                                                                 triggeringEvent: event,
                                                             });
-                                                        })) !== null && _s !== void 0 ? _s : [event.domain];
+                                                        });
                                                         for (_d = 0, _e = Array.from(new Set(domains)); _d < _e.length; _d++) {
                                                             _dom = _e[_d];
                                                             result.push((0, arvo_core_1.createArvoEventFactory)(handlerContract_1).emits(__assign(__assign({}, handlerResult), { traceparent: otelSpanHeaders.traceparent || undefined, tracestate: otelSpanHeaders.tracestate || undefined, source: this.source, subject: event.subject, 
                                                                 // 'source'
                                                                 // prioritise returned 'to', 'redirectto' and then
-                                                                to: (0, utils_1.coalesceOrDefault)([handlerResult.to, event.redirectto], event.source), executionunits: (0, utils_1.coalesce)(handlerResult.executionunits, this.executionunits), accesscontrol: (_u = (_t = handlerResult.accesscontrol) !== null && _t !== void 0 ? _t : event.accesscontrol) !== null && _u !== void 0 ? _u : undefined, parentid: event.id, domain: _dom }), __extensions));
+                                                                to: (0, utils_1.coalesceOrDefault)([handlerResult.to, event.redirectto], event.source), executionunits: (0, utils_1.coalesce)(handlerResult.executionunits, this.executionunits), accesscontrol: (_t = (_s = handlerResult.accesscontrol) !== null && _s !== void 0 ? _s : event.accesscontrol) !== null && _t !== void 0 ? _t : undefined, parentid: event.id, domain: _dom }), __extensions));
                                                             for (_f = 0, _g = Object.entries(result[result.length - 1].otelAttributes); _f < _g.length; _f++) {
                                                                 _h = _g[_f], key = _h[0], value = _h[1];
                                                                 span.setAttribute("emittables.".concat(result.length - 1, ".").concat(key), value);
@@ -234,12 +234,12 @@ var ArvoEventHandler = /** @class */ (function () {
                                                         }
                                                     }
                                                     catch (e) {
-                                                        throw new errors_1.ContractViolation((_v = e === null || e === void 0 ? void 0 : e.message) !== null && _v !== void 0 ? _v : 'Invalid data');
+                                                        throw new errors_1.ContractViolation((_u = e === null || e === void 0 ? void 0 : e.message) !== null && _u !== void 0 ? _u : 'Invalid data');
                                                     }
                                                 }
                                                 return [2 /*return*/, (0, orchestrationExecutionWrapper_1.returnEventsWithLogging)({ events: result }, span)];
                                             case 3:
-                                                error_1 = _w.sent();
+                                                error_1 = _v.sent();
                                                 span.setAttribute('arvo.handler.execution.status', 'failure');
                                                 (0, arvo_core_1.exceptionToSpan)(error_1);
                                                 span.setStatus({
@@ -256,10 +256,9 @@ var ArvoEventHandler = /** @class */ (function () {
                                                     orchestrationParentSubject: null,
                                                     initEventId: event.id,
                                                     selfContract: this.contract.version('any'),
-                                                    systemErrorDomain: this.systemErrorDomain,
+                                                    systemErrorDomain: this.defaultEventEmissionDomains.systemError,
                                                     executionunits: this.executionunits,
                                                     source: this.source,
-                                                    domain: this.domain,
                                                     handlerType: 'handler',
                                                 });
                                                 for (_j = 0, _k = Object.entries(errorEvents); _j < _k.length; _j++) {
@@ -289,7 +288,7 @@ var ArvoEventHandler = /** @class */ (function () {
          * Provides access to the system error event schema configuration.
          */
         get: function () {
-            return __assign(__assign({}, this.contract.systemError), { domain: this.systemErrorDomain });
+            return this.contract.systemError;
         },
         enumerable: false,
         configurable: true

package/dist/ArvoEventHandler/types.d.ts

@@ -1,7 +1,7 @@
 import type { Span } from '@opentelemetry/api';
 import type { ArvoContract, ArvoEvent, ArvoSemanticVersion, CreateArvoEvent, InferArvoEvent, OpenTelemetryHeaders, VersionedArvoContract } from 'arvo-core';
 import type { z } from 'zod';
-import type { ArvoEventHandlerOtelSpanOptions } from '../types';
+import type { ArvoEventHandlerOtelSpanOptions, NonEmptyArray } from '../types';
 /**
  * Represents the input for an ArvoEvent handler function.
  */
@@ -38,29 +38,18 @@ export type ArvoEventHandlerFunctionOutput<TContract extends VersionedArvoContra
         /** Optional extensions for the event. */
         __extensions?: Record<string, string | number | boolean>;
         /**
-         * The domain configuration for multi-domain event broadcasting.
+         * Specifies which execution contexts should receive this event. Each domain value creates a separate routed event.
+         * Defaults to the domain encoded in the triggering event's subject with fallback to ArvoDomain.LOCAL (null) to
+         * maintain execution context continuity.
          *
-         * When an event is emitted with a `domain` array, Arvo generates a separate ArvoEvent
-         * for each resolved domain value. This enables parallel routing to multiple contexts
-         * such as analytics, auditing, human-in-the-loop systems, or external integrations.
-         *
-         * **Accepted Values:**
-         * - A concrete domain string (e.g. `'audit.orders'`)
-         * - `null` for standard internal routing (no domain)
-         * - A symbolic value from {@link ArvoDomain}.
-         *
-         * **Broadcasting Rules:**
-         * - Each resolved domain in the array creates a separate ArvoEvent instance
-         * - Duplicate resolved domains are automatically removed
-         * - If the field is omitted, Arvo defaults to `[null]`
+         * @default [ArvoDomain.FROM_PARENT_SUBJECT]
          *
          * **Examples:**
-         * - `['analytics.orders', 'audit.orders']` → Creates two routed events
-         * - `[ArvoDomain.FROM_TRIGGERING_EVENT, 'human.review', null]` → Mirrors source domain, routes to review, and standard consumer
-         * - `[null]` → Emits a single event with no domain routing
-         * - _Omitted_ → Same as `[null]`
+         * - `['human.interaction', 'audit.reporting']` → Creates two routed events
+         * - `[ArvoDomain.FROM_TRIGGERING_EVENT, 'human.review']` → Mirrors source domain and routes to review
+         * - `[ArvoDomain.LOCAL]` → Stays in current execution context
          */
-        domain?: (string | null)[];
+        domain?: NonEmptyArray<string | null>;
     };
 }[keyof TContract['emits']];
 /**
@@ -93,17 +82,28 @@ export type ArvoEventHandlerParam<TContract extends ArvoContract> = {
      */
     spanOptions?: ArvoEventHandlerOtelSpanOptions;
     /**
-     * Optional configuration to customize where system error events are emitted.
-     *
-     * This overrides the default system error domain fallback of:
-     * `[event.domain, handler.contract.domain, null]`
-     *
-     * Use this to precisely control the set of domains that should receive structured
-     * `sys.*.error` events when uncaught exceptions occur in the handler.
-     *
-     * Symbolic constants from {@link ArvoDomain} are supported.
-     *
-     * @default undefined — uses standard fallback broadcast domains
+     * Optional default domains for the events emitted
+     * by the event handler.
      */
-    systemErrorDomain?: (string | null)[];
+    defaultEventEmissionDomains?: {
+        /**
+         * Default domains for system error events emitted by this handler.
+         *
+         * 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 response events emitted by this handler.
+         *
+         * Response events are routed through these domains when the handler successfully
+         * processes an incoming event. Individual handler implementations can override
+         * this default on a per-event basis.
+         *
+         * @default [ArvoDomain.ORCHESTRATION_CONTEXT]
+         */
+        emits?: NonEmptyArray<string | null>;
+    };
 };

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,6 +134,7 @@ 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"];

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

@@ -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

@@ -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.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.
  */
@@ -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

@@ -69,16 +69,14 @@ var ArvoDomain_1 = require("../ArvoDomain");
 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 */
@@ -156,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',
@@ -231,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]
-                                                    : [ArvoDomain_1.ArvoDomain.LOCAL],
+                                                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,
                                             });
                                         }
@@ -264,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 = {
@@ -274,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 }];
                                 }
@@ -287,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.23",
+  "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.23",
+    "arvo-core": "3.0.25",
     "uuid": "11.1.0",
     "xstate": "5.24.0",
     "zod": "3.25.74",