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

package/dist/runtime/suspension-handler.d.ts

@@ -1,6 +1,6 @@
 import type { Span } from '@opentelemetry/api';
 import { type WorkflowRun, type World } from '@workflow/world';
-import type { WorkflowSuspension } from '../global.js';
+import type { StepInvocationQueueItem, WorkflowSuspension } from '../global.js';
 export interface SuspensionHandlerParams {
     suspension: WorkflowSuspension;
     world: World;
@@ -8,17 +8,35 @@ export interface SuspensionHandlerParams {
     span?: Span;
     requestId?: string;
 }
+/**
+ * Result of handling a suspension. Returns pending step items so the caller
+ * can decide which to execute inline vs queue to background.
+ */
 export interface SuspensionHandlerResult {
+    /** Pending step items with events created but NOT queued */
+    pendingSteps: StepInvocationQueueItem[];
+    /**
+     * Correlation IDs for which this suspension call actually wrote the
+     * step_created event (as opposed to catching EntityConflictError because
+     * a concurrent handler wrote it first). Only the handler that wrote the
+     * step_created event should queue / inline-execute the step — this
+     * guarantees a single owner per step, even when multiple handlers race
+     * into the same batch boundary.
+     */
+    createdStepCorrelationIds: Set<string>;
+    /** Timeout from waits, if any */
     timeoutSeconds?: number;
+    /** Whether a hook conflict was detected (should re-invoke immediately) */
+    hasHookConflict: boolean;
 }
 /**
  * Handles a workflow suspension by processing all pending operations (hooks, steps, waits).
- * Uses an event-sourced architecture where entities (steps, hooks) are created atomically
- * with their corresponding events via events.create().
+ * Creates events for all operations but does NOT queue step messages — returns the pending
+ * steps so the caller can decide which to execute inline vs queue to background.
  *
  * Processing order:
  * 1. Hooks are processed first to prevent race conditions with webhook receivers
- * 2. Steps and waits are processed in parallel after hooks complete
+ * 2. Step events and wait events are created in parallel
  */
 export declare function handleSuspension({ suspension, world, run, span, requestId, }: SuspensionHandlerParams): Promise<SuspensionHandlerResult>;
 //# sourceMappingURL=suspension-handler.d.ts.map

package/dist/runtime/suspension-handler.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"suspension-handler.d.ts","sourceRoot":"","sources":["../../src/runtime/suspension-handler.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,oBAAoB,CAAC;AAO/C,OAAO,EAIL,KAAK,WAAW,EAChB,KAAK,KAAK,EACX,MAAM,iBAAiB,CAAC;AAEzB,OAAO,KAAK,EAIV,kBAAkB,EACnB,MAAM,cAAc,CAAC;AAwBtB,MAAM,WAAW,uBAAuB;IACtC,UAAU,EAAE,kBAAkB,CAAC;IAC/B,KAAK,EAAE,KAAK,CAAC;IACb,GAAG,EAAE,WAAW,CAAC;IACjB,IAAI,CAAC,EAAE,IAAI,CAAC;IACZ,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB;AAED,MAAM,WAAW,uBAAuB;IACtC,cAAc,CAAC,EAAE,MAAM,CAAC;CACzB;AAED;;;;;;;;GAQG;AACH,wBAAsB,gBAAgB,CAAC,EACrC,UAAU,EACV,KAAK,EACL,GAAG,EACH,IAAI,EACJ,SAAS,GACV,EAAE,uBAAuB,GAAG,OAAO,CAAC,uBAAuB,CAAC,CAgS5D"}
+{"version":3,"file":"suspension-handler.d.ts","sourceRoot":"","sources":["../../src/runtime/suspension-handler.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,oBAAoB,CAAC;AAO/C,OAAO,EAIL,KAAK,WAAW,EAChB,KAAK,KAAK,EACX,MAAM,iBAAiB,CAAC;AAEzB,OAAO,KAAK,EAEV,uBAAuB,EAEvB,kBAAkB,EACnB,MAAM,cAAc,CAAC;AAMtB,MAAM,WAAW,uBAAuB;IACtC,UAAU,EAAE,kBAAkB,CAAC;IAC/B,KAAK,EAAE,KAAK,CAAC;IACb,GAAG,EAAE,WAAW,CAAC;IACjB,IAAI,CAAC,EAAE,IAAI,CAAC;IACZ,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB;AAED;;;GAGG;AACH,MAAM,WAAW,uBAAuB;IACtC,4DAA4D;IAC5D,YAAY,EAAE,uBAAuB,EAAE,CAAC;IACxC;;;;;;;OAOG;IACH,yBAAyB,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC;IACvC,iCAAiC;IACjC,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,0EAA0E;IAC1E,eAAe,EAAE,OAAO,CAAC;CAC1B;AAED;;;;;;;;GAQG;AACH,wBAAsB,gBAAgB,CAAC,EACrC,UAAU,EACV,KAAK,EACL,GAAG,EACH,IAAI,EACJ,SAAS,GACV,EAAE,uBAAuB,GAAG,OAAO,CAAC,uBAAuB,CAAC,CAyU5D"}

package/dist/runtime/suspension-handler.js

@@ -4,49 +4,30 @@ import { SPEC_VERSION_CURRENT, } from '@workflow/world';
 import { importKey } from '../encryption.js';
 import { runtimeLogger } from '../logger.js';
 import { dehydrateStepArguments } from '../serialization.js';
+import { getAbortStreamIdFromToken } from '../util.js';
 import * as Attribute from '../telemetry/semantic-conventions.js';
-import { serializeTraceCarrier } from '../telemetry.js';
-import { queueMessage } from './helpers.js';
-/**
- * Extracts W3C trace context headers from a trace carrier for HTTP propagation.
- * Returns an object with `traceparent` and optionally `tracestate` headers.
- */
-function extractTraceHeaders(traceCarrier) {
-    const headers = {};
-    if (traceCarrier.traceparent) {
-        headers.traceparent = traceCarrier.traceparent;
-    }
-    if (traceCarrier.tracestate) {
-        headers.tracestate = traceCarrier.tracestate;
-    }
-    return headers;
-}
 /**
  * Handles a workflow suspension by processing all pending operations (hooks, steps, waits).
- * Uses an event-sourced architecture where entities (steps, hooks) are created atomically
- * with their corresponding events via events.create().
+ * Creates events for all operations but does NOT queue step messages — returns the pending
+ * steps so the caller can decide which to execute inline vs queue to background.
  *
  * Processing order:
  * 1. Hooks are processed first to prevent race conditions with webhook receivers
- * 2. Steps and waits are processed in parallel after hooks complete
+ * 2. Step events and wait events are created in parallel
  */
 export async function handleSuspension({ suspension, world, run, span, requestId, }) {
     const runId = run.runId;
-    const workflowName = run.workflowName;
-    const workflowStartedAt = run.startedAt ? +run.startedAt : Date.now();
     // Separate queue items by type
     const stepItems = suspension.steps.filter((item) => item.type === 'step');
     const allHookItems = suspension.steps.filter((item) => item.type === 'hook');
     const waitItems = suspension.steps.filter((item) => item.type === 'wait');
     // Split hooks by what actions they need
     const hooksNeedingCreation = allHookItems.filter((item) => !item.hasCreatedEvent);
-    // Hooks needing disposal: any disposed hook (including those needing creation first)
-    // Hooks are created before disposal in the processing order below
     const hooksNeedingDisposal = allHookItems.filter((item) => item.disposed);
     // Resolve encryption key for this run
     const rawKey = await world.getEncryptionKeyForRun?.(run);
     const encryptionKey = rawKey ? await importKey(rawKey) : undefined;
-    // Build hook_created events (World will atomically create hook entities)
+    // Build and process hook_created events (same as V1)
     const hookEvents = await Promise.all(hooksNeedingCreation.map(async (queueItem) => {
         const hookMetadata = typeof queueItem.metadata === 'undefined'
             ? undefined
@@ -59,12 +40,14 @@ export async function handleSuspension({ suspension, world, run, span, requestId
                 token: queueItem.token,
                 metadata: hookMetadata,
                 isWebhook: queueItem.isWebhook ?? false,
+                ...(queueItem.isSystem && { isSystem: true }),
             },
         };
     }));
-    // Process hooks first to prevent race conditions with webhook receivers
-    // All hook creations run in parallel
-    // Track any hook conflicts that occur - these will be handled by re-enqueueing the workflow
+    // Process hooks first to prevent race conditions with webhook receivers.
+    // All hook creations run in parallel.
+    // Track any hook conflicts that occur — these are returned to the caller
+    // so the V2 handler can re-invoke immediately.
     let hasHookConflict = false;
     if (hookEvents.length > 0) {
         await Promise.all(hookEvents.map(async (hookEvent) => {
@@ -72,9 +55,9 @@ export async function handleSuspension({ suspension, world, run, span, requestId
                 const result = await world.events.create(runId, hookEvent, {
                     requestId,
                 });
-                // Check if the world returned a hook_conflict event instead of hook_created
+                // Check if the world returned a hook_conflict event instead of hook_created.
                 // The hook_conflict event is stored in the event log and will be replayed
-                // on the next workflow invocation, causing the hook's promise to reject
+                // on the next workflow invocation, causing the hook's promise to reject.
                 // Note: hook events always create an event (legacy runs throw, not return undefined)
                 if (result.event.eventType === 'hook_conflict') {
                     hasHookConflict = true;
@@ -93,7 +76,7 @@ export async function handleSuspension({ suspension, world, run, span, requestId
             }
         }));
     }
-    // Process hook disposals - these release hook tokens for reuse by other workflows
+    // Process hook disposals — these release hook tokens for reuse by other workflows.
     if (hooksNeedingDisposal.length > 0) {
         await Promise.all(hooksNeedingDisposal.map(async (queueItem) => {
             const hookDisposedEvent = {
@@ -134,19 +117,73 @@ export async function handleSuspension({ suspension, world, run, span, requestId
             }
         }));
     }
-    // Build a map of stepId -> step event for steps that need creation
+    // Process abort requests — resume the hook with abort payload and write stream packet
+    const hooksNeedingAbort = allHookItems.filter((item) => item.abortRequested && !item.disposed);
+    if (hooksNeedingAbort.length > 0) {
+        await Promise.all(hooksNeedingAbort.map(async (queueItem) => {
+            try {
+                // Dehydrate the abort payload for storage
+                const abortPayload = await dehydrateStepArguments({ aborted: true, reason: queueItem.abortReason }, runId, encryptionKey, suspension.globalThis);
+                // Create hook_received event with abort payload
+                await world.events.create(runId, {
+                    eventType: 'hook_received',
+                    specVersion: SPEC_VERSION_CURRENT,
+                    correlationId: queueItem.correlationId,
+                    eventData: {
+                        payload: abortPayload,
+                    },
+                });
+                // Write stream cancellation packet for real-time step propagation.
+                // Reuse the same dehydrated payload as the hook event so the reason
+                // round-trips through `dehydrateStepArguments` / `hydrateStepArguments`
+                // (handles DOMException, custom errors, encryption, etc.) instead of
+                // bare JSON.stringify which loses type information and drops undefined.
+                // streamName is set on the queue item at controller construction time
+                // (see workflow/abort-controller.ts).
+                try {
+                    const streamName = getAbortStreamIdFromToken(queueItem.token);
+                    await world.streams.write(runId, streamName, abortPayload);
+                    await world.streams.close(runId, streamName);
+                }
+                catch {
+                    // Best-effort stream write — hook event provides the durable fallback
+                    runtimeLogger.debug('Failed to write abort stream packet, hook event will provide fallback', {
+                        workflowRunId: runId,
+                        correlationId: queueItem.correlationId,
+                    });
+                }
+            }
+            catch (err) {
+                if (EntityConflictError.is(err) || RunExpiredError.is(err)) {
+                    runtimeLogger.info('Workflow run already completed, skipping abort', {
+                        workflowRunId: runId,
+                        correlationId: queueItem.correlationId,
+                        message: err.message,
+                    });
+                }
+                else {
+                    throw err;
+                }
+            }
+        }));
+    }
+    // Create step events for steps that don't have them yet.
+    // Unlike V1, we do NOT queue step messages from here — the caller
+    // decides which steps to execute inline vs. queue to background.
+    // Wait events are also created in parallel below.
     const stepsNeedingCreation = new Set(stepItems
         .filter((queueItem) => !queueItem.hasCreatedEvent)
         .map((queueItem) => queueItem.correlationId));
-    // Process steps and waits in parallel
-    // Each step: create event (if needed) -> queue message
-    // Each wait: create event (if needed)
+    // Correlation IDs for which THIS suspension call actually wrote the
+    // step_created event. Populated by the ops below after a successful
+    // events.create — used by the caller to claim ownership and avoid
+    // racing with concurrent handlers on step execution.
+    const createdStepCorrelationIds = new Set();
     const ops = [];
-    // Steps: create event then queue message, all in parallel
+    // Steps: create step_created events (no queuing — V2 returns pending steps to caller)
     for (const queueItem of stepItems) {
-        ops.push((async () => {
-            // Create step event if not already created
-            if (stepsNeedingCreation.has(queueItem.correlationId)) {
+        if (stepsNeedingCreation.has(queueItem.correlationId)) {
+            ops.push((async () => {
                 const dehydratedInput = await dehydrateStepArguments({
                     args: queueItem.args,
                     closureVars: queueItem.closureVars,
@@ -163,6 +200,7 @@ export async function handleSuspension({ suspension, world, run, span, requestId
                 };
                 try {
                     await world.events.create(runId, stepEvent, { requestId });
+                    createdStepCorrelationIds.add(queueItem.correlationId);
                 }
                 catch (err) {
                     if (EntityConflictError.is(err)) {
@@ -176,28 +214,10 @@ export async function handleSuspension({ suspension, world, run, span, requestId
                         throw err;
                     }
                 }
-            }
-            // Queue step execution message
-            // Serialize trace context once and include in both payload and headers
-            // Payload: for manual context restoration in step handler
-            // Headers: for automatic trace propagation by Vercel's infrastructure
-            const traceCarrier = await serializeTraceCarrier();
-            await queueMessage(world, `__wkf_step_${queueItem.stepName}`, {
-                workflowName,
-                workflowRunId: runId,
-                workflowStartedAt,
-                stepId: queueItem.correlationId,
-                traceCarrier,
-                requestedAt: new Date(),
-            }, {
-                idempotencyKey: queueItem.correlationId,
-                headers: {
-                    ...extractTraceHeaders(traceCarrier),
-                },
-            });
-        })());
+            })());
+        }
     }
-    // Waits: create events in parallel (no queueing needed for waits)
+    // Create wait events (same as V1)
     for (const queueItem of waitItems) {
         if (!queueItem.hasCreatedEvent) {
             ops.push((async () => {
@@ -227,7 +247,6 @@ export async function handleSuspension({ suspension, world, run, span, requestId
             })());
         }
     }
-    // Wait for all step and wait operations to complete
     waitUntil(Promise.all(ops).catch((opErr) => {
         const isAbortError = opErr?.name === 'AbortError' || opErr?.name === 'ResponseAborted';
         if (!isAbortError)
@@ -250,17 +269,11 @@ export async function handleSuspension({ suspension, world, run, span, requestId
         ...Attribute.WorkflowHooksCreated(hooksNeedingCreation.length),
         ...Attribute.WorkflowWaitsCreated(waitItems.length),
     });
-    // If any hook conflicts occurred, re-enqueue the workflow immediately
-    // On the next iteration, the hook consumer will see the hook_conflict event
-    // and reject the promise with a WorkflowRuntimeError
-    // We do this after processing all other operations (steps, waits) to ensure
-    // they are recorded in the event log before the re-execution
-    if (hasHookConflict) {
-        return { timeoutSeconds: 0 };
-    }
-    if (minTimeoutSeconds !== null) {
-        return { timeoutSeconds: minTimeoutSeconds };
-    }
-    return {};
+    return {
+        pendingSteps: stepItems,
+        createdStepCorrelationIds,
+        timeoutSeconds: hasHookConflict ? 0 : (minTimeoutSeconds ?? undefined),
+        hasHookConflict,
+    };
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"suspension-handler.js","sourceRoot":"","sources":["../../src/runtime/suspension-handler.ts"],"names":[],"mappings":"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","sourcesContent":["import type { Span } from '@opentelemetry/api';\nimport { waitUntil } from '@vercel/functions';\nimport {\n  EntityConflictError,\n  HookNotFoundError,\n  RunExpiredError,\n} from '@workflow/errors';\nimport {\n  type CreateEventRequest,\n  type SerializedData,\n  SPEC_VERSION_CURRENT,\n  type WorkflowRun,\n  type World,\n} from '@workflow/world';\nimport { importKey } from '../encryption.js';\nimport type {\n  HookInvocationQueueItem,\n  StepInvocationQueueItem,\n  WaitInvocationQueueItem,\n  WorkflowSuspension,\n} from '../global.js';\nimport { runtimeLogger } from '../logger.js';\nimport { dehydrateStepArguments } from '../serialization.js';\nimport * as Attribute from '../telemetry/semantic-conventions.js';\nimport { serializeTraceCarrier } from '../telemetry.js';\nimport { queueMessage } from './helpers.js';\n\n/**\n * Extracts W3C trace context headers from a trace carrier for HTTP propagation.\n * Returns an object with `traceparent` and optionally `tracestate` headers.\n */\nfunction extractTraceHeaders(\n  traceCarrier: Record<string, string>\n): Record<string, string> {\n  const headers: Record<string, string> = {};\n  if (traceCarrier.traceparent) {\n    headers.traceparent = traceCarrier.traceparent;\n  }\n  if (traceCarrier.tracestate) {\n    headers.tracestate = traceCarrier.tracestate;\n  }\n  return headers;\n}\n\nexport interface SuspensionHandlerParams {\n  suspension: WorkflowSuspension;\n  world: World;\n  run: WorkflowRun;\n  span?: Span;\n  requestId?: string;\n}\n\nexport interface SuspensionHandlerResult {\n  timeoutSeconds?: number;\n}\n\n/**\n * Handles a workflow suspension by processing all pending operations (hooks, steps, waits).\n * Uses an event-sourced architecture where entities (steps, hooks) are created atomically\n * with their corresponding events via events.create().\n *\n * Processing order:\n * 1. Hooks are processed first to prevent race conditions with webhook receivers\n * 2. Steps and waits are processed in parallel after hooks complete\n */\nexport async function handleSuspension({\n  suspension,\n  world,\n  run,\n  span,\n  requestId,\n}: SuspensionHandlerParams): Promise<SuspensionHandlerResult> {\n  const runId = run.runId;\n  const workflowName = run.workflowName;\n  const workflowStartedAt = run.startedAt ? +run.startedAt : Date.now();\n  // Separate queue items by type\n  const stepItems = suspension.steps.filter(\n    (item): item is StepInvocationQueueItem => item.type === 'step'\n  );\n  const allHookItems = suspension.steps.filter(\n    (item): item is HookInvocationQueueItem => item.type === 'hook'\n  );\n  const waitItems = suspension.steps.filter(\n    (item): item is WaitInvocationQueueItem => item.type === 'wait'\n  );\n\n  // Split hooks by what actions they need\n  const hooksNeedingCreation = allHookItems.filter(\n    (item) => !item.hasCreatedEvent\n  );\n  // Hooks needing disposal: any disposed hook (including those needing creation first)\n  // Hooks are created before disposal in the processing order below\n  const hooksNeedingDisposal = allHookItems.filter((item) => item.disposed);\n\n  // Resolve encryption key for this run\n  const rawKey = await world.getEncryptionKeyForRun?.(run);\n  const encryptionKey = rawKey ? await importKey(rawKey) : undefined;\n\n  // Build hook_created events (World will atomically create hook entities)\n  const hookEvents: CreateEventRequest[] = await Promise.all(\n    hooksNeedingCreation.map(async (queueItem) => {\n      const hookMetadata: SerializedData | undefined =\n        typeof queueItem.metadata === 'undefined'\n          ? undefined\n          : ((await dehydrateStepArguments(\n              queueItem.metadata,\n              runId,\n              encryptionKey,\n              suspension.globalThis\n            )) as SerializedData);\n      return {\n        eventType: 'hook_created' as const,\n        specVersion: SPEC_VERSION_CURRENT,\n        correlationId: queueItem.correlationId,\n        eventData: {\n          token: queueItem.token,\n          metadata: hookMetadata,\n          isWebhook: queueItem.isWebhook ?? false,\n        },\n      };\n    })\n  );\n\n  // Process hooks first to prevent race conditions with webhook receivers\n  // All hook creations run in parallel\n  // Track any hook conflicts that occur - these will be handled by re-enqueueing the workflow\n  let hasHookConflict = false;\n\n  if (hookEvents.length > 0) {\n    await Promise.all(\n      hookEvents.map(async (hookEvent) => {\n        try {\n          const result = await world.events.create(runId, hookEvent, {\n            requestId,\n          });\n          // Check if the world returned a hook_conflict event instead of hook_created\n          // The hook_conflict event is stored in the event log and will be replayed\n          // on the next workflow invocation, causing the hook's promise to reject\n          // Note: hook events always create an event (legacy runs throw, not return undefined)\n          if (result.event!.eventType === 'hook_conflict') {\n            hasHookConflict = true;\n          }\n        } catch (err) {\n          if (EntityConflictError.is(err) || RunExpiredError.is(err)) {\n            runtimeLogger.info(\n              'Workflow run already completed, skipping hook',\n              {\n                workflowRunId: runId,\n                message: err.message,\n              }\n            );\n          } else {\n            throw err;\n          }\n        }\n      })\n    );\n  }\n\n  // Process hook disposals - these release hook tokens for reuse by other workflows\n  if (hooksNeedingDisposal.length > 0) {\n    await Promise.all(\n      hooksNeedingDisposal.map(async (queueItem) => {\n        const hookDisposedEvent: CreateEventRequest = {\n          eventType: 'hook_disposed' as const,\n          specVersion: SPEC_VERSION_CURRENT,\n          correlationId: queueItem.correlationId,\n        };\n        try {\n          await world.events.create(runId, hookDisposedEvent, { requestId });\n        } catch (err) {\n          if (EntityConflictError.is(err)) {\n            // Hook was already disposed by a concurrent invocation — safe to skip\n            runtimeLogger.info(\n              'Hook already disposed, skipping duplicate disposal',\n              {\n                workflowRunId: runId,\n                correlationId: queueItem.correlationId,\n                message: err.message,\n              }\n            );\n          } else if (RunExpiredError.is(err)) {\n            runtimeLogger.info(\n              'Workflow run already completed, skipping hook disposal',\n              {\n                workflowRunId: runId,\n                correlationId: queueItem.correlationId,\n                message: err.message,\n              }\n            );\n          } else if (HookNotFoundError.is(err)) {\n            // Hook may have already been disposed or never created\n            runtimeLogger.info('Hook not found for disposal, continuing', {\n              workflowRunId: runId,\n              correlationId: queueItem.correlationId,\n              message: err.message,\n            });\n          } else {\n            throw err;\n          }\n        }\n      })\n    );\n  }\n\n  // Build a map of stepId -> step event for steps that need creation\n  const stepsNeedingCreation = new Set(\n    stepItems\n      .filter((queueItem) => !queueItem.hasCreatedEvent)\n      .map((queueItem) => queueItem.correlationId)\n  );\n\n  // Process steps and waits in parallel\n  // Each step: create event (if needed) -> queue message\n  // Each wait: create event (if needed)\n  const ops: Promise<void>[] = [];\n\n  // Steps: create event then queue message, all in parallel\n  for (const queueItem of stepItems) {\n    ops.push(\n      (async () => {\n        // Create step event if not already created\n        if (stepsNeedingCreation.has(queueItem.correlationId)) {\n          const dehydratedInput = await dehydrateStepArguments(\n            {\n              args: queueItem.args,\n              closureVars: queueItem.closureVars,\n              thisVal: queueItem.thisVal,\n            },\n            runId,\n            encryptionKey,\n            suspension.globalThis\n          );\n          const stepEvent: CreateEventRequest = {\n            eventType: 'step_created' as const,\n            specVersion: SPEC_VERSION_CURRENT,\n            correlationId: queueItem.correlationId,\n            eventData: {\n              stepName: queueItem.stepName,\n              input: dehydratedInput as SerializedData,\n            },\n          };\n          try {\n            await world.events.create(runId, stepEvent, { requestId });\n          } catch (err) {\n            if (EntityConflictError.is(err)) {\n              runtimeLogger.info('Step already exists, continuing', {\n                workflowRunId: runId,\n                correlationId: queueItem.correlationId,\n                message: err.message,\n              });\n            } else {\n              throw err;\n            }\n          }\n        }\n\n        // Queue step execution message\n        // Serialize trace context once and include in both payload and headers\n        // Payload: for manual context restoration in step handler\n        // Headers: for automatic trace propagation by Vercel's infrastructure\n        const traceCarrier = await serializeTraceCarrier();\n        await queueMessage(\n          world,\n          `__wkf_step_${queueItem.stepName}`,\n          {\n            workflowName,\n            workflowRunId: runId,\n            workflowStartedAt,\n            stepId: queueItem.correlationId,\n            traceCarrier,\n            requestedAt: new Date(),\n          },\n          {\n            idempotencyKey: queueItem.correlationId,\n            headers: {\n              ...extractTraceHeaders(traceCarrier),\n            },\n          }\n        );\n      })()\n    );\n  }\n\n  // Waits: create events in parallel (no queueing needed for waits)\n  for (const queueItem of waitItems) {\n    if (!queueItem.hasCreatedEvent) {\n      ops.push(\n        (async () => {\n          const waitEvent: CreateEventRequest = {\n            eventType: 'wait_created' as const,\n            specVersion: SPEC_VERSION_CURRENT,\n            correlationId: queueItem.correlationId,\n            eventData: {\n              resumeAt: queueItem.resumeAt,\n            },\n          };\n          try {\n            await world.events.create(runId, waitEvent, { requestId });\n          } catch (err) {\n            if (EntityConflictError.is(err)) {\n              runtimeLogger.info('Wait already exists, continuing', {\n                workflowRunId: runId,\n                correlationId: queueItem.correlationId,\n                message: err.message,\n              });\n            } else {\n              throw err;\n            }\n          }\n        })()\n      );\n    }\n  }\n\n  // Wait for all step and wait operations to complete\n  waitUntil(\n    Promise.all(ops).catch((opErr) => {\n      const isAbortError =\n        opErr?.name === 'AbortError' || opErr?.name === 'ResponseAborted';\n      if (!isAbortError) throw opErr;\n    })\n  );\n  await Promise.all(ops);\n\n  // Calculate minimum timeout from waits\n  const now = Date.now();\n  const minTimeoutSeconds = waitItems.reduce<number | null>(\n    (min, queueItem) => {\n      const resumeAtMs = queueItem.resumeAt.getTime();\n      const delayMs = Math.max(1000, resumeAtMs - now);\n      const timeoutSeconds = Math.ceil(delayMs / 1000);\n      if (min === null) return timeoutSeconds;\n      return Math.min(min, timeoutSeconds);\n    },\n    null\n  );\n\n  span?.setAttributes({\n    ...Attribute.WorkflowRunStatus('workflow_suspended'),\n    ...Attribute.WorkflowStepsCreated(stepItems.length),\n    ...Attribute.WorkflowHooksCreated(hooksNeedingCreation.length),\n    ...Attribute.WorkflowWaitsCreated(waitItems.length),\n  });\n\n  // If any hook conflicts occurred, re-enqueue the workflow immediately\n  // On the next iteration, the hook consumer will see the hook_conflict event\n  // and reject the promise with a WorkflowRuntimeError\n  // We do this after processing all other operations (steps, waits) to ensure\n  // they are recorded in the event log before the re-execution\n  if (hasHookConflict) {\n    return { timeoutSeconds: 0 };\n  }\n\n  if (minTimeoutSeconds !== null) {\n    return { timeoutSeconds: minTimeoutSeconds };\n  }\n\n  return {};\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"suspension-handler.js","sourceRoot":"","sources":["../../src/runtime/suspension-handler.ts"],"names":[],"mappings":"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","sourcesContent":["import type { Span } from '@opentelemetry/api';\nimport { waitUntil } from '@vercel/functions';\nimport {\n  EntityConflictError,\n  HookNotFoundError,\n  RunExpiredError,\n} from '@workflow/errors';\nimport {\n  type CreateEventRequest,\n  type SerializedData,\n  SPEC_VERSION_CURRENT,\n  type WorkflowRun,\n  type World,\n} from '@workflow/world';\nimport { importKey } from '../encryption.js';\nimport type {\n  HookInvocationQueueItem,\n  StepInvocationQueueItem,\n  WaitInvocationQueueItem,\n  WorkflowSuspension,\n} from '../global.js';\nimport { runtimeLogger } from '../logger.js';\nimport { dehydrateStepArguments } from '../serialization.js';\nimport { getAbortStreamIdFromToken } from '../util.js';\nimport * as Attribute from '../telemetry/semantic-conventions.js';\n\nexport interface SuspensionHandlerParams {\n  suspension: WorkflowSuspension;\n  world: World;\n  run: WorkflowRun;\n  span?: Span;\n  requestId?: string;\n}\n\n/**\n * Result of handling a suspension. Returns pending step items so the caller\n * can decide which to execute inline vs queue to background.\n */\nexport interface SuspensionHandlerResult {\n  /** Pending step items with events created but NOT queued */\n  pendingSteps: StepInvocationQueueItem[];\n  /**\n   * Correlation IDs for which this suspension call actually wrote the\n   * step_created event (as opposed to catching EntityConflictError because\n   * a concurrent handler wrote it first). Only the handler that wrote the\n   * step_created event should queue / inline-execute the step — this\n   * guarantees a single owner per step, even when multiple handlers race\n   * into the same batch boundary.\n   */\n  createdStepCorrelationIds: Set<string>;\n  /** Timeout from waits, if any */\n  timeoutSeconds?: number;\n  /** Whether a hook conflict was detected (should re-invoke immediately) */\n  hasHookConflict: boolean;\n}\n\n/**\n * Handles a workflow suspension by processing all pending operations (hooks, steps, waits).\n * Creates events for all operations but does NOT queue step messages — returns the pending\n * steps so the caller can decide which to execute inline vs queue to background.\n *\n * Processing order:\n * 1. Hooks are processed first to prevent race conditions with webhook receivers\n * 2. Step events and wait events are created in parallel\n */\nexport async function handleSuspension({\n  suspension,\n  world,\n  run,\n  span,\n  requestId,\n}: SuspensionHandlerParams): Promise<SuspensionHandlerResult> {\n  const runId = run.runId;\n  // Separate queue items by type\n  const stepItems = suspension.steps.filter(\n    (item): item is StepInvocationQueueItem => item.type === 'step'\n  );\n  const allHookItems = suspension.steps.filter(\n    (item): item is HookInvocationQueueItem => item.type === 'hook'\n  );\n  const waitItems = suspension.steps.filter(\n    (item): item is WaitInvocationQueueItem => item.type === 'wait'\n  );\n\n  // Split hooks by what actions they need\n  const hooksNeedingCreation = allHookItems.filter(\n    (item) => !item.hasCreatedEvent\n  );\n  const hooksNeedingDisposal = allHookItems.filter((item) => item.disposed);\n\n  // Resolve encryption key for this run\n  const rawKey = await world.getEncryptionKeyForRun?.(run);\n  const encryptionKey = rawKey ? await importKey(rawKey) : undefined;\n\n  // Build and process hook_created events (same as V1)\n  const hookEvents: CreateEventRequest[] = await Promise.all(\n    hooksNeedingCreation.map(async (queueItem) => {\n      const hookMetadata: SerializedData | undefined =\n        typeof queueItem.metadata === 'undefined'\n          ? undefined\n          : ((await dehydrateStepArguments(\n              queueItem.metadata,\n              runId,\n              encryptionKey,\n              suspension.globalThis\n            )) as SerializedData);\n      return {\n        eventType: 'hook_created' as const,\n        specVersion: SPEC_VERSION_CURRENT,\n        correlationId: queueItem.correlationId,\n        eventData: {\n          token: queueItem.token,\n          metadata: hookMetadata,\n          isWebhook: queueItem.isWebhook ?? false,\n          ...(queueItem.isSystem && { isSystem: true }),\n        },\n      };\n    })\n  );\n\n  // Process hooks first to prevent race conditions with webhook receivers.\n  // All hook creations run in parallel.\n  // Track any hook conflicts that occur — these are returned to the caller\n  // so the V2 handler can re-invoke immediately.\n  let hasHookConflict = false;\n\n  if (hookEvents.length > 0) {\n    await Promise.all(\n      hookEvents.map(async (hookEvent) => {\n        try {\n          const result = await world.events.create(runId, hookEvent, {\n            requestId,\n          });\n          // Check if the world returned a hook_conflict event instead of hook_created.\n          // The hook_conflict event is stored in the event log and will be replayed\n          // on the next workflow invocation, causing the hook's promise to reject.\n          // Note: hook events always create an event (legacy runs throw, not return undefined)\n          if (result.event!.eventType === 'hook_conflict') {\n            hasHookConflict = true;\n          }\n        } catch (err) {\n          if (EntityConflictError.is(err) || RunExpiredError.is(err)) {\n            runtimeLogger.info(\n              'Workflow run already completed, skipping hook',\n              {\n                workflowRunId: runId,\n                message: err.message,\n              }\n            );\n          } else {\n            throw err;\n          }\n        }\n      })\n    );\n  }\n\n  // Process hook disposals — these release hook tokens for reuse by other workflows.\n  if (hooksNeedingDisposal.length > 0) {\n    await Promise.all(\n      hooksNeedingDisposal.map(async (queueItem) => {\n        const hookDisposedEvent: CreateEventRequest = {\n          eventType: 'hook_disposed' as const,\n          specVersion: SPEC_VERSION_CURRENT,\n          correlationId: queueItem.correlationId,\n        };\n        try {\n          await world.events.create(runId, hookDisposedEvent, { requestId });\n        } catch (err) {\n          if (EntityConflictError.is(err)) {\n            // Hook was already disposed by a concurrent invocation — safe to skip\n            runtimeLogger.info(\n              'Hook already disposed, skipping duplicate disposal',\n              {\n                workflowRunId: runId,\n                correlationId: queueItem.correlationId,\n                message: err.message,\n              }\n            );\n          } else if (RunExpiredError.is(err)) {\n            runtimeLogger.info(\n              'Workflow run already completed, skipping hook disposal',\n              {\n                workflowRunId: runId,\n                correlationId: queueItem.correlationId,\n                message: err.message,\n              }\n            );\n          } else if (HookNotFoundError.is(err)) {\n            // Hook may have already been disposed or never created\n            runtimeLogger.info('Hook not found for disposal, continuing', {\n              workflowRunId: runId,\n              correlationId: queueItem.correlationId,\n              message: err.message,\n            });\n          } else {\n            throw err;\n          }\n        }\n      })\n    );\n  }\n\n  // Process abort requests — resume the hook with abort payload and write stream packet\n  const hooksNeedingAbort = allHookItems.filter(\n    (item) => item.abortRequested && !item.disposed\n  );\n\n  if (hooksNeedingAbort.length > 0) {\n    await Promise.all(\n      hooksNeedingAbort.map(async (queueItem) => {\n        try {\n          // Dehydrate the abort payload for storage\n          const abortPayload = await dehydrateStepArguments(\n            { aborted: true, reason: queueItem.abortReason },\n            runId,\n            encryptionKey,\n            suspension.globalThis\n          );\n\n          // Create hook_received event with abort payload\n          await world.events.create(runId, {\n            eventType: 'hook_received' as const,\n            specVersion: SPEC_VERSION_CURRENT,\n            correlationId: queueItem.correlationId,\n            eventData: {\n              payload: abortPayload,\n            },\n          });\n\n          // Write stream cancellation packet for real-time step propagation.\n          // Reuse the same dehydrated payload as the hook event so the reason\n          // round-trips through `dehydrateStepArguments` / `hydrateStepArguments`\n          // (handles DOMException, custom errors, encryption, etc.) instead of\n          // bare JSON.stringify which loses type information and drops undefined.\n          // streamName is set on the queue item at controller construction time\n          // (see workflow/abort-controller.ts).\n          try {\n            const streamName = getAbortStreamIdFromToken(queueItem.token);\n            await world.streams.write(\n              runId,\n              streamName,\n              abortPayload as Uint8Array\n            );\n            await world.streams.close(runId, streamName);\n          } catch {\n            // Best-effort stream write — hook event provides the durable fallback\n            runtimeLogger.debug(\n              'Failed to write abort stream packet, hook event will provide fallback',\n              {\n                workflowRunId: runId,\n                correlationId: queueItem.correlationId,\n              }\n            );\n          }\n        } catch (err) {\n          if (EntityConflictError.is(err) || RunExpiredError.is(err)) {\n            runtimeLogger.info(\n              'Workflow run already completed, skipping abort',\n              {\n                workflowRunId: runId,\n                correlationId: queueItem.correlationId,\n                message: err.message,\n              }\n            );\n          } else {\n            throw err;\n          }\n        }\n      })\n    );\n  }\n\n  // Create step events for steps that don't have them yet.\n  // Unlike V1, we do NOT queue step messages from here — the caller\n  // decides which steps to execute inline vs. queue to background.\n  // Wait events are also created in parallel below.\n  const stepsNeedingCreation = new Set(\n    stepItems\n      .filter((queueItem) => !queueItem.hasCreatedEvent)\n      .map((queueItem) => queueItem.correlationId)\n  );\n\n  // Correlation IDs for which THIS suspension call actually wrote the\n  // step_created event. Populated by the ops below after a successful\n  // events.create — used by the caller to claim ownership and avoid\n  // racing with concurrent handlers on step execution.\n  const createdStepCorrelationIds = new Set<string>();\n\n  const ops: Promise<void>[] = [];\n\n  // Steps: create step_created events (no queuing — V2 returns pending steps to caller)\n  for (const queueItem of stepItems) {\n    if (stepsNeedingCreation.has(queueItem.correlationId)) {\n      ops.push(\n        (async () => {\n          const dehydratedInput = await dehydrateStepArguments(\n            {\n              args: queueItem.args,\n              closureVars: queueItem.closureVars,\n              thisVal: queueItem.thisVal,\n            },\n            runId,\n            encryptionKey,\n            suspension.globalThis\n          );\n          const stepEvent: CreateEventRequest = {\n            eventType: 'step_created' as const,\n            specVersion: SPEC_VERSION_CURRENT,\n            correlationId: queueItem.correlationId,\n            eventData: {\n              stepName: queueItem.stepName,\n              input: dehydratedInput as SerializedData,\n            },\n          };\n          try {\n            await world.events.create(runId, stepEvent, { requestId });\n            createdStepCorrelationIds.add(queueItem.correlationId);\n          } catch (err) {\n            if (EntityConflictError.is(err)) {\n              runtimeLogger.info('Step already exists, continuing', {\n                workflowRunId: runId,\n                correlationId: queueItem.correlationId,\n                message: err.message,\n              });\n            } else {\n              throw err;\n            }\n          }\n        })()\n      );\n    }\n  }\n\n  // Create wait events (same as V1)\n  for (const queueItem of waitItems) {\n    if (!queueItem.hasCreatedEvent) {\n      ops.push(\n        (async () => {\n          const waitEvent: CreateEventRequest = {\n            eventType: 'wait_created' as const,\n            specVersion: SPEC_VERSION_CURRENT,\n            correlationId: queueItem.correlationId,\n            eventData: {\n              resumeAt: queueItem.resumeAt,\n            },\n          };\n          try {\n            await world.events.create(runId, waitEvent, { requestId });\n          } catch (err) {\n            if (EntityConflictError.is(err)) {\n              runtimeLogger.info('Wait already exists, continuing', {\n                workflowRunId: runId,\n                correlationId: queueItem.correlationId,\n                message: err.message,\n              });\n            } else {\n              throw err;\n            }\n          }\n        })()\n      );\n    }\n  }\n\n  waitUntil(\n    Promise.all(ops).catch((opErr) => {\n      const isAbortError =\n        opErr?.name === 'AbortError' || opErr?.name === 'ResponseAborted';\n      if (!isAbortError) throw opErr;\n    })\n  );\n  await Promise.all(ops);\n\n  // Calculate minimum timeout from waits\n  const now = Date.now();\n  const minTimeoutSeconds = waitItems.reduce<number | null>(\n    (min, queueItem) => {\n      const resumeAtMs = queueItem.resumeAt.getTime();\n      const delayMs = Math.max(1000, resumeAtMs - now);\n      const timeoutSeconds = Math.ceil(delayMs / 1000);\n      if (min === null) return timeoutSeconds;\n      return Math.min(min, timeoutSeconds);\n    },\n    null\n  );\n\n  span?.setAttributes({\n    ...Attribute.WorkflowRunStatus('workflow_suspended'),\n    ...Attribute.WorkflowStepsCreated(stepItems.length),\n    ...Attribute.WorkflowHooksCreated(hooksNeedingCreation.length),\n    ...Attribute.WorkflowWaitsCreated(waitItems.length),\n  });\n\n  return {\n    pendingSteps: stepItems,\n    createdStepCorrelationIds,\n    timeoutSeconds: hasHookConflict ? 0 : (minTimeoutSeconds ?? undefined),\n    hasHookConflict,\n  };\n}\n"]}

package/dist/runtime/world-init.d.ts

@@ -0,0 +1,75 @@
+/**
+ * Server-only side-effect module that ensures `world.ts` is loaded so its
+ * module-load side effect — `globalThis[GetWorldFnKey] ??= getWorld` —
+ * fires in host bundles.
+ *
+ * # Why this exists
+ *
+ * `getWorldLazy()` in `./get-world-lazy.ts` checks the globalThis cache
+ * (populated by `world.ts`'s module-load side effect) before falling back
+ * to a runtime-built dynamic `import('./world.js')`. When a server route
+ * only consumes a single helper that goes through `getWorldLazy` — most
+ * commonly `start` from `workflow/api` — webpack/turbopack tree-shake the
+ * named import `{ getWorld } from './runtime/world.js'` out of
+ * `runtime.ts`, taking `world.ts`'s module evaluation with it. The
+ * globalThis registration never fires.
+ *
+ * `getWorldLazy` then falls through to its dynamic-import fallback, which
+ * itself fails: webpack inlines `get-world-lazy.js` into the bundled route
+ * file, so the relative specifier `./world.js` resolves against
+ * `/var/task/<app>/.next/server/app/<...>/route.js` — where no sibling
+ * `world.js` exists — and Node throws `MODULE_NOT_FOUND`. The symptom is a
+ * cold-start regression: the very first user request that goes through
+ * `start()` fails until some other code path (typically the queue-driven
+ * `/.well-known/workflow/v1/flow` route, which uses `getWorld` directly
+ * via `workflowEntrypoint`) has loaded `world.ts` and populated the
+ * cache.
+ *
+ * Importing this module for its side effect — exactly once, from the
+ * host-side `workflow/api` (`packages/workflow/src/api.ts`) — guarantees
+ * `world.ts` enters the bundle, the global is registered at module load,
+ * and `getWorldLazy()` short-circuits to the registered function on the
+ * first call.
+ *
+ * # Why a separate module instead of importing `./world.js` directly
+ *
+ * `world.ts` is internal to `@workflow/core` and not part of the public
+ * exports surface. Adding a dedicated public init entry (this file)
+ * keeps the side-effect intent obvious to anyone reading
+ * `packages/workflow/src/api.ts`, and lets the `workflow` export
+ * condition route to a stub for VM/step bundles (see below).
+ *
+ * # Why this doesn't break VM/step bundles
+ *
+ * The `@workflow/core/runtime/world-init` export resolves via the
+ * `workflow` condition to `./dist/workflow/world-init-stub.js`, an empty
+ * module. Esbuild runs the workflow VM and step bundlers with the
+ * `workflow` condition active, so they pick up the stub and never reach
+ * `world.ts`. Host bundlers (webpack, turbopack, Node.js) use the
+ * `default` (or `node`) condition and pick up this file, loading
+ * `world.ts` as intended. The split keeps `@workflow/world-vercel`,
+ * `@workflow/world-local`, `cbor-x`, and other server-only deps out of
+ * the workflow sandbox bundle.
+ *
+ * # Why we keep the `getWorldLazy` dynamic-import fallback
+ *
+ * The fallback remains in `./get-world-lazy.ts` as a defense-in-depth for
+ * environments we haven't accounted for (CJS test runners, scripts that
+ * import `start` without going through `workflow/api`, future bundlers
+ * with stricter tree-shaking). With this init module in place, the
+ * fallback should never fire in normal use — but if it does, the
+ * dynamic-import branch still resolves correctly when `world.js` is
+ * physically adjacent on disk (e.g., direct Node.js execution of
+ * unbundled source).
+ *
+ * # Maintenance notes
+ *
+ * If you add another `getWorldLazy()` consumer that's reachable from a
+ * host route without going through `workflow/api` (e.g., a new helper in
+ * `workflow/runtime`), make sure that entry also imports this module —
+ * or that it transitively reaches `world.ts` via a non-tree-shakeable
+ * path. Adding a regression test in `world-init.test.ts` is preferred to
+ * relying on careful manual tracing.
+ */
+import './world.js';
+//# sourceMappingURL=world-init.d.ts.map

package/dist/runtime/world-init.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"world-init.d.ts","sourceRoot":"","sources":["../../src/runtime/world-init.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwEG;AACH,OAAO,YAAY,CAAC"}

package/dist/runtime/world-init.js

@@ -0,0 +1,75 @@
+/**
+ * Server-only side-effect module that ensures `world.ts` is loaded so its
+ * module-load side effect — `globalThis[GetWorldFnKey] ??= getWorld` —
+ * fires in host bundles.
+ *
+ * # Why this exists
+ *
+ * `getWorldLazy()` in `./get-world-lazy.ts` checks the globalThis cache
+ * (populated by `world.ts`'s module-load side effect) before falling back
+ * to a runtime-built dynamic `import('./world.js')`. When a server route
+ * only consumes a single helper that goes through `getWorldLazy` — most
+ * commonly `start` from `workflow/api` — webpack/turbopack tree-shake the
+ * named import `{ getWorld } from './runtime/world.js'` out of
+ * `runtime.ts`, taking `world.ts`'s module evaluation with it. The
+ * globalThis registration never fires.
+ *
+ * `getWorldLazy` then falls through to its dynamic-import fallback, which
+ * itself fails: webpack inlines `get-world-lazy.js` into the bundled route
+ * file, so the relative specifier `./world.js` resolves against
+ * `/var/task/<app>/.next/server/app/<...>/route.js` — where no sibling
+ * `world.js` exists — and Node throws `MODULE_NOT_FOUND`. The symptom is a
+ * cold-start regression: the very first user request that goes through
+ * `start()` fails until some other code path (typically the queue-driven
+ * `/.well-known/workflow/v1/flow` route, which uses `getWorld` directly
+ * via `workflowEntrypoint`) has loaded `world.ts` and populated the
+ * cache.
+ *
+ * Importing this module for its side effect — exactly once, from the
+ * host-side `workflow/api` (`packages/workflow/src/api.ts`) — guarantees
+ * `world.ts` enters the bundle, the global is registered at module load,
+ * and `getWorldLazy()` short-circuits to the registered function on the
+ * first call.
+ *
+ * # Why a separate module instead of importing `./world.js` directly
+ *
+ * `world.ts` is internal to `@workflow/core` and not part of the public
+ * exports surface. Adding a dedicated public init entry (this file)
+ * keeps the side-effect intent obvious to anyone reading
+ * `packages/workflow/src/api.ts`, and lets the `workflow` export
+ * condition route to a stub for VM/step bundles (see below).
+ *
+ * # Why this doesn't break VM/step bundles
+ *
+ * The `@workflow/core/runtime/world-init` export resolves via the
+ * `workflow` condition to `./dist/workflow/world-init-stub.js`, an empty
+ * module. Esbuild runs the workflow VM and step bundlers with the
+ * `workflow` condition active, so they pick up the stub and never reach
+ * `world.ts`. Host bundlers (webpack, turbopack, Node.js) use the
+ * `default` (or `node`) condition and pick up this file, loading
+ * `world.ts` as intended. The split keeps `@workflow/world-vercel`,
+ * `@workflow/world-local`, `cbor-x`, and other server-only deps out of
+ * the workflow sandbox bundle.
+ *
+ * # Why we keep the `getWorldLazy` dynamic-import fallback
+ *
+ * The fallback remains in `./get-world-lazy.ts` as a defense-in-depth for
+ * environments we haven't accounted for (CJS test runners, scripts that
+ * import `start` without going through `workflow/api`, future bundlers
+ * with stricter tree-shaking). With this init module in place, the
+ * fallback should never fire in normal use — but if it does, the
+ * dynamic-import branch still resolves correctly when `world.js` is
+ * physically adjacent on disk (e.g., direct Node.js execution of
+ * unbundled source).
+ *
+ * # Maintenance notes
+ *
+ * If you add another `getWorldLazy()` consumer that's reachable from a
+ * host route without going through `workflow/api` (e.g., a new helper in
+ * `workflow/runtime`), make sure that entry also imports this module —
+ * or that it transitively reaches `world.ts` via a non-tree-shakeable
+ * path. Adding a regression test in `world-init.test.ts` is preferred to
+ * relying on careful manual tracing.
+ */
+import './world.js';
+//# sourceMappingURL=data:application/json;base64,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

package/dist/runtime/world.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"world.d.ts","sourceRoot":"","sources":["../../src/runtime/world.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,iBAAiB,CAAC;AAqD7C;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,WAAW,QAAa,OAAO,CAAC,KAAK,CAqDjD,CAAC;AAEF,MAAM,MAAM,aAAa,GAAG,IAAI,CAAC,KAAK,EAAE,oBAAoB,GAAG,aAAa,CAAC,CAAC;AAE9E;;;;;;;;GAQG;AACH,eAAO,MAAM,gBAAgB,QAAa,OAAO,CAAC,aAAa,CAkB9D,CAAC;AAEF,eAAO,MAAM,QAAQ,QAAa,OAAO,CAAC,KAAK,CAc9C,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,QAAQ,GAAI,OAAO,KAAK,GAAG,SAAS,KAAG,IAKnD,CAAC"}
+{"version":3,"file":"world.d.ts","sourceRoot":"","sources":["../../src/runtime/world.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,iBAAiB,CAAC;AA4D7C;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,WAAW,QAAa,OAAO,CAAC,KAAK,CAqDjD,CAAC;AAEF,MAAM,MAAM,aAAa,GAAG,IAAI,CAAC,KAAK,EAAE,oBAAoB,GAAG,aAAa,CAAC,CAAC;AAE9E;;;;;;;;GAQG;AACH,eAAO,MAAM,gBAAgB,QAAa,OAAO,CAAC,aAAa,CAkB9D,CAAC;AAEF,eAAO,MAAM,QAAQ,QAAa,OAAO,CAAC,KAAK,CAc9C,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,QAAQ,GAAI,OAAO,KAAK,GAAG,SAAS,KAAG,IAKnD,CAAC"}