eve 0.70.0 → 0.70.2

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

@@ -11,5 +11,5 @@
  */
 export type Serializable = string | number | boolean | null | undefined | Serializable[] | {
     [key: string]: Serializable;
-} | ArrayBuffer | bigint | BigInt64Array | BigUint64Array | Date | DOMException | Error | Float32Array | Float64Array | Headers | Int8Array | Int16Array | Int32Array | Map<Serializable, Serializable> | ReadableStream<Uint8Array> | RegExp | Response | Set<Serializable> | URL | URLSearchParams | Uint8Array | Uint8ClampedArray | Uint16Array | Uint32Array | WritableStream<Uint8Array> | AbortController | AbortSignal | ((...args: Serializable[]) => Promise<Serializable>);
+} | ArrayBuffer | bigint | BigInt64Array | BigUint64Array | DataView | Date | DOMException | Error | Float32Array | Float64Array | Headers | Int8Array | Int16Array | Int32Array | Map<Serializable, Serializable> | ReadableStream<Uint8Array> | RegExp | Response | Set<Serializable> | URL | URLSearchParams | Uint8Array | Uint8ClampedArray | Uint16Array | Uint32Array | WritableStream<Uint8Array> | AbortController | AbortSignal | ((...args: Serializable[]) => Promise<Serializable>);
 //# sourceMappingURL=schemas.d.ts.map

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

@@ -47,6 +47,14 @@ export declare const COMPRESSION_MIN_BYTES = 1024;
 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';
+/**
+ * Thrown by {@link decompress} when a payload inflates past the caller's
+ * `maxOutputBytes`, so a small compressed input cannot exhaust memory.
+ */
+export declare class DecompressedSizeLimitError extends Error {
+    readonly maxOutputBytes: number;
+    constructor(maxOutputBytes: number);
+}
 /**
  * Telemetry sink describing what the compression layer did to a payload.
  * Populated by {@link compress} (write) and {@link decompress} (read) when
@@ -88,7 +96,16 @@ export interface CompressionStats {
  * @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>;
+export declare function compress(data: Uint8Array | unknown, enabled: boolean, stats?: CompressionStats, opts?: {
+    /**
+     * Compress off the event loop where the codec supports it (zstd via
+     * the libuv threadpool; gzip is stream-based and already async).
+     * For multi-MB payloads compressed while a response is flushing —
+     * the sync zstd path would block the loop for the whole compression.
+     * Output bytes are identical either way.
+     */
+    preferAsync?: boolean;
+}): Promise<Uint8Array | unknown>;
 /**
  * Decompress a format-prefixed payload if it's compressed.
  * Dispatches on the prefix ('zstd' or 'gzip') and inflates the inner
@@ -97,7 +114,15 @@ export declare function compress(data: Uint8Array | unknown, enabled: boolean, s
  * 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>;
+export declare function decompress(data: Uint8Array | unknown, stats?: CompressionStats, opts?: {
+    /**
+     * Refuse to inflate past this many bytes (throws
+     * {@link DecompressedSizeLimitError}). For payloads from storage that
+     * may be hostile or corrupt, where a small input could otherwise
+     * inflate without bound.
+     */
+    maxOutputBytes?: number;
+}): Promise<Uint8Array | unknown>;
 /**
  * Check if data is compressed (has a 'zstd' or 'gzip' format prefix).
  */

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

@@ -132,6 +132,14 @@ export declare function urlSearchParamsToString(value: URLSearchParams): string;
 /**
  * Iterates a Headers instance through the captured host iterator, so the
  * iterator object, and its `next`, are host-realm.
+ *
+ * Some server runtimes hand out Headers look-alikes: objects that inherit
+ * from `Headers.prototype` and forward every method to a wrapped native
+ * instance (srvx, used by Nitro, does this for incoming request headers).
+ * They carry no native header state, so the host iterator rejects them with
+ * a TypeError on runtimes whose undici keeps that state in private fields
+ * (Node 24+). Those fall back to the object's own iterator, which runs
+ * non-intrinsic code and is recorded as such.
  */
 export declare function headersToEntries(value: Headers): [string, string][];
 /**

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

@@ -62,6 +62,7 @@ export interface SerializableSpecial {
     BigInt: string;
     BigInt64Array: string;
     BigUint64Array: string;
+    DataViewBytes: string;
     Date: string;
     DOMException: {
         message: string;

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

@@ -150,6 +150,7 @@ export declare function getCommonRevivers(global?: Record<string, any>): {
     BigInt?: ((value: string) => any) | undefined;
     BigInt64Array?: ((value: string) => any) | undefined;
     BigUint64Array?: ((value: string) => any) | undefined;
+    DataViewBytes?: ((value: string) => any) | undefined;
     Date?: ((value: string) => any) | undefined;
     DOMException?: ((value: {
         message: string;
@@ -531,6 +532,53 @@ export declare function dehydrateStepError(value: unknown, runId: string, key: P
  * @returns The hydrated thrown value, ready to reject the step promise
  */
 export declare function hydrateStepError(value: Uint8Array | unknown, _runId: string, key: PayloadKey | undefined, global?: Record<string, any>, extraRevivers?: Record<string, (value: any) => any>, prepared?: PreparedReplayPayload): Promise<unknown>;
+/**
+ * Serialize a dynamic run's generated workflow VM code for storage.
+ *
+ * Dynamic workflow code is application source, so it gets the same treatment
+ * as any other run payload: compressed (it is plain text, which compresses
+ * very well), then encrypted with the run's key. At rest it is opaque
+ * ciphertext, which is the point — generated orchestration can name internal
+ * step ids, prompts, and business rules, and observability surfaces must not
+ * read it without going through the decrypt flow.
+ *
+ * The code is a plain string, so it needs none of the reducers the other
+ * payloads go through, but it is still written as real devalue under the
+ * `DEVALUE_V1` prefix: the generic hydrators (`hydrateData` behind the CLI
+ * and the observability UI) trust that prefix and hand the bytes to
+ * devalue's `parse`, which rejects a bare JSON string as invalid input.
+ *
+ * @param code - Generated workflow VM code.
+ * @param key - Encryption key (undefined to skip encryption).
+ * @param compression - Whether the target run may carry compressed payloads.
+ */
+export declare function dehydrateDynamicWorkflowCode(code: string, key: PayloadKey | undefined, compression?: boolean): Promise<Uint8Array>;
+/**
+ * Hydrate a dynamic run's workflow VM code back into source, on the replay
+ * path.
+ *
+ * When the run has key material, or its execution context records that it was
+ * started with encryption, only the symmetric `encr` envelope is accepted.
+ * Plaintext would let anyone who can write the run record supply code, and a
+ * sealed `encp` envelope can be produced by anyone holding the run's public
+ * key, so neither is evidence that the run's own key encrypted it. This gives
+ * confidentiality and narrows who can supply code; it is not an integrity
+ * guarantee against a holder of the run key.
+ *
+ * Without key material (Worlds with no encryption), plaintext is accepted.
+ *
+ * @param value - Stored bytes from the run's `dynamicWorkflowCode`.
+ * @param key - Encryption key (undefined when encryption is disabled).
+ * @param options.encryptionRequired - The run was started with encryption
+ *   (`executionContext.features.encryption`), so plaintext is refused even
+ *   when no key was resolved.
+ * @throws SerializationError when the payload is not `encr` although
+ *   encryption is required, or does not decode to a string: a corrupted or
+ *   foreign payload must not reach the workflow VM as code.
+ */
+export declare function hydrateDynamicWorkflowCode(value: Uint8Array | unknown, key: PayloadKey | undefined, options?: {
+    encryptionRequired?: boolean;
+}): Promise<string>;
 /**
  * Called from the workflow handler when the workflow itself throws.
  * Dehydrates the thrown value from within the workflow execution environment

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

@@ -1 +1 @@
-import{Bn as e,Fn as t,Gn as n,Hn as r,In as i,Mn as a,Nn as o,Pn as s,Rn as c,Un as l,Vn as u,Wn as d,jn as f,zn as p}from"../../_chunks/workflow/logger-D4GJNTk4.js";import{A as m,C as h,D as g,E as _,F as v,I as y,J as b,L as x,M as S,N as C,O as w,P as T,S as E,T as D,_ as O,a as k,b as A,c as j,d as M,f as N,g as P,h as F,i as I,j as L,k as R,l as z,m as B,n as V,o as H,p as U,q as W,r as G,s as K,t as q,u as J,v as Y,w as X,x as Z,y as Q}from"../../_chunks/workflow/serialization-CNIYl1D3.js";export{q as FRAMED_STREAM_MAX_RECONNECTS,V as FRAMED_STREAM_MAX_TOTAL_RECONNECTS,d as SerializationFormat,G as WorkflowServerReadableStream,I as WorkflowServerWritableStream,f as aesKeyOf,k as cancelAbortReaders,W as compress,H as createForwardedWritable,K as createReconnectingFramedStream,e as decodeFormatPrefix,b as decompress,a as decrypt,j as dehydrateRunError,z as dehydrateStepArguments,J as dehydrateStepError,M as dehydrateStepReturnValue,N as dehydrateWorkflowArguments,U as dehydrateWorkflowReturnValue,o as deriveRunPayloadKeys,B as deserializePreparedReplayPayload,F as deserializePreparedStepError,u as encodeWithFormatPrefix,s as encrypt,P as getByteFramingStream,O as getByteUnframingStream,Y as getCommonRevivers,Q as getDeserializeStream,A as getExternalReducers,Z as getExternalRevivers,E as getForwardedWritableEncryptionKey,h as getRunReadableStream,X as getSerializeStream,D as getStreamType,_ as getWorkflowReducers,g as getWorkflowRevivers,w as hydrateRunError,R as hydrateStepArguments,m as hydrateStepError,L as hydrateStepReturnValue,S as hydrateWorkflowArguments,C as hydrateWorkflowReturnValue,r as isEncrypted,n as isFormatPrefix,t as isRunPayloadKeys,i as isSealTarget,T as maybeDecrypt,v as maybeEncrypt,l as peekFormatPrefix,y as prepareReplayPayload,c as runPayloadKeys,p as sealTo,x as tagForwardedWritableTarget};
+import{Bn as e,Fn as t,Gn as n,Hn as r,In as i,Jn as a,Kn as o,Ln as s,Rn as c,Un as l,Wn as u,Yn as d,qn as f,zn as p}from"../../_chunks/workflow/logger-oqfblE3p.js";import{A as m,C as h,D as g,E as _,F as v,I as y,L as b,M as x,N as S,O as C,P as w,R as T,S as E,T as D,X as O,Y as k,_ as A,a as j,b as M,c as N,d as P,f as F,g as I,h as L,i as R,j as z,k as B,l as V,m as H,n as U,o as W,p as G,r as K,s as q,t as J,u as Y,v as X,w as Z,x as Q,y as $,z as ee}from"../../_chunks/workflow/serialization-APSKphN5.js";export{J as FRAMED_STREAM_MAX_RECONNECTS,U as FRAMED_STREAM_MAX_TOTAL_RECONNECTS,a as SerializationFormat,K as WorkflowServerReadableStream,R as WorkflowServerWritableStream,t as aesKeyOf,j as cancelAbortReaders,k as compress,W as createForwardedWritable,q as createReconnectingFramedStream,u as decodeFormatPrefix,O as decompress,i as decrypt,N as dehydrateDynamicWorkflowCode,V as dehydrateRunError,Y as dehydrateStepArguments,P as dehydrateStepError,F as dehydrateStepReturnValue,G as dehydrateWorkflowArguments,H as dehydrateWorkflowReturnValue,s as deriveRunPayloadKeys,L as deserializePreparedReplayPayload,I as deserializePreparedStepError,n as encodeWithFormatPrefix,c as encrypt,A as getByteFramingStream,X as getByteUnframingStream,$ as getCommonRevivers,M as getDeserializeStream,Q as getExternalReducers,E as getExternalRevivers,h as getForwardedWritableEncryptionKey,Z as getRunReadableStream,D as getSerializeStream,_ as getStreamType,g as getWorkflowReducers,C as getWorkflowRevivers,B as hydrateDynamicWorkflowCode,m as hydrateRunError,z as hydrateStepArguments,x as hydrateStepError,S as hydrateStepReturnValue,w as hydrateWorkflowArguments,v as hydrateWorkflowReturnValue,o as isEncrypted,d as isFormatPrefix,p as isRunPayloadKeys,e as isSealTarget,y as maybeDecrypt,b as maybeEncrypt,f as peekFormatPrefix,T as prepareReplayPayload,r as runPayloadKeys,l as sealTo,ee as tagForwardedWritableTarget};

package/dist/src/compiled/@workflow/core/set-error-stack.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Replaces `error.stack` with `stack` when the property allows it.
+ *
+ * Some libraries redefine `stack` on the errors they throw. postgres.js, for
+ * example, uses `Object.defineProperties(err, { stack: { value } })`, which
+ * turns it into a non-writable data property. Assigning to it throws a
+ * `TypeError` in strict mode, and that `TypeError` would replace the user's
+ * error. A non-writable `stack` that is still configurable is redefined; one
+ * that cannot be changed at all keeps its original value.
+ */
+export declare function setErrorStack(error: Error, stack: string): void;
+//# sourceMappingURL=set-error-stack.d.ts.map

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

@@ -64,6 +64,25 @@ export declare const WorkflowEventsCount: (value: number) => {
 export declare const WorkflowExecutionMode: (value: "replay" | "retained") => {
     [k: string]: "replay" | "retained";
 };
+/**
+ * Whether the run executes dynamic workflow code stored with the run rather
+ * than the deployment's workflow bundle.
+ */
+export declare const WorkflowDynamic: (value: boolean) => {
+    [k: string]: boolean;
+};
+/** SHA-256 of a dynamic run's source and step bindings. */
+export declare const WorkflowDynamicSourceHash: (value: string) => {
+    [k: string]: string;
+};
+/** Size in bytes of a dynamic run's serialized workflow code. */
+export declare const WorkflowDynamicCodeBytes: (value: number) => {
+    [k: string]: number;
+};
+/** Whether a dynamic run's code was stored inline or behind a ref. */
+export declare const WorkflowDynamicCodeStorage: (value: "inline" | "ref") => {
+    [k: string]: "inline" | "ref";
+};
 /** Whether the compiled application workflow bundle was cached. */
 export declare const WorkflowBundleCompileCacheHit: (value: boolean) => {
     [k: string]: boolean;
@@ -136,6 +155,34 @@ export declare const QuickJSPendingOpsCount: (value: number) => {
 export declare const QuickJSInlineSteps: (value: number) => {
     [k: string]: number;
 };
+/** Whether this QuickJS invocation restored a persisted VM snapshot */
+export declare const QuickJSSnapshotRestored: (value: boolean) => {
+    [k: string]: boolean;
+};
+/** Events replayed on top of a restored snapshot (the delta after its cursor) */
+export declare const QuickJSSnapshotDeltaEvents: (value: number) => {
+    [k: string]: number;
+};
+/** Time spent loading, verifying and decoding a persisted snapshot */
+export declare const QuickJSSnapshotRestoreMs: (value: number) => {
+    [k: string]: number;
+};
+/** Why a stored snapshot was not restored (the invocation replayed in full) */
+export declare const QuickJSSnapshotFallbackReason: (value: string) => {
+    [k: string]: string;
+};
+/** Time the post-response snapshot save pipeline took */
+export declare const QuickJSSnapshotSaveMs: (value: number) => {
+    [k: string]: number;
+};
+/** Uncompressed size of a saved VM snapshot */
+export declare const QuickJSSnapshotPlaintextBytes: (value: number) => {
+    [k: string]: number;
+};
+/** Stored (compressed, encrypted) size of a saved VM snapshot */
+export declare const QuickJSSnapshotStoredBytes: (value: number) => {
+    [k: string]: number;
+};
 /** Active trace-correlation mode for this invocation (linked or continuous) */
 export declare const WorkflowTraceMode: (value: "linked" | "continuous") => {
     [k: string]: "linked" | "continuous";

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

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

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

@@ -1 +1 @@
-import{d as e,i as t}from"../../_chunks/workflow/dist-CaNNONeg.js";import{i as n}from"../../_chunks/workflow/workflow-routes-CwqB063q.js";import{X as r,Y as i,ft as a,mt as o,pt as s,st as c}from"../../_chunks/workflow/serialization-CNIYl1D3.js";import{c as l,i as u,o as d,r as f,t as p}from"../../_chunks/workflow/attribute-changes-D721NpZv.js";import{t as m}from"../../_chunks/workflow/sleep-DFKgN7UG.js";import{t as h}from"../../_chunks/workflow/run-5DmiMN9b.js";r(i,h);function g(e){let t=globalThis[a];return t||u(`createHook()`,`https://workflow-sdk.dev/docs/api-reference/workflow/create-hook`,g),t(e)}function _(e){let{respondWith:t,token:r,...i}=e??{};if(r!==void 0)throw Error("`createWebhook()` does not accept a `token` option. Webhook tokens are always generated for you. Use `createHook()` with `resumeHook()` for deterministic token patterns.");let a;t!==void 0&&(a={respondWith:t});let o=g({...i,metadata:a,isWebhook:!0}),{url:s}=l();return o.url=n(s,{type:`webhook`,token:o.token}),o}function v(){function e(t,n){d(`defineHook().resume()`,`https://workflow-sdk.dev/docs/api-reference/workflow-api/resume-hook`,e)}return{create(e){return g(e)},resume:e}}async function y(e,n={}){let r=p(e,n);if(r.length===0)return;let i=n.allowReservedAttributes===!0,a=globalThis[o];if(!a)throw new t("setAttributes() called outside a workflow runtime context. It must be called from within a workflow body (`use workflow`).");await a(r,i?{allowReservedAttributes:!0}:{})}function b(e={}){let{namespace:t}=e,n=globalThis[s](t);return Object.create(globalThis.WritableStream.prototype,{[c]:{value:n,writable:!1}})}function x(){f(`getStepMetadata()`,`https://workflow-sdk.dev/docs/api-reference/workflow/get-step-metadata`,x)}function S(){d(`resumeHook()`,`https://workflow-sdk.dev/docs/api-reference/workflow-api/resume-hook`,S)}export{t as FatalError,e as RetryableError,g as createHook,_ as createWebhook,v as defineHook,x as getStepMetadata,l as getWorkflowMetadata,b as getWritable,S as resumeHook,y as setAttributes,m as sleep};
+import{d as e,i as t}from"../../_chunks/workflow/dist-CaNNONeg.js";import{i as n}from"../../_chunks/workflow/workflow-routes-CwqB063q.js";import{Q as r,Z as i,gt as a,ht as o,lt as s,mt as c}from"../../_chunks/workflow/serialization-APSKphN5.js";import{c as l,i as u,o as d,r as f,t as p}from"../../_chunks/workflow/attribute-changes-VaTKT4K8.js";import{t as m}from"../../_chunks/workflow/sleep-Ba8SExMt.js";import{t as h}from"../../_chunks/workflow/run-DYKeqbob.js";r(i,h);function g(e){let t=globalThis[c];return t||u(`createHook()`,`https://workflow-sdk.dev/docs/api-reference/workflow/create-hook`,g),t(e)}function _(e){let{respondWith:t,token:r,...i}=e??{};if(r!==void 0)throw Error("`createWebhook()` does not accept a `token` option. Webhook tokens are always generated for you. Use `createHook()` with `resumeHook()` for deterministic token patterns.");let a;t!==void 0&&(a={respondWith:t});let o=g({...i,metadata:a,isWebhook:!0}),{url:s}=l();return o.url=n(s,{type:`webhook`,token:o.token}),o}function v(){function e(t,n){d(`defineHook().resume()`,`https://workflow-sdk.dev/docs/api-reference/workflow-api/resume-hook`,e)}return{create(e){return g(e)},resume:e}}async function y(e,n={}){let r=p(e,n);if(r.length===0)return;let i=n.allowReservedAttributes===!0,o=globalThis[a];if(!o)throw new t("setAttributes() called outside a workflow runtime context. It must be called from within a workflow body (`use workflow`).");await o(r,i?{allowReservedAttributes:!0}:{})}function b(e={}){let{namespace:t}=e,n=globalThis[o](t);return Object.create(globalThis.WritableStream.prototype,{[s]:{value:n,writable:!1}})}function x(){f(`getStepMetadata()`,`https://workflow-sdk.dev/docs/api-reference/workflow/get-step-metadata`,x)}function S(){d(`resumeHook()`,`https://workflow-sdk.dev/docs/api-reference/workflow-api/resume-hook`,S)}export{t as FatalError,e as RetryableError,g as createHook,_ as createWebhook,v as defineHook,x as getStepMetadata,l as getWorkflowMetadata,b as getWritable,S as resumeHook,y as setAttributes,m as sleep};

package/dist/src/compiled/@workflow/world/events.d.ts

@@ -187,6 +187,8 @@ declare const RunCreatedEventSchema: z.ZodObject<{
         executionContext: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
         attributes: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
         allowReservedAttributes: z.ZodOptional<z.ZodLiteral<true>>;
+        dynamicWorkflowCode: z.ZodOptional<z.ZodUnion<readonly [z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>]>>;
+        dynamicWorkflowCodeRef: z.ZodOptional<z.ZodString>;
         encryptionPublicKey: z.ZodOptional<z.ZodString>;
     }, z.core.$strip>;
 }, z.core.$strip>;
@@ -201,6 +203,8 @@ export declare const CreateEventSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
         executionContext: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
         attributes: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
         allowReservedAttributes: z.ZodOptional<z.ZodLiteral<true>>;
+        dynamicWorkflowCode: z.ZodOptional<z.ZodUnion<readonly [z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>]>>;
+        dynamicWorkflowCodeRef: z.ZodOptional<z.ZodString>;
         encryptionPublicKey: z.ZodOptional<z.ZodString>;
     }, z.core.$strip>;
 }, z.core.$strip>, z.ZodObject<{
@@ -215,6 +219,8 @@ export declare const CreateEventSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
         attributes: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
         allowReservedAttributes: z.ZodOptional<z.ZodLiteral<true>>;
         encryptionPublicKey: z.ZodOptional<z.ZodString>;
+        dynamicWorkflowCode: z.ZodOptional<z.ZodUnion<readonly [z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>]>>;
+        dynamicWorkflowCodeRef: z.ZodOptional<z.ZodString>;
     }, z.core.$strip>>;
 }, z.core.$strip>, z.ZodObject<{
     correlationId: z.ZodOptional<z.ZodString>;
@@ -380,6 +386,8 @@ export declare const EventSchema: z.ZodIntersection<z.ZodDiscriminatedUnion<[z.Z
         executionContext: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
         attributes: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
         allowReservedAttributes: z.ZodOptional<z.ZodLiteral<true>>;
+        dynamicWorkflowCode: z.ZodOptional<z.ZodUnion<readonly [z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>]>>;
+        dynamicWorkflowCodeRef: z.ZodOptional<z.ZodString>;
         encryptionPublicKey: z.ZodOptional<z.ZodString>;
     }, z.core.$strip>;
 }, z.core.$strip>, z.ZodObject<{
@@ -394,6 +402,8 @@ export declare const EventSchema: z.ZodIntersection<z.ZodDiscriminatedUnion<[z.Z
         attributes: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
         allowReservedAttributes: z.ZodOptional<z.ZodLiteral<true>>;
         encryptionPublicKey: z.ZodOptional<z.ZodString>;
+        dynamicWorkflowCode: z.ZodOptional<z.ZodUnion<readonly [z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>]>>;
+        dynamicWorkflowCodeRef: z.ZodOptional<z.ZodString>;
     }, z.core.$strip>>;
 }, z.core.$strip>, z.ZodObject<{
     correlationId: z.ZodOptional<z.ZodString>;

package/dist/src/compiled/@workflow/world/index.d.ts

@@ -21,6 +21,8 @@ export type * from './shared.js';
 export type { GetChunksOptions, StreamChunk, StreamChunksResponse, StreamInfoResponse, } from './shared.js';
 export { entityResolveData, PaginatedResponseSchema, StructuredErrorSchema, } from './shared.js';
 export { EVENT_ID_BODY_LENGTH, EVENT_ID_PREFIX, eventIdToSlot, FIRST_EVENT_SLOT, isSlotBody, isSlotEventId, MAX_EVENT_SLOT, requireEventSlot, slotToEventId, } from './slot-identity.js';
+export type * from './snapshots.js';
+export { decodeSnapshotEnvelope, encodeSnapshotEnvelope, SNAPSHOT_FORMAT_VERSION, SnapshotMetadataSchema, } from './snapshots.js';
 export type { SpecVersion } from './spec-version.js';
 export { CAPABILITY_ONLY_SPEC_VERSIONS, crossesStructuralSpecVersion, isLegacySpecVersion, mintedSpecVersion, requiresNewerWorld, SEALED_LOG_ENV_VAR, SPEC_VERSION_CURRENT, SPEC_VERSION_LEGACY, SPEC_VERSION_MAX_SUPPORTED, SPEC_VERSION_SUPPORTS_ATTRIBUTES, SPEC_VERSION_SUPPORTS_CBOR_QUEUE_TRANSPORT, SPEC_VERSION_SUPPORTS_COMPRESSION, SPEC_VERSION_SUPPORTS_EVENT_SOURCING, SPEC_VERSION_SUPPORTS_HOOK_FORCE_CLAIM, SPEC_VERSION_SUPPORTS_SEALED_LOG, SPEC_VERSION_SUPPORTS_SLOT_IDENTITY, STRUCTURAL_SPEC_VERSIONS, } from './spec-version.js';
 export type * from './steps.js';

package/dist/src/compiled/@workflow/world/interfaces.d.ts

@@ -5,6 +5,7 @@ import type { GetHookParams, Hook, ListHooksParams } from './hooks.js';
 import type { Queue } from './queue.js';
 import type { BulkCancelWorkflowRunsRequest, BulkCancelWorkflowRunsResult, GetWorkflowRunParams, ListWorkflowRunsParams, WaitForTerminalRunStatusParams, WorkflowRun, WorkflowRunWithoutData } from './runs.js';
 import type { GetChunksOptions, PaginatedResponse, StreamChunksResponse, StreamInfoResponse } from './shared.js';
+import type { SnapshotMetadata } from './snapshots.js';
 import type { GetStepParams, ListWorkflowRunStepsParams, Step, StepWithoutData } from './steps.js';
 export interface StreamWriteSession {
     /**
@@ -357,6 +358,65 @@ export interface Storage {
          */
         list(params: ListHooksParams): Promise<PaginatedResponse<Hook>>;
     };
+    /**
+     * VM snapshot storage for the QuickJS engine's VM-memory snapshotting.
+     *
+     * @experimental The shape of this interface and of `SnapshotMetadata`
+     * may change without a major version bump. It is OPTIONAL and World
+     * implementations do not need to provide it: a World that omits it
+     * simply runs every invocation with full event replay, which is always
+     * correct (snapshots are an optimization, never a correctness
+     * requirement). Consumers must feature-detect
+     * (`world.experimental_snapshots?.…`).
+     *
+     * Snapshots capture the state of the QuickJS WASM VM at a suspension
+     * point, allowing workflow execution to resume from the exact point of
+     * suspension instead of replaying the full event log.
+     *
+     * The metadata (including eventsCursor) is stored alongside the snapshot
+     * data so that on restore, only events created after the snapshot need
+     * to be fetched. Implementations MUST round-trip the metadata object
+     * losslessly and atomically with the bytes it describes — a snapshot
+     * paired with another suspension's metadata replays from the wrong log
+     * position and silently diverges. The `encodeSnapshotEnvelope` /
+     * `decodeSnapshotEnvelope` helpers pack both into one self-describing
+     * blob so a plain blob store satisfies this with a single atomic
+     * write; worlds with transactional metadata storage may store the
+     * fields natively instead.
+     */
+    experimental_snapshots?: {
+        /**
+         * Save a VM snapshot for a workflow run.
+         * Each save overwrites the previous snapshot for this run.
+         *
+         * @param runId - The workflow run ID
+         * @param data - The serialized snapshot bytes (from QuickJS.serializeSnapshot())
+         * @param metadata - Snapshot metadata including the events cursor
+         */
+        save(runId: string, data: Uint8Array, metadata: SnapshotMetadata): Promise<void>;
+        /**
+         * Load the most recent VM snapshot for a workflow run.
+         * Returns null if no snapshot exists (first invocation).
+         *
+         * @param runId - The workflow run ID
+         * @returns The snapshot data and metadata, or null if not found
+         */
+        load(runId: string): Promise<{
+            data: Uint8Array;
+            metadata: SnapshotMetadata;
+        } | null>;
+        /**
+         * Delete the snapshot for a workflow run.
+         * Called when the workflow reaches a terminal state (completed,
+         * failed, cancelled). MUST be idempotent: terminal-state cleanup is
+         * exactly the path most likely to retry or run for a run that never
+         * snapshotted, so deleting a nonexistent snapshot resolves
+         * successfully.
+         *
+         * @param runId - The workflow run ID
+         */
+        delete(runId: string): Promise<void>;
+    };
 }
 /**
  * Optional feature capabilities a World implementation declares so the core
@@ -472,6 +532,19 @@ export interface WorldCapabilities {
      * fail ordinary runs after a version bump.
      */
     deploymentAffinity?: boolean;
+    /**
+     * Stores a dynamic run's workflow code with the run. The World must persist
+     * `dynamicWorkflowCode` from `run_created` (and from a resilient
+     * `run_started` that creates the run), echo it on the created run, and
+     * return it from `runs.get` with `resolveData: 'all'` for the run's
+     * lifetime, because every replay evaluates that code and it exists nowhere
+     * else. `start()` refuses a dynamic start on a World that leaves this unset.
+     *
+     * Code too large for the creating write goes through
+     * {@link World.uploadDynamicWorkflowCode} when the World implements it;
+     * otherwise it is always sent inline.
+     */
+    dynamicWorkflowCode?: boolean;
 }
 /**
  * The "World" interface represents how Workflows are able to communicate with the outside world.
@@ -504,6 +577,13 @@ export interface World extends Queue, Streamer, Storage {
      * "unsupported": runtime optimizations gated on a capability fail closed.
      */
     capabilities?: WorldCapabilities;
+    /**
+     * Validates a dynamic run's complete execution context against
+     * World-specific limits. `start()` calls it only for dynamic starts, before
+     * any durable start side effect, so implementations throw to refuse the
+     * start.
+     */
+    validateRunExecutionContext?(value: Record<string, unknown>): void;
     /**
      * Absolute wall-clock time when the current function invocation will be
      * terminated by the hosting platform, if known. Used to optimize runtime behavior.
@@ -581,6 +661,40 @@ export interface World extends Queue, Streamer, Storage {
      *   tolerate `undefined` for direct callers.
      */
     createRunId?(options?: Readonly<Record<string, unknown>>): string;
+    /**
+     * Upload a dynamic run's serialized workflow VM code to the World's blob
+     * storage ahead of `run_created`, returning the ref key to attach to the
+     * run.
+     *
+     * The inline path — sending the bytes on `run_created` itself — is the
+     * common case and needs nothing from this method: a generated orchestration
+     * function is usually a couple of KB, and keeping it on the creating write
+     * costs no extra round-trip. This exists for the tail: a definition too
+     * large to ride the event wire, which has to be streamed separately and
+     * referenced.
+     *
+     * Worlds that store run records whole (local, Postgres) have no size
+     * pressure and leave this unset; `start()` then always sends inline, and a
+     * definition over its own source limit is rejected client-side rather than
+     * silently truncated.
+     *
+     * The upload necessarily precedes the run it belongs to, so implementations
+     * must accept a `runId` that does not exist yet, and must scope the stored
+     * object to the caller's tenant and that run so it is reclaimed with the
+     * run's other storage.
+     *
+     * @param runId - The client-minted ID of the run being started.
+     * @param params.workflowName - The run's generated dynamic workflow name.
+     *   Worlds that embed it in the storage key need it passed in, because the
+     *   run record does not exist yet to read it from.
+     * @param params.code - Serialized (compressed + encrypted) workflow code.
+     * @returns The ref key to send as `run_created`'s
+     *   `eventData.dynamicWorkflowCodeRef`.
+     */
+    uploadDynamicWorkflowCode?(runId: string, params: {
+        workflowName: string;
+        code: Uint8Array;
+    }): Promise<string>;
     /**
      * The environment this World's writes are attributed to by the backend
      * (`@workflow/world-vercel`: `'production' | 'preview' | 'development'`).
@@ -627,5 +741,18 @@ export interface World extends Queue, Streamer, Storage {
      *   empty object to add nothing for a given run.
      */
     describeRun?(run: Readonly<Record<string, unknown>>): Record<string, string | null> | null | Promise<Record<string, string | null> | null>;
+    /**
+     * Optional telemetry write namespace for non-critical observability signals.
+     */
+    telemetry?: Telemetry;
+}
+export interface Telemetry {
+    /**
+     * Called immediately before a step's user code begins executing.
+     *
+     * Worlds may use this synchronous hook to correlate step execution with the
+     * current platform invocation. Implementations must not throw.
+     */
+    recordStepExecution?(stepId: string): void;
 }
 //# sourceMappingURL=interfaces.d.ts.map

package/dist/src/compiled/@workflow/world/queue.d.ts

@@ -49,6 +49,8 @@ export declare const RunInputSchema: z.ZodObject<{
     workflowName: z.ZodString;
     specVersion: z.ZodNumber;
     executionContext: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+    dynamicWorkflowCode: z.ZodOptional<z.ZodUnion<readonly [z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>]>>;
+    dynamicWorkflowCodeRef: z.ZodOptional<z.ZodString>;
     attributes: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
     allowReservedAttributes: z.ZodOptional<z.ZodLiteral<true>>;
     environment: z.ZodOptional<z.ZodString>;
@@ -183,6 +185,8 @@ export declare const WorkflowInvokePayloadSchema: z.ZodObject<{
         workflowName: z.ZodString;
         specVersion: z.ZodNumber;
         executionContext: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+        dynamicWorkflowCode: z.ZodOptional<z.ZodUnion<readonly [z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>]>>;
+        dynamicWorkflowCodeRef: z.ZodOptional<z.ZodString>;
         attributes: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
         allowReservedAttributes: z.ZodOptional<z.ZodLiteral<true>>;
         environment: z.ZodOptional<z.ZodString>;
@@ -273,6 +277,8 @@ export declare const QueuePayloadSchema: z.ZodUnion<readonly [z.ZodObject<{
         workflowName: z.ZodString;
         specVersion: z.ZodNumber;
         executionContext: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+        dynamicWorkflowCode: z.ZodOptional<z.ZodUnion<readonly [z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>]>>;
+        dynamicWorkflowCodeRef: z.ZodOptional<z.ZodString>;
         attributes: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
         allowReservedAttributes: z.ZodOptional<z.ZodLiteral<true>>;
         environment: z.ZodOptional<z.ZodString>;

package/dist/src/compiled/@workflow/world/runs.d.ts

@@ -40,6 +40,7 @@ export declare const WorkflowRunBaseSchema: z.ZodObject<{
     executionContext: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
     input: z.ZodOptional<z.ZodUnion<readonly [z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>]>>;
     output: z.ZodOptional<z.ZodUnion<readonly [z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>]>>;
+    dynamicWorkflowCode: z.ZodOptional<z.ZodUnion<readonly [z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>]>>;
     error: z.ZodOptional<z.ZodUnion<readonly [z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>]>>;
     errorCode: z.ZodOptional<z.ZodString>;
     attributes: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodString>>;
@@ -57,6 +58,7 @@ export declare const WorkflowRunSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
     specVersion: z.ZodOptional<z.ZodNumber>;
     executionContext: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
     input: z.ZodOptional<z.ZodUnion<readonly [z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>]>>;
+    dynamicWorkflowCode: z.ZodOptional<z.ZodUnion<readonly [z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>]>>;
     errorCode: z.ZodOptional<z.ZodString>;
     attributes: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodString>>;
     encryptionPublicKey: z.ZodOptional<z.ZodString>;
@@ -78,6 +80,7 @@ export declare const WorkflowRunSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
     specVersion: z.ZodOptional<z.ZodNumber>;
     executionContext: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
     input: z.ZodOptional<z.ZodUnion<readonly [z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>]>>;
+    dynamicWorkflowCode: z.ZodOptional<z.ZodUnion<readonly [z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>]>>;
     errorCode: z.ZodOptional<z.ZodString>;
     attributes: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodString>>;
     encryptionPublicKey: z.ZodOptional<z.ZodString>;
@@ -96,6 +99,7 @@ export declare const WorkflowRunSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
     specVersion: z.ZodOptional<z.ZodNumber>;
     executionContext: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
     input: z.ZodOptional<z.ZodUnion<readonly [z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>]>>;
+    dynamicWorkflowCode: z.ZodOptional<z.ZodUnion<readonly [z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>]>>;
     errorCode: z.ZodOptional<z.ZodString>;
     attributes: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodString>>;
     encryptionPublicKey: z.ZodOptional<z.ZodString>;
@@ -114,6 +118,7 @@ export declare const WorkflowRunSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
     specVersion: z.ZodOptional<z.ZodNumber>;
     executionContext: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
     input: z.ZodOptional<z.ZodUnion<readonly [z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>]>>;
+    dynamicWorkflowCode: z.ZodOptional<z.ZodUnion<readonly [z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>]>>;
     errorCode: z.ZodOptional<z.ZodString>;
     attributes: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodString>>;
     encryptionPublicKey: z.ZodOptional<z.ZodString>;
@@ -132,12 +137,14 @@ export type StartedWorkflowRun = WorkflowRun & {
     startedAt: Date;
 };
 /**
- * WorkflowRun with input/output fields excluded (when resolveData='none').
+ * WorkflowRun with its payload fields excluded (when resolveData='none'):
+ * input, output, and a dynamic run's stored workflow code.
  * Used for listing runs without fetching the full serialized data.
  */
-export type WorkflowRunWithoutData = Omit<WorkflowRun, 'input' | 'output'> & {
+export type WorkflowRunWithoutData = Omit<WorkflowRun, 'input' | 'output' | 'dynamicWorkflowCode'> & {
     input: undefined;
     output: undefined;
+    dynamicWorkflowCode?: undefined;
 };
 export interface CreateWorkflowRunRequest {
     deploymentId: string;

package/dist/src/compiled/@workflow/world/snapshots.d.ts

@@ -0,0 +1,60 @@
+/**
+ * VM snapshot storage types and helpers backing
+ * `Storage.experimental_snapshots`.
+ *
+ * @experimental Everything exported from this module may change without a
+ * major version bump. Worlds are not required to implement snapshot
+ * storage.
+ */
+import { z } from '#compiled/zod/index.js';
+/** @experimental See `Storage.experimental_snapshots`. */
+export declare const SnapshotMetadataSchema: z.ZodObject<{
+    eventsCursor: z.ZodNullable<z.ZodString>;
+    createdAt: z.ZodCoercedDate<unknown>;
+    eventCount: z.ZodOptional<z.ZodNumber>;
+    rngDraws: z.ZodOptional<z.ZodNumber>;
+    serdeRootPtr: z.ZodOptional<z.ZodNumber>;
+    lastUlid: z.ZodOptional<z.ZodString>;
+    engineVersion: z.ZodOptional<z.ZodString>;
+    clockMs: z.ZodOptional<z.ZodNumber>;
+    formatVersion: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+/**
+ * Current snapshot format version, bumped when the heap layout or the
+ * metadata contract changes incompatibly.
+ *
+ * v2: host-side serde + host-side ULID factory (post-#3263 engine) —
+ * adds required `serdeRootPtr` and `lastUlid` continuation state. v1
+ * snapshots (in-VM serde era) cannot be restored by this engine and are
+ * treated as a miss.
+ *
+ * v3: the stored bytes frame the heap with the restore-relevant metadata,
+ * sealed inside the encryption so it can be checked against the envelope
+ * on load, and the heap stops retaining consumed step results. v2
+ * snapshots are treated as a miss.
+ *
+ * @experimental See `Storage.experimental_snapshots`.
+ */
+export declare const SNAPSHOT_FORMAT_VERSION = 3;
+/** @experimental See `Storage.experimental_snapshots`. */
+export type SnapshotMetadata = z.infer<typeof SnapshotMetadataSchema>;
+/**
+ * Encode a snapshot's metadata and bytes into one atomic blob.
+ *
+ * @experimental See `Storage.experimental_snapshots`.
+ */
+export declare function encodeSnapshotEnvelope(metadata: SnapshotMetadata, data: Uint8Array): Uint8Array;
+/**
+ * Decode a snapshot envelope. Returns null for anything that is not a
+ * well-formed, schema-valid envelope (wrong magic, unknown version,
+ * truncated, invalid JSON, schema violation) — the caller treats that as
+ * a clean miss (full replay) rather than restoring from fabricated or
+ * torn state. Never invents metadata.
+ *
+ * @experimental See `Storage.experimental_snapshots`.
+ */
+export declare function decodeSnapshotEnvelope(bytes: Uint8Array): {
+    metadata: SnapshotMetadata;
+    data: Uint8Array;
+} | null;
+//# sourceMappingURL=snapshots.d.ts.map