arvo-event-handler 3.0.3 → 3.0.4

package/dist/ArvoEventHandler/index.js

@@ -81,77 +81,86 @@ var arvo_core_1 = require("arvo-core");
 var AbstractArvoEventHandler_1 = __importDefault(require("../AbstractArvoEventHandler"));
 var errors_1 = require("../errors");
 var utils_1 = require("../utils");
+var ArvoDomain_1 = require("../ArvoDomain");
 /**
- * ArvoEventHandler is the core component for processing events in the Arvo system. It enforces
- * contracts between services by ensuring that all events follow their specified formats and rules.
+ * `ArvoEventHandler` is the foundational component for building stateless,
+ * contract-bound services in the Arvo system.
  *
- * The handler is built on two fundamental patterns: Meyer's Design by Contract and Fowler's
- * Tolerant Reader. It binds to an ArvoContract that defines what events it can receive and send
- * across all versions. This versioning is strict - the handler must implement every version defined
- * in its contract, or it will fail both at compile time and runtime.
+ * It enforces strict contract validation, version-aware handler resolution,
+ * and safe, observable event emission — all while maintaining type safety,
+ * traceability, and support for multi-domain workflows.
  *
- * Following the Tolerant Reader pattern, the handler accepts any incoming event but only processes
- * those that exactly match one of its contract versions. When an event matches, it's handled by
- * the specific implementation for that version. This approach maintains compatibility while
- * ensuring precise contract adherence.
+ * ## What It Does
+ * - Ensures incoming events match the contract's `type` and `dataschema`
+ * - Resolves the correct contract version using `dataschema`
+ * - Validates input and output data via Zod schemas
+ * - Executes the version-specific handler function
+ * - Emits one or more response events based on the handler result
+ * - Supports multi-domain broadcasting via `domain[]` on the emitted events
+ * - Automatically emits system error events (`sys.*.error`) on failure
+ * - Integrates deeply with OpenTelemetry for tracing and observability
  *
- * The handler uses Zod for validation, automatically checking both incoming and outgoing events.
- * 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 Boundaries
+ * ArvoEventHandler enforces a clear separation between:
  *
- * ## Event Processing Lifecycle
+ * - **Violations** — structural, schema, or config errors that break the contract.
+ *   These are thrown and must be handled explicitly by the caller.
  *
- * 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 Errors** — runtime exceptions during execution that are caught and
+ *   emitted as standardized `sys.<contract>.error` events.
  *
- * ## Error Handling Strategy
+ * ## Domain Broadcasting
+ * The handler supports multi-domain event distribution. When the handler
+ * returns an event with a `domain` array, it is broadcast to one or more
+ * routing contexts.
  *
- * The handler divides issues into two distinct categories:
+ * ### System Error Domain Control
+ * By default, system error events are broadcast into the source event’s domain,
+ * the handler’s contract domain, and the `null` domain. This fallback ensures errors
+ * are visible across all relevant contexts. Developers can override this behavior
+ * using the optional `systemErrorDomain` field to specify an explicit set of
+ * domain values, including symbolic constants from {@link ArvoDomain}.
  *
- * - **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.
+ * ### Supported Domain Values:
+ * - A **concrete domain string** like `'audit.orders'` or `'human.review'`
+ * - `null` to emit with no domain (standard internal flow)
+ * - A **symbolic reference** from {@link ArvoDomain}
  *
- * - **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).
+ * ### Domain Resolution Rules:
+ * - Each item in the `domain` array is resolved via {@link resolveEventDomain}
+ * - Duplicate domains are deduplicated before emitting
+ * - If `domain` is omitted entirely, Arvo defaults to `[null]`
  *
- * ## Multi-Domain Event Broadcasting
+ * ### Example:
+ * ```ts
+ * return {
+ *   type: 'evt.user.registered',
+ *   data: { ... },
+ *   domain: ['analytics', ArvoDomain.FROM_TRIGGERING_EVENT, null]
+ * };
+ * ```
+ * This would emit at most 3 copies of the event, domained to:
+ * - `'analytics'`
+ * - the domain of the incoming event
+ * - no domain (default)
  *
- * The handler supports sophisticated multi-domain event distribution through array-based domain specification:
+ * ### Domain Usage Guidance
  *
- * ### 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)
+ * > **Avoid setting `contract.domain` unless fully intentional.**
+ * 99% emitted event should default to `null` (standard processing pipeline).
  *
- * ### 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`
+ * Contract-level domains enforce implicit routing for every emitted event
+ * in that handler, making the behavior harder to override and debug.
  *
- * ### 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`)
+ * Prefer:
+ * - Explicit per-event `domain` values in handler output
+ * - Using `null` or symbolic constants to control domain cleanly
  *
- * Duplicates are automatically removed, so if `event.domain === handler.contract.domain`,
- * only two error events are created instead of three.
+ * ## When to Use Domains
+ * Use domains when handling for specialized contexts:
+ * - `'human.review'` → for human-in-the-loop steps
+ * - `'analytics.workflow'` → to pipe events into observability systems
+ * - `'external.partner.sync'` → to route to external services
  */
 var ArvoEventHandler = /** @class */ (function (_super) {
     __extends(ArvoEventHandler, _super);
@@ -169,9 +178,11 @@ var ArvoEventHandler = /** @class */ (function (_super) {
         var _a;
         var _b, _c;
         var _this = _super.call(this) || this;
+        _this.systemErrorDomain = undefined;
         _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];
             if (!_this.handler[contractVersions]) {
@@ -231,7 +242,7 @@ var ArvoEventHandler = /** @class */ (function (_super) {
                     case 0:
                         otelConfig = (0, utils_1.createEventHandlerTelemetryConfig)("Handler<".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, 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 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, 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) {
@@ -266,33 +277,32 @@ var ArvoEventHandler = /** @class */ (function (_super) {
                                                         message: "Version resolution failed for event with dataschema '".concat(event.dataschema, "'. Defaulting to latest version (=").concat(this.contract.version('latest').version, ") of contract (uri=").concat(this.contract.uri, ")"),
                                                     });
                                                 }
-                                                handlerContract = void 0;
                                                 try {
-                                                    handlerContract = this.contract.version((_p = parsedDataSchema === null || parsedDataSchema === void 0 ? void 0 : parsedDataSchema.version) !== null && _p !== void 0 ? _p : 'latest');
+                                                    handlerContract_1 = this.contract.version((_p = parsedDataSchema === null || parsedDataSchema === void 0 ? void 0 : parsedDataSchema.version) !== null && _p !== void 0 ? _p : 'latest');
                                                 }
                                                 catch (_0) {
                                                     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)({
                                                     level: 'INFO',
-                                                    message: "Processing event with contract version ".concat(handlerContract.version),
+                                                    message: "Processing event with contract version ".concat(handlerContract_1.version),
                                                 });
-                                                inputEventValidation = handlerContract.accepts.schema.safeParse(event.data);
+                                                inputEventValidation = handlerContract_1.accepts.schema.safeParse(event.data);
                                                 if (inputEventValidation.error) {
                                                     throw new errors_1.ContractViolation("Input event payload validation failed: ".concat(inputEventValidation.error));
                                                 }
                                                 (0, arvo_core_1.logToSpan)({
                                                     level: 'INFO',
-                                                    message: "Event payload validated successfully against contract ".concat(arvo_core_1.EventDataschemaUtil.create(handlerContract)),
+                                                    message: "Event payload validated successfully against contract ".concat(arvo_core_1.EventDataschemaUtil.create(handlerContract_1)),
                                                 });
                                                 (0, arvo_core_1.logToSpan)({
                                                     level: 'INFO',
                                                     message: "Executing handler for event type '".concat(event.type, "'"),
                                                 });
-                                                return [4 /*yield*/, this.handler[handlerContract.version]({
+                                                return [4 /*yield*/, this.handler[handlerContract_1.version]({
                                                         event: event.toJSON(),
                                                         source: this.source,
-                                                        contract: handlerContract,
+                                                        contract: handlerContract_1,
                                                         domain: {
                                                             self: this.domain,
                                                             event: event.domain,
@@ -317,10 +327,17 @@ var ArvoEventHandler = /** @class */ (function (_super) {
                                                     item = outputs_1[_c];
                                                     try {
                                                         __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];
+                                                        domains = (_r = (_q = handlerResult.domain) === null || _q === void 0 ? void 0 : _q.map(function (item) {
+                                                            return (0, ArvoDomain_1.resolveEventDomain)({
+                                                                domainToResolve: item,
+                                                                handlerSelfContract: handlerContract_1,
+                                                                eventContract: handlerContract_1,
+                                                                triggeringEvent: event,
+                                                            });
+                                                        })) !== 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, 
+                                                            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: (_t = (_s = handlerResult.accesscontrol) !== null && _s !== void 0 ? _s : event.accesscontrol) !== null && _t !== void 0 ? _t : undefined, parentid: event.id, domain: _dom }), __extensions));
@@ -356,7 +373,16 @@ var ArvoEventHandler = /** @class */ (function (_super) {
                                                     throw error_1;
                                                 }
                                                 result = [];
-                                                for (_j = 0, _k = Array.from(new Set([event.domain, this.domain, null])); _j < _k.length; _j++) {
+                                                for (_j = 0, _k = Array.from(new Set(this.systemErrorDomain
+                                                    ? this.systemErrorDomain.map(function (item) {
+                                                        return (0, ArvoDomain_1.resolveEventDomain)({
+                                                            domainToResolve: item,
+                                                            handlerSelfContract: _this.contract.version('latest'),
+                                                            eventContract: _this.contract.version('latest'),
+                                                            triggeringEvent: event,
+                                                        });
+                                                    })
+                                                    : [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,

package/dist/ArvoEventHandler/types.d.ts

@@ -35,21 +35,29 @@ export type ArvoEventHandlerFunctionOutput<TContract extends VersionedArvoContra
         /** Optional extensions for the event. */
         __extensions?: Record<string, string | number | boolean>;
         /**
-         * The event domain configuration for multi-domain broadcasting.
+         * The domain configuration for multi-domain event broadcasting.
          *
-         * **Domain Broadcasting Rules:**
-         * - Each element in the array creates a separate ArvoEvent instance
-         * - `undefined` elements resolve using inheritance: `event.domain ?? contract.domain ?? null`
-         * - Duplicate domains are automatically removed to prevent redundant events
-         * - Omitting this field (or setting to `undefined`) defaults to `[null]`
+         * 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.
          *
-         * **Domain Broadcasting Patterns:**
-         * - `['domain1', 'domain2']` → Creates 2 events for different processing contexts
-         * - `['analytics', undefined, 'audit']` → Creates events for analytics, inherited context, and audit
-         * - `[null]` → Creates single event with no domain routing (standard processing)
-         * - `undefined` (or omitted) → Creates single event with `domain: null`
+         * **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]`
+         *
+         * **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]`
          */
-        domain?: (string | undefined | null)[];
+        domain?: (string | null)[];
     };
 }[keyof TContract['emits']];
 /**
@@ -81,4 +89,18 @@ export interface IArvoEventHandler<TContract extends ArvoContract> {
      * The OpenTelemetry span options
      */
     spanOptions?: SpanOptions;
+    /**
+     * 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
+     */
+    systemErrorDomain?: (string | null)[];
 }

package/dist/ArvoMachine/types.d.ts

@@ -36,21 +36,29 @@ export type ArvoMachineContext = {
  */
 export type EnqueueArvoEventActionParam<TData extends ArvoEventData = ArvoEventData, TType extends string = string, TExtension extends CloudEventExtension = CloudEventExtension> = {
     /**
-     * The event domain configuration for multi-domain broadcasting.
+     * The domain configuration for multi-domain event broadcasting.
      *
-     * **Domain Broadcasting Rules:**
-     * - Each element in the array creates a separate ArvoEvent instance
-     * - `undefined` elements resolve using inheritance: `event.domain ?? contract.domain ?? null`
-     * - Duplicate domains are automatically removed to prevent redundant events
-     * - Omitting this field (or setting to `undefined`) defaults to `[null]`
+     * 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.
      *
-     * **Domain Broadcasting Patterns:**
-     * - `['domain1', 'domain2']` → Creates 2 events for different processing contexts
-     * - `['analytics', undefined, 'audit']` → Creates events for analytics, inherited context, and audit
-     * - `[null]` → Creates single event with no domain routing (standard processing)
-     * - `undefined` (or omitted) → Creates single event with `domain: null`
+     * **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]`
+     *
+     * **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]`
      */
-    domain?: (string | null | undefined)[];
+    domain?: (string | null)[];
     /**
      * Custom extensions for the CloudEvent.
      * Allows for additional metadata to be attached to the event.

package/dist/ArvoOrchestrator/factory.d.ts

@@ -8,6 +8,7 @@ import type { ICreateArvoOrchestrator } from './types';
  * @param config.memory - State persistence interface for storing machine states
  * @param config.executionunits - Cost units for execution tracking
  * @param config.machines - Array of state machines to manage. Their resource locking flags determine orchestrator's locking behavior
+ * @param config.systemErrorDomain - An optional array of system error domain overrides
  * @returns Configured ArvoOrchestrator instance with default registry and execution engine
  *
  * @remarks
@@ -19,10 +20,10 @@ import type { ICreateArvoOrchestrator } from './types';
  * @example
  * ```typescript
  * const orchestrator = createArvoOrchestrator({
- *   memory: new MyMemoryImplementation(),
+ *   memory: new SimpleMachineMemory() // or, any other IMachineMemory implementation,
  *   executionunits: 1,
  *   machines: [machineA, machineB]
  * });
  * ```
  */
-export declare const createArvoOrchestrator: ({ executionunits, memory, machines, }: ICreateArvoOrchestrator) => ArvoOrchestrator;
+export declare const createArvoOrchestrator: ({ executionunits, memory, machines, systemErrorDomain, }: ICreateArvoOrchestrator) => ArvoOrchestrator;

package/dist/ArvoOrchestrator/factory.js

@@ -21,6 +21,7 @@ var MachineRegistry_1 = require("../MachineRegistry");
  * @param config.memory - State persistence interface for storing machine states
  * @param config.executionunits - Cost units for execution tracking
  * @param config.machines - Array of state machines to manage. Their resource locking flags determine orchestrator's locking behavior
+ * @param config.systemErrorDomain - An optional array of system error domain overrides
  * @returns Configured ArvoOrchestrator instance with default registry and execution engine
  *
  * @remarks
@@ -32,14 +33,14 @@ var MachineRegistry_1 = require("../MachineRegistry");
  * @example
  * ```typescript
  * const orchestrator = createArvoOrchestrator({
- *   memory: new MyMemoryImplementation(),
+ *   memory: new SimpleMachineMemory() // or, any other IMachineMemory implementation,
  *   executionunits: 1,
  *   machines: [machineA, machineB]
  * });
  * ```
  */
 var createArvoOrchestrator = function (_a) {
-    var executionunits = _a.executionunits, memory = _a.memory, machines = _a.machines;
+    var executionunits = _a.executionunits, memory = _a.memory, machines = _a.machines, systemErrorDomain = _a.systemErrorDomain;
     if (!(machines === null || machines === void 0 ? void 0 : machines.length)) {
         throw new Error('At least one machine must be provided');
     }
@@ -51,6 +52,7 @@ var createArvoOrchestrator = function (_a) {
         registry: registry,
         executionEngine: new MachineExecutionEngine_1.MachineExecutionEngine(),
         requiresResourceLocking: requiresResourceLocking,
+        systemErrorDomain: systemErrorDomain,
     });
 };
 exports.createArvoOrchestrator = createArvoOrchestrator;

package/dist/ArvoOrchestrator/index.d.ts

@@ -17,6 +17,7 @@ export declare class ArvoOrchestrator extends AbstractArvoEventHandler {
     readonly registry: IMachineRegistry;
     readonly executionEngine: IMachineExectionEngine;
     readonly syncEventResource: SyncEventResource<MachineMemoryRecord>;
+    readonly systemErrorDomain?: (string | null)[];
     get source(): any;
     get requiresResourceLocking(): boolean;
     get memory(): IMachineMemory<MachineMemoryRecord>;
@@ -26,7 +27,7 @@ export declare class ArvoOrchestrator extends AbstractArvoEventHandler {
      * @param params - Configuration parameters
      * @throws Error if machines in registry have different sources
      */
-    constructor({ executionunits, memory, registry, executionEngine, requiresResourceLocking }: IArvoOrchestrator);
+    constructor({ executionunits, memory, registry, executionEngine, requiresResourceLocking, systemErrorDomain, }: IArvoOrchestrator);
     /**
      * Creates emittable event from execution result
      * @param event - Source event to emit
@@ -40,15 +41,9 @@ export declare class ArvoOrchestrator extends AbstractArvoEventHandler {
      * @throws {ContractViolation} On schema/contract mismatch
      * @throws {ExecutionViolation} On invalid parentSubject$$ format
      */
-    protected createEmittableEvent(event: EnqueueArvoEventActionParam, machine: ArvoMachine<any, any, any, any, any>, otelHeaders: OpenTelemetryHeaders, orchestrationParentSubject: string | null, sourceEvent: ArvoEvent, initEventId: string, _domain: string | null | undefined): ArvoEvent;
+    protected createEmittableEvent(event: EnqueueArvoEventActionParam, machine: ArvoMachine<any, any, any, any, any>, otelHeaders: OpenTelemetryHeaders, orchestrationParentSubject: string | null, sourceEvent: ArvoEvent, initEventId: string, _domain: string | null): ArvoEvent;
     /**
      * Core orchestration method that executes state machines in response to events.
-     * Manages the complete event lifecycle:
-     * 1. Acquires lock and state
-     * 2. Validates events and contracts
-     * 3. Executes state machine
-     * 4. Persists new state
-     * 5. Generates response events with domain-based segregation
      *
      * @param event - Event triggering the execution
      * @param opentelemetry - OpenTelemetry configuration