arvo-event-handler 2.2.6 → 2.2.7

package/biome.json

@@ -0,0 +1,58 @@
+{
+  "$schema": "https://biomejs.dev/schemas/1.9.4/schema.json",
+  "vcs": {
+    "enabled": false,
+    "clientKind": "git",
+    "useIgnoreFile": false
+  },
+  "files": {
+    "ignoreUnknown": false,
+    "ignore": [
+      "**/dist/**",
+      "**/node_modules/**",
+      "**/.turbo/**",
+      "**/coverage/**",
+      "**/.github/**",
+      "**/docs/**",
+      "*.md"
+    ]
+  },
+  "formatter": {
+    "enabled": true,
+    "formatWithErrors": false,
+    "ignore": [],
+    "attributePosition": "auto",
+    "indentStyle": "space",
+    "indentWidth": 2,
+    "lineWidth": 120,
+    "lineEnding": "lf"
+  },
+  "organizeImports": {
+    "enabled": true
+  },
+  "linter": {
+    "enabled": true,
+    "rules": {
+      "recommended": true,
+      "correctness": {
+        "noUnusedImports": "warn"
+      },
+      "suspicious": {
+        "noExplicitAny": "off"
+      }
+    }
+  },
+  "javascript": {
+    "jsxRuntime": "reactClassic",
+    "formatter": {
+      "quoteStyle": "single",
+      "arrowParentheses": "always",
+      "bracketSameLine": false,
+      "bracketSpacing": true,
+      "jsxQuoteStyle": "single",
+      "quoteProperties": "asNeeded",
+      "semicolons": "always",
+      "trailingCommas": "all"
+    }
+  }
+}

package/dist/AbstractArvoEventHandler/index.d.ts

@@ -1,5 +1,5 @@
-import { ArvoContractRecord, ArvoEvent } from 'arvo-core';
-import { ArvoEventHandlerOpenTelemetryOptions } from '../types';
+import type { ArvoContractRecord, ArvoEvent } from 'arvo-core';
+import type { ArvoEventHandlerOpenTelemetryOptions } from '../types';
 /**
  * Abstract base class for Arvo event handlers.
  *

package/dist/ArvoEventHandler/helpers.d.ts

@@ -1,6 +1,6 @@
-import { ArvoContract } from 'arvo-core';
-import { IArvoEventHandler } from './types';
+import type { ArvoContract } from 'arvo-core';
 import ArvoEventHandler from '.';
+import type { IArvoEventHandler } from './types';
 /**
  * Creates an ArvoEventHandler for processing events defined by a specific contract.
  * Each handler manages event validation, processing, and telemetry for its contract.

package/dist/ArvoEventHandler/index.d.ts

@@ -1,17 +1,49 @@
-import { ArvoContract, ArvoEvent } from 'arvo-core';
-import { IArvoEventHandler, ArvoEventHandlerFunction } from './types';
-import { SpanOptions } from '@opentelemetry/api';
+import { type SpanOptions } from '@opentelemetry/api';
+import { type ArvoContract, type ArvoEvent } from 'arvo-core';
 import AbstractArvoEventHandler from '../AbstractArvoEventHandler';
-import { ArvoEventHandlerOpenTelemetryOptions } from '../types';
+import type { ArvoEventHandlerOpenTelemetryOptions } from '../types';
+import type { ArvoEventHandlerFunction, IArvoEventHandler } from './types';
 /**
- * ArvoEventHandler manages the execution and processing of events in accordance with
- * Arvo contracts. This class serves as the cornerstone for event handling operations,
- * integrating contract validation, telemetry management, and event processing.
+ * ArvoEventHandler is the core component for processing events in the Arvo system. It enforces
+ * contracts between services by ensuring that all events follow their specified formats and rules.
  *
- * The handler implements a robust execution flow that ensures proper validation,
- * versioning, and error handling while maintaining detailed telemetry through
- * OpenTelemetry integration. It supports versioned contracts and handles routing
- * of both successful and error events.
+ * The handler is built on two fundamental patterns: Meyer's Design by Contract and Fowler's
+ * Tolerant Reader. It binds to an ArvoContract that defines what events it can receive and send
+ * across all versions. This versioning is strict - the handler must implement every version defined
+ * in its contract, or it will fail both at compile time and runtime.
+ *
+ * Following the Tolerant Reader pattern, the handler accepts any incoming event but only processes
+ * those that exactly match one of its contract versions. When an event matches, it's handled by
+ * the specific implementation for that version. This approach maintains compatibility while
+ * ensuring precise contract adherence.
+ *
+ * The handler uses Zod for validation, automatically checking both incoming and outgoing events.
+ * This means it not only verifies data formats but also applies default values where needed and
+ * ensures all conditions are met before and after processing.
+ *
+ * Error handling in the handler divides issues into two categories:
+ *
+ * - `Violations` are serious contract breaches that indicate fundamental problems with how services
+ * are communicating. These errors bubble up to the calling code, allowing developers to handle
+ * these critical issues explicitly.
+ *
+ * - `System Error Events` cover normal runtime errors that occur during event processing. These are
+ * typically workflow-related issues that need to be reported back to the event's source but don't
+ * indicate a broken contract.
+ *
+ * * @example
+ * const handler = createArvoEventHandler({
+ *   contract: userContract,
+ *   executionunits: 1,
+ *   handler: {
+ *     '1.0.0': async ({ event }) => {
+ *       // Process event according to contract v1.0.0
+ *     },
+ *     '2.0.0': async ({ event }) => {
+ *       // Process event according to contract v2.0.0
+ *     }
+ *   }
+ * });
  */
 export default class ArvoEventHandler<TContract extends ArvoContract> extends AbstractArvoEventHandler {
     /** Contract instance that defines the event schema and validation rules */
@@ -36,31 +68,36 @@ export default class ArvoEventHandler<TContract extends ArvoContract> extends Ab
      */
     constructor(param: IArvoEventHandler<TContract>);
     /**
-     * Processes an event according to the contract specifications. The execution flow encompasses
-     * span management, validation, handler execution, and error processing phases.
-     *
-     * Event Routing Logic:
-     * - Success events: Routes based on priority (handler result -> redirectto -> source)
-     * - Error events: Always routes back to the source
+     * Processes an incoming event according to the handler's contract specifications. This method
+     * handles the complete lifecycle of event processing including validation, execution, and error
+     * handling, while maintaining detailed telemetry through OpenTelemetry.
      *
-     * Telemetry Integration:
-     * - Creates and manages OpenTelemetry spans for execution tracking
-     * - Propagates trace context through the event chain
-     * - Records execution metrics and error details
+     * The execution follows a careful sequence to ensure reliability:
+     * First, it validates that the event matches the handler's contract type. Then it extracts
+     * and validates the event's schema version, defaulting to the latest version if none is specified.
+     * After validation passes, it executes the version-specific handler function and processes its
+     * output into new events.
      *
-     * Version Resolution:
-     * - Extracts version from event dataschema
-     * - Falls back to latest version if unspecified
-     * - Validates event data against versioned contract schema
+     * The method handles routing through three distinct paths:
+     * - For successful execution, events are routed based on handler output or configuration.
+     *    - The 'to' field in the handler's result (if specified)
+     *    - The 'redirectto' field from the source event (if present)
+     *    - Falls back to the source event's 'source' field
+     * - For violations (mismatched types, invalid data), errors bubble up to the caller
+     * - For runtime errors, system error events are created and sent back to the source
      *
-     * Error Handling:
-     * - Converts all errors to system error events
-     * - Maintains telemetry context for error scenarios
-     * - Ensures proper error event routing
+     * Throughout execution, comprehensive telemetry is maintained through OpenTelemetry spans,
+     * tracking the complete event journey including validation steps, processing time, and any
+     * errors that occur. This enables detailed monitoring and debugging of the event flow.
      *
-     * @param event - The event to process
+     * @param event - The incoming event to process
      * @param opentelemetry - Configuration for OpenTelemetry context inheritance
-     * @returns Promise resolving to array of result events or error event
+     * @returns Promise resolving to an array of output events or error events
+     * @throws `ContractViolation` when input or output event data violates the contract
+     * @throws `ConfigViolation` when event type doesn't match contract type or the
+     *                           contract version expected by the event does not exist
+     *                           in handler configuration
+     * @throws `ExecutionViolation` for explicitly handled runtime errors
      */
     execute(event: ArvoEvent, opentelemetry?: ArvoEventHandlerOpenTelemetryOptions): Promise<ArvoEvent[]>;
     /**

package/dist/ArvoEventHandler/index.js

@@ -65,20 +65,52 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-var arvo_core_1 = require("arvo-core");
 var api_1 = require("@opentelemetry/api");
-var utils_1 = require("../utils");
+var arvo_core_1 = require("arvo-core");
 var AbstractArvoEventHandler_1 = __importDefault(require("../AbstractArvoEventHandler"));
 var errors_1 = require("../errors");
+var utils_1 = require("../utils");
 /**
- * ArvoEventHandler manages the execution and processing of events in accordance with
- * Arvo contracts. This class serves as the cornerstone for event handling operations,
- * integrating contract validation, telemetry management, and event processing.
+ * ArvoEventHandler is the core component for processing events in the Arvo system. It enforces
+ * contracts between services by ensuring that all events follow their specified formats and rules.
+ *
+ * The handler is built on two fundamental patterns: Meyer's Design by Contract and Fowler's
+ * Tolerant Reader. It binds to an ArvoContract that defines what events it can receive and send
+ * across all versions. This versioning is strict - the handler must implement every version defined
+ * in its contract, or it will fail both at compile time and runtime.
+ *
+ * Following the Tolerant Reader pattern, the handler accepts any incoming event but only processes
+ * those that exactly match one of its contract versions. When an event matches, it's handled by
+ * the specific implementation for that version. This approach maintains compatibility while
+ * ensuring precise contract adherence.
+ *
+ * The handler uses Zod for validation, automatically checking both incoming and outgoing events.
+ * This means it not only verifies data formats but also applies default values where needed and
+ * ensures all conditions are met before and after processing.
+ *
+ * Error handling in the handler divides issues into two categories:
+ *
+ * - `Violations` are serious contract breaches that indicate fundamental problems with how services
+ * are communicating. These errors bubble up to the calling code, allowing developers to handle
+ * these critical issues explicitly.
  *
- * The handler implements a robust execution flow that ensures proper validation,
- * versioning, and error handling while maintaining detailed telemetry through
- * OpenTelemetry integration. It supports versioned contracts and handles routing
- * of both successful and error events.
+ * - `System Error Events` cover normal runtime errors that occur during event processing. These are
+ * typically workflow-related issues that need to be reported back to the event's source but don't
+ * indicate a broken contract.
+ *
+ * * @example
+ * const handler = createArvoEventHandler({
+ *   contract: userContract,
+ *   executionunits: 1,
+ *   handler: {
+ *     '1.0.0': async ({ event }) => {
+ *       // Process event according to contract v1.0.0
+ *     },
+ *     '2.0.0': async ({ event }) => {
+ *       // Process event according to contract v2.0.0
+ *     }
+ *   }
+ * });
  */
 var ArvoEventHandler = /** @class */ (function (_super) {
     __extends(ArvoEventHandler, _super);
@@ -117,31 +149,36 @@ var ArvoEventHandler = /** @class */ (function (_super) {
         configurable: true
     });
     /**
-     * Processes an event according to the contract specifications. The execution flow encompasses
-     * span management, validation, handler execution, and error processing phases.
-     *
-     * Event Routing Logic:
-     * - Success events: Routes based on priority (handler result -> redirectto -> source)
-     * - Error events: Always routes back to the source
+     * Processes an incoming event according to the handler's contract specifications. This method
+     * handles the complete lifecycle of event processing including validation, execution, and error
+     * handling, while maintaining detailed telemetry through OpenTelemetry.
      *
-     * Telemetry Integration:
-     * - Creates and manages OpenTelemetry spans for execution tracking
-     * - Propagates trace context through the event chain
-     * - Records execution metrics and error details
+     * The execution follows a careful sequence to ensure reliability:
+     * First, it validates that the event matches the handler's contract type. Then it extracts
+     * and validates the event's schema version, defaulting to the latest version if none is specified.
+     * After validation passes, it executes the version-specific handler function and processes its
+     * output into new events.
      *
-     * Version Resolution:
-     * - Extracts version from event dataschema
-     * - Falls back to latest version if unspecified
-     * - Validates event data against versioned contract schema
+     * The method handles routing through three distinct paths:
+     * - For successful execution, events are routed based on handler output or configuration.
+     *    - The 'to' field in the handler's result (if specified)
+     *    - The 'redirectto' field from the source event (if present)
+     *    - Falls back to the source event's 'source' field
+     * - For violations (mismatched types, invalid data), errors bubble up to the caller
+     * - For runtime errors, system error events are created and sent back to the source
      *
-     * Error Handling:
-     * - Converts all errors to system error events
-     * - Maintains telemetry context for error scenarios
-     * - Ensures proper error event routing
+     * Throughout execution, comprehensive telemetry is maintained through OpenTelemetry spans,
+     * tracking the complete event journey including validation steps, processing time, and any
+     * errors that occur. This enables detailed monitoring and debugging of the event flow.
      *
-     * @param event - The event to process
+     * @param event - The incoming event to process
      * @param opentelemetry - Configuration for OpenTelemetry context inheritance
-     * @returns Promise resolving to array of result events or error event
+     * @returns Promise resolving to an array of output events or error events
+     * @throws `ContractViolation` when input or output event data violates the contract
+     * @throws `ConfigViolation` when event type doesn't match contract type or the
+     *                           contract version expected by the event does not exist
+     *                           in handler configuration
+     * @throws `ExecutionViolation` for explicitly handled runtime errors
      */
     ArvoEventHandler.prototype.execute = function (event_1) {
         return __awaiter(this, arguments, void 0, function (event, opentelemetry) {
@@ -155,39 +192,47 @@ var ArvoEventHandler = /** @class */ (function (_super) {
                     case 0:
                         otelConfig = (0, utils_1.createEventHandlerTelemetryConfig)("ArvoEventHandler<".concat(this.contract.uri, ">"), this.spanOptions, opentelemetry, event);
                         return [4 /*yield*/, arvo_core_1.ArvoOpenTelemetry.getInstance().startActiveSpan(__assign(__assign({}, otelConfig), { fn: function (span) { return __awaiter(_this, void 0, void 0, function () {
-                                    var otelSpanHeaders, parsedDataSchema, handlerContract, inputEventValidation, _handleOutput, outputs, eventFactory_1, result, error_1, eventFactory, result;
-                                    var _a, _b, _c, _d;
-                                    return __generator(this, function (_e) {
-                                        switch (_e.label) {
+                                    var otelSpanHeaders, _i, _a, _b, key, value, parsedDataSchema, handlerContract, inputEventValidation, _handleOutput, outputs, eventFactory_1, result, error_1, eventFactory, result, _c, _d, _e, key, value;
+                                    var _f, _g, _h, _j;
+                                    return __generator(this, function (_k) {
+                                        switch (_k.label) {
                                             case 0:
                                                 otelSpanHeaders = (0, arvo_core_1.currentOpenTelemetryHeaders)();
-                                                _e.label = 1;
+                                                _k.label = 1;
                                             case 1:
-                                                _e.trys.push([1, 3, 4, 5]);
+                                                _k.trys.push([1, 3, 4, 5]);
                                                 span.setStatus({ code: api_1.SpanStatusCode.OK });
-                                                Object.entries(event.otelAttributes).forEach(function (_a) {
-                                                    var key = _a[0], value = _a[1];
-                                                    return span.setAttribute("to_process.0.".concat(key), value);
-                                                });
+                                                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);
+                                                }
                                                 if (this.contract.type !== event.type) {
-                                                    throw new errors_1.ContractViolation("Event type mismatch: Received '".concat(event.type, "', expected '").concat(this.contract.type, "'"));
+                                                    throw new errors_1.ConfigViolation("Event type mismatch: Received '".concat(event.type, "', expected '").concat(this.contract.type, "'"));
                                                 }
                                                 (0, arvo_core_1.logToSpan)({
                                                     level: 'INFO',
                                                     message: "Event type '".concat(event.type, "' validated against contract '").concat(this.contract.uri, "'"),
                                                 });
                                                 parsedDataSchema = arvo_core_1.EventDataschemaUtil.parse(event);
-                                                if ((parsedDataSchema === null || parsedDataSchema === void 0 ? void 0 : parsedDataSchema.uri) &&
-                                                    (parsedDataSchema === null || parsedDataSchema === void 0 ? void 0 : parsedDataSchema.uri) !== this.contract.uri) {
+                                                // If the URI exists but conflicts with the contract's URI
+                                                // Here we are only concerned with the URI bit not the version
+                                                if ((parsedDataSchema === null || parsedDataSchema === void 0 ? void 0 : parsedDataSchema.uri) && (parsedDataSchema === null || parsedDataSchema === void 0 ? void 0 : parsedDataSchema.uri) !== this.contract.uri) {
                                                     throw new errors_1.ContractViolation("Contract URI mismatch: Handler expects '".concat(this.contract.uri, "' but event dataschema specifies '").concat(event.dataschema, "'. Events must reference the same contract URI as their handler."));
                                                 }
+                                                // If the version does not exist then just warn. The latest version will be used in this case
                                                 if (!(parsedDataSchema === null || parsedDataSchema === void 0 ? void 0 : parsedDataSchema.version)) {
                                                     (0, arvo_core_1.logToSpan)({
                                                         level: 'WARNING',
                                                         message: "Version resolution failed for event with dataschema '".concat(event.dataschema, "'. Defaulting to latest version (=").concat(this.contract.version('latest').version, ") of contract (uri=").concat(this.contract.uri, ")"),
                                                     });
                                                 }
-                                                handlerContract = this.contract.version((_a = parsedDataSchema === null || parsedDataSchema === void 0 ? void 0 : parsedDataSchema.version) !== null && _a !== void 0 ? _a : 'latest');
+                                                handlerContract = void 0;
+                                                try {
+                                                    handlerContract = this.contract.version((_f = parsedDataSchema === null || parsedDataSchema === void 0 ? void 0 : parsedDataSchema.version) !== null && _f !== void 0 ? _f : 'latest');
+                                                }
+                                                catch (error) {
+                                                    throw new errors_1.ConfigViolation("Invalid contract version: ".concat(parsedDataSchema === null || parsedDataSchema === void 0 ? void 0 : parsedDataSchema.version, ". Available versions: ").concat(Object.keys(this.contract.versions).join(', ')));
+                                                }
                                                 (0, arvo_core_1.logToSpan)({
                                                     level: 'INFO',
                                                     message: "Processing event with contract version ".concat(handlerContract.version),
@@ -210,7 +255,7 @@ var ArvoEventHandler = /** @class */ (function (_super) {
                                                         span: span,
                                                     })];
                                             case 2:
-                                                _handleOutput = _e.sent();
+                                                _handleOutput = _k.sent();
                                                 if (!_handleOutput)
                                                     return [2 /*return*/, []];
                                                 outputs = [];
@@ -239,7 +284,7 @@ var ArvoEventHandler = /** @class */ (function (_super) {
                                                 });
                                                 return [2 /*return*/, result];
                                             case 3:
-                                                error_1 = _e.sent();
+                                                error_1 = _k.sent();
                                                 (0, arvo_core_1.exceptionToSpan)(error_1);
                                                 span.setStatus({
                                                     code: api_1.SpanStatusCode.ERROR,
@@ -257,14 +302,14 @@ var ArvoEventHandler = /** @class */ (function (_super) {
                                                     to: event.source,
                                                     error: error_1,
                                                     executionunits: this.executionunits,
-                                                    traceparent: (_b = otelSpanHeaders.traceparent) !== null && _b !== void 0 ? _b : undefined,
-                                                    tracestate: (_c = otelSpanHeaders.tracestate) !== null && _c !== void 0 ? _c : undefined,
-                                                    accesscontrol: (_d = event.accesscontrol) !== null && _d !== void 0 ? _d : undefined,
+                                                    traceparent: (_g = otelSpanHeaders.traceparent) !== null && _g !== void 0 ? _g : undefined,
+                                                    tracestate: (_h = otelSpanHeaders.tracestate) !== null && _h !== void 0 ? _h : undefined,
+                                                    accesscontrol: (_j = event.accesscontrol) !== null && _j !== void 0 ? _j : undefined,
                                                 }, {});
-                                                Object.entries(result.otelAttributes).forEach(function (_a) {
-                                                    var key = _a[0], value = _a[1];
-                                                    return span.setAttribute("to_emit.0.".concat(key), value);
-                                                });
+                                                for (_c = 0, _d = Object.entries(result.otelAttributes); _c < _d.length; _c++) {
+                                                    _e = _d[_c], key = _e[0], value = _e[1];
+                                                    span.setAttribute("to_emit.0.".concat(key), value);
+                                                }
                                                 return [2 /*return*/, [result]];
                                             case 4:
                                                 span.end();

package/dist/ArvoEventHandler/types.d.ts

@@ -1,6 +1,6 @@
-import { Span, SpanOptions } from '@opentelemetry/api';
-import { ArvoContract, ArvoEvent, CreateArvoEvent, VersionedArvoContract, ArvoSemanticVersion } from 'arvo-core';
-import { z } from 'zod';
+import type { Span, SpanOptions } from '@opentelemetry/api';
+import type { ArvoContract, ArvoEvent, ArvoSemanticVersion, CreateArvoEvent, VersionedArvoContract } from 'arvo-core';
+import type { z } from 'zod';
 /**
  * Represents the input for an ArvoEvent handler function.
  */

package/dist/ArvoEventRouter/helpers.d.ts

@@ -1,5 +1,5 @@
 import { ArvoEventRouter } from '.';
-import { IArvoEventRouter } from './types';
+import type { IArvoEventRouter } from './types';
 /**
  * Creates a new ArvoEventRouter instance with the provided configuration.
  * Validates source format and ensures unique handlers per event type.

package/dist/ArvoEventRouter/helpers.js

@@ -18,7 +18,5 @@ var _1 = require(".");
  *   executionunits: 10
  * });
  */
-var createArvoEventRouter = function (param) {
-    return new _1.ArvoEventRouter(param);
-};
+var createArvoEventRouter = function (param) { return new _1.ArvoEventRouter(param); };
 exports.createArvoEventRouter = createArvoEventRouter;

package/dist/ArvoEventRouter/index.d.ts

@@ -1,9 +1,9 @@
-import { ArvoContract, ArvoEvent } from 'arvo-core';
-import ArvoEventHandler from '../ArvoEventHandler';
-import { IArvoEventRouter } from './types';
-import { SpanOptions } from '@opentelemetry/api';
+import { type SpanOptions } from '@opentelemetry/api';
+import { type ArvoContract, ArvoEvent } from 'arvo-core';
 import AbstractArvoEventHandler from '../AbstractArvoEventHandler';
-import { ArvoEventHandlerOpenTelemetryOptions } from '../types';
+import type ArvoEventHandler from '../ArvoEventHandler';
+import type { ArvoEventHandlerOpenTelemetryOptions } from '../types';
+import type { IArvoEventRouter } from './types';
 /**
  * ArvoEventRouter manages event routing and execution within the Arvo event system. It directs
  * incoming events to appropriate handlers based on event type while maintaining telemetry

package/dist/ArvoEventRouter/index.js

@@ -66,12 +66,12 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ArvoEventRouter = void 0;
-var arvo_core_1 = require("arvo-core");
-var utils_1 = require("../utils");
 var api_1 = require("@opentelemetry/api");
-var utils_2 = require("./utils");
+var arvo_core_1 = require("arvo-core");
 var AbstractArvoEventHandler_1 = __importDefault(require("../AbstractArvoEventHandler"));
 var errors_1 = require("../errors");
+var utils_1 = require("../utils");
+var utils_2 = require("./utils");
 /**
  * ArvoEventRouter manages event routing and execution within the Arvo event system. It directs
  * incoming events to appropriate handlers based on event type while maintaining telemetry
@@ -162,21 +162,21 @@ var ArvoEventRouter = /** @class */ (function (_super) {
                                     context: api_1.context.active(),
                                 },
                             fn: function (span) { return __awaiter(_this, void 0, void 0, function () {
-                                var otelSpanHeaders, newEvent, results, resultingEvents, error_1;
+                                var otelSpanHeaders, newEvent, _i, _a, _b, key, value, results, resultingEvents, index, _c, _d, _e, key, value, error_1;
                                 var _this = this;
-                                return __generator(this, function (_a) {
-                                    switch (_a.label) {
+                                return __generator(this, function (_f) {
+                                    switch (_f.label) {
                                         case 0:
                                             otelSpanHeaders = (0, arvo_core_1.currentOpenTelemetryHeaders)();
                                             newEvent = (0, utils_2.deleteOtelHeaders)(event);
-                                            _a.label = 1;
+                                            _f.label = 1;
                                         case 1:
-                                            _a.trys.push([1, 3, 4, 5]);
+                                            _f.trys.push([1, 3, 4, 5]);
                                             span.setStatus({ code: api_1.SpanStatusCode.OK });
-                                            Object.entries(event.otelAttributes).forEach(function (_a) {
-                                                var key = _a[0], value = _a[1];
-                                                return span.setAttribute("to_process.0.".concat(key), value);
-                                            });
+                                            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);
+                                            }
                                             (0, arvo_core_1.logToSpan)({
                                                 level: 'INFO',
                                                 message: "Initiating event resolution - Type: ".concat(newEvent.type, ", Source: ").concat(newEvent.source, ", Destination: ").concat(newEvent.to),
@@ -196,7 +196,7 @@ var ArvoEventRouter = /** @class */ (function (_super) {
                                                     inheritFrom: 'CONTEXT',
                                                 })];
                                         case 2:
-                                            results = _a.sent();
+                                            results = _f.sent();
                                             resultingEvents = results.map(function (event) {
                                                 var _a;
                                                 return new arvo_core_1.ArvoEvent({
@@ -220,15 +220,15 @@ var ArvoEventRouter = /** @class */ (function (_super) {
                                                 level: 'INFO',
                                                 message: "Event processing completed successfully - Generated ".concat(resultingEvents.length, " new event(s)"),
                                             });
-                                            resultingEvents.forEach(function (event, index) {
-                                                return Object.entries(event.otelAttributes).forEach(function (_a) {
-                                                    var key = _a[0], value = _a[1];
-                                                    return span.setAttribute("to_emit.".concat(index, ".").concat(key), value);
-                                                });
-                                            });
+                                            for (index = 0; index < resultingEvents.length; index++) {
+                                                for (_c = 0, _d = Object.entries(resultingEvents[index].otelAttributes); _c < _d.length; _c++) {
+                                                    _e = _d[_c], key = _e[0], value = _e[1];
+                                                    span.setAttribute("to_emit.".concat(index, ".").concat(key), value);
+                                                }
+                                            }
                                             return [2 /*return*/, resultingEvents];
                                         case 3:
-                                            error_1 = _a.sent();
+                                            error_1 = _f.sent();
                                             return [2 /*return*/, (0, utils_1.handleArvoEventHandlerCommonError)(error_1, otelSpanHeaders, this.systemErrorSchema.type, this.source, event, this.executionunits, function (param, extensions) { return (0, arvo_core_1.createArvoEvent)(param, extensions); })];
                                         case 4:
                                             span.end();

package/dist/ArvoEventRouter/types.d.ts

@@ -1,6 +1,6 @@
-import { ArvoContract } from 'arvo-core';
-import ArvoEventHandler from '../ArvoEventHandler';
-import { SpanOptions } from '@opentelemetry/api';
+import type { SpanOptions } from '@opentelemetry/api';
+import type { ArvoContract } from 'arvo-core';
+import type ArvoEventHandler from '../ArvoEventHandler';
 /**
  * Interface for defining an Arvo Event Router.
  */

package/dist/MultiArvoEventHandler/helpers.d.ts

@@ -1,5 +1,5 @@
 import MultiArvoEventHandler from '.';
-import { IMultiArvoEventHandler } from './types';
+import type { IMultiArvoEventHandler } from './types';
 /**
  * Creates a MultiArvoEventHandler instance capable of handling multiple event types across different ArvoContracts.
  *

package/dist/MultiArvoEventHandler/helpers.js

@@ -50,5 +50,7 @@ var _1 = __importDefault(require("."));
  * @see {@link IMultiArvoEventHandler} for the full configuration options
  * @see {@link MultiArvoEventHandler} for the handler class implementation
  */
-var createMultiArvoEventHandler = function (param) { return new _1.default(param); };
+var createMultiArvoEventHandler = function (param) {
+    return new _1.default(param);
+};
 exports.createMultiArvoEventHandler = createMultiArvoEventHandler;

package/dist/MultiArvoEventHandler/index.d.ts

@@ -1,8 +1,8 @@
-import { SpanOptions } from '@opentelemetry/api';
-import { ArvoEvent } from 'arvo-core';
-import { IMultiArvoEventHandler, MultiArvoEventHandlerFunction } from './types';
+import { type SpanOptions } from '@opentelemetry/api';
+import { type ArvoEvent } from 'arvo-core';
 import AbstractArvoEventHandler from '../AbstractArvoEventHandler';
-import { ArvoEventHandlerOpenTelemetryOptions } from '../types';
+import type { ArvoEventHandlerOpenTelemetryOptions } from '../types';
+import type { IMultiArvoEventHandler, MultiArvoEventHandlerFunction } from './types';
 /**
  * MultiArvoEventHandler processes multiple event types without being bound to specific contracts.
  * Manages event execution, telemetry tracking, and error handling for diverse event streams.

package/dist/MultiArvoEventHandler/index.js

@@ -67,9 +67,9 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 var api_1 = require("@opentelemetry/api");
 var arvo_core_1 = require("arvo-core");
-var utils_1 = require("../utils");
 var AbstractArvoEventHandler_1 = __importDefault(require("../AbstractArvoEventHandler"));
 var errors_1 = require("../errors");
+var utils_1 = require("../utils");
 /**
  * MultiArvoEventHandler processes multiple event types without being bound to specific contracts.
  * Manages event execution, telemetry tracking, and error handling for diverse event streams.
@@ -123,19 +123,19 @@ var MultiArvoEventHandler = /** @class */ (function (_super) {
                     case 0:
                         otelConfig = (0, utils_1.createEventHandlerTelemetryConfig)('MutliArvoEventHandler', this.spanOptions, opentelemetry, event);
                         return [4 /*yield*/, arvo_core_1.ArvoOpenTelemetry.getInstance().startActiveSpan(__assign(__assign({}, otelConfig), { fn: function (span) { return __awaiter(_this, void 0, void 0, function () {
-                                    var otelSpanHeaders, _handlerOutput, outputs, resultingEvents, error_1;
-                                    return __generator(this, function (_a) {
-                                        switch (_a.label) {
+                                    var otelSpanHeaders, _i, _a, _b, key, value, _handlerOutput, outputs, resultingEvents, error_1;
+                                    return __generator(this, function (_c) {
+                                        switch (_c.label) {
                                             case 0:
                                                 otelSpanHeaders = (0, arvo_core_1.currentOpenTelemetryHeaders)();
-                                                _a.label = 1;
+                                                _c.label = 1;
                                             case 1:
-                                                _a.trys.push([1, 3, 4, 5]);
+                                                _c.trys.push([1, 3, 4, 5]);
                                                 span.setStatus({ code: api_1.SpanStatusCode.OK });
-                                                Object.entries(event.otelAttributes).forEach(function (_a) {
-                                                    var key = _a[0], value = _a[1];
-                                                    return span.setAttribute("to_process.0.".concat(key), value);
-                                                });
+                                                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);
+                                                }
                                                 (0, arvo_core_1.logToSpan)({
                                                     level: 'INFO',
                                                     message: "Initiating event resolution - Type: ".concat(event.type, ", Source: ").concat(event.source, ", Destination: ").concat(event.to),
@@ -149,7 +149,7 @@ var MultiArvoEventHandler = /** @class */ (function (_super) {
                                                         span: span,
                                                     })];
                                             case 2:
-                                                _handlerOutput = _a.sent();
+                                                _handlerOutput = _c.sent();
                                                 if (!_handlerOutput)
                                                     return [2 /*return*/, []];
                                                 outputs = [];
@@ -166,7 +166,7 @@ var MultiArvoEventHandler = /** @class */ (function (_super) {
                                                 });
                                                 return [2 /*return*/, resultingEvents];
                                             case 3:
-                                                error_1 = _a.sent();
+                                                error_1 = _c.sent();
                                                 return [2 /*return*/, (0, utils_1.handleArvoEventHandlerCommonError)(error_1, otelSpanHeaders, "sys.".concat(this.source, ".error"), this.source, event, this.executionunits, function (param, extensions) { return (0, arvo_core_1.createArvoEvent)(param, extensions); })];
                                             case 4:
                                                 span.end();

package/dist/MultiArvoEventHandler/types.d.ts

@@ -1,5 +1,5 @@
-import { Span, SpanOptions } from '@opentelemetry/api';
-import { ArvoEvent, CreateArvoEvent } from 'arvo-core';
+import type { Span, SpanOptions } from '@opentelemetry/api';
+import type { ArvoEvent, CreateArvoEvent } from 'arvo-core';
 /**
  * Represents the input for a Multi ArvoEvent handler function.
  */

package/dist/errors.d.ts

@@ -1,37 +1,38 @@
 import { ViolationError } from 'arvo-core';
 /**
- * Represents violations of service contracts, typically involving invalid inputs,
- * outputs, or state transitions that break expected invariants.
+ * ContractViolation indicates a critical mismatch between services where event data
+ * violates the receiving handler's contract. This represents a serious system issue
+ * where services are out of sync with their contracts. Common causes include:
+ * - Upstream services sending malformed data
+ * - Breaking changes in contracts without proper version management
+ * - Implicit assumptions in handlers not covered by contracts
+ *
+ * Requires explicit handling as it signals potential system-wide contract violations.
  */
 export declare class ContractViolation extends ViolationError<'Contract'> {
     constructor(message: string, metadata?: Record<string, any>);
 }
 /**
- * Represents violations related to system configuration, typically involving
- * missing, invalid, or conflicting configuration requirement by the event
- * being processed.
+ * ConfigViolation indicates system configuration or routing issues where events
+ * are mismatched with their handlers. This occurs separately from contract
+ * violations and represents problems with the system topology itself, such as:
+ * - Events sent to handlers not configured to process them
+ * - Mismatched event types not covered by handler contracts
+ * - Configuration conflicts between services
+ *
+ * Requires explicit resolution as it indicates fundamental routing or setup issues.
  */
 export declare class ConfigViolation extends ViolationError<'Config'> {
     constructor(message: string, metadata?: Record<string, any>);
 }
 /**
- * Represents violations that occur during system execution, typically involving
- * runtime failures that require explicit handling or intervention. This allow
- * the developer to throw an error which must be handled explicity at `.execute`
- * of an Arvo event handler. Otherwise, the the error throw during exection are
- * converted to system error event and require to be handled by the workflow
- * orchestration.
+ * ExecutionViolation represents runtime failures requiring explicit intervention
+ * outside normal error flow. Unlike regular errors that convert to system error
+ * events, these violations demand special handling at the handler's .execute level.
  *
- * @example
- * ```typescript
- * throw new ExecutionViolation(
- *   'API rate limit exceeded',
- *   {
- *     rateLimitRemaining: 0,
- *     resetAfterSeconds: 60
- *   }
- * );
- * ```
+ * Use sparingly - most runtime errors should flow through standard system error
+ * events. Reserve ExecutionViolation for cases requiring custom error handling
+ * logic that can't be managed through normal event patterns.
  */
 export declare class ExecutionViolation extends ViolationError<'Execution'> {
     constructor(message: string, metadata?: Record<string, any>);

package/dist/errors.js

@@ -18,8 +18,14 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.ExecutionViolation = exports.ConfigViolation = exports.ContractViolation = void 0;
 var arvo_core_1 = require("arvo-core");
 /**
- * Represents violations of service contracts, typically involving invalid inputs,
- * outputs, or state transitions that break expected invariants.
+ * ContractViolation indicates a critical mismatch between services where event data
+ * violates the receiving handler's contract. This represents a serious system issue
+ * where services are out of sync with their contracts. Common causes include:
+ * - Upstream services sending malformed data
+ * - Breaking changes in contracts without proper version management
+ * - Implicit assumptions in handlers not covered by contracts
+ *
+ * Requires explicit handling as it signals potential system-wide contract violations.
  */
 var ContractViolation = /** @class */ (function (_super) {
     __extends(ContractViolation, _super);
@@ -34,9 +40,14 @@ var ContractViolation = /** @class */ (function (_super) {
 }(arvo_core_1.ViolationError));
 exports.ContractViolation = ContractViolation;
 /**
- * Represents violations related to system configuration, typically involving
- * missing, invalid, or conflicting configuration requirement by the event
- * being processed.
+ * ConfigViolation indicates system configuration or routing issues where events
+ * are mismatched with their handlers. This occurs separately from contract
+ * violations and represents problems with the system topology itself, such as:
+ * - Events sent to handlers not configured to process them
+ * - Mismatched event types not covered by handler contracts
+ * - Configuration conflicts between services
+ *
+ * Requires explicit resolution as it indicates fundamental routing or setup issues.
  */
 var ConfigViolation = /** @class */ (function (_super) {
     __extends(ConfigViolation, _super);
@@ -51,23 +62,13 @@ var ConfigViolation = /** @class */ (function (_super) {
 }(arvo_core_1.ViolationError));
 exports.ConfigViolation = ConfigViolation;
 /**
- * Represents violations that occur during system execution, typically involving
- * runtime failures that require explicit handling or intervention. This allow
- * the developer to throw an error which must be handled explicity at `.execute`
- * of an Arvo event handler. Otherwise, the the error throw during exection are
- * converted to system error event and require to be handled by the workflow
- * orchestration.
+ * ExecutionViolation represents runtime failures requiring explicit intervention
+ * outside normal error flow. Unlike regular errors that convert to system error
+ * events, these violations demand special handling at the handler's .execute level.
  *
- * @example
- * ```typescript
- * throw new ExecutionViolation(
- *   'API rate limit exceeded',
- *   {
- *     rateLimitRemaining: 0,
- *     resetAfterSeconds: 60
- *   }
- * );
- * ```
+ * Use sparingly - most runtime errors should flow through standard system error
+ * events. Reserve ExecutionViolation for cases requiring custom error handling
+ * logic that can't be managed through normal event patterns.
  */
 var ExecutionViolation = /** @class */ (function (_super) {
     __extends(ExecutionViolation, _super);

package/dist/index.d.ts

@@ -1,15 +1,15 @@
+import AbstractArvoEventHandler from './AbstractArvoEventHandler';
 import ArvoEventHandler from './ArvoEventHandler';
-import { ArvoEventHandlerFunctionInput, ArvoEventHandlerFunctionOutput, ArvoEventHandlerFunction, IArvoEventHandler } from './ArvoEventHandler/types';
 import { createArvoEventHandler } from './ArvoEventHandler/helpers';
-import { PartialExcept, ArvoEventHandlerOpenTelemetryOptions, EventHandlerFactory } from './types';
-import MultiArvoEventHandler from './MultiArvoEventHandler';
-import { MultiArvoEventHandlerFunctionInput, MultiArvoEventHandlerFunctionOutput, MultiArvoEventHandlerFunction, IMultiArvoEventHandler } from './MultiArvoEventHandler/types';
-import { createMultiArvoEventHandler } from './MultiArvoEventHandler/helpers';
-import { isNullOrUndefined, getValueOrDefault, coalesce, coalesceOrDefault } from './utils';
-import { IArvoEventRouter } from './ArvoEventRouter/types';
+import { ArvoEventHandlerFunction, ArvoEventHandlerFunctionInput, ArvoEventHandlerFunctionOutput, IArvoEventHandler } from './ArvoEventHandler/types';
 import { ArvoEventRouter } from './ArvoEventRouter';
 import { createArvoEventRouter } from './ArvoEventRouter/helpers';
-import AbstractArvoEventHandler from './AbstractArvoEventHandler';
+import { IArvoEventRouter } from './ArvoEventRouter/types';
 import { deleteOtelHeaders } from './ArvoEventRouter/utils';
-import { ContractViolation, ConfigViolation, ExecutionViolation } from './errors';
+import MultiArvoEventHandler from './MultiArvoEventHandler';
+import { createMultiArvoEventHandler } from './MultiArvoEventHandler/helpers';
+import { IMultiArvoEventHandler, MultiArvoEventHandlerFunction, MultiArvoEventHandlerFunctionInput, MultiArvoEventHandlerFunctionOutput } from './MultiArvoEventHandler/types';
+import { ConfigViolation, ContractViolation, ExecutionViolation } from './errors';
+import { ArvoEventHandlerOpenTelemetryOptions, EventHandlerFactory, PartialExcept } from './types';
+import { coalesce, coalesceOrDefault, getValueOrDefault, isNullOrUndefined } from './utils';
 export { ArvoEventHandler, createArvoEventHandler, IArvoEventHandler, ArvoEventHandlerFunctionOutput, ArvoEventHandlerFunctionInput, ArvoEventHandlerFunction, PartialExcept, MultiArvoEventHandler, MultiArvoEventHandlerFunctionInput, MultiArvoEventHandlerFunctionOutput, MultiArvoEventHandlerFunction, IMultiArvoEventHandler, createMultiArvoEventHandler, isNullOrUndefined, getValueOrDefault, coalesce, coalesceOrDefault, IArvoEventRouter, ArvoEventRouter, createArvoEventRouter, AbstractArvoEventHandler, deleteOtelHeaders, ArvoEventHandlerOpenTelemetryOptions, EventHandlerFactory, ContractViolation, ConfigViolation, ExecutionViolation, };

package/dist/index.js

@@ -4,28 +4,28 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ExecutionViolation = exports.ConfigViolation = exports.ContractViolation = exports.deleteOtelHeaders = exports.AbstractArvoEventHandler = exports.createArvoEventRouter = exports.ArvoEventRouter = exports.coalesceOrDefault = exports.coalesce = exports.getValueOrDefault = exports.isNullOrUndefined = exports.createMultiArvoEventHandler = exports.MultiArvoEventHandler = exports.createArvoEventHandler = exports.ArvoEventHandler = void 0;
+var AbstractArvoEventHandler_1 = __importDefault(require("./AbstractArvoEventHandler"));
+exports.AbstractArvoEventHandler = AbstractArvoEventHandler_1.default;
 var ArvoEventHandler_1 = __importDefault(require("./ArvoEventHandler"));
 exports.ArvoEventHandler = ArvoEventHandler_1.default;
 var helpers_1 = require("./ArvoEventHandler/helpers");
 Object.defineProperty(exports, "createArvoEventHandler", { enumerable: true, get: function () { return helpers_1.createArvoEventHandler; } });
-var MultiArvoEventHandler_1 = __importDefault(require("./MultiArvoEventHandler"));
-exports.MultiArvoEventHandler = MultiArvoEventHandler_1.default;
-var helpers_2 = require("./MultiArvoEventHandler/helpers");
-Object.defineProperty(exports, "createMultiArvoEventHandler", { enumerable: true, get: function () { return helpers_2.createMultiArvoEventHandler; } });
-var utils_1 = require("./utils");
-Object.defineProperty(exports, "isNullOrUndefined", { enumerable: true, get: function () { return utils_1.isNullOrUndefined; } });
-Object.defineProperty(exports, "getValueOrDefault", { enumerable: true, get: function () { return utils_1.getValueOrDefault; } });
-Object.defineProperty(exports, "coalesce", { enumerable: true, get: function () { return utils_1.coalesce; } });
-Object.defineProperty(exports, "coalesceOrDefault", { enumerable: true, get: function () { return utils_1.coalesceOrDefault; } });
 var ArvoEventRouter_1 = require("./ArvoEventRouter");
 Object.defineProperty(exports, "ArvoEventRouter", { enumerable: true, get: function () { return ArvoEventRouter_1.ArvoEventRouter; } });
-var helpers_3 = require("./ArvoEventRouter/helpers");
-Object.defineProperty(exports, "createArvoEventRouter", { enumerable: true, get: function () { return helpers_3.createArvoEventRouter; } });
-var AbstractArvoEventHandler_1 = __importDefault(require("./AbstractArvoEventHandler"));
-exports.AbstractArvoEventHandler = AbstractArvoEventHandler_1.default;
-var utils_2 = require("./ArvoEventRouter/utils");
-Object.defineProperty(exports, "deleteOtelHeaders", { enumerable: true, get: function () { return utils_2.deleteOtelHeaders; } });
+var helpers_2 = require("./ArvoEventRouter/helpers");
+Object.defineProperty(exports, "createArvoEventRouter", { enumerable: true, get: function () { return helpers_2.createArvoEventRouter; } });
+var utils_1 = require("./ArvoEventRouter/utils");
+Object.defineProperty(exports, "deleteOtelHeaders", { enumerable: true, get: function () { return utils_1.deleteOtelHeaders; } });
+var MultiArvoEventHandler_1 = __importDefault(require("./MultiArvoEventHandler"));
+exports.MultiArvoEventHandler = MultiArvoEventHandler_1.default;
+var helpers_3 = require("./MultiArvoEventHandler/helpers");
+Object.defineProperty(exports, "createMultiArvoEventHandler", { enumerable: true, get: function () { return helpers_3.createMultiArvoEventHandler; } });
 var errors_1 = require("./errors");
-Object.defineProperty(exports, "ContractViolation", { enumerable: true, get: function () { return errors_1.ContractViolation; } });
 Object.defineProperty(exports, "ConfigViolation", { enumerable: true, get: function () { return errors_1.ConfigViolation; } });
+Object.defineProperty(exports, "ContractViolation", { enumerable: true, get: function () { return errors_1.ContractViolation; } });
 Object.defineProperty(exports, "ExecutionViolation", { enumerable: true, get: function () { return errors_1.ExecutionViolation; } });
+var utils_2 = require("./utils");
+Object.defineProperty(exports, "coalesce", { enumerable: true, get: function () { return utils_2.coalesce; } });
+Object.defineProperty(exports, "coalesceOrDefault", { enumerable: true, get: function () { return utils_2.coalesceOrDefault; } });
+Object.defineProperty(exports, "getValueOrDefault", { enumerable: true, get: function () { return utils_2.getValueOrDefault; } });
+Object.defineProperty(exports, "isNullOrUndefined", { enumerable: true, get: function () { return utils_2.isNullOrUndefined; } });

package/dist/types.d.ts

@@ -1,4 +1,4 @@
-import AbstractArvoEventHandler from './AbstractArvoEventHandler';
+import type AbstractArvoEventHandler from './AbstractArvoEventHandler';
 /**
  * Makes properties optional except specified keys
  *

package/dist/utils.d.ts

@@ -1,8 +1,8 @@
-import { ArvoEvent, CreateArvoEvent, OpenTelemetryHeaders } from 'arvo-core';
-import { ArvoEventHandlerFunctionOutput } from './ArvoEventHandler/types';
-import { MultiArvoEventHandlerFunctionOutput } from './MultiArvoEventHandler/types';
-import { SpanOptions } from '@opentelemetry/api';
-import { ArvoEventHandlerOpenTelemetryOptions } from './types';
+import { type SpanOptions } from '@opentelemetry/api';
+import { type ArvoEvent, type CreateArvoEvent, type OpenTelemetryHeaders } from 'arvo-core';
+import type { ArvoEventHandlerFunctionOutput } from './ArvoEventHandler/types';
+import type { MultiArvoEventHandlerFunctionOutput } from './MultiArvoEventHandler/types';
+import type { ArvoEventHandlerOpenTelemetryOptions } from './types';
 /**
  * Checks if the item is null or undefined.
  *

package/dist/utils.js

@@ -28,8 +28,8 @@ exports.getValueOrDefault = getValueOrDefault;
 exports.coalesce = coalesce;
 exports.coalesceOrDefault = coalesceOrDefault;
 exports.isLowerAlphanumeric = isLowerAlphanumeric;
-var arvo_core_1 = require("arvo-core");
 var api_1 = require("@opentelemetry/api");
+var arvo_core_1 = require("arvo-core");
 /**
  * Checks if the item is null or undefined.
  *
@@ -111,11 +111,11 @@ var eventHandlerOutputEventCreator = function (events, otelSpanHeaders, source,
             // prioritise returned 'to', 'redirectto' and then
             // 'source'
             to: coalesceOrDefault([handlerResult.to, originalEvent.redirectto], originalEvent.source), executionunits: coalesce(handlerResult.executionunits, handlerExectionUnits), accesscontrol: (_b = (_a = handlerResult.accesscontrol) !== null && _a !== void 0 ? _a : originalEvent.accesscontrol) !== null && _b !== void 0 ? _b : undefined }), __extensions);
-        Object.entries(result.otelAttributes).forEach(function (_a) {
-            var _b;
-            var key = _a[0], value = _a[1];
-            return (_b = api_1.trace.getActiveSpan()) === null || _b === void 0 ? void 0 : _b.setAttribute("to_emit.".concat(index, ".").concat(key), value);
-        });
+        var activeSpan = api_1.trace.getActiveSpan();
+        for (var _i = 0, _c = Object.entries(result.otelAttributes); _i < _c.length; _i++) {
+            var _d = _c[_i], key = _d[0], value = _d[1];
+            activeSpan === null || activeSpan === void 0 ? void 0 : activeSpan.setAttribute("to_emit.".concat(index, ".").concat(key), value);
+        }
         return result;
     });
 };
@@ -145,11 +145,11 @@ var handleArvoEventHandlerCommonError = function (error, otelSpanHeaders, type,
         },
         accesscontrol: (_e = originalEvent.accesscontrol) !== null && _e !== void 0 ? _e : undefined,
     });
-    Object.entries(result.otelAttributes).forEach(function (_a) {
-        var _b;
-        var key = _a[0], value = _a[1];
-        return (_b = api_1.trace.getActiveSpan()) === null || _b === void 0 ? void 0 : _b.setAttribute("to_emit.0.".concat(key), value);
-    });
+    var activeSpan = api_1.trace.getActiveSpan();
+    for (var _i = 0, _f = Object.entries(result.otelAttributes); _i < _f.length; _i++) {
+        var _g = _f[_i], key = _g[0], value = _g[1];
+        activeSpan === null || activeSpan === void 0 ? void 0 : activeSpan.setAttribute("to_emit.0.".concat(key), value);
+    }
     return [result];
 };
 exports.handleArvoEventHandlerCommonError = handleArvoEventHandlerCommonError;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "arvo-event-handler",
-  "version": "2.2.6",
+  "version": "2.2.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": {
@@ -8,21 +8,15 @@
     "start": "node ./dist/index.js",
     "dev": "ts-node ./src/index.ts",
     "test": "jest --passWithNoTests --runInBand --detectOpenHandles --forceExit",
-    "format": "npx prettier --write .",
+    "lint": "biome check --fix",
+    "format": "biome format --fix",
     "doc": "npx typedoc"
   },
-  "keywords": [
-    "arvo",
-    "event-driven architecture",
-    "xorca",
-    "core",
-    "cloudevent",
-    "opentelemetry",
-    "orchestrator"
-  ],
+  "keywords": ["arvo", "event-driven architecture", "xorca", "core", "cloudevent", "opentelemetry", "orchestrator"],
   "author": "Saad Ahmad <saadkwi12@hotmail.com>",
   "license": "MIT",
   "devDependencies": {
+    "@biomejs/biome": "^1.9.4",
     "@jest/globals": "^29.7.0",
     "@opentelemetry/auto-instrumentations-node": "^0.49.1",
     "@opentelemetry/exporter-metrics-otlp-proto": "^0.52.1",