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

package/dist/runtime/world.js

@@ -1,102 +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 * as targetWorldModule from '@workflow/core/runtime/world-target';
+import { assertWorldSupportsRuntimeProtocol } from './world-compatibility.js';
 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 statically injected target world module) and
+ * tooling that loads a world module dynamically (e.g. the Nitro dev
+ * handler and `@workflow/world-testing`). Legacy world-specific factory
+ * names are still accepted for compatibility, but world packages should
+ * export `createWorld()`.
  */
-const dynamicImport = new Function('specifier', 'return import(specifier)');
-function resolveModulePath(specifier) {
-    // Already a file:// URL
-    if (specifier.startsWith('file://')) {
-        return specifier;
+export function createWorldFromModule(mod) {
+    if (typeof mod.createWorld === 'function') {
+        return mod.createWorld();
     }
-    // Absolute path - convert to file:// URL
-    if (specifier.startsWith('/')) {
-        return pathToFileURL(specifier).href;
+    if (typeof mod.createLocalWorld === 'function') {
+        return mod.createLocalWorld();
     }
-    // Relative path - resolve relative to cwd and convert to file:// URL
-    if (specifier.startsWith('./') || specifier.startsWith('../')) {
-        return pathToFileURL(resolve(process.cwd(), specifier)).href;
+    if (typeof mod.createVercelWorld === 'function') {
+        return mod.createVercelWorld();
     }
-    // Package specifier - use require.resolve to find the package
-    try {
-        return pathToFileURL(require.resolve(specifier)).href;
+    if (typeof mod.default === 'function') {
+        return mod.default();
     }
-    catch {
-        return specifier;
+    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.');
 }
 /**
- * Create a new world instance based on environment variables.
- * WORKFLOW_TARGET_WORLD is used to determine the target world.
+ * Create a new world instance from the statically imported target world module.
  *
- * Note: WORKFLOW_VERCEL_* env vars (PROJECT, TEAM, AUTH_TOKEN, etc.) are
- * intentionally NOT read here. Those are for CLI/observability tooling only
- * and should not affect runtime behavior. The Vercel runtime provides
- * authentication via OIDC tokens and project context via system env vars
- * (VERCEL_DEPLOYMENT_ID, VERCEL_PROJECT_ID). Tooling that needs these env
- * vars should call createVercelWorld() directly with an explicit config and
- * use setWorld() to inject the instance.
+ * Framework integrations alias `@workflow/core/runtime/world-target` to the
+ * concrete world package at build time, so bundlers see a static import path
+ * instead of tracing a runtime-built require/import expression.
  */
 export const createWorld = async () => {
-    const targetWorld = resolveWorkflowTargetWorld();
-    if (isVercelWorldTarget(targetWorld)) {
-        // Warn if WORKFLOW_VERCEL_* env vars are set inside a Vercel serverless
-        // function (VERCEL=1) — they have no effect at runtime and likely indicate
-        // a misconfiguration (user manually added them as Vercel project env vars,
-        // which is not needed). We gate on VERCEL=1 so the warning does not fire
-        // when the CLI or web observability app sets these env vars intentionally.
-        const staleEnvVars = [
-            'WORKFLOW_VERCEL_PROJECT',
-            'WORKFLOW_VERCEL_TEAM',
-            'WORKFLOW_VERCEL_AUTH_TOKEN',
-            'WORKFLOW_VERCEL_ENV',
-        ].filter((key) => process.env[key]);
-        if (staleEnvVars.length > 0 && process.env.VERCEL === '1') {
-            console.warn(`[workflow] Warning: ${staleEnvVars.join(', ')} env var(s) ` +
-                'are set but have no effect at runtime. These are only used by the Workflow CLI. ' +
-                'Remove them from your Vercel project environment variables.');
-        }
-        return createVercelWorld();
-    }
-    if (targetWorld === 'local') {
-        return createLocalWorld({
-            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).
-    let mod;
-    try {
-        const resolvedPath = resolveModulePath(targetWorld);
-        mod = await dynamicImport(resolvedPath);
-    }
-    catch {
-        mod = require(targetWorld);
-    }
-    if (typeof mod === 'function') {
-        return mod();
-    }
-    else if (typeof mod.default === 'function') {
-        return mod.default();
-    }
-    else if (typeof mod.createWorld === 'function') {
-        return mod.createWorld();
-    }
-    throw new Error(`Invalid target world module: ${targetWorld}, must export a default function or createWorld function that returns a World instance.`);
+    const world = await createWorldFromModule(targetWorldModule);
+    const staleEnvVars = [
+        'WORKFLOW_VERCEL_PROJECT',
+        'WORKFLOW_VERCEL_TEAM',
+        'WORKFLOW_VERCEL_AUTH_TOKEN',
+        'WORKFLOW_VERCEL_ENV',
+    ].filter((key) => process.env[key]);
+    if (staleEnvVars.length > 0 && process.env.VERCEL === '1') {
+        console.warn(`[workflow] Warning: ${staleEnvVars.join(', ')} env var(s) ` +
+            'are set but have no effect at runtime. These are only used by the Workflow CLI. ' +
+            'Remove them from your Vercel project environment variables.');
+    }
+    return world;
 };
 /**
  * Some functions from the world are needed at build time, but we do NOT want
@@ -109,6 +64,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 +76,7 @@ export const getWorldHandlers = async () => {
         });
     }
     const _world = await globalSymbols[StubbedWorldCachePromise];
+    assertWorldSupportsRuntimeProtocol(_world);
     globalSymbols[StubbedWorldCache] = _world;
     return {
         createQueueHandler: _world.createQueueHandler,
@@ -128,6 +85,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 +97,7 @@ export const getWorld = async () => {
         });
     }
     globalSymbols[WorldCache] = await globalSymbols[WorldCachePromise];
+    assertWorldSupportsRuntimeProtocol(globalSymbols[WorldCache]);
     return globalSymbols[WorldCache];
 };
 /**
@@ -151,4 +110,20 @@ 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.
+//
+// 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 * as targetWorldModule from '@workflow/core/runtime/world-target';\nimport type { World } from '@workflow/world';\nimport { assertWorldSupportsRuntimeProtocol } from './world-compatibility.js';\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  /** @deprecated World packages should export `createWorld()` instead. */\n  createLocalWorld?: () => World | Promise<World>;\n  /** @deprecated World packages should export `createWorld()` instead. */\n  createVercelWorld?: () => 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 statically injected target world module) and\n * tooling that loads a world module dynamically (e.g. the Nitro dev\n * handler and `@workflow/world-testing`). Legacy world-specific factory\n * names are still accepted for compatibility, but world packages should\n * export `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.createLocalWorld === 'function') {\n    return mod.createLocalWorld();\n  }\n  if (typeof mod.createVercelWorld === 'function') {\n    return mod.createVercelWorld();\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/**\n * Create a new world instance from the statically imported target world module.\n *\n * Framework integrations alias `@workflow/core/runtime/world-target` to the\n * concrete world package at build time, so bundlers see a static import path\n * instead of tracing a runtime-built require/import expression.\n */\nexport const createWorld = async (): Promise<World> => {\n  const world = await createWorldFromModule(targetWorldModule);\n\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 world;\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.\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

@@ -4,18 +4,23 @@ 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 { 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, 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":"AAgBA,OAAO,EACL,KAAK,KAAK,EAMV,KAAK,WAAW,EAEjB,MAAM,iBAAiB,CAAC;AAmEzB,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,KAAK,gBAAgB,EACrB,SAAS,EACT,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;AAK5B,OAAO,EACL,WAAW,EACX,qBAAqB,EACrB,QAAQ,EACR,gBAAgB,EAChB,QAAQ,EACR,KAAK,kBAAkB,GACxB,MAAM,oBAAoB,CAAC;AAwJ5B;;;;;;;;;;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,CAonErC"}