eve 0.22.1 → 0.22.3

package/dist/src/compiled/@workflow/core/runtime/world-init.d.ts

@@ -6,30 +6,17 @@
  * # Why this exists
  *
  * `getWorldLazy()` in `./get-world-lazy.ts` checks the globalThis cache
- * (populated by `world.ts`'s module-load side effect) before falling back
- * to a runtime-built dynamic `import('./world.js')`. When a server route
- * only consumes a single helper that goes through `getWorldLazy` — most
- * commonly `start` from `workflow/api` — webpack/turbopack tree-shake the
- * named import `{ getWorld } from './runtime/world.js'` out of
- * `runtime.ts`, taking `world.ts`'s module evaluation with it. The
+ * 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.
  *
- * `getWorldLazy` then falls through to its dynamic-import fallback, which
- * itself fails: webpack inlines `get-world-lazy.js` into the bundled route
- * file, so the relative specifier `./world.js` resolves against
- * `/var/task/<app>/.next/server/app/<...>/route.js` — where no sibling
- * `world.js` exists — and Node throws `MODULE_NOT_FOUND`. The symptom is a
- * cold-start regression: the very first user request that goes through
- * `start()` fails until some other code path (typically the queue-driven
- * `/.well-known/workflow/v1/flow` route, which uses `getWorld` directly
- * via `workflowEntrypoint`) has loaded `world.ts` and populated the
- * cache.
- *
- * Importing this module for its side effect — exactly once, from the
- * host-side `workflow/api` (`packages/workflow/src/api.ts`) — guarantees
- * `world.ts` enters the bundle, the global is registered at module load,
- * and `getWorldLazy()` short-circuits to the registered function on the
- * first call.
+ * 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
  *
@@ -47,29 +34,17 @@
  * `workflow` condition active, so they pick up the stub and never reach
  * `world.ts`. Host bundlers (webpack, turbopack, Node.js) use the
  * `default` (or `node`) condition and pick up this file, loading
- * `world.ts` as intended. The split keeps `@workflow/world-vercel`,
- * `@workflow/world-local`, `cbor-x`, and other server-only deps out of
- * the workflow sandbox bundle.
- *
- * # Why we keep the `getWorldLazy` dynamic-import fallback
- *
- * The fallback remains in `./get-world-lazy.ts` as a defense-in-depth for
- * environments we haven't accounted for (CJS test runners, scripts that
- * import `start` without going through `workflow/api`, future bundlers
- * with stricter tree-shaking). With this init module in place, the
- * fallback should never fire in normal use — but if it does, the
- * dynamic-import branch still resolves correctly when `world.js` is
- * physically adjacent on disk (e.g., direct Node.js execution of
- * unbundled source).
+ * `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/api` (e.g., a new helper in
- * `workflow/runtime`), make sure that entry also imports this module —
- * or that it transitively reaches `world.ts` via a non-tree-shakeable
- * path. Adding a regression test in `world-init.test.ts` is preferred to
- * relying on careful manual tracing.
+ * 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/src/compiled/@workflow/core/runtime/world-target.d.ts

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

package/dist/src/compiled/@workflow/core/runtime/world.d.ts

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

package/dist/src/compiled/@workflow/core/runtime.d.ts

@@ -6,7 +6,7 @@ export { getHookByToken, resumeHook, resumeWebhook, } from './runtime/resume-hoo
 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 StartOptions, type StartOptionsBase, type StartOptionsWithDeploymentId, type StartOptionsWithoutDeploymentId, start, } from './runtime/start.js';
-export { createWorld, getWorld, getWorldHandlers, setWorld, } from './runtime/world.js';
+export { createWorld, createWorldFromModule, getWorld, getWorldHandlers, setWorld, type WorldFactoryModule, } from './runtime/world.js';
 /**
  * Creates a single route which handles workflow execution requests,
  * executing steps inline when possible to reduce function invocations
@@ -21,5 +21,6 @@ export { createWorld, getWorld, getWorldHandlers, setWorld, } from './runtime/wo
 export declare function workflowEntrypoint(workflowCode: string, options?: {
     namespace?: string;
     routeModuleBodyStartedAt?: number;
+    basePath?: string;
 }): (req: Request) => Promise<Response>;
 //# sourceMappingURL=runtime.d.ts.map