@workflow/core 4.2.0-beta.74 → 4.2.0-beta.76

package/dist/capabilities.d.ts

@@ -0,0 +1,45 @@
+/**
+ * Capabilities table for workflow runs based on their `@workflow/core` version.
+ *
+ * When resuming a hook or webhook, the payload must be encoded in a format
+ * that the *target* workflow run's deployment can decode. This module provides
+ * a way to look up what serialization formats a given `@workflow/core` version
+ * supports, so that newer deployments can avoid encoding payloads in formats
+ * that older deployments don't understand (e.g., the `encr` encryption format).
+ *
+ * ## Adding a new format
+ *
+ * When a new serialization format is introduced:
+ * 1. Add the format constant to `SerializationFormat` in `serialization.ts`
+ * 2. Add an entry to `FORMAT_VERSION_TABLE` below with the minimum
+ *    `@workflow/core` version that supports it
+ * 3. The `getRunCapabilities()` function will automatically include it
+ *
+ * ## History
+ *
+ * - `encr` (AES-256-GCM encryption): added in `4.2.0-beta.64`
+ *   Commit: 7618ac36 "Wire AES-GCM encryption into serialization layer (#1251)"
+ *   https://github.com/vercel/workflow/commit/7618ac36
+ */
+import { type SerializationFormatType } from './serialization.js';
+/**
+ * Capabilities of a workflow run based on its `@workflow/core` version.
+ */
+export interface RunCapabilities {
+    /**
+     * The set of serialization format prefixes that the target run can decode.
+     * Use `supportedFormats.has(SerializationFormat.ENCRYPTED)` to check
+     * if encryption is supported, etc.
+     */
+    supportedFormats: ReadonlySet<SerializationFormatType>;
+}
+/**
+ * Look up what serialization capabilities a workflow run supports based on
+ * its `@workflow/core` version string (from `executionContext.workflowCoreVersion`).
+ *
+ * When the version is `undefined`, not a string, or not a valid semver string
+ * (e.g. very old runs that predate the field, or corrupted metadata),
+ * we assume the most conservative capabilities (baseline formats only).
+ */
+export declare function getRunCapabilities(workflowCoreVersion: string | undefined): RunCapabilities;
+//# sourceMappingURL=capabilities.d.ts.map

package/dist/capabilities.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"capabilities.d.ts","sourceRoot":"","sources":["../src/capabilities.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AAGH,OAAO,EAEL,KAAK,uBAAuB,EAC7B,MAAM,oBAAoB,CAAC;AAE5B;;GAEG;AACH,MAAM,WAAW,eAAe;IAC9B;;;;OAIG;IACH,gBAAgB,EAAE,WAAW,CAAC,uBAAuB,CAAC,CAAC;CACxD;AA0BD;;;;;;;GAOG;AACH,wBAAgB,kBAAkB,CAChC,mBAAmB,EAAE,MAAM,GAAG,SAAS,GACtC,eAAe,CAcjB"}

package/dist/capabilities.js

@@ -0,0 +1,65 @@
+/**
+ * Capabilities table for workflow runs based on their `@workflow/core` version.
+ *
+ * When resuming a hook or webhook, the payload must be encoded in a format
+ * that the *target* workflow run's deployment can decode. This module provides
+ * a way to look up what serialization formats a given `@workflow/core` version
+ * supports, so that newer deployments can avoid encoding payloads in formats
+ * that older deployments don't understand (e.g., the `encr` encryption format).
+ *
+ * ## Adding a new format
+ *
+ * When a new serialization format is introduced:
+ * 1. Add the format constant to `SerializationFormat` in `serialization.ts`
+ * 2. Add an entry to `FORMAT_VERSION_TABLE` below with the minimum
+ *    `@workflow/core` version that supports it
+ * 3. The `getRunCapabilities()` function will automatically include it
+ *
+ * ## History
+ *
+ * - `encr` (AES-256-GCM encryption): added in `4.2.0-beta.64`
+ *   Commit: 7618ac36 "Wire AES-GCM encryption into serialization layer (#1251)"
+ *   https://github.com/vercel/workflow/commit/7618ac36
+ */
+import semver from 'semver';
+import { SerializationFormat, } from './serialization.js';
+/**
+ * Maps serialization format identifiers to the minimum `@workflow/core`
+ * version that introduced support for them. Formats not listed here are
+ * assumed to be supported by all specVersion 2 runs (e.g., `devl`).
+ */
+const FORMAT_VERSION_TABLE = [
+    { format: SerializationFormat.ENCRYPTED, minVersion: '4.2.0-beta.64' },
+    // Future entries:
+    // { format: SerializationFormat.CBOR, minVersion: '5.x.y' },
+    // { format: SerializationFormat.ENCRYPTED_V2, minVersion: '5.x.y' },
+];
+/**
+ * The set of formats supported by all specVersion 2 runs, regardless of
+ * `@workflow/core` version. These are the baseline formats that were present
+ * from the start of the specVersion 2 protocol.
+ */
+const BASELINE_FORMATS = new Set([
+    SerializationFormat.DEVALUE_V1,
+]);
+/**
+ * Look up what serialization capabilities a workflow run supports based on
+ * its `@workflow/core` version string (from `executionContext.workflowCoreVersion`).
+ *
+ * When the version is `undefined`, not a string, or not a valid semver string
+ * (e.g. very old runs that predate the field, or corrupted metadata),
+ * we assume the most conservative capabilities (baseline formats only).
+ */
+export function getRunCapabilities(workflowCoreVersion) {
+    if (!workflowCoreVersion || !semver.valid(workflowCoreVersion)) {
+        return { supportedFormats: BASELINE_FORMATS };
+    }
+    const formats = new Set(BASELINE_FORMATS);
+    for (const { format, minVersion } of FORMAT_VERSION_TABLE) {
+        if (semver.gte(workflowCoreVersion, minVersion)) {
+            formats.add(format);
+        }
+    }
+    return { supportedFormats: formats };
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY2FwYWJpbGl0aWVzLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vc3JjL2NhcGFiaWxpdGllcy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OztHQXNCRztBQUVILE9BQU8sTUFBTSxNQUFNLFFBQVEsQ0FBQztBQUM1QixPQUFPLEVBQ0wsbUJBQW1CLEdBRXBCLE1BQU0sb0JBQW9CLENBQUM7QUFjNUI7Ozs7R0FJRztBQUNILE1BQU0sb0JBQW9CLEdBR3JCO0lBQ0gsRUFBRSxNQUFNLEVBQUUsbUJBQW1CLENBQUMsU0FBUyxFQUFFLFVBQVUsRUFBRSxlQUFlLEVBQUU7SUFDdEUsa0JBQWtCO0lBQ2xCLDZEQUE2RDtJQUM3RCxxRUFBcUU7Q0FDdEUsQ0FBQztBQUVGOzs7O0dBSUc7QUFDSCxNQUFNLGdCQUFnQixHQUF5QyxJQUFJLEdBQUcsQ0FBQztJQUNyRSxtQkFBbUIsQ0FBQyxVQUFVO0NBQy9CLENBQUMsQ0FBQztBQUVIOzs7Ozs7O0dBT0c7QUFDSCxNQUFNLFVBQVUsa0JBQWtCLENBQ2hDLG1CQUF1QztJQUV2QyxJQUFJLENBQUMsbUJBQW1CLElBQUksQ0FBQyxNQUFNLENBQUMsS0FBSyxDQUFDLG1CQUFtQixDQUFDLEVBQUUsQ0FBQztRQUMvRCxPQUFPLEVBQUUsZ0JBQWdCLEVBQUUsZ0JBQWdCLEVBQUUsQ0FBQztJQUNoRCxDQUFDO0lBRUQsTUFBTSxPQUFPLEdBQUcsSUFBSSxHQUFHLENBQTBCLGdCQUFnQixDQUFDLENBQUM7SUFFbkUsS0FBSyxNQUFNLEVBQUUsTUFBTSxFQUFFLFVBQVUsRUFBRSxJQUFJLG9CQUFvQixFQUFFLENBQUM7UUFDMUQsSUFBSSxNQUFNLENBQUMsR0FBRyxDQUFDLG1CQUFtQixFQUFFLFVBQVUsQ0FBQyxFQUFFLENBQUM7WUFDaEQsT0FBTyxDQUFDLEdBQUcsQ0FBQyxNQUFNLENBQUMsQ0FBQztRQUN0QixDQUFDO0lBQ0gsQ0FBQztJQUVELE9BQU8sRUFBRSxnQkFBZ0IsRUFBRSxPQUFPLEVBQUUsQ0FBQztBQUN2QyxDQUFDIn0=

package/dist/runtime/constants.d.ts

@@ -1,2 +1,3 @@
 export declare const MAX_QUEUE_DELIVERIES = 48;
+export declare const REPLAY_TIMEOUT_MS = 240000;
 //# sourceMappingURL=constants.d.ts.map

package/dist/runtime/constants.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../../src/runtime/constants.ts"],"names":[],"mappings":"AAYA,eAAO,MAAM,oBAAoB,KAAK,CAAC"}
+{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../../src/runtime/constants.ts"],"names":[],"mappings":"AAYA,eAAO,MAAM,oBAAoB,KAAK,CAAC;AASvC,eAAO,MAAM,iBAAiB,SAAU,CAAC"}

package/dist/runtime/constants.js

@@ -11,4 +11,12 @@
 // At 48 attempts the total elapsed time is approximately 20 hours, which is
 // safely under the 24-hour message visibility limit.
 export const MAX_QUEUE_DELIVERIES = 48;
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29uc3RhbnRzLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL3J1bnRpbWUvY29uc3RhbnRzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLDRFQUE0RTtBQUM1RSw0RUFBNEU7QUFDNUUseUVBQXlFO0FBQ3pFLG9EQUFvRDtBQUNwRCxFQUFFO0FBQ0Ysa0RBQWtEO0FBQ2xELDJFQUEyRTtBQUMzRSwrREFBK0Q7QUFDL0Qsd0VBQXdFO0FBQ3hFLEVBQUU7QUFDRiw0RUFBNEU7QUFDNUUscURBQXFEO0FBQ3JELE1BQU0sQ0FBQyxNQUFNLG9CQUFvQixHQUFHLEVBQUUsQ0FBQyJ9
+// Maximum time allowed for a single workflow replay execution (in ms).
+// If a replay exceeds this duration, the run is failed and the process exits.
+// This must be lower than the function's maxDuration to ensure the
+// timeout handler has time to post the run_failed event before the platform
+// kills the function.
+// Note that on hobby plan, the maxDuration is 60s, so this barrier will not be hit,
+// and the queue will re-try until the visibility window expires.
+export const REPLAY_TIMEOUT_MS = 240_000;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29uc3RhbnRzLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL3J1bnRpbWUvY29uc3RhbnRzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLDRFQUE0RTtBQUM1RSw0RUFBNEU7QUFDNUUseUVBQXlFO0FBQ3pFLG9EQUFvRDtBQUNwRCxFQUFFO0FBQ0Ysa0RBQWtEO0FBQ2xELDJFQUEyRTtBQUMzRSwrREFBK0Q7QUFDL0Qsd0VBQXdFO0FBQ3hFLEVBQUU7QUFDRiw0RUFBNEU7QUFDNUUscURBQXFEO0FBQ3JELE1BQU0sQ0FBQyxNQUFNLG9CQUFvQixHQUFHLEVBQUUsQ0FBQztBQUV2Qyx1RUFBdUU7QUFDdkUsOEVBQThFO0FBQzlFLG1FQUFtRTtBQUNuRSw0RUFBNEU7QUFDNUUsc0JBQXNCO0FBQ3RCLG9GQUFvRjtBQUNwRixpRUFBaUU7QUFDakUsTUFBTSxDQUFDLE1BQU0saUJBQWlCLEdBQUcsT0FBTyxDQUFDIn0=

package/dist/runtime/resume-hook.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"resume-hook.d.ts","sourceRoot":"","sources":["../../src/runtime/resume-hook.ts"],"names":[],"mappings":"AAMA,OAAO,EACL,KAAK,IAAI,EAKV,MAAM,iBAAiB,CAAC;AACzB,OAAO,EAAE,KAAK,SAAS,EAAa,MAAM,kBAAkB,CAAC;AAoC7D;;;;;;GAMG;AACH,wBAAsB,cAAc,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAGjE;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,wBAAsB,UAAU,CAAC,CAAC,GAAG,GAAG,EACtC,WAAW,EAAE,MAAM,GAAG,IAAI,EAC1B,OAAO,EAAE,CAAC,EACV,qBAAqB,CAAC,EAAE,SAAS,GAChC,OAAO,CAAC,IAAI,CAAC,CAuGf;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AACH,wBAAsB,aAAa,CACjC,KAAK,EAAE,MAAM,EACb,OAAO,EAAE,OAAO,GACf,OAAO,CAAC,QAAQ,CAAC,CA0DnB"}
+{"version":3,"file":"resume-hook.d.ts","sourceRoot":"","sources":["../../src/runtime/resume-hook.ts"],"names":[],"mappings":"AAMA,OAAO,EACL,KAAK,IAAI,EAKV,MAAM,iBAAiB,CAAC;AAEzB,OAAO,EAAE,KAAK,SAAS,EAAa,MAAM,kBAAkB,CAAC;AAqC7D;;;;;;GAMG;AACH,wBAAsB,cAAc,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAGjE;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,wBAAsB,UAAU,CAAC,CAAC,GAAG,GAAG,EACtC,WAAW,EAAE,MAAM,GAAG,IAAI,EAC1B,OAAO,EAAE,CAAC,EACV,qBAAqB,CAAC,EAAE,SAAS,GAChC,OAAO,CAAC,IAAI,CAAC,CAmHf;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AACH,wBAAsB,aAAa,CACjC,KAAK,EAAE,MAAM,EACb,OAAO,EAAE,OAAO,GACf,OAAO,CAAC,QAAQ,CAAC,CA0DnB"}

package/dist/runtime/resume-hook.js

@@ -1,8 +1,9 @@
 import { waitUntil } from '@vercel/functions';
 import { ERROR_SLUGS, HookNotFoundError, WorkflowRuntimeError, } from '@workflow/errors';
 import { isLegacySpecVersion, SPEC_VERSION_CURRENT, } from '@workflow/world';
+import { getRunCapabilities } from '../capabilities.js';
 import { importKey } from '../encryption.js';
-import { dehydrateStepReturnValue, hydrateStepArguments, } from '../serialization.js';
+import { dehydrateStepReturnValue, hydrateStepArguments, SerializationFormat, } from '../serialization.js';
 import { WEBHOOK_RESPONSE_WRITABLE } from '../symbols.js';
 import * as Attribute from '../telemetry/semantic-conventions.js';
 import { getSpanContextForTraceCarrier, trace } from '../telemetry.js';
@@ -94,6 +95,15 @@ export async function resumeHook(tokenOrHook, payload, encryptionKeyOverride) {
                     ...Attribute.HookId(hook.hookId),
                     ...Attribute.WorkflowRunId(hook.runId),
                 });
+                // Check the target run's capabilities to ensure we encode the
+                // payload in a format the run's deployment can decode. For example,
+                // runs created before encryption support was added cannot decode
+                // the 'encr' serialization format.
+                const rawVersion = workflowRun.executionContext?.workflowCoreVersion;
+                const { supportedFormats } = getRunCapabilities(typeof rawVersion === 'string' ? rawVersion : undefined);
+                if (!supportedFormats.has(SerializationFormat.ENCRYPTED)) {
+                    encryptionKey = undefined;
+                }
                 // Dehydrate the payload for storage
                 const ops = [];
                 const v1Compat = isLegacySpecVersion(hook.specVersion);
@@ -228,4 +238,4 @@ export async function resumeWebhook(token, request) {
     }
     return response;
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"resume-hook.js","sourceRoot":"","sources":["../../src/runtime/resume-hook.ts"],"names":[],"mappings":"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"}

package/dist/runtime/start.js

@@ -18,7 +18,7 @@ export async function start(workflow, argsOrOptions, options) {
         // @ts-expect-error this field is added by our client transform
         const workflowName = workflow?.workflowId;
         if (!workflowName) {
-            throw new WorkflowRuntimeError(`'start' received an invalid workflow function. Ensure the Workflow Development Kit is configured correctly and the function includes a 'use workflow' directive.`, { slug: 'start-invalid-workflow-function' });
+            throw new WorkflowRuntimeError(`'start' received an invalid workflow function. Ensure the Workflow SDK is configured correctly and the function includes a 'use workflow' directive.`, { slug: 'start-invalid-workflow-function' });
         }
         return trace(`workflow.start ${workflowName}`, async (span) => {
             span?.setAttributes({
@@ -109,4 +109,4 @@ export async function start(workflow, argsOrOptions, options) {
         });
     });
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic3RhcnQuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvcnVudGltZS9zdGFydC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsU0FBUyxFQUFFLE1BQU0sbUJBQW1CLENBQUM7QUFDOUMsT0FBTyxFQUFFLG9CQUFvQixFQUFFLE1BQU0sa0JBQWtCLENBQUM7QUFFeEQsT0FBTyxFQUFFLG1CQUFtQixFQUFFLG9CQUFvQixFQUFFLE1BQU0saUJBQWlCLENBQUM7QUFDNUUsT0FBTyxFQUFFLGdCQUFnQixFQUFFLE1BQU0sTUFBTSxDQUFDO0FBQ3hDLE9BQU8sRUFBRSxTQUFTLEVBQUUsTUFBTSxrQkFBa0IsQ0FBQztBQUU3QyxPQUFPLEVBQUUsMEJBQTBCLEVBQUUsTUFBTSxxQkFBcUIsQ0FBQztBQUNqRSxPQUFPLEtBQUssU0FBUyxNQUFNLHNDQUFzQyxDQUFDO0FBQ2xFLE9BQU8sRUFBRSxxQkFBcUIsRUFBRSxLQUFLLEVBQUUsTUFBTSxpQkFBaUIsQ0FBQztBQUMvRCxPQUFPLEVBQUUsV0FBVyxFQUFFLE1BQU0sWUFBWSxDQUFDO0FBQ3pDLE9BQU8sRUFBRSxPQUFPLElBQUksbUJBQW1CLEVBQUUsTUFBTSxlQUFlLENBQUM7QUFDL0QsT0FBTyxFQUFFLG9CQUFvQixFQUFFLE1BQU0sY0FBYyxDQUFDO0FBQ3BELE9BQU8sRUFBRSxHQUFHLEVBQUUsTUFBTSxVQUFVLENBQUM7QUFDL0IsT0FBTyxFQUFFLFFBQVEsRUFBRSxNQUFNLFlBQVksQ0FBQztBQUV0QyxzREFBc0Q7QUFDdEQsTUFBTSxJQUFJLEdBQUcsZ0JBQWdCLEVBQUUsQ0FBQztBQTBEaEMsTUFBTSxDQUFDLEtBQUssVUFBVSxLQUFLLENBQ3pCLFFBQTZELEVBQzdELGFBQW9DLEVBQ3BDLE9BQXNCO0lBRXRCLE9BQU8sTUFBTSxXQUFXLENBQUMsR0FBRyxFQUFFO1FBQzVCLCtEQUErRDtRQUMvRCxNQUFNLFlBQVksR0FBRyxRQUFRLEVBQUUsVUFBVSxDQUFDO1FBRTFDLElBQUksQ0FBQyxZQUFZLEVBQUUsQ0FBQztZQUNsQixNQUFNLElBQUksb0JBQW9CLENBQzVCLHNKQUFzSixFQUN0SixFQUFFLElBQUksRUFBRSxpQ0FBaUMsRUFBRSxDQUM1QyxDQUFDO1FBQ0osQ0FBQztRQUVELE9BQU8sS0FBSyxDQUFDLGtCQUFrQixZQUFZLEVBQUUsRUFBRSxLQUFLLEVBQUUsSUFBSSxFQUFFLEVBQUU7WUFDNUQsSUFBSSxFQUFFLGFBQWEsQ0FBQztnQkFDbEIsR0FBRyxTQUFTLENBQUMsWUFBWSxDQUFDLFlBQVksQ0FBQztnQkFDdkMsR0FBRyxTQUFTLENBQUMsaUJBQWlCLENBQUMsT0FBTyxDQUFDO2FBQ3hDLENBQUMsQ0FBQztZQUVILElBQUksSUFBSSxHQUFtQixFQUFFLENBQUM7WUFDOUIsSUFBSSxJQUFJLEdBQWlCLE9BQU8sSUFBSSxFQUFFLENBQUM7WUFDdkMsSUFBSSxLQUFLLENBQUMsT0FBTyxDQUFDLGFBQWEsQ0FBQyxFQUFFLENBQUM7Z0JBQ2pDLElBQUksR0FBRyxhQUErQixDQUFDO1lBQ3pDLENBQUM7aUJBQU0sSUFBSSxPQUFPLGFBQWEsS0FBSyxRQUFRLEVBQUUsQ0FBQztnQkFDN0MsSUFBSSxHQUFHLGFBQWEsQ0FBQztZQUN2QixDQUFDO1lBRUQsSUFBSSxFQUFFLGFBQWEsQ0FBQztnQkFDbEIsR0FBRyxTQUFTLENBQUMsc0JBQXNCLENBQUMsSUFBSSxDQUFDLE1BQU0sQ0FBQzthQUNqRCxDQUFDLENBQUM7WUFFSCxNQUFNLEtBQUssR0FBRyxJQUFJLEVBQUUsS0FBSyxJQUFJLFFBQVEsRUFBRSxDQUFDO1lBQ3hDLElBQUksWUFBWSxHQUFHLElBQUksQ0FBQyxZQUFZLElBQUksQ0FBQyxNQUFNLEtBQUssQ0FBQyxlQUFlLEVBQUUsQ0FBQyxDQUFDO1lBRXhFLHNFQUFzRTtZQUN0RSxzRUFBc0U7WUFDdEUsNENBQTRDO1lBQzVDLElBQUksWUFBWSxLQUFLLFFBQVEsRUFBRSxDQUFDO2dCQUM5QixJQUFJLENBQUMsS0FBSyxDQUFDLHlCQUF5QixFQUFFLENBQUM7b0JBQ3JDLE1BQU0sSUFBSSxvQkFBb0IsQ0FDNUIsb0ZBQW9GLENBQ3JGLENBQUM7Z0JBQ0osQ0FBQztnQkFDRCxZQUFZLEdBQUcsTUFBTSxLQUFLLENBQUMseUJBQXlCLEVBQUUsQ0FBQztZQUN6RCxDQUFDO1lBRUQsTUFBTSxHQUFHLEdBQW9CLEVBQUUsQ0FBQztZQUVoQyxnRUFBZ0U7WUFDaEUscUZBQXFGO1lBQ3JGLE1BQU0sS0FBSyxHQUFHLFFBQVEsSUFBSSxFQUFFLEVBQUUsQ0FBQztZQUUvQixxRUFBcUU7WUFDckUsTUFBTSxZQUFZLEdBQUcsTUFBTSxxQkFBcUIsRUFBRSxDQUFDO1lBRW5ELE1BQU0sV0FBVyxHQUFHLElBQUksQ0FBQyxXQUFXLElBQUksb0JBQW9CLENBQUM7WUFDN0QsTUFBTSxRQUFRLEdBQUcsbUJBQW1CLENBQUMsV0FBVyxDQUFDLENBQUM7WUFFbEQscUVBQXFFO1lBQ3JFLG9FQUFvRTtZQUNwRSxxRUFBcUU7WUFDckUsdUVBQXVFO1lBQ3ZFLG1FQUFtRTtZQUNuRSwwRUFBMEU7WUFDMUUsdUVBQXVFO1lBQ3ZFLE1BQU0sTUFBTSxHQUFHLE1BQU0sS0FBSyxDQUFDLHNCQUFzQixFQUFFLENBQUMsS0FBSyxFQUFFO2dCQUN6RCxHQUFHLElBQUk7Z0JBQ1AsWUFBWTthQUNiLENBQUMsQ0FBQztZQUNILE1BQU0sYUFBYSxHQUFHLE1BQU0sQ0FBQyxDQUFDLENBQUMsTUFBTSxTQUFTLENBQUMsTUFBTSxDQUFDLENBQUMsQ0FBQyxDQUFDLFNBQVMsQ0FBQztZQUVuRSxnRUFBZ0U7WUFDaEUsOERBQThEO1lBQzlELE1BQU0saUJBQWlCLEdBQUcsTUFBTSwwQkFBMEIsQ0FDeEQsSUFBSSxFQUNKLEtBQUssRUFDTCxhQUFhLEVBQ2IsR0FBRyxFQUNILFVBQVUsRUFDVixRQUFRLENBQ1QsQ0FBQztZQUNGLE1BQU0sTUFBTSxHQUFHLE1BQU0sS0FBSyxDQUFDLE1BQU0sQ0FBQyxNQUFNLENBQ3RDLEtBQUssRUFDTDtnQkFDRSxTQUFTLEVBQUUsYUFBYTtnQkFDeEIsV0FBVztnQkFDWCxTQUFTLEVBQUU7b0JBQ1QsWUFBWSxFQUFFLFlBQVk7b0JBQzFCLFlBQVksRUFBRSxZQUFZO29CQUMxQixLQUFLLEVBQUUsaUJBQWlCO29CQUN4QixnQkFBZ0IsRUFBRSxFQUFFLFlBQVksRUFBRSxtQkFBbUIsRUFBRTtpQkFDeEQ7YUFDRixFQUNELEVBQUUsUUFBUSxFQUFFLENBQ2IsQ0FBQztZQUVGLGtDQUFrQztZQUNsQyxJQUFJLENBQUMsTUFBTSxDQUFDLEdBQUcsRUFBRSxDQUFDO2dCQUNoQixNQUFNLElBQUksb0JBQW9CLENBQzVCLDBEQUEwRCxDQUMzRCxDQUFDO1lBQ0osQ0FBQztZQUVELG1DQUFtQztZQUNuQyxJQUFJLENBQUMsUUFBUSxJQUFJLE1BQU0sQ0FBQyxHQUFHLENBQUMsS0FBSyxLQUFLLEtBQUssRUFBRSxDQUFDO2dCQUM1QyxNQUFNLElBQUksb0JBQW9CLENBQzVCLDREQUE0RCxLQUFLLFNBQVMsTUFBTSxDQUFDLEdBQUcsQ0FBQyxLQUFLLEVBQUUsQ0FDN0YsQ0FBQztZQUNKLENBQUM7WUFFRCxTQUFTLENBQ1AsT0FBTyxDQUFDLEdBQUcsQ0FBQyxHQUFHLENBQUMsQ0FBQyxLQUFLLENBQUMsQ0FBQyxHQUFHLEVBQUUsRUFBRTtnQkFDN0Isb0ZBQW9GO2dCQUNwRixNQUFNLFlBQVksR0FDaEIsR0FBRyxFQUFFLElBQUksS0FBSyxZQUFZLElBQUksR0FBRyxFQUFFLElBQUksS0FBSyxpQkFBaUIsQ0FBQztnQkFDaEUsSUFBSSxDQUFDLFlBQVk7b0JBQUUsTUFBTSxHQUFHLENBQUM7WUFDL0IsQ0FBQyxDQUFDLENBQ0gsQ0FBQztZQUVGLElBQUksRUFBRSxhQUFhLENBQUM7Z0JBQ2xCLEdBQUcsU0FBUyxDQUFDLGFBQWEsQ0FBQyxLQUFLLENBQUM7Z0JBQ2pDLEdBQUcsU0FBUyxDQUFDLGlCQUFpQixDQUFDLE1BQU0sQ0FBQyxHQUFHLENBQUMsTUFBTSxDQUFDO2dCQUNqRCxHQUFHLFNBQVMsQ0FBQyxZQUFZLENBQUMsWUFBWSxDQUFDO2FBQ3hDLENBQUMsQ0FBQztZQUVILE1BQU0sS0FBSyxDQUFDLEtBQUssQ0FDZixvQkFBb0IsQ0FBQyxZQUFZLENBQUMsRUFDbEM7Z0JBQ0UsS0FBSztnQkFDTCxZQUFZO2FBQ21CLEVBQ2pDO2dCQUNFLFlBQVk7YUFDYixDQUNGLENBQUM7WUFFRixPQUFPLElBQUksR0FBRyxDQUFVLEtBQUssQ0FBQyxDQUFDO1FBQ2pDLENBQUMsQ0FBQyxDQUFDO0lBQ0wsQ0FBQyxDQUFDLENBQUM7QUFDTCxDQUFDIn0=

package/dist/runtime.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"runtime.d.ts","sourceRoot":"","sources":["../src/runtime.ts"],"names":[],"mappings":"AASA,OAAO,EACL,KAAK,KAAK,EAGV,KAAK,WAAW,EACjB,MAAM,iBAAiB,CAAC;AAyBzB,YAAY,EAAE,KAAK,EAAE,WAAW,EAAE,CAAC;AACnC,OAAO,EAAE,kBAAkB,EAAE,MAAM,aAAa,CAAC;AACjD,OAAO,EACL,KAAK,mBAAmB,EACxB,KAAK,kBAAkB,EACvB,KAAK,iBAAiB,EACtB,WAAW,GACZ,MAAM,sBAAsB,CAAC;AAC9B,OAAO,EACL,cAAc,EACd,UAAU,EACV,aAAa,GACd,MAAM,0BAA0B,CAAC;AAClC,OAAO,EACL,MAAM,EACN,GAAG,EACH,KAAK,sBAAsB,EAC3B,KAAK,6BAA6B,GACnC,MAAM,kBAAkB,CAAC;AAC1B,OAAO,EACL,SAAS,EACT,WAAW,EACX,KAAK,iBAAiB,EACtB,KAAK,kBAAkB,EACvB,UAAU,EACV,uBAAuB,EACvB,YAAY,EACZ,KAAK,gBAAgB,EACrB,KAAK,eAAe,EACpB,SAAS,GACV,MAAM,mBAAmB,CAAC;AAC3B,OAAO,EAAE,KAAK,YAAY,EAAE,KAAK,EAAE,MAAM,oBAAoB,CAAC;AAC9D,OAAO,EAAE,cAAc,EAAE,MAAM,2BAA2B,CAAC;AAC3D,OAAO,EACL,WAAW,EACX,QAAQ,EACR,gBAAgB,EAChB,QAAQ,GACT,MAAM,oBAAoB,CAAC;AAE5B;;;;;;;GAOG;AACH,wBAAgB,kBAAkB,CAChC,YAAY,EAAE,MAAM,GACnB,CAAC,GAAG,EAAE,OAAO,KAAK,OAAO,CAAC,QAAQ,CAAC,CA2brC;AAID,wBAAgB,OAAO,SAAK"}
+{"version":3,"file":"runtime.d.ts","sourceRoot":"","sources":["../src/runtime.ts"],"names":[],"mappings":"AAOA,OAAO,EACL,KAAK,KAAK,EAGV,KAAK,WAAW,EACjB,MAAM,iBAAiB,CAAC;AA8BzB,YAAY,EAAE,KAAK,EAAE,WAAW,EAAE,CAAC;AACnC,OAAO,EAAE,kBAAkB,EAAE,MAAM,aAAa,CAAC;AACjD,OAAO,EACL,KAAK,mBAAmB,EACxB,KAAK,kBAAkB,EACvB,KAAK,iBAAiB,EACtB,WAAW,GACZ,MAAM,sBAAsB,CAAC;AAC9B,OAAO,EACL,cAAc,EACd,UAAU,EACV,aAAa,GACd,MAAM,0BAA0B,CAAC;AAClC,OAAO,EACL,MAAM,EACN,GAAG,EACH,KAAK,sBAAsB,EAC3B,KAAK,6BAA6B,GACnC,MAAM,kBAAkB,CAAC;AAC1B,OAAO,EACL,SAAS,EACT,WAAW,EACX,KAAK,iBAAiB,EACtB,KAAK,kBAAkB,EACvB,UAAU,EACV,uBAAuB,EACvB,YAAY,EACZ,KAAK,gBAAgB,EACrB,KAAK,eAAe,EACpB,SAAS,GACV,MAAM,mBAAmB,CAAC;AAC3B,OAAO,EAAE,KAAK,YAAY,EAAE,KAAK,EAAE,MAAM,oBAAoB,CAAC;AAC9D,OAAO,EAAE,cAAc,EAAE,MAAM,2BAA2B,CAAC;AAC3D,OAAO,EACL,WAAW,EACX,QAAQ,EACR,gBAAgB,EAChB,QAAQ,GACT,MAAM,oBAAoB,CAAC;AAE5B;;;;;;;GAOG;AACH,wBAAgB,kBAAkB,CAChC,YAAY,EAAE,MAAM,GACnB,CAAC,GAAG,EAAE,OAAO,KAAK,OAAO,CAAC,QAAQ,CAAC,CAgfrC;AAID,wBAAgB,OAAO,SAAK"}

package/dist/runtime.js

@@ -1,11 +1,11 @@
 import { EntityConflictError, RUN_ERROR_CODES, RunExpiredError, WorkflowRuntimeError, } from '@workflow/errors';
-import { classifyRunError } from './classify-error.js';
-import { MAX_QUEUE_DELIVERIES } from './runtime/constants.js';
 import { parseWorkflowName } from '@workflow/utils/parse-name';
 import { SPEC_VERSION_CURRENT, WorkflowInvokePayloadSchema, } from '@workflow/world';
+import { classifyRunError } from './classify-error.js';
 import { importKey } from './encryption.js';
 import { WorkflowSuspension } from './global.js';
 import { runtimeLogger } from './logger.js';
+import { MAX_QUEUE_DELIVERIES, REPLAY_TIMEOUT_MS, } from './runtime/constants.js';
 import { getAllWorkflowRunEvents, getQueueOverhead, handleHealthCheckMessage, parseHealthCheckPayload, withHealthCheck, } from './runtime/helpers.js';
 import { handleSuspension } from './runtime/suspension-handler.js';
 import { getWorld, getWorldHandlers } from './runtime/world.js';
@@ -86,6 +86,39 @@ export function workflowEntrypoint(workflowCode) {
             return;
         }
         const spanLinks = await linkToCurrentContext();
+        // --- Replay timeout guard ---
+        // If the replay takes longer than the timeout, fail the run and exit.
+        // This must be lower than the function's maxDuration to ensure
+        // the failure is recorded before the platform kills the function.
+        let replayTimeout;
+        if (process.env.VERCEL_URL !== undefined) {
+            replayTimeout = setTimeout(async () => {
+                runtimeLogger.error('Workflow replay exceeded timeout', {
+                    workflowRunId: runId,
+                    timeoutMs: REPLAY_TIMEOUT_MS,
+                });
+                try {
+                    const world = getWorld();
+                    await world.events.create(runId, {
+                        eventType: 'run_failed',
+                        specVersion: SPEC_VERSION_CURRENT,
+                        eventData: {
+                            error: {
+                                message: `Workflow replay exceeded maximum duration (${REPLAY_TIMEOUT_MS / 1000}s)`,
+                            },
+                            errorCode: RUN_ERROR_CODES.REPLAY_TIMEOUT,
+                        },
+                    }, { requestId });
+                }
+                catch {
+                    // Best effort — process exits regardless
+                }
+                // Note that this also prevents the runtime to acking the queue message,
+                // so the queue will call back once, after which a 410 will get it to exit early.
+                process.exit(1);
+            }, REPLAY_TIMEOUT_MS);
+            replayTimeout.unref();
+        }
         // Invoke user workflow within the propagated trace context and baggage
         return await withTraceContext(traceContext, async () => {
             // Set workflow context as baggage for automatic propagation
@@ -108,33 +141,40 @@ export function workflowEntrypoint(workflowCode) {
                         ...Attribute.WorkflowTracePropagated(!!traceContext),
                     });
                     let workflowStartedAt = -1;
-                    let workflowRun = await world.runs.get(runId);
+                    let workflowRun;
+                    // Pre-loaded events from the run_started response.
+                    // When present, we skip the events.list call to reduce TTFB.
+                    let preloadedEvents;
                     // --- Infrastructure: prepare the run state ---
+                    // Always call run_started directly — this both transitions
+                    // the run to 'running' AND returns the run entity, saving
+                    // a separate runs.get round-trip.
+                    // Contract: events.create('run_started') must be idempotent
+                    // for runs already in 'running' status (return the run
+                    // without error), not just for pending → running transitions.
                     // Network/server errors propagate to the queue handler for retry.
                     // WorkflowRuntimeError (data integrity issues) are fatal and
                     // produce run_failed since retrying won't fix them.
                     try {
-                        if (workflowRun.status === 'pending') {
-                            // Transition run to 'running' via event (event-sourced architecture)
-                            const result = await world.events.create(runId, {
-                                eventType: 'run_started',
-                                specVersion: SPEC_VERSION_CURRENT,
-                            }, { requestId });
-                            // Use the run entity from the event response (no extra get call needed)
-                            if (!result.run) {
-                                throw new WorkflowRuntimeError(`Event creation for 'run_started' did not return the run entity for run "${runId}"`);
-                            }
-                            workflowRun = result.run;
+                        const result = await world.events.create(runId, {
+                            eventType: 'run_started',
+                            specVersion: SPEC_VERSION_CURRENT,
+                        }, { requestId });
+                        if (!result.run) {
+                            throw new WorkflowRuntimeError(`Event creation for 'run_started' did not return the run entity for run "${runId}"`);
+                        }
+                        workflowRun = result.run;
+                        // If the world returned events, use them to skip
+                        // the initial events.list call and reduce TTFB.
+                        if (result.events && result.events.length > 0) {
+                            preloadedEvents = result.events;
                         }
-                        // At this point, the workflow is "running" and `startedAt` should
-                        // definitely be set.
                         if (!workflowRun.startedAt) {
                             throw new WorkflowRuntimeError(`Workflow run "${runId}" has no "startedAt" timestamp`);
                         }
                     }
                     catch (err) {
                         // Run was concurrently completed/failed/cancelled
-                        // between the GET and the run_started event creation
                         if (EntityConflictError.is(err) || RunExpiredError.is(err)) {
                             runtimeLogger.info('Run already finished during setup, skipping', { workflowRunId: runId, message: err.message });
                             return;
@@ -183,8 +223,11 @@ export function workflowEntrypoint(workflowCode) {
                         // the replaying the workflow is itself failing.
                         return;
                     }
-                    // Load all events into memory before running
-                    const events = await getAllWorkflowRunEvents(workflowRun.runId);
+                    // Load all events into memory before running.
+                    // If we got pre-loaded events from the run_started response,
+                    // skip the events.list round-trip to reduce TTFB.
+                    const events = preloadedEvents ??
+                        (await getAllWorkflowRunEvents(workflowRun.runId));
                     // Check for any elapsed waits and create wait_completed events
                     const now = Date.now();
                     // Pre-compute completed correlation IDs for O(n) lookup instead of O(n²)
@@ -358,6 +401,10 @@ export function workflowEntrypoint(workflowCode) {
                     });
                 }); // End trace
             }); // End withWorkflowBaggage
+        }).finally(() => {
+            if (replayTimeout) {
+                clearTimeout(replayTimeout);
+            }
         }); // End withTraceContext
     });
     return withHealthCheck(handler);
@@ -365,4 +412,4 @@ export function workflowEntrypoint(workflowCode) {
 // this is a no-op placeholder as the client is
 // expecting this to be present but we aren't actually using it
 export function runStep() { }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"runtime.js","sourceRoot":"","sources":["../src/runtime.ts"],"names":[],"mappings":"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"}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"runtime.js","sourceRoot":"","sources":["../src/runtime.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,mBAAmB,EACnB,eAAe,EACf,eAAe,EACf,oBAAoB,GACrB,MAAM,kBAAkB,CAAC;AAC1B,OAAO,EAAE,iBAAiB,EAAE,MAAM,4BAA4B,CAAC;AAC/D,OAAO,EAEL,oBAAoB,EACpB,2BAA2B,GAE5B,MAAM,iBAAiB,CAAC;AACzB,OAAO,EAAE,gBAAgB,EAAE,MAAM,qBAAqB,CAAC;AACvD,OAAO,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AAC5C,OAAO,EAAE,kBAAkB,EAAE,MAAM,aAAa,CAAC;AACjD,OAAO,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AAC5C,OAAO,EACL,oBAAoB,EACpB,iBAAiB,GAClB,MAAM,wBAAwB,CAAC;AAChC,OAAO,EACL,uBAAuB,EACvB,gBAAgB,EAChB,wBAAwB,EACxB,uBAAuB,EACvB,eAAe,GAChB,MAAM,sBAAsB,CAAC;AAC9B,OAAO,EAAE,gBAAgB,EAAE,MAAM,iCAAiC,CAAC;AACnE,OAAO,EAAE,QAAQ,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAC;AAChE,OAAO,EAAE,eAAe,EAAE,MAAM,iBAAiB,CAAC;AAClD,OAAO,KAAK,SAAS,MAAM,qCAAqC,CAAC;AACjE,OAAO,EACL,oBAAoB,EACpB,KAAK,EACL,gBAAgB,EAChB,mBAAmB,GACpB,MAAM,gBAAgB,CAAC;AACxB,OAAO,EAAE,YAAY,EAAE,aAAa,EAAE,qBAAqB,EAAE,MAAM,YAAY,CAAC;AAChF,OAAO,EAAE,8BAA8B,EAAE,MAAM,WAAW,CAAC;AAC3D,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAG5C,OAAO,EAAE,kBAAkB,EAAE,MAAM,aAAa,CAAC;AACjD,OAAO,EAIL,WAAW,GACZ,MAAM,sBAAsB,CAAC;AAC9B,OAAO,EACL,cAAc,EACd,UAAU,EACV,aAAa,GACd,MAAM,0BAA0B,CAAC;AAClC,OAAO,EACL,MAAM,EACN,GAAG,GAGJ,MAAM,kBAAkB,CAAC;AAC1B,OAAO,EACL,SAAS,EACT,WAAW,EAGX,UAAU,EACV,uBAAuB,EACvB,YAAY,EAGZ,SAAS,GACV,MAAM,mBAAmB,CAAC;AAC3B,OAAO,EAAqB,KAAK,EAAE,MAAM,oBAAoB,CAAC;AAC9D,OAAO,EAAE,cAAc,EAAE,MAAM,2BAA2B,CAAC;AAC3D,OAAO,EACL,WAAW,EACX,QAAQ,EACR,gBAAgB,EAChB,QAAQ,GACT,MAAM,oBAAoB,CAAC;AAE5B;;;;;;;GAOG;AACH,MAAM,UAAU,kBAAkB,CAChC,YAAoB;IAEpB,MAAM,OAAO,GAAG,gBAAgB,EAAE,CAAC,kBAAkB,CACnD,iBAAiB,EACjB,KAAK,EAAE,QAAQ,EAAE,QAAQ,EAAE,EAAE;QAC3B,0CAA0C;QAC1C,yFAAyF;QACzF,yFAAyF;QACzF,oFAAoF;QACpF,MAAM,WAAW,GAAG,uBAAuB,CAAC,QAAQ,CAAC,CAAC;QACtD,IAAI,WAAW,EAAE,CAAC;YAChB,MAAM,wBAAwB,CAAC,WAAW,EAAE,UAAU,CAAC,CAAC;YACxD,OAAO;QACT,CAAC;QAED,MAAM,EACJ,KAAK,EACL,YAAY,EAAE,YAAY,EAC1B,WAAW,GACZ,GAAG,2BAA2B,CAAC,KAAK,CAAC,QAAQ,CAAC,CAAC;QAChD,MAAM,EAAE,SAAS,EAAE,GAAG,QAAQ,CAAC;QAC/B,gDAAgD;QAChD,MAAM,YAAY,GAAG,QAAQ,CAAC,SAAS,CAAC,KAAK,CAAC,iBAAiB,CAAC,MAAM,CAAC,CAAC;QAExE,6BAA6B;QAC7B,8DAA8D;QAC9D,4EAA4E;QAC5E,uEAAuE;QACvE,2EAA2E;QAC3E,6EAA6E;QAC7E,6DAA6D;QAC7D,IAAI,QAAQ,CAAC,OAAO,GAAG,oBAAoB,EAAE,CAAC;YAC5C,aAAa,CAAC,KAAK,CACjB,6CAA6C,QAAQ,CAAC,OAAO,IAAI,oBAAoB,GAAG,EACxF,EAAE,aAAa,EAAE,KAAK,EAAE,YAAY,EAAE,OAAO,EAAE,QAAQ,CAAC,OAAO,EAAE,CAClE,CAAC;YACF,IAAI,CAAC;gBACH,MAAM,KAAK,GAAG,QAAQ,EAAE,CAAC;gBACzB,MAAM,KAAK,CAAC,MAAM,CAAC,MAAM,CACvB,KAAK,EACL;oBACE,SAAS,EAAE,YAAY;oBACvB,WAAW,EAAE,oBAAoB;oBACjC,SAAS,EAAE;wBACT,KAAK,EAAE;4BACL,OAAO,EAAE,+CAA+C,QAAQ,CAAC,OAAO,IAAI,oBAAoB,GAAG;yBACpG;wBACD,SAAS,EAAE,eAAe,CAAC,uBAAuB;qBACnD;iBACF,EACD,EAAE,SAAS,EAAE,CACd,CAAC;YACJ,CAAC;YAAC,OAAO,GAAG,EAAE,CAAC;gBACb,IAAI,mBAAmB,CAAC,EAAE,CAAC,GAAG,CAAC,IAAI,eAAe,CAAC,EAAE,CAAC,GAAG,CAAC,EAAE,CAAC;oBAC3D,qDAAqD;oBACrD,OAAO;gBACT,CAAC;gBACD,aAAa,CAAC,KAAK,CACjB,sCAAsC,QAAQ,CAAC,OAAO,sBAAsB;oBAC1E,kEAAkE;oBAClE,oEAAoE;oBACpE,yEAAyE;oBACzE,+EAA+E,EACjF;oBACE,aAAa,EAAE,KAAK;oBACpB,KAAK,EAAE,GAAG,YAAY,KAAK,CAAC,CAAC,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC,CAAC,MAAM,CAAC,GAAG,CAAC;oBACvD,OAAO,EAAE,QAAQ,CAAC,OAAO;iBAC1B,CACF,CAAC;YACJ,CAAC;YACD,OAAO;QACT,CAAC;QAED,MAAM,SAAS,GAAG,MAAM,oBAAoB,EAAE,CAAC;QAE/C,+BAA+B;QAC/B,sEAAsE;QACtE,+DAA+D;QAC/D,kEAAkE;QAClE,IAAI,aAAyC,CAAC;QAC9C,IAAI,OAAO,CAAC,GAAG,CAAC,UAAU,KAAK,SAAS,EAAE,CAAC;YACzC,aAAa,GAAG,UAAU,CAAC,KAAK,IAAI,EAAE;gBACpC,aAAa,CAAC,KAAK,CAAC,kCAAkC,EAAE;oBACtD,aAAa,EAAE,KAAK;oBACpB,SAAS,EAAE,iBAAiB;iBAC7B,CAAC,CAAC;gBACH,IAAI,CAAC;oBACH,MAAM,KAAK,GAAG,QAAQ,EAAE,CAAC;oBACzB,MAAM,KAAK,CAAC,MAAM,CAAC,MAAM,CACvB,KAAK,EACL;wBACE,SAAS,EAAE,YAAY;wBACvB,WAAW,EAAE,oBAAoB;wBACjC,SAAS,EAAE;4BACT,KAAK,EAAE;gCACL,OAAO,EAAE,8CAA8C,iBAAiB,GAAG,IAAI,IAAI;6BACpF;4BACD,SAAS,EAAE,eAAe,CAAC,cAAc;yBAC1C;qBACF,EACD,EAAE,SAAS,EAAE,CACd,CAAC;gBACJ,CAAC;gBAAC,MAAM,CAAC;oBACP,yCAAyC;gBAC3C,CAAC;gBACD,wEAAwE;gBACxE,iFAAiF;gBACjF,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;YAClB,CAAC,EAAE,iBAAiB,CAAC,CAAC;YACtB,aAAa,CAAC,KAAK,EAAE,CAAC;QACxB,CAAC;QAED,uEAAuE;QACvE,OAAO,MAAM,gBAAgB,CAAC,YAAY,EAAE,KAAK,IAAI,EAAE;YACrD,4DAA4D;YAC5D,OAAO,MAAM,mBAAmB,CAC9B,EAAE,aAAa,EAAE,KAAK,EAAE,YAAY,EAAE,EACtC,KAAK,IAAI,EAAE;gBACT,MAAM,KAAK,GAAG,QAAQ,EAAE,CAAC;gBACzB,OAAO,KAAK,CACV,YAAY,YAAY,EAAE,EAC1B,EAAE,KAAK,EAAE,SAAS,EAAE,EACpB,KAAK,EAAE,IAAI,EAAE,EAAE;oBACb,IAAI,EAAE,aAAa,CAAC;wBAClB,GAAG,SAAS,CAAC,YAAY,CAAC,YAAY,CAAC;wBACvC,GAAG,SAAS,CAAC,iBAAiB,CAAC,SAAS,CAAC;wBACzC,sCAAsC;wBACtC,GAAG,SAAS,CAAC,eAAe,CAAC,cAAc,CAAC;wBAC5C,GAAG,SAAS,CAAC,wBAAwB,CAAC,QAAQ,CAAC,SAAS,CAAC;wBACzD,GAAG,SAAS,CAAC,kBAAkB,CAAC,QAAQ,CAAC,SAAS,CAAC;wBACnD,GAAG,SAAS,CAAC,sBAAsB,CAAC,SAAS,CAAC;wBAC9C,GAAG,gBAAgB,CAAC,EAAE,WAAW,EAAE,CAAC;qBACrC,CAAC,CAAC;oBAEH,iEAAiE;oBAEjE,IAAI,EAAE,aAAa,CAAC;wBAClB,GAAG,SAAS,CAAC,aAAa,CAAC,KAAK,CAAC;wBACjC,GAAG,SAAS,CAAC,uBAAuB,CAAC,CAAC,CAAC,YAAY,CAAC;qBACrD,CAAC,CAAC;oBAEH,IAAI,iBAAiB,GAAG,CAAC,CAAC,CAAC;oBAC3B,IAAI,WAAoC,CAAC;oBACzC,mDAAmD;oBACnD,6DAA6D;oBAC7D,IAAI,eAAoC,CAAC;oBAEzC,gDAAgD;oBAChD,2DAA2D;oBAC3D,0DAA0D;oBAC1D,kCAAkC;oBAClC,4DAA4D;oBAC5D,uDAAuD;oBACvD,8DAA8D;oBAC9D,kEAAkE;oBAClE,6DAA6D;oBAC7D,oDAAoD;oBACpD,IAAI,CAAC;wBACH,MAAM,MAAM,GAAG,MAAM,KAAK,CAAC,MAAM,CAAC,MAAM,CACtC,KAAK,EACL;4BACE,SAAS,EAAE,aAAa;4BACxB,WAAW,EAAE,oBAAoB;yBAClC,EACD,EAAE,SAAS,EAAE,CACd,CAAC;wBACF,IAAI,CAAC,MAAM,CAAC,GAAG,EAAE,CAAC;4BAChB,MAAM,IAAI,oBAAoB,CAC5B,2EAA2E,KAAK,GAAG,CACpF,CAAC;wBACJ,CAAC;wBACD,WAAW,GAAG,MAAM,CAAC,GAAG,CAAC;wBAEzB,iDAAiD;wBACjD,gDAAgD;wBAChD,IAAI,MAAM,CAAC,MAAM,IAAI,MAAM,CAAC,MAAM,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;4BAC9C,eAAe,GAAG,MAAM,CAAC,MAAM,CAAC;wBAClC,CAAC;wBAED,IAAI,CAAC,WAAW,CAAC,SAAS,EAAE,CAAC;4BAC3B,MAAM,IAAI,oBAAoB,CAC5B,iBAAiB,KAAK,gCAAgC,CACvD,CAAC;wBACJ,CAAC;oBACH,CAAC;oBAAC,OAAO,GAAG,EAAE,CAAC;wBACb,kDAAkD;wBAClD,IAAI,mBAAmB,CAAC,EAAE,CAAC,GAAG,CAAC,IAAI,eAAe,CAAC,EAAE,CAAC,GAAG,CAAC,EAAE,CAAC;4BAC3D,aAAa,CAAC,IAAI,CAChB,6CAA6C,EAC7C,EAAE,aAAa,EAAE,KAAK,EAAE,OAAO,EAAE,GAAG,CAAC,OAAO,EAAE,CAC/C,CAAC;4BACF,OAAO;wBACT,CAAC;wBACD,IAAI,GAAG,YAAY,oBAAoB,EAAE,CAAC;4BACxC,aAAa,CAAC,KAAK,CACjB,2CAA2C,EAC3C,EAAE,aAAa,EAAE,KAAK,EAAE,KAAK,EAAE,GAAG,CAAC,OAAO,EAAE,CAC7C,CAAC;4BACF,IAAI,CAAC;gCACH,MAAM,KAAK,CAAC,MAAM,CAAC,MAAM,CACvB,KAAK,EACL;oCACE,SAAS,EAAE,YAAY;oCACvB,WAAW,EAAE,oBAAoB;oCACjC,SAAS,EAAE;wCACT,KAAK,EAAE;4CACL,OAAO,EAAE,GAAG,CAAC,OAAO;4CACpB,KAAK,EAAE,GAAG,CAAC,KAAK;yCACjB;wCACD,SAAS,EAAE,eAAe,CAAC,aAAa;qCACzC;iCACF,EACD,EAAE,SAAS,EAAE,CACd,CAAC;4BACJ,CAAC;4BAAC,OAAO,OAAO,EAAE,CAAC;gCACjB,IACE,mBAAmB,CAAC,EAAE,CAAC,OAAO,CAAC;oCAC/B,eAAe,CAAC,EAAE,CAAC,OAAO,CAAC,EAC3B,CAAC;oCACD,OAAO;gCACT,CAAC;gCACD,MAAM,OAAO,CAAC;4BAChB,CAAC;4BACD,OAAO;wBACT,CAAC;wBACD,MAAM,GAAG,CAAC;oBACZ,CAAC;oBACD,iBAAiB,GAAG,CAAC,WAAW,CAAC,SAAS,CAAC;oBAE3C,IAAI,EAAE,aAAa,CAAC;wBAClB,GAAG,SAAS,CAAC,iBAAiB,CAAC,WAAW,CAAC,MAAM,CAAC;wBAClD,GAAG,SAAS,CAAC,iBAAiB,CAAC,iBAAiB,CAAC;qBAClD,CAAC,CAAC;oBAEH,IAAI,WAAW,CAAC,MAAM,KAAK,SAAS,EAAE,CAAC;wBACrC,8DAA8D;wBAC9D,aAAa,CAAC,IAAI,CAChB,gDAAgD,EAChD;4BACE,aAAa,EAAE,KAAK;4BACpB,MAAM,EAAE,WAAW,CAAC,MAAM;yBAC3B,CACF,CAAC;wBAEF,8EAA8E;wBAC9E,+EAA+E;wBAC/E,gFAAgF;wBAChF,mFAAmF;wBACnF,gDAAgD;wBAEhD,OAAO;oBACT,CAAC;oBAED,8CAA8C;oBAC9C,6DAA6D;oBAC7D,kDAAkD;oBAClD,MAAM,MAAM,GACV,eAAe;wBACf,CAAC,MAAM,uBAAuB,CAAC,WAAW,CAAC,KAAK,CAAC,CAAC,CAAC;oBAErD,+DAA+D;oBAC/D,MAAM,GAAG,GAAG,IAAI,CAAC,GAAG,EAAE,CAAC;oBAEvB,yEAAyE;oBACzE,MAAM,gBAAgB,GAAG,IAAI,GAAG,CAC9B,MAAM;yBACH,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,SAAS,KAAK,gBAAgB,CAAC;yBAC/C,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,aAAa,CAAC,CAC/B,CAAC;oBAEF,yCAAyC;oBACzC,MAAM,eAAe,GAAG,MAAM;yBAC3B,MAAM,CACL,CAAC,CAAC,EAA6C,EAAE,CAC/C,CAAC,CAAC,SAAS,KAAK,cAAc;wBAC9B,CAAC,CAAC,aAAa,KAAK,SAAS;wBAC7B,CAAC,gBAAgB,CAAC,GAAG,CAAC,CAAC,CAAC,aAAa,CAAC;wBACtC,GAAG,IAAK,CAAC,CAAC,SAAS,CAAC,QAAiB,CAAC,OAAO,EAAE,CAClD;yBACA,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC;wBACX,SAAS,EAAE,gBAAyB;wBACpC,WAAW,EAAE,oBAAoB;wBACjC,aAAa,EAAE,CAAC,CAAC,aAAa;qBAC/B,CAAC,CAAC,CAAC;oBAEN,mCAAmC;oBACnC,KAAK,MAAM,SAAS,IAAI,eAAe,EAAE,CAAC;wBACxC,IAAI,CAAC;4BACH,MAAM,MAAM,GAAG,MAAM,KAAK,CAAC,MAAM,CAAC,MAAM,CAAC,KAAK,EAAE,SAAS,EAAE;gCACzD,SAAS;6BACV,CAAC,CAAC;4BACH,+DAA+D;4BAC/D,MAAM,CAAC,IAAI,CAAC,MAAM,CAAC,KAAM,CAAC,CAAC;wBAC7B,CAAC;wBAAC,OAAO,GAAG,EAAE,CAAC;4BACb,IAAI,mBAAmB,CAAC,EAAE,CAAC,GAAG,CAAC,EAAE,CAAC;gCAChC,aAAa,CAAC,IAAI,CAAC,kCAAkC,EAAE;oCACrD,aAAa,EAAE,KAAK;oCACpB,aAAa,EAAE,SAAS,CAAC,aAAa;iCACvC,CAAC,CAAC;gCACH,SAAS;4BACX,CAAC;4BACD,MAAM,GAAG,CAAC;wBACZ,CAAC;oBACH,CAAC;oBAED,uDAAuD;oBACvD,MAAM,MAAM,GACV,MAAM,KAAK,CAAC,sBAAsB,EAAE,CAAC,WAAW,CAAC,CAAC;oBACpD,MAAM,aAAa,GAAG,MAAM;wBAC1B,CAAC,CAAC,MAAM,SAAS,CAAC,MAAM,CAAC;wBACzB,CAAC,CAAC,SAAS,CAAC;oBAEd,8BAA8B;oBAC9B,6DAA6D;oBAC7D,8DAA8D;oBAC9D,2DAA2D;oBAC3D,IAAI,cAAuB,CAAC;oBAC5B,IAAI,CAAC;wBACH,cAAc,GAAG,MAAM,KAAK,CAC1B,iBAAiB,EACjB,EAAE,EACF,KAAK,EAAE,UAAU,EAAE,EAAE;4BACnB,UAAU,EAAE,aAAa,CAAC;gCACxB,GAAG,SAAS,CAAC,mBAAmB,CAAC,MAAM,CAAC,MAAM,CAAC;6BAChD,CAAC,CAAC;4BACH,OAAO,MAAM,WAAW,CACtB,YAAY,EACZ,WAAW,EACX,MAAM,EACN,aAAa,CACd,CAAC;wBACJ,CAAC,CACF,CAAC;oBACJ,CAAC;oBAAC,OAAO,GAAG,EAAE,CAAC;wBACb,2DAA2D;wBAC3D,IAAI,kBAAkB,CAAC,EAAE,CAAC,GAAG,CAAC,EAAE,CAAC;4BAC/B,MAAM,iBAAiB,GAAG,8BAA8B,CACtD,KAAK,EACL,GAAG,CAAC,SAAS,EACb,GAAG,CAAC,SAAS,EACb,GAAG,CAAC,SAAS,CACd,CAAC;4BACF,IAAI,iBAAiB,EAAE,CAAC;gCACtB,aAAa,CAAC,KAAK,CAAC,iBAAiB,CAAC,CAAC;4BACzC,CAAC;4BAED,MAAM,MAAM,GAAG,MAAM,gBAAgB,CAAC;gCACpC,UAAU,EAAE,GAAG;gCACf,KAAK;gCACL,GAAG,EAAE,WAAW;gCAChB,IAAI;gCACJ,SAAS;6BACV,CAAC,CAAC;4BAEH,IAAI,MAAM,CAAC,cAAc,KAAK,SAAS,EAAE,CAAC;gCACxC,OAAO,EAAE,cAAc,EAAE,MAAM,CAAC,cAAc,EAAE,CAAC;4BACnD,CAAC;4BAED,6CAA6C;4BAC7C,OAAO;wBACT,CAAC;wBAED,sDAAsD;wBACtD,sDAAsD;wBAEtD,2CAA2C;wBAC3C,IAAI,GAAG,YAAY,KAAK,EAAE,CAAC;4BACzB,IAAI,EAAE,eAAe,EAAE,CAAC,GAAG,CAAC,CAAC;wBAC/B,CAAC;wBAED,MAAM,eAAe,GAAG,MAAM,qBAAqB,CAAC,GAAG,CAAC,CAAC;wBACzD,MAAM,SAAS,GAAG,eAAe,CAAC,IAAI,IAAI,YAAY,CAAC,GAAG,CAAC,CAAC;wBAC5D,MAAM,YAAY,GAAG,eAAe,CAAC,OAAO,CAAC;wBAC7C,IAAI,UAAU,GAAG,eAAe,CAAC,KAAK,IAAI,aAAa,CAAC,GAAG,CAAC,CAAC;wBAE7D,wEAAwE;wBACxE,IAAI,UAAU,EAAE,CAAC;4BACf,MAAM,UAAU,GAAG,iBAAiB,CAAC,YAAY,CAAC,CAAC;4BACnD,MAAM,QAAQ,GACZ,UAAU,EAAE,eAAe,IAAI,YAAY,CAAC;4BAC9C,UAAU,GAAG,eAAe,CAC1B,UAAU,EACV,QAAQ,EACR,YAAY,CACb,CAAC;wBACJ,CAAC;wBAED,wDAAwD;wBACxD,sDAAsD;wBACtD,wCAAwC;wBACxC,MAAM,SAAS,GAAG,gBAAgB,CAAC,GAAG,CAAC,CAAC;wBAExC,aAAa,CAAC,KAAK,CAAC,8BAA8B,EAAE;4BAClD,aAAa,EAAE,KAAK;4BACpB,SAAS;4BACT,SAAS;4BACT,UAAU;yBACX,CAAC,CAAC;wBAEH,+DAA+D;wBAC/D,IAAI,CAAC;4BACH,MAAM,KAAK,CAAC,MAAM,CAAC,MAAM,CACvB,KAAK,EACL;gCACE,SAAS,EAAE,YAAY;gCACvB,WAAW,EAAE,oBAAoB;gCACjC,SAAS,EAAE;oCACT,KAAK,EAAE;wCACL,OAAO,EAAE,YAAY;wCACrB,KAAK,EAAE,UAAU;qCAClB;oCACD,SAAS;iCACV;6BACF,EACD,EAAE,SAAS,EAAE,CACd,CAAC;wBACJ,CAAC;wBAAC,OAAO,OAAO,EAAE,CAAC;4BACjB,IACE,mBAAmB,CAAC,EAAE,CAAC,OAAO,CAAC;gCAC/B,eAAe,CAAC,EAAE,CAAC,OAAO,CAAC,EAC3B,CAAC;gCACD,aAAa,CAAC,IAAI,CAChB,2DAA2D,EAC3D;oCACE,aAAa,EAAE,KAAK;oCACpB,OAAO,EAAE,OAAO,CAAC,OAAO;iCACzB,CACF,CAAC;gCACF,IAAI,EAAE,aAAa,CAAC;oCAClB,GAAG,SAAS,CAAC,iBAAiB,CAAC,SAAS,CAAC;oCACzC,GAAG,SAAS,CAAC,iBAAiB,CAAC,SAAS,CAAC;oCACzC,GAAG,SAAS,CAAC,oBAAoB,CAAC,YAAY,CAAC;oCAC/C,GAAG,SAAS,CAAC,SAAS,CAAC,SAAS,CAAC;iCAClC,CAAC,CAAC;gCACH,OAAO;4BACT,CAAC;iCAAM,CAAC;gCACN,MAAM,OAAO,CAAC;4BAChB,CAAC;wBACH,CAAC;wBAED,IAAI,EAAE,aAAa,CAAC;4BAClB,GAAG,SAAS,CAAC,iBAAiB,CAAC,QAAQ,CAAC;4BACxC,GAAG,SAAS,CAAC,iBAAiB,CAAC,SAAS,CAAC;4BACzC,GAAG,SAAS,CAAC,iBAAiB,CAAC,SAAS,CAAC;4BACzC,GAAG,SAAS,CAAC,oBAAoB,CAAC,YAAY,CAAC;4BAC/C,GAAG,SAAS,CAAC,SAAS,CAAC,SAAS,CAAC;yBAClC,CAAC,CAAC;wBACH,OAAO;oBACT,CAAC;oBAED,2CAA2C;oBAC3C,2DAA2D;oBAC3D,8DAA8D;oBAC9D,IAAI,CAAC;wBACH,MAAM,KAAK,CAAC,MAAM,CAAC,MAAM,CACvB,KAAK,EACL;4BACE,SAAS,EAAE,eAAe;4BAC1B,WAAW,EAAE,oBAAoB;4BACjC,SAAS,EAAE;gCACT,MAAM,EAAE,cAAc;6BACvB;yBACF,EACD,EAAE,SAAS,EAAE,CACd,CAAC;oBACJ,CAAC;oBAAC,OAAO,GAAG,EAAE,CAAC;wBACb,IAAI,mBAAmB,CAAC,EAAE,CAAC,GAAG,CAAC,IAAI,eAAe,CAAC,EAAE,CAAC,GAAG,CAAC,EAAE,CAAC;4BAC3D,aAAa,CAAC,IAAI,CAChB,8DAA8D,EAC9D;gCACE,aAAa,EAAE,KAAK;gCACpB,OAAO,EAAE,GAAG,CAAC,OAAO;6BACrB,CACF,CAAC;4BACF,OAAO;wBACT,CAAC;6BAAM,CAAC;4BACN,MAAM,GAAG,CAAC;wBACZ,CAAC;oBACH,CAAC;oBAED,IAAI,EAAE,aAAa,CAAC;wBAClB,GAAG,SAAS,CAAC,iBAAiB,CAAC,WAAW,CAAC;wBAC3C,GAAG,SAAS,CAAC,mBAAmB,CAAC,MAAM,CAAC,MAAM,CAAC;qBAChD,CAAC,CAAC;gBACL,CAAC,CACF,CAAC,CAAC,YAAY;YACjB,CAAC,CACF,CAAC,CAAC,0BAA0B;QAC/B,CAAC,CAAC,CAAC,OAAO,CAAC,GAAG,EAAE;YACd,IAAI,aAAa,EAAE,CAAC;gBAClB,YAAY,CAAC,aAAa,CAAC,CAAC;YAC9B,CAAC;QACH,CAAC,CAAC,CAAC,CAAC,uBAAuB;IAC7B,CAAC,CACF,CAAC;IAEF,OAAO,eAAe,CAAC,OAAO,CAAC,CAAC;AAClC,CAAC;AAED,+CAA+C;AAC/C,+DAA+D;AAC/D,MAAM,UAAU,OAAO,KAAI,CAAC"}

package/dist/version.d.ts

@@ -1,2 +1,2 @@
-export declare const version = "4.2.0-beta.74";
+export declare const version = "4.2.0-beta.76";
 //# sourceMappingURL=version.d.ts.map

package/dist/version.js

@@ -1,3 +1,3 @@
 // Generated by genversion.
-export const version = '4.2.0-beta.74';
+export const version = '4.2.0-beta.76';
 //# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidmVyc2lvbi5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uL3NyYy92ZXJzaW9uLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLDJCQUEyQjtBQUMzQixNQUFNLENBQUMsTUFBTSxPQUFPLEdBQUcsZUFBZSxDQUFBIn0=

package/docs/api-reference/create-webhook.mdx

@@ -13,6 +13,10 @@ Creates a webhook that can be used to suspend and resume a workflow run upon rec
 
 Webhooks provide a way for external systems to send HTTP requests directly to your workflow. Unlike hooks which accept arbitrary payloads, webhooks work with standard HTTP `Request` objects and can return HTTP `Response` objects.
 
+<Callout type="warn">
+`createWebhook()` creates a public endpoint at `/.well-known/workflow/v1/webhook/:token`, and the token in that URL is the only authorization performed for incoming requests resuming that webhook. This is convenient for prototypes and simple resume links because it avoids creating another route, but if you need stronger security, prefer [`createHook()`](/docs/api-reference/workflow/create-hook) behind your own route and authorize the request before calling [`resumeHook()`](/docs/api-reference/workflow-api/resume-hook) to avoid unauthenticated workflow resumptions.
+</Callout>
+
 ```ts lineNumbers
 import { createWebhook } from "workflow"
 

package/docs/foundations/hooks.mdx

@@ -221,6 +221,10 @@ While hooks are powerful, they require you to manually handle HTTP requests and
 
 When using Workflow SDK, webhooks are automatically wired up at `/.well-known/workflow/v1/webhook/:token` without any additional setup.
 
+<Callout type="warn">
+`createWebhook()` exposes a public route at `/.well-known/workflow/v1/webhook/:token`, and the token in that URL is the only authorization performed for incoming requests. This is convenient for prototypes and a simple developer experience because you can share the webhook URL (endpoint) without creating another route, but if you need stronger security, prefer [`createHook()`](/docs/api-reference/workflow/create-hook) behind your own route and authorize the request before calling [`resumeHook()`](/docs/api-reference/workflow-api/resume-hook) to avoid unauthenticated workflow resumptions.
+</Callout>
+
 <Callout type="info">
 See the full API reference for [`createWebhook()`](/docs/api-reference/workflow/create-webhook) for all available options.
 </Callout>

package/docs/foundations/serialization.mdx

@@ -190,7 +190,7 @@ async function doublePoint(point: Point) {
 ### Requirements
 
 <Callout type="warn">
-Both methods must be implemented as **static** methods on the class. Instance methods are not supported.
+`WORKFLOW_SERIALIZE` and `WORKFLOW_DESERIALIZE` must be implemented as **static** methods on the class. Defining them as instance methods is not supported.
 </Callout>
 
 - The data returned by `WORKFLOW_SERIALIZE` must itself be serializable (see [Supported Serializable Types](#supported-serializable-types))
@@ -205,9 +205,9 @@ The `WORKFLOW_SERIALIZE` and `WORKFLOW_DESERIALIZE` methods run inside the workf
 Keep these methods simple and focused on data transformation only.
 </Callout>
 
-### Complex Example
+### Instance Methods as Steps
 
-A class that uses Node.js APIs or other non-deterministic operations cannot be used directly inside a workflow function. The recommended approach is to make the class workflow-compatible by adding `"use step"` to its instance methods. The SWC compiler will strip the method bodies from the workflow bundle and replace them with proxy functions that invoke the method as a step — with full Node.js runtime access. The `this` context (the class instance) is automatically serialized and deserialized across the workflow/step boundary.
+In practice, many classes have methods that need Node.js APIs, perform network calls, or interact with databases — operations that are not allowed in the `"use workflow"` execution context. You can make these methods workflow-compatible by adding `"use step"` to them. The SWC compiler will strip the method bodies from the workflow bundle and replace them with proxy functions that invoke the method as a step — with full Node.js runtime access. The `this` context (the class instance) is automatically serialized and deserialized across the workflow/step boundary.
 
 This requires the class to implement `WORKFLOW_SERIALIZE` and `WORKFLOW_DESERIALIZE`, so that the instance can be passed to the step execution context.
 

package/docs/foundations/streaming.mdx

@@ -593,6 +593,7 @@ Stream errors don't trigger automatic retries for the producer step. Design your
 - [`sleep()` API Reference](/docs/api-reference/workflow/sleep) - Pause workflow execution for a duration
 - [`start()` API Reference](/docs/api-reference/workflow-api/start) - Start workflows and access the `Run` object
 - [`getRun()` API Reference](/docs/api-reference/workflow-api/get-run) - Retrieve runs and their streams later
+- [world.streams](/docs/api-reference/workflow-api/world/streams) - Low-level stream read/write/close via World SDK
 - [DurableAgent](/docs/api-reference/workflow-ai/durable-agent) - AI agents with built-in streaming support
 - [Errors and Retries](/docs/foundations/errors-and-retries) - Understanding error handling and retry behavior
 - [Serialization](/docs/foundations/serialization) - Understanding what data types can be passed in workflows

package/docs/how-it-works/understanding-directives.mdx

@@ -15,7 +15,7 @@ import { File, Folder, Files } from "fumadocs-ui/components/files";
 This guide explores how JavaScript directives enable the Workflow SDK's execution model. For getting started with workflows, see the [getting started](/docs/getting-started) guides for your framework.
 </Callout>
 
-The Workflow Development Kit uses JavaScript directives (`"use workflow"` and `"use step"`) as the foundation for its durable execution model. Directives provide the compile-time semantic boundary necessary for workflows to suspend, resume, and maintain deterministic behavior across replays.
+The Workflow SDK uses JavaScript directives (`"use workflow"` and `"use step"`) as the foundation for its durable execution model. Directives provide the compile-time semantic boundary necessary for workflows to suspend, resume, and maintain deterministic behavior across replays.
 
 This page explores how directives enable this execution model and the design principles that led us here.
 
@@ -339,7 +339,7 @@ This approach requires:
 - Storing/mutating class properties was not obvious (similar closure/mutation issues as the runtime-only approach)
 - Class-based syntax that doesn't feel "JavaScript native" to developers used to functional patterns
 
-As the JavaScript ecosystem has moved toward function-forward programming (exemplified by React's shift from class components to functions and hooks), requiring developers to use classes felt like a step backward and also didn't match our own personal taste as authors of the DevKit.
+As the JavaScript ecosystem has moved toward function-forward programming (exemplified by React's shift from class components to functions and hooks), requiring developers to use classes felt like a step backward and also didn't match our own personal taste as authors of the SDK.
 
 **The core problem: Presents workflows as regular runtime code**
 
@@ -615,4 +615,4 @@ As TC39 members, we at Vercel are actively working with the standards body and b
 
 Directives aren't about syntax preference, they're about expressing semantic boundaries. `"use workflow"` tells the compiler, developer, and runtime that this code is deterministic, resumable, and sandboxed.
 
-This clarity enables the Workflow Development Kit to provide durable execution with familiar JavaScript patterns, while maintaining the compile-time guarantees necessary for reliable workflow orchestration.
+This clarity enables the Workflow SDK to provide durable execution with familiar JavaScript patterns, while maintaining the compile-time guarantees necessary for reliable workflow orchestration.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@workflow/core",
-  "version": "4.2.0-beta.74",
+  "version": "4.2.0-beta.76",
   "description": "Core runtime and engine for Workflow SDK",
   "type": "module",
   "main": "dist/index.js",
@@ -77,18 +77,20 @@
     "ms": "2.1.3",
     "nanoid": "5.1.6",
     "seedrandom": "3.0.5",
+    "semver": "7.7.4",
     "ulid": "~3.0.1",
     "zod": "4.3.6",
-    "@workflow/errors": "4.1.0-beta.19",
+    "@workflow/errors": "4.1.0-beta.20",
     "@workflow/serde": "4.1.0-beta.2",
     "@workflow/utils": "4.1.0-beta.13",
-    "@workflow/world": "4.1.0-beta.14",
-    "@workflow/world-local": "4.1.0-beta.47",
-    "@workflow/world-vercel": "4.1.0-beta.45"
+    "@workflow/world": "4.1.0-beta.15",
+    "@workflow/world-local": "4.1.0-beta.49",
+    "@workflow/world-vercel": "4.1.0-beta.47"
   },
   "devDependencies": {
     "@opentelemetry/api": "1.9.0",
     "@types/debug": "4.1.12",
+    "@types/semver": "7.7.1",
     "@types/node": "22.19.0",
     "@types/seedrandom": "3.0.8",
     "cross-env": "10.1.0",