eve 0.31.1 → 0.31.2

package/dist/src/compiled/@workflow/core/serialization/reducers/step-function-vm.d.ts

@@ -0,0 +1,44 @@
+/**
+ * VM-compatible copy: identical semantics to step-function.ts before the host-side
+ * hardening (#3257) made that module depend on `serialization/hardened.ts`
+ * (which imports `node:util` and captures host intrinsics — meaningless
+ * and unbundleable inside the QuickJS VM, where the codec already runs in
+ * the guest realm). The host/guest boundary hardening for the QuickJS
+ * engine lands with the host-side serde (#3263), which retires this
+ * bundle entirely. Wire format is identical to the hardened host version.
+ */
+/**
+ * Reducer and reviver for step function references.
+ *
+ * In workflow mode, step functions are replaced by the SWC plugin with
+ * proxies created by `globalThis[Symbol.for("WORKFLOW_USE_STEP")]("stepId")`.
+ * These proxies have a `.stepId` property and optionally a `.__closureVarsFn`
+ * for captured closure variables. They may additionally have `.__boundThis`
+ * (and rarely `.__boundArgs`) when the SWC plugin emitted
+ * `useStep(...).bind(this)` for a nested arrow step that lexically
+ * captured `this` (see `packages/swc-plugin-workflow/spec.md` → "Lexical
+ * `this` Capture in Nested Arrow Steps").
+ *
+ * The reducer serializes them as
+ *   `{ stepId, closureVars?, boundThis?, boundArgs? }`.
+ * The reviver reconstructs them by calling WORKFLOW_USE_STEP and, when
+ * `boundThis` (or `boundArgs`) is present, re-binding the resulting
+ * proxy so the caller's captured `this` (and prefilled args) survive the
+ * round trip.
+ */
+import type { Reducers, Revivers } from '../types.js';
+export declare function getStepFunctionReducer(): Partial<Reducers>;
+/**
+ * Create the StepFunction reviver for workflow context.
+ *
+ * The reviver calls WORKFLOW_USE_STEP to create the step proxy,
+ * restoring the ability to call the step from workflow code. If the
+ * serialized payload includes `boundThis` (and optionally `boundArgs`),
+ * the reviver also re-binds the freshly-created proxy so a step proxy
+ * that was constructed with `.bind(this, …)` in the workflow bundle
+ * continues to carry that receiver and any prefilled arguments after
+ * being deserialized in another bundle (e.g. when passed as a step
+ * argument).
+ */
+export declare function getStepFunctionReviver(global?: Record<string, any>): Partial<Revivers>;
+//# sourceMappingURL=step-function-vm.d.ts.map

package/dist/src/compiled/@workflow/core/serialization/vm-bundle-entry.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Entry point for the VM serialization bundle.
+ *
+ * This file is bundled by esbuild into a self-contained IIFE that
+ * sets up serialize/deserialize on globalThis. The bundled output
+ * is evaluated inside the QuickJS VM during bootstrap.
+ *
+ * TextEncoder, TextDecoder, and Headers are provided by native C
+ * extensions in quickjs-wasi, so no polyfills are needed.
+ */
+export {};
+//# sourceMappingURL=vm-bundle-entry.d.ts.map

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

@@ -0,0 +1,24 @@
+/**
+ * VM-compatible workflow mode serialization.
+ *
+ * This module is designed to be bundled into the QuickJS WASM VM.
+ * It has NO Node.js dependencies (no Buffer, no node:util).
+ *
+ * Produces and consumes the same wire format as the Node.js workflow.ts —
+ * format-prefixed devalue data ("devl" + devalue.stringify output).
+ */
+/**
+ * Serialize a value to format-prefixed bytes.
+ *
+ * @param value - The value to serialize
+ * @returns Uint8Array with "devl" prefix + devalue payload
+ */
+export declare function serialize(value: unknown): Uint8Array;
+/**
+ * Deserialize format-prefixed bytes back to a value.
+ *
+ * @param data - Uint8Array with format prefix, or legacy non-binary data
+ * @returns The deserialized value
+ */
+export declare function deserialize(data: Uint8Array | unknown): unknown;
+//# sourceMappingURL=workflow-vm.d.ts.map

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

@@ -394,7 +394,8 @@ export declare function dehydrateWorkflowReturnValue(value: unknown, _runId: str
  * not avoid, for callers that need them programmatically (e.g. a
  * retained-VM gate deciding whether the VM is still reusable). The
  * executions are emitted as span attributes either way, so omitting this
- * loses nothing observability-wise. No runtime caller passes one yet.
+ * loses nothing observability-wise. The retained-VM gate in
+ * runtime/suspension-handler.ts passes one for step-input dehydration.
  */
 guestCodeStatsOut?: GuestCodeStats): Promise<Uint8Array | unknown>;
 /**

package/dist/src/compiled/@workflow/core/source-map.d.ts

@@ -1,3 +1,23 @@
+/**
+ * Strip the trailing `//# sourceMappingURL=data:…` comment from a JS
+ * bundle. Returns the input unchanged if no trailing inline map is
+ * present.
+ *
+ * Use this on the host side before evaluating workflow bundles inside
+ * the QuickJS VM — the inline map can account for several MB of bundle
+ * text (measured ~30%+ of VM heap bytes on the example workbench's
+ * bundle), and the VM never needs it; only host-side `remapErrorStack`
+ * reads the map (and it can do so against the original, unstripped
+ * string).
+ *
+ * Implemented as a linear `lastIndexOf` + character scan rather than a
+ * regex: on webpack dev-server bundles (tens of MB, with hundreds of
+ * per-module inline map comments embedded in eval strings) a
+ * `String.replace` regex over the bundle blows V8's call stack
+ * ("RangeError: Maximum call stack size exceeded"), wedging every
+ * workflow invocation on that framework.
+ */
+export declare function stripInlineSourceMap(workflowCode: string): string;
 /**
  * Remaps an error stack trace using inline source maps to show original source locations.
  *

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

@@ -60,6 +60,10 @@ export declare const WorkflowStartedAt: (value: number) => {
 export declare const WorkflowEventsCount: (value: number) => {
     [k: string]: number;
 };
+/** Whether workflow execution starts with replay or resumes a retained VM */
+export declare const WorkflowExecutionMode: (value: "replay" | "retained") => {
+    [k: string]: "replay" | "retained";
+};
 /** Number of arguments passed to the workflow */
 export declare const WorkflowArgumentsCount: (value: number) => {
     [k: string]: number;
@@ -72,6 +76,34 @@ export declare const WorkflowResultType: (value: string) => {
 export declare const WorkflowTracePropagated: (value: boolean) => {
     [k: string]: boolean;
 };
+/** The VM engine executing the workflow function for this invocation */
+export declare const WorkflowVm: (value: "node" | "quickjs") => {
+    [k: string]: "node" | "quickjs";
+};
+/** Outcome of a QuickJS VM workflow invocation */
+export declare const QuickJSOutcome: (value: "completed" | "failed" | "suspended") => {
+    [k: string]: "completed" | "failed" | "suspended";
+};
+/** Whether preloaded events from `events.create('run_started')` were used */
+export declare const QuickJSEventsPreloaded: (value: boolean) => {
+    [k: string]: boolean;
+};
+/** Total number of events fetched from the world for this invocation */
+export declare const QuickJSEventsFetchedCount: (value: number) => {
+    [k: string]: number;
+};
+/** Number of pages required to fetch all events */
+export declare const QuickJSEventsFetchedPages: (value: number) => {
+    [k: string]: number;
+};
+/** Number of pending VM operations captured at suspension */
+export declare const QuickJSPendingOpsCount: (value: number) => {
+    [k: string]: number;
+};
+/** Number of steps executed inline (live-VM continuation) this invocation */
+export declare const QuickJSInlineSteps: (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";
@@ -286,6 +318,18 @@ export declare const QueueOverheadMs: (value: number) => {
 export declare const DeploymentId: (value: string) => {
     [k: string]: string;
 };
+/** The deployment a run is pinned to, set only on a misrouted delivery. */
+export declare const WorkflowRunPinnedDeploymentId: (value: string) => {
+    [k: string]: string;
+};
+/** Re-route attempts for this misrouted delivery, including this one. */
+export declare const WorkflowDeploymentMismatchRetryCount: (value: number) => {
+    [k: string]: number;
+};
+/** Whether the misrouted delivery was re-routed instead of failing the run. */
+export declare const WorkflowDeploymentMismatchRecovered: (value: boolean) => {
+    [k: string]: boolean;
+};
 /** Token identifying a specific hook */
 export declare const HookToken: (value: string) => {
     [k: string]: string;
@@ -312,10 +356,44 @@ export declare const HookResilientResume: (value: boolean) => {
  * materialized the `hook_received` event from the queue message's `hookInput`
  * because the producer's direct write had not landed — the completion of the
  * recovery path {@link HookResilientResume} began.
+ *
+ * Legacy / non-atomic re-ensure signal only. Atomic lazy resumes
+ * (resumeId + digest) go through the hoisted preload write instead, whose
+ * response cannot tell whether the producer or the consumer won the
+ * `(runId, resumeId)` claim — so this attribute is deliberately NOT emitted
+ * for them (emitting `true` unconditionally would count every producer-won
+ * resume as a recovery). The producer-begin ({@link HookResilientResume}) /
+ * consumer-materialized pairing is therefore no longer complete for atomic
+ * lazy resumptions; use {@link HookResumeSetupSource} to observe that path.
  */
 export declare const HookResilientResumeMaterialized: (value: boolean) => {
     [k: string]: boolean;
 };
+/**
+ * Consumer-side signal (on the workflow execution span) of how a lazy hook
+ * resume initialized its replay state:
+ *
+ * - `hook_received_stream` — the hoisted `hook_received` write returned a
+ *   usable replay preload (run + complete event log), so the invocation
+ *   skipped both the `run_started` write and the initial `events.list`.
+ * - `hook_received_fallback` — the hoisted write succeeded but returned no
+ *   usable preload (a CBOR response from an older server, a World that
+ *   ignored the opt-in, a bounded `hasMore` page, or a preload that failed
+ *   validation); the invocation fell back to the `run_started` setup without
+ *   re-posting the hook.
+ *
+ * Absent on legacy hook deliveries (no resumeId/digest) and on every other
+ * delivery kind, which take the `run_started` setup unconditionally.
+ *
+ * This is a latency/setup-path signal: it says which requests initialized
+ * the invocation, NOT that this consumer created the `hook_received` event
+ * (the hoisted write may equally have converged on the producer's — claim
+ * ownership is not observable client-side; cf.
+ * {@link HookResilientResumeMaterialized}).
+ */
+export declare const HookResumeSetupSource: (value: string) => {
+    [k: string]: string;
+};
 /** Number of webhook handlers triggered */
 export declare const WebhookHandlersTriggered: (value: number) => {
     [k: string]: number;

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

@@ -1,5 +1,6 @@
 import type * as api from '#compiled/@opentelemetry/api/index.js';
 import type { Span, SpanKind, SpanOptions } from '#compiled/@opentelemetry/api/index.js';
+import { WorkflowSuspension } from './global.js';
 /**
  * Controls how workflow/step queue-handler spans relate to the run-origin
  * trace context carried in queue messages:
@@ -80,6 +81,10 @@ export declare function trace<T>(spanName: string, ...args: [fn: (span?: Span) =
  * callback. No-op when OpenTelemetry is not available.
  */
 export declare function recordElapsedSpan(spanName: string, startEpochMs: number, opts?: SpanOptions): Promise<void>;
+/**
+ * Applies the workflow suspension algebraic effect to an active span.
+ */
+export declare function applyWorkflowSuspensionToSpan(error: WorkflowSuspension, span: api.Span): void;
 export declare function getSpanContextForTraceCarrier(carrier: Record<string, string>): Promise<api.SpanContext | undefined>;
 export declare function getActiveSpan(): Promise<api.Span | undefined>;
 /**

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

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

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

@@ -1 +1 @@
-import{Cn as e,Gn as t,Kn as n,Wn as r,wn as i,zn as a}from"../../_chunks/workflow/wait-until-DoW76jdb.js";import"../../_chunks/workflow/dist-B-vbuNqP.js";import{i as o}from"../../_chunks/workflow/workflow-routes-CwqB063q.js";import{i as s,u as c}from"../../_chunks/workflow/dist-dNxTT6nO.js";import{c as l,i as u,o as d,r as f,t as p}from"../../_chunks/workflow/attribute-changes-DROfGk6l.js";import{t as m}from"../../_chunks/workflow/sleep-D5iWly6-.js";import{t as h}from"../../_chunks/workflow/run-DM3ouA3U.js";i(e,h);function g(e){let t=globalThis[r];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 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}=l();return a.url=o(s,{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 r=p(e,t);if(r.length===0)return;let i=t.allowReservedAttributes===!0,a=globalThis[n];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(r,i?{allowReservedAttributes:!0}:{})}function b(e={}){let{namespace:n}=e,r=globalThis[t](n);return Object.create(globalThis.WritableStream.prototype,{[a]:{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,c 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{An as e,Gn as t,Qn as n,Xn as r,Zn as i,kn as a}from"../../_chunks/workflow/wait-until-CMX5LUWJ.js";import{i as o,u as s}from"../../_chunks/workflow/dist-CRTn4Sg8.js";import"../../_chunks/workflow/dist-tJoQXAF6.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-Du5ztewf.js";import{t as m}from"../../_chunks/workflow/sleep-BeH4B0Cd.js";import{t as h}from"../../_chunks/workflow/run-DBheaFhH.js";e(a,h);function g(e){let t=globalThis[r];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 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: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 r=p(e,t);if(r.length===0)return;let i=t.allowReservedAttributes===!0,a=globalThis[n];if(!a)throw new o("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:n}=e,r=globalThis[i](n);return Object.create(globalThis.WritableStream.prototype,{[t]:{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{o as FatalError,s 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/error-codes.d.ts

@@ -20,6 +20,8 @@ export declare const RUN_ERROR_CODES: {
     readonly REPLAY_TIMEOUT: "REPLAY_TIMEOUT";
     /** World response violated the SDK contract and cannot be retried safely */
     readonly WORLD_CONTRACT_ERROR: "WORLD_CONTRACT_ERROR";
+    /** Run was delivered to a deployment other than the one it is pinned to */
+    readonly DEPLOYMENT_MISMATCH: "DEPLOYMENT_MISMATCH";
 };
 export type RunErrorCode = (typeof RUN_ERROR_CODES)[keyof typeof RUN_ERROR_CODES];
 //# sourceMappingURL=error-codes.d.ts.map

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

@@ -17,6 +17,7 @@ export declare const ERROR_SLUGS: {
     readonly STEP_NOT_REGISTERED: "step-not-registered";
     readonly WORKFLOW_NOT_REGISTERED: "workflow-not-registered";
     readonly RUNTIME_DECRYPTION_FAILED: "runtime-decryption-failed";
+    readonly DEPLOYMENT_MISMATCH: "deployment-mismatch";
 };
 type ErrorSlug = (typeof ERROR_SLUGS)[keyof typeof ERROR_SLUGS];
 interface WorkflowErrorOptions extends ErrorOptions {
@@ -313,6 +314,29 @@ export declare class WorkflowNotRegisteredError extends WorkflowRuntimeError {
     constructor(workflowName: string);
     static is(value: unknown): value is WorkflowNotRegisteredError;
 }
+/**
+ * Thrown when a workflow run is delivered to a deployment other than the one
+ * it is pinned to.
+ *
+ * A run is pinned to one deployment when it starts, and executing anywhere
+ * else is unsafe: that deployment's bundles may not match the run's history.
+ */
+export declare class WorkflowDeploymentMismatchError extends WorkflowRuntimeError {
+    readonly runId: string;
+    readonly expectedDeploymentId: string;
+    readonly actualDeploymentId: string;
+    /**
+     * How many times the runtime re-routed the message before giving up. `0`
+     * means recovery was never attempted: the budget is disabled, or the
+     * re-route itself failed and `cause` holds the enqueue error.
+     */
+    readonly recoveryAttempts: number;
+    constructor(runId: string, expectedDeploymentId: string, actualDeploymentId: string, options?: {
+        recoveryAttempts?: number;
+        cause?: unknown;
+    });
+    static is(value: unknown): value is WorkflowDeploymentMismatchError;
+}
 /**
  * Thrown when performing operations on a workflow run that does not exist.
  *

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

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

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

@@ -174,6 +174,8 @@ export interface AnalyticsListEventsParams extends AnalyticsListRunScopedParams
 }
 export interface AnalyticsListEventsByCorrelationIdParams {
     correlationId: string;
+    /** The run the correlation id belongs to; see `ListEventsByCorrelationIdParams`. */
+    runId: string;
     pagination?: PaginationOptions;
 }
 export interface AnalyticsListHooksParams {

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

@@ -742,6 +742,42 @@ export interface CreateEventParams {
      * across the SDK and the backend.
      */
     skipPreload?: boolean;
+    /**
+     * Replay-log preload opt-in (advisory) — the `hook_received` dual of
+     * {@link skipPreload}. Set only by the queue consumer's idempotent
+     * `hook_received` re-ensure on a lazy hook resume (alongside
+     * {@link resumeId} + {@link resumePayloadDigest}). A World MAY return the
+     * run's current replay event log with the event creation
+     * (`events`/`cursor`/`hasMore`, plus `run` and `maxEvents`) so the runtime
+     * can initialize replay from this one request and skip both the
+     * `run_started` write and the initial `events.list`.
+     *
+     * The runtime trusts a returned preload as replay input ONLY when all of
+     * the following hold — a World that cannot guarantee them should return
+     * its normal {@link EventResult} instead:
+     *
+     * - `events` is the COMPLETE log with `hasMore: false` (the runtime has no
+     *   cursor-continuation machinery on this path; a bounded page is
+     *   rejected).
+     * - `cursor` is a valid non-null resume point matching `events.list`
+     *   semantics (present even on the final page).
+     * - `run` (with `run.startedAt`) and `maxEvents` are present — this
+     *   response plays `run_started`'s role, including the event-ceiling
+     *   handshake.
+     * - The log contains `run_created`, `run_started`, and the canonical
+     *   `hook_received` carrying the requested {@link resumeId}.
+     * - `events` uses the same ascending ordering semantics as `events.list`.
+     * - The log is read atomically/consistently WITH (i.e. no earlier than)
+     *   the `hook_received` write, so no concurrently committed event can be
+     *   omitted from the replay input.
+     *
+     * Anything less and the runtime observes that no usable replay preload
+     * came back and falls back to the existing `run_started` setup — a World
+     * that ignores the param entirely remains fully correct. Only meaningful
+     * for `hook_received`; ignored for other event types. Producer-side
+     * `resumeHook()` must not set it.
+     */
+    preloadEvents?: true;
 }
 /**
  * Result of creating an event. Includes the created event and optionally
@@ -761,7 +797,7 @@ export interface EventResult {
     /** The wait entity (for wait_created/wait_completed events) */
     wait?: import('./waits.js').Wait;
     /**
-     * Events with data resolved. Two producers populate this:
+     * Events with data resolved. Three producers populate this:
      *
      * - On a `run_started` response: all events up to this point, so the
      *   runtime can skip the initial `events.list` call and reduce TTFB.
@@ -769,6 +805,11 @@ export interface EventResult {
      *   the caller passed {@link CreateEventParams.sinceCursor}: the delta
      *   of events written strictly after that cursor, so the inline loop
      *   can skip the per-step incremental `events.list` round-trip.
+     * - On a `hook_received` response when the caller passed
+     *   {@link CreateEventParams.preloadEvents}: the run's current replay
+     *   log through the canonical `hook_received`, so the lazy hook queue
+     *   consumer can skip both the `run_started` write and the initial
+     *   `events.list`.
      */
     events?: Event[];
     /** Pagination cursor for `events`, matching events.list semantics. */
@@ -800,6 +841,15 @@ export interface ListEventsParams {
 }
 export interface ListEventsByCorrelationIdParams {
     correlationId: string;
+    /**
+     * The run the correlation id belongs to. A correlation id is unique per
+     * run, not globally: a slot-numbered run counts its own steps and waits, so
+     * `step_…001` names the first step of *every* such run. Naming the run is
+     * what makes the answer that run's events, and it is what makes the
+     * pagination cursor unambiguous — `(runId, eventId)` is a key where an
+     * event id alone is not.
+     */
+    runId: string;
     pagination?: PaginationOptions;
     resolveData?: ResolveData;
 }

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

@@ -74,6 +74,7 @@ export declare const HookSchema: z.ZodObject<{
     specVersion: z.ZodOptional<z.ZodNumber>;
     isWebhook: z.ZodOptional<z.ZodBoolean>;
     isSystem: z.ZodOptional<z.ZodBoolean>;
+    tokenRetentionUntil: z.ZodOptional<z.ZodCoercedDate<unknown>>;
     resumeContext: z.ZodOptional<z.ZodObject<{
         deploymentId: z.ZodString;
         workflowName: z.ZodString;

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

@@ -12,7 +12,7 @@ export type * from './queue.js';
 export { getQueueTopicPrefix, HealthCheckPayloadSchema, MessageId, parseQueueName, QueuePayloadSchema, QueuePrefix, RunInputSchema, resolveQueueNamespace, ValidQueueName, WorkflowInvokePayloadSchema, } from './queue.js';
 export { reenqueueActiveRuns } from './recovery.js';
 export type * from './runs.js';
-export { isTerminalWorkflowRunStatus, TERMINAL_WORKFLOW_RUN_STATUSES, TerminalWorkflowRunStatusSchema, WorkflowRunBaseSchema, WorkflowRunSchema, WorkflowRunStatusSchema, } from './runs.js';
+export { BULK_CANCEL_MAX_RUN_IDS, BulkCancelWorkflowRunResultSchema, BulkCancelWorkflowRunsRequestSchema, BulkCancelWorkflowRunsResultSchema, isTerminalWorkflowRunStatus, TERMINAL_WORKFLOW_RUN_STATUSES, TerminalWorkflowRunStatusSchema, WorkflowRunBaseSchema, WorkflowRunSchema, WorkflowRunStatusSchema, } from './runs.js';
 export type { SerializedData } from './serialization.js';
 export { LegacySerializedDataSchemaV1, SerializedDataSchema, } from './serialization.js';
 export type * from './shared.js';

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

@@ -3,7 +3,7 @@ import type { AttributeChange, ExperimentalSetAttributesResult } from './attribu
 import type { CreateEventParams, CreateEventRequest, Event, EventResult, GetEventParams, ListEventsByCorrelationIdParams, ListEventsParams, RunCreatedEventRequest } from './events.js';
 import type { GetHookParams, Hook, ListHooksParams } from './hooks.js';
 import type { Queue } from './queue.js';
-import type { GetWorkflowRunParams, ListWorkflowRunsParams, WorkflowRun, WorkflowRunWithoutData } from './runs.js';
+import type { BulkCancelWorkflowRunsRequest, BulkCancelWorkflowRunsResult, GetWorkflowRunParams, ListWorkflowRunsParams, WorkflowRun, WorkflowRunWithoutData } from './runs.js';
 import type { GetChunksOptions, PaginatedResponse, StreamChunksResponse, StreamInfoResponse } from './shared.js';
 import type { GetStepParams, ListWorkflowRunStepsParams, Step, StepWithoutData } from './steps.js';
 export interface Streamer {
@@ -143,6 +143,14 @@ export interface Storage {
         experimentalSetAttributes?(runId: string, changes: AttributeChange[], options?: {
             allowReservedAttributes?: boolean;
         }): Promise<ExperimentalSetAttributesResult>;
+        /**
+         * Cancel many runs in a single operation, returning a per-run outcome
+         * for each requested ID (order preserved) plus an aggregate summary.
+         *
+         * OPTIONAL. The SDK helper `cancelRuns` in `@workflow/core` falls back to
+         * bounded-concurrency single-run cancellation when unavailable.
+         */
+        cancelMany?(request: BulkCancelWorkflowRunsRequest): Promise<BulkCancelWorkflowRunsResult>;
     };
     steps: {
         get(runId: string, stepId: string, params: GetStepParams & {
@@ -283,6 +291,20 @@ export interface WorldCapabilities {
      * `resumeCapabilities.hookResumeDedupVersion` on the by-token hook.
      */
     hookResumeDedup?: boolean;
+    /**
+     * Deployments are atomic and immutable: a deployment id names one fixed
+     * build for its whole lifetime, so a run pinned to one may only execute
+     * there. Worlds that declare this get the runtime's deployment-affinity
+     * guard, which re-routes a misrouted delivery to the run's own deployment
+     * and ultimately fails the run with `DEPLOYMENT_MISMATCH`.
+     *
+     * Worlds whose deployment id is synthetic or version-tagged (e.g.
+     * `dpl_local@<sdk-version>`, which legitimately differs across SDK versions
+     * within one logical environment) must leave this unset: there a
+     * "mismatch" is not a real cross-deployment delivery, and guarding would
+     * fail ordinary runs after a version bump.
+     */
+    deploymentAffinity?: boolean;
 }
 /**
  * The "World" interface represents how Workflows are able to communicate with the outside world.
@@ -331,6 +353,11 @@ export interface World extends Queue, Streamer, Storage {
      * `packages/core/src/runtime/replay-budget.ts`.
      */
     processExitTriggersQueueRedelivery?: boolean;
+    /**
+     * Absolute wall-clock time when the current function invocation will be
+     * terminated by the hosting platform, if known. Used to optimize runtime behavior.
+     */
+    getRuntimeDeadline?(): Promise<Date | undefined>;
     /**
      * A function that will be called to start any background tasks needed by the World implementation.
      * For example, in the case of a queue backed World, this would start the queue processing.

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

@@ -85,6 +85,7 @@ export declare const WorkflowInvokePayloadSchema: z.ZodObject<{
     }, z.core.$strip>>;
     preconditionReinvocations: z.ZodOptional<z.ZodNumber>;
     serverErrorRetryCount: z.ZodOptional<z.ZodNumber>;
+    deploymentMismatchRetryCount: z.ZodOptional<z.ZodNumber>;
     stepId: z.ZodOptional<z.ZodString>;
     stepName: z.ZodOptional<z.ZodString>;
     runInput: z.ZodOptional<z.ZodObject<{
@@ -147,6 +148,7 @@ export declare const QueuePayloadSchema: z.ZodUnion<readonly [z.ZodObject<{
     }, z.core.$strip>>;
     preconditionReinvocations: z.ZodOptional<z.ZodNumber>;
     serverErrorRetryCount: z.ZodOptional<z.ZodNumber>;
+    deploymentMismatchRetryCount: z.ZodOptional<z.ZodNumber>;
     stepId: z.ZodOptional<z.ZodString>;
     stepName: z.ZodOptional<z.ZodString>;
     runInput: z.ZodOptional<z.ZodObject<{
@@ -191,6 +193,12 @@ export interface QueueOptions {
 }
 export interface Queue {
     getDeploymentId(): Promise<string>;
+    /**
+     * Returns true only when a queue error definitively means the explicitly
+     * targeted deployment cannot receive the message. Unknown and transient
+     * errors must return false so the current delivery can be retried safely.
+     */
+    isDeploymentUnavailableError?(error: unknown): boolean;
     /**
      * Enqueues a message to the specified queue.
      *

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

@@ -156,4 +156,87 @@ export interface ListWorkflowRunsParams {
 export interface CancelWorkflowRunParams {
     resolveData?: ResolveData;
 }
+/**
+ * Maximum number of run IDs that a single bulk cancellation request may
+ * carry. Kept small enough that the backend can process one request
+ * synchronously without an asynchronous job or cursor.
+ */
+export declare const BULK_CANCEL_MAX_RUN_IDS = 500;
+/**
+ * Request payload for cancelling many runs in a single operation.
+ *
+ * `runIds` must contain 1–{@link BULK_CANCEL_MAX_RUN_IDS} unique IDs.
+ * `cancelReason` (max 512 chars) is recorded on each run_cancelled event,
+ * mirroring the single-run {@link CancelRunOptions.cancelReason}.
+ */
+export declare const BulkCancelWorkflowRunsRequestSchema: z.ZodObject<{
+    runIds: z.ZodArray<z.ZodString>;
+    cancelReason: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type BulkCancelWorkflowRunsRequest = z.infer<typeof BulkCancelWorkflowRunsRequestSchema>;
+/**
+ * Per-run outcome of a bulk cancellation.
+ *
+ * - `cancelled`: the run was transitioned to cancelled by this request.
+ * - `already_cancelled`: the run was already cancelled (idempotent success).
+ * - `not_cancellable`: the run is in a terminal, non-cancellable state
+ *   (e.g. `completed`/`failed`); `status` reports the observed status.
+ * - `not_found`: no run exists for this ID.
+ * - `failed`: cancellation failed; `code` is a machine-readable error code
+ *   and `retryable` indicates whether retrying may succeed.
+ */
+export declare const BulkCancelWorkflowRunResultSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    runId: z.ZodString;
+    outcome: z.ZodLiteral<"cancelled">;
+}, z.core.$strip>, z.ZodObject<{
+    runId: z.ZodString;
+    outcome: z.ZodLiteral<"already_cancelled">;
+}, z.core.$strip>, z.ZodObject<{
+    runId: z.ZodString;
+    outcome: z.ZodLiteral<"not_cancellable">;
+    status: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    runId: z.ZodString;
+    outcome: z.ZodLiteral<"not_found">;
+}, z.core.$strip>, z.ZodObject<{
+    runId: z.ZodString;
+    outcome: z.ZodLiteral<"failed">;
+    code: z.ZodString;
+    retryable: z.ZodBoolean;
+}, z.core.$strip>], "outcome">;
+export type BulkCancelWorkflowRunResult = z.infer<typeof BulkCancelWorkflowRunResultSchema>;
+/**
+ * Aggregate result of a bulk cancellation. `results` preserves the order of
+ * the requested `runIds`; `summary` counts each outcome.
+ */
+export declare const BulkCancelWorkflowRunsResultSchema: z.ZodObject<{
+    summary: z.ZodObject<{
+        requested: z.ZodNumber;
+        cancelled: z.ZodNumber;
+        alreadyCancelled: z.ZodNumber;
+        notCancellable: z.ZodNumber;
+        notFound: z.ZodNumber;
+        failed: z.ZodNumber;
+    }, z.core.$strip>;
+    results: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        runId: z.ZodString;
+        outcome: z.ZodLiteral<"cancelled">;
+    }, z.core.$strip>, z.ZodObject<{
+        runId: z.ZodString;
+        outcome: z.ZodLiteral<"already_cancelled">;
+    }, z.core.$strip>, z.ZodObject<{
+        runId: z.ZodString;
+        outcome: z.ZodLiteral<"not_cancellable">;
+        status: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        runId: z.ZodString;
+        outcome: z.ZodLiteral<"not_found">;
+    }, z.core.$strip>, z.ZodObject<{
+        runId: z.ZodString;
+        outcome: z.ZodLiteral<"failed">;
+        code: z.ZodString;
+        retryable: z.ZodBoolean;
+    }, z.core.$strip>], "outcome">>;
+}, z.core.$strip>;
+export type BulkCancelWorkflowRunsResult = z.infer<typeof BulkCancelWorkflowRunsResultSchema>;
 //# sourceMappingURL=runs.d.ts.map