arvo-event-handler 2.3.3 → 3.0.1

package/dist/AbstractArvoEventHandler/index.d.ts

@@ -57,7 +57,7 @@ export default abstract class AbstractArvoEventHandler {
      */
     abstract execute(event: ArvoEvent, opentelemetry: ArvoEventHandlerOpenTelemetryOptions): Promise<{
         events: ArvoEvent[];
-        [key: string]: unknown;
+        metadata?: Record<string, any>;
     }>;
     /**
      * Provides the schema for system error events.

package/dist/ArvoEventHandler/helpers.d.ts

@@ -2,21 +2,55 @@ import type { ArvoContract } from 'arvo-core';
 import ArvoEventHandler from '.';
 import type { IArvoEventHandler } from './types';
 /**
- * Creates an ArvoEventHandler for processing events defined by a specific contract.
- * Each handler manages event validation, processing, and telemetry for its contract.
+ * Create the instance of `ArvoEventHandler`
  *
- * @param param Configuration including contract, execution metrics and version handlers
- * @returns Configured ArvoEventHandler instance for the specified contract
+ * > **Caution:** Don't use domained contracts unless it is fully intentional. Using domained
+ * contracts causes implicit domain assignment which can be hard to track and confusing. For 99%
+ * of the cases you dont need domained contracts
+ *
+ * See {@link ArvoEventHandler}
  *
  * @example
+ * ```typescript
  * const handler = createArvoEventHandler({
  *   contract: userContract,
- *   executionunits: 10,
+ *   executionunits: 1,
  *   handler: {
- *     '1.0.0': async ({ event }) => {
+ *     '1.0.0': async ({ event, domain, span }) => {
+ *       // Access domain context
+ *       if (event.domain === 'priority.high') {
+ *         // Handle high-priority processing
+ *       }
+ *
+ *       if (domain.event !== domain.self) {
+ *          logToSpan({
+ *            level: 'WARN',
+ *            message: 'Domain mismatch detected'
+ *          }, span)
+ *       }
+ *
+ *
  *       // Process event according to contract v1.0.0
+ *       const result = await processUser(event.data);
+ *
+ *       // Return structured response
+ *       return {
+ *         type: 'evt.user.created',
+ *         data: result,
+ *         // Optional: override default routing
+ *         to: 'com.notification.service',
+ *         // Creates 2 events:
+ *         // - One for 'analytics.realtime' domain (specialized processing)
+ *         // - One with no domain (standard processing pipeline)
+ *         domain: ['analytics.realtime', null]
+ *       };
+ *     },
+ *     '2.0.0': async ({ event, contract, span }) => {
+ *       // Process event according to contract v2.0.0
+ *       // Handler must be implemented for all contract versions
  *     }
  *   }
  * });
+ * ```
  */
 export declare const createArvoEventHandler: <TContract extends ArvoContract>(param: IArvoEventHandler<TContract>) => ArvoEventHandler<TContract>;

package/dist/ArvoEventHandler/helpers.js

@@ -6,22 +6,56 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.createArvoEventHandler = void 0;
 var _1 = __importDefault(require("."));
 /**
- * Creates an ArvoEventHandler for processing events defined by a specific contract.
- * Each handler manages event validation, processing, and telemetry for its contract.
+ * Create the instance of `ArvoEventHandler`
  *
- * @param param Configuration including contract, execution metrics and version handlers
- * @returns Configured ArvoEventHandler instance for the specified contract
+ * > **Caution:** Don't use domained contracts unless it is fully intentional. Using domained
+ * contracts causes implicit domain assignment which can be hard to track and confusing. For 99%
+ * of the cases you dont need domained contracts
+ *
+ * See {@link ArvoEventHandler}
  *
  * @example
+ * ```typescript
  * const handler = createArvoEventHandler({
  *   contract: userContract,
- *   executionunits: 10,
+ *   executionunits: 1,
  *   handler: {
- *     '1.0.0': async ({ event }) => {
+ *     '1.0.0': async ({ event, domain, span }) => {
+ *       // Access domain context
+ *       if (event.domain === 'priority.high') {
+ *         // Handle high-priority processing
+ *       }
+ *
+ *       if (domain.event !== domain.self) {
+ *          logToSpan({
+ *            level: 'WARN',
+ *            message: 'Domain mismatch detected'
+ *          }, span)
+ *       }
+ *
+ *
  *       // Process event according to contract v1.0.0
+ *       const result = await processUser(event.data);
+ *
+ *       // Return structured response
+ *       return {
+ *         type: 'evt.user.created',
+ *         data: result,
+ *         // Optional: override default routing
+ *         to: 'com.notification.service',
+ *         // Creates 2 events:
+ *         // - One for 'analytics.realtime' domain (specialized processing)
+ *         // - One with no domain (standard processing pipeline)
+ *         domain: ['analytics.realtime', null]
+ *       };
+ *     },
+ *     '2.0.0': async ({ event, contract, span }) => {
+ *       // Process event according to contract v2.0.0
+ *       // Handler must be implemented for all contract versions
  *     }
  *   }
  * });
+ * ```
  */
 var createArvoEventHandler = function (param) { return new _1.default(param); };
 exports.createArvoEventHandler = createArvoEventHandler;

package/dist/ArvoEventHandler/index.d.ts

@@ -21,29 +21,59 @@ import type { ArvoEventHandlerFunction, IArvoEventHandler } from './types';
  * This means it not only verifies data formats but also applies default values where needed and
  * ensures all conditions are met before and after processing.
  *
- * Error handling in the handler divides issues into two categories:
+ * ## Event Processing Lifecycle
  *
- * - `Violations` are serious contract breaches that indicate fundamental problems with how services
- * are communicating. These errors bubble up to the calling code, allowing developers to handle
- * these critical issues explicitly.
+ * 1. **Type Validation**: Ensures the incoming event type matches the handler's contract
+ * 2. **Contract Resolution**: Extracts version from dataschema and resolves appropriate contract version
+ * 3. **Schema Validation**: Validates event data against the contract's accepts schema
+ * 4. **Handler Execution**: Invokes the version-specific handler implementation
+ * 5. **Response Processing**: Validates and structures handler output into events
+ * 6. **Domain Broadcasting**: Creates multiple events for multi-domain distribution if specified
+ * 7. **Routing Configuration**: Applies routing logic based on handler output and event context
+ * 8. **Telemetry Integration**: Records processing metrics and tracing information
  *
- * - `System Error Events` cover normal runtime errors that occur during event processing. These are
- * typically workflow-related issues that need to be reported back to the event's source but don't
- * indicate a broken contract.
+ * ## Error Handling Strategy
  *
- * * @example
- * const handler = createArvoEventHandler({
- *   contract: userContract,
- *   executionunits: 1,
- *   handler: {
- *     '1.0.0': async ({ event }) => {
- *       // Process event according to contract v1.0.0
- *     },
- *     '2.0.0': async ({ event }) => {
- *       // Process event according to contract v2.0.0
- *     }
- *   }
- * });
+ * The handler divides issues into two distinct categories:
+ *
+ * - **Violations** are serious contract breaches that indicate fundamental problems with how services
+ *   are communicating. These errors bubble up to the calling code, allowing developers to handle
+ *   these critical issues explicitly. Violations include contract mismatches, schema validation
+ *   failures, and configuration errors.
+ *
+ * - **System Error Events** cover normal runtime errors that occur during event processing. These are
+ *   typically workflow-related issues that need to be reported back to the event's source but don't
+ *   indicate a broken contract. System errors are converted to structured error events and returned
+ *   in the response. **Multi-domain error broadcasting** ensures error events reach all relevant
+ *   processing contexts (source event domain, handler contract domain, and null domain).
+ *
+ * ## Multi-Domain Event Broadcasting
+ *
+ * The handler supports sophisticated multi-domain event distribution through array-based domain specification:
+ *
+ * ### Domain Assignment Rules:
+ * 1. **Array Processing**: Each element in the `domain` array creates a separate ArvoEvent
+ * 2. **Undefined Resolution**: `undefined` elements resolve to: `event.domain ?? handler.contract.domain ?? null`
+ * 3. **Automatic Deduplication**: Duplicate domains are removed to prevent redundant events
+ * 4. **Default Behavior**: Omitted/undefined `domain` field defaults to `[null]` (single event, no domain)
+ *
+ * ### Domain Patterns:
+ * - `domain: ['domain1', 'domain2']` → Creates 2 events: one for each domain
+ * - `domain: ['analytics', undefined, null]` → Creates up to 3 events:
+ *   - Event with `domain: 'analytics'`
+ *   - Event with `domain: event.domain ?? handler.contract.domain ?? null`
+ *   - Event with `domain: null`
+ * - `domain: [null]` → Single event with explicit no-domain routing
+ * - `domain: undefined` (or omitted) → Single event with `domain: null`
+ *
+ * ### Error Broadcasting:
+ * System errors are automatically broadcast to all relevant processing contexts:
+ * - Source event domain (`event.domain`)
+ * - Handler contract domain (`handler.contract.domain`)
+ * - No-domain context (`null`)
+ *
+ * Duplicates are automatically removed, so if `event.domain === handler.contract.domain`,
+ * only two error events are created instead of three.
  */
 export default class ArvoEventHandler<TContract extends ArvoContract> extends AbstractArvoEventHandler {
     /** Contract instance that defines the event schema and validation rules */
@@ -56,6 +86,12 @@ export default class ArvoEventHandler<TContract extends ArvoContract> extends Ab
     readonly handler: ArvoEventHandlerFunction<TContract>;
     /** The source identifier for events produced by this handler */
     get source(): TContract['type'];
+    /**
+     * The contract-defined domain for this handler, used as the default domain for emitted events.
+     * Can be overridden by individual handler implementations for cross-domain workflows.
+     * Returns null if no domain is specified, indicating standard processing context.
+     */
+    get domain(): string | null;
     /**
      * Initializes a new ArvoEventHandler instance with the specified contract and configuration.
      * Validates handler implementations against contract versions during initialization.
@@ -69,46 +105,39 @@ export default class ArvoEventHandler<TContract extends ArvoContract> extends Ab
     constructor(param: IArvoEventHandler<TContract>);
     /**
      * Processes an incoming event according to the handler's contract specifications. This method
-     * handles the complete lifecycle of event processing including validation, execution, and error
-     * handling, while maintaining detailed telemetry through OpenTelemetry.
-     *
-     * The execution follows a careful sequence to ensure reliability:
-     * First, it validates that the event matches the handler's contract type. Then it extracts
-     * and validates the event's schema version, defaulting to the latest version if none is specified.
-     * After validation passes, it executes the version-specific handler function and processes its
-     * output into new events.
-     *
-     * The method handles routing through three distinct paths:
-     * - For successful execution, events are routed based on handler output or configuration.
-     *    - The 'to' field in the handler's result (if specified)
-     *    - The 'redirectto' field from the source event (if present)
-     *    - Falls back to the source event's 'source' field
-     * - For violations (mismatched types, invalid data), errors bubble up to the caller
-     * - For runtime errors, system error events are created and sent back to the source
-     *
-     * Throughout execution, comprehensive telemetry is maintained through OpenTelemetry spans,
-     * tracking the complete event journey including validation steps, processing time, and any
-     * errors that occur. This enables detailed monitoring and debugging of the event flow.
+     * handles the complete lifecycle of event processing including validation, execution, error
+     * handling, and multi-domain event broadcasting, while maintaining detailed telemetry through OpenTelemetry.
      *
      * @param event - The incoming event to process
-     * @param opentelemetry - Configuration for OpenTelemetry context inheritance
-     * @returns Promise resolving to an array of output events or error events
-     * @throws `ContractViolation` when input or output event data violates the contract
-     * @throws `ConfigViolation` when event type doesn't match contract type or the
+     * @param opentelemetry - Configuration for OpenTelemetry context inheritance, defaults to inheriting from the event
+     * @returns Promise resolving to a structured result containing an array of output events
+     * @returns Structured response containing:
+     *   - `events`: Array of events to be emitted (may contain multiple events per handler output due to domain broadcasting)
+     *
+     * @throws {ContractViolation} when input or output event data violates the contract schema,
+     *                             or when event emission fails due to invalid data
+     * @throws {ConfigViolation} when event type doesn't match contract type, when the
      *                           contract version expected by the event does not exist
-     *                           in handler configuration
-     * @throws `ExecutionViolation` for explicitly handled runtime errors
+     *                           in handler configuration, or when contract URI mismatch occurs
+     * @throws {ExecutionViolation} for explicitly handled runtime errors that should bubble up
      */
     execute(event: ArvoEvent, opentelemetry?: ArvoEventHandlerOpenTelemetryOptions): Promise<{
         events: ArvoEvent[];
     }>;
     /**
      * Provides access to the system error event schema configuration.
+     *
      * The schema defines the structure of error events emitted during execution failures.
+     * These events are automatically generated when runtime errors occur and follow a
+     * standardized format for consistent error handling across the system.
+     *
+     * Error events follow the naming convention: `sys.<contract-type>.error`
+     *
+     * @example
+     * For a contract handling 'com.user.create' events, system error events
+     * will have the type 'sys.com.user.create.error'
      *
-     * Error events follow the naming convention: sys.<contract-type>.error
-     * For example, a contract handling 'user.created' events will emit error events
-     * with the type 'sys.user.created.error'.
+     * @returns The error event schema containing type and validation rules
      */
     get systemErrorSchema(): import("arvo-core").ArvoContractRecord<`sys.${string}.error`, import("zod").ZodObject<{
         errorName: import("zod").ZodString;

package/dist/ArvoEventHandler/index.js

@@ -61,6 +61,17 @@ var __generator = (this && this.__generator) || function (thisArg, body) {
         if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
     }
 };
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
@@ -88,29 +99,59 @@ var utils_1 = require("../utils");
  * This means it not only verifies data formats but also applies default values where needed and
  * ensures all conditions are met before and after processing.
  *
- * Error handling in the handler divides issues into two categories:
+ * ## Event Processing Lifecycle
+ *
+ * 1. **Type Validation**: Ensures the incoming event type matches the handler's contract
+ * 2. **Contract Resolution**: Extracts version from dataschema and resolves appropriate contract version
+ * 3. **Schema Validation**: Validates event data against the contract's accepts schema
+ * 4. **Handler Execution**: Invokes the version-specific handler implementation
+ * 5. **Response Processing**: Validates and structures handler output into events
+ * 6. **Domain Broadcasting**: Creates multiple events for multi-domain distribution if specified
+ * 7. **Routing Configuration**: Applies routing logic based on handler output and event context
+ * 8. **Telemetry Integration**: Records processing metrics and tracing information
+ *
+ * ## Error Handling Strategy
+ *
+ * The handler divides issues into two distinct categories:
+ *
+ * - **Violations** are serious contract breaches that indicate fundamental problems with how services
+ *   are communicating. These errors bubble up to the calling code, allowing developers to handle
+ *   these critical issues explicitly. Violations include contract mismatches, schema validation
+ *   failures, and configuration errors.
+ *
+ * - **System Error Events** cover normal runtime errors that occur during event processing. These are
+ *   typically workflow-related issues that need to be reported back to the event's source but don't
+ *   indicate a broken contract. System errors are converted to structured error events and returned
+ *   in the response. **Multi-domain error broadcasting** ensures error events reach all relevant
+ *   processing contexts (source event domain, handler contract domain, and null domain).
+ *
+ * ## Multi-Domain Event Broadcasting
  *
- * - `Violations` are serious contract breaches that indicate fundamental problems with how services
- * are communicating. These errors bubble up to the calling code, allowing developers to handle
- * these critical issues explicitly.
+ * The handler supports sophisticated multi-domain event distribution through array-based domain specification:
  *
- * - `System Error Events` cover normal runtime errors that occur during event processing. These are
- * typically workflow-related issues that need to be reported back to the event's source but don't
- * indicate a broken contract.
+ * ### Domain Assignment Rules:
+ * 1. **Array Processing**: Each element in the `domain` array creates a separate ArvoEvent
+ * 2. **Undefined Resolution**: `undefined` elements resolve to: `event.domain ?? handler.contract.domain ?? null`
+ * 3. **Automatic Deduplication**: Duplicate domains are removed to prevent redundant events
+ * 4. **Default Behavior**: Omitted/undefined `domain` field defaults to `[null]` (single event, no domain)
  *
- * * @example
- * const handler = createArvoEventHandler({
- *   contract: userContract,
- *   executionunits: 1,
- *   handler: {
- *     '1.0.0': async ({ event }) => {
- *       // Process event according to contract v1.0.0
- *     },
- *     '2.0.0': async ({ event }) => {
- *       // Process event according to contract v2.0.0
- *     }
- *   }
- * });
+ * ### Domain Patterns:
+ * - `domain: ['domain1', 'domain2']` → Creates 2 events: one for each domain
+ * - `domain: ['analytics', undefined, null]` → Creates up to 3 events:
+ *   - Event with `domain: 'analytics'`
+ *   - Event with `domain: event.domain ?? handler.contract.domain ?? null`
+ *   - Event with `domain: null`
+ * - `domain: [null]` → Single event with explicit no-domain routing
+ * - `domain: undefined` (or omitted) → Single event with `domain: null`
+ *
+ * ### Error Broadcasting:
+ * System errors are automatically broadcast to all relevant processing contexts:
+ * - Source event domain (`event.domain`)
+ * - Handler contract domain (`handler.contract.domain`)
+ * - No-domain context (`null`)
+ *
+ * Duplicates are automatically removed, so if `event.domain === handler.contract.domain`,
+ * only two error events are created instead of three.
  */
 var ArvoEventHandler = /** @class */ (function (_super) {
     __extends(ArvoEventHandler, _super);
@@ -148,37 +189,35 @@ var ArvoEventHandler = /** @class */ (function (_super) {
         enumerable: false,
         configurable: true
     });
+    Object.defineProperty(ArvoEventHandler.prototype, "domain", {
+        /**
+         * The contract-defined domain for this handler, used as the default domain for emitted events.
+         * Can be overridden by individual handler implementations for cross-domain workflows.
+         * Returns null if no domain is specified, indicating standard processing context.
+         */
+        get: function () {
+            return this.contract.domain;
+        },
+        enumerable: false,
+        configurable: true
+    });
     /**
      * Processes an incoming event according to the handler's contract specifications. This method
-     * handles the complete lifecycle of event processing including validation, execution, and error
-     * handling, while maintaining detailed telemetry through OpenTelemetry.
-     *
-     * The execution follows a careful sequence to ensure reliability:
-     * First, it validates that the event matches the handler's contract type. Then it extracts
-     * and validates the event's schema version, defaulting to the latest version if none is specified.
-     * After validation passes, it executes the version-specific handler function and processes its
-     * output into new events.
-     *
-     * The method handles routing through three distinct paths:
-     * - For successful execution, events are routed based on handler output or configuration.
-     *    - The 'to' field in the handler's result (if specified)
-     *    - The 'redirectto' field from the source event (if present)
-     *    - Falls back to the source event's 'source' field
-     * - For violations (mismatched types, invalid data), errors bubble up to the caller
-     * - For runtime errors, system error events are created and sent back to the source
-     *
-     * Throughout execution, comprehensive telemetry is maintained through OpenTelemetry spans,
-     * tracking the complete event journey including validation steps, processing time, and any
-     * errors that occur. This enables detailed monitoring and debugging of the event flow.
+     * handles the complete lifecycle of event processing including validation, execution, error
+     * handling, and multi-domain event broadcasting, while maintaining detailed telemetry through OpenTelemetry.
      *
      * @param event - The incoming event to process
-     * @param opentelemetry - Configuration for OpenTelemetry context inheritance
-     * @returns Promise resolving to an array of output events or error events
-     * @throws `ContractViolation` when input or output event data violates the contract
-     * @throws `ConfigViolation` when event type doesn't match contract type or the
+     * @param opentelemetry - Configuration for OpenTelemetry context inheritance, defaults to inheriting from the event
+     * @returns Promise resolving to a structured result containing an array of output events
+     * @returns Structured response containing:
+     *   - `events`: Array of events to be emitted (may contain multiple events per handler output due to domain broadcasting)
+     *
+     * @throws {ContractViolation} when input or output event data violates the contract schema,
+     *                             or when event emission fails due to invalid data
+     * @throws {ConfigViolation} when event type doesn't match contract type, when the
      *                           contract version expected by the event does not exist
-     *                           in handler configuration
-     * @throws `ExecutionViolation` for explicitly handled runtime errors
+     *                           in handler configuration, or when contract URI mismatch occurs
+     * @throws {ExecutionViolation} for explicitly handled runtime errors that should bubble up
      */
     ArvoEventHandler.prototype.execute = function (event_1) {
         return __awaiter(this, arguments, void 0, function (event, opentelemetry) {
@@ -192,15 +231,16 @@ var ArvoEventHandler = /** @class */ (function (_super) {
                     case 0:
                         otelConfig = (0, utils_1.createEventHandlerTelemetryConfig)("ArvoEventHandler<".concat(this.contract.uri, ">"), this.spanOptions, opentelemetry, 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, inputEventValidation, _handleOutput, outputs, eventFactory_1, result, error_1, eventFactory, result, _c, _d, _e, key, value;
-                                    var _f, _g, _h, _j, _k;
-                                    return __generator(this, function (_l) {
-                                        switch (_l.label) {
+                                    var otelSpanHeaders, _i, _a, _b, key, value, parsedDataSchema, handlerContract, inputEventValidation, _handleOutput, outputs, result, _c, outputs_1, item, __extensions, handlerResult, domains, _d, _e, _dom, _f, _g, _h, key, value, error_1, result, _j, _k, _dom, _l, _m, _o, key, value;
+                                    var _this = this;
+                                    var _p, _q, _r, _s, _t, _u, _v, _w, _x, _y;
+                                    return __generator(this, function (_z) {
+                                        switch (_z.label) {
                                             case 0:
                                                 otelSpanHeaders = (0, arvo_core_1.currentOpenTelemetryHeaders)();
-                                                _l.label = 1;
+                                                _z.label = 1;
                                             case 1:
-                                                _l.trys.push([1, 3, 4, 5]);
+                                                _z.trys.push([1, 3, 4, 5]);
                                                 span.setStatus({ code: api_1.SpanStatusCode.OK });
                                                 for (_i = 0, _a = Object.entries(event.otelAttributes); _i < _a.length; _i++) {
                                                     _b = _a[_i], key = _b[0], value = _b[1];
@@ -228,7 +268,7 @@ var ArvoEventHandler = /** @class */ (function (_super) {
                                                 }
                                                 handlerContract = void 0;
                                                 try {
-                                                    handlerContract = this.contract.version((_f = parsedDataSchema === null || parsedDataSchema === void 0 ? void 0 : parsedDataSchema.version) !== null && _f !== void 0 ? _f : 'latest');
+                                                    handlerContract = this.contract.version((_p = parsedDataSchema === null || parsedDataSchema === void 0 ? void 0 : parsedDataSchema.version) !== null && _p !== void 0 ? _p : 'latest');
                                                 }
                                                 catch (error) {
                                                     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(', ')));
@@ -250,12 +290,17 @@ var ArvoEventHandler = /** @class */ (function (_super) {
                                                     message: "Executing handler for event type '".concat(event.type, "'"),
                                                 });
                                                 return [4 /*yield*/, this.handler[handlerContract.version]({
-                                                        event: event,
+                                                        event: event.toJSON(),
                                                         source: this.source,
+                                                        contract: handlerContract,
+                                                        domain: {
+                                                            self: this.domain,
+                                                            event: event.domain,
+                                                        },
                                                         span: span,
                                                     })];
                                             case 2:
-                                                _handleOutput = _l.sent();
+                                                _handleOutput = _z.sent();
                                                 if (!_handleOutput)
                                                     return [2 /*return*/, {
                                                             events: [],
@@ -267,15 +312,28 @@ var ArvoEventHandler = /** @class */ (function (_super) {
                                                 else {
                                                     outputs = [_handleOutput];
                                                 }
-                                                eventFactory_1 = (0, arvo_core_1.createArvoEventFactory)(handlerContract);
-                                                result = (0, utils_1.eventHandlerOutputEventCreator)(outputs, otelSpanHeaders, this.source, event, this.executionunits, function (param, extensions) {
+                                                result = [];
+                                                for (_c = 0, outputs_1 = outputs; _c < outputs_1.length; _c++) {
+                                                    item = outputs_1[_c];
                                                     try {
-                                                        return eventFactory_1.emits(param, extensions);
+                                                        __extensions = item.__extensions, handlerResult = __rest(item, ["__extensions"]);
+                                                        domains = (_r = (_q = handlerResult.domain) === null || _q === void 0 ? void 0 : _q.map(function (item) { var _a, _b; return item === undefined ? ((_b = (_a = event.domain) !== null && _a !== void 0 ? _a : _this.domain) !== null && _b !== void 0 ? _b : null) : item; })) !== null && _r !== void 0 ? _r : [null];
+                                                        for (_d = 0, _e = Array.from(new Set(domains)); _d < _e.length; _d++) {
+                                                            _dom = _e[_d];
+                                                            result.push((0, arvo_core_1.createArvoEventFactory)(handlerContract).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: (_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("to_emit.".concat(result.length - 1, ".").concat(key), value);
+                                                            }
+                                                        }
                                                     }
                                                     catch (e) {
-                                                        throw new errors_1.ContractViolation(e.message);
+                                                        throw new errors_1.ContractViolation((_u = e === null || e === void 0 ? void 0 : e.message) !== null && _u !== void 0 ? _u : 'Invalid data');
                                                     }
-                                                });
+                                                }
                                                 (0, arvo_core_1.logToSpan)({
                                                     level: 'INFO',
                                                     message: "Event processing completed successfully. Generated ".concat(result.length, " event(s)"),
@@ -288,7 +346,7 @@ var ArvoEventHandler = /** @class */ (function (_super) {
                                                         events: result,
                                                     }];
                                             case 3:
-                                                error_1 = _l.sent();
+                                                error_1 = _z.sent();
                                                 (0, arvo_core_1.exceptionToSpan)(error_1);
                                                 span.setStatus({
                                                     code: api_1.SpanStatusCode.ERROR,
@@ -297,26 +355,30 @@ var ArvoEventHandler = /** @class */ (function (_super) {
                                                 if (error_1.name.includes('ViolationError')) {
                                                     throw error_1;
                                                 }
-                                                eventFactory = (0, arvo_core_1.createArvoEventFactory)(this.contract.version('latest'));
-                                                result = eventFactory.systemError({
-                                                    source: this.source,
-                                                    subject: event.subject,
-                                                    // The system error must always got back to
-                                                    // the source
-                                                    to: event.source,
-                                                    error: error_1,
-                                                    executionunits: this.executionunits,
-                                                    traceparent: (_g = otelSpanHeaders.traceparent) !== null && _g !== void 0 ? _g : undefined,
-                                                    tracestate: (_h = otelSpanHeaders.tracestate) !== null && _h !== void 0 ? _h : undefined,
-                                                    accesscontrol: (_j = event.accesscontrol) !== null && _j !== void 0 ? _j : undefined,
-                                                    parentid: (_k = event.id) !== null && _k !== void 0 ? _k : undefined,
-                                                }, {});
-                                                for (_c = 0, _d = Object.entries(result.otelAttributes); _c < _d.length; _c++) {
-                                                    _e = _d[_c], key = _e[0], value = _e[1];
-                                                    span.setAttribute("to_emit.0.".concat(key), value);
+                                                result = [];
+                                                for (_j = 0, _k = Array.from(new Set([event.domain, this.domain, null])); _j < _k.length; _j++) {
+                                                    _dom = _k[_j];
+                                                    result.push((0, arvo_core_1.createArvoEventFactory)(this.contract.version('latest')).systemError({
+                                                        source: this.source,
+                                                        subject: event.subject,
+                                                        // The system error must always got back to
+                                                        // the source
+                                                        to: event.source,
+                                                        error: error_1,
+                                                        executionunits: this.executionunits,
+                                                        traceparent: (_v = otelSpanHeaders.traceparent) !== null && _v !== void 0 ? _v : undefined,
+                                                        tracestate: (_w = otelSpanHeaders.tracestate) !== null && _w !== void 0 ? _w : undefined,
+                                                        accesscontrol: (_x = event.accesscontrol) !== null && _x !== void 0 ? _x : undefined,
+                                                        parentid: (_y = event.id) !== null && _y !== void 0 ? _y : undefined,
+                                                        domain: _dom,
+                                                    }));
+                                                    for (_l = 0, _m = Object.entries(result[result.length - 1].otelAttributes); _l < _m.length; _l++) {
+                                                        _o = _m[_l], key = _o[0], value = _o[1];
+                                                        span.setAttribute("to_emit.".concat(result.length - 1, ".").concat(key), value);
+                                                    }
                                                 }
                                                 return [2 /*return*/, {
-                                                        events: [result],
+                                                        events: result,
                                                     }];
                                             case 4:
                                                 span.end();
@@ -333,11 +395,18 @@ var ArvoEventHandler = /** @class */ (function (_super) {
     Object.defineProperty(ArvoEventHandler.prototype, "systemErrorSchema", {
         /**
          * Provides access to the system error event schema configuration.
+         *
          * The schema defines the structure of error events emitted during execution failures.
+         * These events are automatically generated when runtime errors occur and follow a
+         * standardized format for consistent error handling across the system.
+         *
+         * Error events follow the naming convention: `sys.<contract-type>.error`
+         *
+         * @example
+         * For a contract handling 'com.user.create' events, system error events
+         * will have the type 'sys.com.user.create.error'
          *
-         * Error events follow the naming convention: sys.<contract-type>.error
-         * For example, a contract handling 'user.created' events will emit error events
-         * with the type 'sys.user.created.error'.
+         * @returns The error event schema containing type and validation rules
          */
         get: function () {
             return this.contract.systemError;