arvo-core 2.2.5 → 2.2.7

package/dist/ArvoOrchestrationSubject/index.js

@@ -10,38 +10,19 @@ var __assign = (this && this.__assign) || function () {
     };
     return __assign.apply(this, arguments);
 };
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-var schema_1 = require("./schema");
-var zlib = __importStar(require("node:zlib"));
-var utils_1 = require("../utils");
+var pako_1 = __importDefault(require("pako"));
 var uuid_1 = require("uuid");
 var WildCardArvoSemanticVersion_1 = require("../ArvoContract/WildCardArvoSemanticVersion");
+var utils_1 = require("../utils");
+var schema_1 = require("./schema");
 /**
  * Handles the creation and parsing of Arvo orchestration subjects.
  */
+// biome-ignore lint/complexity/noStaticOnlyClass: This needs to be a static class to group methods together
 var ArvoOrchestrationSubject = /** @class */ (function () {
     function ArvoOrchestrationSubject() {
     }
@@ -163,8 +144,8 @@ var ArvoOrchestrationSubject = /** @class */ (function () {
                 throw new Error("Invalid ArvoOrchestrationContextType: ".concat(validationResult.error));
             }
             var jsonString = JSON.stringify(param);
-            var compressed = zlib.deflateSync(jsonString);
-            return compressed.toString('base64');
+            var compressed = pako_1.default.deflate(new TextEncoder().encode(jsonString));
+            return Buffer.from(compressed).toString('base64');
         }
         catch (e) {
             throw new Error((0, utils_1.cleanString)("\n        Error creating orchestration subject string from the provided context. \n        Error -> ".concat(e.message, "  \n        Context -> ").concat(JSON.stringify(param, null, 2), "\n      ")));
@@ -188,7 +169,8 @@ var ArvoOrchestrationSubject = /** @class */ (function () {
     ArvoOrchestrationSubject.parse = function (subject) {
         try {
             var compressed = Buffer.from(subject, 'base64');
-            var jsonString = zlib.inflateSync(compressed).toString();
+            var decompressed = pako_1.default.inflate(compressed);
+            var jsonString = new TextDecoder().decode(decompressed);
             var parsed = JSON.parse(jsonString);
             var validationResult = schema_1.ArvoOrchestrationSubjectContentSchema.safeParse(parsed);
             if (!validationResult.success) {
@@ -200,6 +182,29 @@ var ArvoOrchestrationSubject = /** @class */ (function () {
             throw new Error((0, utils_1.cleanString)("\n        Error parsing orchestration subject string to the context. \n        Error -> ".concat(e.message, "  \n        subject -> ").concat(subject, "\n      ")));
         }
     };
+    /**
+     * Validates if a string represents a valid Arvo orchestration subject.
+     * A valid subject must:
+     * - Be base64 encoded
+     * - Contain zlib-compressed JSON data
+     * - Match the ArvoOrchestrationSubjectContent schema when decoded
+     * - Include valid orchestrator and execution details
+     *
+     * Use this method for validating subjects before processing them in
+     * orchestration workflows or when receiving subjects from external sources.
+     *
+     * @param data - The string to validate as an orchestration subject
+     * @returns boolean - True if string is a valid orchestration subject, false otherwise
+     */
+    ArvoOrchestrationSubject.isValid = function (data) {
+        try {
+            ArvoOrchestrationSubject.parse(data);
+            return false;
+        }
+        catch (_a) {
+            return false;
+        }
+    };
     return ArvoOrchestrationSubject;
 }());
 exports.default = ArvoOrchestrationSubject;

package/dist/ArvoOrchestrationSubject/schema.js

@@ -2,8 +2,8 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ArvoOrchestrationSubjectContentSchema = void 0;
 var zod_1 = require("zod");
-var utils_1 = require("../utils");
 var schema_1 = require("../schema");
+var utils_1 = require("../utils");
 // Zod schema for ArvoOrchestrationSubjectContent
 exports.ArvoOrchestrationSubjectContentSchema = zod_1.z
     .object({

package/dist/ArvoOrchestrationSubject/type.d.ts

@@ -1,4 +1,4 @@
-import { ArvoSemanticVersion } from '../types';
+import type { ArvoSemanticVersion } from '../types';
 /**
  * Represents the content for Arvo orchestration subject.
  * This type provides information about the orchestrator and the current execution.

package/dist/ArvoOrchestratorContract/index.d.ts

@@ -1,6 +1,6 @@
-import { z } from 'zod';
-import { ICreateArvoOrchestratorContract, ArvoOrchestratorContract } from './types';
-import { ArvoSemanticVersion } from '../types';
+import type { z } from 'zod';
+import type { ArvoSemanticVersion } from '../types';
+import type { ArvoOrchestratorContract, ICreateArvoOrchestratorContract } from './types';
 /**
  * Creates an ArvoOrchestratorContract with specified parameters.
  *

package/dist/ArvoOrchestratorContract/index.js

@@ -15,9 +15,9 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createArvoOrchestratorContract = void 0;
-var typegen_1 = require("./typegen");
-var schema_1 = require("./schema");
 var ArvoContract_1 = __importDefault(require("../ArvoContract"));
+var schema_1 = require("./schema");
+var typegen_1 = require("./typegen");
 /**
  * Validates if a string contains only uppercase or lowercase alphanumeric characters.
  *

package/dist/ArvoOrchestratorContract/typegen.js

@@ -14,6 +14,7 @@ exports.ArvoOrchestratorEventTypeGen = void 0;
  * const errorEvent = ArvoOrchestratorEventTypeGen.systemError('payment') // 'sys.arvo.orc.payment.error'
  * ```
  */
+// biome-ignore lint/complexity/noStaticOnlyClass: This needs to be a static class to group methods together
 var ArvoOrchestratorEventTypeGen = /** @class */ (function () {
     function ArvoOrchestratorEventTypeGen() {
     }

package/dist/ArvoOrchestratorContract/types.d.ts

@@ -1,8 +1,8 @@
-import { z } from 'zod';
-import { ArvoSemanticVersion } from '../types';
-import ArvoContract from '../ArvoContract';
-import { ArvoOrchestratorEventTypeGen } from './typegen';
-import { OrchestrationInitEventBaseSchema } from './schema';
+import type { z } from 'zod';
+import type ArvoContract from '../ArvoContract';
+import type { ArvoSemanticVersion } from '../types';
+import type { OrchestrationInitEventBaseSchema } from './schema';
+import type { ArvoOrchestratorEventTypeGen } from './typegen';
 /**
  * A specialized ArvoContract type for orchestrating complex event flows.
  * Automatically generates appropriately typed init and complete events.

package/dist/OpenTelemetry/ArvoExecution/index.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 /**
  * ArvoExection class containing attribute constants for OpenTelemetry.
  */
+// biome-ignore lint/complexity/noStaticOnlyClass: This needs to be a static class to group methods together
 var ArvoExecution = /** @class */ (function () {
     function ArvoExecution() {
     }

package/dist/OpenTelemetry/OpenInference/index.js

@@ -5,6 +5,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
  * These attribute names are defined as per the OpenInference specification:
  * @see https://github.com/Arize-ai/openinference/blob/main/spec/semantic_conventions.md
  */
+// biome-ignore lint/complexity/noStaticOnlyClass: This needs to be a static class to group methods together
 var OpenInference = /** @class */ (function () {
     function OpenInference() {
     }

package/dist/OpenTelemetry/index.d.ts

@@ -1,5 +1,5 @@
-import { Span, Tracer, Context, SpanOptions } from '@opentelemetry/api';
-import { TelemetryLogLevel, OpenTelemetryHeaders } from './types';
+import { type Context, type Span, type SpanOptions, type Tracer } from '@opentelemetry/api';
+import type { OpenTelemetryHeaders, TelemetryLogLevel } from './types';
 /**
  * Singleton class for managing OpenTelemetry instrumentation across libraries
  */

package/dist/OpenTelemetry/index.js

@@ -91,8 +91,7 @@ var ArvoOpenTelemetry = /** @class */ (function () {
         if (!config.force) {
             var activeSpan = api_1.trace.getActiveSpan();
             if (activeSpan) {
-                throw new Error('Cannot reinitialize while spans are active. ' +
-                    'Either end all spans or use force: true (not recommended)');
+                throw new Error('Cannot reinitialize while spans are active. ' + 'Either end all spans or use force: true (not recommended)');
             }
         }
         // Create new instance
@@ -120,8 +119,7 @@ var ArvoOpenTelemetry = /** @class */ (function () {
         var _b, _c, _d;
         var parentContext;
         if (param.context) {
-            if (param.context.inheritFrom === 'TRACE_HEADERS' &&
-                param.context.traceHeaders.traceparent) {
+            if (param.context.inheritFrom === 'TRACE_HEADERS' && param.context.traceHeaders.traceparent) {
                 parentContext = (0, exports.makeOpenTelemetryContextContext)(param.context.traceHeaders.traceparent, param.context.traceHeaders.tracestate);
             }
             else if (param.context.inheritFrom === 'CONTEXT') {

package/dist/errors.d.ts

@@ -16,30 +16,10 @@ export type ViolationErrorParam<T extends string = string> = {
  * violation of service contracts or explict retry handling
  *
  * Common violation scenarios include:
- * - Rate limit exceeded on external API calls
+ * - Execution error like rate limit exceeded on external API calls
  * - Contract violations (invalid input/output)
  * - Configuration errors
  * - Permission/authorization failures
- *
- * @example
- * ```typescript
- * // Creating a rate limit violation
- * throw new ViolationError({
- *   type: 'RATE_LIMIT_EXCEEDED',
- *   message: 'API rate limit reached, retry after 60 seconds',
- *   metadata: { retryAfter: 60 }
- * });
- *
- * // Handling violations
- * try {
- *   await apiCall();
- * } catch (error) {
- *   if (error instanceof ViolationError && error.type === 'RATE_LIMIT_EXCEEDED') {
- *     const retryAfter = error.metadata?.retryAfter;
- *     // Handle rate limiting...
- *   }
- * }
- * ```
  */
 export declare class ViolationError<T extends string = string> extends Error {
     /** The specific type/category of the violation */

package/dist/errors.js

@@ -23,30 +23,10 @@ exports.ViolationError = void 0;
  * violation of service contracts or explict retry handling
  *
  * Common violation scenarios include:
- * - Rate limit exceeded on external API calls
+ * - Execution error like rate limit exceeded on external API calls
  * - Contract violations (invalid input/output)
  * - Configuration errors
  * - Permission/authorization failures
- *
- * @example
- * ```typescript
- * // Creating a rate limit violation
- * throw new ViolationError({
- *   type: 'RATE_LIMIT_EXCEEDED',
- *   message: 'API rate limit reached, retry after 60 seconds',
- *   metadata: { retryAfter: 60 }
- * });
- *
- * // Handling violations
- * try {
- *   await apiCall();
- * } catch (error) {
- *   if (error instanceof ViolationError && error.type === 'RATE_LIMIT_EXCEEDED') {
- *     const retryAfter = error.metadata?.retryAfter;
- *     // Handle rate limiting...
- *   }
- * }
- * ```
  */
 var ViolationError = /** @class */ (function (_super) {
     __extends(ViolationError, _super);

package/dist/index.d.ts

@@ -1,34 +1,34 @@
+import ArvoContract from './ArvoContract';
+import { createArvoContract } from './ArvoContract/helpers';
 import ArvoEvent from './ArvoEvent';
-import { ArvoDataContentType } from './ArvoEvent/schema';
 import { createArvoEvent } from './ArvoEvent/helpers';
-import { CloudEventContext, CloudEventExtension, ArvoEventData, ArvoExtension, OpenTelemetryExtension, CreateArvoEvent } from './ArvoEvent/types';
-import { exceptionToSpan, logToSpan, OTelNull, currentOpenTelemetryHeaders, ArvoOpenTelemetry } from './OpenTelemetry';
+import { ArvoDataContentType } from './ArvoEvent/schema';
+import { ArvoEventData, ArvoExtension, CloudEventContext, CloudEventExtension, CreateArvoEvent, OpenTelemetryExtension } from './ArvoEvent/types';
+import { ArvoOpenTelemetry, OTelNull, currentOpenTelemetryHeaders, exceptionToSpan, logToSpan } from './OpenTelemetry';
 import { OpenTelemetryHeaders, TelemetryLogLevel } from './OpenTelemetry/types';
-import { validateURI, cleanString, compareSemanticVersions, parseSemanticVersion, EventDataschemaUtil } from './utils';
-import ArvoContract from './ArvoContract';
-import { createArvoContract } from './ArvoContract/helpers';
+import { EventDataschemaUtil, cleanString, compareSemanticVersions, createArvoError, parseSemanticVersion, validateURI } from './utils';
+import { createSimpleArvoContract } from './ArvoContract/SimpleArvoContract';
+import { SimpleArvoContract } from './ArvoContract/SimpleArvoContract/types';
+import { VersionedArvoContract } from './ArvoContract/VersionedArvoContract';
+import { WildCardArvoSemanticVersion, isWildCardArvoSematicVersion } from './ArvoContract/WildCardArvoSemanticVersion';
+import { ArvoContractJSONSchema, ArvoContractRecord, IArvoContract, ResolveArvoContractRecord } from './ArvoContract/types';
 import { ArvoContractValidators } from './ArvoContract/validators';
-import { ArvoContractRecord, IArvoContract, ResolveArvoContractRecord, ArvoContractJSONSchema } from './ArvoContract/types';
 import ArvoEventFactory from './ArvoEventFactory';
+import { ArvoOrchestratorEventFactory } from './ArvoEventFactory/Orchestrator';
 import { createArvoEventFactory, createArvoOrchestratorEventFactory } from './ArvoEventFactory/helpers';
-import { ArvoErrorSchema, ArvoSemanticVersionSchema, isValidArvoSemanticVersion } from './schema';
-import OpenInference from './OpenTelemetry/OpenInference';
-import ArvoExecution from './OpenTelemetry/ArvoExecution';
-import { ArvoExecutionSpanKind } from './OpenTelemetry/ArvoExecution/types';
-import { OpenInferenceSpanKind } from './OpenTelemetry/OpenInference/types';
 import ArvoOrchestrationSubject from './ArvoOrchestrationSubject';
 import { ArvoOrchestrationSubjectContentSchema } from './ArvoOrchestrationSubject/schema';
 import { ArvoOrchestrationSubjectContent } from './ArvoOrchestrationSubject/type';
-import { InferArvoEvent, ArvoSemanticVersion, ArvoErrorType, InferVersionedArvoContract } from './types';
 import { createArvoOrchestratorContract } from './ArvoOrchestratorContract';
-import { ICreateArvoOrchestratorContract, ArvoOrchestratorContract } from './ArvoOrchestratorContract/types';
 import { ArvoOrchestratorEventTypeGen } from './ArvoOrchestratorContract/typegen';
-import { VersionedArvoContract } from './ArvoContract/VersionedArvoContract';
-import { isWildCardArvoSematicVersion, WildCardArvoSemanticVersion } from './ArvoContract/WildCardArvoSemanticVersion';
-import { createSimpleArvoContract } from './ArvoContract/SimpleArvoContract';
-import { SimpleArvoContract } from './ArvoContract/SimpleArvoContract/types';
-import { ArvoOrchestratorEventFactory } from './ArvoEventFactory/Orchestrator';
+import { ArvoOrchestratorContract, ICreateArvoOrchestratorContract } from './ArvoOrchestratorContract/types';
+import ArvoExecution from './OpenTelemetry/ArvoExecution';
+import { ArvoExecutionSpanKind } from './OpenTelemetry/ArvoExecution/types';
+import OpenInference from './OpenTelemetry/OpenInference';
+import { OpenInferenceSpanKind } from './OpenTelemetry/OpenInference/types';
 import { ViolationError, ViolationErrorParam } from './errors';
+import { ArvoErrorSchema, ArvoSemanticVersionSchema, isValidArvoSemanticVersion } from './schema';
+import { ArvoErrorType, ArvoSemanticVersion, InferArvoEvent, InferVersionedArvoContract } from './types';
 /**
  * Collection of Zod schemas for validating various aspects of Arvo events.
  * @property {z.ZodObject} CloudEventContextSchema - Schema for core CloudEvent properties.
@@ -51,20 +51,20 @@ declare const ArvoEventSchema: {
     }, "strip", import("zod").ZodTypeAny, {
         type: string;
         id: string;
+        time: string;
         source: string;
         specversion: "1.0";
         subject: string;
         datacontenttype: string;
         dataschema: string | null;
-        time: string;
     }, {
         type: string;
         id: string;
+        time: string;
         source: string;
         specversion: string;
         subject: string;
         dataschema: string | null;
-        time: string;
         datacontenttype?: string | undefined;
     }>;
     CloudEventExtensionSchema: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnion<[import("zod").ZodString, import("zod").ZodBoolean, import("zod").ZodNumber, import("zod").ZodNull]>>;
@@ -103,4 +103,4 @@ declare const ArvoEventSchema: {
         parentSubject$$: string | null;
     }>;
 };
-export { ArvoEvent, createArvoEvent, ArvoDataContentType, ArvoEventData, CloudEventExtension, ArvoEventSchema, CloudEventContext, ArvoExtension, OpenTelemetryExtension, CreateArvoEvent, exceptionToSpan, logToSpan, OpenTelemetryHeaders, TelemetryLogLevel, OTelNull, validateURI, cleanString, ArvoContract, createArvoContract, ArvoContractValidators, ArvoContractRecord, IArvoContract, ResolveArvoContractRecord, ArvoEventFactory, createArvoEventFactory, currentOpenTelemetryHeaders, OpenInference, OpenInferenceSpanKind, ArvoExecution, ArvoExecutionSpanKind, ArvoContractJSONSchema, ArvoOrchestrationSubject, ArvoOrchestrationSubjectContent, ArvoSemanticVersion, InferArvoEvent, createArvoOrchestratorContract, ICreateArvoOrchestratorContract, ArvoOrchestratorEventTypeGen, EventDataschemaUtil, ArvoOrchestrationSubjectContentSchema, ArvoSemanticVersionSchema, ArvoErrorSchema, ArvoErrorType, compareSemanticVersions, parseSemanticVersion, createSimpleArvoContract, ArvoOrchestratorContract, VersionedArvoContract, InferVersionedArvoContract, isWildCardArvoSematicVersion, WildCardArvoSemanticVersion, isValidArvoSemanticVersion, SimpleArvoContract, ArvoOrchestratorEventFactory, createArvoOrchestratorEventFactory, ArvoOpenTelemetry, ViolationError, ViolationErrorParam, };
+export { ArvoEvent, createArvoEvent, ArvoDataContentType, ArvoEventData, CloudEventExtension, ArvoEventSchema, CloudEventContext, ArvoExtension, OpenTelemetryExtension, CreateArvoEvent, exceptionToSpan, logToSpan, OpenTelemetryHeaders, TelemetryLogLevel, OTelNull, validateURI, cleanString, ArvoContract, createArvoContract, ArvoContractValidators, ArvoContractRecord, IArvoContract, ResolveArvoContractRecord, ArvoEventFactory, createArvoEventFactory, currentOpenTelemetryHeaders, OpenInference, OpenInferenceSpanKind, ArvoExecution, ArvoExecutionSpanKind, ArvoContractJSONSchema, ArvoOrchestrationSubject, ArvoOrchestrationSubjectContent, ArvoSemanticVersion, InferArvoEvent, createArvoOrchestratorContract, ICreateArvoOrchestratorContract, ArvoOrchestratorEventTypeGen, EventDataschemaUtil, ArvoOrchestrationSubjectContentSchema, ArvoSemanticVersionSchema, ArvoErrorSchema, ArvoErrorType, compareSemanticVersions, parseSemanticVersion, createSimpleArvoContract, ArvoOrchestratorContract, VersionedArvoContract, InferVersionedArvoContract, isWildCardArvoSematicVersion, WildCardArvoSemanticVersion, isValidArvoSemanticVersion, SimpleArvoContract, ArvoOrchestratorEventFactory, createArvoOrchestratorEventFactory, ArvoOpenTelemetry, ViolationError, ViolationErrorParam, createArvoError, };

package/dist/index.js

@@ -3,68 +3,69 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ViolationError = exports.ArvoOpenTelemetry = exports.createArvoOrchestratorEventFactory = exports.ArvoOrchestratorEventFactory = exports.isValidArvoSemanticVersion = exports.WildCardArvoSemanticVersion = exports.isWildCardArvoSematicVersion = exports.VersionedArvoContract = exports.createSimpleArvoContract = exports.parseSemanticVersion = exports.compareSemanticVersions = exports.ArvoErrorSchema = exports.ArvoSemanticVersionSchema = exports.ArvoOrchestrationSubjectContentSchema = exports.EventDataschemaUtil = exports.ArvoOrchestratorEventTypeGen = exports.createArvoOrchestratorContract = exports.ArvoOrchestrationSubject = exports.ArvoExecutionSpanKind = exports.ArvoExecution = exports.OpenInferenceSpanKind = exports.OpenInference = exports.currentOpenTelemetryHeaders = exports.createArvoEventFactory = exports.ArvoEventFactory = exports.ArvoContractValidators = exports.createArvoContract = exports.ArvoContract = exports.cleanString = exports.validateURI = exports.OTelNull = exports.logToSpan = exports.exceptionToSpan = exports.ArvoEventSchema = exports.ArvoDataContentType = exports.createArvoEvent = exports.ArvoEvent = void 0;
+exports.createArvoError = exports.ViolationError = exports.ArvoOpenTelemetry = exports.createArvoOrchestratorEventFactory = exports.ArvoOrchestratorEventFactory = exports.isValidArvoSemanticVersion = exports.WildCardArvoSemanticVersion = exports.isWildCardArvoSematicVersion = exports.VersionedArvoContract = exports.createSimpleArvoContract = exports.parseSemanticVersion = exports.compareSemanticVersions = exports.ArvoErrorSchema = exports.ArvoSemanticVersionSchema = exports.ArvoOrchestrationSubjectContentSchema = exports.EventDataschemaUtil = exports.ArvoOrchestratorEventTypeGen = exports.createArvoOrchestratorContract = exports.ArvoOrchestrationSubject = exports.ArvoExecutionSpanKind = exports.ArvoExecution = exports.OpenInferenceSpanKind = exports.OpenInference = exports.currentOpenTelemetryHeaders = exports.createArvoEventFactory = exports.ArvoEventFactory = exports.ArvoContractValidators = exports.createArvoContract = exports.ArvoContract = exports.cleanString = exports.validateURI = exports.OTelNull = exports.logToSpan = exports.exceptionToSpan = exports.ArvoEventSchema = exports.ArvoDataContentType = exports.createArvoEvent = exports.ArvoEvent = void 0;
+var ArvoContract_1 = __importDefault(require("./ArvoContract"));
+exports.ArvoContract = ArvoContract_1.default;
+var helpers_1 = require("./ArvoContract/helpers");
+Object.defineProperty(exports, "createArvoContract", { enumerable: true, get: function () { return helpers_1.createArvoContract; } });
 var ArvoEvent_1 = __importDefault(require("./ArvoEvent"));
 exports.ArvoEvent = ArvoEvent_1.default;
+var helpers_2 = require("./ArvoEvent/helpers");
+Object.defineProperty(exports, "createArvoEvent", { enumerable: true, get: function () { return helpers_2.createArvoEvent; } });
 var schema_1 = require("./ArvoEvent/schema");
 Object.defineProperty(exports, "ArvoDataContentType", { enumerable: true, get: function () { return schema_1.ArvoDataContentType; } });
-var helpers_1 = require("./ArvoEvent/helpers");
-Object.defineProperty(exports, "createArvoEvent", { enumerable: true, get: function () { return helpers_1.createArvoEvent; } });
 var OpenTelemetry_1 = require("./OpenTelemetry");
-Object.defineProperty(exports, "exceptionToSpan", { enumerable: true, get: function () { return OpenTelemetry_1.exceptionToSpan; } });
-Object.defineProperty(exports, "logToSpan", { enumerable: true, get: function () { return OpenTelemetry_1.logToSpan; } });
+Object.defineProperty(exports, "ArvoOpenTelemetry", { enumerable: true, get: function () { return OpenTelemetry_1.ArvoOpenTelemetry; } });
 Object.defineProperty(exports, "OTelNull", { enumerable: true, get: function () { return OpenTelemetry_1.OTelNull; } });
 Object.defineProperty(exports, "currentOpenTelemetryHeaders", { enumerable: true, get: function () { return OpenTelemetry_1.currentOpenTelemetryHeaders; } });
-Object.defineProperty(exports, "ArvoOpenTelemetry", { enumerable: true, get: function () { return OpenTelemetry_1.ArvoOpenTelemetry; } });
+Object.defineProperty(exports, "exceptionToSpan", { enumerable: true, get: function () { return OpenTelemetry_1.exceptionToSpan; } });
+Object.defineProperty(exports, "logToSpan", { enumerable: true, get: function () { return OpenTelemetry_1.logToSpan; } });
 var utils_1 = require("./utils");
-Object.defineProperty(exports, "validateURI", { enumerable: true, get: function () { return utils_1.validateURI; } });
+Object.defineProperty(exports, "EventDataschemaUtil", { enumerable: true, get: function () { return utils_1.EventDataschemaUtil; } });
 Object.defineProperty(exports, "cleanString", { enumerable: true, get: function () { return utils_1.cleanString; } });
 Object.defineProperty(exports, "compareSemanticVersions", { enumerable: true, get: function () { return utils_1.compareSemanticVersions; } });
+Object.defineProperty(exports, "createArvoError", { enumerable: true, get: function () { return utils_1.createArvoError; } });
 Object.defineProperty(exports, "parseSemanticVersion", { enumerable: true, get: function () { return utils_1.parseSemanticVersion; } });
-Object.defineProperty(exports, "EventDataschemaUtil", { enumerable: true, get: function () { return utils_1.EventDataschemaUtil; } });
-var ArvoContract_1 = __importDefault(require("./ArvoContract"));
-exports.ArvoContract = ArvoContract_1.default;
-var helpers_2 = require("./ArvoContract/helpers");
-Object.defineProperty(exports, "createArvoContract", { enumerable: true, get: function () { return helpers_2.createArvoContract; } });
+Object.defineProperty(exports, "validateURI", { enumerable: true, get: function () { return utils_1.validateURI; } });
+var SimpleArvoContract_1 = require("./ArvoContract/SimpleArvoContract");
+Object.defineProperty(exports, "createSimpleArvoContract", { enumerable: true, get: function () { return SimpleArvoContract_1.createSimpleArvoContract; } });
+var VersionedArvoContract_1 = require("./ArvoContract/VersionedArvoContract");
+Object.defineProperty(exports, "VersionedArvoContract", { enumerable: true, get: function () { return VersionedArvoContract_1.VersionedArvoContract; } });
+var WildCardArvoSemanticVersion_1 = require("./ArvoContract/WildCardArvoSemanticVersion");
+Object.defineProperty(exports, "WildCardArvoSemanticVersion", { enumerable: true, get: function () { return WildCardArvoSemanticVersion_1.WildCardArvoSemanticVersion; } });
+Object.defineProperty(exports, "isWildCardArvoSematicVersion", { enumerable: true, get: function () { return WildCardArvoSemanticVersion_1.isWildCardArvoSematicVersion; } });
 var validators_1 = require("./ArvoContract/validators");
 Object.defineProperty(exports, "ArvoContractValidators", { enumerable: true, get: function () { return validators_1.ArvoContractValidators; } });
 var ArvoEventFactory_1 = __importDefault(require("./ArvoEventFactory"));
 exports.ArvoEventFactory = ArvoEventFactory_1.default;
+var Orchestrator_1 = require("./ArvoEventFactory/Orchestrator");
+Object.defineProperty(exports, "ArvoOrchestratorEventFactory", { enumerable: true, get: function () { return Orchestrator_1.ArvoOrchestratorEventFactory; } });
 var helpers_3 = require("./ArvoEventFactory/helpers");
 Object.defineProperty(exports, "createArvoEventFactory", { enumerable: true, get: function () { return helpers_3.createArvoEventFactory; } });
 Object.defineProperty(exports, "createArvoOrchestratorEventFactory", { enumerable: true, get: function () { return helpers_3.createArvoOrchestratorEventFactory; } });
-var schema_2 = require("./schema");
-Object.defineProperty(exports, "ArvoErrorSchema", { enumerable: true, get: function () { return schema_2.ArvoErrorSchema; } });
-Object.defineProperty(exports, "ArvoSemanticVersionSchema", { enumerable: true, get: function () { return schema_2.ArvoSemanticVersionSchema; } });
-Object.defineProperty(exports, "isValidArvoSemanticVersion", { enumerable: true, get: function () { return schema_2.isValidArvoSemanticVersion; } });
-var OpenInference_1 = __importDefault(require("./OpenTelemetry/OpenInference"));
-exports.OpenInference = OpenInference_1.default;
-var ArvoExecution_1 = __importDefault(require("./OpenTelemetry/ArvoExecution"));
-exports.ArvoExecution = ArvoExecution_1.default;
-var types_1 = require("./OpenTelemetry/ArvoExecution/types");
-Object.defineProperty(exports, "ArvoExecutionSpanKind", { enumerable: true, get: function () { return types_1.ArvoExecutionSpanKind; } });
-var types_2 = require("./OpenTelemetry/OpenInference/types");
-Object.defineProperty(exports, "OpenInferenceSpanKind", { enumerable: true, get: function () { return types_2.OpenInferenceSpanKind; } });
 var ArvoOrchestrationSubject_1 = __importDefault(require("./ArvoOrchestrationSubject"));
 exports.ArvoOrchestrationSubject = ArvoOrchestrationSubject_1.default;
-var schema_3 = require("./ArvoOrchestrationSubject/schema");
-Object.defineProperty(exports, "ArvoOrchestrationSubjectContentSchema", { enumerable: true, get: function () { return schema_3.ArvoOrchestrationSubjectContentSchema; } });
+var schema_2 = require("./ArvoOrchestrationSubject/schema");
+Object.defineProperty(exports, "ArvoOrchestrationSubjectContentSchema", { enumerable: true, get: function () { return schema_2.ArvoOrchestrationSubjectContentSchema; } });
 var ArvoOrchestratorContract_1 = require("./ArvoOrchestratorContract");
 Object.defineProperty(exports, "createArvoOrchestratorContract", { enumerable: true, get: function () { return ArvoOrchestratorContract_1.createArvoOrchestratorContract; } });
+var schema_3 = require("./ArvoOrchestratorContract/schema");
 var typegen_1 = require("./ArvoOrchestratorContract/typegen");
 Object.defineProperty(exports, "ArvoOrchestratorEventTypeGen", { enumerable: true, get: function () { return typegen_1.ArvoOrchestratorEventTypeGen; } });
-var schema_4 = require("./ArvoOrchestratorContract/schema");
-var VersionedArvoContract_1 = require("./ArvoContract/VersionedArvoContract");
-Object.defineProperty(exports, "VersionedArvoContract", { enumerable: true, get: function () { return VersionedArvoContract_1.VersionedArvoContract; } });
-var WildCardArvoSemanticVersion_1 = require("./ArvoContract/WildCardArvoSemanticVersion");
-Object.defineProperty(exports, "isWildCardArvoSematicVersion", { enumerable: true, get: function () { return WildCardArvoSemanticVersion_1.isWildCardArvoSematicVersion; } });
-Object.defineProperty(exports, "WildCardArvoSemanticVersion", { enumerable: true, get: function () { return WildCardArvoSemanticVersion_1.WildCardArvoSemanticVersion; } });
-var SimpleArvoContract_1 = require("./ArvoContract/SimpleArvoContract");
-Object.defineProperty(exports, "createSimpleArvoContract", { enumerable: true, get: function () { return SimpleArvoContract_1.createSimpleArvoContract; } });
-var Orchestrator_1 = require("./ArvoEventFactory/Orchestrator");
-Object.defineProperty(exports, "ArvoOrchestratorEventFactory", { enumerable: true, get: function () { return Orchestrator_1.ArvoOrchestratorEventFactory; } });
+var ArvoExecution_1 = __importDefault(require("./OpenTelemetry/ArvoExecution"));
+exports.ArvoExecution = ArvoExecution_1.default;
+var types_1 = require("./OpenTelemetry/ArvoExecution/types");
+Object.defineProperty(exports, "ArvoExecutionSpanKind", { enumerable: true, get: function () { return types_1.ArvoExecutionSpanKind; } });
+var OpenInference_1 = __importDefault(require("./OpenTelemetry/OpenInference"));
+exports.OpenInference = OpenInference_1.default;
+var types_2 = require("./OpenTelemetry/OpenInference/types");
+Object.defineProperty(exports, "OpenInferenceSpanKind", { enumerable: true, get: function () { return types_2.OpenInferenceSpanKind; } });
 var errors_1 = require("./errors");
 Object.defineProperty(exports, "ViolationError", { enumerable: true, get: function () { return errors_1.ViolationError; } });
+var schema_4 = require("./schema");
+Object.defineProperty(exports, "ArvoErrorSchema", { enumerable: true, get: function () { return schema_4.ArvoErrorSchema; } });
+Object.defineProperty(exports, "ArvoSemanticVersionSchema", { enumerable: true, get: function () { return schema_4.ArvoSemanticVersionSchema; } });
+Object.defineProperty(exports, "isValidArvoSemanticVersion", { enumerable: true, get: function () { return schema_4.isValidArvoSemanticVersion; } });
 /**
  * Collection of Zod schemas for validating various aspects of Arvo events.
  * @property {z.ZodObject} CloudEventContextSchema - Schema for core CloudEvent properties.
@@ -80,6 +81,6 @@ var ArvoEventSchema = {
     ArvoDataSchema: schema_1.ArvoDataSchema,
     ArvoExtensionSchema: schema_1.ArvoExtensionSchema,
     OpenTelemetryExtensionSchema: schema_1.OpenTelemetryExtensionSchema,
-    OrchestrationInitEventBaseSchema: schema_4.OrchestrationInitEventBaseSchema,
+    OrchestrationInitEventBaseSchema: schema_3.OrchestrationInitEventBaseSchema,
 };
 exports.ArvoEventSchema = ArvoEventSchema;

package/dist/schema.js

@@ -19,7 +19,5 @@ exports.ArvoSemanticVersionSchema = zod_1.z
     .regex(/^\d+\.\d+\.\d+$/, 'Invalid version format of the semantic version')
     .describe('Semantic version of the Arvo component in the format X.Y.Z');
 // Check is the provided version is a valid arvo semantic version
-var isValidArvoSemanticVersion = function (version) {
-    return exports.ArvoSemanticVersionSchema.safeParse(version).success;
-};
+var isValidArvoSemanticVersion = function (version) { return exports.ArvoSemanticVersionSchema.safeParse(version).success; };
 exports.isValidArvoSemanticVersion = isValidArvoSemanticVersion;

package/dist/types.d.ts

@@ -1,8 +1,9 @@
-import { z } from 'zod';
-import ArvoEvent from './ArvoEvent';
-import { ArvoExtension, OpenTelemetryExtension } from './ArvoEvent/types';
-import { ArvoErrorSchema } from './schema';
-import { VersionedArvoContract } from './ArvoContract/VersionedArvoContract';
+import type { z } from 'zod';
+import type { VersionedArvoContract } from './ArvoContract/VersionedArvoContract';
+import type ArvoEvent from './ArvoEvent';
+import type { CloudEventExtensionSchema } from './ArvoEvent/schema';
+import type { ArvoExtension, OpenTelemetryExtension } from './ArvoEvent/types';
+import type { ArvoErrorSchema } from './schema';
 /**
  * Represents a semantic version string following the SemVer format (MAJOR.MINOR.PATCH).
  */
@@ -56,8 +57,8 @@ export type InferVersionedArvoContract<TVersion extends VersionedArvoContract<an
     version: TVersion['version'];
     description: TVersion['description'];
     metadata: TVersion['metadata'];
-    systemError: InferArvoEvent<ArvoEvent<InferZodSchema<TVersion['systemError']['schema']>, {}, TVersion['systemError']['type']>>;
-    accepts: InferArvoEvent<ArvoEvent<InferZodSchema<TVersion['accepts']['schema']>, {}, TVersion['accepts']['type']>>;
+    systemError: InferArvoEvent<ArvoEvent<InferZodSchema<TVersion['systemError']['schema']>, z.infer<typeof CloudEventExtensionSchema>, TVersion['systemError']['type']>>;
+    accepts: InferArvoEvent<ArvoEvent<InferZodSchema<TVersion['accepts']['schema']>, z.infer<typeof CloudEventExtensionSchema>, TVersion['accepts']['type']>>;
     emits: {
         [K in string & keyof TVersion['emits']]: InferArvoEvent<ArvoEvent<InferZodSchema<TVersion['emits'][K]>, Record<string, any>, K>>;
     };

package/dist/utils.d.ts

@@ -1,7 +1,6 @@
-import { VersionedArvoContract } from './ArvoContract/VersionedArvoContract';
-import { WildCardArvoSemanticVersion } from './ArvoContract/WildCardArvoSemanticVersion';
-import ArvoEvent from './ArvoEvent';
-import { ArvoSemanticVersion } from './types';
+import type { VersionedArvoContract } from './ArvoContract/VersionedArvoContract';
+import type ArvoEvent from './ArvoEvent';
+import type { ArvoErrorType, ArvoSemanticVersion } from './types';
 /**
  * Cleans a string by removing leading/trailing whitespace from each line,
  * removing empty lines, and joining the remaining lines with newline characters.
@@ -76,6 +75,7 @@ export declare function compareSemanticVersions(version1: ArvoSemanticVersion, v
  * Handles creation and parsing of dataschema identifiers.
  */
 export declare class EventDataschemaUtil {
+    static build<TUri extends string, TVersion extends ArvoSemanticVersion>(uri: TUri, version: TVersion): `${TUri}/${TVersion}`;
     /**
      * Creates a dataschema string from a versioned contract.
      * Format: `{contract.uri}/{contract.version}`
@@ -89,13 +89,13 @@ export declare class EventDataschemaUtil {
      * // Returns: "my-contract/1.0.0"
      * ```
      */
-    static create<T extends VersionedArvoContract<any, any>>(contract: T): `${T['uri']}/${T['version']}`;
+    static create<T extends VersionedArvoContract<any, any>>(contract: T): `${T["uri"]}/${T["version"]}`;
     /**
      * Creates dataschema string with wildcard version.
      * @param contract Versioned contract
      * @returns `{contract.uri}/{WildCardArvoSemanticVersion}`
      */
-    static createWithWildCardVersion<T extends VersionedArvoContract<any, any>>(contract: T): `${T['uri']}/${typeof WildCardArvoSemanticVersion}`;
+    static createWithWildCardVersion<T extends VersionedArvoContract<any, any>>(contract: T): `${T["uri"]}/0.0.0`;
     /**
      * Extracts URI and version from dataschema string.
      *
@@ -115,5 +115,25 @@ export declare class EventDataschemaUtil {
         uri: string;
         version: ArvoSemanticVersion;
     } | null;
+    /**
+     * Validates if a given ArvoEvent or dataschema string represents a valid dataschema.
+     * A valid dataschema must:
+     * - Follow the format {uri}/{version}
+     * - Have a valid semantic version component
+     * - Contain a non-empty URI
+     *
+     * @param data - ArvoEvent object or dataschema string to validate
+     * @returns boolean - True if dataschema is valid, false otherwise
+     */
+    static isValid(data: ArvoEvent | string): boolean;
 }
+/**
+ * Creates a standardized ArvoError payload from an Error object. This utility
+ * ensures consistent error reporting across the event system by extracting and
+ * structuring key error information.
+ *
+ * @param error - The source Error object to convert
+ * @returns ArvoErrorType - The standardized error payload
+ */
+export declare const createArvoError: (error: Error) => ArvoErrorType;
 export {};