@workflow/core 5.0.0-beta.2 → 5.0.0-beta.21

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: VQS
+ * messages have a 24h retention limit; the 1h buffer 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;AAEH;;;;;GAKG;AACH,eAAO,MAAM,mCAAmC,QAAS,CAAC;AAE1D;;;;;GAKG;AACH,eAAO,MAAM,mCAAmC,IAAI,CAAC;AAErD,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,CAc1B"}

package/dist/runtime/wait-continuation.js

@@ -0,0 +1,92 @@
+/**
+ * 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: VQS
+ * messages have a 24h retention limit; the 1h buffer 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;
+/**
+ * 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()) {
+    if (timeoutSeconds <= NEAR_ELAPSED_WAIT_THRESHOLD_SECONDS) {
+        return {
+            delaySeconds: timeoutSeconds,
+            idempotencyKey: `${waitCorrelationId}:${Math.floor(now / 1000)}`,
+        };
+    }
+    const hop = Math.ceil(timeoutSeconds / WAIT_CONTINUATION_MAX_DELAY_SECONDS);
+    return {
+        delaySeconds: Math.min(timeoutSeconds, WAIT_CONTINUATION_MAX_DELAY_SECONDS),
+        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;;;;;GAKG;AACH,MAAM,CAAC,MAAM,mCAAmC,GAAG,MAAM,CAAC;AAE1D;;;;;GAKG;AACH,MAAM,CAAC,MAAM,mCAAmC,GAAG,CAAC,CAAC;AAOrD;;;;;GAKG;AACH,MAAM,UAAU,2BAA2B,CACzC,cAAsB,EACtB,iBAAyB,EACzB,MAAc,IAAI,CAAC,GAAG,EAAE;IAExB,IAAI,cAAc,IAAI,mCAAmC,EAAE,CAAC;QAC1D,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,mCAAmC,CAAC,CAAC;IAC5E,OAAO;QACL,YAAY,EAAE,IAAI,CAAC,GAAG,CAAC,cAAc,EAAE,mCAAmC,CAAC;QAC3E,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\n/**\n * Maximum `delaySeconds` for a single wait-continuation message. Waits\n * longer than this are chained across multiple hops. 23 hours: VQS\n * messages have a 24h retention limit; the 1h buffer 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\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  if (timeoutSeconds <= NEAR_ELAPSED_WAIT_THRESHOLD_SECONDS) {\n    return {\n      delaySeconds: timeoutSeconds,\n      idempotencyKey: `${waitCorrelationId}:${Math.floor(now / 1000)}`,\n    };\n  }\n\n  const hop = Math.ceil(timeoutSeconds / WAIT_CONTINUATION_MAX_DELAY_SECONDS);\n  return {\n    delaySeconds: Math.min(timeoutSeconds, WAIT_CONTINUATION_MAX_DELAY_SECONDS),\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-init.d.ts

@@ -0,0 +1,75 @@
+/**
+ * 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) before falling back
+ * to a runtime-built dynamic `import('./world.js')`. When a server route
+ * only consumes a single helper that goes through `getWorldLazy` — most
+ * commonly `start` from `workflow/api` — webpack/turbopack tree-shake the
+ * named import `{ getWorld } from './runtime/world.js'` out of
+ * `runtime.ts`, taking `world.ts`'s module evaluation with it. The
+ * globalThis registration never fires.
+ *
+ * `getWorldLazy` then falls through to its dynamic-import fallback, which
+ * itself fails: webpack inlines `get-world-lazy.js` into the bundled route
+ * file, so the relative specifier `./world.js` resolves against
+ * `/var/task/<app>/.next/server/app/<...>/route.js` — where no sibling
+ * `world.js` exists — and Node throws `MODULE_NOT_FOUND`. The symptom is a
+ * cold-start regression: the very first user request that goes through
+ * `start()` fails until some other code path (typically the queue-driven
+ * `/.well-known/workflow/v1/flow` route, which uses `getWorld` directly
+ * via `workflowEntrypoint`) has loaded `world.ts` and populated the
+ * cache.
+ *
+ * Importing this module for its side effect — exactly once, from the
+ * host-side `workflow/api` (`packages/workflow/src/api.ts`) — 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 `@workflow/world-vercel`,
+ * `@workflow/world-local`, `cbor-x`, and other server-only deps out of
+ * the workflow sandbox bundle.
+ *
+ * # Why we keep the `getWorldLazy` dynamic-import fallback
+ *
+ * The fallback remains in `./get-world-lazy.ts` as a defense-in-depth for
+ * environments we haven't accounted for (CJS test runners, scripts that
+ * import `start` without going through `workflow/api`, future bundlers
+ * with stricter tree-shaking). With this init module in place, the
+ * fallback should never fire in normal use — but if it does, the
+ * dynamic-import branch still resolves correctly when `world.js` is
+ * physically adjacent on disk (e.g., direct Node.js execution of
+ * unbundled source).
+ *
+ * # Maintenance notes
+ *
+ * If you add another `getWorldLazy()` consumer that's reachable from a
+ * host route without going through `workflow/api` (e.g., a new helper in
+ * `workflow/runtime`), 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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwEG;AACH,OAAO,YAAY,CAAC"}

package/dist/runtime/world-init.js

@@ -0,0 +1,75 @@
+/**
+ * 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) before falling back
+ * to a runtime-built dynamic `import('./world.js')`. When a server route
+ * only consumes a single helper that goes through `getWorldLazy` — most
+ * commonly `start` from `workflow/api` — webpack/turbopack tree-shake the
+ * named import `{ getWorld } from './runtime/world.js'` out of
+ * `runtime.ts`, taking `world.ts`'s module evaluation with it. The
+ * globalThis registration never fires.
+ *
+ * `getWorldLazy` then falls through to its dynamic-import fallback, which
+ * itself fails: webpack inlines `get-world-lazy.js` into the bundled route
+ * file, so the relative specifier `./world.js` resolves against
+ * `/var/task/<app>/.next/server/app/<...>/route.js` — where no sibling
+ * `world.js` exists — and Node throws `MODULE_NOT_FOUND`. The symptom is a
+ * cold-start regression: the very first user request that goes through
+ * `start()` fails until some other code path (typically the queue-driven
+ * `/.well-known/workflow/v1/flow` route, which uses `getWorld` directly
+ * via `workflowEntrypoint`) has loaded `world.ts` and populated the
+ * cache.
+ *
+ * Importing this module for its side effect — exactly once, from the
+ * host-side `workflow/api` (`packages/workflow/src/api.ts`) — 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 `@workflow/world-vercel`,
+ * `@workflow/world-local`, `cbor-x`, and other server-only deps out of
+ * the workflow sandbox bundle.
+ *
+ * # Why we keep the `getWorldLazy` dynamic-import fallback
+ *
+ * The fallback remains in `./get-world-lazy.ts` as a defense-in-depth for
+ * environments we haven't accounted for (CJS test runners, scripts that
+ * import `start` without going through `workflow/api`, future bundlers
+ * with stricter tree-shaking). With this init module in place, the
+ * fallback should never fire in normal use — but if it does, the
+ * dynamic-import branch still resolves correctly when `world.js` is
+ * physically adjacent on disk (e.g., direct Node.js execution of
+ * unbundled source).
+ *
+ * # Maintenance notes
+ *
+ * If you add another `getWorldLazy()` consumer that's reachable from a
+ * host route without going through `workflow/api` (e.g., a new helper in
+ * `workflow/runtime`), 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.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":"AAMA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,iBAAiB,CAAC;AA4D7C;;;;;;;;;;;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"}

package/dist/runtime/world.js

@@ -1,22 +1,31 @@
 import { createRequire } from 'node:module';
-import { resolve } from 'node:path';
 import { pathToFileURL } from 'node:url';
 import { isVercelWorldTarget, resolveWorkflowTargetWorld, } from '@workflow/utils';
 import { createLocalWorld } from '@workflow/world-local';
 import { createVercelWorld } from '@workflow/world-vercel';
-const require = createRequire(pathToFileURL(process.cwd() + '/package.json').href);
+function getRuntimeRequire() {
+    // Resolve from the app root (process.cwd()) so custom world packages
+    // like @workflow/world-postgres can be found even though they're not
+    // dependencies of @workflow/core. Using import.meta.url would resolve
+    // from core's location, missing app-level packages.
+    try {
+        return createRequire(pathToFileURL(process.cwd() + '/package.json').href);
+    }
+    catch {
+        return createRequire(import.meta.url);
+    }
+}
 const WorldCache = Symbol.for('@workflow/world//cache');
 const StubbedWorldCache = Symbol.for('@workflow/world//stubbedCache');
 const WorldCachePromise = Symbol.for('@workflow/world//cachePromise');
 const StubbedWorldCachePromise = Symbol.for('@workflow/world//stubbedCachePromise');
 const globalSymbols = globalThis;
-/**
- * Hides the dynamic import behind `new Function` to prevent bundlers from
- * trying to resolve it at build time, since the world module may not exist
- * at build time. Falls back to `require()` in environments where
- * `new Function`-based `import()` is unavailable (e.g. CJS test runners).
- */
-const dynamicImport = new Function('specifier', 'return import(specifier)');
+// Dynamic import for custom world modules. Uses a standard import()
+// wrapped in a try/catch with require() fallback for CJS test runners.
+// Note: the previous `new Function('specifier', 'return import(specifier)')`
+// pattern was replaced because Turbopack (Next.js) treats unresolvable
+// dynamic imports from `new Function` as fatal build errors in the V2
+// combined flow route context.
 function resolveModulePath(specifier) {
     // Already a file:// URL
     if (specifier.startsWith('file://')) {
@@ -28,11 +37,12 @@ function resolveModulePath(specifier) {
     }
     // Relative path - resolve relative to cwd and convert to file:// URL
     if (specifier.startsWith('./') || specifier.startsWith('../')) {
-        return pathToFileURL(resolve(process.cwd(), specifier)).href;
+        return pathToFileURL(
+        /* turbopackIgnore: true */ process.cwd() + '/' + specifier).href;
     }
     // Package specifier - use require.resolve to find the package
     try {
-        return pathToFileURL(require.resolve(specifier)).href;
+        return pathToFileURL(getRuntimeRequire().resolve(specifier)).href;
     }
     catch {
         return specifier;
@@ -76,16 +86,16 @@ export const createWorld = async () => {
             dataDir: process.env.WORKFLOW_LOCAL_DATA_DIR,
         });
     }
-    // Try dynamic import() first — ESM-first since this PR's purpose is ESM support.
-    // Fall back to require() for environments where `new Function`-based import()
-    // is unavailable (e.g. CJS test runners).
+    // Try require() first for custom worlds — this avoids Turbopack tracing
+    // a dynamic import() that it can't statically resolve. Fall back to
+    // dynamic import() for ESM-only packages.
     let mod;
     try {
-        const resolvedPath = resolveModulePath(targetWorld);
-        mod = await dynamicImport(resolvedPath);
+        mod = getRuntimeRequire()(targetWorld);
     }
     catch {
-        mod = require(targetWorld);
+        const resolvedPath = resolveModulePath(targetWorld);
+        mod = await import(/* webpackIgnore: true */ resolvedPath);
     }
     if (typeof mod === 'function') {
         return mod();
@@ -151,4 +161,23 @@ export const setWorld = (world) => {
     globalSymbols[WorldCachePromise] = undefined;
     globalSymbols[StubbedWorldCachePromise] = undefined;
 };
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"world.js","sourceRoot":"","sources":["../../src/runtime/world.ts"],"names":[],"mappings":"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","sourcesContent":["import { createRequire } from 'node:module';\nimport { resolve } from 'node:path';\nimport { pathToFileURL } from 'node:url';\nimport {\n  isVercelWorldTarget,\n  resolveWorkflowTargetWorld,\n} from '@workflow/utils';\nimport type { World } from '@workflow/world';\nimport { createLocalWorld } from '@workflow/world-local';\nimport { createVercelWorld } from '@workflow/world-vercel';\n\nconst require = createRequire(\n  pathToFileURL(process.cwd() + '/package.json').href\n);\n\nconst WorldCache = Symbol.for('@workflow/world//cache');\nconst StubbedWorldCache = Symbol.for('@workflow/world//stubbedCache');\nconst WorldCachePromise = Symbol.for('@workflow/world//cachePromise');\nconst StubbedWorldCachePromise = Symbol.for(\n  '@workflow/world//stubbedCachePromise'\n);\n\nconst globalSymbols: typeof globalThis & {\n  [WorldCache]?: World;\n  [StubbedWorldCache]?: World;\n  [WorldCachePromise]?: Promise<World>;\n  [StubbedWorldCachePromise]?: Promise<World>;\n} = globalThis;\n\n/**\n * Hides the dynamic import behind `new Function` to prevent bundlers from\n * trying to resolve it at build time, since the world module may not exist\n * at build time. Falls back to `require()` in environments where\n * `new Function`-based `import()` is unavailable (e.g. CJS test runners).\n */\nconst dynamicImport = new Function('specifier', 'return import(specifier)') as (\n  specifier: string\n) => Promise<any>;\n\nfunction resolveModulePath(specifier: string): string {\n  // Already a file:// URL\n  if (specifier.startsWith('file://')) {\n    return specifier;\n  }\n  // Absolute path - convert to file:// URL\n  if (specifier.startsWith('/')) {\n    return pathToFileURL(specifier).href;\n  }\n  // Relative path - resolve relative to cwd and convert to file:// URL\n  if (specifier.startsWith('./') || specifier.startsWith('../')) {\n    return pathToFileURL(resolve(process.cwd(), specifier)).href;\n  }\n  // Package specifier - use require.resolve to find the package\n  try {\n    return pathToFileURL(require.resolve(specifier)).href;\n  } catch {\n    return specifier;\n  }\n}\n\n/**\n * Create a new world instance based on environment variables.\n * WORKFLOW_TARGET_WORLD is used to determine the target world.\n *\n * Note: WORKFLOW_VERCEL_* env vars (PROJECT, TEAM, AUTH_TOKEN, etc.) are\n * intentionally NOT read here. Those are for CLI/observability tooling only\n * and should not affect runtime behavior. The Vercel runtime provides\n * authentication via OIDC tokens and project context via system env vars\n * (VERCEL_DEPLOYMENT_ID, VERCEL_PROJECT_ID). Tooling that needs these env\n * vars should call createVercelWorld() directly with an explicit config and\n * use setWorld() to inject the instance.\n */\nexport const createWorld = async (): Promise<World> => {\n  const targetWorld = resolveWorkflowTargetWorld();\n\n  if (isVercelWorldTarget(targetWorld)) {\n    // Warn if WORKFLOW_VERCEL_* env vars are set inside a Vercel serverless\n    // function (VERCEL=1) — they have no effect at runtime and likely indicate\n    // a misconfiguration (user manually added them as Vercel project env vars,\n    // which is not needed). We gate on VERCEL=1 so the warning does not fire\n    // when the CLI or web observability app sets these env vars intentionally.\n    const staleEnvVars = [\n      'WORKFLOW_VERCEL_PROJECT',\n      'WORKFLOW_VERCEL_TEAM',\n      'WORKFLOW_VERCEL_AUTH_TOKEN',\n      'WORKFLOW_VERCEL_ENV',\n    ].filter((key) => process.env[key]);\n    if (staleEnvVars.length > 0 && process.env.VERCEL === '1') {\n      console.warn(\n        `[workflow] Warning: ${staleEnvVars.join(', ')} env var(s) ` +\n          'are set but have no effect at runtime. These are only used by the Workflow CLI. ' +\n          'Remove them from your Vercel project environment variables.'\n      );\n    }\n\n    return createVercelWorld();\n  }\n\n  if (targetWorld === 'local') {\n    return createLocalWorld({\n      dataDir: process.env.WORKFLOW_LOCAL_DATA_DIR,\n    });\n  }\n\n  // Try dynamic import() first — ESM-first since this PR's purpose is ESM support.\n  // Fall back to require() for environments where `new Function`-based import()\n  // is unavailable (e.g. CJS test runners).\n  let mod: any;\n  try {\n    const resolvedPath = resolveModulePath(targetWorld);\n    mod = await dynamicImport(resolvedPath);\n  } catch {\n    mod = require(targetWorld);\n  }\n  if (typeof mod === 'function') {\n    return mod() as World;\n  } else if (typeof mod.default === 'function') {\n    return mod.default() as World;\n  } else if (typeof mod.createWorld === 'function') {\n    return mod.createWorld() as World;\n  }\n\n  throw new Error(\n    `Invalid target world module: ${targetWorld}, must export a default function or createWorld function that returns a World instance.`\n  );\n};\n\nexport type WorldHandlers = Pick<World, 'createQueueHandler' | 'specVersion'>;\n\n/**\n * Some functions from the world are needed at build time, but we do NOT want\n * to cache the world in those instances for general use, since we don't have\n * the correct environment variables set yet. This is a safe function to\n * call at build time, that only gives access to non-environment-bound world\n * functions. The only binding value should be the target world.\n * Once we migrate to a file-based configuration (workflow.config.ts), we should\n * be able to re-combine getWorld and getWorldHandlers into one singleton.\n */\nexport const getWorldHandlers = async (): Promise<WorldHandlers> => {\n  if (globalSymbols[StubbedWorldCache]) {\n    return globalSymbols[StubbedWorldCache];\n  }\n  // Store the promise immediately to prevent race conditions with concurrent calls.\n  // Clear on rejection so subsequent calls can retry instead of caching the failure.\n  if (!globalSymbols[StubbedWorldCachePromise]) {\n    globalSymbols[StubbedWorldCachePromise] = createWorld().catch((err) => {\n      globalSymbols[StubbedWorldCachePromise] = undefined;\n      throw err;\n    });\n  }\n  const _world = await globalSymbols[StubbedWorldCachePromise];\n  globalSymbols[StubbedWorldCache] = _world;\n  return {\n    createQueueHandler: _world.createQueueHandler,\n    specVersion: _world.specVersion,\n  };\n};\n\nexport const getWorld = async (): Promise<World> => {\n  if (globalSymbols[WorldCache]) {\n    return globalSymbols[WorldCache];\n  }\n  // Store the promise immediately to prevent race conditions with concurrent calls.\n  // Clear on rejection so subsequent calls can retry instead of caching the failure.\n  if (!globalSymbols[WorldCachePromise]) {\n    globalSymbols[WorldCachePromise] = createWorld().catch((err) => {\n      globalSymbols[WorldCachePromise] = undefined;\n      throw err;\n    });\n  }\n  globalSymbols[WorldCache] = await globalSymbols[WorldCachePromise];\n  return globalSymbols[WorldCache];\n};\n\n/**\n * Reset the cached world instance. This should be called when environment\n * variables change and you need to reinitialize the world with new config.\n */\nexport const setWorld = (world: World | undefined): void => {\n  globalSymbols[WorldCache] = world;\n  globalSymbols[StubbedWorldCache] = world;\n  globalSymbols[WorldCachePromise] = undefined;\n  globalSymbols[StubbedWorldCachePromise] = undefined;\n};\n"]}
+// Register getWorld on globalThis so getWorldLazy can call it directly when
+// world.ts is statically present in the bundle. This avoids the relative
+// dynamic import('./world.js') fallback in get-world-lazy.ts, which fails
+// after Next.js inlines get-world-lazy.js into a route bundle (no sibling
+// world.js exists at the bundled location).
+//
+// For server routes that only consume `start` (or another helper that goes
+// through getWorldLazy without statically using getWorld), webpack/turbopack
+// would otherwise tree-shake world.ts out of the bundle entirely. The
+// host-only `./world-init.ts` module imports world.ts for its side effect
+// and is itself imported by `packages/workflow/src/api.ts` so this
+// registration runs in every server bundle that touches `workflow/api`.
+//
+// Step/VM bundles never reach this branch: they don't statically import
+// world.ts, and `world-init` resolves to an empty stub via the `workflow`
+// export condition.
+const GetWorldFnKey = Symbol.for('@workflow/world//getWorldFn');
+globalThis[GetWorldFnKey] ??=
+    getWorld;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"world.js","sourceRoot":"","sources":["../../src/runtime/world.ts"],"names":[],"mappings":"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","sourcesContent":["import { createRequire } from 'node:module';\nimport { pathToFileURL } from 'node:url';\nimport {\n  isVercelWorldTarget,\n  resolveWorkflowTargetWorld,\n} from '@workflow/utils';\nimport type { World } from '@workflow/world';\nimport { createLocalWorld } from '@workflow/world-local';\nimport { createVercelWorld } from '@workflow/world-vercel';\n\nfunction getRuntimeRequire() {\n  // Resolve from the app root (process.cwd()) so custom world packages\n  // like @workflow/world-postgres can be found even though they're not\n  // dependencies of @workflow/core. Using import.meta.url would resolve\n  // from core's location, missing app-level packages.\n  try {\n    return createRequire(pathToFileURL(process.cwd() + '/package.json').href);\n  } catch {\n    return createRequire(import.meta.url);\n  }\n}\n\nconst WorldCache = Symbol.for('@workflow/world//cache');\nconst StubbedWorldCache = Symbol.for('@workflow/world//stubbedCache');\nconst WorldCachePromise = Symbol.for('@workflow/world//cachePromise');\nconst StubbedWorldCachePromise = Symbol.for(\n  '@workflow/world//stubbedCachePromise'\n);\n\nconst globalSymbols: typeof globalThis & {\n  [WorldCache]?: World;\n  [StubbedWorldCache]?: World;\n  [WorldCachePromise]?: Promise<World>;\n  [StubbedWorldCachePromise]?: Promise<World>;\n} = globalThis;\n\n// Dynamic import for custom world modules. Uses a standard import()\n// wrapped in a try/catch with require() fallback for CJS test runners.\n// Note: the previous `new Function('specifier', 'return import(specifier)')`\n// pattern was replaced because Turbopack (Next.js) treats unresolvable\n// dynamic imports from `new Function` as fatal build errors in the V2\n// combined flow route context.\n\nfunction resolveModulePath(specifier: string): string {\n  // Already a file:// URL\n  if (specifier.startsWith('file://')) {\n    return specifier;\n  }\n  // Absolute path - convert to file:// URL\n  if (specifier.startsWith('/')) {\n    return pathToFileURL(specifier).href;\n  }\n  // Relative path - resolve relative to cwd and convert to file:// URL\n  if (specifier.startsWith('./') || specifier.startsWith('../')) {\n    return pathToFileURL(\n      /* turbopackIgnore: true */ process.cwd() + '/' + specifier\n    ).href;\n  }\n  // Package specifier - use require.resolve to find the package\n  try {\n    return pathToFileURL(getRuntimeRequire().resolve(specifier)).href;\n  } catch {\n    return specifier;\n  }\n}\n\n/**\n * Create a new world instance based on environment variables.\n * WORKFLOW_TARGET_WORLD is used to determine the target world.\n *\n * Note: WORKFLOW_VERCEL_* env vars (PROJECT, TEAM, AUTH_TOKEN, etc.) are\n * intentionally NOT read here. Those are for CLI/observability tooling only\n * and should not affect runtime behavior. The Vercel runtime provides\n * authentication via OIDC tokens and project context via system env vars\n * (VERCEL_DEPLOYMENT_ID, VERCEL_PROJECT_ID). Tooling that needs these env\n * vars should call createVercelWorld() directly with an explicit config and\n * use setWorld() to inject the instance.\n */\nexport const createWorld = async (): Promise<World> => {\n  const targetWorld = resolveWorkflowTargetWorld();\n\n  if (isVercelWorldTarget(targetWorld)) {\n    // Warn if WORKFLOW_VERCEL_* env vars are set inside a Vercel serverless\n    // function (VERCEL=1) — they have no effect at runtime and likely indicate\n    // a misconfiguration (user manually added them as Vercel project env vars,\n    // which is not needed). We gate on VERCEL=1 so the warning does not fire\n    // when the CLI or web observability app sets these env vars intentionally.\n    const staleEnvVars = [\n      'WORKFLOW_VERCEL_PROJECT',\n      'WORKFLOW_VERCEL_TEAM',\n      'WORKFLOW_VERCEL_AUTH_TOKEN',\n      'WORKFLOW_VERCEL_ENV',\n    ].filter((key) => process.env[key]);\n    if (staleEnvVars.length > 0 && process.env.VERCEL === '1') {\n      console.warn(\n        `[workflow] Warning: ${staleEnvVars.join(', ')} env var(s) ` +\n          'are set but have no effect at runtime. These are only used by the Workflow CLI. ' +\n          'Remove them from your Vercel project environment variables.'\n      );\n    }\n\n    return createVercelWorld();\n  }\n\n  if (targetWorld === 'local') {\n    return createLocalWorld({\n      dataDir: process.env.WORKFLOW_LOCAL_DATA_DIR,\n    });\n  }\n\n  // Try require() first for custom worlds — this avoids Turbopack tracing\n  // a dynamic import() that it can't statically resolve. Fall back to\n  // dynamic import() for ESM-only packages.\n  let mod: any;\n  try {\n    mod = getRuntimeRequire()(targetWorld);\n  } catch {\n    const resolvedPath = resolveModulePath(targetWorld);\n    mod = await import(/* webpackIgnore: true */ resolvedPath);\n  }\n  if (typeof mod === 'function') {\n    return mod() as World;\n  } else if (typeof mod.default === 'function') {\n    return mod.default() as World;\n  } else if (typeof mod.createWorld === 'function') {\n    return mod.createWorld() as World;\n  }\n\n  throw new Error(\n    `Invalid target world module: ${targetWorld}, must export a default function or createWorld function that returns a World instance.`\n  );\n};\n\nexport type WorldHandlers = Pick<World, 'createQueueHandler' | 'specVersion'>;\n\n/**\n * Some functions from the world are needed at build time, but we do NOT want\n * to cache the world in those instances for general use, since we don't have\n * the correct environment variables set yet. This is a safe function to\n * call at build time, that only gives access to non-environment-bound world\n * functions. The only binding value should be the target world.\n * Once we migrate to a file-based configuration (workflow.config.ts), we should\n * be able to re-combine getWorld and getWorldHandlers into one singleton.\n */\nexport const getWorldHandlers = async (): Promise<WorldHandlers> => {\n  if (globalSymbols[StubbedWorldCache]) {\n    return globalSymbols[StubbedWorldCache];\n  }\n  // Store the promise immediately to prevent race conditions with concurrent calls.\n  // Clear on rejection so subsequent calls can retry instead of caching the failure.\n  if (!globalSymbols[StubbedWorldCachePromise]) {\n    globalSymbols[StubbedWorldCachePromise] = createWorld().catch((err) => {\n      globalSymbols[StubbedWorldCachePromise] = undefined;\n      throw err;\n    });\n  }\n  const _world = await globalSymbols[StubbedWorldCachePromise];\n  globalSymbols[StubbedWorldCache] = _world;\n  return {\n    createQueueHandler: _world.createQueueHandler,\n    specVersion: _world.specVersion,\n  };\n};\n\nexport const getWorld = async (): Promise<World> => {\n  if (globalSymbols[WorldCache]) {\n    return globalSymbols[WorldCache];\n  }\n  // Store the promise immediately to prevent race conditions with concurrent calls.\n  // Clear on rejection so subsequent calls can retry instead of caching the failure.\n  if (!globalSymbols[WorldCachePromise]) {\n    globalSymbols[WorldCachePromise] = createWorld().catch((err) => {\n      globalSymbols[WorldCachePromise] = undefined;\n      throw err;\n    });\n  }\n  globalSymbols[WorldCache] = await globalSymbols[WorldCachePromise];\n  return globalSymbols[WorldCache];\n};\n\n/**\n * Reset the cached world instance. This should be called when environment\n * variables change and you need to reinitialize the world with new config.\n */\nexport const setWorld = (world: World | undefined): void => {\n  globalSymbols[WorldCache] = world;\n  globalSymbols[StubbedWorldCache] = world;\n  globalSymbols[WorldCachePromise] = undefined;\n  globalSymbols[StubbedWorldCachePromise] = undefined;\n};\n\n// Register getWorld on globalThis so getWorldLazy can call it directly when\n// world.ts is statically present in the bundle. This avoids the relative\n// dynamic import('./world.js') fallback in get-world-lazy.ts, which fails\n// after Next.js inlines get-world-lazy.js into a route bundle (no sibling\n// world.js exists at the bundled location).\n//\n// For server routes that only consume `start` (or another helper that goes\n// through getWorldLazy without statically using getWorld), webpack/turbopack\n// would otherwise tree-shake world.ts out of the bundle entirely. The\n// host-only `./world-init.ts` module imports world.ts for its side effect\n// and is itself imported by `packages/workflow/src/api.ts` so this\n// registration runs in every server bundle that touches `workflow/api`.\n//\n// Step/VM bundles never reach this branch: they don't statically import\n// world.ts, and `world-init` resolves to an empty stub via the `workflow`\n// export condition.\nconst GetWorldFnKey = Symbol.for('@workflow/world//getWorldFn');\n(globalThis as { [GetWorldFnKey]?: () => Promise<World> })[GetWorldFnKey] ??=\n  getWorld;\n"]}