arvo-event-handler 3.0.14 → 3.0.15

package/dist/ArvoMachine/types.d.ts

@@ -5,13 +5,11 @@ import type { z } from 'zod';
  * Represents an extended context for Arvo XState machines, including additional properties
  * for volatile and internal data.
  *
- * @remarks
  * This type extends the base XState MachineContext with additional properties
  * to provide more flexibility and organization in storing machine-related data.
  *
  * The `$$` suffix in property names is used to indicate special storage objects within the context.
  *
- * @note
  * To avoid runtime errors, it is recommended not to use `arvo$$` object at all in the
  * machine context
  */
@@ -27,12 +25,6 @@ export type ArvoMachineContext = {
  * Represents the parameters for the emitArvoEvent action in ArvoXState.
  * This type defines a subset of properties from the CreateArvoEvent type,
  * specifically tailored for emitting an ArvoEvent within the state machine context.
- *
- * @remarks
- * The EmitArvoEventActionParam type is crucial for maintaining consistency and
- * type safety when emitting events in an ArvoXState machine. It ensures that
- * only relevant properties are included and properly typed.
- * ```
  */
 export type EnqueueArvoEventActionParam<TData extends ArvoEventData = ArvoEventData, TType extends string = string, TExtension extends CloudEventExtension = CloudEventExtension> = {
     /**
@@ -41,107 +33,46 @@ export type EnqueueArvoEventActionParam<TData extends ArvoEventData = ArvoEventD
     id?: CreateArvoEvent<TData, TType>['id'];
     /**
      * The domain configuration for multi-domain event broadcasting.
-     *
-     * When an event is emitted with a `domain` array, Arvo generates a separate ArvoEvent
-     * for each resolved domain value. This enables parallel routing to multiple contexts
-     * such as analytics, auditing, human-in-the-loop systems, or external integrations.
-     *
-     * **Accepted Values:**
-     * - A concrete domain string (e.g. `'audit.orders'`)
-     * - `null` for standard internal routing (no domain)
-     * - A symbolic value from {@link ArvoDomain}.
-     *
-     * **Broadcasting Rules:**
-     * - Each resolved domain in the array creates a separate ArvoEvent instance
-     * - Duplicate resolved domains are automatically removed
-     * - If the field is omitted, Arvo defaults to `[null]`
-     *
-     * **Examples:**
-     * - `['analytics.orders', 'audit.orders']` → Creates two routed events
-     * - `[ArvoDomain.FROM_TRIGGERING_EVENT, 'human.review', null]` → Mirrors source domain, routes to review, and standard consumer
-     * - `[null]` → Emits a single event with no domain routing
-     * - _Omitted_ → Same as `[null]`
      */
     domain?: (string | null)[];
     /**
      * Custom extensions for the CloudEvent.
      * Allows for additional metadata to be attached to the event.
-     *
-     * @remarks
-     * Use this field to include any non-standard attributes that are not
-     * covered by the core CloudEvent specification or Arvo extensions.
      */
     __extensions?: TExtension;
     /**
      * Defines access controls for the event.
      * Can be a UserID, encrypted string, or key-value pairs.
-     *
-     * @remarks
-     * This field is used to implement fine-grained access control on event
-     * consumption. The exact format and interpretation may depend on your
-     * system's access control mechanisms.
      */
     accesscontrol?: string;
     /**
      * The event payload. This payload must be JSON serializable.
-     *
-     * @remarks
-     * The data field contains the event-specific information. Ensure that
-     * the structure of this data conforms to the schema specified in the
-     * `dataschema` field, if provided.
      */
     data: TData;
     /**
      * Identifies the schema that the `data` adheres to.
-     * Must be a valid URI if present.
-     *
-     * @remarks
-     * Use this field to provide a link to the schema definition for the
-     * event data. This helps consumers understand and validate the event structure.
      */
     dataschema?: string;
     /**
      * Indicates alternative recipients or destinations for events.
-     * Must be a valid URI if present.
-     *
-     * @remarks
-     * Use this field to implement event forwarding or to specify secondary
-     * event consumers in addition to the primary one specified in the `to` field.
      */
     redirectto?: string;
     /**
      * Defines the consumer machine of the event. Used for event routing.
      * Must be a valid URI if present. If not available, the `type` field
      * is used as a default.
-     *
-     * @remarks
-     * This field is crucial for directing events to specific services or
-     * components in your system. Ensure the URI is correctly formatted and
-     * recognized by your event routing infrastructure.
      */
     to?: string;
     /**
      * Describes the type of event.
-     * Should be prefixed with a reverse-DNS name.
-     *
-     * @remarks
-     * The event type is a key field for consumers to understand the nature
-     * of the event without inspecting its data. Use a consistent naming convention
-     * to enhance system-wide event comprehension.
      */
     type: TType;
     /**
      * Represents the cost associated with generating the cloudevent.
-     *
-     * @remarks
-     * By default, it uses the actor's executionunits. This field can be used for
-     * resource accounting or billing purposes. Only override this if you have a specific
-     * reason to assign a different cost to this particular event emission.
      */
     executionunits?: number;
 };
 /**
- * @remarks
  * This is an internal type. Copied as it is from the
  * xstate core [here](https://github.com/statelyai/xstate/blob/main/packages/core/src/setup.ts#L26)
  */
@@ -152,7 +83,6 @@ export type ToParameterizedObject<TParameterizedMap extends Record<string, Param
     };
 }>;
 /**
- * @remarks
  * This is an internal type. Copied as it is from the
  * xstate core [here](https://github.com/statelyai/xstate/blob/main/packages/core/src/setup.ts#L43)
  */
@@ -165,10 +95,6 @@ export type ToProvidedActor<TChildrenMap extends Record<string, string>, TActors
 }>;
 /**
  * Infers emittable events from a versioned Arvo contract.
- *
- * @template T - Versioned Arvo contract type
- *
- * @remarks
  * Extracts all possible events that can be emitted by a contract,
  * including system error events.
  */
@@ -177,19 +103,11 @@ export type InferEmittableEventsFromVersionedArvoContract<T extends VersionedArv
 }[keyof InferVersionedArvoContract<T>['emits']] | InferVersionedArvoContract<T>['systemError'];
 /**
  * Extracts the orchestrator type from an event type string.
- *
- * @template T - Event type string
- *
- * @remarks
  * Parses the specific orchestrator type from a fully qualified event type string.
  */
 export type ExtractOrchestratorType<T extends string> = T extends `${typeof ArvoOrchestratorEventTypeGen.prefix}.${infer Type}` ? Type : never;
 /**
  * Infers the complete service contract from a record of versioned Arvo contracts.
- *
- * @template T - Record of versioned Arvo contracts
- *
- * @remarks
  * Generates a comprehensive type definition including both emitted and received events
  * for all services in the contract.
  *

package/dist/ArvoMachine/utils.d.ts

@@ -2,22 +2,7 @@ import type { MachineConfig } from 'xstate';
 /**
  * Detects if an XState machine configuration contains any parallel states.
  * Uses a stack-based approach for efficient traversal of the state hierarchy.
- *
  * @param config - XState machine configuration
  * @returns True if the machine contains at least one parallel state, false otherwise
- *
- * @example
- * const machine = {
- *   states: {
- *     processing: {
- *       type: 'parallel',
- *       states: {
- *         upload: { ... },
- *         scan: { ... }
- *       }
- *     }
- *   }
- * }
- * const hasParallel = detectParallelStates(machine) // Returns true
  */
 export declare const detectParallelStates: (config?: MachineConfig<any, any, any, any, any, any, any, any, any, any, any>) => boolean;

package/dist/ArvoMachine/utils.js

@@ -4,23 +4,8 @@ exports.detectParallelStates = void 0;
 /**
  * Detects if an XState machine configuration contains any parallel states.
  * Uses a stack-based approach for efficient traversal of the state hierarchy.
- *
  * @param config - XState machine configuration
  * @returns True if the machine contains at least one parallel state, false otherwise
- *
- * @example
- * const machine = {
- *   states: {
- *     processing: {
- *       type: 'parallel',
- *       states: {
- *         upload: { ... },
- *         scan: { ... }
- *       }
- *     }
- *   }
- * }
- * const hasParallel = detectParallelStates(machine) // Returns true
  */
 var detectParallelStates = function (config) {
     if (!(config === null || config === void 0 ? void 0 : config.states)) {

package/dist/ArvoOrchestrationUtils/createEmitableEvent.d.ts

@@ -1,18 +1,49 @@
 import type { Span } from '@opentelemetry/api';
 import { type ArvoEvent, type ArvoOrchestratorContract, type ArvoSemanticVersion, type OpenTelemetryHeaders, type VersionedArvoContract } from 'arvo-core';
 import type { EnqueueArvoEventActionParam } from '../ArvoMachine/types';
+/**
+ * Parameters for creating an emittable event from raw event data.
+ */
 export type CreateEmittableEventParams = {
+    /** Raw event parameters from machine execution */
     event: EnqueueArvoEventActionParam;
+    /** OpenTelemetry headers for distributed tracing */
     otelHeaders: OpenTelemetryHeaders;
+    /** Parent orchestration subject for nested workflows */
     orchestrationParentSubject: string | null;
+    /** Event that triggered this emission */
     sourceEvent: ArvoEvent;
+    /** Self contract for orchestrator validation */
     selfContract: VersionedArvoContract<ArvoOrchestratorContract, ArvoSemanticVersion>;
+    /** Service contracts for external event validation */
     serviceContracts: Record<string, VersionedArvoContract<any, any>>;
+    /** ID of the workflow initialization event */
     initEventId: string;
+    /** Domain for event routing */
     domain: string | null;
+    /** Execution units to assign to event */
     executionunits: number;
+    /** Source identifier for the orchestrator */
     source: string;
 };
+/**
+ * Creates a fully-formed emittable event from raw event parameters.
+ *
+ * Transforms machine-emitted event data into valid Arvo events by:
+ * - Validating against appropriate contracts (self or service)
+ * - Resolving domains for routing
+ * - Generating proper subjects for orchestration events
+ * - Adding tracing context and metadata
+ *
+ * Handles three event types differently:
+ * 1. Completion events - routed to workflow initiator with parent subject
+ * 2. Service orchestrator events - creates/extends orchestration subjects
+ * 3. Regular service events - standard external service calls
+ *
+ * @returns Fully-formed Arvo event ready for emission
+ * @throws {ContractViolation} When event data fails schema validation
+ * @throws {ExecutionViolation} When orchestration subject creation fails
+ */
 export declare const createEmittableEvent: ({ event, otelHeaders, orchestrationParentSubject, sourceEvent, selfContract, serviceContracts, initEventId, domain: _domain, executionunits, source, }: CreateEmittableEventParams, span: Span) => ArvoEvent;
 /**
  * Processes raw events into emittable events with domain resolution

package/dist/ArvoOrchestrationUtils/createEmitableEvent.js

@@ -4,6 +4,24 @@ exports.processRawEventsIntoEmittables = exports.createEmittableEvent = void 0;
 var arvo_core_1 = require("arvo-core");
 var ArvoDomain_1 = require("../ArvoDomain");
 var errors_1 = require("../errors");
+/**
+ * Creates a fully-formed emittable event from raw event parameters.
+ *
+ * Transforms machine-emitted event data into valid Arvo events by:
+ * - Validating against appropriate contracts (self or service)
+ * - Resolving domains for routing
+ * - Generating proper subjects for orchestration events
+ * - Adding tracing context and metadata
+ *
+ * Handles three event types differently:
+ * 1. Completion events - routed to workflow initiator with parent subject
+ * 2. Service orchestrator events - creates/extends orchestration subjects
+ * 3. Regular service events - standard external service calls
+ *
+ * @returns Fully-formed Arvo event ready for emission
+ * @throws {ContractViolation} When event data fails schema validation
+ * @throws {ExecutionViolation} When orchestration subject creation fails
+ */
 var createEmittableEvent = function (_a, span) {
     var _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m;
     var event = _a.event, otelHeaders = _a.otelHeaders, orchestrationParentSubject = _a.orchestrationParentSubject, sourceEvent = _a.sourceEvent, selfContract = _a.selfContract, serviceContracts = _a.serviceContracts, initEventId = _a.initEventId, _domain = _a.domain, executionunits = _a.executionunits, source = _a.source;

package/dist/ArvoOrchestrationUtils/error.d.ts

@@ -1,13 +1,28 @@
 import { type ArvoEvent, ViolationError } from 'arvo-core';
+/**
+ * Enumeration of transaction violation causes for state management operations.
+ */
 export declare const TransactionViolationCause: {
+    /** Failed to read from machine memory */
     readonly READ_FAILURE: "READ_MACHINE_MEMORY_FAILURE";
+    /** Failed to acquire lock on machine memory */
     readonly LOCK_FAILURE: "LOCK_MACHINE_MEMORY_FAILURE";
+    /** Failed to write to machine memory */
     readonly WRITE_FAILURE: "WRITE_MACHINE_MEMORY_FAILURE";
+    /** Lock acquisition was denied */
     readonly LOCK_UNACQUIRED: "LOCK_UNACQUIRED";
+    /** Event subject format is invalid */
     readonly INVALID_SUBJECT: "INVALID_SUBJECT";
 };
 export type TransactionViolationCauseType = (typeof TransactionViolationCause)[keyof typeof TransactionViolationCause];
+/**
+ * Error representing failures in orchestrator state transaction operations.
+ *
+ * Indicates issues with lock acquisition, state persistence, or memory access
+ * during orchestration execution. These errors typically trigger retries.
+ */
 export declare class TransactionViolation extends ViolationError<'OrchestratorTransaction'> {
+    /** Specific cause of the transaction failure */
     readonly cause: TransactionViolationCauseType;
     constructor(param: {
         cause: TransactionViolationCauseType;
@@ -15,4 +30,11 @@ export declare class TransactionViolation extends ViolationError<'OrchestratorTr
         initiatingEvent: ArvoEvent;
     });
 }
+/**
+ * Type guard checking if an error is a TransactionViolation.
+ *
+ * @param error - Error to check
+ * @param cause - Optional specific cause to match
+ * @returns True if error is TransactionViolation with optional matching cause
+ */
 export declare const isTransactionViolationError: (error: unknown, cause?: TransactionViolationCauseType) => boolean;

package/dist/ArvoOrchestrationUtils/error.js

@@ -17,13 +17,27 @@ var __extends = (this && this.__extends) || (function () {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.isTransactionViolationError = exports.TransactionViolation = exports.TransactionViolationCause = void 0;
 var arvo_core_1 = require("arvo-core");
+/**
+ * Enumeration of transaction violation causes for state management operations.
+ */
 exports.TransactionViolationCause = {
+    /** Failed to read from machine memory */
     READ_FAILURE: 'READ_MACHINE_MEMORY_FAILURE',
+    /** Failed to acquire lock on machine memory */
     LOCK_FAILURE: 'LOCK_MACHINE_MEMORY_FAILURE',
+    /** Failed to write to machine memory */
     WRITE_FAILURE: 'WRITE_MACHINE_MEMORY_FAILURE',
+    /** Lock acquisition was denied */
     LOCK_UNACQUIRED: 'LOCK_UNACQUIRED',
+    /** Event subject format is invalid */
     INVALID_SUBJECT: 'INVALID_SUBJECT',
 };
+/**
+ * Error representing failures in orchestrator state transaction operations.
+ *
+ * Indicates issues with lock acquisition, state persistence, or memory access
+ * during orchestration execution. These errors typically trigger retries.
+ */
 var TransactionViolation = /** @class */ (function (_super) {
     __extends(TransactionViolation, _super);
     function TransactionViolation(param) {
@@ -40,6 +54,13 @@ var TransactionViolation = /** @class */ (function (_super) {
     return TransactionViolation;
 }(arvo_core_1.ViolationError));
 exports.TransactionViolation = TransactionViolation;
+/**
+ * Type guard checking if an error is a TransactionViolation.
+ *
+ * @param error - Error to check
+ * @param cause - Optional specific cause to match
+ * @returns True if error is TransactionViolation with optional matching cause
+ */
 var isTransactionViolationError = function (error, cause) {
     return ((0, arvo_core_1.isViolationError)(error) &&
         error.type === 'OrchestratorTransaction' &&

package/dist/ArvoOrchestrationUtils/handlerErrors.d.ts

@@ -4,27 +4,55 @@ import type { SyncEventResource } from '../SyncEventResource';
 import type { OrchestrationExecutionMemoryRecord } from './orchestrationExecutionState';
 import { type ArvoOrchestrationHandlerType } from './types';
 /**
- * Parameters for system error event creation
+ * Parameters for creating system error events during orchestration failures.
  */
 export type CreateSystemErrorEventsParams = {
+    /** The error that occurred */
     error: unknown;
+    /** Event that triggered the error */
     event: ArvoEvent;
+    /** OpenTelemetry headers for tracing */
     otelHeaders: OpenTelemetryHeaders;
+    /** Parent orchestration subject if nested */
     orchestrationParentSubject: string | null;
+    /** ID of the initiating event */
     initEventId: string | null;
+    /** Self contract defining error schema */
     selfContract: VersionedArvoContract<ArvoContract, ArvoSemanticVersion>;
+    /** Optional domains for error event routing */
     systemErrorDomain?: (string | null)[];
+    /** Execution units for error events */
     executionunits: number;
+    /** Source identifier */
     source: string;
+    /** Domain for error events */
     domain: string | null;
+    /** Type of handler reporting the error */
     handlerType: ArvoOrchestrationHandlerType;
 };
 /**
- * Creates system error events
+ * Creates standardized system error events for orchestration failures.
+ *
+ * Generates error events that route back to the workflow initiator, preserving
+ * tracing context and orchestration hierarchy. Supports multiple domains for
+ * error distribution.
+ *
+ * @param params - Error event creation parameters
+ * @returns Array of system error events for each configured domain
  */
 export declare const createSystemErrorEvents: ({ error, event, otelHeaders, orchestrationParentSubject: _orchestrationParentSubject, initEventId, selfContract, systemErrorDomain, executionunits, source, domain, handlerType, }: CreateSystemErrorEventsParams & {
     error: Error;
 }) => ArvoEvent[];
+/**
+ * Handles errors during orchestration execution with proper state management.
+ *
+ * Processes errors by determining if they are violations (retriable) or execution
+ * errors (terminal). For execution errors, persists failure state and generates
+ * system error events. For violations, returns the error to be thrown without
+ * state persistence.
+ *
+ * @returns Either the violation error to throw or system error events to emit
+ */
 export declare const handleOrchestrationErrors: (_handlerType: ArvoOrchestrationHandlerType, param: CreateSystemErrorEventsParams & {
     syncEventResource: SyncEventResource<OrchestrationExecutionMemoryRecord<Record<string, any>>>;
 }, span: Span) => Promise<{

package/dist/ArvoOrchestrationUtils/handlerErrors.js

@@ -55,7 +55,14 @@ var errors_1 = require("../errors");
 var utils_1 = require("../utils");
 var types_1 = require("./types");
 /**
- * Creates system error events
+ * Creates standardized system error events for orchestration failures.
+ *
+ * Generates error events that route back to the workflow initiator, preserving
+ * tracing context and orchestration hierarchy. Supports multiple domains for
+ * error distribution.
+ *
+ * @param params - Error event creation parameters
+ * @returns Array of system error events for each configured domain
  */
 var createSystemErrorEvents = function (_a) {
     var _b, _c, _d, _e, _f;
@@ -79,7 +86,7 @@ var createSystemErrorEvents = function (_a) {
             });
         }
     }
-    var domainSets = new Set(systemErrorDomain
+    var domainSets = new Set((systemErrorDomain === null || systemErrorDomain === void 0 ? void 0 : systemErrorDomain.length)
         ? systemErrorDomain.map(function (item) {
             return (0, ArvoDomain_1.resolveEventDomain)({
                 domainToResolve: item,
@@ -119,6 +126,16 @@ var createSystemErrorEvents = function (_a) {
     return result;
 };
 exports.createSystemErrorEvents = createSystemErrorEvents;
+/**
+ * Handles errors during orchestration execution with proper state management.
+ *
+ * Processes errors by determining if they are violations (retriable) or execution
+ * errors (terminal). For execution errors, persists failure state and generates
+ * system error events. For violations, returns the error to be thrown without
+ * state persistence.
+ *
+ * @returns Either the violation error to throw or system error events to emit
+ */
 var handleOrchestrationErrors = function (_handlerType, param, span) { return __awaiter(void 0, void 0, void 0, function () {
     var handlerType, error, errorEvents, _i, _a, _b, errEvtIdx, errEvt, _c, _d, _e, key, value;
     return __generator(this, function (_f) {

package/dist/ArvoOrchestrationUtils/inputValidation.d.ts

@@ -0,0 +1,47 @@
+import type { Span } from '@opentelemetry/api';
+import { type ArvoContract, type ArvoEvent, VersionedArvoContract } from 'arvo-core';
+import type { z } from 'zod';
+/**
+ * Result type for event validation operations.
+ *
+ * Discriminated union representing all possible validation outcomes:
+ * - VALID: Event passed all validation checks
+ * - CONTRACT_UNRESOLVED: No matching contract found for the event
+ * - INVALID: Event dataschema conflicts with contract (URI or version mismatch)
+ * - INVALID_DATA: Event data doesn't match contract schema (Zod validation failure)
+ */
+export type EventValidationResult = {
+    type: 'VALID';
+    contractType: 'self' | 'service';
+} | {
+    type: 'CONTRACT_UNRESOLVED';
+} | {
+    type: 'INVALID';
+    error: Error;
+} | {
+    type: 'INVALID_DATA';
+    error: z.ZodError;
+};
+/**
+ * Configuration for event validation.
+ */
+export type EventValidationConfig = {
+    /** The event to validate */
+    event: ArvoEvent;
+    /** Self contract for initialization event validation */
+    selfContract: VersionedArvoContract<any, any> | ArvoContract;
+    /** Service contracts for response event validation */
+    serviceContracts: Record<string, VersionedArvoContract<any, any>>;
+    /** Optional OpenTelemetry span for logging */
+    span?: Span;
+};
+/**
+ * Validates an event against provided contracts.
+ *
+ * Performs comprehensive validation including:
+ * - Dataschema parsing and resolution
+ * - Contract resolution (self vs service)
+ * - URI and version compatibility checks
+ * - Schema-based data validation
+ */
+export declare function validateInputEvent({ event, selfContract: _selfContract, serviceContracts, span, }: EventValidationConfig): EventValidationResult;

package/dist/ArvoOrchestrationUtils/inputValidation.js

@@ -0,0 +1,120 @@
+"use strict";
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateInputEvent = validateInputEvent;
+var arvo_core_1 = require("arvo-core");
+/**
+ * Validates an event against provided contracts.
+ *
+ * Performs comprehensive validation including:
+ * - Dataschema parsing and resolution
+ * - Contract resolution (self vs service)
+ * - URI and version compatibility checks
+ * - Schema-based data validation
+ */
+function validateInputEvent(_a) {
+    var _b;
+    var event = _a.event, _selfContract = _a.selfContract, serviceContracts = _a.serviceContracts, span = _a.span;
+    var resolvedContract = null;
+    var contractType;
+    var parsedEventDataSchema = arvo_core_1.EventDataschemaUtil.parse(event);
+    if (!parsedEventDataSchema) {
+        var errorMessage = "Event dataschema resolution failed: Unable to parse dataschema='".concat(event.dataschema, "' for event(id='").concat(event.id, "', type='").concat(event.type, "'). This makes the event opaque and does not allow contract resolution");
+        (0, arvo_core_1.logToSpan)({
+            level: 'WARNING',
+            message: errorMessage,
+        }, span);
+        return {
+            type: 'INVALID',
+            error: new Error(errorMessage),
+        };
+    }
+    var selfContract;
+    if (_selfContract instanceof arvo_core_1.VersionedArvoContract) {
+        selfContract = _selfContract;
+    }
+    else {
+        if (!_selfContract.versions[parsedEventDataSchema.version]) {
+            var errorMessage = "Contract resolution failed: No matching contract found for event (id='".concat(event.id, "', type='").concat(event.type, "', dataschema='").concat(event.dataschema, "')");
+            (0, arvo_core_1.logToSpan)({
+                level: 'WARNING',
+                message: errorMessage,
+            }, span);
+            return {
+                type: 'CONTRACT_UNRESOLVED',
+            };
+        }
+        selfContract = _selfContract.version(parsedEventDataSchema.version);
+    }
+    if (event.type === selfContract.accepts.type) {
+        contractType = 'self';
+        resolvedContract = selfContract;
+    }
+    else {
+        contractType = 'service';
+        // Search through service contracts for matching event type
+        for (var _i = 0, _c = Object.values(serviceContracts); _i < _c.length; _i++) {
+            var contract = _c[_i];
+            if (resolvedContract)
+                break;
+            // Check both emitted events and system error
+            for (var _d = 0, _e = __spreadArray(__spreadArray([], contract.emitList, true), [contract.systemError], false); _d < _e.length; _d++) {
+                var emitType = _e[_d];
+                if (resolvedContract)
+                    break;
+                if (event.type === emitType.type) {
+                    resolvedContract = contract;
+                }
+            }
+        }
+    }
+    if (!resolvedContract) {
+        var errorMessage = "Contract resolution failed: No matching contract found for event (id='".concat(event.id, "', type='").concat(event.type, "')");
+        (0, arvo_core_1.logToSpan)({
+            level: 'WARNING',
+            message: errorMessage,
+        }, span);
+        return {
+            type: 'CONTRACT_UNRESOLVED',
+        };
+    }
+    (0, arvo_core_1.logToSpan)({
+        level: 'INFO',
+        message: "Dataschema resolved: ".concat(event.dataschema, " matches contract(uri='").concat(resolvedContract.uri, "', version='").concat(resolvedContract.version, "')"),
+    }, span);
+    if (parsedEventDataSchema.uri !== resolvedContract.uri) {
+        return {
+            type: 'INVALID',
+            error: new Error("Contract URI mismatch: ".concat(contractType, " Contract(uri='").concat(resolvedContract.uri, "', type='").concat(resolvedContract.accepts.type, "') does not match Event(dataschema='").concat(event.dataschema, "', type='").concat(event.type, "')")),
+        };
+    }
+    if (!(0, arvo_core_1.isWildCardArvoSematicVersion)(parsedEventDataSchema.version) &&
+        parsedEventDataSchema.version !== resolvedContract.version) {
+        return {
+            type: 'INVALID',
+            error: new Error("Contract version mismatch: ".concat(contractType, " Contract(version='").concat(resolvedContract.version, "', type='").concat(resolvedContract.accepts.type, "', uri=").concat(resolvedContract.uri, ") does not match Event(dataschema='").concat(event.dataschema, "', type='").concat(event.type, "')")),
+        };
+    }
+    var validationSchema = contractType === 'self'
+        ? resolvedContract.accepts.schema
+        : ((_b = resolvedContract.emits[event.type]) !== null && _b !== void 0 ? _b : resolvedContract.systemError.schema);
+    var validationResult = validationSchema.safeParse(event.data);
+    if (!validationResult.success) {
+        return {
+            type: 'INVALID_DATA',
+            error: validationResult.error,
+        };
+    }
+    return {
+        type: 'VALID',
+        contractType: contractType,
+    };
+}