@workflow/core 5.0.0-beta.4 → 5.0.0-beta.40

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.d.ts

@@ -1,4 +1,16 @@
 import type { World } from '@workflow/world';
+export type WorldFactoryModule = {
+    createWorld?: () => World | Promise<World>;
+    default?: (() => World | Promise<World>) | World;
+};
+/**
+ * Create a World instance from a world factory module. Shared by
+ * `createWorld()` (for the world package named by WORKFLOW_TARGET_WORLD) and
+ * tooling that loads a world module dynamically (e.g. the Nitro dev
+ * handler and `@workflow/world-testing`). World packages should export
+ * `createWorld()`.
+ */
+export declare function createWorldFromModule(mod: WorldFactoryModule): World | Promise<World>;
 /**
  * Create a new world instance based on environment variables.
  * WORKFLOW_TARGET_WORLD is used to determine the target world.
@@ -8,8 +20,8 @@ import type { World } from '@workflow/world';
  * 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.
+ * vars should call the Vercel world's createWorld() directly with an explicit
+ * config and use setWorld() to inject the instance.
  */
 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":"AAMA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,iBAAiB,CAAC;AAuC7C,MAAM,MAAM,kBAAkB,GAAG;IAC/B,WAAW,CAAC,EAAE,MAAM,KAAK,GAAG,OAAO,CAAC,KAAK,CAAC,CAAC;IAC3C,OAAO,CAAC,EAAE,CAAC,MAAM,KAAK,GAAG,OAAO,CAAC,KAAK,CAAC,CAAC,GAAG,KAAK,CAAC;CAClD,CAAC;AAEF;;;;;;GAMG;AACH,wBAAgB,qBAAqB,CACnC,GAAG,EAAE,kBAAkB,GACtB,KAAK,GAAG,OAAO,CAAC,KAAK,CAAC,CAcxB;AA8CD;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,WAAW,QAAa,OAAO,CAAC,KAAK,CA6DjD,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"}

package/dist/runtime/world.js

@@ -1,22 +1,57 @@
 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);
+import { createWorld as createLocalWorld } from '@workflow/world-local';
+import { createWorld as createVercelWorld } from '@workflow/world-vercel';
+import { assertWorldSupportsRuntimeProtocol } from './world-compatibility.js';
+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(
+        /* webpackIgnore: true */
+        /* turbopackIgnore: true */
+        pathToFileURL(process.cwd() + '/package.json').href);
+    }
+    catch {
+        return createRequire(
+        /* webpackIgnore: true */
+        /* turbopackIgnore: true */
+        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).
+ * Create a World instance from a world factory module. Shared by
+ * `createWorld()` (for the world package named by WORKFLOW_TARGET_WORLD) and
+ * tooling that loads a world module dynamically (e.g. the Nitro dev
+ * handler and `@workflow/world-testing`). World packages should export
+ * `createWorld()`.
  */
-const dynamicImport = new Function('specifier', 'return import(specifier)');
+export function createWorldFromModule(mod) {
+    if (typeof mod.createWorld === 'function') {
+        return mod.createWorld();
+    }
+    if (typeof mod.default === 'function') {
+        return mod.default();
+    }
+    if (mod.default && typeof mod.default === 'object') {
+        return mod.default;
+    }
+    throw new Error('Invalid target world module: must export createWorld(), a default factory, or a default World instance.');
+}
+// 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://')) {
@@ -24,15 +59,27 @@ function resolveModulePath(specifier) {
     }
     // Absolute path - convert to file:// URL
     if (specifier.startsWith('/')) {
-        return pathToFileURL(specifier).href;
+        return pathToFileURL(
+        /* webpackIgnore: true */
+        /* turbopackIgnore: true */
+        specifier).href;
     }
     // 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(
+        /* webpackIgnore: true */
+        /* turbopackIgnore: true */
+        process.cwd() + '/' + specifier).href;
     }
     // Package specifier - use require.resolve to find the package
     try {
-        return pathToFileURL(require.resolve(specifier)).href;
+        return pathToFileURL(
+        /* webpackIgnore: true */
+        /* turbopackIgnore: true */
+        getRuntimeRequire().resolve(
+        /* webpackIgnore: true */
+        /* turbopackIgnore: true */
+        specifier)).href;
     }
     catch {
         return specifier;
@@ -47,8 +94,8 @@ function resolveModulePath(specifier) {
  * 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.
+ * vars should call the Vercel world's createWorld() directly with an explicit
+ * config and use setWorld() to inject the instance.
  */
 export const createWorld = async () => {
     const targetWorld = resolveWorkflowTargetWorld();
@@ -76,27 +123,32 @@ 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()(
+        /* webpackIgnore: true */
+        /* turbopackIgnore: true */
+        targetWorld);
     }
     catch {
-        mod = require(targetWorld);
+        const resolvedPath = resolveModulePath(targetWorld);
+        mod = await import(
+        /* webpackIgnore: true */
+        /* turbopackIgnore: true */
+        resolvedPath);
     }
     if (typeof mod === 'function') {
         return mod();
     }
-    else if (typeof mod.default === 'function') {
-        return mod.default();
+    try {
+        return await createWorldFromModule(mod);
     }
-    else if (typeof mod.createWorld === 'function') {
-        return mod.createWorld();
+    catch {
+        throw new Error(`Invalid target world module: ${targetWorld}, must export a createWorld function or a default function that returns a World instance.`);
     }
-    throw new Error(`Invalid target world module: ${targetWorld}, must export a default function or createWorld function that returns a World instance.`);
 };
 /**
  * Some functions from the world are needed at build time, but we do NOT want
@@ -109,6 +161,7 @@ export const createWorld = async () => {
  */
 export const getWorldHandlers = async () => {
     if (globalSymbols[StubbedWorldCache]) {
+        assertWorldSupportsRuntimeProtocol(globalSymbols[StubbedWorldCache]);
         return globalSymbols[StubbedWorldCache];
     }
     // Store the promise immediately to prevent race conditions with concurrent calls.
@@ -120,6 +173,7 @@ export const getWorldHandlers = async () => {
         });
     }
     const _world = await globalSymbols[StubbedWorldCachePromise];
+    assertWorldSupportsRuntimeProtocol(_world);
     globalSymbols[StubbedWorldCache] = _world;
     return {
         createQueueHandler: _world.createQueueHandler,
@@ -128,6 +182,7 @@ export const getWorldHandlers = async () => {
 };
 export const getWorld = async () => {
     if (globalSymbols[WorldCache]) {
+        assertWorldSupportsRuntimeProtocol(globalSymbols[WorldCache]);
         return globalSymbols[WorldCache];
     }
     // Store the promise immediately to prevent race conditions with concurrent calls.
@@ -139,6 +194,7 @@ export const getWorld = async () => {
         });
     }
     globalSymbols[WorldCache] = await globalSymbols[WorldCachePromise];
+    assertWorldSupportsRuntimeProtocol(globalSymbols[WorldCache]);
     return globalSymbols[WorldCache];
 };
 /**
@@ -151,4 +207,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":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AAC5C,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AACpC,OAAO,EAAE,aAAa,EAAE,MAAM,UAAU,CAAC;AACzC,OAAO,EACL,mBAAmB,EACnB,0BAA0B,GAC3B,MAAM,iBAAiB,CAAC;AAEzB,OAAO,EAAE,gBAAgB,EAAE,MAAM,uBAAuB,CAAC;AACzD,OAAO,EAAE,iBAAiB,EAAE,MAAM,wBAAwB,CAAC;AAE3D,MAAM,OAAO,GAAG,aAAa,CAC3B,aAAa,CAAC,OAAO,CAAC,GAAG,EAAE,GAAG,eAAe,CAAC,CAAC,IAAI,CACpD,CAAC;AAEF,MAAM,UAAU,GAAG,MAAM,CAAC,GAAG,CAAC,wBAAwB,CAAC,CAAC;AACxD,MAAM,iBAAiB,GAAG,MAAM,CAAC,GAAG,CAAC,+BAA+B,CAAC,CAAC;AACtE,MAAM,iBAAiB,GAAG,MAAM,CAAC,GAAG,CAAC,+BAA+B,CAAC,CAAC;AACtE,MAAM,wBAAwB,GAAG,MAAM,CAAC,GAAG,CACzC,sCAAsC,CACvC,CAAC;AAEF,MAAM,aAAa,GAKf,UAAU,CAAC;AAEf;;;;;GAKG;AACH,MAAM,aAAa,GAAG,IAAI,QAAQ,CAAC,WAAW,EAAE,0BAA0B,CAEzD,CAAC;AAElB,SAAS,iBAAiB,CAAC,SAAiB;IAC1C,wBAAwB;IACxB,IAAI,SAAS,CAAC,UAAU,CAAC,SAAS,CAAC,EAAE,CAAC;QACpC,OAAO,SAAS,CAAC;IACnB,CAAC;IACD,yCAAyC;IACzC,IAAI,SAAS,CAAC,UAAU,CAAC,GAAG,CAAC,EAAE,CAAC;QAC9B,OAAO,aAAa,CAAC,SAAS,CAAC,CAAC,IAAI,CAAC;IACvC,CAAC;IACD,qEAAqE;IACrE,IAAI,SAAS,CAAC,UAAU,CAAC,IAAI,CAAC,IAAI,SAAS,CAAC,UAAU,CAAC,KAAK,CAAC,EAAE,CAAC;QAC9D,OAAO,aAAa,CAAC,OAAO,CAAC,OAAO,CAAC,GAAG,EAAE,EAAE,SAAS,CAAC,CAAC,CAAC,IAAI,CAAC;IAC/D,CAAC;IACD,8DAA8D;IAC9D,IAAI,CAAC;QACH,OAAO,aAAa,CAAC,OAAO,CAAC,OAAO,CAAC,SAAS,CAAC,CAAC,CAAC,IAAI,CAAC;IACxD,CAAC;IAAC,MAAM,CAAC;QACP,OAAO,SAAS,CAAC;IACnB,CAAC;AACH,CAAC;AAED;;;;;;;;;;;GAWG;AACH,MAAM,CAAC,MAAM,WAAW,GAAG,KAAK,IAAoB,EAAE;IACpD,MAAM,WAAW,GAAG,0BAA0B,EAAE,CAAC;IAEjD,IAAI,mBAAmB,CAAC,WAAW,CAAC,EAAE,CAAC;QACrC,wEAAwE;QACxE,2EAA2E;QAC3E,2EAA2E;QAC3E,yEAAyE;QACzE,2EAA2E;QAC3E,MAAM,YAAY,GAAG;YACnB,yBAAyB;YACzB,sBAAsB;YACtB,4BAA4B;YAC5B,qBAAqB;SACtB,CAAC,MAAM,CAAC,CAAC,GAAG,EAAE,EAAE,CAAC,OAAO,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC,CAAC;QACpC,IAAI,YAAY,CAAC,MAAM,GAAG,CAAC,IAAI,OAAO,CAAC,GAAG,CAAC,MAAM,KAAK,GAAG,EAAE,CAAC;YAC1D,OAAO,CAAC,IAAI,CACV,uBAAuB,YAAY,CAAC,IAAI,CAAC,IAAI,CAAC,cAAc;gBAC1D,kFAAkF;gBAClF,6DAA6D,CAChE,CAAC;QACJ,CAAC;QAED,OAAO,iBAAiB,EAAE,CAAC;IAC7B,CAAC;IAED,IAAI,WAAW,KAAK,OAAO,EAAE,CAAC;QAC5B,OAAO,gBAAgB,CAAC;YACtB,OAAO,EAAE,OAAO,CAAC,GAAG,CAAC,uBAAuB;SAC7C,CAAC,CAAC;IACL,CAAC;IAED,iFAAiF;IACjF,8EAA8E;IAC9E,0CAA0C;IAC1C,IAAI,GAAQ,CAAC;IACb,IAAI,CAAC;QACH,MAAM,YAAY,GAAG,iBAAiB,CAAC,WAAW,CAAC,CAAC;QACpD,GAAG,GAAG,MAAM,aAAa,CAAC,YAAY,CAAC,CAAC;IAC1C,CAAC;IAAC,MAAM,CAAC;QACP,GAAG,GAAG,OAAO,CAAC,WAAW,CAAC,CAAC;IAC7B,CAAC;IACD,IAAI,OAAO,GAAG,KAAK,UAAU,EAAE,CAAC;QAC9B,OAAO,GAAG,EAAW,CAAC;IACxB,CAAC;SAAM,IAAI,OAAO,GAAG,CAAC,OAAO,KAAK,UAAU,EAAE,CAAC;QAC7C,OAAO,GAAG,CAAC,OAAO,EAAW,CAAC;IAChC,CAAC;SAAM,IAAI,OAAO,GAAG,CAAC,WAAW,KAAK,UAAU,EAAE,CAAC;QACjD,OAAO,GAAG,CAAC,WAAW,EAAW,CAAC;IACpC,CAAC;IAED,MAAM,IAAI,KAAK,CACb,gCAAgC,WAAW,yFAAyF,CACrI,CAAC;AACJ,CAAC,CAAC;AAIF;;;;;;;;GAQG;AACH,MAAM,CAAC,MAAM,gBAAgB,GAAG,KAAK,IAA4B,EAAE;IACjE,IAAI,aAAa,CAAC,iBAAiB,CAAC,EAAE,CAAC;QACrC,OAAO,aAAa,CAAC,iBAAiB,CAAC,CAAC;IAC1C,CAAC;IACD,kFAAkF;IAClF,mFAAmF;IACnF,IAAI,CAAC,aAAa,CAAC,wBAAwB,CAAC,EAAE,CAAC;QAC7C,aAAa,CAAC,wBAAwB,CAAC,GAAG,WAAW,EAAE,CAAC,KAAK,CAAC,CAAC,GAAG,EAAE,EAAE;YACpE,aAAa,CAAC,wBAAwB,CAAC,GAAG,SAAS,CAAC;YACpD,MAAM,GAAG,CAAC;QACZ,CAAC,CAAC,CAAC;IACL,CAAC;IACD,MAAM,MAAM,GAAG,MAAM,aAAa,CAAC,wBAAwB,CAAC,CAAC;IAC7D,aAAa,CAAC,iBAAiB,CAAC,GAAG,MAAM,CAAC;IAC1C,OAAO;QACL,kBAAkB,EAAE,MAAM,CAAC,kBAAkB;QAC7C,WAAW,EAAE,MAAM,CAAC,WAAW;KAChC,CAAC;AACJ,CAAC,CAAC;AAEF,MAAM,CAAC,MAAM,QAAQ,GAAG,KAAK,IAAoB,EAAE;IACjD,IAAI,aAAa,CAAC,UAAU,CAAC,EAAE,CAAC;QAC9B,OAAO,aAAa,CAAC,UAAU,CAAC,CAAC;IACnC,CAAC;IACD,kFAAkF;IAClF,mFAAmF;IACnF,IAAI,CAAC,aAAa,CAAC,iBAAiB,CAAC,EAAE,CAAC;QACtC,aAAa,CAAC,iBAAiB,CAAC,GAAG,WAAW,EAAE,CAAC,KAAK,CAAC,CAAC,GAAG,EAAE,EAAE;YAC7D,aAAa,CAAC,iBAAiB,CAAC,GAAG,SAAS,CAAC;YAC7C,MAAM,GAAG,CAAC;QACZ,CAAC,CAAC,CAAC;IACL,CAAC;IACD,aAAa,CAAC,UAAU,CAAC,GAAG,MAAM,aAAa,CAAC,iBAAiB,CAAC,CAAC;IACnE,OAAO,aAAa,CAAC,UAAU,CAAC,CAAC;AACnC,CAAC,CAAC;AAEF;;;GAGG;AACH,MAAM,CAAC,MAAM,QAAQ,GAAG,CAAC,KAAwB,EAAQ,EAAE;IACzD,aAAa,CAAC,UAAU,CAAC,GAAG,KAAK,CAAC;IAClC,aAAa,CAAC,iBAAiB,CAAC,GAAG,KAAK,CAAC;IACzC,aAAa,CAAC,iBAAiB,CAAC,GAAG,SAAS,CAAC;IAC7C,aAAa,CAAC,wBAAwB,CAAC,GAAG,SAAS,CAAC;AACtD,CAAC,CAAC","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 { createWorld as createLocalWorld } from '@workflow/world-local';\nimport { createWorld as createVercelWorld } from '@workflow/world-vercel';\nimport { assertWorldSupportsRuntimeProtocol } from './world-compatibility.js';\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(\n      /* webpackIgnore: true */\n      /* turbopackIgnore: true */\n      pathToFileURL(process.cwd() + '/package.json').href\n    );\n  } catch {\n    return createRequire(\n      /* webpackIgnore: true */\n      /* turbopackIgnore: true */\n      import.meta.url\n    );\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\nexport type WorldFactoryModule = {\n  createWorld?: () => World | Promise<World>;\n  default?: (() => World | Promise<World>) | World;\n};\n\n/**\n * Create a World instance from a world factory module. Shared by\n * `createWorld()` (for the world package named by WORKFLOW_TARGET_WORLD) and\n * tooling that loads a world module dynamically (e.g. the Nitro dev\n * handler and `@workflow/world-testing`). World packages should export\n * `createWorld()`.\n */\nexport function createWorldFromModule(\n  mod: WorldFactoryModule\n): World | Promise<World> {\n  if (typeof mod.createWorld === 'function') {\n    return mod.createWorld();\n  }\n  if (typeof mod.default === 'function') {\n    return mod.default();\n  }\n  if (mod.default && typeof mod.default === 'object') {\n    return mod.default as World;\n  }\n\n  throw new Error(\n    'Invalid target world module: must export createWorld(), a default factory, or a default World instance.'\n  );\n}\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(\n      /* webpackIgnore: true */\n      /* turbopackIgnore: true */\n      specifier\n    ).href;\n  }\n  // Relative path - resolve relative to cwd and convert to file:// URL\n  if (specifier.startsWith('./') || specifier.startsWith('../')) {\n    return pathToFileURL(\n      /* webpackIgnore: true */\n      /* turbopackIgnore: true */\n      process.cwd() + '/' + specifier\n    ).href;\n  }\n  // Package specifier - use require.resolve to find the package\n  try {\n    return pathToFileURL(\n      /* webpackIgnore: true */\n      /* turbopackIgnore: true */\n      getRuntimeRequire().resolve(\n        /* webpackIgnore: true */\n        /* turbopackIgnore: true */\n        specifier\n      )\n    ).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 the Vercel world's createWorld() directly with an explicit\n * config and 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()(\n      /* webpackIgnore: true */\n      /* turbopackIgnore: true */\n      targetWorld\n    );\n  } catch {\n    const resolvedPath = resolveModulePath(targetWorld);\n    mod = await import(\n      /* webpackIgnore: true */\n      /* turbopackIgnore: true */\n      resolvedPath\n    );\n  }\n  if (typeof mod === 'function') {\n    return mod() as World;\n  }\n\n  try {\n    return await createWorldFromModule(mod as WorldFactoryModule);\n  } catch {\n    throw new Error(\n      `Invalid target world module: ${targetWorld}, must export a createWorld function or a default function that returns a World instance.`\n    );\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    assertWorldSupportsRuntimeProtocol(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  assertWorldSupportsRuntimeProtocol(_world);\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    assertWorldSupportsRuntimeProtocol(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  assertWorldSupportsRuntimeProtocol(globalSymbols[WorldCache]);\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"]}

package/dist/runtime.d.ts

@@ -1,21 +1,26 @@
 import { type Event, type WorkflowRun } from '@workflow/world';
 export type { Event, WorkflowRun };
 export { WorkflowSuspension } from './global.js';
-export { type HealthCheckEndpoint, type HealthCheckOptions, type HealthCheckResult, healthCheck, } from './runtime/helpers.js';
-export { getHookByToken, resumeHook, resumeWebhook, } from './runtime/resume-hook.js';
+export { type HealthCheckOptions, type HealthCheckResult, healthCheck, } from './runtime/helpers.js';
+export { getHookByToken, type ResumedHook, resumeHook, resumeWebhook, } from './runtime/resume-hook.js';
 export { getRun, Run, type WorkflowReadableStream, type WorkflowReadableStreamOptions, } from './runtime/run.js';
-export { cancelRun, listStreams, type ReadStreamOptions, type RecreateRunOptions, readStream, recreateRunFromExisting, reenqueueRun, type StopSleepOptions, type StopSleepResult, wakeUpRun, } from './runtime/runs.js';
+export { type CancelRunOptions, cancelRun, cancelRuns, listStreams, type ReadStreamOptions, type RecreateRunOptions, type ReenqueueRunOptions, readStream, recreateRunFromExisting, reenqueueRun, type StopSleepOptions, type StopSleepResult, wakeUpRun, } from './runtime/runs.js';
 export { type StartOptions, type StartOptionsBase, type StartOptionsWithDeploymentId, type StartOptionsWithoutDeploymentId, start, } from './runtime/start.js';
-export { stepEntrypoint } from './runtime/step-handler.js';
-export { createWorld, getWorld, getWorldHandlers, setWorld, } from './runtime/world.js';
+export { createWorld, createWorldFromModule, getWorld, getWorldHandlers, setWorld, type WorldFactoryModule, } from './runtime/world.js';
 /**
- * Function that creates a single route which handles any workflow execution
- * request and routes to the appropriate workflow function.
+ * Creates a single route which handles workflow execution requests,
+ * executing steps inline when possible to reduce function invocations
+ * and queue overhead.
  *
- * @param workflowCode - The workflow bundle code containing all the workflow
- * functions at the top level.
- * @returns A function that can be used as a Vercel API route.
+ * The handler loops: replay workflow → execute step inline → replay → ...
+ * until the workflow completes, times out, or encounters non-step suspensions.
+ *
+ * @param workflowCode - The workflow bundle code containing all workflow functions
+ * @returns A function that can be used as a Vercel API route
  */
-export declare function workflowEntrypoint(workflowCode: string): (req: Request) => Promise<Response>;
-export declare function runStep(): void;
+export declare function workflowEntrypoint(workflowCode: string, options?: {
+    namespace?: string;
+    routeModuleBodyStartedAt?: number;
+    basePath?: string;
+}): (req: Request) => Promise<Response>;
 //# sourceMappingURL=runtime.d.ts.map

package/dist/runtime.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"runtime.d.ts","sourceRoot":"","sources":["../src/runtime.ts"],"names":[],"mappings":"AAOA,OAAO,EACL,KAAK,KAAK,EAGV,KAAK,WAAW,EACjB,MAAM,iBAAiB,CAAC;AAmCzB,YAAY,EAAE,KAAK,EAAE,WAAW,EAAE,CAAC;AACnC,OAAO,EAAE,kBAAkB,EAAE,MAAM,aAAa,CAAC;AACjD,OAAO,EACL,KAAK,mBAAmB,EACxB,KAAK,kBAAkB,EACvB,KAAK,iBAAiB,EACtB,WAAW,GACZ,MAAM,sBAAsB,CAAC;AAC9B,OAAO,EACL,cAAc,EACd,UAAU,EACV,aAAa,GACd,MAAM,0BAA0B,CAAC;AAClC,OAAO,EACL,MAAM,EACN,GAAG,EACH,KAAK,sBAAsB,EAC3B,KAAK,6BAA6B,GACnC,MAAM,kBAAkB,CAAC;AAC1B,OAAO,EACL,SAAS,EACT,WAAW,EACX,KAAK,iBAAiB,EACtB,KAAK,kBAAkB,EACvB,UAAU,EACV,uBAAuB,EACvB,YAAY,EACZ,KAAK,gBAAgB,EACrB,KAAK,eAAe,EACpB,SAAS,GACV,MAAM,mBAAmB,CAAC;AAC3B,OAAO,EACL,KAAK,YAAY,EACjB,KAAK,gBAAgB,EACrB,KAAK,4BAA4B,EACjC,KAAK,+BAA+B,EACpC,KAAK,GACN,MAAM,oBAAoB,CAAC;AAC5B,OAAO,EAAE,cAAc,EAAE,MAAM,2BAA2B,CAAC;AAC3D,OAAO,EACL,WAAW,EACX,QAAQ,EACR,gBAAgB,EAChB,QAAQ,GACT,MAAM,oBAAoB,CAAC;AAE5B;;;;;;;GAOG;AACH,wBAAgB,kBAAkB,CAChC,YAAY,EAAE,MAAM,GACnB,CAAC,GAAG,EAAE,OAAO,KAAK,OAAO,CAAC,QAAQ,CAAC,CAuiBrC;AAID,wBAAgB,OAAO,SAAK"}
+{"version":3,"file":"runtime.d.ts","sourceRoot":"","sources":["../src/runtime.ts"],"names":[],"mappings":"AAmBA,OAAO,EACL,KAAK,KAAK,EAUV,KAAK,WAAW,EAEjB,MAAM,iBAAiB,CAAC;AAgGzB,YAAY,EAAE,KAAK,EAAE,WAAW,EAAE,CAAC;AACnC,OAAO,EAAE,kBAAkB,EAAE,MAAM,aAAa,CAAC;AACjD,OAAO,EACL,KAAK,kBAAkB,EACvB,KAAK,iBAAiB,EACtB,WAAW,GACZ,MAAM,sBAAsB,CAAC;AAC9B,OAAO,EACL,cAAc,EACd,KAAK,WAAW,EAChB,UAAU,EACV,aAAa,GACd,MAAM,0BAA0B,CAAC;AAClC,OAAO,EACL,MAAM,EACN,GAAG,EACH,KAAK,sBAAsB,EAC3B,KAAK,6BAA6B,GACnC,MAAM,kBAAkB,CAAC;AAC1B,OAAO,EACL,KAAK,gBAAgB,EACrB,SAAS,EACT,UAAU,EACV,WAAW,EACX,KAAK,iBAAiB,EACtB,KAAK,kBAAkB,EACvB,KAAK,mBAAmB,EACxB,UAAU,EACV,uBAAuB,EACvB,YAAY,EACZ,KAAK,gBAAgB,EACrB,KAAK,eAAe,EACpB,SAAS,GACV,MAAM,mBAAmB,CAAC;AAC3B,OAAO,EACL,KAAK,YAAY,EACjB,KAAK,gBAAgB,EACrB,KAAK,4BAA4B,EACjC,KAAK,+BAA+B,EACpC,KAAK,GACN,MAAM,oBAAoB,CAAC;AAC5B,OAAO,EACL,WAAW,EACX,qBAAqB,EACrB,QAAQ,EACR,gBAAgB,EAChB,QAAQ,EACR,KAAK,kBAAkB,GACxB,MAAM,oBAAoB,CAAC;AA4Y5B;;;;;;;;;;GAUG;AACH,wBAAgB,kBAAkB,CAChC,YAAY,EAAE,MAAM,EACpB,OAAO,CAAC,EAAE;IACR,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,wBAAwB,CAAC,EAAE,MAAM,CAAC;IAClC,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB,GACA,CAAC,GAAG,EAAE,OAAO,KAAK,OAAO,CAAC,QAAQ,CAAC,CA+4GrC"}