arvo-event-handler 3.0.8 → 3.0.10

package/dist/ArvoEventHandler/index.d.ts

@@ -1,7 +1,6 @@
-import { type SpanOptions } from '@opentelemetry/api';
 import { type ArvoContract, type ArvoEvent } from 'arvo-core';
 import type IArvoEventHandler from '../IArvoEventHandler';
-import type { ArvoEventHandlerOpenTelemetryOptions } from '../types';
+import type { ArvoEventHandlerOpenTelemetryOptions, ArvoEventHandlerOtelSpanOptions } from '../types';
 import type { ArvoEventHandlerFunction, ArvoEventHandlerParam } from './types';
 /**
  * `ArvoEventHandler` is the foundational component for building stateless,
@@ -89,7 +88,7 @@ export default class ArvoEventHandler<TContract extends ArvoContract> implements
     /** Computational cost metric associated with event handling operations */
     readonly executionunits: number;
     /** OpenTelemetry configuration for event handling spans */
-    readonly spanOptions: SpanOptions;
+    readonly spanOptions: ArvoEventHandlerOtelSpanOptions;
     /** Version-specific event handler implementation map */
     readonly handler: ArvoEventHandlerFunction<TContract>;
     /** The source identifier for events produced by this handler */

package/dist/ArvoEventHandler/index.js

@@ -61,6 +61,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 var api_1 = require("@opentelemetry/api");
 var arvo_core_1 = require("arvo-core");
 var ArvoDomain_1 = require("../ArvoDomain");
+var handlerErrors_1 = require("../ArvoOrchestrationUtils/handlerErrors");
+var orchestrationExecutionWrapper_1 = require("../ArvoOrchestrationUtils/orchestrationExecutionWrapper");
 var errors_1 = require("../errors");
 var utils_1 = require("../utils");
 /**
@@ -208,32 +210,32 @@ var ArvoEventHandler = /** @class */ (function () {
      *                           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) {
+    ArvoEventHandler.prototype.execute = function (event, opentelemetry) {
+        return __awaiter(this, void 0, void 0, function () {
             var otelConfig;
             var _this = this;
-            if (opentelemetry === void 0) { opentelemetry = {
-                inheritFrom: 'EVENT',
-            }; }
-            return __generator(this, function (_a) {
-                switch (_a.label) {
+            var _a, _b;
+            return __generator(this, function (_c) {
+                switch (_c.label) {
                     case 0:
-                        otelConfig = (0, utils_1.createEventHandlerTelemetryConfig)("Handler<".concat(this.contract.uri, ">"), this.spanOptions, opentelemetry, event);
+                        otelConfig = (0, utils_1.createEventHandlerTelemetryConfig)(((_b = (_a = this.spanOptions).spanName) === null || _b === void 0 ? void 0 : _b.call(_a, { selfContractUri: this.contract.uri, consumedEvent: event })) ||
+                            "Handler<".concat(this.contract.uri, ">"), this.spanOptions, opentelemetry !== null && opentelemetry !== void 0 ? opentelemetry : { inheritFrom: 'EVENT' }, event);
                         return [4 /*yield*/, arvo_core_1.ArvoOpenTelemetry.getInstance().startActiveSpan(__assign(__assign({}, otelConfig), { fn: function (span) { return __awaiter(_this, void 0, void 0, function () {
-                                    var otelSpanHeaders, _i, _a, _b, key, value, parsedDataSchema, handlerContract_1, inputEventValidation, _handleOutput, outputs, result, _c, outputs_1, item, __extensions, handlerResult, domains, _d, _e, _dom, _f, _g, _h, key, value, error_1, 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) {
+                                    var otelSpanHeaders, _i, _a, _b, key, value, parsedDataSchema, handlerContract_1, inputEventValidation, _handleOutput, outputs, result, _c, outputs_1, item, __extensions, handlerResult, domains, _d, _e, _dom, _f, _g, _h, key, value, error_1, errorEvents, _j, _k, _l, errEvtIdx, errEvt, _m, _o, _p, key, value;
+                                    var _q, _r, _s, _t, _u, _v;
+                                    return __generator(this, function (_w) {
+                                        switch (_w.label) {
                                             case 0:
                                                 otelSpanHeaders = (0, arvo_core_1.currentOpenTelemetryHeaders)();
-                                                _z.label = 1;
+                                                _w.label = 1;
                                             case 1:
-                                                _z.trys.push([1, 3, 4, 5]);
+                                                _w.trys.push([1, 3, 4, 5]);
+                                                span.setAttribute('arvo.handler.execution.status', 'normal');
+                                                span.setAttribute('arvo.handler.execution.type', 'handler');
                                                 span.setStatus({ code: api_1.SpanStatusCode.OK });
                                                 for (_i = 0, _a = Object.entries(event.otelAttributes); _i < _a.length; _i++) {
                                                     _b = _a[_i], key = _b[0], value = _b[1];
-                                                    span.setAttribute("to_process.0.".concat(key), value);
+                                                    span.setAttribute("consumable.0.".concat(key), value);
                                                 }
                                                 if (this.contract.type !== event.type) {
                                                     throw new errors_1.ConfigViolation("Event type mismatch: Received '".concat(event.type, "', expected '").concat(this.contract.type, "'"));
@@ -256,9 +258,9 @@ var ArvoEventHandler = /** @class */ (function () {
                                                     });
                                                 }
                                                 try {
-                                                    handlerContract_1 = this.contract.version((_p = parsedDataSchema === null || parsedDataSchema === void 0 ? void 0 : parsedDataSchema.version) !== null && _p !== void 0 ? _p : 'latest');
+                                                    handlerContract_1 = this.contract.version((_q = parsedDataSchema === null || parsedDataSchema === void 0 ? void 0 : parsedDataSchema.version) !== null && _q !== void 0 ? _q : 'latest');
                                                 }
-                                                catch (_0) {
+                                                catch (_x) {
                                                     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)({
@@ -289,7 +291,7 @@ var ArvoEventHandler = /** @class */ (function () {
                                                         spanHeaders: otelSpanHeaders,
                                                     })];
                                             case 2:
-                                                _handleOutput = _z.sent();
+                                                _handleOutput = _w.sent();
                                                 if (!_handleOutput)
                                                     return [2 /*return*/, {
                                                             events: [],
@@ -306,85 +308,65 @@ var ArvoEventHandler = /** @class */ (function () {
                                                     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) {
+                                                        domains = (_s = (_r = handlerResult.domain) === null || _r === void 0 ? void 0 : _r.map(function (item) {
                                                             return (0, ArvoDomain_1.resolveEventDomain)({
                                                                 domainToResolve: item,
                                                                 handlerSelfContract: handlerContract_1,
                                                                 eventContract: handlerContract_1,
                                                                 triggeringEvent: event,
                                                             });
-                                                        })) !== null && _r !== void 0 ? _r : [null];
+                                                        })) !== null && _s !== void 0 ? _s : [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_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));
+                                                                to: (0, utils_1.coalesceOrDefault)([handlerResult.to, event.redirectto], event.source), executionunits: (0, utils_1.coalesce)(handlerResult.executionunits, this.executionunits), accesscontrol: (_u = (_t = handlerResult.accesscontrol) !== null && _t !== void 0 ? _t : event.accesscontrol) !== null && _u !== void 0 ? _u : undefined, parentid: event.id, domain: _dom }), __extensions));
                                                             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);
+                                                                span.setAttribute("emittables.".concat(result.length - 1, ".").concat(key), value);
                                                             }
                                                         }
                                                     }
                                                     catch (e) {
-                                                        throw new errors_1.ContractViolation((_u = e === null || e === void 0 ? void 0 : e.message) !== null && _u !== void 0 ? _u : 'Invalid data');
+                                                        throw new errors_1.ContractViolation((_v = e === null || e === void 0 ? void 0 : e.message) !== null && _v !== void 0 ? _v : 'Invalid data');
                                                     }
                                                 }
-                                                (0, arvo_core_1.logToSpan)({
-                                                    level: 'INFO',
-                                                    message: "Event processing completed successfully. Generated ".concat(result.length, " event(s)"),
-                                                });
-                                                (0, arvo_core_1.logToSpan)({
-                                                    level: 'INFO',
-                                                    message: 'Event handled successfully',
-                                                });
-                                                return [2 /*return*/, {
-                                                        events: result,
-                                                    }];
+                                                return [2 /*return*/, (0, orchestrationExecutionWrapper_1.returnEventsWithLogging)({ events: result }, span)];
                                             case 3:
-                                                error_1 = _z.sent();
+                                                error_1 = _w.sent();
+                                                span.setAttribute('arvo.handler.execution.status', 'failure');
                                                 (0, arvo_core_1.exceptionToSpan)(error_1);
                                                 span.setStatus({
                                                     code: api_1.SpanStatusCode.ERROR,
                                                     message: "Event processing failed: ".concat(error_1.message),
                                                 });
-                                                if (error_1.name.includes('ViolationError')) {
+                                                if ((0, arvo_core_1.isViolationError)(error_1)) {
                                                     throw error_1;
                                                 }
-                                                result = [];
-                                                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,
-                                                        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);
+                                                errorEvents = (0, handlerErrors_1.createSystemErrorEvents)({
+                                                    error: error_1,
+                                                    event: event,
+                                                    otelHeaders: otelSpanHeaders,
+                                                    orchestrationParentSubject: null,
+                                                    initEventId: event.id,
+                                                    selfContract: this.contract.version('any'),
+                                                    systemErrorDomain: undefined,
+                                                    executionunits: this.executionunits,
+                                                    source: this.source,
+                                                    domain: this.domain,
+                                                    handlerType: 'handler',
+                                                });
+                                                for (_j = 0, _k = Object.entries(errorEvents); _j < _k.length; _j++) {
+                                                    _l = _k[_j], errEvtIdx = _l[0], errEvt = _l[1];
+                                                    for (_m = 0, _o = Object.entries(errEvt.otelAttributes); _m < _o.length; _m++) {
+                                                        _p = _o[_m], key = _p[0], value = _p[1];
+                                                        span.setAttribute("emittables.".concat(errEvtIdx, ".").concat(key), value);
                                                     }
                                                 }
-                                                return [2 /*return*/, {
-                                                        events: result,
-                                                    }];
+                                                return [2 /*return*/, (0, orchestrationExecutionWrapper_1.returnEventsWithLogging)({
+                                                        events: errorEvents,
+                                                    }, span)];
                                             case 4:
                                                 span.end();
                                                 return [7 /*endfinally*/];
@@ -392,7 +374,7 @@ var ArvoEventHandler = /** @class */ (function () {
                                         }
                                     });
                                 }); } }))];
-                    case 1: return [2 /*return*/, _a.sent()];
+                    case 1: return [2 /*return*/, _c.sent()];
                 }
             });
         });

package/dist/ArvoEventHandler/types.d.ts

@@ -1,6 +1,7 @@
-import type { Span, SpanOptions } from '@opentelemetry/api';
+import type { Span } from '@opentelemetry/api';
 import type { ArvoContract, ArvoEvent, ArvoSemanticVersion, CreateArvoEvent, InferArvoEvent, OpenTelemetryHeaders, VersionedArvoContract } from 'arvo-core';
 import type { z } from 'zod';
+import type { ArvoEventHandlerOtelSpanOptions } from '../types';
 /**
  * Represents the input for an ArvoEvent handler function.
  */
@@ -90,7 +91,7 @@ export type ArvoEventHandlerParam<TContract extends ArvoContract> = {
     /**
      * The OpenTelemetry span options
      */
-    spanOptions?: SpanOptions;
+    spanOptions?: ArvoEventHandlerOtelSpanOptions;
     /**
      * Optional configuration to customize where system error events are emitted.
      *

package/dist/ArvoOrchestrationUtils/createEmitableEvent.js

@@ -151,7 +151,7 @@ var processRawEventsIntoEmittables = function (params, span) {
             emittables.push(evt);
             for (var _e = 0, _f = Object.entries(emittables[emittables.length - 1].otelAttributes); _e < _f.length; _e++) {
                 var _g = _f[_e], key = _g[0], value = _g[1];
-                span.setAttribute("to_emit.".concat(emittables.length - 1, ".").concat(key), value);
+                span.setAttribute("emittables.".concat(emittables.length - 1, ".").concat(key), value);
             }
         }
     }

package/dist/ArvoOrchestrationUtils/handlerErrors.d.ts

@@ -2,7 +2,7 @@ import { type Span } from '@opentelemetry/api';
 import { type ArvoEvent, type ArvoOrchestratorContract, type ArvoSemanticVersion, type OpenTelemetryHeaders, type VersionedArvoContract, type ViolationError } from 'arvo-core';
 import type { SyncEventResource } from '../SyncEventResource';
 import type { OrchestrationExecutionMemoryRecord } from './orchestrationExecutionState';
-import type { ArvoOrchestrationHandlerType } from './types';
+import { type ArvoOrchestrationHandlerType } from './types';
 /**
  * Parameters for system error event creation
  */
@@ -17,11 +17,12 @@ export type CreateSystemErrorEventsParams = {
     executionunits: number;
     source: string;
     domain: string | null;
+    handlerType: ArvoOrchestrationHandlerType;
 };
 /**
  * Creates system error events
  */
-export declare const createSystemErrorEvents: ({ error, event, otelHeaders, orchestrationParentSubject, initEventId, selfContract, systemErrorDomain, executionunits, source, domain, }: CreateSystemErrorEventsParams & {
+export declare const createSystemErrorEvents: ({ error, event, otelHeaders, orchestrationParentSubject, initEventId, selfContract, systemErrorDomain, executionunits, source, domain, handlerType, }: CreateSystemErrorEventsParams & {
     error: Error;
 }) => ArvoEvent[];
 export declare const handleOrchestrationErrors: (_handlerType: ArvoOrchestrationHandlerType, param: CreateSystemErrorEventsParams & {

package/dist/ArvoOrchestrationUtils/handlerErrors.js

@@ -53,12 +53,13 @@ var arvo_core_1 = require("arvo-core");
 var ArvoDomain_1 = require("../ArvoDomain");
 var errors_1 = require("../errors");
 var utils_1 = require("../utils");
+var types_1 = require("./types");
 /**
  * Creates system error events
  */
 var createSystemErrorEvents = function (_a) {
     var _b, _c, _d, _e;
-    var error = _a.error, event = _a.event, otelHeaders = _a.otelHeaders, orchestrationParentSubject = _a.orchestrationParentSubject, initEventId = _a.initEventId, selfContract = _a.selfContract, systemErrorDomain = _a.systemErrorDomain, executionunits = _a.executionunits, source = _a.source, domain = _a.domain;
+    var error = _a.error, event = _a.event, otelHeaders = _a.otelHeaders, orchestrationParentSubject = _a.orchestrationParentSubject, initEventId = _a.initEventId, selfContract = _a.selfContract, systemErrorDomain = _a.systemErrorDomain, executionunits = _a.executionunits, source = _a.source, domain = _a.domain, handlerType = _a.handlerType;
     // In case of none transaction errors like errors from
     // the machine or the event creation etc, the are workflow
     // error and shuold be handled by the workflow. Then are
@@ -87,7 +88,8 @@ var createSystemErrorEvents = function (_a) {
     var result = [];
     for (var _i = 0, _f = Array.from(domainSets); _i < _f.length; _i++) {
         var _dom = _f[_i];
-        result.push((0, arvo_core_1.createArvoOrchestratorEventFactory)(selfContract).systemError({
+        var factoryBuilder = handlerType === 'handler' ? arvo_core_1.createArvoEventFactory : arvo_core_1.createArvoOrchestratorEventFactory;
+        result.push(factoryBuilder(selfContract).systemError({
             source: source,
             // If the initiator of the workflow exist then match the
             // subject so that it can incorporate it in its state. If
@@ -118,10 +120,7 @@ var handleOrchestrationErrors = function (_handlerType, param, span) { return __
     return __generator(this, function (_f) {
         switch (_f.label) {
             case 0:
-                handlerType = {
-                    orchestrator: 'ArvoOrchestrator',
-                    resumable: 'ArvoResumable',
-                }[_handlerType];
+                handlerType = types_1.ArvoOrchestrationHandlerMap[_handlerType];
                 error = (0, utils_1.isError)(param.error)
                     ? param.error
                     : new errors_1.ExecutionViolation("Non-Error object thrown during machine execution: ".concat(typeof param.error, ". This indicates a serious implementation flaw."));
@@ -171,7 +170,7 @@ var handleOrchestrationErrors = function (_handlerType, param, span) { return __
                     _b = _a[_i], errEvtIdx = _b[0], errEvt = _b[1];
                     for (_c = 0, _d = Object.entries(errEvt.otelAttributes); _c < _d.length; _c++) {
                         _e = _d[_c], key = _e[0], value = _e[1];
-                        span.setAttribute("to_emit.".concat(errEvtIdx, ".").concat(key), value);
+                        span.setAttribute("emittables.".concat(errEvtIdx, ".").concat(key), value);
                     }
                 }
                 return [2 /*return*/, {

package/dist/ArvoOrchestrationUtils/orchestrationExecutionWrapper/index.d.ts

@@ -2,13 +2,12 @@ import { type Span } from '@opentelemetry/api';
 import { type ArvoEvent, type ArvoOrchestrationSubjectContent, type ArvoOrchestratorContract, type ArvoSemanticVersion, type OpenTelemetryHeaders, type VersionedArvoContract } from 'arvo-core';
 import type IArvoEventHandler from '../../IArvoEventHandler';
 import type { SyncEventResource } from '../../SyncEventResource';
-import type { ArvoEventHandlerOpenTelemetryOptions } from '../../types';
+import type { ArvoEventHandlerOpenTelemetryOptions, ArvoEventHandlerOtelSpanOptions } from '../../types';
 import type { OrchestrationExecutionMemoryRecord } from '../orchestrationExecutionState';
 import type { ArvoOrchestrationHandlerType } from '../types';
 export type OrchestrationExecutionContext<TState extends OrchestrationExecutionMemoryRecord<Record<string, any>>> = {
     event: ArvoEvent;
     opentelemetry: ArvoEventHandlerOpenTelemetryOptions;
-    spanName: string;
     source: string;
     syncEventResource: SyncEventResource<TState>;
     executionunits: number;
@@ -16,6 +15,9 @@ export type OrchestrationExecutionContext<TState extends OrchestrationExecutionM
     selfContract: VersionedArvoContract<ArvoOrchestratorContract, ArvoSemanticVersion>;
     domain: string | null;
     _handlerType: ArvoOrchestrationHandlerType;
+    spanOptions: ArvoEventHandlerOtelSpanOptions & {
+        spanName: NonNullable<ArvoEventHandlerOtelSpanOptions['spanName']>;
+    };
 };
 export type CoreExecutionFn<TState extends OrchestrationExecutionMemoryRecord<Record<string, any>>> = (params: {
     span: any;
@@ -37,4 +39,4 @@ export declare const returnEventsWithLogging: (param: Awaited<ReturnType<IArvoEv
  * - State management
  * - Error handling and system error generation
  */
-export declare const executeWithOrchestrationWrapper: <TState extends OrchestrationExecutionMemoryRecord<Record<string, any>>>({ event, opentelemetry, spanName, source, syncEventResource, executionunits, systemErrorDomain, selfContract, domain, _handlerType, }: OrchestrationExecutionContext<TState>, coreExecutionFn: CoreExecutionFn<TState>) => Promise<Awaited<ReturnType<IArvoEventHandler["execute"]>>>;
+export declare const executeWithOrchestrationWrapper: <TState extends OrchestrationExecutionMemoryRecord<Record<string, any>>>({ event, opentelemetry, spanOptions, source, syncEventResource, executionunits, systemErrorDomain, selfContract, domain, _handlerType, }: OrchestrationExecutionContext<TState>, coreExecutionFn: CoreExecutionFn<TState>) => Promise<Awaited<ReturnType<IArvoEventHandler["execute"]>>>;

package/dist/ArvoOrchestrationUtils/orchestrationExecutionWrapper/index.js

@@ -50,6 +50,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.executeWithOrchestrationWrapper = exports.returnEventsWithLogging = void 0;
 var api_1 = require("@opentelemetry/api");
 var arvo_core_1 = require("arvo-core");
+var utils_1 = require("../../utils");
 var handlerErrors_1 = require("../handlerErrors");
 var acquireLockWithValidation_1 = require("./acquireLockWithValidation");
 var validateAndParseSubject_1 = require("./validateAndParseSubject");
@@ -70,158 +71,150 @@ exports.returnEventsWithLogging = returnEventsWithLogging;
  * - Error handling and system error generation
  */
 var executeWithOrchestrationWrapper = function (_a, coreExecutionFn_1) { return __awaiter(void 0, [_a, coreExecutionFn_1], void 0, function (_b, coreExecutionFn) {
-    var _c;
-    var event = _b.event, opentelemetry = _b.opentelemetry, spanName = _b.spanName, source = _b.source, syncEventResource = _b.syncEventResource, executionunits = _b.executionunits, systemErrorDomain = _b.systemErrorDomain, selfContract = _b.selfContract, domain = _b.domain, _handlerType = _b._handlerType;
-    return __generator(this, function (_d) {
-        switch (_d.label) {
-            case 0: return [4 /*yield*/, arvo_core_1.ArvoOpenTelemetry.getInstance().startActiveSpan({
-                    name: spanName,
-                    spanOptions: {
-                        kind: api_1.SpanKind.PRODUCER,
-                        attributes: __assign((_c = {}, _c[arvo_core_1.ArvoExecution.ATTR_SPAN_KIND] = arvo_core_1.ArvoExecutionSpanKind.ORCHESTRATOR, _c[arvo_core_1.OpenInference.ATTR_SPAN_KIND] = arvo_core_1.OpenInferenceSpanKind.CHAIN, _c), Object.fromEntries(Object.entries(event.otelAttributes).map(function (_a) {
-                            var key = _a[0], value = _a[1];
-                            return ["to_process.0.".concat(key), value];
-                        }))),
-                    },
-                    context: opentelemetry.inheritFrom === 'EVENT'
-                        ? {
-                            inheritFrom: 'TRACE_HEADERS',
-                            traceHeaders: {
-                                traceparent: event.traceparent,
-                                tracestate: event.tracestate,
-                            },
-                        }
-                        : {
-                            inheritFrom: 'CONTEXT',
-                            context: api_1.context.active(),
-                        },
-                    disableSpanManagement: true,
-                    fn: function (span) { return __awaiter(void 0, void 0, void 0, function () {
-                        var otelHeaders, orchestrationParentSubject, initEventId, acquiredLock, parsedEventSubject, state, _a, emittables, newState, i, _i, _b, _c, key, value, error_1, _d, errorToThrow, errorEvents;
-                        var _e, _f, _g, _h;
-                        return __generator(this, function (_j) {
-                            switch (_j.label) {
-                                case 0:
-                                    (0, arvo_core_1.logToSpan)({
-                                        level: 'INFO',
-                                        message: "Starting execution for ".concat(event.type, " on subject ").concat(event.subject),
-                                    }, span);
-                                    otelHeaders = (0, arvo_core_1.currentOpenTelemetryHeaders)();
-                                    orchestrationParentSubject = null;
-                                    initEventId = null;
-                                    acquiredLock = null;
-                                    _j.label = 1;
-                                case 1:
-                                    _j.trys.push([1, 6, 8, 10]);
-                                    parsedEventSubject = (0, validateAndParseSubject_1.validateAndParseSubject)(event, source, syncEventResource, span, 'orchestrator');
-                                    if (!parsedEventSubject) {
-                                        return [2 /*return*/, (0, exports.returnEventsWithLogging)({ events: [] }, span)];
-                                    }
-                                    return [4 /*yield*/, (0, acquireLockWithValidation_1.acquireLockWithValidation)(syncEventResource, event, span)];
-                                case 2:
-                                    // Lock acquisition
-                                    acquiredLock = _j.sent();
-                                    return [4 /*yield*/, syncEventResource.acquireState(event, span)];
-                                case 3:
-                                    state = _j.sent();
-                                    if ((state === null || state === void 0 ? void 0 : state.executionStatus) === 'failure') {
-                                        (0, arvo_core_1.logToSpan)({
-                                            level: 'WARNING',
-                                            message: "The orchestration has failed in a previous event. Ignoring event id: ".concat(event.id, " with event subject: ").concat(event.subject),
-                                        }, span);
-                                        return [2 /*return*/, (0, exports.returnEventsWithLogging)({ events: [] }, span)];
-                                    }
-                                    orchestrationParentSubject = (_e = state === null || state === void 0 ? void 0 : state.parentSubject) !== null && _e !== void 0 ? _e : null;
-                                    initEventId = (_f = state === null || state === void 0 ? void 0 : state.initEventId) !== null && _f !== void 0 ? _f : null;
-                                    if (!state) {
+    var otelConfig;
+    var event = _b.event, opentelemetry = _b.opentelemetry, spanOptions = _b.spanOptions, source = _b.source, syncEventResource = _b.syncEventResource, executionunits = _b.executionunits, systemErrorDomain = _b.systemErrorDomain, selfContract = _b.selfContract, domain = _b.domain, _handlerType = _b._handlerType;
+    return __generator(this, function (_c) {
+        switch (_c.label) {
+            case 0:
+                otelConfig = (0, utils_1.createEventHandlerTelemetryConfig)(spanOptions.spanName({ selfContractUri: selfContract.uri, consumedEvent: event }), spanOptions, opentelemetry, event);
+                return [4 /*yield*/, arvo_core_1.ArvoOpenTelemetry.getInstance().startActiveSpan(__assign(__assign({}, otelConfig), { fn: function (span) { return __awaiter(void 0, void 0, void 0, function () {
+                            var _i, _a, _b, key, value, otelHeaders, orchestrationParentSubject, initEventId, acquiredLock, parsedEventSubject, state, _c, emittables, newState, i, _d, _e, _f, key, value, error_1, _g, errorToThrow, errorEvents;
+                            var _h, _j, _k, _l;
+                            return __generator(this, function (_m) {
+                                switch (_m.label) {
+                                    case 0:
+                                        span.setStatus({ code: api_1.SpanStatusCode.OK });
+                                        span.setAttribute('arvo.handler.execution.type', _handlerType);
+                                        span.setAttribute('arvo.handler.execution.status', 'normal');
+                                        for (_i = 0, _a = Object.entries(event.otelAttributes); _i < _a.length; _i++) {
+                                            _b = _a[_i], key = _b[0], value = _b[1];
+                                            span.setAttribute("consumable.0.".concat(key), value);
+                                        }
                                         (0, arvo_core_1.logToSpan)({
                                             level: 'INFO',
-                                            message: "Initializing new execution state for subject: ".concat(event.subject),
-                                        });
-                                        if (event.type !== source) {
+                                            message: "Starting execution for ".concat(event.type, " on subject ").concat(event.subject),
+                                        }, span);
+                                        otelHeaders = (0, arvo_core_1.currentOpenTelemetryHeaders)();
+                                        orchestrationParentSubject = null;
+                                        initEventId = null;
+                                        acquiredLock = null;
+                                        _m.label = 1;
+                                    case 1:
+                                        _m.trys.push([1, 6, 8, 10]);
+                                        parsedEventSubject = (0, validateAndParseSubject_1.validateAndParseSubject)(event, source, syncEventResource, span, 'orchestrator');
+                                        if (!parsedEventSubject) {
+                                            return [2 /*return*/, (0, exports.returnEventsWithLogging)({ events: [] }, span)];
+                                        }
+                                        return [4 /*yield*/, (0, acquireLockWithValidation_1.acquireLockWithValidation)(syncEventResource, event, span)];
+                                    case 2:
+                                        // Lock acquisition
+                                        acquiredLock = _m.sent();
+                                        return [4 /*yield*/, syncEventResource.acquireState(event, span)];
+                                    case 3:
+                                        state = _m.sent();
+                                        if ((state === null || state === void 0 ? void 0 : state.executionStatus) === 'failure') {
+                                            span.setAttribute('arvo.handler.execution.status', state.executionStatus);
                                             (0, arvo_core_1.logToSpan)({
                                                 level: 'WARNING',
-                                                message: "Invalid initialization event detected. Expected type '".concat(source, "' but received '").concat(event.type, "'."),
+                                                message: "The orchestration has failed in a previous event. Ignoring event id: ".concat(event.id, " with event subject: ").concat(event.subject),
+                                            }, span);
+                                            span.setStatus({
+                                                code: api_1.SpanStatusCode.ERROR,
+                                                message: "The orchestration has failed in a previous event. Ignoring event id: ".concat(event.id, " with event subject: ").concat(event.subject),
                                             });
                                             return [2 /*return*/, (0, exports.returnEventsWithLogging)({ events: [] }, span)];
                                         }
-                                    }
-                                    else {
+                                        orchestrationParentSubject = (_h = state === null || state === void 0 ? void 0 : state.parentSubject) !== null && _h !== void 0 ? _h : null;
+                                        initEventId = (_j = state === null || state === void 0 ? void 0 : state.initEventId) !== null && _j !== void 0 ? _j : null;
+                                        if (!state) {
+                                            (0, arvo_core_1.logToSpan)({
+                                                level: 'INFO',
+                                                message: "Initializing new execution state for subject: ".concat(event.subject),
+                                            });
+                                            if (event.type !== source) {
+                                                (0, arvo_core_1.logToSpan)({
+                                                    level: 'WARNING',
+                                                    message: "Invalid initialization event detected. Expected type '".concat(source, "' but received '").concat(event.type, "'."),
+                                                });
+                                                return [2 /*return*/, (0, exports.returnEventsWithLogging)({ events: [] }, span)];
+                                            }
+                                        }
+                                        else {
+                                            (0, arvo_core_1.logToSpan)({
+                                                level: 'INFO',
+                                                message: "Resuming execution with existing state for subject: ".concat(event.subject),
+                                            });
+                                        }
+                                        // Extract parent subject from init event if applicable
+                                        if (event.type === source) {
+                                            orchestrationParentSubject = (_l = (_k = event === null || event === void 0 ? void 0 : event.data) === null || _k === void 0 ? void 0 : _k.parentSubject$$) !== null && _l !== void 0 ? _l : null;
+                                        }
+                                        return [4 /*yield*/, coreExecutionFn({
+                                                span: span,
+                                                otelHeaders: otelHeaders,
+                                                orchestrationParentSubject: orchestrationParentSubject,
+                                                initEventId: initEventId !== null && initEventId !== void 0 ? initEventId : event.id,
+                                                parsedEventSubject: parsedEventSubject,
+                                                state: state,
+                                                _handlerType: _handlerType,
+                                            })];
+                                    case 4:
+                                        _c = _m.sent(), emittables = _c.emittables, newState = _c.newState;
+                                        // Add OpenTelemetry attributes for emitted events
+                                        for (i = 0; i < emittables.length; i++) {
+                                            for (_d = 0, _e = Object.entries(emittables[i].otelAttributes); _d < _e.length; _d++) {
+                                                _f = _e[_d], key = _f[0], value = _f[1];
+                                                span.setAttribute("emittables.".concat(i, ".").concat(key), value);
+                                            }
+                                        }
+                                        // Persist state
+                                        return [4 /*yield*/, syncEventResource.persistState(event, newState, state, span)];
+                                    case 5:
+                                        // Persist state
+                                        _m.sent();
                                         (0, arvo_core_1.logToSpan)({
                                             level: 'INFO',
-                                            message: "Resuming execution with existing state for subject: ".concat(event.subject),
+                                            message: "State update persisted in memory for subject ".concat(event.subject),
                                         });
-                                    }
-                                    // Extract parent subject from init event if applicable
-                                    if (event.type === source) {
-                                        orchestrationParentSubject = (_h = (_g = event === null || event === void 0 ? void 0 : event.data) === null || _g === void 0 ? void 0 : _g.parentSubject$$) !== null && _h !== void 0 ? _h : null;
-                                    }
-                                    return [4 /*yield*/, coreExecutionFn({
-                                            span: span,
-                                            otelHeaders: otelHeaders,
-                                            orchestrationParentSubject: orchestrationParentSubject,
-                                            initEventId: initEventId !== null && initEventId !== void 0 ? initEventId : event.id,
-                                            parsedEventSubject: parsedEventSubject,
-                                            state: state,
-                                            _handlerType: _handlerType,
-                                        })];
-                                case 4:
-                                    _a = _j.sent(), emittables = _a.emittables, newState = _a.newState;
-                                    span.setAttribute("arvo.".concat(_handlerType, ".execution.status"), newState.executionStatus);
-                                    // Add OpenTelemetry attributes for emitted events
-                                    for (i = 0; i < emittables.length; i++) {
-                                        for (_i = 0, _b = Object.entries(emittables[i].otelAttributes); _i < _b.length; _i++) {
-                                            _c = _b[_i], key = _c[0], value = _c[1];
-                                            span.setAttribute("to_emit.".concat(i, ".").concat(key), value);
-                                        }
-                                    }
-                                    // Persist state
-                                    return [4 /*yield*/, syncEventResource.persistState(event, newState, state, span)];
-                                case 5:
-                                    // Persist state
-                                    _j.sent();
-                                    (0, arvo_core_1.logToSpan)({
-                                        level: 'INFO',
-                                        message: "State update persisted in memory for subject ".concat(event.subject),
-                                    });
-                                    (0, arvo_core_1.logToSpan)({
-                                        level: 'INFO',
-                                        message: "Execution successfully completed and emitted ".concat(emittables.length, " events"),
-                                    });
-                                    return [2 /*return*/, (0, exports.returnEventsWithLogging)({ events: emittables }, span)];
-                                case 6:
-                                    error_1 = _j.sent();
-                                    return [4 /*yield*/, (0, handlerErrors_1.handleOrchestrationErrors)(_handlerType, {
-                                            error: error_1,
-                                            event: event,
-                                            otelHeaders: otelHeaders,
-                                            orchestrationParentSubject: orchestrationParentSubject,
-                                            initEventId: initEventId,
-                                            selfContract: selfContract,
-                                            systemErrorDomain: systemErrorDomain,
-                                            executionunits: executionunits,
-                                            source: source,
-                                            domain: domain,
-                                            syncEventResource: syncEventResource,
-                                        }, span)];
-                                case 7:
-                                    _d = _j.sent(), errorToThrow = _d.errorToThrow, errorEvents = _d.events;
-                                    if (errorToThrow)
-                                        throw errorToThrow;
-                                    return [2 /*return*/, {
-                                            events: errorEvents,
-                                        }];
-                                case 8: return [4 /*yield*/, syncEventResource.releaseLock(event, acquiredLock, span)];
-                                case 9:
-                                    _j.sent();
-                                    span.end();
-                                    return [7 /*endfinally*/];
-                                case 10: return [2 /*return*/];
-                            }
-                        });
-                    }); },
-                })];
-            case 1: return [2 /*return*/, _d.sent()];
+                                        (0, arvo_core_1.logToSpan)({
+                                            level: 'INFO',
+                                            message: "Execution successfully completed and emitted ".concat(emittables.length, " events"),
+                                        });
+                                        return [2 /*return*/, (0, exports.returnEventsWithLogging)({ events: emittables }, span)];
+                                    case 6:
+                                        error_1 = _m.sent();
+                                        span.setAttribute('arvo.handler.execution.status', 'failure');
+                                        return [4 /*yield*/, (0, handlerErrors_1.handleOrchestrationErrors)(_handlerType, {
+                                                error: error_1,
+                                                event: event,
+                                                otelHeaders: otelHeaders,
+                                                orchestrationParentSubject: orchestrationParentSubject,
+                                                initEventId: initEventId,
+                                                selfContract: selfContract,
+                                                systemErrorDomain: systemErrorDomain,
+                                                executionunits: executionunits,
+                                                source: source,
+                                                domain: domain,
+                                                syncEventResource: syncEventResource,
+                                                handlerType: _handlerType,
+                                            }, span)];
+                                    case 7:
+                                        _g = _m.sent(), errorToThrow = _g.errorToThrow, errorEvents = _g.events;
+                                        if (errorToThrow)
+                                            throw errorToThrow;
+                                        return [2 /*return*/, {
+                                                events: errorEvents,
+                                            }];
+                                    case 8: return [4 /*yield*/, syncEventResource.releaseLock(event, acquiredLock, span)];
+                                    case 9:
+                                        _m.sent();
+                                        span.end();
+                                        return [7 /*endfinally*/];
+                                    case 10: return [2 /*return*/];
+                                }
+                            });
+                        }); } }))];
+            case 1: return [2 /*return*/, _c.sent()];
         }
     });
 }); };

package/dist/ArvoOrchestrationUtils/servicesValidation.d.ts

@@ -0,0 +1,22 @@
+import type { ArvoContract, VersionedArvoContract } from 'arvo-core';
+import { type ArvoOrchestrationHandlerType } from './types';
+/**
+ * Validates that all service contracts in a collection have unique URIs.
+ *
+ * Iterates through the provided contracts and checks if any URI appears more than once.
+ * Multiple versions of the same contract (with the same URI) are not allowed.
+ *
+ * @param contracts - A record mapping contract keys to their respective ArvoContract objects
+ * @returns An object with a boolean result indicating if all contracts are unique, and the error keys if not
+ */
+export declare const areServiceContractsUnique: (contracts: Record<string, ArvoContract | VersionedArvoContract<any, any>>) => {
+    result: false;
+    keys: [string, string];
+    contractUri: string;
+} | {
+    result: true;
+};
+export declare const servicesValidation: (contracts: {
+    self: ArvoContract | VersionedArvoContract<any, any>;
+    services: Record<string, VersionedArvoContract<any, any>>;
+}, _handlerType: ArvoOrchestrationHandlerType) => void;

package/dist/ArvoOrchestrationUtils/servicesValidation.js

@@ -0,0 +1,56 @@
+"use strict";
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.servicesValidation = exports.areServiceContractsUnique = void 0;
+var uuid_1 = require("uuid");
+var errors_1 = require("../errors");
+var types_1 = require("./types");
+/**
+ * Validates that all service contracts in a collection have unique URIs.
+ *
+ * Iterates through the provided contracts and checks if any URI appears more than once.
+ * Multiple versions of the same contract (with the same URI) are not allowed.
+ *
+ * @param contracts - A record mapping contract keys to their respective ArvoContract objects
+ * @returns An object with a boolean result indicating if all contracts are unique, and the error keys if not
+ */
+var areServiceContractsUnique = function (contracts) {
+    var uriToKeyMap = {};
+    for (var _i = 0, _a = Object.entries(contracts); _i < _a.length; _i++) {
+        var _b = _a[_i], key = _b[0], contract = _b[1];
+        if (uriToKeyMap[contract.uri]) {
+            return {
+                result: false,
+                keys: [key, uriToKeyMap[contract.uri]],
+                contractUri: contract.uri,
+            };
+        }
+        uriToKeyMap[contract.uri] = key;
+    }
+    return {
+        result: true,
+    };
+};
+exports.areServiceContractsUnique = areServiceContractsUnique;
+var servicesValidation = function (contracts, _handlerType) {
+    var _a;
+    var __areServiceContractsUnique = (0, exports.areServiceContractsUnique)(contracts.services);
+    if (!__areServiceContractsUnique.result) {
+        throw new errors_1.ConfigViolation("In ".concat(types_1.ArvoOrchestrationHandlerMap[_handlerType], ", the service contracts must have unique URIs. Multiple versions of the same contract are not allow. The contracts '").concat(__areServiceContractsUnique.keys[0], "' and '").concat(__areServiceContractsUnique.keys[1], "' have the same URI '").concat(__areServiceContractsUnique.contractUri, "'"));
+    }
+    var __checkIfSelfIsAService = (0, exports.areServiceContractsUnique)(__assign(__assign({}, contracts.services), (_a = {}, _a[(0, uuid_1.v4)()] = contracts.self, _a)));
+    if (!__checkIfSelfIsAService.result) {
+        throw new errors_1.ConfigViolation("In ".concat(types_1.ArvoOrchestrationHandlerMap[_handlerType], ", Circular dependency detected: Machine with URI '").concat(contracts.self.uri, "' is registered as service '").concat(__checkIfSelfIsAService.keys[1], "'. Self-referential services create execution loops and are prohibited."));
+    }
+};
+exports.servicesValidation = servicesValidation;

package/dist/ArvoOrchestrationUtils/types.d.ts

@@ -1 +1,7 @@
-export type ArvoOrchestrationHandlerType = 'orchestrator' | 'resumable';
+export declare const ArvoOrchestrationHandlerMap: {
+    readonly orchestrator: "ArvoOrchestrator";
+    readonly resumable: "ArvoResumable";
+    readonly machine: "ArvoMachine";
+    readonly handler: "ArvoEventHandler";
+};
+export type ArvoOrchestrationHandlerType = keyof typeof ArvoOrchestrationHandlerMap;

package/dist/ArvoOrchestrationUtils/types.js

@@ -1,2 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.ArvoOrchestrationHandlerMap = void 0;
+exports.ArvoOrchestrationHandlerMap = {
+    orchestrator: 'ArvoOrchestrator',
+    resumable: 'ArvoResumable',
+    machine: 'ArvoMachine',
+    handler: 'ArvoEventHandler',
+};

package/dist/ArvoOrchestrator/factory.d.ts

@@ -1,5 +1,5 @@
 import { ArvoOrchestrator } from '.';
-import type { ICreateArvoOrchestrator } from './types';
+import type { CreateArvoOrchestratorParam } from './types';
 /**
  * Creates a new Arvo orchestrator instance with default components.
  * For custom components, use ArvoOrchestrator constructor directly.
@@ -26,4 +26,4 @@ import type { ICreateArvoOrchestrator } from './types';
  * });
  * ```
  */
-export declare const createArvoOrchestrator: ({ executionunits, memory, machines, systemErrorDomain, }: ICreateArvoOrchestrator) => ArvoOrchestrator;
+export declare const createArvoOrchestrator: ({ executionunits, memory, machines, systemErrorDomain, spanOptions, }: CreateArvoOrchestratorParam) => ArvoOrchestrator;

package/dist/ArvoOrchestrator/factory.js

@@ -41,7 +41,7 @@ var errors_1 = require("../errors");
  * ```
  */
 var createArvoOrchestrator = function (_a) {
-    var executionunits = _a.executionunits, memory = _a.memory, machines = _a.machines, systemErrorDomain = _a.systemErrorDomain;
+    var executionunits = _a.executionunits, memory = _a.memory, machines = _a.machines, systemErrorDomain = _a.systemErrorDomain, spanOptions = _a.spanOptions;
     if (!(machines === null || machines === void 0 ? void 0 : machines.length)) {
         throw new Error('At least one machine must be provided');
     }
@@ -66,6 +66,7 @@ var createArvoOrchestrator = function (_a) {
         executionEngine: new MachineExecutionEngine_1.MachineExecutionEngine(),
         requiresResourceLocking: requiresResourceLocking,
         systemErrorDomain: systemErrorDomain,
+        spanOptions: spanOptions,
     });
 };
 exports.createArvoOrchestrator = createArvoOrchestrator;

package/dist/ArvoOrchestrator/index.d.ts

@@ -16,6 +16,7 @@ export declare class ArvoOrchestrator implements IArvoEventHandler {
     readonly executionEngine: IMachineExectionEngine;
     readonly syncEventResource: SyncEventResource<MachineMemoryRecord>;
     readonly systemErrorDomain?: (string | null)[];
+    private readonly spanOptions;
     get source(): any;
     get requiresResourceLocking(): boolean;
     get memory(): IMachineMemory<MachineMemoryRecord>;
@@ -25,7 +26,7 @@ export declare class ArvoOrchestrator implements IArvoEventHandler {
      * @param params - Configuration parameters
      * @throws Error if machines in registry have different sources
      */
-    constructor({ executionunits, memory, registry, executionEngine, requiresResourceLocking, systemErrorDomain, }: ArvoOrchestratorParam);
+    constructor({ executionunits, memory, registry, executionEngine, requiresResourceLocking, systemErrorDomain, spanOptions, }: ArvoOrchestratorParam);
     /**
      * Core orchestration method that executes state machines in response to events.
      *

package/dist/ArvoOrchestrator/index.js

@@ -1,4 +1,15 @@
 "use strict";
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
 var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
     function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
     return new (P || (P = Promise))(function (resolve, reject) {
@@ -37,6 +48,7 @@ var __generator = (this && this.__generator) || function (thisArg, body) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ArvoOrchestrator = void 0;
+var api_1 = require("@opentelemetry/api");
 var arvo_core_1 = require("arvo-core");
 var createEmitableEvent_1 = require("../ArvoOrchestrationUtils/createEmitableEvent");
 var orchestrationExecutionWrapper_1 = require("../ArvoOrchestrationUtils/orchestrationExecutionWrapper");
@@ -53,13 +65,16 @@ var ArvoOrchestrator = /** @class */ (function () {
      * @throws Error if machines in registry have different sources
      */
     function ArvoOrchestrator(_a) {
-        var executionunits = _a.executionunits, memory = _a.memory, registry = _a.registry, executionEngine = _a.executionEngine, requiresResourceLocking = _a.requiresResourceLocking, systemErrorDomain = _a.systemErrorDomain;
+        var _b;
+        var executionunits = _a.executionunits, memory = _a.memory, registry = _a.registry, executionEngine = _a.executionEngine, requiresResourceLocking = _a.requiresResourceLocking, systemErrorDomain = _a.systemErrorDomain, spanOptions = _a.spanOptions;
+        var _c, _d, _e, _f, _g, _h, _j;
         this.systemErrorDomain = [];
         this.executionunits = executionunits;
         this.registry = registry;
         this.executionEngine = executionEngine;
         this.syncEventResource = new SyncEventResource_1.SyncEventResource(memory, requiresResourceLocking);
         this.systemErrorDomain = systemErrorDomain;
+        this.spanOptions = __assign(__assign({ kind: api_1.SpanKind.PRODUCER }, spanOptions), { attributes: __assign(__assign((_b = {}, _b[arvo_core_1.ArvoExecution.ATTR_SPAN_KIND] = arvo_core_1.ArvoExecutionSpanKind.ORCHESTRATOR, _b[arvo_core_1.OpenInference.ATTR_SPAN_KIND] = arvo_core_1.OpenInferenceSpanKind.CHAIN, _b), ((_c = spanOptions === null || spanOptions === void 0 ? void 0 : spanOptions.attributes) !== null && _c !== void 0 ? _c : {})), { 'arvo.handler.source': this.source, 'arvo.contract.uri': (_j = (_h = (_g = (_f = (_e = (_d = this === null || this === void 0 ? void 0 : this.registry) === null || _d === void 0 ? void 0 : _d.machines) === null || _e === void 0 ? void 0 : _e[0]) === null || _f === void 0 ? void 0 : _f.contracts) === null || _g === void 0 ? void 0 : _g.self) === null || _h === void 0 ? void 0 : _h.uri) !== null && _j !== void 0 ? _j : 'N/A' }) });
     }
     Object.defineProperty(ArvoOrchestrator.prototype, "source", {
         get: function () {
@@ -101,19 +116,19 @@ var ArvoOrchestrator = /** @class */ (function () {
      * @throws {ContractViolation} Schema/contract mismatch
      * @throws {ConfigViolation} Missing/invalid machine version
      */
-    ArvoOrchestrator.prototype.execute = function (event_1) {
-        return __awaiter(this, arguments, void 0, function (event, opentelemetry) {
+    ArvoOrchestrator.prototype.execute = function (event, opentelemetry) {
+        return __awaiter(this, void 0, void 0, function () {
             var _this = this;
-            if (opentelemetry === void 0) { opentelemetry = {
-                inheritFrom: 'EVENT',
-            }; }
             return __generator(this, function (_a) {
                 switch (_a.label) {
                     case 0: return [4 /*yield*/, (0, orchestrationExecutionWrapper_1.executeWithOrchestrationWrapper)({
                             _handlerType: 'orchestrator',
                             event: event,
-                            opentelemetry: opentelemetry,
-                            spanName: "Orchestrator<".concat(this.registry.machines[0].contracts.self.uri, ">@<").concat(event.type, ">"),
+                            opentelemetry: opentelemetry !== null && opentelemetry !== void 0 ? opentelemetry : { inheritFrom: 'EVENT' },
+                            spanOptions: __assign({ spanName: function (_a) {
+                                    var selfContractUri = _a.selfContractUri, consumedEvent = _a.consumedEvent;
+                                    return "Orchestrator<".concat(selfContractUri, ">@<").concat(consumedEvent.type, ">");
+                                } }, this.spanOptions),
                             source: this.source,
                             syncEventResource: this.syncEventResource,
                             executionunits: this.executionunits,

package/dist/ArvoOrchestrator/types.d.ts

@@ -5,6 +5,7 @@ import type { OrchestrationExecutionMemoryRecord } from '../ArvoOrchestrationUti
 import type { IMachineExectionEngine } from '../MachineExecutionEngine/interface';
 import type { IMachineMemory } from '../MachineMemory/interface';
 import type { IMachineRegistry } from '../MachineRegistry/interface';
+import type { ArvoEventHandlerOtelSpanOptions } from '../types';
 export type TryFunctionOutput<TData, TError extends Error> = {
     type: 'success';
     data: TData;
@@ -82,24 +83,6 @@ export type ArvoOrchestratorParam = {
     /** Engine responsible for machine execution */
     executionEngine: IMachineExectionEngine;
     requiresResourceLocking: boolean;
-    /**
-     * Optional configuration to customize where system error events are emitted.
-     */
-    systemErrorDomain?: (string | null)[];
-};
-/**
- * Configuration interface for creating an Arvo orchestrator instance.
- */
-export interface ICreateArvoOrchestrator {
-    /** Memory interface for storing and retrieving machine state */
-    memory: IMachineMemory<MachineMemoryRecord>;
-    /** The cost of the execution of the orchestrator */
-    executionunits: number;
-    /**
-     * Collection of state machines to be managed by the orchestrator.
-     * All machines must have the same source identifier.
-     */
-    machines: ArvoMachine<any, any, any, any, any>[];
     /**
      * Optional configuration to customize where system error events are emitted.
      *
@@ -114,4 +97,18 @@ export interface ICreateArvoOrchestrator {
      * @default undefined — uses standard fallback broadcast domains
      */
     systemErrorDomain?: (string | null)[];
-}
+    /**
+     * The OpenTelemetry span options
+     */
+    spanOptions?: ArvoEventHandlerOtelSpanOptions;
+};
+/**
+ * Configuration interface for creating an Arvo orchestrator instance.
+ */
+export type CreateArvoOrchestratorParam = Pick<ArvoOrchestratorParam, 'memory' | 'executionunits' | 'spanOptions' | 'systemErrorDomain'> & {
+    /**
+     * Collection of state machines to be managed by the orchestrator.
+     * All machines must have the same source identifier.
+     */
+    machines: ArvoMachine<any, any, any, any, any>[];
+};

package/dist/ArvoResumable/factory.d.ts

@@ -1,6 +1,7 @@
 import type { ArvoOrchestratorContract, VersionedArvoContract } from 'arvo-core';
 import { ArvoResumable } from '.';
 import type { IMachineMemory } from '../MachineMemory/interface';
+import type { ArvoEventHandlerOtelSpanOptions } from '../types';
 import type { ArvoResumableHandler, ArvoResumableState } from './types';
 /**
  * Factory function for creating ArvoResumable orchestrator instances
@@ -39,4 +40,5 @@ export declare const createArvoResumable: <TMemory extends Record<string, any>,
     executionunits?: number;
     requiresResourceLocking?: boolean;
     systemErrorDomain?: (string | null)[];
+    spanOptions?: ArvoEventHandlerOtelSpanOptions;
 }) => ArvoResumable<TMemory, TSelfContract, TServiceContract>;

package/dist/ArvoResumable/factory.js

@@ -1,20 +1,8 @@
 "use strict";
-var __assign = (this && this.__assign) || function () {
-    __assign = Object.assign || function(t) {
-        for (var s, i = 1, n = arguments.length; i < n; i++) {
-            s = arguments[i];
-            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
-                t[p] = s[p];
-        }
-        return t;
-    };
-    return __assign.apply(this, arguments);
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createArvoResumable = void 0;
-var uuid_1 = require("uuid");
 var _1 = require(".");
-var utils_1 = require("../ArvoMachine/utils");
+var servicesValidation_1 = require("../ArvoOrchestrationUtils/servicesValidation");
 /**
  * Factory function for creating ArvoResumable orchestrator instances
  *
@@ -40,23 +28,16 @@ var utils_1 = require("../ArvoMachine/utils");
  * @throws {Error} Circular dependency detected - Self contract is registered as a service, creating execution loops
  */
 var createArvoResumable = function (param) {
-    var _a;
-    var _b, _c;
-    var __areServiceContractsUnique = (0, utils_1.areServiceContractsUnique)(param.contracts.services);
-    if (!__areServiceContractsUnique.result) {
-        throw new Error("The service contracts must have unique URIs. Multiple versions of the same contract are not allow. The contracts '".concat(__areServiceContractsUnique.keys[0], "' and '").concat(__areServiceContractsUnique.keys[1], "' have the same URI '").concat(__areServiceContractsUnique.contractUri, "'"));
-    }
-    var __checkIfSelfIsAService = (0, utils_1.areServiceContractsUnique)(__assign(__assign({}, param.contracts.services), (_a = {}, _a[(0, uuid_1.v4)()] = param.contracts.self, _a)));
-    if (!__checkIfSelfIsAService.result) {
-        throw new Error("Circular dependency detected: Machine with URI '".concat(param.contracts.self.uri, "' is registered as service '").concat(__checkIfSelfIsAService.keys[1], "'. Self-referential services create execution loops and are prohibited."));
-    }
+    var _a, _b;
+    (0, servicesValidation_1.servicesValidation)(param.contracts, 'resumable');
     return new _1.ArvoResumable({
         contracts: param.contracts,
         memory: param.memory,
         handler: param.handler,
-        executionunits: (_b = param.executionunits) !== null && _b !== void 0 ? _b : 0,
-        requiresResourceLocking: (_c = param.requiresResourceLocking) !== null && _c !== void 0 ? _c : Object.keys(param.contracts.services).length > 1,
+        executionunits: (_a = param.executionunits) !== null && _a !== void 0 ? _a : 0,
+        requiresResourceLocking: (_b = param.requiresResourceLocking) !== null && _b !== void 0 ? _b : Object.keys(param.contracts.services).length > 1,
         systemErrorDomain: param.systemErrorDomain,
+        spanOptions: param.spanOptions,
     });
 };
 exports.createArvoResumable = createArvoResumable;

package/dist/ArvoResumable/index.d.ts

@@ -1,10 +1,10 @@
-import type { Span } from '@opentelemetry/api';
+import { type Span } from '@opentelemetry/api';
 import { type ArvoEvent, type ArvoOrchestratorContract, type VersionedArvoContract } from 'arvo-core';
 import type { z } from 'zod';
 import type IArvoEventHandler from '../IArvoEventHandler';
 import type { IMachineMemory } from '../MachineMemory/interface';
 import { SyncEventResource } from '../SyncEventResource/index';
-import type { ArvoEventHandlerOpenTelemetryOptions } from '../types';
+import type { ArvoEventHandlerOpenTelemetryOptions, ArvoEventHandlerOtelSpanOptions } from '../types';
 import type { ArvoResumableHandler, ArvoResumableState } from './types';
 /**
  * ArvoResumable - A stateful orchestration handler for managing distributed workflows
@@ -43,6 +43,7 @@ export declare class ArvoResumable<TMemory extends Record<string, any> = Record<
     readonly source: string;
     readonly handler: ArvoResumableHandler<ArvoResumableState<TMemory>, TSelfContract, TServiceContract>;
     readonly systemErrorDomain?: (string | null)[];
+    private readonly spanOptions;
     readonly contracts: {
         self: TSelfContract;
         services: TServiceContract;
@@ -60,6 +61,7 @@ export declare class ArvoResumable<TMemory extends Record<string, any> = Record<
         requiresResourceLocking?: boolean;
         handler: ArvoResumableHandler<ArvoResumableState<TMemory>, TSelfContract, TServiceContract>;
         systemErrorDomain?: (string | null)[];
+        spanOptions?: ArvoEventHandlerOtelSpanOptions;
     });
     protected validateInput(event: ArvoEvent, span: Span): {
         contractType: 'self' | 'service';
@@ -77,7 +79,7 @@ export declare class ArvoResumable<TMemory extends Record<string, any> = Record<
      * @throws {ContractViolation} When event schema validation fails
      * @throws {ExecutionViolation} When workflow execution encounters critical errors
      */
-    execute(event: ArvoEvent, opentelemetry: ArvoEventHandlerOpenTelemetryOptions): Promise<{
+    execute(event: ArvoEvent, opentelemetry?: ArvoEventHandlerOpenTelemetryOptions): Promise<{
         events: ArvoEvent[];
     }>;
     get systemErrorSchema(): import("arvo-core").ArvoContractRecord<`sys.arvo.orc.${string}.error`, z.ZodObject<{

package/dist/ArvoResumable/index.js

@@ -1,4 +1,15 @@
 "use strict";
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
 var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
     function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
     return new (P || (P = Promise))(function (resolve, reject) {
@@ -46,6 +57,7 @@ var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ArvoResumable = void 0;
+var api_1 = require("@opentelemetry/api");
 var arvo_core_1 = require("arvo-core");
 var createEmitableEvent_1 = require("../ArvoOrchestrationUtils/createEmitableEvent");
 var orchestrationExecutionWrapper_1 = require("../ArvoOrchestrationUtils/orchestrationExecutionWrapper");
@@ -85,13 +97,15 @@ var errors_1 = require("../errors");
 var ArvoResumable = /** @class */ (function () {
     function ArvoResumable(param) {
         var _a;
+        var _b, _c, _d;
         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.syncEventResource = new index_1.SyncEventResource(param.memory, (_b = param.requiresResourceLocking) !== null && _b !== void 0 ? _b : true);
         this.contracts = param.contracts;
         this.handler = param.handler;
         this.systemErrorDomain = param.systemErrorDomain;
+        this.spanOptions = __assign(__assign({ kind: api_1.SpanKind.PRODUCER }, param.spanOptions), { attributes: __assign(__assign((_a = {}, _a[arvo_core_1.ArvoExecution.ATTR_SPAN_KIND] = arvo_core_1.ArvoExecutionSpanKind.ORCHESTRATOR, _a[arvo_core_1.OpenInference.ATTR_SPAN_KIND] = arvo_core_1.OpenInferenceSpanKind.CHAIN, _a), ((_d = (_c = param.spanOptions) === null || _c === void 0 ? void 0 : _c.attributes) !== null && _d !== void 0 ? _d : {})), { 'arvo.handler.source': this.source, 'arvo.contract.uri': this.contracts.self.uri }) });
     }
     Object.defineProperty(ArvoResumable.prototype, "requiresResourceLocking", {
         get: function () {
@@ -183,8 +197,11 @@ var ArvoResumable = /** @class */ (function () {
                     case 0: return [4 /*yield*/, (0, orchestrationExecutionWrapper_1.executeWithOrchestrationWrapper)({
                             _handlerType: 'resumable',
                             event: event,
-                            opentelemetry: opentelemetry,
-                            spanName: "Resumable<".concat(this.contracts.self.uri, ">@<").concat(event.type, ">"),
+                            opentelemetry: opentelemetry !== null && opentelemetry !== void 0 ? opentelemetry : { inheritFrom: 'EVENT' },
+                            spanOptions: __assign({ spanName: function (_a) {
+                                    var selfContractUri = _a.selfContractUri, consumedEvent = _a.consumedEvent;
+                                    return "Resumable<".concat(selfContractUri, ">@<").concat(consumedEvent.type, ">");
+                                } }, this.spanOptions),
                             source: this.source,
                             syncEventResource: this.syncEventResource,
                             executionunits: this.executionunits,

package/dist/IArvoEventHandler/index.d.ts

@@ -21,7 +21,7 @@ export default interface IArvoEventHandler {
      * @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<{
+    execute(event: ArvoEvent, opentelemetry?: ArvoEventHandlerOpenTelemetryOptions): Promise<{
         events: ArvoEvent[];
     }>;
     /**

package/dist/index.d.ts

@@ -6,7 +6,8 @@ import { ArvoEventHandlerFunction, ArvoEventHandlerFunctionInput, ArvoEventHandl
 import ArvoMachine from './ArvoMachine';
 import { setupArvoMachine } from './ArvoMachine/createMachine';
 import { ArvoMachineContext, EnqueueArvoEventActionParam } from './ArvoMachine/types';
-import { isTransactionViolationError, TransactionViolation, TransactionViolationCause } from './ArvoOrchestrationUtils/error';
+import { TransactionViolation, TransactionViolationCause, isTransactionViolationError } from './ArvoOrchestrationUtils/error';
+import { OrchestrationExecutionStatus } from './ArvoOrchestrationUtils/orchestrationExecutionState';
 import { ArvoOrchestrator } from './ArvoOrchestrator';
 import { createArvoOrchestrator } from './ArvoOrchestrator/factory';
 import { ArvoOrchestratorParam, MachineMemoryRecord } from './ArvoOrchestrator/types';
@@ -23,13 +24,12 @@ import { IMachineMemory } from './MachineMemory/interface';
 import { MachineRegistry } from './MachineRegistry';
 import { IMachineRegistry } from './MachineRegistry/interface';
 import { ConfigViolation, ContractViolation, ExecutionViolation } from './errors';
-import { ArvoEventHandlerOpenTelemetryOptions, EventHandlerFactory, PartialExcept } from './types';
+import { ArvoEventHandlerOpenTelemetryOptions, ArvoEventHandlerOtelSpanOptions, EventHandlerFactory, PartialExcept } from './types';
 import { coalesce, coalesceOrDefault, getValueOrDefault, isNullOrUndefined } from './utils';
 import { SimpleEventBroker } from './utils/SimpleEventBroker';
 import { createSimpleEventBroker } from './utils/SimpleEventBroker/helper';
-import { OrchestrationExecutionStatus } from './ArvoOrchestrationUtils/orchestrationExecutionState';
 declare const xstate: {
     emit: typeof emit;
     assign: typeof assign;
 };
-export { ArvoEventHandler, createArvoEventHandler, IArvoEventHandler, ArvoEventHandlerFunctionOutput, ArvoEventHandlerFunctionInput, ArvoEventHandlerFunction, PartialExcept, isNullOrUndefined, getValueOrDefault, coalesce, coalesceOrDefault, ArvoEventHandlerOpenTelemetryOptions, EventHandlerFactory, ContractViolation, ConfigViolation, ExecutionViolation, ArvoMachine, setupArvoMachine, ArvoMachineContext, EnqueueArvoEventActionParam, IMachineRegistry, MachineRegistry, MachineExecutionEngine, IMachineExectionEngine, ExecuteMachineInput, ExecuteMachineOutput, IMachineMemory, SimpleMachineMemory, MachineMemoryRecord, ArvoOrchestratorParam, TransactionViolation, TransactionViolationCause, ArvoOrchestrator, createArvoOrchestrator, SimpleEventBroker, createSimpleEventBroker, TelemetredSimpleMachineMemory, xstate, ArvoResumable, createArvoResumable, ArvoResumableHandler, ArvoResumableState, ArvoDomain, resolveEventDomain, isTransactionViolationError, OrchestrationExecutionStatus };
+export { ArvoEventHandler, createArvoEventHandler, IArvoEventHandler, ArvoEventHandlerFunctionOutput, ArvoEventHandlerFunctionInput, ArvoEventHandlerFunction, PartialExcept, isNullOrUndefined, getValueOrDefault, coalesce, coalesceOrDefault, ArvoEventHandlerOpenTelemetryOptions, EventHandlerFactory, ContractViolation, ConfigViolation, ExecutionViolation, ArvoMachine, setupArvoMachine, ArvoMachineContext, EnqueueArvoEventActionParam, IMachineRegistry, MachineRegistry, MachineExecutionEngine, IMachineExectionEngine, ExecuteMachineInput, ExecuteMachineOutput, IMachineMemory, SimpleMachineMemory, MachineMemoryRecord, ArvoOrchestratorParam, TransactionViolation, TransactionViolationCause, ArvoOrchestrator, createArvoOrchestrator, SimpleEventBroker, createSimpleEventBroker, TelemetredSimpleMachineMemory, xstate, ArvoResumable, createArvoResumable, ArvoResumableHandler, ArvoResumableState, ArvoDomain, resolveEventDomain, isTransactionViolationError, OrchestrationExecutionStatus, ArvoEventHandlerOtelSpanOptions, };

package/dist/index.js

@@ -17,9 +17,11 @@ exports.ArvoMachine = ArvoMachine_1.default;
 var createMachine_1 = require("./ArvoMachine/createMachine");
 Object.defineProperty(exports, "setupArvoMachine", { enumerable: true, get: function () { return createMachine_1.setupArvoMachine; } });
 var error_1 = require("./ArvoOrchestrationUtils/error");
-Object.defineProperty(exports, "isTransactionViolationError", { enumerable: true, get: function () { return error_1.isTransactionViolationError; } });
 Object.defineProperty(exports, "TransactionViolation", { enumerable: true, get: function () { return error_1.TransactionViolation; } });
 Object.defineProperty(exports, "TransactionViolationCause", { enumerable: true, get: function () { return error_1.TransactionViolationCause; } });
+Object.defineProperty(exports, "isTransactionViolationError", { enumerable: true, get: function () { return error_1.isTransactionViolationError; } });
+var orchestrationExecutionState_1 = require("./ArvoOrchestrationUtils/orchestrationExecutionState");
+Object.defineProperty(exports, "OrchestrationExecutionStatus", { enumerable: true, get: function () { return orchestrationExecutionState_1.OrchestrationExecutionStatus; } });
 var ArvoOrchestrator_1 = require("./ArvoOrchestrator");
 Object.defineProperty(exports, "ArvoOrchestrator", { enumerable: true, get: function () { return ArvoOrchestrator_1.ArvoOrchestrator; } });
 var factory_1 = require("./ArvoOrchestrator/factory");
@@ -49,8 +51,6 @@ var SimpleEventBroker_1 = require("./utils/SimpleEventBroker");
 Object.defineProperty(exports, "SimpleEventBroker", { enumerable: true, get: function () { return SimpleEventBroker_1.SimpleEventBroker; } });
 var helper_1 = require("./utils/SimpleEventBroker/helper");
 Object.defineProperty(exports, "createSimpleEventBroker", { enumerable: true, get: function () { return helper_1.createSimpleEventBroker; } });
-var orchestrationExecutionState_1 = require("./ArvoOrchestrationUtils/orchestrationExecutionState");
-Object.defineProperty(exports, "OrchestrationExecutionStatus", { enumerable: true, get: function () { return orchestrationExecutionState_1.OrchestrationExecutionStatus; } });
 var xstate = {
     emit: xstate_1.emit,
     assign: xstate_1.assign,

package/dist/types.d.ts

@@ -1,3 +1,5 @@
+import type { SpanOptions } from '@opentelemetry/api';
+import type { ArvoEvent } from 'arvo-core';
 import type IArvoEventHandler from './IArvoEventHandler';
 /**
  * Makes properties optional except specified keys
@@ -30,3 +32,9 @@ export type ArvoEventHandlerOpenTelemetryOptions = {
  * @template T - Configuration object type
  */
 export type EventHandlerFactory<T = void> = T extends void ? () => IArvoEventHandler : (config: T) => IArvoEventHandler;
+export type ArvoEventHandlerOtelSpanOptions = SpanOptions & {
+    spanName?: (param: {
+        selfContractUri: string;
+        consumedEvent: ArvoEvent;
+    }) => string;
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "arvo-event-handler",
-  "version": "3.0.8",
+  "version": "3.0.10",
   "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,7 +46,7 @@
   "dependencies": {
     "@opentelemetry/api": "^1.9.0",
     "@opentelemetry/core": "^1.30.1",
-    "arvo-core": "^3.0.8",
+    "arvo-core": "^3.0.10",
     "uuid": "^11.1.0",
     "xstate": "^5.23.0",
     "zod": "^3.25.74",