eve 0.72.1 → 0.74.0

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

@@ -13,7 +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 { CompressionMode, CompressionStats } from './compression.js';
 import type { GuestCodeStats } from './hardened.js';
 import type { FormatPrefix } from './types.js';
 /**
@@ -53,15 +53,15 @@ export interface CodecOptions {
     extraRevivers?: Record<string, (value: any) => any>;
     /**
      * Whether to compress the serialized payload (write side only; zstd is
-     * preferred and gzip is the portable fallback). Reads dispatch compressed
-     * payloads by format prefix; zstd decoding still requires runtime or
-     * registered decoder support. 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
+     * preferred and gzip is the portable fallback), and which codecs are
+     * allowed (see `CompressionMode`). Reads dispatch compressed payloads by
+     * format prefix; zstd decoding still requires runtime or registered
+     * decoder support. 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;
+    compression?: CompressionMode;
     /**
      * Optional telemetry sink populated by the compression layer with what
      * it did to the payload (whether it compressed, logical vs stored size).

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

@@ -47,6 +47,15 @@ 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';
+/**
+ * Which compressed formats a write may produce for its target run:
+ * - `false`: none, the payload is stored uncompressed.
+ * - `'gzip'`: gzip only. The target can read compressed payloads but its
+ *   runtime cannot decode zstd (e.g. a run pinned to a Node.js < 22.15
+ *   deployment; see `getRunCapabilities` in capabilities.ts).
+ * - `true`: any codec, zstd preferred.
+ */
+export type CompressionMode = boolean | 'gzip';
 /**
  * Thrown by {@link decompress} when a payload inflates past the caller's
  * `maxOutputBytes`, so a small compressed input cannot exhaust memory.
@@ -87,16 +96,15 @@ export interface CompressionStats {
  * 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
+ * @param mode - Which compressed formats the target run can decode (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.
+ *   `getRunCapabilities` and `getCompressionMode` in capabilities.ts).
  * @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, opts?: {
+export declare function compress(data: Uint8Array | unknown, mode: CompressionMode, 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).

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

@@ -1,5 +1,5 @@
 import { createFlushableState, type FlushableStreamState } from './flushable-stream.js';
-import { compress, decompress } from './serialization/compression.js';
+import { type CompressionMode, compress, decompress } from './serialization/compression.js';
 import { aesKeyOf, decrypt, deriveRunPayloadKeys, type EncryptionKeyParam, encrypt, isRunPayloadKeys, isSealTarget, type PayloadKey, type RunPayloadKeys, runPayloadKeys, type SealTarget, sealTo } from './serialization/encryption.js';
 import { decodeFormatPrefix, encodeWithFormatPrefix, isEncrypted, peekFormatPrefix } from './serialization/format.js';
 import { type GuestCodeStats } from './serialization/hardened.js';
@@ -447,7 +447,7 @@ export declare function deserializePreparedStepError(prepared: PreparedReplayPay
  *   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: PayloadKey | undefined, ops?: Promise<void>[], global?: Record<string, any>, v1Compat?: boolean, framedByteStreams?: boolean, compression?: boolean, readbackOps?: Promise<void>[]): Promise<Uint8Array | unknown>;
+export declare function dehydrateWorkflowArguments(value: unknown, runId: string, key: PayloadKey | undefined, ops?: Promise<void>[], global?: Record<string, any>, v1Compat?: boolean, framedByteStreams?: boolean, compression?: CompressionMode, readbackOps?: Promise<void>[]): Promise<Uint8Array | unknown>;
 /**
  * Called from workflow execution environment to hydrate the workflow
  * arguments from the database at the start of workflow execution. A prepared
@@ -457,7 +457,7 @@ export declare function hydrateWorkflowArguments(value: Uint8Array | unknown, _r
 /**
  * Dehydrate workflow return value for storage.
  */
-export declare function dehydrateWorkflowReturnValue(value: unknown, _runId: string, key: PayloadKey | undefined, global?: Record<string, any>, v1Compat?: boolean, compression?: boolean, 
+export declare function dehydrateWorkflowReturnValue(value: unknown, _runId: string, key: PayloadKey | undefined, global?: Record<string, any>, v1Compat?: boolean, compression?: CompressionMode, 
 /**
  * Optional sink receiving the first five samples and exact total count of
  * workflow-code executions serialization could not avoid. The diagnostics
@@ -475,14 +475,14 @@ 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: PayloadKey | undefined, global?: Record<string, any>, v1Compat?: boolean, compression?: boolean, 
+export declare function dehydrateStepArguments(value: unknown, _runId: string, key: PayloadKey | undefined, global?: Record<string, any>, v1Compat?: boolean, compression?: CompressionMode, 
 /** See `dehydrateWorkflowReturnValue`. */
 guestCodeStatsOut?: GuestCodeStats): Promise<Uint8Array | unknown>;
 /**
  * Called from the step executor to hydrate the arguments of a step
  * from the database at the start of the step execution.
  */
-export declare function hydrateStepArguments(value: Uint8Array | unknown, runId: string, key: PayloadKey | undefined, ops?: Promise<any>[], global?: Record<string, any>, extraRevivers?: Record<string, (value: any) => any>, deploymentId?: string, streamStates?: FlushableStreamState[]): Promise<any>;
+export declare function hydrateStepArguments(value: Uint8Array | unknown, runId: string, key: PayloadKey | undefined, ops?: Promise<any>[], global?: Record<string, any>, extraRevivers?: Record<string, (value: any) => any>, deploymentId?: string, streamStates?: FlushableStreamState[], runReadyBarrier?: Promise<unknown>): Promise<any>;
 /**
  * Called from the step executor when a step has completed.
  * Dehydrates values from within the step execution environment
@@ -500,7 +500,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: PayloadKey | undefined, ops?: Promise<any>[], global?: Record<string, any>, v1Compat?: boolean, framedByteStreams?: boolean, compression?: boolean, runReadyBarrier?: Promise<unknown>, readbackOps?: Promise<void>[]): Promise<Uint8Array | unknown>;
+export declare function dehydrateStepReturnValue(value: unknown, runId: string, key: PayloadKey | undefined, ops?: Promise<any>[], global?: Record<string, any>, v1Compat?: boolean, framedByteStreams?: boolean, compression?: CompressionMode, runReadyBarrier?: Promise<unknown>, readbackOps?: Promise<void>[]): Promise<Uint8Array | unknown>;
 /**
  * Called from the step executor when a step throws. Dehydrates the thrown
  * value from within the step execution environment into a format that can
@@ -517,7 +517,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: PayloadKey | undefined, ops?: Promise<any>[], global?: Record<string, any>, compression?: boolean): Promise<Uint8Array>;
+export declare function dehydrateStepError(value: unknown, runId: string, key: PayloadKey | undefined, ops?: Promise<any>[], global?: Record<string, any>, compression?: CompressionMode): 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
@@ -552,7 +552,7 @@ export declare function hydrateStepError(value: Uint8Array | unknown, _runId: st
  * @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>;
+export declare function dehydrateDynamicWorkflowCode(code: string, key: PayloadKey | undefined, compression?: CompressionMode): Promise<Uint8Array>;
 /**
  * Hydrate a dynamic run's workflow VM code back into source, on the replay
  * path.
@@ -590,7 +590,7 @@ export declare function hydrateDynamicWorkflowCode(value: Uint8Array | unknown,
  * @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: PayloadKey | undefined, global?: Record<string, any>, compression?: boolean): Promise<Uint8Array>;
+export declare function dehydrateRunError(value: unknown, _runId: string, key: PayloadKey | undefined, global?: Record<string, any>, compression?: CompressionMode): 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/serialization.js

@@ -1 +1 @@
-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};
+import{A as e,Ar as t,C as n,Cr as r,D as i,Dr as a,E as o,Er as s,F as c,I as l,L as u,M as d,Mr as f,N as p,Nr as m,O as h,Or as g,P as _,R as v,S as y,Sr as b,T as x,Tr as S,_ as C,a as w,b as T,br as E,c as D,d as O,f as k,g as A,h as j,i as M,j as N,jr as P,k as F,kr as I,l as L,m as R,n as z,o as B,p as V,r as H,s as U,t as W,u as G,v as K,vr as q,w as J,wr as Y,x as X,xr as Z,y as Q,yr as $,z as ee}from"../../_chunks/workflow/serialization-vDozzDhh.js";export{W as FRAMED_STREAM_MAX_RECONNECTS,z as FRAMED_STREAM_MAX_TOTAL_RECONNECTS,f as SerializationFormat,H as WorkflowServerReadableStream,M as WorkflowServerWritableStream,q as aesKeyOf,w as cancelAbortReaders,s as compress,B as createForwardedWritable,U as createReconnectingFramedStream,g as decodeFormatPrefix,a as decompress,$ as decrypt,D as dehydrateDynamicWorkflowCode,L as dehydrateRunError,G as dehydrateStepArguments,O as dehydrateStepError,k as dehydrateStepReturnValue,V as dehydrateWorkflowArguments,R as dehydrateWorkflowReturnValue,E as deriveRunPayloadKeys,j as deserializePreparedReplayPayload,A as deserializePreparedStepError,I as encodeWithFormatPrefix,Z as encrypt,C as getByteFramingStream,K as getByteUnframingStream,Q as getCommonRevivers,T as getDeserializeStream,X as getExternalReducers,y as getExternalRevivers,n as getForwardedWritableEncryptionKey,J as getRunReadableStream,x as getSerializeStream,o as getStreamType,i as getWorkflowReducers,h as getWorkflowRevivers,F as hydrateDynamicWorkflowCode,e as hydrateRunError,N as hydrateStepArguments,d as hydrateStepError,p as hydrateStepReturnValue,_ as hydrateWorkflowArguments,c as hydrateWorkflowReturnValue,t as isEncrypted,m as isFormatPrefix,b as isRunPayloadKeys,r as isSealTarget,l as maybeDecrypt,u as maybeEncrypt,P as peekFormatPrefix,v as prepareReplayPayload,Y as runPayloadKeys,S as sealTo,ee as tagForwardedWritableTarget};

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

@@ -56,6 +56,8 @@ export declare const STREAM_SERVER_PUBLIC_KEY_SYMBOL: unique symbol;
  * client-side. Sinks without it are fully durable per `write()` already.
  */
 export declare const STREAM_DRAIN_SYMBOL: unique symbol;
+/** Release idle sink transport resources without closing or invalidating it. */
+export declare const STREAM_RELEASE_SYMBOL: unique symbol;
 export declare const BODY_INIT_SYMBOL: unique symbol;
 export declare const WEBHOOK_RESPONSE_WRITABLE: unique symbol;
 /**

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

@@ -734,8 +734,8 @@ 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";
+export declare const SerializationCodec: (value: "gzip" | "zstd" | "none") => {
+    [k: string]: "gzip" | "zstd" | "none";
 };
 /** Logical (uncompressed, devalue-prefixed) payload size in bytes. */
 export declare const SerializationUncompressedBytes: (value: number) => {

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

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

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

@@ -1,6 +1,7 @@
 import type { StepMetadata } from '../step/get-step-metadata.js';
 export { FatalError, RetryableError, type RetryableErrorOptions, } from '#compiled/@workflow/errors/index.js';
 export type { Hook, HookOptions } from '../create-hook.js';
+export type { Serializable } from '../schemas.js';
 export { sleep } from '../sleep.js';
 export { createHook, createWebhook } from './create-hook.js';
 export { defineHook } from './define-hook.js';

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{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};
+import{Fr as e,Pr as t,Zr as n,ii as r,ni as i,ri as a}from"../../_chunks/workflow/serialization-vDozzDhh.js";import{d as o,i as s}from"../../_chunks/workflow/dist-T5NnW-0k.js";import{i as c}from"../../_chunks/workflow/workflow-routes-CwqB063q.js";import{c as l,i as u,o as d,r as f,t as p}from"../../_chunks/workflow/attribute-changes-CSqvJx6j.js";import{t as m}from"../../_chunks/workflow/sleep-BMqbraZM.js";import{t as h}from"../../_chunks/workflow/run-8pLWuR2U.js";e(t,h);function g(e){let t=globalThis[i];return t||u(`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 generated for you. 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:o}=l();return a.url=c(o,{type:`webhook`,token:a.token}),a}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,t={}){let n=p(e,t);if(n.length===0)return;let i=t.allowReservedAttributes===!0,a=globalThis[r];if(!a)throw new s("setAttributes() called outside a workflow runtime context. It must be called from within a workflow body (`use workflow`).");await a(n,i?{allowReservedAttributes:!0}:{})}function b(e={}){let{namespace:t}=e,r=globalThis[a](t);return Object.create(globalThis.WritableStream.prototype,{[n]:{value:r,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{s as FatalError,o 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/errors/index.js

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

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

@@ -664,6 +664,17 @@ export interface CreateEventParams {
      * may ignore this flag entirely.
      */
     viaStepDispatch?: boolean;
+    /**
+     * Marks a `step_failed` write that records the failure of a step body this
+     * invocation already ran. Losing such a write to queue redelivery runs the
+     * body again, so a World may keep a throttled write waiting longer than it
+     * otherwise would (world-vercel waits until the invocation's deadline).
+     * `step_failed` needs the mark because the runtime also writes it for a step
+     * whose arguments failed to serialize, where no body ran. `step_completed`
+     * and `step_retrying` are only ever written after a body ran. Advisory;
+     * Worlds may ignore it.
+     */
+    afterStepBody?: true;
     /** Request ID (x-vercel-id when on Vercel) for correlating request logs with workflow events. */
     requestId?: string;
     /**

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

@@ -16,6 +16,7 @@ export declare const HookResumeContextSchema: z.ZodObject<{
     workflowName: z.ZodString;
     runSpecVersion: z.ZodOptional<z.ZodNumber>;
     workflowCoreVersion: z.ZodOptional<z.ZodString>;
+    nodeVersion: z.ZodOptional<z.ZodString>;
     traceCarrier: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
     encryptionPublicKey: z.ZodOptional<z.ZodString>;
     hookResumeInputVersion: z.ZodOptional<z.ZodNumber>;
@@ -101,6 +102,7 @@ export declare const HookSchema: z.ZodObject<{
         workflowName: z.ZodString;
         runSpecVersion: z.ZodOptional<z.ZodNumber>;
         workflowCoreVersion: z.ZodOptional<z.ZodString>;
+        nodeVersion: z.ZodOptional<z.ZodString>;
         traceCarrier: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
         encryptionPublicKey: z.ZodOptional<z.ZodString>;
         hookResumeInputVersion: z.ZodOptional<z.ZodNumber>;

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

@@ -15,6 +15,12 @@ export interface StreamWriteSession {
     write(chunkSeq: number, chunks: (string | Uint8Array)[]): Promise<void>;
     /** Close this writer lifetime after all prior writes are durable. */
     close(): Promise<void>;
+    /**
+     * Release an idle transport after accepted writes are durable, without
+     * closing the stream or invalidating this writer. Later writes and close
+     * must remain usable (for example, over stateless HTTP).
+     */
+    release?(): Promise<void> | void;
     /** Release transport resources without semantically closing the stream. */
     dispose?(): Promise<void> | void;
 }