@workflow/core 5.0.0-beta.48 → 5.0.0-beta.49

package/dist/runtime/run.d.ts

@@ -61,6 +61,32 @@ export interface WorkflowReadableStreamOptions {
      */
     global?: Record<string, any>;
 }
+/**
+ * Options for configuring a writable onto a workflow run's stream.
+ */
+export interface WorkflowRunWritableStreamOptions {
+    /**
+     * An optional namespace to distinguish between multiple streams associated
+     * with the same workflow run.
+     */
+    namespace?: string;
+    /**
+     * Any asynchronous operations to complete before pausing or terminating the
+     * execution environment
+     * (i.e. using [`waitUntil()`](https://developer.mozilla.org/docs/Web/API/ExtendableEvent/waitUntil) or similar).
+     *
+     * Writes are acknowledged on buffer entry, so a caller that needs them
+     * durable before the environment goes away should pass an array here and
+     * await it after releasing the writer lock.
+     */
+    ops?: Promise<any>[];
+    /**
+     * The global object to use for reducing types from the global scope.
+     *
+     * Defaults to {@link [`globalThis`](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/globalThis)}.
+     */
+    global?: Record<string, any>;
+}
 /**
  * A handler class for a workflow run.
  */
@@ -145,6 +171,22 @@ export declare class Run<TResult> {
      * @returns A `WorkflowReadableStream` for the workflow run.
      */
     getReadable<R = any>(options?: WorkflowReadableStreamOptions): WorkflowReadableStream<R>;
+    /** The writable stream of the workflow run. */
+    get writable(): WritableStream;
+    /**
+     * Returns a writable that appends to this run's stream.
+     *
+     * Initialization is deferred until the first write. The run must already
+     * exist. The writable may be forwarded through `start()` and into steps, but
+     * grants no read access or additional authorization.
+     *
+     * @remarks
+     * `writer.close()` closes the shared stream. Contributors should call
+     * `releaseLock()`, which also drains pending writes.
+     *
+     * @param options - The writable stream options.
+     */
+    getWritable<W = any>(options?: WorkflowRunWritableStreamOptions): WritableStream<W>;
 }
 /**
  * Retrieves a `Run` object for a given run ID.

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

@@ -1 +1 @@
-{"version":3,"file":"run.d.ts","sourceRoot":"","sources":["../../src/runtime/run.ts"],"names":[],"mappings":"AAMA,OAAO,EAAE,oBAAoB,EAAE,kBAAkB,EAAE,MAAM,iBAAiB,CAAC;AAC3E,OAAO,KAAK,EAAe,iBAAiB,EAAS,MAAM,iBAAiB,CAAC;AAc7E,OAAO,EACL,KAAK,gBAAgB,EACrB,KAAK,gBAAgB,EACrB,KAAK,eAAe,EAErB,MAAM,WAAW,CAAC;AAQnB,gBAAgB;AAChB,wBAAgB,4BAA4B,IAAI,MAAM,CAMrD;AAiBD,gBAAgB;AAChB,wBAAgB,2BAA2B,IAAI,MAAM,CAMpD;AAqBD,gBAAgB;AAChB,wBAAgB,0BAA0B,IAAI,MAAM,CAMnD;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,4BAA4B,IAAI,OAAO,CAItD;AAED;;GAEG;AACH,MAAM,MAAM,sBAAsB,CAAC,CAAC,GAAG,GAAG,IAAI,cAAc,CAAC,CAAC,CAAC,GAAG;IAChE;;;;;;;OAOG;IACH,YAAY,IAAI,OAAO,CAAC,MAAM,CAAC,CAAC;CACjC,CAAC;AAEF;;GAEG;AACH,MAAM,WAAW,6BAA6B;IAC5C;;;OAGG;IACH,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB;;;OAGG;IACH,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB;;;;OAIG;IACH,GAAG,CAAC,EAAE,OAAO,CAAC,GAAG,CAAC,EAAE,CAAC;IACrB;;;;OAIG;IACH,MAAM,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;CAC9B;AAED;;GAEG;AACH,qBAAa,GAAG,CAAC,OAAO;;IACtB,MAAM,CAAC,CAAC,kBAAkB,CAAC,CAAC,QAAQ,EAAE,GAAG,CAAC,OAAO,CAAC;;;;IAIlD,MAAM,CAAC,CAAC,oBAAoB,CAAC,CAAC,IAAI,EAAE;QAClC,KAAK,EAAE,MAAM,CAAC;QACd,cAAc,CAAC,EAAE,OAAO,CAAC;KAC1B;IAID;;OAEG;IACH,KAAK,EAAE,MAAM,CAAC;gBA4BF,KAAK,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE;QAAE,cAAc,CAAC,EAAE,OAAO,CAAA;KAAE;IAiC9D;;;;;;OAMG;IACG,MAAM,CAAC,OAAO,CAAC,EAAE,gBAAgB,GAAG,OAAO,CAAC,eAAe,CAAC;IAKlE;;;;;;OAMG;IACG,MAAM,CAAC,OAAO,CAAC,EAAE,gBAAgB,GAAG,OAAO,CAAC,IAAI,CAAC;IAYvD;;OAEG;IACH,IAAI,MAAM,IAAI,OAAO,CAAC,OAAO,CAAC,CAa7B;IAED;;OAEG;IACH,IAAI,MAAM,IAAI,OAAO,CAAC,iBAAiB,CAAC,CAOvC;IAED;;;OAGG;IACH,IAAI,WAAW,IAAI,OAAO,CAAC,OAAO,CAAC,CAGlC;IAED;;OAEG;IACH,IAAI,YAAY,IAAI,OAAO,CAAC,MAAM,CAAC,CAKlC;IAED;;OAEG;IACH,IAAI,SAAS,IAAI,OAAO,CAAC,IAAI,CAAC,CAK7B;IAED;;;OAGG;IACH,IAAI,SAAS,IAAI,OAAO,CAAC,IAAI,GAAG,SAAS,CAAC,CAKzC;IAED;;;OAGG;IACH,IAAI,WAAW,IAAI,OAAO,CAAC,IAAI,GAAG,SAAS,CAAC,CAK3C;IAED;;OAEG;IACH,IAAI,QAAQ,IAAI,sBAAsB,CAErC;IAED;;;;;;;;;;;OAWG;IACH,WAAW,CAAC,CAAC,GAAG,GAAG,EACjB,OAAO,GAAE,6BAAkC,GAC1C,sBAAsB,CAAC,CAAC,CAAC;CA8K7B;AAED;;;;;;GAMG;AACH,wBAAgB,MAAM,CAAC,OAAO,EAAE,KAAK,EAAE,MAAM,GAAG,GAAG,CAAC,OAAO,CAAC,CAE3D"}
+{"version":3,"file":"run.d.ts","sourceRoot":"","sources":["../../src/runtime/run.ts"],"names":[],"mappings":"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"}

package/dist/runtime/run.js

@@ -1,9 +1,9 @@
-import { WorkflowRunCancelledError, WorkflowRunFailedError, WorkflowRunNotCompletedError, WorkflowRunNotFoundError, } from '@workflow/errors';
+import { RunExpiredError, WorkflowRunCancelledError, WorkflowRunFailedError, WorkflowRunNotCompletedError, WorkflowRunNotFoundError, } from '@workflow/errors';
 import { WORKFLOW_DESERIALIZE, WORKFLOW_SERIALIZE } from '@workflow/serde';
 import { envNumber } from '@workflow/world/env-config';
 import { SPEC_VERSION_CURRENT } from '@workflow/world/spec-version';
 import { deriveRunPayloadKeys, } from '../serialization/encryption.js';
-import { getRunReadableStream, hydrateRunError, hydrateWorkflowReturnValue, } from '../serialization.js';
+import { createForwardedWritable, getForwardedWritableEncryptionKey, getRunReadableStream, hydrateRunError, hydrateWorkflowReturnValue, tagForwardedWritableTarget, } from '../serialization.js';
 import { getWorkflowRunStreamId } from '../util.js';
 import { getWorldLazy } from './get-world-lazy.js';
 import { wakeUpRun, } from './runs.js';
@@ -12,6 +12,8 @@ const PAYLOAD_TERMINAL_RUN_STATUSES = new Set([
     'completed',
     'failed',
 ]);
+// Give resilient starts up to 10 seconds to create the run.
+const NOT_FOUND_RETRY_DELAYS = [1_000, 3_000, 6_000];
 /** @internal */
 export function getReturnValuePollIntervalMs() {
     return envNumber('WORKFLOW_RETURN_VALUE_POLL_INTERVAL_MS', RETURN_VALUE_POLL_INTERVAL_MS, { integer: true, min: 1 });
@@ -270,8 +272,94 @@ export class Run {
             },
         });
     }
+    /** The writable stream of the workflow run. */
+    get writable() {
+        return this.getWritable();
+    }
+    /**
+     * Returns a writable that appends to this run's stream.
+     *
+     * Initialization is deferred until the first write. The run must already
+     * exist. The writable may be forwarded through `start()` and into steps, but
+     * grants no read access or additional authorization.
+     *
+     * @remarks
+     * `writer.close()` closes the shared stream. Contributors should call
+     * `releaseLock()`, which also drains pending writes.
+     *
+     * @param options - The writable stream options.
+     */
+    getWritable(options = {}) {
+        'use step';
+        const { ops = [], global = globalThis, namespace } = options;
+        const name = getWorkflowRunStreamId(this.runId, namespace);
+        let targetPromise;
+        let writable;
+        const resolveTarget = () => {
+            targetPromise ??= this.#getMetadata().then(async (run) => {
+                const target = {
+                    key: await getForwardedWritableEncryptionKey(this.runId, run.deploymentId, run.encryptionPublicKey),
+                    deploymentId: run.deploymentId,
+                    encryptionPublicKey: run.encryptionPublicKey,
+                };
+                tagForwardedWritableTarget(writable, target);
+                return target;
+            });
+            return targetPromise;
+        };
+        writable = createForwardedWritable({
+            global,
+            ops,
+            runId: this.runId,
+            name,
+            key: () => resolveTarget().then(({ key }) => key),
+        });
+        return writable;
+    }
+    /** Reads metadata, briefly retrying resilient starts. @internal */
+    async #getMetadata() {
+        const world = await this.#lazyWorldPromise;
+        const maxRetries = this.#resilientStart ? NOT_FOUND_RETRY_DELAYS.length : 0;
+        let attempt = 0;
+        while (true) {
+            try {
+                return await world.runs.get(this.runId, { resolveData: 'none' });
+            }
+            catch (error) {
+                if (!WorkflowRunNotFoundError.is(error) || attempt >= maxRetries) {
+                    throw error;
+                }
+                const delay = NOT_FOUND_RETRY_DELAYS[attempt];
+                attempt++;
+                await new Promise((resolve) => setTimeout(resolve, delay));
+            }
+        }
+    }
     /** @internal */
     async #resolveTerminalReturnValue(run) {
+        // Expiry is checked before the status branches, and deliberately so.
+        //
+        // Past its retention boundary a run's payloads are gone but its metadata
+        // usually is not, so `run.output` and `run.error` hydrate to an
+        // expired-data placeholder rather than to anything the caller asked for.
+        // Handing that back as if it were the return value — or wrapping it as
+        // the `cause` of a WorkflowRunFailedError — is worse than failing: it is
+        // indistinguishable from the workflow having genuinely returned it.
+        //
+        // A run started with `experimental_retention: 0` reaches this almost
+        // immediately (its purge races, and usually beats, the caller's own read
+        // of the result). An ordinary run reaches it whenever it is read after
+        // the World's default window. Both are the same condition and get the
+        // same terminal, non-retryable error, carrying whatever metadata
+        // survived so the caller can still tell success from failure.
+        //
+        // When even the metadata is gone the World reports the run as missing and
+        // the caller gets WorkflowRunNotFoundError from the read above instead —
+        // there is nothing left here to describe.
+        const expiredAt = run.expiredAt;
+        if (expiredAt != null && expiredAt <= new Date()) {
+            throw new RunExpiredError(`Run "${this.runId}" ${run.status === 'completed' ? 'completed' : `is ${run.status}`}, but its data expired at ${expiredAt.toISOString()} and is no longer readable.`, this.runId, run.status, expiredAt);
+        }
         if (run.status === 'completed') {
             const encryptionKey = await this.#getEncryptionKey(run);
             return await hydrateWorkflowReturnValue(run.output, this.runId, encryptionKey);
@@ -315,8 +403,9 @@ export class Run {
         // and the runtime to create the run via run_started.
         // When resilientStart is false, 404 is a real error: fail fast.
         let notFoundRetries = 0;
-        const NOT_FOUND_MAX_RETRIES = this.#resilientStart ? 3 : 0;
-        const NOT_FOUND_DELAYS = [1_000, 3_000, 6_000];
+        const NOT_FOUND_MAX_RETRIES = this.#resilientStart
+            ? NOT_FOUND_RETRY_DELAYS.length
+            : 0;
         // Prefer the World's long poll: one read that the backend holds open
         // until the run finishes, instead of asking again every second and
         // paying up to a full interval of quantization on a run that already
@@ -386,7 +475,7 @@ export class Run {
                 }
                 if (WorkflowRunNotFoundError.is(error) &&
                     notFoundRetries < NOT_FOUND_MAX_RETRIES) {
-                    const delay = NOT_FOUND_DELAYS[notFoundRetries];
+                    const delay = NOT_FOUND_RETRY_DELAYS[notFoundRetries];
                     notFoundRetries++;
                     await new Promise((resolve) => setTimeout(resolve, delay));
                     continue;
@@ -406,4 +495,4 @@ export class Run {
 export function getRun(runId) {
     return new Run(runId);
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"run.js","sourceRoot":"","sources":["../../src/runtime/run.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,yBAAyB,EACzB,sBAAsB,EACtB,4BAA4B,EAC5B,wBAAwB,GACzB,MAAM,kBAAkB,CAAC;AAC1B,OAAO,EAAE,oBAAoB,EAAE,kBAAkB,EAAE,MAAM,iBAAiB,CAAC;AAE3E,OAAO,EAAE,SAAS,EAAE,MAAM,4BAA4B,CAAC;AACvD,OAAO,EAAE,oBAAoB,EAAE,MAAM,8BAA8B,CAAC;AACpE,OAAO,EACL,oBAAoB,GAErB,MAAM,gCAAgC,CAAC;AACxC,OAAO,EACL,oBAAoB,EACpB,eAAe,EACf,0BAA0B,GAC3B,MAAM,qBAAqB,CAAC;AAC7B,OAAO,EAAE,sBAAsB,EAAE,MAAM,YAAY,CAAC;AACpD,OAAO,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAC;AACnD,OAAO,EAIL,SAAS,GACV,MAAM,WAAW,CAAC;AAEnB,MAAM,6BAA6B,GAAG,KAAK,CAAC;AAC5C,MAAM,6BAA6B,GAAG,IAAI,GAAG,CAAoB;IAC/D,WAAW;IACX,QAAQ;CACT,CAAC,CAAC;AAEH,gBAAgB;AAChB,MAAM,UAAU,4BAA4B;IAC1C,OAAO,SAAS,CACd,wCAAwC,EACxC,6BAA6B,EAC7B,EAAE,OAAO,EAAE,IAAI,EAAE,GAAG,EAAE,CAAC,EAAE,CAC1B,CAAC;AACJ,CAAC;AAED;;;;;;;;;;;;GAYG;AACH,MAAM,4BAA4B,GAAG,MAAM,CAAC;AAE5C,gBAAgB;AAChB,MAAM,UAAU,2BAA2B;IACzC,OAAO,SAAS,CACd,+BAA+B,EAC/B,4BAA4B,EAC5B,EAAE,OAAO,EAAE,IAAI,EAAE,GAAG,EAAE,CAAC,EAAE,CAC1B,CAAC;AACJ,CAAC;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,MAAM,2BAA2B,GAAG,EAAE,CAAC;AAEvC,gBAAgB;AAChB,MAAM,UAAU,0BAA0B;IACxC,OAAO,SAAS,CACd,sCAAsC,EACtC,2BAA2B,EAC3B,EAAE,OAAO,EAAE,IAAI,EAAE,GAAG,EAAE,CAAC,EAAE,CAC1B,CAAC;AACJ,CAAC;AAED;;;;;;;;;;;GAWG;AACH,MAAM,UAAU,4BAA4B;IAC1C,MAAM,GAAG,GAAG,OAAO,CAAC,GAAG,CAAC,+BAA+B,CAAC;IACxD,IAAI,GAAG,KAAK,SAAS,IAAI,GAAG,KAAK,EAAE;QAAE,OAAO,IAAI,CAAC;IACjD,OAAO,CAAC,CAAC,GAAG,KAAK,GAAG,IAAI,GAAG,CAAC,WAAW,EAAE,KAAK,OAAO,CAAC,CAAC;AACzD,CAAC;AA6CD;;GAEG;AACH,MAAM,OAAO,GAAG;IACd,MAAM,CAAC,CAAC,kBAAkB,CAAC,CAAC,QAAsB;QAChD,OAAO,EAAE,KAAK,EAAE,QAAQ,CAAC,KAAK,EAAE,cAAc,EAAE,QAAQ,CAAC,eAAe,EAAE,CAAC;IAC7E,CAAC;IAED,MAAM,CAAC,CAAC,oBAAoB,CAAC,CAAC,IAG7B;QACC,OAAO,IAAI,GAAG,CAAC,IAAI,CAAC,KAAK,EAAE,EAAE,cAAc,EAAE,IAAI,CAAC,cAAc,EAAE,CAAC,CAAC;IACtE,CAAC;IAED;;OAEG;IACH,KAAK,CAAS;IAEd;;;OAGG;IACH,aAAa,CAA6B;IAC1C,IAAI,iBAAiB;QACnB,IAAI,CAAC,IAAI,CAAC,aAAa;YAAE,IAAI,CAAC,aAAa,GAAG,YAAY,EAAE,CAAC;QAC7D,OAAO,IAAI,CAAC,aAAa,CAAC;IAC5B,CAAC;IAED;;;;OAIG;IACH,qBAAqB,GAA2C,IAAI,CAAC;IAErE;;;;;;OAMG;IACH,eAAe,GAAG,KAAK,CAAC;IAExB,YAAY,KAAa,EAAE,IAAmC;QAC5D,IAAI,CAAC,KAAK,GAAG,KAAK,CAAC;QACnB,IAAI,CAAC,eAAe,GAAG,IAAI,EAAE,cAAc,IAAI,KAAK,CAAC;IACvD,CAAC;IAED;;;;;OAKG;IACH,iBAAiB,CAAC,GAAiB;QACjC,IAAI,CAAC,IAAI,CAAC,qBAAqB,EAAE,CAAC;YAChC,IAAI,CAAC,qBAAqB,GAAG,CAAC,KAAK,IAAI,EAAE;gBACvC,MAAM,KAAK,GAAG,MAAM,IAAI,CAAC,iBAAiB,CAAC;gBAC3C,MAAM,OAAO,GAAG,GAAG,IAAI,CAAC,MAAM,KAAK,CAAC,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC;gBAC1D,MAAM,MAAM,GAAG,MAAM,KAAK,CAAC,sBAAsB,EAAE,CAAC,OAAO,CAAC,CAAC;gBAC7D,OAAO,MAAM,CAAC,CAAC,CAAC,MAAM,oBAAoB,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC;YACjE,CAAC,CAAC,EAAE,CAAC;QACP,CAAC;QACD,OAAO,IAAI,CAAC,qBAAqB,CAAC;IACpC,CAAC;IAED;;;;;OAKG;IACH,uBAAuB;QACrB,OAAO,GAAG,EAAE,CAAC,IAAI,CAAC,iBAAiB,EAAE,CAAC;IACxC,CAAC;IAED;;;;;;OAMG;IACH,KAAK,CAAC,MAAM,CAAC,OAA0B;QACrC,UAAU,CAAC;QACX,OAAO,SAAS,CAAC,MAAM,IAAI,CAAC,iBAAiB,EAAE,IAAI,CAAC,KAAK,EAAE,OAAO,CAAC,CAAC;IACtE,CAAC;IAED;;;;;;OAMG;IACH,KAAK,CAAC,MAAM,CAAC,OAA0B;QACrC,UAAU,CAAC;QACX,MAAM,KAAK,GAAG,MAAM,IAAI,CAAC,iBAAiB,CAAC;QAC3C,MAAM,KAAK,CAAC,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,KAAK,EAAE;YACpC,SAAS,EAAE,eAAe;YAC1B,WAAW,EAAE,oBAAoB;YACjC,GAAG,CAAC,OAAO,EAAE,YAAY,KAAK,SAAS;gBACrC,CAAC,CAAC,EAAE,SAAS,EAAE,EAAE,YAAY,EAAE,OAAO,CAAC,YAAY,EAAE,EAAE;gBACvD,CAAC,CAAC,EAAE,CAAC;SACR,CAAC,CAAC;IACL,CAAC;IAED;;OAEG;IACH,IAAI,MAAM;QACR,UAAU,CAAC;QACX,OAAO,IAAI,CAAC,iBAAiB,CAAC,IAAI,CAAC,CAAC,KAAK,EAAE,EAAE,CAC3C,KAAK,CAAC,IAAI;aACP,GAAG,CAAC,IAAI,CAAC,KAAK,EAAE,EAAE,WAAW,EAAE,MAAM,EAAE,CAAC;aACxC,IAAI,CAAC,GAAG,EAAE,CAAC,IAAI,CAAC;aAChB,KAAK,CAAC,CAAC,KAAK,EAAE,EAAE;YACf,IAAI,wBAAwB,CAAC,EAAE,CAAC,KAAK,CAAC,EAAE,CAAC;gBACvC,OAAO,KAAK,CAAC;YACf,CAAC;YACD,MAAM,KAAK,CAAC;QACd,CAAC,CAAC,CACL,CAAC;IACJ,CAAC;IAED;;OAEG;IACH,IAAI,MAAM;QACR,UAAU,CAAC;QACX,OAAO,IAAI,CAAC,iBAAiB,CAAC,IAAI,CAAC,CAAC,KAAK,EAAE,EAAE,CAC3C,KAAK,CAAC,IAAI;aACP,GAAG,CAAC,IAAI,CAAC,KAAK,EAAE,EAAE,WAAW,EAAE,MAAM,EAAE,CAAC;aACxC,IAAI,CAAC,CAAC,GAAG,EAAE,EAAE,CAAC,GAAG,CAAC,MAAM,CAAC,CAC7B,CAAC;IACJ,CAAC;IAED;;;OAGG;IACH,IAAI,WAAW;QACb,UAAU,CAAC;QACX,OAAO,IAAI,CAAC,gBAAgB,EAAE,CAAC;IACjC,CAAC;IAED;;OAEG;IACH,IAAI,YAAY;QACd,UAAU,CAAC;QACX,OAAO,IAAI,CAAC,iBAAiB,CAAC,IAAI,CAAC,CAAC,KAAK,EAAE,EAAE,CAC3C,KAAK,CAAC,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,IAAI,CAAC,CAAC,GAAG,EAAE,EAAE,CAAC,GAAG,CAAC,YAAY,CAAC,CAC3D,CAAC;IACJ,CAAC;IAED;;OAEG;IACH,IAAI,SAAS;QACX,UAAU,CAAC;QACX,OAAO,IAAI,CAAC,iBAAiB,CAAC,IAAI,CAAC,CAAC,KAAK,EAAE,EAAE,CAC3C,KAAK,CAAC,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,IAAI,CAAC,CAAC,GAAG,EAAE,EAAE,CAAC,GAAG,CAAC,SAAS,CAAC,CACxD,CAAC;IACJ,CAAC;IAED;;;OAGG;IACH,IAAI,SAAS;QACX,UAAU,CAAC;QACX,OAAO,IAAI,CAAC,iBAAiB,CAAC,IAAI,CAAC,CAAC,KAAK,EAAE,EAAE,CAC3C,KAAK,CAAC,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,IAAI,CAAC,CAAC,GAAG,EAAE,EAAE,CAAC,GAAG,CAAC,SAAS,CAAC,CACxD,CAAC;IACJ,CAAC;IAED;;;OAGG;IACH,IAAI,WAAW;QACb,UAAU,CAAC;QACX,OAAO,IAAI,CAAC,iBAAiB,CAAC,IAAI,CAAC,CAAC,KAAK,EAAE,EAAE,CAC3C,KAAK,CAAC,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,IAAI,CAAC,CAAC,GAAG,EAAE,EAAE,CAAC,GAAG,CAAC,WAAW,CAAC,CAC1D,CAAC;IACJ,CAAC;IAED;;OAEG;IACH,IAAI,QAAQ;QACV,OAAO,IAAI,CAAC,WAAW,EAAE,CAAC;IAC5B,CAAC;IAED;;;;;;;;;;;OAWG;IACH,WAAW,CACT,UAAyC,EAAE;QAE3C,UAAU,CAAC;QACX,MAAM,EAAE,GAAG,GAAG,EAAE,EAAE,MAAM,GAAG,UAAU,EAAE,UAAU,EAAE,SAAS,EAAE,GAAG,OAAO,CAAC;QACzE,MAAM,IAAI,GAAG,sBAAsB,CAAC,IAAI,CAAC,KAAK,EAAE,SAAS,CAAC,CAAC;QAC3D,yEAAyE;QACzE,0EAA0E;QAC1E,qDAAqD;QACrD,MAAM,aAAa,GAAG,IAAI,CAAC,uBAAuB,EAAE,CAAC;QACrD,MAAM,MAAM,GAAG,oBAAoB,CACjC,MAAM,EACN,GAAG,EACH,IAAI,CAAC,KAAK,EACV,IAAI,EACJ,UAAU,EACV,aAAa,CACd,CAAC;QAEF,MAAM,YAAY,GAAG,IAAI,CAAC,iBAAiB,CAAC;QAC5C,MAAM,KAAK,GAAG,IAAI,CAAC,KAAK,CAAC;QACzB,OAAO,MAAM,CAAC,MAAM,CAAC,MAAM,EAAE;YAC3B,YAAY,EAAE,KAAK,IAAqB,EAAE;gBACxC,MAAM,KAAK,GAAG,MAAM,YAAY,CAAC;gBACjC,MAAM,IAAI,GAAG,MAAM,KAAK,CAAC,OAAO,CAAC,OAAO,CAAC,KAAK,EAAE,IAAI,CAAC,CAAC;gBACtD,OAAO,IAAI,CAAC,SAAS,CAAC;YACxB,CAAC;SACF,CAAC,CAAC;IACL,CAAC;IAED,gBAAgB;IAChB,KAAK,CAAC,2BAA2B,CAAC,GAAgB;QAChD,IAAI,GAAG,CAAC,MAAM,KAAK,WAAW,EAAE,CAAC;YAC/B,MAAM,aAAa,GAAG,MAAM,IAAI,CAAC,iBAAiB,CAAC,GAAG,CAAC,CAAC;YACxD,OAAO,MAAM,0BAA0B,CACrC,GAAG,CAAC,MAAM,EACV,IAAI,CAAC,KAAK,EACV,aAAa,CACd,CAAC;QACJ,CAAC;QAED,IAAI,GAAG,CAAC,MAAM,KAAK,WAAW,EAAE,CAAC;YAC/B,MAAM,IAAI,yBAAyB,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;QAClD,CAAC;QAED,IAAI,GAAG,CAAC,MAAM,KAAK,QAAQ,EAAE,CAAC;YAC5B,gEAAgE;YAChE,4DAA4D;YAC5D,qCAAqC;YACrC,MAAM,aAAa,GAAG,MAAM,IAAI,CAAC,iBAAiB,CAAC,GAAG,CAAC,CAAC;YACxD,IAAI,aAAsB,CAAC;YAC3B,IAAI,CAAC;gBACH,aAAa,GAAG,MAAM,eAAe,CACnC,GAAG,CAAC,KAAK,EACT,IAAI,CAAC,KAAK,EACV,aAAa,CACd,CAAC;YACJ,CAAC;YAAC,MAAM,CAAC;gBACP,6DAA6D;gBAC7D,8DAA8D;gBAC9D,2DAA2D;gBAC3D,aAAa,GAAG,IAAI,KAAK,CAAC,sCAAsC,CAAC,CAAC;YACpE,CAAC;YACD,MAAM,IAAI,sBAAsB,CAAC,IAAI,CAAC,KAAK,EAAE,aAAa,EAAE;gBAC1D,SAAS,EAAE,GAAG,CAAC,SAAS;aACzB,CAAC,CAAC;QACL,CAAC;QAED,wEAAwE;QACxE,qDAAqD;QACrD,MAAM,IAAI,4BAA4B,CAAC,IAAI,CAAC,KAAK,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC;IACjE,CAAC;IAED;;;;OAIG;IACH,KAAK,CAAC,gBAAgB;QACpB,MAAM,KAAK,GAAG,MAAM,IAAI,CAAC,iBAAiB,CAAC;QAE3C,kEAAkE;QAClE,iEAAiE;QACjE,+DAA+D;QAC/D,qDAAqD;QACrD,gEAAgE;QAChE,IAAI,eAAe,GAAG,CAAC,CAAC;QACxB,MAAM,qBAAqB,GAAG,IAAI,CAAC,eAAe,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;QAC3D,MAAM,gBAAgB,GAAG,CAAC,KAAK,EAAE,KAAK,EAAE,KAAK,CAAC,CAAC;QAE/C,qEAAqE;QACrE,mEAAmE;QACnE,qEAAqE;QACrE,0DAA0D;QAC1D,oEAAoE;QACpE,kEAAkE;QAClE,8DAA8D;QAC9D,MAAM,qBAAqB,GAAG,4BAA4B,EAAE;YAC1D,CAAC,CAAC,KAAK,CAAC,IAAI,CAAC,qBAAqB,EAAE,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC;YACpD,CAAC,CAAC,SAAS,CAAC;QAEd,0EAA0E;QAC1E,0EAA0E;QAC1E,kEAAkE;QAClE,IAAI,SAAS,GAAG,CAAC,CAAC;QAClB,MAAM,YAAY,GAAG,0BAA0B,EAAE,CAAC;QAElD,uEAAuE;QACvE,sEAAsE;QACtE,oEAAoE;QACpE,uEAAuE;QACvE,kEAAkE;QAClE,sEAAsE;QACtE,yBAAyB;QACzB,OAAO,IAAI,EAAE,CAAC;YACZ,MAAM,kBAAkB,GAAG,IAAI,CAAC,GAAG,EAAE,CAAC;YACtC,IAAI,CAAC;gBACH,qEAAqE;gBACrE,uEAAuE;gBACvE,YAAY;gBACZ,MAAM,WAAW,GAAG,qBAAqB,IAAI,SAAS,GAAG,YAAY,CAAC;gBACtE,IAAI,WAAW;oBAAE,SAAS,EAAE,CAAC;gBAC7B,MAAM,WAAW,GAAG,WAAW;oBAC7B,CAAC,CAAC,MAAM,qBAAqB,CAAC,IAAI,CAAC,KAAK,EAAE;wBACtC,SAAS,EAAE,2BAA2B,EAAE;wBACxC,WAAW,EAAE,MAAM;qBACpB,CAAC;oBACJ,CAAC,CAAC,MAAM,KAAK,CAAC,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,KAAK,EAAE;wBAC/B,WAAW,EAAE,MAAM;qBACpB,CAAC,CAAC;gBAEP,IAAI,WAAW,CAAC,MAAM,KAAK,WAAW,EAAE,CAAC;oBACvC,MAAM,IAAI,yBAAyB,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;gBAClD,CAAC;gBAED,IAAI,6BAA6B,CAAC,GAAG,CAAC,WAAW,CAAC,MAAM,CAAC,EAAE,CAAC;oBAC1D,qEAAqE;oBACrE,+DAA+D;oBAC/D,MAAM,GAAG,GAAG,MAAM,KAAK,CAAC,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,KAAK,EAAE;wBAC3C,WAAW,EAAE,KAAK;qBACnB,CAAC,CAAC;oBACH,OAAO,MAAM,IAAI,CAAC,2BAA2B,CAAC,GAAG,CAAC,CAAC;gBACrD,CAAC;gBAED,+CAA+C;gBAC/C,MAAM,IAAI,4BAA4B,CAAC,IAAI,CAAC,KAAK,EAAE,WAAW,CAAC,MAAM,CAAC,CAAC;YACzE,CAAC;YAAC,OAAO,KAAK,EAAE,CAAC;gBACf,IAAI,4BAA4B,CAAC,EAAE,CAAC,KAAK,CAAC,EAAE,CAAC;oBAC3C,gEAAgE;oBAChE,oEAAoE;oBACpE,4DAA4D;oBAC5D,kEAAkE;oBAClE,iEAAiE;oBACjE,oEAAoE;oBACpE,MAAM,mBAAmB,GACvB,4BAA4B,EAAE,GAAG,CAAC,IAAI,CAAC,GAAG,EAAE,GAAG,kBAAkB,CAAC,CAAC;oBACrE,IAAI,mBAAmB,GAAG,CAAC,EAAE,CAAC;wBAC5B,MAAM,IAAI,OAAO,CAAC,CAAC,OAAO,EAAE,EAAE,CAC5B,UAAU,CAAC,OAAO,EAAE,mBAAmB,CAAC,CACzC,CAAC;oBACJ,CAAC;oBACD,SAAS;gBACX,CAAC;gBACD,IACE,wBAAwB,CAAC,EAAE,CAAC,KAAK,CAAC;oBAClC,eAAe,GAAG,qBAAqB,EACvC,CAAC;oBACD,MAAM,KAAK,GAAG,gBAAgB,CAAC,eAAe,CAAE,CAAC;oBACjD,eAAe,EAAE,CAAC;oBAClB,MAAM,IAAI,OAAO,CAAC,CAAC,OAAO,EAAE,EAAE,CAAC,UAAU,CAAC,OAAO,EAAE,KAAK,CAAC,CAAC,CAAC;oBAC3D,SAAS;gBACX,CAAC;gBACD,MAAM,KAAK,CAAC;YACd,CAAC;QACH,CAAC;IACH,CAAC;CACF;AAED;;;;;;GAMG;AACH,MAAM,UAAU,MAAM,CAAU,KAAa;IAC3C,OAAO,IAAI,GAAG,CAAC,KAAK,CAAC,CAAC;AACxB,CAAC","sourcesContent":["import {\n  WorkflowRunCancelledError,\n  WorkflowRunFailedError,\n  WorkflowRunNotCompletedError,\n  WorkflowRunNotFoundError,\n} from '@workflow/errors';\nimport { WORKFLOW_DESERIALIZE, WORKFLOW_SERIALIZE } from '@workflow/serde';\nimport type { WorkflowRun, WorkflowRunStatus, World } from '@workflow/world';\nimport { envNumber } from '@workflow/world/env-config';\nimport { SPEC_VERSION_CURRENT } from '@workflow/world/spec-version';\nimport {\n  deriveRunPayloadKeys,\n  type PayloadKey,\n} from '../serialization/encryption.js';\nimport {\n  getRunReadableStream,\n  hydrateRunError,\n  hydrateWorkflowReturnValue,\n} from '../serialization.js';\nimport { getWorkflowRunStreamId } from '../util.js';\nimport { getWorldLazy } from './get-world-lazy.js';\nimport {\n  type CancelRunOptions,\n  type StopSleepOptions,\n  type StopSleepResult,\n  wakeUpRun,\n} from './runs.js';\n\nconst RETURN_VALUE_POLL_INTERVAL_MS = 1_000;\nconst PAYLOAD_TERMINAL_RUN_STATUSES = new Set<WorkflowRunStatus>([\n  'completed',\n  'failed',\n]);\n\n/** @internal */\nexport function getReturnValuePollIntervalMs(): number {\n  return envNumber(\n    'WORKFLOW_RETURN_VALUE_POLL_INTERVAL_MS',\n    RETURN_VALUE_POLL_INTERVAL_MS,\n    { integer: true, min: 1 }\n  );\n}\n\n/**\n * How long a single `runs.waitForTerminalStatus` call may block while waiting\n * for a run to finish. The wait is re-issued until the run is terminal, so\n * this is a per-call budget rather than a limit on total wait time: its only\n * job is to bound one request so a stalled connection cannot hold the awaiting\n * side forever.\n *\n * 50s is the largest budget `world-vercel` can actually request: it clamps to\n * `REQUEST_TIMEOUT_MS` (60s) minus 10s of headroom, so the budget is always\n * observed as a *response* (a non-terminal snapshot) rather than as a\n * client-side timeout. Asking for more is silently reduced to that, so raising\n * this without also raising `WORKFLOW_REQUEST_TIMEOUT_MS` has no effect.\n */\nconst RETURN_VALUE_WAIT_TIMEOUT_MS = 50_000;\n\n/** @internal */\nexport function getReturnValueWaitTimeoutMs(): number {\n  return envNumber(\n    'WORKFLOW_RETURN_VALUE_WAIT_MS',\n    RETURN_VALUE_WAIT_TIMEOUT_MS,\n    { integer: true, min: 1 }\n  );\n}\n\n/**\n * How many consecutive long-poll calls `await run.returnValue` will make\n * before falling back to interval polling for the rest of the wait.\n *\n * A cap is worth having because a wait that keeps returning non-terminal is\n * indistinguishable from one that is not working, and interval polling is the\n * behavior we know is correct. It does **not** end the await: a run legitimately\n * lasts hours or days, so exhausting the cap switches strategy and keeps\n * waiting rather than throwing.\n *\n * Note the consequence, since it cuts against the reason the long poll exists:\n * a run still going after `MAX x budget` (~8 minutes at the defaults) spends\n * the remainder of its life polling once per\n * `WORKFLOW_RETURN_VALUE_POLL_INTERVAL_MS`, which is more requests than\n * continuing to long poll would have cost. Runs that outlive the cap are\n * exactly the ones the request reduction helped most.\n */\nconst RETURN_VALUE_MAX_LONG_POLLS = 10;\n\n/** @internal */\nexport function getReturnValueMaxLongPolls(): number {\n  return envNumber(\n    'WORKFLOW_RETURN_VALUE_MAX_LONG_POLLS',\n    RETURN_VALUE_MAX_LONG_POLLS,\n    { integer: true, min: 1 }\n  );\n}\n\n/**\n * Whether `await run.returnValue` may use the World's long poll\n * (`runs.waitForTerminalStatus`) instead of interval-polling `runs.get`.\n *\n * Default **ON** wherever the World implements the method; a World that does\n * not is already on the interval path with nothing to switch off. Reads\n * `process.env.WORKFLOW_RETURN_VALUE_LONG_POLL` lazily; an explicit `'0'` /\n * `'false'` is the kill switch, restoring the fixed-interval poll exactly as\n * it behaved before the fast path existed.\n *\n * @internal\n */\nexport function isReturnValueLongPollEnabled(): boolean {\n  const raw = process.env.WORKFLOW_RETURN_VALUE_LONG_POLL;\n  if (raw === undefined || raw === '') return true;\n  return !(raw === '0' || raw.toLowerCase() === 'false');\n}\n\n/**\n * A `ReadableStream` extended with workflow-specific helpers.\n */\nexport type WorkflowReadableStream<R = any> = ReadableStream<R> & {\n  /**\n   * Returns the tail index (index of the last known chunk, 0-based) of the\n   * underlying workflow stream. Useful for resolving a negative `startIndex`\n   * into an absolute position, for example, when building reconnection\n   * endpoints that need to inform the client where the stream starts.\n   *\n   * Returns `-1` when no chunks have been written yet.\n   */\n  getTailIndex(): Promise<number>;\n};\n\n/**\n * Options for configuring a workflow's readable stream.\n */\nexport interface WorkflowReadableStreamOptions {\n  /**\n   * An optional namespace to distinguish between multiple streams associated\n   * with the same workflow run.\n   */\n  namespace?: string;\n  /**\n   * The index number of the starting chunk to begin reading the stream from.\n   * Negative values start from the end (e.g. -3 reads the last 3 chunks).\n   */\n  startIndex?: number;\n  /**\n   * Any asynchronous operations to complete before pausing or terminating the\n   * execution environment\n   * (i.e. using [`waitUntil()`](https://developer.mozilla.org/docs/Web/API/ExtendableEvent/waitUntil) or similar).\n   */\n  ops?: Promise<any>[];\n  /**\n   * The global object to use for hydrating types from the global scope.\n   *\n   * Defaults to {@link [`globalThis`](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/globalThis)}.\n   */\n  global?: Record<string, any>;\n}\n\n/**\n * A handler class for a workflow run.\n */\nexport class Run<TResult> {\n  static [WORKFLOW_SERIALIZE](instance: Run<unknown>) {\n    return { runId: instance.runId, resilientStart: instance.#resilientStart };\n  }\n\n  static [WORKFLOW_DESERIALIZE](data: {\n    runId: string;\n    resilientStart?: boolean;\n  }) {\n    return new Run(data.runId, { resilientStart: data.resilientStart });\n  }\n\n  /**\n   * The ID of the workflow run.\n   */\n  runId: string;\n\n  /**\n   * The world object.\n   * @internal\n   */\n  #worldPromise: Promise<World> | undefined;\n  get #lazyWorldPromise() {\n    if (!this.#worldPromise) this.#worldPromise = getWorldLazy();\n    return this.#worldPromise;\n  }\n\n  /**\n   * Cached encryption key resolution. Resolved once on first use and\n   * reused for returnValue, getReadable(), etc.\n   * @internal\n   */\n  #encryptionKeyPromise: Promise<PayloadKey | undefined> | null = null;\n\n  /**\n   * When true, run_created failed and the run may not exist yet (the\n   * resilient start path will create it via run_started). pollReturnValue\n   * retries on WorkflowRunNotFoundError only when this flag is set so\n   * that normal runs fail fast on 404.\n   * @internal\n   */\n  #resilientStart = false;\n\n  constructor(runId: string, opts?: { resilientStart?: boolean }) {\n    this.runId = runId;\n    this.#resilientStart = opts?.resilientStart ?? false;\n  }\n\n  /**\n   * Resolves and caches the encryption key for this run.\n   * The key is the same for the lifetime of a run, so it only needs\n   * to be resolved once.\n   * @internal\n   */\n  #getEncryptionKey(run?: WorkflowRun): Promise<PayloadKey | undefined> {\n    if (!this.#encryptionKeyPromise) {\n      this.#encryptionKeyPromise = (async () => {\n        const world = await this.#lazyWorldPromise;\n        const runData = run ?? (await world.runs.get(this.runId));\n        const rawKey = await world.getEncryptionKeyForRun?.(runData);\n        return rawKey ? await deriveRunPayloadKeys(rawKey) : undefined;\n      })();\n    }\n    return this.#encryptionKeyPromise;\n  }\n\n  /**\n   * Defers fetching the run and its encryption key until a readable is first\n   * consumed. The first pull prefetches it so an encrypted first frame can join\n   * the lookup; this also applies to an empty consumed stream.\n   * @internal\n   */\n  #getEncryptionKeyLazily(): () => Promise<PayloadKey | undefined> {\n    return () => this.#getEncryptionKey();\n  }\n\n  /**\n   * Interrupts pending `sleep()` calls, resuming the workflow early.\n   *\n   * @param options - Optional settings to target specific sleep calls by correlation ID.\n   *   If not provided, all pending sleep calls will be interrupted.\n   * @returns A {@link StopSleepResult} object containing the number of sleep calls that were interrupted.\n   */\n  async wakeUp(options?: StopSleepOptions): Promise<StopSleepResult> {\n    'use step';\n    return wakeUpRun(await this.#lazyWorldPromise, this.runId, options);\n  }\n\n  /**\n   * Cancels the workflow run.\n   *\n   * @param options - Optional cancellation settings. `cancelReason` records a\n   *   free-text reason (max 512 chars) on the run_cancelled event, surfaced in\n   *   the run detail view.\n   */\n  async cancel(options?: CancelRunOptions): Promise<void> {\n    'use step';\n    const world = await this.#lazyWorldPromise;\n    await world.events.create(this.runId, {\n      eventType: 'run_cancelled',\n      specVersion: SPEC_VERSION_CURRENT,\n      ...(options?.cancelReason !== undefined\n        ? { eventData: { cancelReason: options.cancelReason } }\n        : {}),\n    });\n  }\n\n  /**\n   * Whether the workflow run exists.\n   */\n  get exists(): Promise<boolean> {\n    'use step';\n    return this.#lazyWorldPromise.then((world) =>\n      world.runs\n        .get(this.runId, { resolveData: 'none' })\n        .then(() => true)\n        .catch((error) => {\n          if (WorkflowRunNotFoundError.is(error)) {\n            return false;\n          }\n          throw error;\n        })\n    );\n  }\n\n  /**\n   * The status of the workflow run.\n   */\n  get status(): Promise<WorkflowRunStatus> {\n    'use step';\n    return this.#lazyWorldPromise.then((world) =>\n      world.runs\n        .get(this.runId, { resolveData: 'none' })\n        .then((run) => run.status)\n    );\n  }\n\n  /**\n   * The return value of the workflow run.\n   * Polls the workflow return value until the workflow run completes.\n   */\n  get returnValue(): Promise<TResult> {\n    'use step';\n    return this.#pollReturnValue();\n  }\n\n  /**\n   * The name of the workflow.\n   */\n  get workflowName(): Promise<string> {\n    'use step';\n    return this.#lazyWorldPromise.then((world) =>\n      world.runs.get(this.runId).then((run) => run.workflowName)\n    );\n  }\n\n  /**\n   * The timestamp when the workflow run was created.\n   */\n  get createdAt(): Promise<Date> {\n    'use step';\n    return this.#lazyWorldPromise.then((world) =>\n      world.runs.get(this.runId).then((run) => run.createdAt)\n    );\n  }\n\n  /**\n   * The timestamp when the workflow run started execution.\n   * Returns undefined if the workflow has not started yet.\n   */\n  get startedAt(): Promise<Date | undefined> {\n    'use step';\n    return this.#lazyWorldPromise.then((world) =>\n      world.runs.get(this.runId).then((run) => run.startedAt)\n    );\n  }\n\n  /**\n   * The timestamp when the workflow run completed.\n   * Returns undefined if the workflow has not completed yet.\n   */\n  get completedAt(): Promise<Date | undefined> {\n    'use step';\n    return this.#lazyWorldPromise.then((world) =>\n      world.runs.get(this.runId).then((run) => run.completedAt)\n    );\n  }\n\n  /**\n   * The readable stream of the workflow run.\n   */\n  get readable(): WorkflowReadableStream {\n    return this.getReadable();\n  }\n\n  /**\n   * Retrieves the workflow run's default readable stream, which reads chunks\n   * written to the corresponding writable stream {@link getWritable}.\n   *\n   * The returned stream has an additional {@link WorkflowReadableStream.getTailIndex | getTailIndex()}\n   * helper that returns the index of the last known chunk. This is useful when\n   * building reconnection endpoints that need to inform clients where the\n   * stream starts.\n   *\n   * @param options - The options for the readable stream.\n   * @returns A `WorkflowReadableStream` for the workflow run.\n   */\n  getReadable<R = any>(\n    options: WorkflowReadableStreamOptions = {}\n  ): WorkflowReadableStream<R> {\n    'use step';\n    const { ops = [], global = globalThis, startIndex, namespace } = options;\n    const name = getWorkflowRunStreamId(this.runId, namespace);\n    // The resolver starts only on the readable's first pull, so construction\n    // is inert. A consumed empty stream still performs the speculative lookup\n    // to keep the first encrypted-frame path concurrent.\n    const encryptionKey = this.#getEncryptionKeyLazily();\n    const stream = getRunReadableStream<R>(\n      global,\n      ops,\n      this.runId,\n      name,\n      startIndex,\n      encryptionKey\n    );\n\n    const worldPromise = this.#lazyWorldPromise;\n    const runId = this.runId;\n    return Object.assign(stream, {\n      getTailIndex: async (): Promise<number> => {\n        const world = await worldPromise;\n        const info = await world.streams.getInfo(runId, name);\n        return info.tailIndex;\n      },\n    });\n  }\n\n  /** @internal */\n  async #resolveTerminalReturnValue(run: WorkflowRun): Promise<TResult> {\n    if (run.status === 'completed') {\n      const encryptionKey = await this.#getEncryptionKey(run);\n      return await hydrateWorkflowReturnValue(\n        run.output,\n        this.runId,\n        encryptionKey\n      );\n    }\n\n    if (run.status === 'cancelled') {\n      throw new WorkflowRunCancelledError(this.runId);\n    }\n\n    if (run.status === 'failed') {\n      // Hydrate the serialized run error so the original thrown value\n      // (with its type identity, cause chain, etc.) is set as the\n      // `cause` on WorkflowRunFailedError.\n      const encryptionKey = await this.#getEncryptionKey(run);\n      let hydratedError: unknown;\n      try {\n        hydratedError = await hydrateRunError(\n          run.error,\n          this.runId,\n          encryptionKey\n        );\n      } catch {\n        // If hydration fails, surface a generic fallback rather than\n        // leaving the user with a raw Uint8Array. The run's errorCode\n        // is still preserved on the thrown WorkflowRunFailedError.\n        hydratedError = new Error('Failed to hydrate workflow run error');\n      }\n      throw new WorkflowRunFailedError(this.runId, hydratedError, {\n        errorCode: run.errorCode,\n      });\n    }\n\n    // Terminal statuses are immutable, but if an inconsistent world returns\n    // a non-terminal full record, resume polling safely.\n    throw new WorkflowRunNotCompletedError(this.runId, run.status);\n  }\n\n  /**\n   * Polls the workflow return value until the workflow run completes.\n   * @internal\n   * @returns The workflow return value.\n   */\n  async #pollReturnValue(): Promise<TResult> {\n    const world = await this.#lazyWorldPromise;\n\n    // When resilientStart is true, run_created failed and the run may\n    // not exist yet. Retry on WorkflowRunNotFoundError up to 3 times\n    // (1s + 3s + 6s = 10s total) to give the queue time to deliver\n    // and the runtime to create the run via run_started.\n    // When resilientStart is false, 404 is a real error: fail fast.\n    let notFoundRetries = 0;\n    const NOT_FOUND_MAX_RETRIES = this.#resilientStart ? 3 : 0;\n    const NOT_FOUND_DELAYS = [1_000, 3_000, 6_000];\n\n    // Prefer the World's long poll: one read that the backend holds open\n    // until the run finishes, instead of asking again every second and\n    // paying up to a full interval of quantization on a run that already\n    // ended. Worlds that cannot wait do not implement it (see\n    // `Storage['runs'].waitForTerminalStatus`) and this stays the exact\n    // fixed-interval poll it has always been, as does an operator who\n    // throws the `WORKFLOW_RETURN_VALUE_LONG_POLL=0` kill switch.\n    const waitForTerminalStatus = isReturnValueLongPollEnabled()\n      ? world.runs.waitForTerminalStatus?.bind(world.runs)\n      : undefined;\n\n    // Long polls spent so far. Once the cap is reached the loop keeps waiting\n    // but on the interval path, which is the strategy we know is correct; see\n    // `RETURN_VALUE_MAX_LONG_POLLS`. Never a reason to stop awaiting.\n    let longPolls = 0;\n    const maxLongPolls = getReturnValueMaxLongPolls();\n\n    // NOTE: when this poll runs inside a step (e.g. the step that a parent\n    // workflow uses to await a child workflow's `returnValue`), it blocks\n    // a queue worker slot for as long as the child run takes to finish.\n    // Worker-based worlds like `world-postgres` must be sized to cover the\n    // peak number of such polls in flight; see the `queueConcurrency`\n    // default on the Postgres world and the notes in the eager-processing\n    // changelog for details.\n    while (true) {\n      const iterationStartedAt = Date.now();\n      try {\n        // Metadata only, either way: the status is all this iteration needs,\n        // and payload refs are resolved once below, after a terminal status is\n        // observed.\n        const useLongPoll = waitForTerminalStatus && longPolls < maxLongPolls;\n        if (useLongPoll) longPolls++;\n        const runMetadata = useLongPoll\n          ? await waitForTerminalStatus(this.runId, {\n              timeoutMs: getReturnValueWaitTimeoutMs(),\n              resolveData: 'none',\n            })\n          : await world.runs.get(this.runId, {\n              resolveData: 'none',\n            });\n\n        if (runMetadata.status === 'cancelled') {\n          throw new WorkflowRunCancelledError(this.runId);\n        }\n\n        if (PAYLOAD_TERMINAL_RUN_STATUSES.has(runMetadata.status)) {\n          // The polling read above deliberately skips input/output/error refs.\n          // Resolve payloads only once the run reaches a terminal state.\n          const run = await world.runs.get(this.runId, {\n            resolveData: 'all',\n          });\n          return await this.#resolveTerminalReturnValue(run);\n        }\n\n        // Run not completed yet: sleep and poll again.\n        throw new WorkflowRunNotCompletedError(this.runId, runMetadata.status);\n      } catch (error) {\n        if (WorkflowRunNotCompletedError.is(error)) {\n          // Space consecutive non-terminal observations at least one poll\n          // interval apart. On the plain-poll path that is the familiar fixed\n          // sleep; on the long-poll path the wait has usually already\n          // outlasted the interval and this is a no-op, but it also means a\n          // World whose wait returns early (a backend with no long poll, a\n          // clamped budget) degrades to interval polling instead of spinning.\n          const remainingIntervalMs =\n            getReturnValuePollIntervalMs() - (Date.now() - iterationStartedAt);\n          if (remainingIntervalMs > 0) {\n            await new Promise((resolve) =>\n              setTimeout(resolve, remainingIntervalMs)\n            );\n          }\n          continue;\n        }\n        if (\n          WorkflowRunNotFoundError.is(error) &&\n          notFoundRetries < NOT_FOUND_MAX_RETRIES\n        ) {\n          const delay = NOT_FOUND_DELAYS[notFoundRetries]!;\n          notFoundRetries++;\n          await new Promise((resolve) => setTimeout(resolve, delay));\n          continue;\n        }\n        throw error;\n      }\n    }\n  }\n}\n\n/**\n * Retrieves a `Run` object for a given run ID.\n *\n * @param runId - The workflow run ID obtained from {@link start}.\n * @returns A `Run` object.\n * @throws WorkflowRunNotFoundError if the run ID is not found.\n */\nexport function getRun<TResult>(runId: string): Run<TResult> {\n  return new Run(runId);\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"run.js","sourceRoot":"","sources":["../../src/runtime/run.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  RunExpiredError,\n  WorkflowRunCancelledError,\n  WorkflowRunFailedError,\n  WorkflowRunNotCompletedError,\n  WorkflowRunNotFoundError,\n} from '@workflow/errors';\nimport { WORKFLOW_DESERIALIZE, WORKFLOW_SERIALIZE } from '@workflow/serde';\nimport type { WorkflowRun, WorkflowRunStatus, World } from '@workflow/world';\nimport { envNumber } from '@workflow/world/env-config';\nimport { SPEC_VERSION_CURRENT } from '@workflow/world/spec-version';\nimport {\n  deriveRunPayloadKeys,\n  type PayloadKey,\n} from '../serialization/encryption.js';\nimport {\n  createForwardedWritable,\n  getForwardedWritableEncryptionKey,\n  getRunReadableStream,\n  hydrateRunError,\n  hydrateWorkflowReturnValue,\n  tagForwardedWritableTarget,\n} from '../serialization.js';\nimport { getWorkflowRunStreamId } from '../util.js';\nimport { getWorldLazy } from './get-world-lazy.js';\nimport {\n  type CancelRunOptions,\n  type StopSleepOptions,\n  type StopSleepResult,\n  wakeUpRun,\n} from './runs.js';\n\nconst RETURN_VALUE_POLL_INTERVAL_MS = 1_000;\nconst PAYLOAD_TERMINAL_RUN_STATUSES = new Set<WorkflowRunStatus>([\n  'completed',\n  'failed',\n]);\n\n// Give resilient starts up to 10 seconds to create the run.\nconst NOT_FOUND_RETRY_DELAYS = [1_000, 3_000, 6_000];\n\n/** @internal */\nexport function getReturnValuePollIntervalMs(): number {\n  return envNumber(\n    'WORKFLOW_RETURN_VALUE_POLL_INTERVAL_MS',\n    RETURN_VALUE_POLL_INTERVAL_MS,\n    { integer: true, min: 1 }\n  );\n}\n\n/**\n * How long a single `runs.waitForTerminalStatus` call may block while waiting\n * for a run to finish. The wait is re-issued until the run is terminal, so\n * this is a per-call budget rather than a limit on total wait time: its only\n * job is to bound one request so a stalled connection cannot hold the awaiting\n * side forever.\n *\n * 50s is the largest budget `world-vercel` can actually request: it clamps to\n * `REQUEST_TIMEOUT_MS` (60s) minus 10s of headroom, so the budget is always\n * observed as a *response* (a non-terminal snapshot) rather than as a\n * client-side timeout. Asking for more is silently reduced to that, so raising\n * this without also raising `WORKFLOW_REQUEST_TIMEOUT_MS` has no effect.\n */\nconst RETURN_VALUE_WAIT_TIMEOUT_MS = 50_000;\n\n/** @internal */\nexport function getReturnValueWaitTimeoutMs(): number {\n  return envNumber(\n    'WORKFLOW_RETURN_VALUE_WAIT_MS',\n    RETURN_VALUE_WAIT_TIMEOUT_MS,\n    { integer: true, min: 1 }\n  );\n}\n\n/**\n * How many consecutive long-poll calls `await run.returnValue` will make\n * before falling back to interval polling for the rest of the wait.\n *\n * A cap is worth having because a wait that keeps returning non-terminal is\n * indistinguishable from one that is not working, and interval polling is the\n * behavior we know is correct. It does **not** end the await: a run legitimately\n * lasts hours or days, so exhausting the cap switches strategy and keeps\n * waiting rather than throwing.\n *\n * Note the consequence, since it cuts against the reason the long poll exists:\n * a run still going after `MAX x budget` (~8 minutes at the defaults) spends\n * the remainder of its life polling once per\n * `WORKFLOW_RETURN_VALUE_POLL_INTERVAL_MS`, which is more requests than\n * continuing to long poll would have cost. Runs that outlive the cap are\n * exactly the ones the request reduction helped most.\n */\nconst RETURN_VALUE_MAX_LONG_POLLS = 10;\n\n/** @internal */\nexport function getReturnValueMaxLongPolls(): number {\n  return envNumber(\n    'WORKFLOW_RETURN_VALUE_MAX_LONG_POLLS',\n    RETURN_VALUE_MAX_LONG_POLLS,\n    { integer: true, min: 1 }\n  );\n}\n\n/**\n * Whether `await run.returnValue` may use the World's long poll\n * (`runs.waitForTerminalStatus`) instead of interval-polling `runs.get`.\n *\n * Default **ON** wherever the World implements the method; a World that does\n * not is already on the interval path with nothing to switch off. Reads\n * `process.env.WORKFLOW_RETURN_VALUE_LONG_POLL` lazily; an explicit `'0'` /\n * `'false'` is the kill switch, restoring the fixed-interval poll exactly as\n * it behaved before the fast path existed.\n *\n * @internal\n */\nexport function isReturnValueLongPollEnabled(): boolean {\n  const raw = process.env.WORKFLOW_RETURN_VALUE_LONG_POLL;\n  if (raw === undefined || raw === '') return true;\n  return !(raw === '0' || raw.toLowerCase() === 'false');\n}\n\n/**\n * A `ReadableStream` extended with workflow-specific helpers.\n */\nexport type WorkflowReadableStream<R = any> = ReadableStream<R> & {\n  /**\n   * Returns the tail index (index of the last known chunk, 0-based) of the\n   * underlying workflow stream. Useful for resolving a negative `startIndex`\n   * into an absolute position, for example, when building reconnection\n   * endpoints that need to inform the client where the stream starts.\n   *\n   * Returns `-1` when no chunks have been written yet.\n   */\n  getTailIndex(): Promise<number>;\n};\n\n/**\n * Options for configuring a workflow's readable stream.\n */\nexport interface WorkflowReadableStreamOptions {\n  /**\n   * An optional namespace to distinguish between multiple streams associated\n   * with the same workflow run.\n   */\n  namespace?: string;\n  /**\n   * The index number of the starting chunk to begin reading the stream from.\n   * Negative values start from the end (e.g. -3 reads the last 3 chunks).\n   */\n  startIndex?: number;\n  /**\n   * Any asynchronous operations to complete before pausing or terminating the\n   * execution environment\n   * (i.e. using [`waitUntil()`](https://developer.mozilla.org/docs/Web/API/ExtendableEvent/waitUntil) or similar).\n   */\n  ops?: Promise<any>[];\n  /**\n   * The global object to use for hydrating types from the global scope.\n   *\n   * Defaults to {@link [`globalThis`](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/globalThis)}.\n   */\n  global?: Record<string, any>;\n}\n\n/**\n * Options for configuring a writable onto a workflow run's stream.\n */\nexport interface WorkflowRunWritableStreamOptions {\n  /**\n   * An optional namespace to distinguish between multiple streams associated\n   * with the same workflow run.\n   */\n  namespace?: string;\n  /**\n   * Any asynchronous operations to complete before pausing or terminating the\n   * execution environment\n   * (i.e. using [`waitUntil()`](https://developer.mozilla.org/docs/Web/API/ExtendableEvent/waitUntil) or similar).\n   *\n   * Writes are acknowledged on buffer entry, so a caller that needs them\n   * durable before the environment goes away should pass an array here and\n   * await it after releasing the writer lock.\n   */\n  ops?: Promise<any>[];\n  /**\n   * The global object to use for reducing types from the global scope.\n   *\n   * Defaults to {@link [`globalThis`](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/globalThis)}.\n   */\n  global?: Record<string, any>;\n}\n\n/**\n * A handler class for a workflow run.\n */\nexport class Run<TResult> {\n  static [WORKFLOW_SERIALIZE](instance: Run<unknown>) {\n    return { runId: instance.runId, resilientStart: instance.#resilientStart };\n  }\n\n  static [WORKFLOW_DESERIALIZE](data: {\n    runId: string;\n    resilientStart?: boolean;\n  }) {\n    return new Run(data.runId, { resilientStart: data.resilientStart });\n  }\n\n  /**\n   * The ID of the workflow run.\n   */\n  runId: string;\n\n  /**\n   * The world object.\n   * @internal\n   */\n  #worldPromise: Promise<World> | undefined;\n  get #lazyWorldPromise() {\n    if (!this.#worldPromise) this.#worldPromise = getWorldLazy();\n    return this.#worldPromise;\n  }\n\n  /**\n   * Cached encryption key resolution. Resolved once on first use and\n   * reused for returnValue, getReadable(), etc.\n   * @internal\n   */\n  #encryptionKeyPromise: Promise<PayloadKey | undefined> | null = null;\n\n  /**\n   * When true, run_created failed and the run may not exist yet (the\n   * resilient start path will create it via run_started). pollReturnValue\n   * retries on WorkflowRunNotFoundError only when this flag is set so\n   * that normal runs fail fast on 404.\n   * @internal\n   */\n  #resilientStart = false;\n\n  constructor(runId: string, opts?: { resilientStart?: boolean }) {\n    this.runId = runId;\n    this.#resilientStart = opts?.resilientStart ?? false;\n  }\n\n  /**\n   * Resolves and caches the encryption key for this run.\n   * The key is the same for the lifetime of a run, so it only needs\n   * to be resolved once.\n   * @internal\n   */\n  #getEncryptionKey(run?: WorkflowRun): Promise<PayloadKey | undefined> {\n    if (!this.#encryptionKeyPromise) {\n      this.#encryptionKeyPromise = (async () => {\n        const world = await this.#lazyWorldPromise;\n        const runData = run ?? (await world.runs.get(this.runId));\n        const rawKey = await world.getEncryptionKeyForRun?.(runData);\n        return rawKey ? await deriveRunPayloadKeys(rawKey) : undefined;\n      })();\n    }\n    return this.#encryptionKeyPromise;\n  }\n\n  /**\n   * Defers fetching the run and its encryption key until a readable is first\n   * consumed. The first pull prefetches it so an encrypted first frame can join\n   * the lookup; this also applies to an empty consumed stream.\n   * @internal\n   */\n  #getEncryptionKeyLazily(): () => Promise<PayloadKey | undefined> {\n    return () => this.#getEncryptionKey();\n  }\n\n  /**\n   * Interrupts pending `sleep()` calls, resuming the workflow early.\n   *\n   * @param options - Optional settings to target specific sleep calls by correlation ID.\n   *   If not provided, all pending sleep calls will be interrupted.\n   * @returns A {@link StopSleepResult} object containing the number of sleep calls that were interrupted.\n   */\n  async wakeUp(options?: StopSleepOptions): Promise<StopSleepResult> {\n    'use step';\n    return wakeUpRun(await this.#lazyWorldPromise, this.runId, options);\n  }\n\n  /**\n   * Cancels the workflow run.\n   *\n   * @param options - Optional cancellation settings. `cancelReason` records a\n   *   free-text reason (max 512 chars) on the run_cancelled event, surfaced in\n   *   the run detail view.\n   */\n  async cancel(options?: CancelRunOptions): Promise<void> {\n    'use step';\n    const world = await this.#lazyWorldPromise;\n    await world.events.create(this.runId, {\n      eventType: 'run_cancelled',\n      specVersion: SPEC_VERSION_CURRENT,\n      ...(options?.cancelReason !== undefined\n        ? { eventData: { cancelReason: options.cancelReason } }\n        : {}),\n    });\n  }\n\n  /**\n   * Whether the workflow run exists.\n   */\n  get exists(): Promise<boolean> {\n    'use step';\n    return this.#lazyWorldPromise.then((world) =>\n      world.runs\n        .get(this.runId, { resolveData: 'none' })\n        .then(() => true)\n        .catch((error) => {\n          if (WorkflowRunNotFoundError.is(error)) {\n            return false;\n          }\n          throw error;\n        })\n    );\n  }\n\n  /**\n   * The status of the workflow run.\n   */\n  get status(): Promise<WorkflowRunStatus> {\n    'use step';\n    return this.#lazyWorldPromise.then((world) =>\n      world.runs\n        .get(this.runId, { resolveData: 'none' })\n        .then((run) => run.status)\n    );\n  }\n\n  /**\n   * The return value of the workflow run.\n   * Polls the workflow return value until the workflow run completes.\n   */\n  get returnValue(): Promise<TResult> {\n    'use step';\n    return this.#pollReturnValue();\n  }\n\n  /**\n   * The name of the workflow.\n   */\n  get workflowName(): Promise<string> {\n    'use step';\n    return this.#lazyWorldPromise.then((world) =>\n      world.runs.get(this.runId).then((run) => run.workflowName)\n    );\n  }\n\n  /**\n   * The timestamp when the workflow run was created.\n   */\n  get createdAt(): Promise<Date> {\n    'use step';\n    return this.#lazyWorldPromise.then((world) =>\n      world.runs.get(this.runId).then((run) => run.createdAt)\n    );\n  }\n\n  /**\n   * The timestamp when the workflow run started execution.\n   * Returns undefined if the workflow has not started yet.\n   */\n  get startedAt(): Promise<Date | undefined> {\n    'use step';\n    return this.#lazyWorldPromise.then((world) =>\n      world.runs.get(this.runId).then((run) => run.startedAt)\n    );\n  }\n\n  /**\n   * The timestamp when the workflow run completed.\n   * Returns undefined if the workflow has not completed yet.\n   */\n  get completedAt(): Promise<Date | undefined> {\n    'use step';\n    return this.#lazyWorldPromise.then((world) =>\n      world.runs.get(this.runId).then((run) => run.completedAt)\n    );\n  }\n\n  /**\n   * The readable stream of the workflow run.\n   */\n  get readable(): WorkflowReadableStream {\n    return this.getReadable();\n  }\n\n  /**\n   * Retrieves the workflow run's default readable stream, which reads chunks\n   * written to the corresponding writable stream {@link getWritable}.\n   *\n   * The returned stream has an additional {@link WorkflowReadableStream.getTailIndex | getTailIndex()}\n   * helper that returns the index of the last known chunk. This is useful when\n   * building reconnection endpoints that need to inform clients where the\n   * stream starts.\n   *\n   * @param options - The options for the readable stream.\n   * @returns A `WorkflowReadableStream` for the workflow run.\n   */\n  getReadable<R = any>(\n    options: WorkflowReadableStreamOptions = {}\n  ): WorkflowReadableStream<R> {\n    'use step';\n    const { ops = [], global = globalThis, startIndex, namespace } = options;\n    const name = getWorkflowRunStreamId(this.runId, namespace);\n    // The resolver starts only on the readable's first pull, so construction\n    // is inert. A consumed empty stream still performs the speculative lookup\n    // to keep the first encrypted-frame path concurrent.\n    const encryptionKey = this.#getEncryptionKeyLazily();\n    const stream = getRunReadableStream<R>(\n      global,\n      ops,\n      this.runId,\n      name,\n      startIndex,\n      encryptionKey\n    );\n\n    const worldPromise = this.#lazyWorldPromise;\n    const runId = this.runId;\n    return Object.assign(stream, {\n      getTailIndex: async (): Promise<number> => {\n        const world = await worldPromise;\n        const info = await world.streams.getInfo(runId, name);\n        return info.tailIndex;\n      },\n    });\n  }\n\n  /** The writable stream of the workflow run. */\n  get writable(): WritableStream {\n    return this.getWritable();\n  }\n\n  /**\n   * Returns a writable that appends to this run's stream.\n   *\n   * Initialization is deferred until the first write. The run must already\n   * exist. The writable may be forwarded through `start()` and into steps, but\n   * grants no read access or additional authorization.\n   *\n   * @remarks\n   * `writer.close()` closes the shared stream. Contributors should call\n   * `releaseLock()`, which also drains pending writes.\n   *\n   * @param options - The writable stream options.\n   */\n  getWritable<W = any>(\n    options: WorkflowRunWritableStreamOptions = {}\n  ): WritableStream<W> {\n    'use step';\n    const { ops = [], global = globalThis, namespace } = options;\n    const name = getWorkflowRunStreamId(this.runId, namespace);\n    let targetPromise:\n      | Promise<{\n          key: PayloadKey | undefined;\n          deploymentId?: string;\n          encryptionPublicKey?: string;\n        }>\n      | undefined;\n    let writable: WritableStream<W>;\n\n    const resolveTarget = () => {\n      targetPromise ??= this.#getMetadata().then(async (run) => {\n        const target = {\n          key: await getForwardedWritableEncryptionKey(\n            this.runId,\n            run.deploymentId,\n            run.encryptionPublicKey\n          ),\n          deploymentId: run.deploymentId,\n          encryptionPublicKey: run.encryptionPublicKey,\n        };\n        tagForwardedWritableTarget(writable, target);\n        return target;\n      });\n      return targetPromise;\n    };\n\n    writable = createForwardedWritable<W>({\n      global,\n      ops,\n      runId: this.runId,\n      name,\n      key: () => resolveTarget().then(({ key }) => key),\n    });\n    return writable;\n  }\n\n  /** Reads metadata, briefly retrying resilient starts. @internal */\n  async #getMetadata() {\n    const world = await this.#lazyWorldPromise;\n    const maxRetries = this.#resilientStart ? NOT_FOUND_RETRY_DELAYS.length : 0;\n    let attempt = 0;\n    while (true) {\n      try {\n        return await world.runs.get(this.runId, { resolveData: 'none' });\n      } catch (error) {\n        if (!WorkflowRunNotFoundError.is(error) || attempt >= maxRetries) {\n          throw error;\n        }\n        const delay = NOT_FOUND_RETRY_DELAYS[attempt]!;\n        attempt++;\n        await new Promise((resolve) => setTimeout(resolve, delay));\n      }\n    }\n  }\n\n  /** @internal */\n  async #resolveTerminalReturnValue(run: WorkflowRun): Promise<TResult> {\n    // Expiry is checked before the status branches, and deliberately so.\n    //\n    // Past its retention boundary a run's payloads are gone but its metadata\n    // usually is not, so `run.output` and `run.error` hydrate to an\n    // expired-data placeholder rather than to anything the caller asked for.\n    // Handing that back as if it were the return value — or wrapping it as\n    // the `cause` of a WorkflowRunFailedError — is worse than failing: it is\n    // indistinguishable from the workflow having genuinely returned it.\n    //\n    // A run started with `experimental_retention: 0` reaches this almost\n    // immediately (its purge races, and usually beats, the caller's own read\n    // of the result). An ordinary run reaches it whenever it is read after\n    // the World's default window. Both are the same condition and get the\n    // same terminal, non-retryable error, carrying whatever metadata\n    // survived so the caller can still tell success from failure.\n    //\n    // When even the metadata is gone the World reports the run as missing and\n    // the caller gets WorkflowRunNotFoundError from the read above instead —\n    // there is nothing left here to describe.\n    const expiredAt = run.expiredAt;\n    if (expiredAt != null && expiredAt <= new Date()) {\n      throw new RunExpiredError(\n        `Run \"${this.runId}\" ${run.status === 'completed' ? 'completed' : `is ${run.status}`}, but its data expired at ${expiredAt.toISOString()} and is no longer readable.`,\n        this.runId,\n        run.status,\n        expiredAt\n      );\n    }\n\n    if (run.status === 'completed') {\n      const encryptionKey = await this.#getEncryptionKey(run);\n      return await hydrateWorkflowReturnValue(\n        run.output,\n        this.runId,\n        encryptionKey\n      );\n    }\n\n    if (run.status === 'cancelled') {\n      throw new WorkflowRunCancelledError(this.runId);\n    }\n\n    if (run.status === 'failed') {\n      // Hydrate the serialized run error so the original thrown value\n      // (with its type identity, cause chain, etc.) is set as the\n      // `cause` on WorkflowRunFailedError.\n      const encryptionKey = await this.#getEncryptionKey(run);\n      let hydratedError: unknown;\n      try {\n        hydratedError = await hydrateRunError(\n          run.error,\n          this.runId,\n          encryptionKey\n        );\n      } catch {\n        // If hydration fails, surface a generic fallback rather than\n        // leaving the user with a raw Uint8Array. The run's errorCode\n        // is still preserved on the thrown WorkflowRunFailedError.\n        hydratedError = new Error('Failed to hydrate workflow run error');\n      }\n      throw new WorkflowRunFailedError(this.runId, hydratedError, {\n        errorCode: run.errorCode,\n      });\n    }\n\n    // Terminal statuses are immutable, but if an inconsistent world returns\n    // a non-terminal full record, resume polling safely.\n    throw new WorkflowRunNotCompletedError(this.runId, run.status);\n  }\n\n  /**\n   * Polls the workflow return value until the workflow run completes.\n   * @internal\n   * @returns The workflow return value.\n   */\n  async #pollReturnValue(): Promise<TResult> {\n    const world = await this.#lazyWorldPromise;\n\n    // When resilientStart is true, run_created failed and the run may\n    // not exist yet. Retry on WorkflowRunNotFoundError up to 3 times\n    // (1s + 3s + 6s = 10s total) to give the queue time to deliver\n    // and the runtime to create the run via run_started.\n    // When resilientStart is false, 404 is a real error: fail fast.\n    let notFoundRetries = 0;\n    const NOT_FOUND_MAX_RETRIES = this.#resilientStart\n      ? NOT_FOUND_RETRY_DELAYS.length\n      : 0;\n\n    // Prefer the World's long poll: one read that the backend holds open\n    // until the run finishes, instead of asking again every second and\n    // paying up to a full interval of quantization on a run that already\n    // ended. Worlds that cannot wait do not implement it (see\n    // `Storage['runs'].waitForTerminalStatus`) and this stays the exact\n    // fixed-interval poll it has always been, as does an operator who\n    // throws the `WORKFLOW_RETURN_VALUE_LONG_POLL=0` kill switch.\n    const waitForTerminalStatus = isReturnValueLongPollEnabled()\n      ? world.runs.waitForTerminalStatus?.bind(world.runs)\n      : undefined;\n\n    // Long polls spent so far. Once the cap is reached the loop keeps waiting\n    // but on the interval path, which is the strategy we know is correct; see\n    // `RETURN_VALUE_MAX_LONG_POLLS`. Never a reason to stop awaiting.\n    let longPolls = 0;\n    const maxLongPolls = getReturnValueMaxLongPolls();\n\n    // NOTE: when this poll runs inside a step (e.g. the step that a parent\n    // workflow uses to await a child workflow's `returnValue`), it blocks\n    // a queue worker slot for as long as the child run takes to finish.\n    // Worker-based worlds like `world-postgres` must be sized to cover the\n    // peak number of such polls in flight; see the `queueConcurrency`\n    // default on the Postgres world and the notes in the eager-processing\n    // changelog for details.\n    while (true) {\n      const iterationStartedAt = Date.now();\n      try {\n        // Metadata only, either way: the status is all this iteration needs,\n        // and payload refs are resolved once below, after a terminal status is\n        // observed.\n        const useLongPoll = waitForTerminalStatus && longPolls < maxLongPolls;\n        if (useLongPoll) longPolls++;\n        const runMetadata = useLongPoll\n          ? await waitForTerminalStatus(this.runId, {\n              timeoutMs: getReturnValueWaitTimeoutMs(),\n              resolveData: 'none',\n            })\n          : await world.runs.get(this.runId, {\n              resolveData: 'none',\n            });\n\n        if (runMetadata.status === 'cancelled') {\n          throw new WorkflowRunCancelledError(this.runId);\n        }\n\n        if (PAYLOAD_TERMINAL_RUN_STATUSES.has(runMetadata.status)) {\n          // The polling read above deliberately skips input/output/error refs.\n          // Resolve payloads only once the run reaches a terminal state.\n          const run = await world.runs.get(this.runId, {\n            resolveData: 'all',\n          });\n          return await this.#resolveTerminalReturnValue(run);\n        }\n\n        // Run not completed yet: sleep and poll again.\n        throw new WorkflowRunNotCompletedError(this.runId, runMetadata.status);\n      } catch (error) {\n        if (WorkflowRunNotCompletedError.is(error)) {\n          // Space consecutive non-terminal observations at least one poll\n          // interval apart. On the plain-poll path that is the familiar fixed\n          // sleep; on the long-poll path the wait has usually already\n          // outlasted the interval and this is a no-op, but it also means a\n          // World whose wait returns early (a backend with no long poll, a\n          // clamped budget) degrades to interval polling instead of spinning.\n          const remainingIntervalMs =\n            getReturnValuePollIntervalMs() - (Date.now() - iterationStartedAt);\n          if (remainingIntervalMs > 0) {\n            await new Promise((resolve) =>\n              setTimeout(resolve, remainingIntervalMs)\n            );\n          }\n          continue;\n        }\n        if (\n          WorkflowRunNotFoundError.is(error) &&\n          notFoundRetries < NOT_FOUND_MAX_RETRIES\n        ) {\n          const delay = NOT_FOUND_RETRY_DELAYS[notFoundRetries]!;\n          notFoundRetries++;\n          await new Promise((resolve) => setTimeout(resolve, delay));\n          continue;\n        }\n        throw error;\n      }\n    }\n  }\n}\n\n/**\n * Retrieves a `Run` object for a given run ID.\n *\n * @param runId - The workflow run ID obtained from {@link start}.\n * @returns A `Run` object.\n * @throws WorkflowRunNotFoundError if the run ID is not found.\n */\nexport function getRun<TResult>(runId: string): Run<TResult> {\n  return new Run(runId);\n}\n"]}

package/dist/runtime/start.d.ts

@@ -1,4 +1,4 @@
-import type { World } from '@workflow/world';
+import type { RunRetention, World } from '@workflow/world';
 import { Run } from './run.js';
 /**
  * Reset the `deploymentId: 'latest'` no-op warn-once guard. Test-only,
@@ -48,6 +48,36 @@ export interface StartOptionsBase {
      * the `setAttributes` option of the same name.
      */
     allowReservedAttributes?: boolean;
+    /**
+     * Set a preference for data retention after run completion.
+     *
+     * **Experimental.** Both the unit and the set of accepted values are expected
+     * to change.
+     *
+     * Worlds control the retention of user data (event payloads and stream
+     * chunks), the event log, and any analytics data. Options are:
+     * - `'default'`: same as omission, the World will decide. On Vercel, this
+     *   is based on your team's plan.
+     * - `0`: data is deleted as soon as your run completes or fails. On
+     *   Vercel, user data is deleted, but metadata may persist for your plan's
+     *   default retention period.
+     *
+     * The value is a duration, with zero being the only valid option currently.
+     *
+     * **Known limitation at `0`.** The purge races your own read of the run's
+     * result and generally wins, so `await run.returnValue` on a
+     * `experimental_retention: 0` run usually throws `RunExpiredError` rather
+     * than resolving. If you need the result, return it through a channel you
+     * control, e.g. a step that writes it to external storage.
+     *
+     * Recorded on the run as the reserved `$retention` attribute, so it
+     * requires a World implementing spec version 4 or later. `'default'` is
+     * not written at all, keeping it exactly equivalent to omitting the
+     * option. Retention is enforced by the World: the first-party Worlds
+     * (Vercel, Local, Postgres) implement it, and a World that does not
+     * recognize the value keeps the data.
+     */
+    experimental_retention?: RunRetention;
     /**
      * The ID of an existing run this run is being replayed from, if any.
      *

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

@@ -1 +1 @@
-{"version":3,"file":"start.d.ts","sourceRoot":"","sources":["../../src/runtime/start.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAyB,KAAK,EAAE,MAAM,iBAAiB,CAAC;AAmCpE,OAAO,EAAE,GAAG,EAAE,MAAM,UAAU,CAAC;AAqD/B;;;;;GAKG;AACH,wBAAgB,4BAA4B,IAAI,IAAI,CAEnD;AAED,MAAM,WAAW,gBAAgB;IAC/B;;;OAGG;IACH,KAAK,CAAC,EAAE,KAAK,CAAC;IAEd;;OAEG;IACH,WAAW,CAAC,EAAE,MAAM,CAAC;IAErB;;;;;;;;;;OAUG;IACH,MAAM,CAAC,EAAE,MAAM,CAAC;IAEhB;;;;OAIG;IACH,UAAU,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAEpC;;;;;;;;;;;OAWG;IACH,uBAAuB,CAAC,EAAE,OAAO,CAAC;IAElC;;;;;;;;;;;;OAYG;IACH,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAC3B;;;;;;;;;;;;OAYG;IACH,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB;AAED,MAAM,WAAW,4BAA6B,SAAQ,gBAAgB;IACpE;;;;;;;;;;;;;;;OAeG;IACH,YAAY,EAAE,QAAQ,GAAG,CAAC,MAAM,GAAG,EAAE,CAAC,CAAC;CACxC;AAED,MAAM,WAAW,+BAAgC,SAAQ,gBAAgB;IACvE,YAAY,CAAC,EAAE,SAAS,CAAC;CAC1B;AAED;;GAEG;AACH,MAAM,MAAM,YAAY,GACpB,4BAA4B,GAC5B,+BAA+B,CAAC;AAEpC;;GAEG;AACH,MAAM,MAAM,gBAAgB,CAAC,KAAK,SAAS,OAAO,EAAE,EAAE,OAAO,IAAI,CAC/D,GAAG,IAAI,EAAE,KAAK,KACX,OAAO,CAAC,OAAO,CAAC,CAAC;AAEtB;;GAEG;AACH,MAAM,MAAM,gBAAgB,GAAG;IAAE,UAAU,EAAE,MAAM,CAAA;CAAE,CAAC;AAEtD;;;;;;;GAOG;AAIH,wBAAgB,KAAK,CAAC,KAAK,SAAS,OAAO,EAAE,EAAE,OAAO,EACpD,QAAQ,EAAE,gBAAgB,CAAC,KAAK,EAAE,OAAO,CAAC,GAAG,gBAAgB,EAC7D,IAAI,EAAE,OAAO,EAAE,EACf,OAAO,EAAE,4BAA4B,GACpC,OAAO,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC,CAAC;AAEzB,wBAAgB,KAAK,CAAC,OAAO,EAC3B,QAAQ,EAAE,gBAAgB,CAAC,EAAE,EAAE,OAAO,CAAC,GAAG,gBAAgB,EAC1D,OAAO,EAAE,4BAA4B,GACpC,OAAO,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC,CAAC;AAGzB,wBAAgB,KAAK,CAAC,KAAK,SAAS,OAAO,EAAE,EAAE,OAAO,EACpD,QAAQ,EAAE,gBAAgB,CAAC,KAAK,EAAE,OAAO,CAAC,GAAG,gBAAgB,EAC7D,IAAI,EAAE,KAAK,EACX,OAAO,CAAC,EAAE,+BAA+B,GACxC,OAAO,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC,CAAC;AAEzB,wBAAgB,KAAK,CAAC,OAAO,EAC3B,QAAQ,EAAE,gBAAgB,CAAC,EAAE,EAAE,OAAO,CAAC,GAAG,gBAAgB,EAC1D,OAAO,CAAC,EAAE,+BAA+B,GACxC,OAAO,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC,CAAC"}
+{"version":3,"file":"start.d.ts","sourceRoot":"","sources":["../../src/runtime/start.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EACV,YAAY,EAEZ,KAAK,EACN,MAAM,iBAAiB,CAAC;AAoCzB,OAAO,EAAE,GAAG,EAAE,MAAM,UAAU,CAAC;AA4D/B;;;;;GAKG;AACH,wBAAgB,4BAA4B,IAAI,IAAI,CAEnD;AAED,MAAM,WAAW,gBAAgB;IAC/B;;;OAGG;IACH,KAAK,CAAC,EAAE,KAAK,CAAC;IAEd;;OAEG;IACH,WAAW,CAAC,EAAE,MAAM,CAAC;IAErB;;;;;;;;;;OAUG;IACH,MAAM,CAAC,EAAE,MAAM,CAAC;IAEhB;;;;OAIG;IACH,UAAU,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAEpC;;;;;;;;;;;OAWG;IACH,uBAAuB,CAAC,EAAE,OAAO,CAAC;IAElC;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA4BG;IACH,sBAAsB,CAAC,EAAE,YAAY,CAAC;IAEtC;;;;;;;;;;;;OAYG;IACH,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAC3B;;;;;;;;;;;;OAYG;IACH,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB;AAED,MAAM,WAAW,4BAA6B,SAAQ,gBAAgB;IACpE;;;;;;;;;;;;;;;OAeG;IACH,YAAY,EAAE,QAAQ,GAAG,CAAC,MAAM,GAAG,EAAE,CAAC,CAAC;CACxC;AAED,MAAM,WAAW,+BAAgC,SAAQ,gBAAgB;IACvE,YAAY,CAAC,EAAE,SAAS,CAAC;CAC1B;AAED;;GAEG;AACH,MAAM,MAAM,YAAY,GACpB,4BAA4B,GAC5B,+BAA+B,CAAC;AAEpC;;GAEG;AACH,MAAM,MAAM,gBAAgB,CAAC,KAAK,SAAS,OAAO,EAAE,EAAE,OAAO,IAAI,CAC/D,GAAG,IAAI,EAAE,KAAK,KACX,OAAO,CAAC,OAAO,CAAC,CAAC;AAEtB;;GAEG;AACH,MAAM,MAAM,gBAAgB,GAAG;IAAE,UAAU,EAAE,MAAM,CAAA;CAAE,CAAC;AAEtD;;;;;;;GAOG;AAIH,wBAAgB,KAAK,CAAC,KAAK,SAAS,OAAO,EAAE,EAAE,OAAO,EACpD,QAAQ,EAAE,gBAAgB,CAAC,KAAK,EAAE,OAAO,CAAC,GAAG,gBAAgB,EAC7D,IAAI,EAAE,OAAO,EAAE,EACf,OAAO,EAAE,4BAA4B,GACpC,OAAO,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC,CAAC;AAEzB,wBAAgB,KAAK,CAAC,OAAO,EAC3B,QAAQ,EAAE,gBAAgB,CAAC,EAAE,EAAE,OAAO,CAAC,GAAG,gBAAgB,EAC1D,OAAO,EAAE,4BAA4B,GACpC,OAAO,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC,CAAC;AAGzB,wBAAgB,KAAK,CAAC,KAAK,SAAS,OAAO,EAAE,EAAE,OAAO,EACpD,QAAQ,EAAE,gBAAgB,CAAC,KAAK,EAAE,OAAO,CAAC,GAAG,gBAAgB,EAC7D,IAAI,EAAE,KAAK,EACX,OAAO,CAAC,EAAE,+BAA+B,GACxC,OAAO,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC,CAAC;AAEzB,wBAAgB,KAAK,CAAC,OAAO,EAC3B,QAAQ,EAAE,gBAAgB,CAAC,EAAE,EAAE,OAAO,CAAC,GAAG,gBAAgB,EAC1D,OAAO,CAAC,EAAE,+BAA+B,GACxC,OAAO,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC,CAAC"}