@workflow/core 5.0.0-beta.37 → 5.0.0-beta.38

package/dist/runtime/world.js

@@ -1,5 +1,27 @@
-import * as targetWorldModule from '@workflow/core/runtime/world-target';
+import { createRequire } from 'node:module';
+import { pathToFileURL } from 'node:url';
+import { isVercelWorldTarget, resolveWorkflowTargetWorld, } from '@workflow/utils';
+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');
@@ -7,7 +29,7 @@ const StubbedWorldCachePromise = Symbol.for('@workflow/world//stubbedCachePromis
 const globalSymbols = globalThis;
 /**
  * Create a World instance from a world factory module. Shared by
- * `createWorld()` (for the statically injected target world module) and
+ * `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()`.
@@ -24,27 +46,109 @@ export function createWorldFromModule(mod) {
     }
     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://')) {
+        return specifier;
+    }
+    // Absolute path - convert to file:// URL
+    if (specifier.startsWith('/')) {
+        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(
+        /* webpackIgnore: true */
+        /* turbopackIgnore: true */
+        process.cwd() + '/' + specifier).href;
+    }
+    // Package specifier - use require.resolve to find the package
+    try {
+        return pathToFileURL(
+        /* webpackIgnore: true */
+        /* turbopackIgnore: true */
+        getRuntimeRequire().resolve(
+        /* webpackIgnore: true */
+        /* turbopackIgnore: true */
+        specifier)).href;
+    }
+    catch {
+        return specifier;
+    }
+}
 /**
- * Create a new world instance from the statically imported target world module.
+ * Create a new world instance based on environment variables.
+ * WORKFLOW_TARGET_WORLD is used to determine the target world.
  *
- * 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.
+ * 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 the Vercel world's createWorld() directly with an explicit
+ * config and use setWorld() to inject the instance.
  */
 export const createWorld = async () => {
-    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;
+    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 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 {
+        mod = getRuntimeRequire()(
+        /* webpackIgnore: true */
+        /* turbopackIgnore: true */
+        targetWorld);
+    }
+    catch {
+        const resolvedPath = resolveModulePath(targetWorld);
+        mod = await import(
+        /* webpackIgnore: true */
+        /* turbopackIgnore: true */
+        resolvedPath);
+    }
+    if (typeof mod === 'function') {
+        return mod();
+    }
+    try {
+        return await createWorldFromModule(mod);
+    }
+    catch {
+        throw new Error(`Invalid target world module: ${targetWorld}, must export a createWorld function or a default function that returns a World instance.`);
+    }
 };
 /**
  * Some functions from the world are needed at build time, but we do NOT want
@@ -104,7 +208,10 @@ export const setWorld = (world) => {
     globalSymbols[StubbedWorldCachePromise] = undefined;
 };
 // Register getWorld on globalThis so getWorldLazy can call it directly when
-// world.ts is statically present in the bundle.
+// 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
@@ -119,4 +226,4 @@ export const setWorld = (world) => {
 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":"AAAA,OAAO,KAAK,iBAAiB,MAAM,qCAAqC,CAAC;AAEzE,OAAO,EAAE,kCAAkC,EAAE,MAAM,0BAA0B,CAAC;AAE9E,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;AAOf;;;;;;GAMG;AACH,MAAM,UAAU,qBAAqB,CACnC,GAAuB;IAEvB,IAAI,OAAO,GAAG,CAAC,WAAW,KAAK,UAAU,EAAE,CAAC;QAC1C,OAAO,GAAG,CAAC,WAAW,EAAE,CAAC;IAC3B,CAAC;IACD,IAAI,OAAO,GAAG,CAAC,OAAO,KAAK,UAAU,EAAE,CAAC;QACtC,OAAO,GAAG,CAAC,OAAO,EAAE,CAAC;IACvB,CAAC;IACD,IAAI,GAAG,CAAC,OAAO,IAAI,OAAO,GAAG,CAAC,OAAO,KAAK,QAAQ,EAAE,CAAC;QACnD,OAAO,GAAG,CAAC,OAAgB,CAAC;IAC9B,CAAC;IAED,MAAM,IAAI,KAAK,CACb,yGAAyG,CAC1G,CAAC;AACJ,CAAC;AAED;;;;;;GAMG;AACH,MAAM,CAAC,MAAM,WAAW,GAAG,KAAK,IAAoB,EAAE;IACpD,MAAM,KAAK,GAAG,MAAM,qBAAqB,CAAC,iBAAiB,CAAC,CAAC;IAE7D,MAAM,YAAY,GAAG;QACnB,yBAAyB;QACzB,sBAAsB;QACtB,4BAA4B;QAC5B,qBAAqB;KACtB,CAAC,MAAM,CAAC,CAAC,GAAG,EAAE,EAAE,CAAC,OAAO,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC,CAAC;IACpC,IAAI,YAAY,CAAC,MAAM,GAAG,CAAC,IAAI,OAAO,CAAC,GAAG,CAAC,MAAM,KAAK,GAAG,EAAE,CAAC;QAC1D,OAAO,CAAC,IAAI,CACV,uBAAuB,YAAY,CAAC,IAAI,CAAC,IAAI,CAAC,cAAc;YAC1D,kFAAkF;YAClF,6DAA6D,CAChE,CAAC;IACJ,CAAC;IAED,OAAO,KAAK,CAAC;AACf,CAAC,CAAC;AAIF;;;;;;;;GAQG;AACH,MAAM,CAAC,MAAM,gBAAgB,GAAG,KAAK,IAA4B,EAAE;IACjE,IAAI,aAAa,CAAC,iBAAiB,CAAC,EAAE,CAAC;QACrC,kCAAkC,CAAC,aAAa,CAAC,iBAAiB,CAAC,CAAC,CAAC;QACrE,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,kCAAkC,CAAC,MAAM,CAAC,CAAC;IAC3C,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,kCAAkC,CAAC,aAAa,CAAC,UAAU,CAAC,CAAC,CAAC;QAC9D,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,kCAAkC,CAAC,aAAa,CAAC,UAAU,CAAC,CAAC,CAAC;IAC9D,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;AAEF,4EAA4E;AAC5E,gDAAgD;AAChD,EAAE;AACF,2EAA2E;AAC3E,6EAA6E;AAC7E,sEAAsE;AACtE,0EAA0E;AAC1E,mEAAmE;AACnE,wEAAwE;AACxE,EAAE;AACF,wEAAwE;AACxE,0EAA0E;AAC1E,oBAAoB;AACpB,MAAM,aAAa,GAAG,MAAM,CAAC,GAAG,CAAC,6BAA6B,CAAC,CAAC;AAC/D,UAAyD,CAAC,aAAa,CAAC;IACvE,QAAQ,CAAC","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  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`). 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/**\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"]}
+//# 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"]}