arvo-event-handler 3.0.23 → 3.0.26

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/helpers.d.ts

@@ -14,7 +14,6 @@ import type { ArvoEventHandlerParam } from './types';
  * ```ts
  * const handler = createArvoEventHandler({
  *   contract: userContract,
- *   executionunits: 1,
  *   handler: {
  *     '1.0.0': async ({ event, domain, span }) => {
  *       if (domain.event !== domain.self) {

package/dist/ArvoEventHandler/helpers.js

@@ -18,7 +18,6 @@ var _1 = __importDefault(require("."));
  * ```ts
  * const handler = createArvoEventHandler({
  *   contract: userContract,
- *   executionunits: 1,
  *   handler: {
  *     '1.0.0': async ({ event, domain, span }) => {
  *       if (domain.event !== domain.self) {

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, _e;
         this.contract = param.contract;
-        this.executionunits = param.executionunits;
+        this.executionunits = (_b = param.executionunits) !== null && _b !== void 0 ? _b : 0;
         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] }, ((_c = param.defaultEventEmissionDomains) !== null && _c !== void 0 ? _c : {}));
+        for (var _i = 0, _f = Object.keys(this.contract.versions); _i < _f.length; _i++) {
+            var contractVersions = _f[_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), ((_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.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']];
 /**
@@ -81,7 +70,7 @@ export type ArvoEventHandlerParam<TContract extends ArvoContract> = {
      * The default execution cost of the function.
      * This can represent a dollar value or some other number with a rate card.
      */
-    executionunits: number;
+    executionunits?: number;
     /**
      * The functional handler of the event which takes the input, performs an action, and returns the result.
      * @param params - The input parameters for the handler function.
@@ -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>;
+    };
 };