eve 0.11.4 → 0.11.6

package/dist/src/compiled/@workflow/core/serialization/codec.d.ts

@@ -13,6 +13,7 @@
  * - **json**: Would only support standard JSON types (primitives, arrays,
  *   plain objects). No Date, Map, Set, typed arrays, etc.
  */
+import type { CompressionStats } from './compression.js';
 import type { FormatPrefix } from './types.js';
 /**
  * The serialization mode determines which types are supported and how
@@ -49,6 +50,21 @@ export interface CodecOptions {
      * or other mode-specific type revivers.
      */
     extraRevivers?: Record<string, (value: any) => any>;
+    /**
+     * Whether to gzip-compress the serialized payload (write side only;
+     * reads always handle both compressed and uncompressed data). Must
+     * only be enabled when the target run supports compressed payloads:
+     * run specVersion >= SPEC_VERSION_SUPPORTS_COMPRESSION, and for
+     * cross-deployment writes the target deployment's capabilities (see
+     * `getRunCapabilities` in capabilities.ts). Defaults to `false`.
+     */
+    compression?: boolean;
+    /**
+     * Optional telemetry sink populated by the compression layer with what
+     * it did to the payload (whether it compressed, logical vs stored size).
+     * Used by the dehydrate/hydrate wrappers to emit OTel span attributes.
+     */
+    compressionStats?: CompressionStats;
 }
 export interface Codec {
     /** The 4-character format prefix identifier (e.g. "devl", "cbor", "json") */

package/dist/src/compiled/@workflow/core/serialization/compression.d.ts

@@ -0,0 +1,104 @@
+/**
+ * Composable compression layer for serialized data.
+ *
+ * Wraps/unwraps serialized payloads with a compression codec, using the
+ * format prefix system to mark compressed data (e.g. 'zstd' or 'gzip'
+ * wrapping the inner format: 'zstd' + zstd('devl' + payload)).
+ *
+ * Codec selection (write side): zstd is preferred — it is markedly faster
+ * than gzip at a comparable-or-better ratio (see scripts/README.md), and
+ * compression runs at every step boundary so the write CPU is a per-step
+ * tax. zstd requires `node:zlib` >= 22.15 (Web `CompressionStream` has no
+ * zstd), so on a runtime without it we fall back to gzip via the portable
+ * `CompressionStream`. `WORKFLOW_COMPRESSION_CODEC=gzip` forces the
+ * portable codec.
+ *
+ * Read side: dispatch on the format prefix, so both 'zstd' and 'gzip'
+ * payloads are always decodable regardless of which codec wrote them.
+ * (The browser o11y read path decodes zstd via a registered WASM decoder —
+ * see `serialization-format.ts`; this module's `decompress` is the Node
+ * runtime/replay path and uses `node:zlib`.)
+ *
+ * Layering order with encryption: compression is applied BEFORE
+ * encryption (encr(zstd(devl))) — encrypted bytes are high-entropy and
+ * do not compress, so the reverse order would be a no-op.
+ *
+ * Compression is conditional:
+ * - Payloads smaller than {@link COMPRESSION_MIN_BYTES} are passed
+ *   through unchanged (codec overhead isn't worth it).
+ * - If the compressed result isn't meaningfully smaller than the
+ *   original (see {@link COMPRESSION_MIN_SAVINGS_RATIO}), the original
+ *   is kept. This protects already-compressed binary payloads (images,
+ *   archives, etc.) from wasted CPU and size inflation.
+ */
+/**
+ * Payloads below this size are never compressed. The 4-byte format
+ * prefix + codec header/trailer overhead means small payloads gain
+ * nothing, and tiny ones would grow.
+ */
+export declare const COMPRESSION_MIN_BYTES = 1024;
+/**
+ * Compression must shave off at least this fraction of the payload
+ * size to be kept; otherwise the uncompressed original is stored.
+ * Guards against incompressible (already-compressed / high-entropy)
+ * data paying a permanent decompression tax for a negligible win.
+ */
+export declare const COMPRESSION_MIN_SAVINGS_RATIO = 0.05;
+/** Which codec compressed a payload (or `none` when stored uncompressed). */
+export type CompressionCodec = 'zstd' | 'gzip' | 'none';
+/**
+ * Telemetry sink describing what the compression layer did to a payload.
+ * Populated by {@link compress} (write) and {@link decompress} (read) when
+ * a `stats` object is passed. Sizes are measured at the compression
+ * boundary — i.e. before encryption is layered on the write side and after
+ * decryption on the read side — so they reflect compression's effect, not
+ * the at-rest size (which also includes the `encr` envelope and, on some
+ * backends, base64 expansion).
+ *
+ * Field meanings are identical for both directions:
+ * - `uncompressedBytes`: the logical (devalue-prefixed) payload size.
+ * - `storedBytes`: the size handed to / read from storage (compressed when
+ *   a codec applied, otherwise equal to `uncompressedBytes`).
+ * - `codec`: which codec applied (`none` when stored uncompressed).
+ */
+export interface CompressionStats {
+    /** True once the compression layer ran (i.e. saw binary data). */
+    recorded?: boolean;
+    /** Whether a codec was applied (write) or present (read). */
+    compressed?: boolean;
+    /** Which codec applied / was present. */
+    codec?: CompressionCodec;
+    /** Logical, uncompressed payload size in bytes. */
+    uncompressedBytes?: number;
+    /** Stored (post-compression) payload size in bytes. */
+    storedBytes?: number;
+}
+/**
+ * Compress a format-prefixed payload if compression is enabled for the
+ * target run and the payload is worth compressing.
+ *
+ * @param data - The format-prefixed serialized data (e.g. 'devl' + bytes)
+ * @param enabled - Whether the target run supports compressed payloads
+ *   (run specVersion >= SPEC_VERSION_SUPPORTS_COMPRESSION, and for
+ *   cross-deployment writes, the target deployment's capabilities —
+ *   see `getRunCapabilities` in capabilities.ts). zstd and gzip read
+ *   support co-ship, so a single boolean is sufficient.
+ * @param stats - Optional telemetry sink; populated when `data` is binary.
+ * @returns The compressed data with a codec prefix, or the original data
+ *   when compression is disabled, unavailable, or not worthwhile.
+ */
+export declare function compress(data: Uint8Array | unknown, enabled: boolean, stats?: CompressionStats): Promise<Uint8Array | unknown>;
+/**
+ * Decompress a format-prefixed payload if it's compressed.
+ * Dispatches on the prefix ('zstd' or 'gzip') and inflates the inner
+ * payload (which carries its own format prefix, e.g. 'devl').
+ *
+ * Non-compressed data (including non-binary legacy data) is returned
+ * unchanged, so this is safe to apply unconditionally on read paths.
+ */
+export declare function decompress(data: Uint8Array | unknown, stats?: CompressionStats): Promise<Uint8Array | unknown>;
+/**
+ * Check if data is compressed (has a 'zstd' or 'gzip' format prefix).
+ */
+export declare function isCompressed(data: Uint8Array | unknown): boolean;
+//# sourceMappingURL=compression.d.ts.map

package/dist/src/compiled/@workflow/core/serialization/index.d.ts

@@ -4,15 +4,16 @@
  * Re-exports the mode-specific serialize/deserialize functions and
  * the codec/format/encryption abstractions.
  */
-export type { FormatPrefix, SerializableSpecial, Reducers, Revivers, } from './types.js';
-export { SerializationFormat, isFormatPrefix } from './types.js';
 export type { Codec, SerializationMode } from './codec.js';
 export { devalueCodec } from './codec-devalue.js';
-export { encodeWithFormatPrefix, decodeFormatPrefix, peekFormatPrefix, isEncrypted, } from './format.js';
-export { encrypt, decrypt, type CryptoKey, type EncryptionKeyParam, } from './encryption.js';
-import * as workflow from './workflow.js';
-import * as step from './step.js';
+export { COMPRESSION_MIN_BYTES, type CompressionCodec, type CompressionStats, compress, decompress, isCompressed, } from './compression.js';
+export { type CryptoKey, decrypt, type EncryptionKeyParam, encrypt, } from './encryption.js';
+export { decodeFormatPrefix, encodeWithFormatPrefix, isEncrypted, peekFormatPrefix, } from './format.js';
+export type { FormatPrefix, Reducers, Revivers, SerializableSpecial, } from './types.js';
+export { isFormatPrefix, SerializationFormat } from './types.js';
 import * as client from './client.js';
+import * as step from './step.js';
+import * as workflow from './workflow.js';
 export { workflow, step, client };
 export { revive } from './reducers/common.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/src/compiled/@workflow/core/serialization/types.d.ts

@@ -26,6 +26,10 @@ export declare const SerializationFormat: {
     readonly DEVALUE_V1: FormatPrefix;
     /** Encrypted payload (inner payload has its own format prefix) */
     readonly ENCRYPTED: FormatPrefix;
+    /** Gzip-compressed payload (inner payload has its own format prefix) */
+    readonly GZIP: FormatPrefix;
+    /** Zstandard-compressed payload (inner payload has its own format prefix) */
+    readonly ZSTD: FormatPrefix;
 };
 /**
  * Wire-framing format identifier carried in the serialized

package/dist/src/compiled/@workflow/core/serialization-format.d.ts

@@ -10,6 +10,10 @@ export declare const SerializationFormat: {
     readonly DEVALUE_V1: "devl";
     /** Encrypted payload (inner payload has its own format prefix after decryption) */
     readonly ENCRYPTED: "encr";
+    /** Gzip-compressed payload (inner payload has its own format prefix after decompression) */
+    readonly GZIP: "gzip";
+    /** Zstandard-compressed payload (inner payload has its own format prefix after decompression) */
+    readonly ZSTD: "zstd";
 };
 export type SerializationFormatType = (typeof SerializationFormat)[keyof typeof SerializationFormat];
 /**
@@ -42,6 +46,17 @@ export declare function isExpiredStub(data: unknown): boolean;
  * Browser-safe — does not depend on the full serialization module.
  */
 export declare function isEncryptedData(data: unknown): boolean;
+/**
+ * Check if a binary value has a compression format prefix ('gzip' or 'zstd').
+ * Browser-safe — does not depend on the full serialization module.
+ */
+export declare function isCompressedData(data: unknown): boolean;
+/**
+ * Register a browser zstd decoder (e.g. a WASM-backed one). The web o11y UI
+ * calls this at init so `hydrateDataWithKey` can inflate zstd payloads after
+ * client-side decryption. Node readers use `node:zlib` and ignore this.
+ */
+export declare function registerZstdDecoder(decoder: (payload: Uint8Array) => Promise<Uint8Array>): void;
 /**
  * A map of type name → reviver function, used by devalue's `parse`/`unflatten`.
  * Each environment (runtime, web, CLI) provides its own set.

package/dist/src/compiled/@workflow/core/serialization.d.ts

@@ -1,8 +1,9 @@
 import { type CryptoKey } from './encryption.js';
+import { compress, decompress } from './serialization/compression.js';
 import { decrypt, type EncryptionKeyParam, encrypt } from './serialization/encryption.js';
 import { decodeFormatPrefix, encodeWithFormatPrefix, isEncrypted, peekFormatPrefix } from './serialization/format.js';
 import { type FormatPrefix, isFormatPrefix, SerializationFormat } from './serialization/types.js';
-export { SerializationFormat, type FormatPrefix, isFormatPrefix, encodeWithFormatPrefix, decodeFormatPrefix, peekFormatPrefix, isEncrypted, encrypt, decrypt, type EncryptionKeyParam, };
+export { SerializationFormat, type FormatPrefix, isFormatPrefix, encodeWithFormatPrefix, decodeFormatPrefix, peekFormatPrefix, isEncrypted, encrypt, decrypt, compress, decompress, type EncryptionKeyParam, };
 export type SerializationFormatType = (typeof SerializationFormat)[keyof typeof SerializationFormat];
 /**
  * Detect if a readable stream is a byte stream.
@@ -337,7 +338,7 @@ export declare function maybeDecrypt(data: Uint8Array | unknown, key: CryptoKey
  *   backwards compatibility with older runs.
  * @returns The dehydrated value as binary data (Uint8Array) with format prefix
  */
-export declare function dehydrateWorkflowArguments(value: unknown, runId: string, key: CryptoKey | undefined, ops?: Promise<void>[], global?: Record<string, any>, v1Compat?: boolean, framedByteStreams?: boolean): Promise<Uint8Array | unknown>;
+export declare function dehydrateWorkflowArguments(value: unknown, runId: string, key: CryptoKey | undefined, ops?: Promise<void>[], global?: Record<string, any>, v1Compat?: boolean, framedByteStreams?: boolean, compression?: boolean): Promise<Uint8Array | unknown>;
 /**
  * Called from workflow execution environment to hydrate the workflow
  * arguments from the database at the start of workflow execution.
@@ -346,7 +347,7 @@ export declare function hydrateWorkflowArguments(value: Uint8Array | unknown, _r
 /**
  * Dehydrate workflow return value for storage.
  */
-export declare function dehydrateWorkflowReturnValue(value: unknown, _runId: string, key: CryptoKey | undefined, global?: Record<string, any>, v1Compat?: boolean): Promise<Uint8Array | unknown>;
+export declare function dehydrateWorkflowReturnValue(value: unknown, _runId: string, key: CryptoKey | undefined, global?: Record<string, any>, v1Compat?: boolean, compression?: boolean): Promise<Uint8Array | unknown>;
 /**
  * Called from the client side to hydrate the workflow return value
  * of a completed workflow run.
@@ -356,7 +357,7 @@ export declare function hydrateWorkflowReturnValue(value: Uint8Array | unknown,
  * Called from the workflow handler when a step is being created.
  * Dehydrates values from within the workflow execution environment.
  */
-export declare function dehydrateStepArguments(value: unknown, _runId: string, key: CryptoKey | undefined, global?: Record<string, any>, v1Compat?: boolean): Promise<Uint8Array | unknown>;
+export declare function dehydrateStepArguments(value: unknown, _runId: string, key: CryptoKey | undefined, global?: Record<string, any>, v1Compat?: boolean, compression?: boolean): Promise<Uint8Array | unknown>;
 /**
  * Called from the step handler to hydrate the arguments of a step
  * from the database at the start of the step execution.
@@ -379,7 +380,7 @@ export declare function hydrateStepArguments(value: Uint8Array | unknown, runId:
  *   backwards compatibility with older runs.
  * @returns The dehydrated value as binary data (Uint8Array) with format prefix
  */
-export declare function dehydrateStepReturnValue(value: unknown, runId: string, key: CryptoKey | undefined, ops?: Promise<any>[], global?: Record<string, any>, v1Compat?: boolean, framedByteStreams?: boolean): Promise<Uint8Array | unknown>;
+export declare function dehydrateStepReturnValue(value: unknown, runId: string, key: CryptoKey | undefined, ops?: Promise<any>[], global?: Record<string, any>, v1Compat?: boolean, framedByteStreams?: boolean, compression?: boolean): Promise<Uint8Array | unknown>;
 /**
  * Called from the step handler when a step throws. Dehydrates the thrown
  * value from within the step execution environment into a format that can
@@ -396,7 +397,7 @@ export declare function dehydrateStepReturnValue(value: unknown, runId: string,
  * @param global - Global object for serialization context
  * @returns The dehydrated value as binary data (Uint8Array) with format prefix
  */
-export declare function dehydrateStepError(value: unknown, runId: string, key: CryptoKey | undefined, ops?: Promise<any>[], global?: Record<string, any>): Promise<Uint8Array>;
+export declare function dehydrateStepError(value: unknown, runId: string, key: CryptoKey | undefined, ops?: Promise<any>[], global?: Record<string, any>, compression?: boolean): Promise<Uint8Array>;
 /**
  * Called from the workflow handler when replaying the event log of a
  * `step_failed` or `step_retrying` event. Hydrates the thrown value from
@@ -421,7 +422,7 @@ export declare function hydrateStepError(value: Uint8Array | unknown, _runId: st
  * @param global - Global object for serialization context
  * @returns The dehydrated value as binary data (Uint8Array) with format prefix
  */
-export declare function dehydrateRunError(value: unknown, _runId: string, key: CryptoKey | undefined, global?: Record<string, any>): Promise<Uint8Array>;
+export declare function dehydrateRunError(value: unknown, _runId: string, key: CryptoKey | undefined, global?: Record<string, any>, compression?: boolean): Promise<Uint8Array>;
 /**
  * Called from the client side (or observability tools) to hydrate the run
  * error value of a failed workflow run.

package/dist/src/compiled/@workflow/core/telemetry/semantic-conventions.d.ts

@@ -260,6 +260,30 @@ export declare const QueueExecutionTimeMs: (value: number) => {
 export declare const QueueSerializeTimeMs: (value: number) => {
     [k: string]: number;
 };
+/** Whether this serialize/deserialize was a write or read. */
+export declare const SerializationOperation: (value: "serialize" | "deserialize") => {
+    [k: string]: "serialize" | "deserialize";
+};
+/** Whether a compression codec was applied (write) / present (read). */
+export declare const SerializationCompressed: (value: boolean) => {
+    [k: string]: boolean;
+};
+/** Which compression codec applied / was present (`zstd`, `gzip`, or `none`). */
+export declare const SerializationCodec: (value: "zstd" | "gzip" | "none") => {
+    [k: string]: "zstd" | "gzip" | "none";
+};
+/** Logical (uncompressed, devalue-prefixed) payload size in bytes. */
+export declare const SerializationUncompressedBytes: (value: number) => {
+    [k: string]: number;
+};
+/** Stored (post-compression, pre-encryption) payload size in bytes. */
+export declare const SerializationStoredBytes: (value: number) => {
+    [k: string]: number;
+};
+/** Fraction of bytes saved by compression (0..1); set only when compressed. */
+export declare const SerializationCompressionRatio: (value: number) => {
+    [k: string]: number;
+};
 /** The remote service name for Datadog service maps (Datadog-specific: peer.service) */
 export declare const PeerService: (value: string) => {
     [k: string]: string;

package/dist/src/compiled/@workflow/core/version.d.ts

@@ -1,2 +1,2 @@
-export declare const version = "5.0.0-beta.17";
+export declare const version = "5.0.0-beta.19";
 //# sourceMappingURL=version.d.ts.map

package/dist/src/compiled/@workflow/core/workflow.js

@@ -1 +1 @@
-import{c as e,i as t}from"../../_chunks/workflow/dist-DvHFhSJM.js";import{$n as n,Kt as r,Zt as i,er as a,ir as o,nn as s,nr as c,qt as l,rn as u,t as d,tn as f}from"../../_chunks/workflow/attribute-changes-Db-CKuLh.js";import{t as p}from"../../_chunks/workflow/sleep-BG6X2Bli.js";import{t as m}from"../../_chunks/workflow/run-AA-FTD_U.js";async function h(e,n={}){let r=d(e,n);if(r.length===0)return;let i=n.allowReservedAttributes===!0,a=globalThis[u];if(!a)throw new t("experimental_setAttributes() called outside a workflow runtime context. It must be called from within a workflow body (`use workflow`).");await a(r,i?{allowReservedAttributes:!0}:{})}l(r,m);function g(e){let t=globalThis[f];return t||a(`createHook()`,`https://workflow-sdk.dev/docs/api-reference/workflow/create-hook`,g),t(e)}function _(e){let{respondWith:t,token:n,...r}=e??{};if(n!==void 0)throw Error("`createWebhook()` does not accept a `token` option. Webhook tokens are always randomly generated. Use `createHook()` with `resumeHook()` for deterministic token patterns.");let i;t!==void 0&&(i={respondWith:t});let a=g({...r,metadata:i,isWebhook:!0}),{url:s}=o();return a.url=`${s}/.well-known/workflow/v1/webhook/${encodeURIComponent(a.token)}`,a}function v(){function e(t,n){c(`defineHook().resume()`,`https://workflow-sdk.dev/docs/api-reference/workflow-api/resume-hook`,e)}return{create(e){return g(e)},resume:e}}function y(e={}){let{namespace:t}=e,n=globalThis[s](t);return Object.create(globalThis.WritableStream.prototype,{[i]:{value:n,writable:!1}})}function b(){n(`getStepMetadata()`,`https://workflow-sdk.dev/docs/api-reference/workflow/get-step-metadata`,b)}function x(){c(`resumeHook()`,`https://workflow-sdk.dev/docs/api-reference/workflow-api/resume-hook`,x)}export{t as FatalError,e as RetryableError,g as createHook,_ as createWebhook,v as defineHook,h as experimental_setAttributes,b as getStepMetadata,o as getWorkflowMetadata,y as getWritable,x as resumeHook,p as sleep};
+import{c as e,i as t}from"../../_chunks/workflow/dist-Dxrjttr2.js";import{$n as n,Kt as r,Zt as i,er as a,ir as o,nn as s,nr as c,qt as l,rn as u,t as d,tn as f}from"../../_chunks/workflow/attribute-changes-Bi5DLT8S.js";import{t as p}from"../../_chunks/workflow/sleep-DPjVkRY-.js";import{t as m}from"../../_chunks/workflow/run-XM8dTRAo.js";async function h(e,n={}){let r=d(e,n);if(r.length===0)return;let i=n.allowReservedAttributes===!0,a=globalThis[u];if(!a)throw new t("experimental_setAttributes() called outside a workflow runtime context. It must be called from within a workflow body (`use workflow`).");await a(r,i?{allowReservedAttributes:!0}:{})}l(r,m);function g(e){let t=globalThis[f];return t||a(`createHook()`,`https://workflow-sdk.dev/docs/api-reference/workflow/create-hook`,g),t(e)}function _(e){let{respondWith:t,token:n,...r}=e??{};if(n!==void 0)throw Error("`createWebhook()` does not accept a `token` option. Webhook tokens are always randomly generated. Use `createHook()` with `resumeHook()` for deterministic token patterns.");let i;t!==void 0&&(i={respondWith:t});let a=g({...r,metadata:i,isWebhook:!0}),{url:s}=o();return a.url=`${s}/.well-known/workflow/v1/webhook/${encodeURIComponent(a.token)}`,a}function v(){function e(t,n){c(`defineHook().resume()`,`https://workflow-sdk.dev/docs/api-reference/workflow-api/resume-hook`,e)}return{create(e){return g(e)},resume:e}}function y(e={}){let{namespace:t}=e,n=globalThis[s](t);return Object.create(globalThis.WritableStream.prototype,{[i]:{value:n,writable:!1}})}function b(){n(`getStepMetadata()`,`https://workflow-sdk.dev/docs/api-reference/workflow/get-step-metadata`,b)}function x(){c(`resumeHook()`,`https://workflow-sdk.dev/docs/api-reference/workflow-api/resume-hook`,x)}export{t as FatalError,e as RetryableError,g as createHook,_ as createWebhook,v as defineHook,h as experimental_setAttributes,b as getStepMetadata,o as getWorkflowMetadata,y as getWritable,x as resumeHook,p as sleep};

package/dist/src/compiled/@workflow/errors/index.js

@@ -1 +1 @@
-import{C as e,E as t,S as n,T as r,_ as i,a,b as o,c as s,d as c,f as l,g as u,h as d,i as f,l as p,m,n as h,o as g,p as _,r as v,s as y,t as b,u as x,v as S,w as C,x as w,y as T}from"../../_chunks/workflow/dist-DvHFhSJM.js";export{b as CorruptedEventLogError,h as ERROR_SLUGS,v as EntityConflictError,f as FatalError,a as HookConflictError,g as HookNotFoundError,t as RUN_ERROR_CODES,y as ReplayDivergenceError,s as RetryableError,p as RunExpiredError,x as RunNotSupportedError,c as RuntimeDecryptionError,l as SerializationError,_ as StepNotRegisteredError,m as ThrottleError,d as TooEarlyError,u as VERCEL_403_ERROR_MESSAGE,i as WorkflowBuildError,S as WorkflowError,T as WorkflowNotRegisteredError,o as WorkflowRunCancelledError,w as WorkflowRunFailedError,n as WorkflowRunNotCompletedError,e as WorkflowRunNotFoundError,C as WorkflowRuntimeError,r as WorkflowWorldError};
+import{C as e,E as t,S as n,T as r,_ as i,a,b as o,c as s,d as c,f as l,g as u,h as d,i as f,l as p,m,n as h,o as g,p as _,r as v,s as y,t as b,u as x,v as S,w as C,x as w,y as T}from"../../_chunks/workflow/dist-Dxrjttr2.js";export{b as CorruptedEventLogError,h as ERROR_SLUGS,v as EntityConflictError,f as FatalError,a as HookConflictError,g as HookNotFoundError,t as RUN_ERROR_CODES,y as ReplayDivergenceError,s as RetryableError,p as RunExpiredError,x as RunNotSupportedError,c as RuntimeDecryptionError,l as SerializationError,_ as StepNotRegisteredError,m as ThrottleError,d as TooEarlyError,u as VERCEL_403_ERROR_MESSAGE,i as WorkflowBuildError,S as WorkflowError,T as WorkflowNotRegisteredError,o as WorkflowRunCancelledError,w as WorkflowRunFailedError,n as WorkflowRunNotCompletedError,e as WorkflowRunNotFoundError,C as WorkflowRuntimeError,r as WorkflowWorldError};