arvo-event-handler 3.0.6 → 3.0.7

package/dist/ArvoEventHandler/helpers.d.ts

@@ -1,6 +1,6 @@
 import type { ArvoContract } from 'arvo-core';
 import ArvoEventHandler from '.';
-import type { IArvoEventHandler } from './types';
+import type { ArvoEventHandlerParam } from './types';
 /**
  * Creates an instance of `ArvoEventHandler` for the specified versioned contract and handlers.
  *
@@ -42,4 +42,4 @@ import type { IArvoEventHandler } from './types';
  * @param param - Configuration object containing contract, versioned handlers, execution units, and span settings
  * @returns A fully configured `ArvoEventHandler` instance for the given contract
  */
-export declare const createArvoEventHandler: <TContract extends ArvoContract>(param: IArvoEventHandler<TContract>) => ArvoEventHandler<TContract>;
+export declare const createArvoEventHandler: <TContract extends ArvoContract>(param: ArvoEventHandlerParam<TContract>) => ArvoEventHandler<TContract>;

package/dist/ArvoEventHandler/index.d.ts

@@ -1,8 +1,8 @@
 import { type SpanOptions } from '@opentelemetry/api';
 import { type ArvoContract, type ArvoEvent } from 'arvo-core';
-import AbstractArvoEventHandler from '../AbstractArvoEventHandler';
+import IArvoEventHandler from '../IArvoEventHandler';
 import type { ArvoEventHandlerOpenTelemetryOptions } from '../types';
-import type { ArvoEventHandlerFunction, IArvoEventHandler } from './types';
+import type { ArvoEventHandlerFunction, ArvoEventHandlerParam } from './types';
 /**
  * `ArvoEventHandler` is the foundational component for building stateless,
  * contract-bound services in the Arvo system.
@@ -83,7 +83,7 @@ import type { ArvoEventHandlerFunction, IArvoEventHandler } from './types';
  * - `'analytics.workflow'` → to pipe events into observability systems
  * - `'external.partner.sync'` → to route to external services
  */
-export default class ArvoEventHandler<TContract extends ArvoContract> extends AbstractArvoEventHandler {
+export default class ArvoEventHandler<TContract extends ArvoContract> implements IArvoEventHandler {
     /** Contract instance that defines the event schema and validation rules */
     readonly contract: TContract;
     /** Computational cost metric associated with event handling operations */
@@ -111,7 +111,7 @@ export default class ArvoEventHandler<TContract extends ArvoContract> extends Ab
      * @param param - Handler configuration including contract, execution units, and handler implementations
      * @throws When handler implementations are missing for any contract version
      */
-    constructor(param: IArvoEventHandler<TContract>);
+    constructor(param: ArvoEventHandlerParam<TContract>);
     /**
      * Processes an incoming event according to the handler's contract specifications. This method
      * handles the complete lifecycle of event processing including validation, execution, error

package/dist/ArvoEventHandler/index.js

@@ -1,19 +1,4 @@
 "use strict";
-var __extends = (this && this.__extends) || (function () {
-    var extendStatics = function (d, b) {
-        extendStatics = Object.setPrototypeOf ||
-            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
-            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
-        return extendStatics(d, b);
-    };
-    return function (d, b) {
-        if (typeof b !== "function" && b !== null)
-            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
-        extendStatics(d, b);
-        function __() { this.constructor = d; }
-        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
-    };
-})();
 var __assign = (this && this.__assign) || function () {
     __assign = Object.assign || function(t) {
         for (var s, i = 1, n = arguments.length; i < n; i++) {
@@ -72,13 +57,9 @@ var __rest = (this && this.__rest) || function (s, e) {
         }
     return t;
 };
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 var api_1 = require("@opentelemetry/api");
 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");
@@ -162,8 +143,7 @@ var ArvoDomain_1 = require("../ArvoDomain");
  * - `'analytics.workflow'` → to pipe events into observability systems
  * - `'external.partner.sync'` → to route to external services
  */
-var ArvoEventHandler = /** @class */ (function (_super) {
-    __extends(ArvoEventHandler, _super);
+var ArvoEventHandler = /** @class */ (function () {
     /**
      * Initializes a new ArvoEventHandler instance with the specified contract and configuration.
      * Validates handler implementations against contract versions during initialization.
@@ -177,20 +157,18 @@ var ArvoEventHandler = /** @class */ (function (_super) {
     function ArvoEventHandler(param) {
         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++) {
+        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]) {
-                throw new Error("Contract ".concat(_this.contract.uri, " requires handler implementation for version ").concat(contractVersions));
+            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 }) });
-        return _this;
+        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 }) });
     }
     Object.defineProperty(ArvoEventHandler.prototype, "source", {
         /** The source identifier for events produced by this handler */
@@ -308,6 +286,7 @@ var ArvoEventHandler = /** @class */ (function (_super) {
                                                             event: event.domain,
                                                         },
                                                         span: span,
+                                                        spanHeaders: otelSpanHeaders,
                                                     })];
                                             case 2:
                                                 _handleOutput = _z.sent();
@@ -441,5 +420,5 @@ var ArvoEventHandler = /** @class */ (function (_super) {
         configurable: true
     });
     return ArvoEventHandler;
-}(AbstractArvoEventHandler_1.default));
+}());
 exports.default = ArvoEventHandler;

package/dist/ArvoEventHandler/types.d.ts

@@ -1,5 +1,5 @@
 import type { Span, SpanOptions } from '@opentelemetry/api';
-import type { ArvoContract, ArvoEvent, ArvoSemanticVersion, CreateArvoEvent, InferArvoEvent, VersionedArvoContract } from 'arvo-core';
+import type { ArvoContract, ArvoEvent, ArvoSemanticVersion, CreateArvoEvent, InferArvoEvent, OpenTelemetryHeaders, VersionedArvoContract } from 'arvo-core';
 import type { z } from 'zod';
 /**
  * Represents the input for an ArvoEvent handler function.
@@ -18,6 +18,8 @@ export type ArvoEventHandlerFunctionInput<TContract extends VersionedArvoContrac
     contract: TContract;
     /** The OpenTelemetry span */
     span: Span;
+    /** The span headers */
+    spanHeaders: OpenTelemetryHeaders;
 };
 /**
  * Represents the output of an ArvoEvent handler function.
@@ -69,7 +71,7 @@ export type ArvoEventHandlerFunction<TContract extends ArvoContract> = {
 /**
  * Interface for an ArvoEvent handler.
  */
-export interface IArvoEventHandler<TContract extends ArvoContract> {
+export type ArvoEventHandlerParam<TContract extends ArvoContract> = {
     /**
      * The contract for the handler defining its input and outputs as well as the description.
      */
@@ -103,4 +105,4 @@ export interface IArvoEventHandler<TContract extends ArvoContract> {
      * @default undefined — uses standard fallback broadcast domains
      */
     systemErrorDomain?: (string | null)[];
-}
+};

package/dist/ArvoMachine/createMachine.d.ts

@@ -1,4 +1,4 @@
-import { type ArvoOrchestratorEventTypeGen, type InferVersionedArvoContract, type VersionedArvoContract } from 'arvo-core';
+import { type ArvoOrchestratorEventTypeGen, CreateArvoEvent, type InferVersionedArvoContract, type VersionedArvoContract } from 'arvo-core';
 import { type ActionFunction, type MachineConfig, type MachineContext, type MetaObject, type ParameterizedObject, type SetupTypes } from 'xstate';
 import type { z } from 'zod';
 import ArvoMachine from '.';
@@ -185,7 +185,9 @@ export declare function setupArvoMachine<TContext extends MachineContext, TSelfC
 }): {
     createMachine: <const TConfig extends MachineConfig<TContext, InferServiceContract<TServiceContracts>["events"], ToProvidedActor<{}, {}>, ToParameterizedObject<TActions & {
         enqueueArvoEvent: EnqueueArvoEventActionParam;
-    }>, ToParameterizedObject<TGuards>, never, TTag, InferVersionedArvoContract<TSelfContract>["accepts"], z.input<TSelfContract["emits"][ReturnType<typeof ArvoOrchestratorEventTypeGen.complete<ExtractOrchestratorType<TSelfContract["accepts"]["type"]>>>]>, InferServiceContract<TServiceContracts>["emitted"], TMeta>>(config: TConfig & {
+    }>, ToParameterizedObject<TGuards>, never, TTag, InferVersionedArvoContract<TSelfContract>["accepts"], z.input<TSelfContract["emits"][ReturnType<typeof ArvoOrchestratorEventTypeGen.complete<ExtractOrchestratorType<TSelfContract["accepts"]["type"]>>>]> & {
+        __id?: CreateArvoEvent<Record<string, unknown>, string>["id"];
+    }, InferServiceContract<TServiceContracts>["emitted"], TMeta>>(config: TConfig & {
         id: string;
         version?: TSelfContract["version"];
     }) => ArvoMachine<string, TSelfContract["version"], TSelfContract, TServiceContracts, import("xstate").StateMachine<TContext, { [K in keyof TServiceContracts]: import("./types").InferEmittableEventsFromVersionedArvoContract<TServiceContracts[K]>; }[keyof TServiceContracts], {}, never, import("xstate").IsNever<TActions & {

package/dist/ArvoMachine/types.d.ts

@@ -1,4 +1,4 @@
-import type { ArvoContract, ArvoEventData, ArvoOrchestratorEventTypeGen, ArvoSemanticVersion, CloudEventExtension, InferVersionedArvoContract, VersionedArvoContract } from 'arvo-core';
+import type { ArvoContract, ArvoEventData, ArvoOrchestratorEventTypeGen, ArvoSemanticVersion, CloudEventExtension, CreateArvoEvent, InferVersionedArvoContract, VersionedArvoContract } from 'arvo-core';
 import type { Invert, IsNever, ParameterizedObject, UnknownActorLogic, Values } from 'xstate';
 import type { z } from 'zod';
 /**
@@ -35,6 +35,10 @@ export type ArvoMachineContext = {
  * ```
  */
 export type EnqueueArvoEventActionParam<TData extends ArvoEventData = ArvoEventData, TType extends string = string, TExtension extends CloudEventExtension = CloudEventExtension> = {
+    /**
+     * The event id
+     */
+    id?: CreateArvoEvent<TData, TType>['id'];
     /**
      * The domain configuration for multi-domain event broadcasting.
      *

package/dist/ArvoOrchestrator/index.d.ts

@@ -4,15 +4,15 @@ import type { EnqueueArvoEventActionParam } from '../ArvoMachine/types';
 import type { IMachineExectionEngine } from '../MachineExecutionEngine/interface';
 import type { IMachineMemory } from '../MachineMemory/interface';
 import type { IMachineRegistry } from '../MachineRegistry/interface';
-import type { IArvoOrchestrator, MachineMemoryRecord } from './types';
+import type { ArvoOrchestratorParam, MachineMemoryRecord } from './types';
 import { SyncEventResource } from '../SyncEventResource';
-import AbstractArvoEventHandler from '../AbstractArvoEventHandler';
+import IArvoEventHandler from '../IArvoEventHandler';
 import type { ArvoEventHandlerOpenTelemetryOptions } from '../types';
 /**
  * Orchestrates state machine execution and lifecycle management.
  * Handles machine resolution, state management, event processing and error handling.
  */
-export declare class ArvoOrchestrator extends AbstractArvoEventHandler {
+export declare class ArvoOrchestrator implements IArvoEventHandler {
     readonly executionunits: number;
     readonly registry: IMachineRegistry;
     readonly executionEngine: IMachineExectionEngine;
@@ -27,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, systemErrorDomain, }: IArvoOrchestrator);
+    constructor({ executionunits, memory, registry, executionEngine, requiresResourceLocking, systemErrorDomain, }: ArvoOrchestratorParam);
     /**
      * Creates emittable event from execution result
      * @param event - Source event to emit

package/dist/ArvoOrchestrator/index.js

@@ -1,19 +1,4 @@
 "use strict";
-var __extends = (this && this.__extends) || (function () {
-    var extendStatics = function (d, b) {
-        extendStatics = Object.setPrototypeOf ||
-            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
-            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
-        return extendStatics(d, b);
-    };
-    return function (d, b) {
-        if (typeof b !== "function" && b !== null)
-            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
-        extendStatics(d, b);
-        function __() { this.constructor = d; }
-        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
-    };
-})();
 var __assign = (this && this.__assign) || function () {
     __assign = Object.assign || function(t) {
         for (var s, i = 1, n = arguments.length; i < n; i++) {
@@ -61,9 +46,6 @@ 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 __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ArvoOrchestrator = void 0;
 var api_1 = require("@opentelemetry/api");
@@ -71,15 +53,13 @@ var arvo_core_1 = require("arvo-core");
 var utils_1 = require("../utils");
 var error_1 = require("./error");
 var SyncEventResource_1 = require("../SyncEventResource");
-var AbstractArvoEventHandler_1 = __importDefault(require("../AbstractArvoEventHandler"));
 var errors_1 = require("../errors");
 var ArvoDomain_1 = require("../ArvoDomain");
 /**
  * Orchestrates state machine execution and lifecycle management.
  * Handles machine resolution, state management, event processing and error handling.
  */
-var ArvoOrchestrator = /** @class */ (function (_super) {
-    __extends(ArvoOrchestrator, _super);
+var ArvoOrchestrator = /** @class */ (function () {
     /**
      * Creates a new orchestrator instance
      * @param params - Configuration parameters
@@ -87,9 +67,8 @@ var ArvoOrchestrator = /** @class */ (function (_super) {
      */
     function ArvoOrchestrator(_a) {
         var executionunits = _a.executionunits, memory = _a.memory, registry = _a.registry, executionEngine = _a.executionEngine, requiresResourceLocking = _a.requiresResourceLocking, systemErrorDomain = _a.systemErrorDomain;
-        var _this = _super.call(this) || this;
-        _this.systemErrorDomain = [];
-        _this.executionunits = executionunits;
+        this.systemErrorDomain = [];
+        this.executionunits = executionunits;
         var representativeMachine = registry.machines[0];
         var lastSeenVersions = [];
         for (var _i = 0, _b = registry.machines; _i < _b.length; _i++) {
@@ -102,11 +81,10 @@ var ArvoOrchestrator = /** @class */ (function (_super) {
             }
             lastSeenVersions.push(machine.version);
         }
-        _this.registry = registry;
-        _this.executionEngine = executionEngine;
-        _this.syncEventResource = new SyncEventResource_1.SyncEventResource(memory, requiresResourceLocking);
-        _this.systemErrorDomain = systemErrorDomain;
-        return _this;
+        this.registry = registry;
+        this.executionEngine = executionEngine;
+        this.syncEventResource = new SyncEventResource_1.SyncEventResource(memory, requiresResourceLocking);
+        this.systemErrorDomain = systemErrorDomain;
     }
     Object.defineProperty(ArvoOrchestrator.prototype, "source", {
         get: function () {
@@ -257,6 +235,7 @@ var ArvoOrchestrator = /** @class */ (function (_super) {
         }
         // Create the event
         var emittableEvent = (0, arvo_core_1.createArvoEvent)({
+            id: event.id,
             source: this.source,
             type: event.type,
             subject: subject,
@@ -459,6 +438,7 @@ var ArvoOrchestrator = /** @class */ (function (_super) {
                                                 rawMachineEmittedEvents.push({
                                                     type: machine.contracts.self
                                                         .metadata.completeEventType,
+                                                    id: executionResult.finalOutput.__id,
                                                     data: executionResult.finalOutput,
                                                     to: (_t = (_s = parsedEventSubject.meta) === null || _s === void 0 ? void 0 : _s.redirectto) !== null && _t !== void 0 ? _t : parsedEventSubject.execution.initiator,
                                                     domain: orchestrationParentSubject
@@ -621,5 +601,5 @@ var ArvoOrchestrator = /** @class */ (function (_super) {
         configurable: true
     });
     return ArvoOrchestrator;
-}(AbstractArvoEventHandler_1.default));
+}());
 exports.ArvoOrchestrator = ArvoOrchestrator;

package/dist/ArvoOrchestrator/types.d.ts

@@ -71,7 +71,7 @@ export type MachineMemoryRecord = {
 /**
  * Interface defining the core components of an Arvo orchestrator.
  */
-export interface IArvoOrchestrator {
+export type ArvoOrchestratorParam = {
     /** The cost of the execution of the orchestrator */
     executionunits: number;
     /** Memory interface for storing and retrieving machine state */
@@ -85,7 +85,7 @@ export interface IArvoOrchestrator {
      * Optional configuration to customize where system error events are emitted.
      */
     systemErrorDomain?: (string | null)[];
-}
+};
 /**
  * Configuration interface for creating an Arvo orchestrator instance.
  */

package/dist/ArvoResumable/index.d.ts

@@ -4,7 +4,7 @@ import type { ArvoResumableHandler, ArvoResumableState } from './types';
 import type { IMachineMemory } from '../MachineMemory/interface';
 import { SyncEventResource } from '../SyncEventResource/index';
 import type { EnqueueArvoEventActionParam } from '../ArvoMachine/types';
-import AbstractArvoEventHandler from '../AbstractArvoEventHandler';
+import IArvoEventHandler from '../IArvoEventHandler';
 import type { ArvoEventHandlerOpenTelemetryOptions } from '../types';
 /**
  * ArvoResumable - A stateful orchestration handler for managing distributed workflows
@@ -37,7 +37,7 @@ import type { ArvoEventHandlerOpenTelemetryOptions } from '../types';
  * @see {@link ArvoResumableHandler} Handler interface documentation
  * @see {@link ArvoResumableState} State structure documentation
  */
-export declare class ArvoResumable<TMemory extends Record<string, any> = Record<string, any>, TSelfContract extends ArvoOrchestratorContract = ArvoOrchestratorContract, TServiceContract extends Record<string, VersionedArvoContract<any, any>> = Record<string, VersionedArvoContract<any, any>>> extends AbstractArvoEventHandler {
+export declare class ArvoResumable<TMemory extends Record<string, any> = Record<string, any>, TSelfContract extends ArvoOrchestratorContract = ArvoOrchestratorContract, TServiceContract extends Record<string, VersionedArvoContract<any, any>> = Record<string, VersionedArvoContract<any, any>>> implements IArvoEventHandler {
     readonly executionunits: number;
     readonly syncEventResource: SyncEventResource<ArvoResumableState<TMemory>>;
     readonly source: string;

package/dist/ArvoResumable/index.js

@@ -1,19 +1,4 @@
 "use strict";
-var __extends = (this && this.__extends) || (function () {
-    var extendStatics = function (d, b) {
-        extendStatics = Object.setPrototypeOf ||
-            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
-            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
-        return extendStatics(d, b);
-    };
-    return function (d, b) {
-        if (typeof b !== "function" && b !== null)
-            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
-        extendStatics(d, b);
-        function __() { this.constructor = d; }
-        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
-    };
-})();
 var __assign = (this && this.__assign) || function () {
     __assign = Object.assign || function(t) {
         for (var s, i = 1, n = arguments.length; i < n; i++) {
@@ -70,9 +55,6 @@ var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
     }
     return to.concat(ar || Array.prototype.slice.call(from));
 };
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ArvoResumable = void 0;
 var api_1 = require("@opentelemetry/api");
@@ -80,7 +62,6 @@ var arvo_core_1 = require("arvo-core");
 var error_1 = require("../ArvoOrchestrator/error");
 var index_1 = require("../SyncEventResource/index");
 var index_2 = require("../utils/index");
-var AbstractArvoEventHandler_1 = __importDefault(require("../AbstractArvoEventHandler"));
 var errors_1 = require("../errors");
 var ArvoDomain_1 = require("../ArvoDomain");
 /**
@@ -114,19 +95,16 @@ var ArvoDomain_1 = require("../ArvoDomain");
  * @see {@link ArvoResumableHandler} Handler interface documentation
  * @see {@link ArvoResumableState} State structure documentation
  */
-var ArvoResumable = /** @class */ (function (_super) {
-    __extends(ArvoResumable, _super);
+var ArvoResumable = /** @class */ (function () {
     function ArvoResumable(param) {
         var _a;
-        var _this = _super.call(this) || this;
-        _this.systemErrorDomain = [];
-        _this.executionunits = param.executionunits;
-        _this.source = param.contracts.self.type;
-        _this.syncEventResource = new index_1.SyncEventResource(param.memory, (_a = param.requiresResourceLocking) !== null && _a !== void 0 ? _a : true);
-        _this.contracts = param.contracts;
-        _this.handler = param.handler;
-        _this.systemErrorDomain = param.systemErrorDomain;
-        return _this;
+        this.systemErrorDomain = [];
+        this.executionunits = param.executionunits;
+        this.source = param.contracts.self.type;
+        this.syncEventResource = new index_1.SyncEventResource(param.memory, (_a = param.requiresResourceLocking) !== null && _a !== void 0 ? _a : true);
+        this.contracts = param.contracts;
+        this.handler = param.handler;
+        this.systemErrorDomain = param.systemErrorDomain;
     }
     Object.defineProperty(ArvoResumable.prototype, "requiresResourceLocking", {
         get: function () {
@@ -317,6 +295,7 @@ var ArvoResumable = /** @class */ (function (_super) {
         }
         // Create the event
         var emittableEvent = (0, arvo_core_1.createArvoEvent)({
+            id: event.id,
             source: this.source,
             type: event.type,
             subject: subject,
@@ -538,6 +517,7 @@ var ArvoResumable = /** @class */ (function (_super) {
                                         for (_d = 0, _e = __spreadArray(__spreadArray([], ((executionResult === null || executionResult === void 0 ? void 0 : executionResult.output)
                                             ? [
                                                 {
+                                                    id: executionResult.output.__id,
                                                     data: executionResult.output,
                                                     type: this.contracts.self.metadata.completeEventType,
                                                     to: (_3 = (_2 = parsedEventSubject.meta) === null || _2 === void 0 ? void 0 : _2.redirectto) !== null && _3 !== void 0 ? _3 : parsedEventSubject.execution.initiator,
@@ -694,5 +674,5 @@ var ArvoResumable = /** @class */ (function (_super) {
         configurable: true
     });
     return ArvoResumable;
-}(AbstractArvoEventHandler_1.default));
+}());
 exports.ArvoResumable = ArvoResumable;

package/dist/ArvoResumable/types.d.ts

@@ -1,4 +1,4 @@
-import type { VersionedArvoContract, ArvoSemanticVersion, InferVersionedArvoContract, ArvoContract, ArvoEvent, InferArvoEvent } from 'arvo-core';
+import type { VersionedArvoContract, ArvoSemanticVersion, InferVersionedArvoContract, ArvoContract, ArvoEvent, InferArvoEvent, CreateArvoEvent } from 'arvo-core';
 import type { EnqueueArvoEventActionParam } from '../ArvoMachine/types';
 import type { Span } from '@opentelemetry/api';
 type ExtractServiceEventTypes<TServiceContract extends Record<string, VersionedArvoContract<any, any>>> = {
@@ -41,7 +41,9 @@ type Handler<TState extends ArvoResumableState<Record<string, any>>, TSelfContra
     context?: TState['state$$'];
     output?: {
         [L in keyof InferVersionedArvoContract<TSelfContract>['emits']]: EnqueueArvoEventActionParam<InferVersionedArvoContract<TSelfContract>['emits'][L]['data'], InferVersionedArvoContract<TSelfContract>['emits'][L]['type']>['data'];
-    }[keyof InferVersionedArvoContract<TSelfContract>['emits']];
+    }[keyof InferVersionedArvoContract<TSelfContract>['emits']] & {
+        __id?: CreateArvoEvent<Record<string, unknown>, string>['id'];
+    };
     services?: Array<{
         [K in keyof TServiceContract]: EnqueueArvoEventActionParam<InferVersionedArvoContract<TServiceContract[K]>['accepts']['data'], InferVersionedArvoContract<TServiceContract[K]>['accepts']['type']>;
     }[keyof TServiceContract]>;

package/dist/IArvoEventHandler/index.d.ts

@@ -0,0 +1,37 @@
+import type { ArvoContractRecord, ArvoEvent } from 'arvo-core';
+import type { ArvoEventHandlerOpenTelemetryOptions } from '../types';
+/**
+ * The interface for Arvo event handlers.
+ *
+ * This class defines the basic structure for all Arvo event handlers.
+ * It provides an abstract method for executing events, which must be
+ * implemented by any concrete subclass.
+ */
+export default interface IArvoEventHandler {
+    /**
+     * Unique identifier for the event handler source system
+     */
+    source: string;
+    /**
+     * Executes the event handling logic for a given Arvo event.
+     *
+     * @param event - The Arvo event to be processed.
+     * @param opentelemetry - Configuration for OpenTelemetry integration
+     *
+     * @returns A promise that resolves to an array of resulting Arvo events.
+     * These events represent the outcome of processing the input event.
+     */
+    execute(event: ArvoEvent, opentelemetry: ArvoEventHandlerOpenTelemetryOptions): Promise<{
+        events: ArvoEvent[];
+        metadata?: Record<string, any>;
+    }>;
+    /**
+     * Provides the schema for system error events.
+     *
+     * @returns An object containing the error event type and schema.
+     *
+     * This defines the structure for system error events that may be emitted
+     * when an unexpected error occurs during event handling.
+     */
+    systemErrorSchema: ArvoContractRecord;
+}

package/dist/IArvoEventHandler/index.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/index.d.ts

@@ -1,7 +1,7 @@
-import AbstractArvoEventHandler from './AbstractArvoEventHandler';
+import IArvoEventHandler from './IArvoEventHandler';
 import ArvoEventHandler from './ArvoEventHandler';
 import { createArvoEventHandler } from './ArvoEventHandler/helpers';
-import { ArvoEventHandlerFunction, ArvoEventHandlerFunctionInput, ArvoEventHandlerFunctionOutput, IArvoEventHandler } from './ArvoEventHandler/types';
+import { ArvoEventHandlerFunction, ArvoEventHandlerFunctionInput, ArvoEventHandlerFunctionOutput } from './ArvoEventHandler/types';
 import { ConfigViolation, ContractViolation, ExecutionViolation } from './errors';
 import { ArvoEventHandlerOpenTelemetryOptions, EventHandlerFactory, PartialExcept } from './types';
 import { coalesce, coalesceOrDefault, getValueOrDefault, isNullOrUndefined } from './utils';
@@ -12,7 +12,7 @@ import { ArvoMachineContext, EnqueueArvoEventActionParam } from './ArvoMachine/t
 import { ArvoOrchestrator } from './ArvoOrchestrator';
 import { TransactionViolation, TransactionViolationCause } from './ArvoOrchestrator/error';
 import { createArvoOrchestrator } from './ArvoOrchestrator/factory';
-import { IArvoOrchestrator, MachineMemoryRecord } from './ArvoOrchestrator/types';
+import { ArvoOrchestratorParam, MachineMemoryRecord } from './ArvoOrchestrator/types';
 import { MachineExecutionEngine } from './MachineExecutionEngine';
 import { IMachineExectionEngine } from './MachineExecutionEngine/interface';
 import { ExecuteMachineInput, ExecuteMachineOutput } from './MachineExecutionEngine/types';
@@ -31,4 +31,4 @@ declare const xstate: {
     emit: typeof emit;
     assign: typeof assign;
 };
-export { ArvoEventHandler, createArvoEventHandler, IArvoEventHandler, ArvoEventHandlerFunctionOutput, ArvoEventHandlerFunctionInput, ArvoEventHandlerFunction, PartialExcept, isNullOrUndefined, getValueOrDefault, coalesce, coalesceOrDefault, AbstractArvoEventHandler, ArvoEventHandlerOpenTelemetryOptions, EventHandlerFactory, ContractViolation, ConfigViolation, ExecutionViolation, ArvoMachine, setupArvoMachine, ArvoMachineContext, EnqueueArvoEventActionParam, IMachineRegistry, MachineRegistry, MachineExecutionEngine, IMachineExectionEngine, ExecuteMachineInput, ExecuteMachineOutput, IMachineMemory, SimpleMachineMemory, MachineMemoryRecord, IArvoOrchestrator, TransactionViolation, TransactionViolationCause, ArvoOrchestrator, createArvoOrchestrator, SimpleEventBroker, createSimpleEventBroker, TelemetredSimpleMachineMemory, xstate, ArvoResumable, createArvoResumable, ArvoResumableHandler, ArvoResumableState, ArvoDomain, resolveEventDomain, };
+export { ArvoEventHandler, createArvoEventHandler, IArvoEventHandler, ArvoEventHandlerFunctionOutput, ArvoEventHandlerFunctionInput, ArvoEventHandlerFunction, PartialExcept, isNullOrUndefined, getValueOrDefault, coalesce, coalesceOrDefault, IArvoEventHandler as AbstractArvoEventHandler, ArvoEventHandlerOpenTelemetryOptions, EventHandlerFactory, ContractViolation, ConfigViolation, ExecutionViolation, ArvoMachine, setupArvoMachine, ArvoMachineContext, EnqueueArvoEventActionParam, IMachineRegistry, MachineRegistry, MachineExecutionEngine, IMachineExectionEngine, ExecuteMachineInput, ExecuteMachineOutput, IMachineMemory, SimpleMachineMemory, MachineMemoryRecord, ArvoOrchestratorParam as IArvoOrchestrator, TransactionViolation, TransactionViolationCause, ArvoOrchestrator, createArvoOrchestrator, SimpleEventBroker, createSimpleEventBroker, TelemetredSimpleMachineMemory, xstate, ArvoResumable, createArvoResumable, ArvoResumableHandler, ArvoResumableState, ArvoDomain, resolveEventDomain, };

package/dist/index.js

@@ -3,9 +3,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.resolveEventDomain = exports.ArvoDomain = exports.createArvoResumable = exports.ArvoResumable = exports.xstate = exports.TelemetredSimpleMachineMemory = exports.createSimpleEventBroker = exports.SimpleEventBroker = exports.createArvoOrchestrator = exports.ArvoOrchestrator = exports.TransactionViolationCause = exports.TransactionViolation = exports.SimpleMachineMemory = exports.MachineExecutionEngine = exports.MachineRegistry = exports.setupArvoMachine = exports.ArvoMachine = exports.ExecutionViolation = exports.ConfigViolation = exports.ContractViolation = exports.AbstractArvoEventHandler = exports.coalesceOrDefault = exports.coalesce = exports.getValueOrDefault = exports.isNullOrUndefined = exports.createArvoEventHandler = exports.ArvoEventHandler = void 0;
-var AbstractArvoEventHandler_1 = __importDefault(require("./AbstractArvoEventHandler"));
-exports.AbstractArvoEventHandler = AbstractArvoEventHandler_1.default;
+exports.resolveEventDomain = exports.ArvoDomain = exports.createArvoResumable = exports.ArvoResumable = exports.xstate = exports.TelemetredSimpleMachineMemory = exports.createSimpleEventBroker = exports.SimpleEventBroker = exports.createArvoOrchestrator = exports.ArvoOrchestrator = exports.TransactionViolationCause = exports.TransactionViolation = exports.SimpleMachineMemory = exports.MachineExecutionEngine = exports.MachineRegistry = exports.setupArvoMachine = exports.ArvoMachine = exports.ExecutionViolation = exports.ConfigViolation = exports.ContractViolation = exports.coalesceOrDefault = exports.coalesce = exports.getValueOrDefault = exports.isNullOrUndefined = exports.createArvoEventHandler = exports.ArvoEventHandler = void 0;
 var ArvoEventHandler_1 = __importDefault(require("./ArvoEventHandler"));
 exports.ArvoEventHandler = ArvoEventHandler_1.default;
 var helpers_1 = require("./ArvoEventHandler/helpers");

package/dist/types.d.ts

@@ -1,4 +1,4 @@
-import type AbstractArvoEventHandler from './AbstractArvoEventHandler';
+import type IArvoEventHandler from './IArvoEventHandler';
 /**
  * Makes properties optional except specified keys
  *
@@ -29,4 +29,4 @@ export type ArvoEventHandlerOpenTelemetryOptions = {
  *
  * @template T - Configuration object type
  */
-export type EventHandlerFactory<T = void> = T extends void ? () => AbstractArvoEventHandler : (config: T) => AbstractArvoEventHandler;
+export type EventHandlerFactory<T = void> = T extends void ? () => IArvoEventHandler : (config: T) => IArvoEventHandler;

package/dist/utils/SimpleEventBroker/helper.d.ts

@@ -1,6 +1,6 @@
 import type { ArvoEvent } from 'arvo-core';
 import { SimpleEventBroker } from '.';
-import type AbstractArvoEventHandler from '../../AbstractArvoEventHandler';
+import type IArvoEventHandler from '../../IArvoEventHandler';
 /**
  * Creates a local event broker configured with domain event handlers and provides event resolution capabilities
  *
@@ -153,7 +153,7 @@ import type AbstractArvoEventHandler from '../../AbstractArvoEventHandler';
  * without requiring external message brokers, making test suites faster and
  * more reliable while maintaining production-like behavior patterns.
  */
-export declare const createSimpleEventBroker: (eventHandlers: AbstractArvoEventHandler[], options?: {
+export declare const createSimpleEventBroker: (eventHandlers: IArvoEventHandler[], options?: {
     onError?: (error: Error, event: ArvoEvent) => void;
     onDomainedEvents?: (param: {
         domain: string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "arvo-event-handler",
-  "version": "3.0.6",
+  "version": "3.0.7",
   "description": "Type-safe event handler system with versioning, telemetry, and contract validation for distributed Arvo event-driven architectures, featuring routing and multi-handler support.",
   "main": "dist/index.js",
   "scripts": {
@@ -46,10 +46,11 @@
   "dependencies": {
     "@opentelemetry/api": "^1.9.0",
     "@opentelemetry/core": "^1.30.1",
-    "arvo-core": "^3.0.6",
+    "arvo-core": "^3.0.7",
     "uuid": "^11.1.0",
-    "xstate": "^5.20.1",
-    "zod": "^3.25.67"
+    "xstate": "^5.23.0",
+    "zod": "^3.25.74",
+    "zod-to-json-schema": "^3.24.6"
   },
   "engines": {
     "node": ">=18.0.0"

package/dist/AbstractArvoEventHandler/index.d.ts

@@ -1,91 +0,0 @@
-import type { ArvoContractRecord, ArvoEvent } from 'arvo-core';
-import type { ArvoEventHandlerOpenTelemetryOptions } from '../types';
-/**
- * Abstract base class for Arvo event handlers.
- *
- * @abstract
- * @description
- * This class defines the basic structure for all Arvo event handlers.
- * It provides an abstract method for executing events, which must be
- * implemented by any concrete subclass.
- * ```
- */
-export default abstract class AbstractArvoEventHandler {
-    /**
-     * Unique identifier for the event handler source system
-     */
-    abstract source: string;
-    /**
-     * Executes the event handling logic for a given Arvo event.
-     *
-     * @abstract
-     * @param event - The Arvo event to be processed. This event should conform
-     *                           to the expected schema for the specific handler implementation.
-     * @param opentelemetry - Configuration for OpenTelemetry integration
-     *
-     * @returns {Promise<ArvoEvent[]>} A promise that resolves to an array of resulting Arvo events.
-     *                                 These events represent the outcome of processing the input event.
-     *
-     * @description
-     * This method defines the core event processing logic that each concrete handler must implement.
-     * It should handle the complete lifecycle of an event, including:
-     * - Validation of the input event
-     * - Processing of the event according to business rules
-     * - Generation of any resulting events
-     * - Error handling and reporting
-     * - OpenTelemetry integration for observability
-     *
-     * @throws {Error}
-     * - When the input event fails validation
-     * - When processing encounters an unrecoverable error
-     * - When the handler is unable to properly execute the event
-     *
-     * @remarks
-     * Implementation considerations:
-     * - Ensure proper error handling and event validation
-     * - Implement appropriate retry logic for transient failures
-     * - Use the provided OpenTelemetry configuration for tracing
-     * - Consider performance implications for long-running operations
-     * - Maintain idempotency where appropriate
-     * - Document any specific requirements for event schemas
-     *
-     * The method should handle observability concerns by:
-     * - Creating appropriate spans for tracing
-     * - Recording relevant attributes and events
-     * - Properly handling span lifecycle (creation and completion)
-     * - Propagating context appropriately
-     */
-    abstract execute(event: ArvoEvent, opentelemetry: ArvoEventHandlerOpenTelemetryOptions): Promise<{
-        events: ArvoEvent[];
-        metadata?: Record<string, any>;
-    }>;
-    /**
-     * Provides the schema for system error events.
-     *
-     * @abstract
-     * @returns {ArvoContractRecord} An object containing the error event type and schema.
-     *
-     * @description
-     * This getter should define the structure for system error events that may be emitted
-     * when an unexpected error occurs during event handling.
-     *
-     * @remarks
-     * - The returned ArvoContractRecord typically includes:
-     *   - `type`: A string representing the error event type.
-     *   - `schema`: The schema definition for the error event.
-     * - Implementations should ensure that the error schema is consistent with the
-     *   overall system's error handling strategy.
-     * - The error event type often follows a pattern like 'sys.[eventType].error'.
-     *
-     * @example
-     * ```typescript
-     * public get systemErrorSchema(): ArvoContractRecord {
-     *   return {
-     *     type: 'sys.myEvent.error',
-     *     schema: MyCustomErrorSchema
-     *   };
-     * }
-     * ```
-     */
-    abstract get systemErrorSchema(): ArvoContractRecord;
-}

package/dist/AbstractArvoEventHandler/index.js

@@ -1,18 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-/**
- * Abstract base class for Arvo event handlers.
- *
- * @abstract
- * @description
- * This class defines the basic structure for all Arvo event handlers.
- * It provides an abstract method for executing events, which must be
- * implemented by any concrete subclass.
- * ```
- */
-var AbstractArvoEventHandler = /** @class */ (function () {
-    function AbstractArvoEventHandler() {
-    }
-    return AbstractArvoEventHandler;
-}());
-exports.default = AbstractArvoEventHandler;