@workflow/core 5.0.0-beta.3 → 5.0.0-beta.31

package/dist/runtime/wait-continuation.d.ts

@@ -0,0 +1,84 @@
+/**
+ * Wait-continuation dispatch: delay + idempotency-key selection.
+ *
+ * When V2 suspension processing observes a pending wait, it enqueues a
+ * delayed "continuation" message that fires once the wait elapses and
+ * drives the next replay (which completes the wait via the "complete
+ * elapsed waits" pass). This module decides the message's `delaySeconds`
+ * and `idempotencyKey`.
+ *
+ * The continuation is keyed on the wait's correlationId: while a wait is
+ * pending, every replay pass over the run re-observes it (e.g., once per
+ * step completion in `Promise.all([steps..., sleep()])`), and without
+ * dedupe each pass would enqueue another delayed continuation — each one
+ * a spurious full replay when the wait elapses, and each a fresh message
+ * that resets the delivery-attempt runaway guard. A key is attached in
+ * all cases: some worlds (e.g. world-postgres) serialize key-less
+ * workflow messages per run, which would park the continuation behind
+ * the handler's own inline step execution and defeat the race semantics
+ * the continuation exists to provide.
+ *
+ * The bare correlationId cannot be the key in every case, though: world
+ * dedupe windows outlive the first delivery (VQS keeps idempotency
+ * records until message-retention TTL; world-postgres keeps a
+ * completed-keys cache), so once a key has been used, a later enqueue
+ * under the same key is silently dropped. Any situation where a
+ * continuation is delivered while its wait is still pending therefore
+ * needs a fresh key for the re-enqueue, or the wait's timer is lost and
+ * the run stalls until unrelated traffic happens to wake it. Two such
+ * situations exist, each with its own key variation:
+ *
+ * - Waits longer than the maximum queue delay are chained: the delay is
+ *   clamped to `WAIT_CONTINUATION_MAX_DELAY_SECONDS` (23h — VQS messages
+ *   have a 24h retention limit, and one hour of buffer matches
+ *   world-vercel's own clamp for delayed re-enqueues), so the
+ *   continuation intentionally fires early, re-observes the wait, and
+ *   must enqueue the next hop. The key is suffixed with the hop index
+ *   (`ceil(timeoutSeconds / maxDelay)`): stable for every re-observation
+ *   within the same hop window (so passes dedupe), decremented at each
+ *   hop delivery (so the chain always advances). Worlds without a delay
+ *   limit (world-postgres, world-local) simply take the same ≤23h hops.
+ *
+ * - Near-elapsed waits (≤2s remaining) get a second-bucketed suffix. A
+ *   continuation delivered marginally early (clock skew between the
+ *   enqueuing and handling hosts; the ceil() on the delay can leave a ~0
+ *   margin) re-observes the wait as pending with ~1s remaining and must
+ *   be able to enqueue a fresh short-delay retry. The bucket suffix
+ *   keeps that retry enqueueable (its ≥1s delay guarantees a later
+ *   bucket) while still collapsing same-instant duplicates.
+ *
+ * Mid-range waits (more than the near-elapsed threshold, at most one
+ * hop) use the bare correlationId: every re-observation targets the same
+ * deadline, so deduping to the first message is semantically lossless.
+ * Host clock skew beyond the near-elapsed threshold could in principle
+ * deliver such a continuation early enough to re-observe its wait and
+ * lose the re-enqueue to the burnt key; the threshold is the skew
+ * tolerance we accept for the benefit of exactly-one continuation per
+ * wait.
+ */
+/**
+ * Maximum `delaySeconds` for a single wait-continuation message. Waits
+ * longer than this are chained across multiple hops. 23 hours leaves a 1h
+ * buffer under Vercel Queues' default 24h message TTL and mirrors
+ * world-vercel's `MAX_DELAY_SECONDS`.
+ */
+export declare const WAIT_CONTINUATION_MAX_DELAY_SECONDS = 82800;
+/**
+ * Waits with at most this many seconds remaining use a second-bucketed
+ * idempotency key so an early-delivered continuation can re-enqueue its
+ * short-delay retry. This is also the host clock-skew tolerance for
+ * mid-range waits keyed on the bare correlationId.
+ */
+export declare const NEAR_ELAPSED_WAIT_THRESHOLD_SECONDS = 2;
+export interface WaitContinuationDispatch {
+    delaySeconds: number;
+    idempotencyKey: string;
+}
+/**
+ * Computes the queue delay and idempotency key for a wait-continuation
+ * message. `timeoutSeconds` is the time until the wait's `resumeAt`
+ * (floored at 1s by the suspension handler); `waitCorrelationId`
+ * identifies the wait so repeated suspension passes dedupe.
+ */
+export declare function getWaitContinuationDispatch(timeoutSeconds: number, waitCorrelationId: string, now?: number): WaitContinuationDispatch;
+//# sourceMappingURL=wait-continuation.d.ts.map

package/dist/runtime/wait-continuation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"wait-continuation.d.ts","sourceRoot":"","sources":["../../src/runtime/wait-continuation.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyDG;AAIH;;;;;GAKG;AACH,eAAO,MAAM,mCAAmC,QAAS,CAAC;AAE1D;;;;;GAKG;AACH,eAAO,MAAM,mCAAmC,IAAI,CAAC;AAiBrD,MAAM,WAAW,wBAAwB;IACvC,YAAY,EAAE,MAAM,CAAC;IACrB,cAAc,EAAE,MAAM,CAAC;CACxB;AAED;;;;;GAKG;AACH,wBAAgB,2BAA2B,CACzC,cAAc,EAAE,MAAM,EACtB,iBAAiB,EAAE,MAAM,EACzB,GAAG,GAAE,MAAmB,GACvB,wBAAwB,CAyB1B"}

package/dist/runtime/wait-continuation.js

@@ -0,0 +1,105 @@
+/**
+ * Wait-continuation dispatch: delay + idempotency-key selection.
+ *
+ * When V2 suspension processing observes a pending wait, it enqueues a
+ * delayed "continuation" message that fires once the wait elapses and
+ * drives the next replay (which completes the wait via the "complete
+ * elapsed waits" pass). This module decides the message's `delaySeconds`
+ * and `idempotencyKey`.
+ *
+ * The continuation is keyed on the wait's correlationId: while a wait is
+ * pending, every replay pass over the run re-observes it (e.g., once per
+ * step completion in `Promise.all([steps..., sleep()])`), and without
+ * dedupe each pass would enqueue another delayed continuation — each one
+ * a spurious full replay when the wait elapses, and each a fresh message
+ * that resets the delivery-attempt runaway guard. A key is attached in
+ * all cases: some worlds (e.g. world-postgres) serialize key-less
+ * workflow messages per run, which would park the continuation behind
+ * the handler's own inline step execution and defeat the race semantics
+ * the continuation exists to provide.
+ *
+ * The bare correlationId cannot be the key in every case, though: world
+ * dedupe windows outlive the first delivery (VQS keeps idempotency
+ * records until message-retention TTL; world-postgres keeps a
+ * completed-keys cache), so once a key has been used, a later enqueue
+ * under the same key is silently dropped. Any situation where a
+ * continuation is delivered while its wait is still pending therefore
+ * needs a fresh key for the re-enqueue, or the wait's timer is lost and
+ * the run stalls until unrelated traffic happens to wake it. Two such
+ * situations exist, each with its own key variation:
+ *
+ * - Waits longer than the maximum queue delay are chained: the delay is
+ *   clamped to `WAIT_CONTINUATION_MAX_DELAY_SECONDS` (23h — VQS messages
+ *   have a 24h retention limit, and one hour of buffer matches
+ *   world-vercel's own clamp for delayed re-enqueues), so the
+ *   continuation intentionally fires early, re-observes the wait, and
+ *   must enqueue the next hop. The key is suffixed with the hop index
+ *   (`ceil(timeoutSeconds / maxDelay)`): stable for every re-observation
+ *   within the same hop window (so passes dedupe), decremented at each
+ *   hop delivery (so the chain always advances). Worlds without a delay
+ *   limit (world-postgres, world-local) simply take the same ≤23h hops.
+ *
+ * - Near-elapsed waits (≤2s remaining) get a second-bucketed suffix. A
+ *   continuation delivered marginally early (clock skew between the
+ *   enqueuing and handling hosts; the ceil() on the delay can leave a ~0
+ *   margin) re-observes the wait as pending with ~1s remaining and must
+ *   be able to enqueue a fresh short-delay retry. The bucket suffix
+ *   keeps that retry enqueueable (its ≥1s delay guarantees a later
+ *   bucket) while still collapsing same-instant duplicates.
+ *
+ * Mid-range waits (more than the near-elapsed threshold, at most one
+ * hop) use the bare correlationId: every re-observation targets the same
+ * deadline, so deduping to the first message is semantically lossless.
+ * Host clock skew beyond the near-elapsed threshold could in principle
+ * deliver such a continuation early enough to re-observe its wait and
+ * lose the re-enqueue to the burnt key; the threshold is the skew
+ * tolerance we accept for the benefit of exactly-one continuation per
+ * wait.
+ */
+import { envNumber } from '@workflow/world';
+/**
+ * Maximum `delaySeconds` for a single wait-continuation message. Waits
+ * longer than this are chained across multiple hops. 23 hours leaves a 1h
+ * buffer under Vercel Queues' default 24h message TTL and mirrors
+ * world-vercel's `MAX_DELAY_SECONDS`.
+ */
+export const WAIT_CONTINUATION_MAX_DELAY_SECONDS = 82_800;
+/**
+ * Waits with at most this many seconds remaining use a second-bucketed
+ * idempotency key so an early-delivered continuation can re-enqueue its
+ * short-delay retry. This is also the host clock-skew tolerance for
+ * mid-range waits keyed on the bare correlationId.
+ */
+export const NEAR_ELAPSED_WAIT_THRESHOLD_SECONDS = 2;
+/** Effective max continuation delay. Override: `WORKFLOW_WAIT_CONTINUATION_MAX_DELAY_SECONDS`. */
+const getWaitContinuationMaxDelaySeconds = () => envNumber('WORKFLOW_WAIT_CONTINUATION_MAX_DELAY_SECONDS', WAIT_CONTINUATION_MAX_DELAY_SECONDS, { integer: true, min: 1 });
+/** Effective near-elapsed threshold. Override: `WORKFLOW_NEAR_ELAPSED_WAIT_THRESHOLD_SECONDS`. */
+const getNearElapsedWaitThresholdSeconds = () => envNumber('WORKFLOW_NEAR_ELAPSED_WAIT_THRESHOLD_SECONDS', NEAR_ELAPSED_WAIT_THRESHOLD_SECONDS);
+/**
+ * Computes the queue delay and idempotency key for a wait-continuation
+ * message. `timeoutSeconds` is the time until the wait's `resumeAt`
+ * (floored at 1s by the suspension handler); `waitCorrelationId`
+ * identifies the wait so repeated suspension passes dedupe.
+ */
+export function getWaitContinuationDispatch(timeoutSeconds, waitCorrelationId, now = Date.now()) {
+    const maxDelaySeconds = getWaitContinuationMaxDelaySeconds();
+    // The near-elapsed branch returns the full remaining time as the delay, so
+    // its threshold can never exceed the max delay — otherwise a wait between the
+    // max and the threshold would be dispatched with a delay above the max. Cap
+    // the threshold at the max so every branch yields a delay within it. (With
+    // defaults — threshold 2s, max 82_800s — this is a no-op; it only bites when
+    // the max is tuned down below the threshold for testing.)
+    const nearElapsedThreshold = Math.min(getNearElapsedWaitThresholdSeconds(), maxDelaySeconds);
+    if (timeoutSeconds <= nearElapsedThreshold) {
+        return {
+            delaySeconds: timeoutSeconds,
+            idempotencyKey: `${waitCorrelationId}:${Math.floor(now / 1000)}`,
+        };
+    }
+    const hop = Math.ceil(timeoutSeconds / maxDelaySeconds);
+    return {
+        delaySeconds: Math.min(timeoutSeconds, maxDelaySeconds),
+        idempotencyKey: hop === 1 ? waitCorrelationId : `${waitCorrelationId}:hop-${hop}`,
+    };
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"wait-continuation.js","sourceRoot":"","sources":["../../src/runtime/wait-continuation.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyDG;AAEH,OAAO,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AAE5C;;;;;GAKG;AACH,MAAM,CAAC,MAAM,mCAAmC,GAAG,MAAM,CAAC;AAE1D;;;;;GAKG;AACH,MAAM,CAAC,MAAM,mCAAmC,GAAG,CAAC,CAAC;AAErD,kGAAkG;AAClG,MAAM,kCAAkC,GAAG,GAAW,EAAE,CACtD,SAAS,CACP,8CAA8C,EAC9C,mCAAmC,EACnC,EAAE,OAAO,EAAE,IAAI,EAAE,GAAG,EAAE,CAAC,EAAE,CAC1B,CAAC;AAEJ,kGAAkG;AAClG,MAAM,kCAAkC,GAAG,GAAW,EAAE,CACtD,SAAS,CACP,8CAA8C,EAC9C,mCAAmC,CACpC,CAAC;AAOJ;;;;;GAKG;AACH,MAAM,UAAU,2BAA2B,CACzC,cAAsB,EACtB,iBAAyB,EACzB,MAAc,IAAI,CAAC,GAAG,EAAE;IAExB,MAAM,eAAe,GAAG,kCAAkC,EAAE,CAAC;IAC7D,2EAA2E;IAC3E,8EAA8E;IAC9E,4EAA4E;IAC5E,2EAA2E;IAC3E,6EAA6E;IAC7E,0DAA0D;IAC1D,MAAM,oBAAoB,GAAG,IAAI,CAAC,GAAG,CACnC,kCAAkC,EAAE,EACpC,eAAe,CAChB,CAAC;IACF,IAAI,cAAc,IAAI,oBAAoB,EAAE,CAAC;QAC3C,OAAO;YACL,YAAY,EAAE,cAAc;YAC5B,cAAc,EAAE,GAAG,iBAAiB,IAAI,IAAI,CAAC,KAAK,CAAC,GAAG,GAAG,IAAI,CAAC,EAAE;SACjE,CAAC;IACJ,CAAC;IAED,MAAM,GAAG,GAAG,IAAI,CAAC,IAAI,CAAC,cAAc,GAAG,eAAe,CAAC,CAAC;IACxD,OAAO;QACL,YAAY,EAAE,IAAI,CAAC,GAAG,CAAC,cAAc,EAAE,eAAe,CAAC;QACvD,cAAc,EACZ,GAAG,KAAK,CAAC,CAAC,CAAC,CAAC,iBAAiB,CAAC,CAAC,CAAC,GAAG,iBAAiB,QAAQ,GAAG,EAAE;KACpE,CAAC;AACJ,CAAC","sourcesContent":["/**\n * Wait-continuation dispatch: delay + idempotency-key selection.\n *\n * When V2 suspension processing observes a pending wait, it enqueues a\n * delayed \"continuation\" message that fires once the wait elapses and\n * drives the next replay (which completes the wait via the \"complete\n * elapsed waits\" pass). This module decides the message's `delaySeconds`\n * and `idempotencyKey`.\n *\n * The continuation is keyed on the wait's correlationId: while a wait is\n * pending, every replay pass over the run re-observes it (e.g., once per\n * step completion in `Promise.all([steps..., sleep()])`), and without\n * dedupe each pass would enqueue another delayed continuation — each one\n * a spurious full replay when the wait elapses, and each a fresh message\n * that resets the delivery-attempt runaway guard. A key is attached in\n * all cases: some worlds (e.g. world-postgres) serialize key-less\n * workflow messages per run, which would park the continuation behind\n * the handler's own inline step execution and defeat the race semantics\n * the continuation exists to provide.\n *\n * The bare correlationId cannot be the key in every case, though: world\n * dedupe windows outlive the first delivery (VQS keeps idempotency\n * records until message-retention TTL; world-postgres keeps a\n * completed-keys cache), so once a key has been used, a later enqueue\n * under the same key is silently dropped. Any situation where a\n * continuation is delivered while its wait is still pending therefore\n * needs a fresh key for the re-enqueue, or the wait's timer is lost and\n * the run stalls until unrelated traffic happens to wake it. Two such\n * situations exist, each with its own key variation:\n *\n * - Waits longer than the maximum queue delay are chained: the delay is\n *   clamped to `WAIT_CONTINUATION_MAX_DELAY_SECONDS` (23h — VQS messages\n *   have a 24h retention limit, and one hour of buffer matches\n *   world-vercel's own clamp for delayed re-enqueues), so the\n *   continuation intentionally fires early, re-observes the wait, and\n *   must enqueue the next hop. The key is suffixed with the hop index\n *   (`ceil(timeoutSeconds / maxDelay)`): stable for every re-observation\n *   within the same hop window (so passes dedupe), decremented at each\n *   hop delivery (so the chain always advances). Worlds without a delay\n *   limit (world-postgres, world-local) simply take the same ≤23h hops.\n *\n * - Near-elapsed waits (≤2s remaining) get a second-bucketed suffix. A\n *   continuation delivered marginally early (clock skew between the\n *   enqueuing and handling hosts; the ceil() on the delay can leave a ~0\n *   margin) re-observes the wait as pending with ~1s remaining and must\n *   be able to enqueue a fresh short-delay retry. The bucket suffix\n *   keeps that retry enqueueable (its ≥1s delay guarantees a later\n *   bucket) while still collapsing same-instant duplicates.\n *\n * Mid-range waits (more than the near-elapsed threshold, at most one\n * hop) use the bare correlationId: every re-observation targets the same\n * deadline, so deduping to the first message is semantically lossless.\n * Host clock skew beyond the near-elapsed threshold could in principle\n * deliver such a continuation early enough to re-observe its wait and\n * lose the re-enqueue to the burnt key; the threshold is the skew\n * tolerance we accept for the benefit of exactly-one continuation per\n * wait.\n */\n\nimport { envNumber } from '@workflow/world';\n\n/**\n * Maximum `delaySeconds` for a single wait-continuation message. Waits\n * longer than this are chained across multiple hops. 23 hours leaves a 1h\n * buffer under Vercel Queues' default 24h message TTL and mirrors\n * world-vercel's `MAX_DELAY_SECONDS`.\n */\nexport const WAIT_CONTINUATION_MAX_DELAY_SECONDS = 82_800;\n\n/**\n * Waits with at most this many seconds remaining use a second-bucketed\n * idempotency key so an early-delivered continuation can re-enqueue its\n * short-delay retry. This is also the host clock-skew tolerance for\n * mid-range waits keyed on the bare correlationId.\n */\nexport const NEAR_ELAPSED_WAIT_THRESHOLD_SECONDS = 2;\n\n/** Effective max continuation delay. Override: `WORKFLOW_WAIT_CONTINUATION_MAX_DELAY_SECONDS`. */\nconst getWaitContinuationMaxDelaySeconds = (): number =>\n  envNumber(\n    'WORKFLOW_WAIT_CONTINUATION_MAX_DELAY_SECONDS',\n    WAIT_CONTINUATION_MAX_DELAY_SECONDS,\n    { integer: true, min: 1 }\n  );\n\n/** Effective near-elapsed threshold. Override: `WORKFLOW_NEAR_ELAPSED_WAIT_THRESHOLD_SECONDS`. */\nconst getNearElapsedWaitThresholdSeconds = (): number =>\n  envNumber(\n    'WORKFLOW_NEAR_ELAPSED_WAIT_THRESHOLD_SECONDS',\n    NEAR_ELAPSED_WAIT_THRESHOLD_SECONDS\n  );\n\nexport interface WaitContinuationDispatch {\n  delaySeconds: number;\n  idempotencyKey: string;\n}\n\n/**\n * Computes the queue delay and idempotency key for a wait-continuation\n * message. `timeoutSeconds` is the time until the wait's `resumeAt`\n * (floored at 1s by the suspension handler); `waitCorrelationId`\n * identifies the wait so repeated suspension passes dedupe.\n */\nexport function getWaitContinuationDispatch(\n  timeoutSeconds: number,\n  waitCorrelationId: string,\n  now: number = Date.now()\n): WaitContinuationDispatch {\n  const maxDelaySeconds = getWaitContinuationMaxDelaySeconds();\n  // The near-elapsed branch returns the full remaining time as the delay, so\n  // its threshold can never exceed the max delay — otherwise a wait between the\n  // max and the threshold would be dispatched with a delay above the max. Cap\n  // the threshold at the max so every branch yields a delay within it. (With\n  // defaults — threshold 2s, max 82_800s — this is a no-op; it only bites when\n  // the max is tuned down below the threshold for testing.)\n  const nearElapsedThreshold = Math.min(\n    getNearElapsedWaitThresholdSeconds(),\n    maxDelaySeconds\n  );\n  if (timeoutSeconds <= nearElapsedThreshold) {\n    return {\n      delaySeconds: timeoutSeconds,\n      idempotencyKey: `${waitCorrelationId}:${Math.floor(now / 1000)}`,\n    };\n  }\n\n  const hop = Math.ceil(timeoutSeconds / maxDelaySeconds);\n  return {\n    delaySeconds: Math.min(timeoutSeconds, maxDelaySeconds),\n    idempotencyKey:\n      hop === 1 ? waitCorrelationId : `${waitCorrelationId}:hop-${hop}`,\n  };\n}\n"]}

package/dist/runtime/wait-until.d.ts

@@ -0,0 +1,18 @@
+export declare function waitUntil(promise: Promise<unknown>): void;
+/**
+ * Schedule a background promise via `waitUntil`, guaranteeing that the
+ * promise handed to `waitUntil` can never reject. Nothing consumes a
+ * `waitUntil` promise, so a rejection surfaces as an `unhandledRejection`
+ * and can crash the process — even when the same underlying error is
+ * correctly handled by an awaited copy elsewhere.
+ *
+ * Expected client-disconnect errors (`AbortError` / `ResponseAborted`)
+ * are ignored. Any other error is passed to `onError` and swallowed.
+ */
+export declare function safeWaitUntil(promise: Promise<unknown>, onError: (err: unknown) => void): void;
+/**
+ * A small wrapper around `waitUntil` that also returns
+ * the result of the awaited promise.
+ */
+export declare function waitedUntil<T>(fn: () => Promise<T>): Promise<T>;
+//# sourceMappingURL=wait-until.d.ts.map

package/dist/runtime/wait-until.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"wait-until.d.ts","sourceRoot":"","sources":["../../src/runtime/wait-until.ts"],"names":[],"mappings":"AAAA,wBAAgB,SAAS,CAAC,OAAO,EAAE,OAAO,CAAC,OAAO,CAAC,GAAG,IAAI,CAIzD;AAED;;;;;;;;;GASG;AACH,wBAAgB,aAAa,CAC3B,OAAO,EAAE,OAAO,CAAC,OAAO,CAAC,EACzB,OAAO,EAAE,CAAC,GAAG,EAAE,OAAO,KAAK,IAAI,GAC9B,IAAI,CAcN;AAED;;;GAGG;AACH,wBAAsB,WAAW,CAAC,CAAC,EAAE,EAAE,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,CAUrE"}

package/dist/runtime/wait-until.js

@@ -0,0 +1,42 @@
+export function waitUntil(promise) {
+    void import('@vercel/functions').then(({ waitUntil }) => {
+        waitUntil(promise);
+    });
+}
+/**
+ * Schedule a background promise via `waitUntil`, guaranteeing that the
+ * promise handed to `waitUntil` can never reject. Nothing consumes a
+ * `waitUntil` promise, so a rejection surfaces as an `unhandledRejection`
+ * and can crash the process — even when the same underlying error is
+ * correctly handled by an awaited copy elsewhere.
+ *
+ * Expected client-disconnect errors (`AbortError` / `ResponseAborted`)
+ * are ignored. Any other error is passed to `onError` and swallowed.
+ */
+export function safeWaitUntil(promise, onError) {
+    waitUntil(promise.catch((err) => {
+        const isAbortError = err?.name === 'AbortError' || err?.name === 'ResponseAborted';
+        if (!isAbortError) {
+            try {
+                onError(err);
+            }
+            catch {
+                // Never let onError break the no-reject guarantee.
+            }
+        }
+    }));
+}
+/**
+ * A small wrapper around `waitUntil` that also returns
+ * the result of the awaited promise.
+ */
+export async function waitedUntil(fn) {
+    const result = fn();
+    waitUntil(result.catch(() => {
+        // Ignore error from the promise being rejected.
+        // It's expected that the invoker of `waitedUntil`
+        // will handle the error.
+    }));
+    return result;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/runtime/world-compatibility.d.ts

@@ -0,0 +1,5 @@
+import type { World } from '@workflow/world';
+type WorldSpecVersionMetadata = Pick<World, 'specVersion'>;
+export declare function assertWorldSupportsRuntimeProtocol(world: WorldSpecVersionMetadata): void;
+export {};
+//# sourceMappingURL=world-compatibility.d.ts.map

package/dist/runtime/world-compatibility.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"world-compatibility.d.ts","sourceRoot":"","sources":["../../src/runtime/world-compatibility.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,iBAAiB,CAAC;AAG7C,KAAK,wBAAwB,GAAG,IAAI,CAAC,KAAK,EAAE,aAAa,CAAC,CAAC;AAE3D,wBAAgB,kCAAkC,CAChD,KAAK,EAAE,wBAAwB,GAC9B,IAAI,CAWN"}

package/dist/runtime/world-compatibility.js

@@ -0,0 +1,12 @@
+import { WorkflowRuntimeError } from '@workflow/errors';
+import { SPEC_VERSION_CURRENT } from '@workflow/world';
+export function assertWorldSupportsRuntimeProtocol(world) {
+    if (world.specVersion === SPEC_VERSION_CURRENT) {
+        return;
+    }
+    const supportedVersion = world.specVersion ?? 'none';
+    throw new WorkflowRuntimeError(`This Workflow runtime requires a World with matching spec version ${SPEC_VERSION_CURRENT}, ` +
+        `but the configured World declares spec version ${supportedVersion}. ` +
+        'Install a World package version compatible with the current Workflow runtime.');
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoid29ybGQtY29tcGF0aWJpbGl0eS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9ydW50aW1lL3dvcmxkLWNvbXBhdGliaWxpdHkudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLG9CQUFvQixFQUFFLE1BQU0sa0JBQWtCLENBQUM7QUFFeEQsT0FBTyxFQUFFLG9CQUFvQixFQUFFLE1BQU0saUJBQWlCLENBQUM7QUFJdkQsTUFBTSxVQUFVLGtDQUFrQyxDQUNoRCxLQUErQjtJQUUvQixJQUFJLEtBQUssQ0FBQyxXQUFXLEtBQUssb0JBQW9CLEVBQUUsQ0FBQztRQUMvQyxPQUFPO0lBQ1QsQ0FBQztJQUVELE1BQU0sZ0JBQWdCLEdBQUcsS0FBSyxDQUFDLFdBQVcsSUFBSSxNQUFNLENBQUM7SUFDckQsTUFBTSxJQUFJLG9CQUFvQixDQUM1QixxRUFBcUUsb0JBQW9CLElBQUk7UUFDM0Ysa0RBQWtELGdCQUFnQixJQUFJO1FBQ3RFLCtFQUErRSxDQUNsRixDQUFDO0FBQ0osQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IFdvcmtmbG93UnVudGltZUVycm9yIH0gZnJvbSAnQHdvcmtmbG93L2Vycm9ycyc7XG5pbXBvcnQgdHlwZSB7IFdvcmxkIH0gZnJvbSAnQHdvcmtmbG93L3dvcmxkJztcbmltcG9ydCB7IFNQRUNfVkVSU0lPTl9DVVJSRU5UIH0gZnJvbSAnQHdvcmtmbG93L3dvcmxkJztcblxudHlwZSBXb3JsZFNwZWNWZXJzaW9uTWV0YWRhdGEgPSBQaWNrPFdvcmxkLCAnc3BlY1ZlcnNpb24nPjtcblxuZXhwb3J0IGZ1bmN0aW9uIGFzc2VydFdvcmxkU3VwcG9ydHNSdW50aW1lUHJvdG9jb2woXG4gIHdvcmxkOiBXb3JsZFNwZWNWZXJzaW9uTWV0YWRhdGFcbik6IHZvaWQge1xuICBpZiAod29ybGQuc3BlY1ZlcnNpb24gPT09IFNQRUNfVkVSU0lPTl9DVVJSRU5UKSB7XG4gICAgcmV0dXJuO1xuICB9XG5cbiAgY29uc3Qgc3VwcG9ydGVkVmVyc2lvbiA9IHdvcmxkLnNwZWNWZXJzaW9uID8/ICdub25lJztcbiAgdGhyb3cgbmV3IFdvcmtmbG93UnVudGltZUVycm9yKFxuICAgIGBUaGlzIFdvcmtmbG93IHJ1bnRpbWUgcmVxdWlyZXMgYSBXb3JsZCB3aXRoIG1hdGNoaW5nIHNwZWMgdmVyc2lvbiAke1NQRUNfVkVSU0lPTl9DVVJSRU5UfSwgYCArXG4gICAgICBgYnV0IHRoZSBjb25maWd1cmVkIFdvcmxkIGRlY2xhcmVzIHNwZWMgdmVyc2lvbiAke3N1cHBvcnRlZFZlcnNpb259LiBgICtcbiAgICAgICdJbnN0YWxsIGEgV29ybGQgcGFja2FnZSB2ZXJzaW9uIGNvbXBhdGlibGUgd2l0aCB0aGUgY3VycmVudCBXb3JrZmxvdyBydW50aW1lLidcbiAgKTtcbn1cbiJdfQ==

package/dist/runtime/world-init.d.ts

@@ -0,0 +1,50 @@
+/**
+ * Server-only side-effect module that ensures `world.ts` is loaded so its
+ * module-load side effect — `globalThis[GetWorldFnKey] ??= getWorld` —
+ * fires in host bundles.
+ *
+ * # Why this exists
+ *
+ * `getWorldLazy()` in `./get-world-lazy.ts` checks the globalThis cache
+ * populated by `world.ts`'s module-load side effect. When a server route
+ * only consumes a helper that goes through `getWorldLazy` — for example
+ * `start` from `workflow/api`, or `defineHook().resume()` from `workflow`
+ * — webpack/turbopack can tree-shake the named import `{ getWorld }` out
+ * of `runtime.ts`, taking `world.ts`'s module evaluation with it. The
+ * globalThis registration never fires.
+ *
+ * Importing this module for its side effect from the host-side `workflow`
+ * and `workflow/api` entries guarantees `world.ts` enters the bundle, the
+ * global is registered at module load, and `getWorldLazy()` short-circuits
+ * to the registered function on the first call.
+ *
+ * # Why a separate module instead of importing `./world.js` directly
+ *
+ * `world.ts` is internal to `@workflow/core` and not part of the public
+ * exports surface. Adding a dedicated public init entry (this file)
+ * keeps the side-effect intent obvious to anyone reading
+ * `packages/workflow/src/api.ts`, and lets the `workflow` export
+ * condition route to a stub for VM/step bundles (see below).
+ *
+ * # Why this doesn't break VM/step bundles
+ *
+ * The `@workflow/core/runtime/world-init` export resolves via the
+ * `workflow` condition to `./dist/workflow/world-init-stub.js`, an empty
+ * module. Esbuild runs the workflow VM and step bundlers with the
+ * `workflow` condition active, so they pick up the stub and never reach
+ * `world.ts`. Host bundlers (webpack, turbopack, Node.js) use the
+ * `default` (or `node`) condition and pick up this file, loading
+ * `world.ts` as intended. The split keeps the configured world package
+ * and other server-only deps out of the workflow sandbox bundle.
+ *
+ * # Maintenance notes
+ *
+ * If you add another `getWorldLazy()` consumer that's reachable from a
+ * host route without going through `workflow` or `workflow/api`, make
+ * sure that entry also imports this module — or that it transitively
+ * reaches `world.ts` via a non-tree-shakeable path. Adding a regression
+ * test in `world-init.test.ts` is preferred to relying on careful manual
+ * tracing.
+ */
+import './world.js';
+//# sourceMappingURL=world-init.d.ts.map

package/dist/runtime/world-init.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"world-init.d.ts","sourceRoot":"","sources":["../../src/runtime/world-init.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+CG;AACH,OAAO,YAAY,CAAC"}

package/dist/runtime/world-init.js

@@ -0,0 +1,50 @@
+/**
+ * Server-only side-effect module that ensures `world.ts` is loaded so its
+ * module-load side effect — `globalThis[GetWorldFnKey] ??= getWorld` —
+ * fires in host bundles.
+ *
+ * # Why this exists
+ *
+ * `getWorldLazy()` in `./get-world-lazy.ts` checks the globalThis cache
+ * populated by `world.ts`'s module-load side effect. When a server route
+ * only consumes a helper that goes through `getWorldLazy` — for example
+ * `start` from `workflow/api`, or `defineHook().resume()` from `workflow`
+ * — webpack/turbopack can tree-shake the named import `{ getWorld }` out
+ * of `runtime.ts`, taking `world.ts`'s module evaluation with it. The
+ * globalThis registration never fires.
+ *
+ * Importing this module for its side effect from the host-side `workflow`
+ * and `workflow/api` entries guarantees `world.ts` enters the bundle, the
+ * global is registered at module load, and `getWorldLazy()` short-circuits
+ * to the registered function on the first call.
+ *
+ * # Why a separate module instead of importing `./world.js` directly
+ *
+ * `world.ts` is internal to `@workflow/core` and not part of the public
+ * exports surface. Adding a dedicated public init entry (this file)
+ * keeps the side-effect intent obvious to anyone reading
+ * `packages/workflow/src/api.ts`, and lets the `workflow` export
+ * condition route to a stub for VM/step bundles (see below).
+ *
+ * # Why this doesn't break VM/step bundles
+ *
+ * The `@workflow/core/runtime/world-init` export resolves via the
+ * `workflow` condition to `./dist/workflow/world-init-stub.js`, an empty
+ * module. Esbuild runs the workflow VM and step bundlers with the
+ * `workflow` condition active, so they pick up the stub and never reach
+ * `world.ts`. Host bundlers (webpack, turbopack, Node.js) use the
+ * `default` (or `node`) condition and pick up this file, loading
+ * `world.ts` as intended. The split keeps the configured world package
+ * and other server-only deps out of the workflow sandbox bundle.
+ *
+ * # Maintenance notes
+ *
+ * If you add another `getWorldLazy()` consumer that's reachable from a
+ * host route without going through `workflow` or `workflow/api`, make
+ * sure that entry also imports this module — or that it transitively
+ * reaches `world.ts` via a non-tree-shakeable path. Adding a regression
+ * test in `world-init.test.ts` is preferred to relying on careful manual
+ * tracing.
+ */
+import './world.js';
+//# sourceMappingURL=data:application/json;base64,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

package/dist/runtime/world-target.d.ts

@@ -0,0 +1,11 @@
+import type { World } from '@workflow/world';
+/**
+ * Unaliased target stub.
+ *
+ * Framework integrations alias this module to the configured world package at
+ * build time, including the default local world. Reaching this file means that
+ * static injection did not happen, so fail loudly instead of importing a
+ * fallback world that bundlers could retain alongside the configured one.
+ */
+export declare function createWorld(): World | Promise<World>;
+//# sourceMappingURL=world-target.d.ts.map

package/dist/runtime/world-target.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"world-target.d.ts","sourceRoot":"","sources":["../../src/runtime/world-target.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,iBAAiB,CAAC;AAQ7C;;;;;;;GAOG;AACH,wBAAgB,WAAW,IAAI,KAAK,GAAG,OAAO,CAAC,KAAK,CAAC,CAEpD"}

package/dist/runtime/world-target.js

@@ -0,0 +1,15 @@
+function throwMissingStaticInjection() {
+    throw new Error('Workflow target world was not statically injected. Configure a Workflow builder/framework plugin so @workflow/core/runtime/world-target is aliased to the selected world package.');
+}
+/**
+ * Unaliased target stub.
+ *
+ * Framework integrations alias this module to the configured world package at
+ * build time, including the default local world. Reaching this file means that
+ * static injection did not happen, so fail loudly instead of importing a
+ * fallback world that bundlers could retain alongside the configured one.
+ */
+export function createWorld() {
+    throwMissingStaticInjection();
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoid29ybGQtdGFyZ2V0LmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL3J1bnRpbWUvd29ybGQtdGFyZ2V0LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUVBLFNBQVMsMkJBQTJCO0lBQ2xDLE1BQU0sSUFBSSxLQUFLLENBQ2IsbUxBQW1MLENBQ3BMLENBQUM7QUFDSixDQUFDO0FBRUQ7Ozs7Ozs7R0FPRztBQUNILE1BQU0sVUFBVSxXQUFXO0lBQ3pCLDJCQUEyQixFQUFFLENBQUM7QUFDaEMsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB0eXBlIHsgV29ybGQgfSBmcm9tICdAd29ya2Zsb3cvd29ybGQnO1xuXG5mdW5jdGlvbiB0aHJvd01pc3NpbmdTdGF0aWNJbmplY3Rpb24oKTogbmV2ZXIge1xuICB0aHJvdyBuZXcgRXJyb3IoXG4gICAgJ1dvcmtmbG93IHRhcmdldCB3b3JsZCB3YXMgbm90IHN0YXRpY2FsbHkgaW5qZWN0ZWQuIENvbmZpZ3VyZSBhIFdvcmtmbG93IGJ1aWxkZXIvZnJhbWV3b3JrIHBsdWdpbiBzbyBAd29ya2Zsb3cvY29yZS9ydW50aW1lL3dvcmxkLXRhcmdldCBpcyBhbGlhc2VkIHRvIHRoZSBzZWxlY3RlZCB3b3JsZCBwYWNrYWdlLidcbiAgKTtcbn1cblxuLyoqXG4gKiBVbmFsaWFzZWQgdGFyZ2V0IHN0dWIuXG4gKlxuICogRnJhbWV3b3JrIGludGVncmF0aW9ucyBhbGlhcyB0aGlzIG1vZHVsZSB0byB0aGUgY29uZmlndXJlZCB3b3JsZCBwYWNrYWdlIGF0XG4gKiBidWlsZCB0aW1lLCBpbmNsdWRpbmcgdGhlIGRlZmF1bHQgbG9jYWwgd29ybGQuIFJlYWNoaW5nIHRoaXMgZmlsZSBtZWFucyB0aGF0XG4gKiBzdGF0aWMgaW5qZWN0aW9uIGRpZCBub3QgaGFwcGVuLCBzbyBmYWlsIGxvdWRseSBpbnN0ZWFkIG9mIGltcG9ydGluZyBhXG4gKiBmYWxsYmFjayB3b3JsZCB0aGF0IGJ1bmRsZXJzIGNvdWxkIHJldGFpbiBhbG9uZ3NpZGUgdGhlIGNvbmZpZ3VyZWQgb25lLlxuICovXG5leHBvcnQgZnVuY3Rpb24gY3JlYXRlV29ybGQoKTogV29ybGQgfCBQcm9taXNlPFdvcmxkPiB7XG4gIHRocm93TWlzc2luZ1N0YXRpY0luamVjdGlvbigpO1xufVxuIl19

package/dist/runtime/world.d.ts

@@ -1,15 +1,27 @@
 import type { World } from '@workflow/world';
+export type WorldFactoryModule = {
+    createWorld?: () => World | Promise<World>;
+    /** @deprecated World packages should export `createWorld()` instead. */
+    createLocalWorld?: () => World | Promise<World>;
+    /** @deprecated World packages should export `createWorld()` instead. */
+    createVercelWorld?: () => World | Promise<World>;
+    default?: (() => World | Promise<World>) | World;
+};
 /**
- * Create a new world instance based on environment variables.
- * WORKFLOW_TARGET_WORLD is used to determine the target world.
+ * Create a World instance from a world factory module. Shared by
+ * `createWorld()` (for the statically injected target world module) and
+ * tooling that loads a world module dynamically (e.g. the Nitro dev
+ * handler and `@workflow/world-testing`). Legacy world-specific factory
+ * names are still accepted for compatibility, but world packages should
+ * export `createWorld()`.
+ */
+export declare function createWorldFromModule(mod: WorldFactoryModule): World | Promise<World>;
+/**
+ * Create a new world instance from the statically imported target world module.
  *
- * Note: WORKFLOW_VERCEL_* env vars (PROJECT, TEAM, AUTH_TOKEN, etc.) are
- * intentionally NOT read here. Those are for CLI/observability tooling only
- * and should not affect runtime behavior. The Vercel runtime provides
- * authentication via OIDC tokens and project context via system env vars
- * (VERCEL_DEPLOYMENT_ID, VERCEL_PROJECT_ID). Tooling that needs these env
- * vars should call createVercelWorld() directly with an explicit config and
- * use setWorld() to inject the instance.
+ * Framework integrations alias `@workflow/core/runtime/world-target` to the
+ * concrete world package at build time, so bundlers see a static import path
+ * instead of tracing a runtime-built require/import expression.
  */
 export declare const createWorld: () => Promise<World>;
 export type WorldHandlers = Pick<World, 'createQueueHandler' | 'specVersion'>;

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

@@ -1 +1 @@
-{"version":3,"file":"world.d.ts","sourceRoot":"","sources":["../../src/runtime/world.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,iBAAiB,CAAC;AAqD7C;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,WAAW,QAAa,OAAO,CAAC,KAAK,CAqDjD,CAAC;AAEF,MAAM,MAAM,aAAa,GAAG,IAAI,CAAC,KAAK,EAAE,oBAAoB,GAAG,aAAa,CAAC,CAAC;AAE9E;;;;;;;;GAQG;AACH,eAAO,MAAM,gBAAgB,QAAa,OAAO,CAAC,aAAa,CAkB9D,CAAC;AAEF,eAAO,MAAM,QAAQ,QAAa,OAAO,CAAC,KAAK,CAc9C,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,QAAQ,GAAI,OAAO,KAAK,GAAG,SAAS,KAAG,IAKnD,CAAC"}
+{"version":3,"file":"world.d.ts","sourceRoot":"","sources":["../../src/runtime/world.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,iBAAiB,CAAC;AAiB7C,MAAM,MAAM,kBAAkB,GAAG;IAC/B,WAAW,CAAC,EAAE,MAAM,KAAK,GAAG,OAAO,CAAC,KAAK,CAAC,CAAC;IAC3C,wEAAwE;IACxE,gBAAgB,CAAC,EAAE,MAAM,KAAK,GAAG,OAAO,CAAC,KAAK,CAAC,CAAC;IAChD,wEAAwE;IACxE,iBAAiB,CAAC,EAAE,MAAM,KAAK,GAAG,OAAO,CAAC,KAAK,CAAC,CAAC;IACjD,OAAO,CAAC,EAAE,CAAC,MAAM,KAAK,GAAG,OAAO,CAAC,KAAK,CAAC,CAAC,GAAG,KAAK,CAAC;CAClD,CAAC;AAEF;;;;;;;GAOG;AACH,wBAAgB,qBAAqB,CACnC,GAAG,EAAE,kBAAkB,GACtB,KAAK,GAAG,OAAO,CAAC,KAAK,CAAC,CAoBxB;AAED;;;;;;GAMG;AACH,eAAO,MAAM,WAAW,QAAa,OAAO,CAAC,KAAK,CAkBjD,CAAC;AAEF,MAAM,MAAM,aAAa,GAAG,IAAI,CAAC,KAAK,EAAE,oBAAoB,GAAG,aAAa,CAAC,CAAC;AAE9E;;;;;;;;GAQG;AACH,eAAO,MAAM,gBAAgB,QAAa,OAAO,CAAC,aAAa,CAoB9D,CAAC;AAEF,eAAO,MAAM,QAAQ,QAAa,OAAO,CAAC,KAAK,CAgB9C,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,QAAQ,GAAI,OAAO,KAAK,GAAG,SAAS,KAAG,IAKnD,CAAC"}