@workflow/core 5.0.0-beta.0 → 5.0.0-beta.10

package/dist/runtime/helpers.js

@@ -1,10 +1,11 @@
 import { HealthCheckPayloadSchema, SPEC_VERSION_CURRENT, SPEC_VERSION_LEGACY, } from '@workflow/world';
 import { monotonicFactory } from 'ulid';
+import { importKey } from '../encryption.js';
 import { runtimeLogger } from '../logger.js';
 import * as Attribute from '../telemetry/semantic-conventions.js';
 import { getSpanKind, trace } from '../telemetry.js';
 import { version as workflowCoreVersion } from '../version.js';
-import { getWorld } from './world.js';
+import { getWorldLazy } from './get-world-lazy.js';
 /** Default timeout for health checks in milliseconds */
 const DEFAULT_HEALTH_CHECK_TIMEOUT = 30_000;
 /**
@@ -43,12 +44,13 @@ export function parseHealthCheckPayload(message) {
     return undefined;
 }
 /**
- * Generates a fake runId for health check streams.
- * This runId passes server validation but is not associated with a real run.
- * The server skips run validation for streams starting with `__health_check__`.
+ * Generates a deterministic fake runId for health check streams.
+ * Both the writer (handleHealthCheckMessage) and reader (healthCheck) derive
+ * the same runId from the correlationId so that implementations that scope
+ * stream reads by runId still work correctly.
  */
-function generateHealthCheckRunId() {
-    return `wrun_${generateId()}`;
+function generateHealthCheckRunId(correlationId) {
+    return `wrun_hc_${correlationId}`;
 }
 /**
  * Handles a health check message by writing the result to the world's stream.
@@ -57,23 +59,22 @@ function generateHealthCheckRunId() {
  * @param healthCheck - The parsed health check payload
  * @param endpoint - Which endpoint is responding ('workflow' or 'step')
  */
-export async function handleHealthCheckMessage(healthCheck, endpoint) {
-    const world = getWorld();
+export async function handleHealthCheckMessage(healthCheck, endpoint, worldSpecVersion) {
+    const world = await getWorldLazy();
     const streamName = getHealthCheckStreamName(healthCheck.correlationId);
     const response = JSON.stringify({
         healthy: true,
         endpoint,
         correlationId: healthCheck.correlationId,
-        specVersion: SPEC_VERSION_CURRENT,
+        specVersion: worldSpecVersion ?? SPEC_VERSION_CURRENT,
         workflowCoreVersion,
         timestamp: Date.now(),
     });
-    // Use a fake runId that passes validation.
-    // The stream name includes the correlationId for identification.
-    // The server skips run validation for health check streams.
-    const fakeRunId = generateHealthCheckRunId();
-    await world.writeToStream(streamName, fakeRunId, response);
-    await world.closeStream(streamName, fakeRunId);
+    // Use a deterministic fake runId derived from the correlationId so that
+    // the reader side produces the same value.
+    const fakeRunId = generateHealthCheckRunId(healthCheck.correlationId);
+    await world.streams.write(fakeRunId, streamName, response);
+    await world.streams.close(fakeRunId, streamName);
 }
 /**
  * Performs a health check by sending a message through the queue pipeline
@@ -158,7 +159,7 @@ function parseHealthCheckResponse(chunks) {
 }
 export async function healthCheck(world, endpoint, options) {
     const timeout = options?.timeout ?? DEFAULT_HEALTH_CHECK_TIMEOUT;
-    const correlationId = `hc_${generateId()}`;
+    const correlationId = generateId();
     const streamName = getHealthCheckStreamName(correlationId);
     const queueName = endpoint === 'workflow'
         ? '__wkf_workflow_health_check'
@@ -173,7 +174,7 @@ export async function healthCheck(world, endpoint, options) {
         });
         while (Date.now() - startTime < timeout) {
             try {
-                const stream = await world.readFromStream(streamName);
+                const stream = await world.streams.get(generateHealthCheckRunId(correlationId), streamName);
                 const reader = stream.getReader();
                 const { chunks, timedOut } = await readStreamWithTimeout(reader, HEALTH_CHECK_READ_TIMEOUT);
                 if (timedOut) {
@@ -212,20 +213,27 @@ export async function healthCheck(world, endpoint, options) {
     }
 }
 /**
- * Loads all workflow run events by iterating through all pages of paginated results.
- * This ensures that *all* events are loaded into memory before running the workflow.
- * Events must be in chronological order (ascending) for proper workflow replay.
+ * Loads workflow run events by iterating through all pages of paginated
+ * results. Events are returned in chronological (ascending) order for
+ * deterministic workflow replay.
+ *
+ * @param runId - The workflow run ID.
+ * @param afterCursor - If provided, only events after this cursor are
+ *   returned (incremental load). If omitted, all events are returned.
+ *   The returned cursor can be passed back in on a subsequent call for
+ *   incremental loading.
  */
-export async function getAllWorkflowRunEvents(runId) {
-    return trace('workflow.loadEvents', async (span) => {
+export async function loadWorkflowRunEvents(runId, afterCursor) {
+    const incremental = afterCursor !== undefined;
+    return trace(incremental ? 'workflow.loadNewEvents' : 'workflow.loadEvents', async (span) => {
         span?.setAttributes({
             ...Attribute.WorkflowRunId(runId),
         });
-        const allEvents = [];
-        let cursor = null;
+        const loadedEvents = [];
+        let cursor = afterCursor ?? null;
         let hasMore = true;
         let pagesLoaded = 0;
-        const world = getWorld();
+        const world = await getWorldLazy();
         const loadStart = Date.now();
         while (hasMore) {
             // TODO: we're currently loading all the data with resolveRef behaviour. We need to update this
@@ -235,34 +243,44 @@ export async function getAllWorkflowRunEvents(runId) {
             const response = await world.events.list({
                 runId,
                 pagination: {
-                    sortOrder: 'asc', // Required: events must be in chronological order for replay
+                    sortOrder: 'asc',
                     cursor: cursor ?? undefined,
                 },
             });
-            allEvents.push(...response.data);
+            loadedEvents.push(...response.data);
             hasMore = response.hasMore;
-            cursor = response.cursor;
+            // Preserve the last non-null cursor across pages. A World may
+            // legitimately return `{ data: [], cursor: null, hasMore: false }`
+            // on a trailing empty page — for example when the previous page's
+            // underlying DB query hit the limit exactly and returned a
+            // `LastEvaluatedKey` "just in case". Overwriting with that null
+            // would lose the position past the last real event we loaded and
+            // force the runtime into the "no cursor after initial load" full-
+            // reload fallback on every subsequent replay iteration.
+            cursor = response.cursor ?? cursor;
             pagesLoaded++;
             runtimeLogger.debug('Loaded event page', {
                 workflowRunId: runId,
+                incremental,
                 page: pagesLoaded,
                 pageEvents: response.data.length,
-                totalEvents: allEvents.length,
+                totalEvents: loadedEvents.length,
                 hasMore,
                 pageMs: Date.now() - pageStart,
             });
         }
-        runtimeLogger.debug('Event loading complete', {
+        runtimeLogger.debug('Event load complete', {
             workflowRunId: runId,
-            totalEvents: allEvents.length,
+            incremental,
+            totalEvents: loadedEvents.length,
             pagesLoaded,
             totalMs: Date.now() - loadStart,
         });
         span?.setAttributes({
-            ...Attribute.WorkflowEventsCount(allEvents.length),
+            ...Attribute.WorkflowEventsCount(loadedEvents.length),
             ...Attribute.WorkflowEventsPagesLoaded(pagesLoaded),
         });
-        return allEvents;
+        return { events: loadedEvents, cursor };
     });
 }
 /**
@@ -278,7 +296,7 @@ const HEALTH_CHECK_CORS_HEADERS = {
  * Wraps a request/response handler and adds a health check "mode"
  * based on the presence of a `__health` query parameter.
  */
-export function withHealthCheck(handler) {
+export function withHealthCheck(handler, worldSpecVersion) {
     return async (req) => {
         const url = new URL(req.url);
         const isHealthCheck = url.searchParams.has('__health');
@@ -293,7 +311,7 @@ export function withHealthCheck(handler) {
             return new Response(JSON.stringify({
                 healthy: true,
                 endpoint: url.pathname,
-                specVersion: SPEC_VERSION_CURRENT,
+                specVersion: worldSpecVersion ?? SPEC_VERSION_CURRENT,
                 workflowCoreVersion,
             }), {
                 status: 200,
@@ -344,4 +362,43 @@ export function getQueueOverhead(message) {
         return;
     }
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"helpers.js","sourceRoot":"","sources":["../../src/runtime/helpers.ts"],"names":[],"mappings":"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"}
+/**
+ * Returns a memoized accessor for the per-run AES-256 encryption key.
+ *
+ * The first call resolves the key via `world.getEncryptionKeyForRun` (which
+ * may do HKDF derivation locally on Vercel, or a network fetch from
+ * external contexts) and imports it as a `CryptoKey`; subsequent calls
+ * await the same cached promise. If the world doesn't support encryption
+ * or the run has no key configured, the cached value is `undefined`.
+ *
+ * Used by step / workflow handlers to defer the (potentially expensive)
+ * key fetch until the first code path that actually needs it — typically
+ * input hydration on the success path, or error dehydration on a failure
+ * path. Both paths can race-call the accessor without triggering duplicate
+ * fetches.
+ *
+ * Errors thrown by `getEncryptionKeyForRun` propagate to every caller
+ * (the cached promise rejects). This is intentional: when encryption is
+ * configured, we never want to silently fall back to plaintext
+ * serialization. A propagated error in an event-emission path leaves the
+ * outer try/catch to log and surface the issue; the queue's redelivery
+ * semantics will retry the key fetch on the next attempt.
+ */
+export function memoizeEncryptionKey(world, runOrId) {
+    let cached;
+    return () => {
+        if (!cached) {
+            cached = (async () => {
+                // The `getEncryptionKeyForRun` overload set takes either a
+                // `WorkflowRun` or a `runId: string` (with optional context). Branch
+                // here so TypeScript picks the right overload for each shape.
+                const rawKey = typeof runOrId === 'string'
+                    ? await world.getEncryptionKeyForRun?.(runOrId)
+                    : await world.getEncryptionKeyForRun?.(runOrId);
+                return rawKey ? await importKey(rawKey) : undefined;
+            })();
+        }
+        return cached;
+    };
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"helpers.js","sourceRoot":"","sources":["../../src/runtime/helpers.ts"],"names":[],"mappings":"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","sourcesContent":["import type {\n  Event,\n  HealthCheckPayload,\n  ValidQueueName,\n  WorkflowRun,\n  World,\n} from '@workflow/world';\nimport {\n  HealthCheckPayloadSchema,\n  SPEC_VERSION_CURRENT,\n  SPEC_VERSION_LEGACY,\n} from '@workflow/world';\nimport { monotonicFactory } from 'ulid';\n\nimport { type CryptoKey, importKey } from '../encryption.js';\nimport { runtimeLogger } from '../logger.js';\nimport * as Attribute from '../telemetry/semantic-conventions.js';\nimport { getSpanKind, trace } from '../telemetry.js';\nimport { version as workflowCoreVersion } from '../version.js';\nimport { getWorldLazy } from './get-world-lazy.js';\n\n/** Default timeout for health checks in milliseconds */\nconst DEFAULT_HEALTH_CHECK_TIMEOUT = 30_000;\n\n/**\n * Pattern for safe workflow names. Only allows alphanumeric characters,\n * underscores, hyphens, dots, forward slashes (for namespaced workflows),\n * and at signs (for scoped packages).\n */\nconst SAFE_WORKFLOW_NAME_PATTERN = /^[a-zA-Z0-9_\\-./@]+$/;\n\n/**\n * Validates a workflow name and returns the corresponding queue name.\n * Ensures the workflow name only contains safe characters before\n * interpolating it into the queue name string.\n */\nexport function getWorkflowQueueName(workflowName: string): ValidQueueName {\n  if (!SAFE_WORKFLOW_NAME_PATTERN.test(workflowName)) {\n    throw new Error(\n      `Invalid workflow name \"${workflowName}\": must only contain alphanumeric characters, underscores, hyphens, dots, forward slashes, or at signs`\n    );\n  }\n  return `__wkf_workflow_${workflowName}` as ValidQueueName;\n}\n\nconst generateId = monotonicFactory();\n\n/**\n * Returns the stream name for a health check with the given correlation ID.\n */\nfunction getHealthCheckStreamName(correlationId: string): string {\n  return `__health_check__${correlationId}`;\n}\n\n/**\n * Result of a health check operation.\n */\nexport interface HealthCheckResult {\n  healthy: boolean;\n  /** Error message if health check failed */\n  error?: string;\n  /** Latency if the health check was successful */\n  latencyMs?: number;\n  /** Spec version of the responding deployment */\n  specVersion?: number;\n}\n\n/**\n * Checks if the given message is a health check payload.\n * If so, returns the parsed payload. Otherwise returns undefined.\n */\nexport function parseHealthCheckPayload(\n  message: unknown\n): HealthCheckPayload | undefined {\n  const result = HealthCheckPayloadSchema.safeParse(message);\n  if (result.success) {\n    return result.data;\n  }\n  return undefined;\n}\n\n/**\n * Generates a deterministic fake runId for health check streams.\n * Both the writer (handleHealthCheckMessage) and reader (healthCheck) derive\n * the same runId from the correlationId so that implementations that scope\n * stream reads by runId still work correctly.\n */\nfunction generateHealthCheckRunId(correlationId: string): string {\n  return `wrun_hc_${correlationId}`;\n}\n\n/**\n * Handles a health check message by writing the result to the world's stream.\n * The caller can listen to this stream to get the health check response.\n *\n * @param healthCheck - The parsed health check payload\n * @param endpoint - Which endpoint is responding ('workflow' or 'step')\n */\nexport async function handleHealthCheckMessage(\n  healthCheck: HealthCheckPayload,\n  endpoint: 'workflow' | 'step',\n  worldSpecVersion?: number\n): Promise<void> {\n  const world = await getWorldLazy();\n  const streamName = getHealthCheckStreamName(healthCheck.correlationId);\n  const response = JSON.stringify({\n    healthy: true,\n    endpoint,\n    correlationId: healthCheck.correlationId,\n    specVersion: worldSpecVersion ?? SPEC_VERSION_CURRENT,\n    workflowCoreVersion,\n    timestamp: Date.now(),\n  });\n  // Use a deterministic fake runId derived from the correlationId so that\n  // the reader side produces the same value.\n  const fakeRunId = generateHealthCheckRunId(healthCheck.correlationId);\n  await world.streams.write(fakeRunId, streamName, response);\n  await world.streams.close(fakeRunId, streamName);\n}\n\nexport type HealthCheckEndpoint = 'workflow' | 'step';\n\nexport interface HealthCheckOptions {\n  /** Timeout in milliseconds to wait for health check response. Default: 30000 (30s) */\n  timeout?: number;\n  /** Deployment ID to send the health check to. Falls back to process.env.VERCEL_DEPLOYMENT_ID. */\n  deploymentId?: string;\n}\n\n/**\n * Performs a health check by sending a message through the queue pipeline\n * and verifying it is processed by the specified endpoint.\n *\n * This function bypasses Deployment Protection on Vercel because it goes\n * through the queue infrastructure rather than direct HTTP.\n *\n * @param world - The World instance to use for the health check\n * @param endpoint - Which endpoint to health check: 'workflow' or 'step'\n * @param options - Optional configuration for the health check\n * @returns Promise resolving to health check result\n */\n// Poll interval for health check retries (ms)\nconst HEALTH_CHECK_POLL_INTERVAL = 100;\n// Per-read timeout to prevent blocking forever on local world's EventEmitter\n// (which doesn't work across processes)\nconst HEALTH_CHECK_READ_TIMEOUT = 500;\n\n/**\n * Read chunks from a stream with a timeout per read operation.\n * Returns { chunks, timedOut } where timedOut indicates if a read timed out.\n */\nasync function readStreamWithTimeout(\n  reader: ReadableStreamDefaultReader<Uint8Array>,\n  readTimeout: number\n): Promise<{ chunks: Uint8Array[]; timedOut: boolean }> {\n  const chunks: Uint8Array[] = [];\n  let done = false;\n  let timedOut = false;\n\n  while (!done && !timedOut) {\n    const readPromise = reader.read();\n    const timeoutPromise = new Promise<{ done: true; value: undefined }>(\n      (resolve) =>\n        setTimeout(() => {\n          timedOut = true;\n          resolve({ done: true, value: undefined });\n        }, readTimeout)\n    );\n\n    const result = await Promise.race([readPromise, timeoutPromise]);\n    done = result.done;\n    if (result.value) chunks.push(result.value);\n  }\n\n  return { chunks, timedOut };\n}\n\n/**\n * Parse and validate a health check response from stream chunks.\n * Returns the parsed response or null if invalid.\n */\nfunction parseHealthCheckResponse(\n  chunks: Uint8Array[]\n): { healthy: boolean } | null {\n  if (chunks.length === 0) return null;\n\n  const totalLength = chunks.reduce((sum, chunk) => sum + chunk.length, 0);\n  const combined = new Uint8Array(totalLength);\n  let offset = 0;\n  for (const chunk of chunks) {\n    combined.set(chunk, offset);\n    offset += chunk.length;\n  }\n  const responseText = new TextDecoder().decode(combined);\n\n  let response: unknown;\n  try {\n    response = JSON.parse(responseText);\n  } catch {\n    // Old deployments (specVersion < 3) return plain text like\n    // 'Workflow SDK \"...\" endpoint is healthy'. Treat any non-empty\n    // text response as a healthy deployment with unknown specVersion.\n    if (responseText.length > 0) {\n      return { healthy: true };\n    }\n    return null;\n  }\n\n  if (\n    typeof response !== 'object' ||\n    response === null ||\n    !('healthy' in response) ||\n    typeof (response as { healthy: unknown }).healthy !== 'boolean'\n  ) {\n    return null;\n  }\n\n  const r = response as Record<string, unknown>;\n  const parsed: { healthy: boolean; specVersion?: number } = {\n    healthy: r.healthy as boolean,\n  };\n  if (typeof r.specVersion === 'number') {\n    parsed.specVersion = r.specVersion;\n  }\n  return parsed;\n}\n\nexport async function healthCheck(\n  world: World,\n  endpoint: HealthCheckEndpoint,\n  options?: HealthCheckOptions\n): Promise<HealthCheckResult> {\n  const timeout = options?.timeout ?? DEFAULT_HEALTH_CHECK_TIMEOUT;\n  const correlationId = generateId();\n  const streamName = getHealthCheckStreamName(correlationId);\n\n  const queueName: ValidQueueName =\n    endpoint === 'workflow'\n      ? '__wkf_workflow_health_check'\n      : '__wkf_step_health_check';\n\n  const startTime = Date.now();\n\n  try {\n    await world.queue(\n      queueName,\n      { __healthCheck: true, correlationId },\n      {\n        // Use JSON transport so the health check works against both\n        // old (JSON-only) and new (dual) deployments.\n        specVersion: SPEC_VERSION_LEGACY,\n        deploymentId: options?.deploymentId,\n      }\n    );\n\n    while (Date.now() - startTime < timeout) {\n      try {\n        const stream = await world.streams.get(\n          generateHealthCheckRunId(correlationId),\n          streamName\n        );\n        const reader = stream.getReader();\n        const { chunks, timedOut } = await readStreamWithTimeout(\n          reader,\n          HEALTH_CHECK_READ_TIMEOUT\n        );\n\n        if (timedOut) {\n          try {\n            reader.cancel();\n          } catch {\n            // Ignore cancel errors\n          }\n          await new Promise((resolve) =>\n            setTimeout(resolve, HEALTH_CHECK_POLL_INTERVAL)\n          );\n          continue;\n        }\n\n        const response = parseHealthCheckResponse(chunks);\n        if (response) {\n          return {\n            ...response,\n            latencyMs: Date.now() - startTime,\n          };\n        }\n\n        await new Promise((resolve) =>\n          setTimeout(resolve, HEALTH_CHECK_POLL_INTERVAL)\n        );\n      } catch {\n        await new Promise((resolve) =>\n          setTimeout(resolve, HEALTH_CHECK_POLL_INTERVAL)\n        );\n      }\n    }\n    return {\n      healthy: false,\n      error: `Health check timed out after ${timeout}ms`,\n    };\n  } catch (error) {\n    return {\n      healthy: false,\n      error: error instanceof Error ? error.message : String(error),\n    };\n  }\n}\n\n/**\n * Loads workflow run events by iterating through all pages of paginated\n * results. Events are returned in chronological (ascending) order for\n * deterministic workflow replay.\n *\n * @param runId - The workflow run ID.\n * @param afterCursor - If provided, only events after this cursor are\n *   returned (incremental load). If omitted, all events are returned.\n *   The returned cursor can be passed back in on a subsequent call for\n *   incremental loading.\n */\nexport async function loadWorkflowRunEvents(\n  runId: string,\n  afterCursor?: string\n): Promise<{ events: Event[]; cursor: string | null }> {\n  const incremental = afterCursor !== undefined;\n  return trace(\n    incremental ? 'workflow.loadNewEvents' : 'workflow.loadEvents',\n    async (span) => {\n      span?.setAttributes({\n        ...Attribute.WorkflowRunId(runId),\n      });\n\n      const loadedEvents: Event[] = [];\n      let cursor: string | null = afterCursor ?? null;\n      let hasMore = true;\n      let pagesLoaded = 0;\n\n      const world = await getWorldLazy();\n      const loadStart = Date.now();\n      while (hasMore) {\n        // TODO: we're currently loading all the data with resolveRef behaviour. We need to update this\n        // to lazyload the data from the world instead so that we can optimize and make the event log loading\n        // much faster and memory efficient\n        const pageStart = Date.now();\n        const response = await world.events.list({\n          runId,\n          pagination: {\n            sortOrder: 'asc',\n            cursor: cursor ?? undefined,\n          },\n        });\n\n        loadedEvents.push(...response.data);\n        hasMore = response.hasMore;\n        // Preserve the last non-null cursor across pages. A World may\n        // legitimately return `{ data: [], cursor: null, hasMore: false }`\n        // on a trailing empty page — for example when the previous page's\n        // underlying DB query hit the limit exactly and returned a\n        // `LastEvaluatedKey` \"just in case\". Overwriting with that null\n        // would lose the position past the last real event we loaded and\n        // force the runtime into the \"no cursor after initial load\" full-\n        // reload fallback on every subsequent replay iteration.\n        cursor = response.cursor ?? cursor;\n        pagesLoaded++;\n\n        runtimeLogger.debug('Loaded event page', {\n          workflowRunId: runId,\n          incremental,\n          page: pagesLoaded,\n          pageEvents: response.data.length,\n          totalEvents: loadedEvents.length,\n          hasMore,\n          pageMs: Date.now() - pageStart,\n        });\n      }\n\n      runtimeLogger.debug('Event load complete', {\n        workflowRunId: runId,\n        incremental,\n        totalEvents: loadedEvents.length,\n        pagesLoaded,\n        totalMs: Date.now() - loadStart,\n      });\n\n      span?.setAttributes({\n        ...Attribute.WorkflowEventsCount(loadedEvents.length),\n        ...Attribute.WorkflowEventsPagesLoaded(pagesLoaded),\n      });\n\n      return { events: loadedEvents, cursor };\n    }\n  );\n}\n\n/**\n * CORS headers for health check responses.\n * Allows the observability UI to check endpoint health from a different origin.\n */\nconst HEALTH_CHECK_CORS_HEADERS = {\n  'Access-Control-Allow-Origin': '*',\n  'Access-Control-Allow-Methods': 'POST, OPTIONS, GET, HEAD',\n  'Access-Control-Allow-Headers': 'Content-Type',\n};\n\n/**\n * Wraps a request/response handler and adds a health check \"mode\"\n * based on the presence of a `__health` query parameter.\n */\nexport function withHealthCheck(\n  handler: (req: Request) => Promise<Response>,\n  worldSpecVersion?: number\n): (req: Request) => Promise<Response> {\n  return async (req: Request) => {\n    const url = new URL(req.url);\n    const isHealthCheck = url.searchParams.has('__health');\n    if (isHealthCheck) {\n      // Handle CORS preflight for health check\n      if (req.method === 'OPTIONS') {\n        return new Response(null, {\n          status: 204,\n          headers: HEALTH_CHECK_CORS_HEADERS,\n        });\n      }\n      return new Response(\n        JSON.stringify({\n          healthy: true,\n          endpoint: url.pathname,\n          specVersion: worldSpecVersion ?? SPEC_VERSION_CURRENT,\n          workflowCoreVersion,\n        }),\n        {\n          status: 200,\n          headers: {\n            'Content-Type': 'application/json',\n            ...HEALTH_CHECK_CORS_HEADERS,\n          },\n        }\n      );\n    }\n    return await handler(req);\n  };\n}\n\n/**\n * Queues a message to the specified queue with tracing.\n */\nexport async function queueMessage(\n  world: World,\n  ...args: Parameters<typeof world.queue>\n) {\n  const queueName = args[0];\n  await trace(\n    'queue.publish',\n    {\n      // Standard OTEL messaging conventions\n      attributes: {\n        ...Attribute.MessagingSystem('vercel-queue'),\n        ...Attribute.MessagingDestinationName(queueName),\n        ...Attribute.MessagingOperationType('publish'),\n        // Peer service for Datadog service maps\n        ...Attribute.PeerService('vercel-queue'),\n        ...Attribute.RpcSystem('vercel-queue'),\n        ...Attribute.RpcService('vqs'),\n        ...Attribute.RpcMethod('publish'),\n      },\n      kind: await getSpanKind('PRODUCER'),\n    },\n    async (span) => {\n      const { messageId } = await world.queue(...args);\n      if (messageId) {\n        span?.setAttributes(Attribute.MessagingMessageId(messageId));\n      }\n    }\n  );\n}\n\n/**\n * Calculates the queue overhead time in milliseconds for a given message.\n */\nexport function getQueueOverhead(message: { requestedAt?: Date }) {\n  if (!message.requestedAt) return;\n  try {\n    return Attribute.QueueOverheadMs(\n      Date.now() - message.requestedAt.getTime()\n    );\n  } catch {\n    return;\n  }\n}\n\n/**\n * Returns a memoized accessor for the per-run AES-256 encryption key.\n *\n * The first call resolves the key via `world.getEncryptionKeyForRun` (which\n * may do HKDF derivation locally on Vercel, or a network fetch from\n * external contexts) and imports it as a `CryptoKey`; subsequent calls\n * await the same cached promise. If the world doesn't support encryption\n * or the run has no key configured, the cached value is `undefined`.\n *\n * Used by step / workflow handlers to defer the (potentially expensive)\n * key fetch until the first code path that actually needs it — typically\n * input hydration on the success path, or error dehydration on a failure\n * path. Both paths can race-call the accessor without triggering duplicate\n * fetches.\n *\n * Errors thrown by `getEncryptionKeyForRun` propagate to every caller\n * (the cached promise rejects). This is intentional: when encryption is\n * configured, we never want to silently fall back to plaintext\n * serialization. A propagated error in an event-emission path leaves the\n * outer try/catch to log and surface the issue; the queue's redelivery\n * semantics will retry the key fetch on the next attempt.\n */\nexport function memoizeEncryptionKey(\n  world: World,\n  runOrId: WorkflowRun | string\n): () => Promise<CryptoKey | undefined> {\n  let cached: Promise<CryptoKey | undefined> | undefined;\n  return () => {\n    if (!cached) {\n      cached = (async () => {\n        // The `getEncryptionKeyForRun` overload set takes either a\n        // `WorkflowRun` or a `runId: string` (with optional context). Branch\n        // here so TypeScript picks the right overload for each shape.\n        const rawKey =\n          typeof runOrId === 'string'\n            ? await world.getEncryptionKeyForRun?.(runOrId)\n            : await world.getEncryptionKeyForRun?.(runOrId);\n        return rawKey ? await importKey(rawKey) : undefined;\n      })();\n    }\n    return cached;\n  };\n}\n"]}

package/dist/runtime/replay-budget.d.ts

@@ -0,0 +1,98 @@
+/**
+ * Per-invocation accounting of the *non-step* portion of a workflow
+ * handler run: deterministic event-log replay, workflow-VM execution
+ * between step boundaries, suspension handling, queue round-trips, etc.
+ * Inline step bodies (`"use step"` functions invoked via `executeStep`)
+ * are intentionally excluded — they are bounded by the platform's
+ * function `maxDuration` and the `NO_INLINE_REPLAY_AFTER_MS` early-return
+ * guard.
+ *
+ * Usage:
+ *
+ * ```ts
+ * const budget = new ReplayBudget();
+ * // …non-step work happens here, accumulates against the budget…
+ * budget.pause();
+ * try {
+ *   await executeStep(...); // not charged
+ * } finally {
+ *   budget.resume();
+ * }
+ * // back to charging
+ * if (budget.isExhausted()) { ... }
+ * ```
+ *
+ * Implementation notes:
+ *
+ * - `pause()` and `resume()` are idempotent: calling `pause()` while
+ *   already paused (or `resume()` while already resumed) is a no-op.
+ *   This protects against double-counting in future refactors that nest
+ *   step execution or take an early-return path between a `pause()` and
+ *   the matching `resume()`.
+ * - `isExhausted()` is checked at loop boundaries by the caller — the
+ *   budget itself does not arm any timers. This means an in-flight
+ *   pathological `runWorkflow` call (e.g. a huge event-log replay) can
+ *   overshoot the budget by up to one iteration's worth of work before
+ *   the next check fires. In practice the 20s headroom built into
+ *   `MAX_REPLAY_TIMEOUT_MS` (and the function `maxDuration` ceiling)
+ *   gives us slack; the old `setTimeout`-based approach also ultimately
+ *   relied on the platform SIGTERM as the hard backstop.
+ */
+export declare class ReplayBudget {
+    private readonly limitMs;
+    private elapsedMs;
+    private intervalStart;
+    constructor(limitMs?: number);
+    /**
+     * The configured replay-timeout limit, in ms. Useful for log messages.
+     */
+    get configuredLimitMs(): number;
+    /**
+     * Total non-step time accumulated so far, in ms. Includes the
+     * currently-active interval if the budget is not paused.
+     */
+    elapsed(): number;
+    /**
+     * Stop counting elapsed time toward the budget. Idempotent — safe to
+     * call multiple times in a row; subsequent calls are no-ops until
+     * `resume()` reopens an interval.
+     */
+    pause(): void;
+    /**
+     * Resume counting elapsed time toward the budget. Idempotent — safe to
+     * call multiple times in a row; subsequent calls re-anchor the
+     * interval start to `now()`, which is fine because no time accrues
+     * between back-to-back `resume()` calls.
+     */
+    resume(): void;
+    /**
+     * True if the budget has been exhausted (`elapsed() >= limitMs`).
+     * Callers should invoke `handleExhausted(...)` afterward and return
+     * from the handler.
+     */
+    isExhausted(): boolean;
+}
+/**
+ * Fail the run (or retry, on early attempts) when the replay budget is
+ * exhausted. The handling depends on whether the underlying World
+ * supports `process.exit(1)` as a queue redelivery signal (see
+ * `World.processExitTriggersQueueRedelivery`):
+ *
+ * - **Managed-platform Worlds** (`world-vercel`): on attempts <=
+ *   `REPLAY_TIMEOUT_MAX_RETRIES` exit the process so the platform fails
+ *   the invocation and the queue redelivers; on the next attempt write
+ *   `run_failed` with `RUN_ERROR_CODES.REPLAY_TIMEOUT` and exit.
+ *
+ * - **In-process Worlds** (`world-local`, dev servers): calling
+ *   `process.exit()` would terminate the host (e.g. `pnpm dev`), so
+ *   instead log a warning, write `run_failed` best-effort, and return.
+ *   The framework completes the request normally.
+ */
+export declare function handleReplayBudgetExhausted(args: {
+    runId: string;
+    workflowName: string;
+    requestId: string | undefined;
+    attempt: number;
+    limitMs: number;
+}): Promise<void>;
+//# sourceMappingURL=replay-budget.d.ts.map

package/dist/runtime/replay-budget.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"replay-budget.d.ts","sourceRoot":"","sources":["../../src/runtime/replay-budget.ts"],"names":[],"mappings":"AASA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuCG;AACH,qBAAa,YAAY;IACvB,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAS;IACjC,OAAO,CAAC,SAAS,CAAK;IACtB,OAAO,CAAC,aAAa,CAAgB;gBAEzB,OAAO,GAAE,MAA6B;IAKlD;;OAEG;IACH,IAAI,iBAAiB,IAAI,MAAM,CAE9B;IAED;;;OAGG;IACH,OAAO,IAAI,MAAM;IAMjB;;;;OAIG;IACH,KAAK,IAAI,IAAI;IAMb;;;;;OAKG;IACH,MAAM,IAAI,IAAI;IAId;;;;OAIG;IACH,WAAW,IAAI,OAAO;CAGvB;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAsB,2BAA2B,CAAC,IAAI,EAAE;IACtD,KAAK,EAAE,MAAM,CAAC;IACd,YAAY,EAAE,MAAM,CAAC;IACrB,SAAS,EAAE,MAAM,GAAG,SAAS,CAAC;IAC9B,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;CACjB,GAAG,OAAO,CAAC,IAAI,CAAC,CAiHhB"}