@workflow/core 4.6.1 → 4.7.0

package/dist/runtime/helpers.d.ts

@@ -64,6 +64,63 @@ export declare function getWorkflowRunEvents(runId: string, cursor?: string): Pr
  * Events must be in chronological order (ascending) for proper workflow replay.
  */
 export declare function getAllWorkflowRunEvents(runId: string): Promise<Event[]>;
+/**
+ * Maximum number of times a replay-context event creation will reload the
+ * event log and retry after the backend rejects it as stale (412). After this
+ * many failed reloads the precondition error propagates so the run is
+ * re-invoked from the queue with a fresh replay.
+ */
+export declare const PRECONDITION_MAX_RELOAD_RETRIES = 2;
+/**
+ * A mutable view of the runtime's in-memory event log. `withPreconditionRetry`
+ * appends freshly-loaded events to `events` (in place) and advances `cursor`
+ * when it reloads, so the caller's loaded snapshot stays current.
+ */
+export interface MutableEventLog {
+    events: Event[];
+    cursor: string | null;
+}
+/**
+ * Whether the optimistic-concurrency guard for event creation is enabled.
+ * **On by default** where the runtime executes: replay-context creates send a
+ * `stateUpdatedAt` snapshot (and can be rejected with 412 by a supporting
+ * backend) unless `WORKFLOW_PRECONDITION_GUARD` is set to `0`. Backends without
+ * guard support ignore the snapshot, so enabling by default is
+ * backward-compatible.
+ */
+export declare function isPreconditionGuardEnabled(): boolean;
+/**
+ * The `stateUpdatedAt` value to send with a replay-context event creation: the
+ * ULID time (epoch ms) of the latest event the runtime has loaded. Events are
+ * stored in ascending order, so the last one is the newest. Returns `undefined`
+ * when there are no events or the latest id is not a decodable ULID.
+ *
+ * Granularity: snapshots are epoch-milliseconds, and the backend allows an
+ * equal-timestamp snapshot (an up-to-date client must not be rejected). Two
+ * out-of-band events landing in the same millisecond where only the first was
+ * loaded therefore pass the guard undetected — the guard is best-effort by
+ * design, and fails open rather than livelocking.
+ */
+export declare function latestEventStateUpdatedAt(events: Event[]): number | undefined;
+/**
+ * The `stateUpdatedAt` to attach to a replay-context event creation:
+ * the loaded snapshot's ULID time when the precondition guard is enabled,
+ * `undefined` (no guard, backend behaves as before) otherwise.
+ */
+export declare function stateUpdatedAtForCreate(events: Event[]): number | undefined;
+/**
+ * Runs a replay-context event creation with the optimistic-concurrency guard.
+ *
+ * `op` receives the current `stateUpdatedAt` (the ULID time of the latest
+ * loaded event) to pass to `world.events.create`. If the backend rejects the
+ * creation as stale (`PreconditionFailedError` / 412), the event log is
+ * reloaded to completion from the last cursor, merged into `log` in place, and
+ * `op` is retried with the now-newer snapshot — up to
+ * `PRECONDITION_MAX_RELOAD_RETRIES` times. If it still fails, the error is
+ * rethrown so the run falls back to a queue re-invocation. Non-precondition
+ * errors are rethrown immediately.
+ */
+export declare function withPreconditionRetry<T>(runId: string, log: MutableEventLog, op: (stateUpdatedAt: number | undefined) => Promise<T>): Promise<T>;
 /**
  * Wraps a request/response handler and adds a health check "mode"
  * based on the presence of a `__health` query parameter.

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

@@ -1 +1 @@
-{"version":3,"file":"helpers.d.ts","sourceRoot":"","sources":["../../src/runtime/helpers.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EACV,KAAK,EACL,kBAAkB,EAClB,cAAc,EACd,KAAK,EACN,MAAM,iBAAiB,CAAC;AA0BzB;;;;GAIG;AACH,wBAAgB,oBAAoB,CAClC,YAAY,EAAE,MAAM,EACpB,SAAS,CAAC,EAAE,MAAM,GACjB,cAAc,CAWhB;AAWD;;GAEG;AACH,MAAM,WAAW,iBAAiB;IAChC,OAAO,EAAE,OAAO,CAAC;IACjB,2CAA2C;IAC3C,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,iDAAiD;IACjD,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,gDAAgD;IAChD,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB;;;;;;OAMG;IACH,mBAAmB,CAAC,EAAE,MAAM,CAAC;CAC9B;AAED;;;GAGG;AACH,wBAAgB,uBAAuB,CACrC,OAAO,EAAE,OAAO,GACf,kBAAkB,GAAG,SAAS,CAMhC;AAWD;;;;;;GAMG;AACH,wBAAsB,wBAAwB,CAC5C,WAAW,EAAE,kBAAkB,EAC/B,QAAQ,EAAE,UAAU,GAAG,MAAM,EAC7B,gBAAgB,CAAC,EAAE,MAAM,GACxB,OAAO,CAAC,IAAI,CAAC,CAiBf;AAED,MAAM,MAAM,mBAAmB,GAAG,UAAU,GAAG,MAAM,CAAC;AAEtD,MAAM,WAAW,kBAAkB;IACjC,sFAAsF;IACtF,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,iGAAiG;IACjG,YAAY,CAAC,EAAE,MAAM,CAAC;CACvB;AA6LD,wBAAsB,WAAW,CAC/B,KAAK,EAAE,KAAK,EACZ,QAAQ,EAAE,mBAAmB,EAC7B,OAAO,CAAC,EAAE,kBAAkB,GAAG;IAAE,SAAS,CAAC,EAAE,MAAM,CAAA;CAAE,GACpD,OAAO,CAAC,iBAAiB,CAAC,CAyD5B;AAED,MAAM,WAAW,uBAAuB;IACtC,MAAM,EAAE,KAAK,EAAE,CAAC;IAChB,MAAM,EAAE,MAAM,GAAG,IAAI,CAAC;CACvB;AA0DD;;;;GAIG;AACH,wBAAsB,oBAAoB,CACxC,KAAK,EAAE,MAAM,EACb,MAAM,CAAC,EAAE,MAAM,GACd,OAAO,CAAC,uBAAuB,CAAC,CAoGlC;AAED;;;;GAIG;AACH,wBAAsB,uBAAuB,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,KAAK,EAAE,CAAC,CAG7E;AAYD;;;GAGG;AACH,wBAAgB,eAAe,CAC7B,OAAO,EAAE,CAAC,GAAG,EAAE,OAAO,KAAK,OAAO,CAAC,QAAQ,CAAC,EAC5C,gBAAgB,CAAC,EAAE,MAAM,GACxB,CAAC,GAAG,EAAE,OAAO,KAAK,OAAO,CAAC,QAAQ,CAAC,CAoCrC;AAED;;GAEG;AACH,wBAAsB,YAAY,CAChC,KAAK,EAAE,KAAK,EACZ,GAAG,IAAI,EAAE,UAAU,CAAC,OAAO,KAAK,CAAC,KAAK,CAAC,iBA0BxC;AAED;;GAEG;AACH,wBAAgB,gBAAgB,CAAC,OAAO,EAAE;IAAE,WAAW,CAAC,EAAE,IAAI,CAAA;CAAE;;cAS/D"}
+{"version":3,"file":"helpers.d.ts","sourceRoot":"","sources":["../../src/runtime/helpers.ts"],"names":[],"mappings":"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"}

package/dist/runtime/helpers.js

@@ -1,5 +1,5 @@
-import { RUN_ERROR_CODES, WorkflowWorldError } from '@workflow/errors';
-import { getQueueTopicPrefix, HealthCheckPayloadSchema, resolveQueueNamespace, SPEC_VERSION_CURRENT, SPEC_VERSION_LEGACY, } from '@workflow/world';
+import { PreconditionFailedError, RUN_ERROR_CODES, WorkflowWorldError, } from '@workflow/errors';
+import { getQueueTopicPrefix, HealthCheckPayloadSchema, resolveQueueNamespace, SPEC_VERSION_CURRENT, SPEC_VERSION_LEGACY, ulidToDate, } from '@workflow/world';
 import { monotonicFactory } from 'ulid';
 import { runtimeLogger } from '../logger.js';
 import * as Attribute from '../telemetry/semantic-conventions.js';
@@ -374,6 +374,105 @@ export async function getAllWorkflowRunEvents(runId) {
     const { events } = await getWorkflowRunEvents(runId);
     return events;
 }
+/**
+ * Maximum number of times a replay-context event creation will reload the
+ * event log and retry after the backend rejects it as stale (412). After this
+ * many failed reloads the precondition error propagates so the run is
+ * re-invoked from the queue with a fresh replay.
+ */
+export const PRECONDITION_MAX_RELOAD_RETRIES = 2;
+/**
+ * Whether the optimistic-concurrency guard for event creation is enabled.
+ * **On by default** where the runtime executes: replay-context creates send a
+ * `stateUpdatedAt` snapshot (and can be rejected with 412 by a supporting
+ * backend) unless `WORKFLOW_PRECONDITION_GUARD` is set to `0`. Backends without
+ * guard support ignore the snapshot, so enabling by default is
+ * backward-compatible.
+ */
+export function isPreconditionGuardEnabled() {
+    return process.env.WORKFLOW_PRECONDITION_GUARD !== '0';
+}
+/**
+ * The `stateUpdatedAt` value to send with a replay-context event creation: the
+ * ULID time (epoch ms) of the latest event the runtime has loaded. Events are
+ * stored in ascending order, so the last one is the newest. Returns `undefined`
+ * when there are no events or the latest id is not a decodable ULID.
+ *
+ * Granularity: snapshots are epoch-milliseconds, and the backend allows an
+ * equal-timestamp snapshot (an up-to-date client must not be rejected). Two
+ * out-of-band events landing in the same millisecond where only the first was
+ * loaded therefore pass the guard undetected — the guard is best-effort by
+ * design, and fails open rather than livelocking.
+ */
+export function latestEventStateUpdatedAt(events) {
+    const last = events[events.length - 1];
+    if (!last) {
+        return undefined;
+    }
+    // Event IDs are prefixed ULIDs (e.g. `evnt_01ARYZ...`); ulidToDate only
+    // decodes the bare 26-char ULID, so strip the prefix first.
+    const eventId = last.eventId;
+    const underscore = eventId.lastIndexOf('_');
+    const rawUlid = underscore === -1 ? eventId : eventId.slice(underscore + 1);
+    const time = ulidToDate(rawUlid)?.getTime();
+    if (time === undefined) {
+        // Fail open: a non-decodable id disarms the guard for this create (no
+        // snapshot sent). Log so a fleet-wide silent disarm is diagnosable.
+        runtimeLogger.debug('Precondition guard: latest event id is not a decodable ULID; sending no snapshot', { eventId });
+        return undefined;
+    }
+    return time;
+}
+/**
+ * The `stateUpdatedAt` to attach to a replay-context event creation:
+ * the loaded snapshot's ULID time when the precondition guard is enabled,
+ * `undefined` (no guard, backend behaves as before) otherwise.
+ */
+export function stateUpdatedAtForCreate(events) {
+    return isPreconditionGuardEnabled()
+        ? latestEventStateUpdatedAt(events)
+        : undefined;
+}
+/**
+ * Runs a replay-context event creation with the optimistic-concurrency guard.
+ *
+ * `op` receives the current `stateUpdatedAt` (the ULID time of the latest
+ * loaded event) to pass to `world.events.create`. If the backend rejects the
+ * creation as stale (`PreconditionFailedError` / 412), the event log is
+ * reloaded to completion from the last cursor, merged into `log` in place, and
+ * `op` is retried with the now-newer snapshot — up to
+ * `PRECONDITION_MAX_RELOAD_RETRIES` times. If it still fails, the error is
+ * rethrown so the run falls back to a queue re-invocation. Non-precondition
+ * errors are rethrown immediately.
+ */
+export async function withPreconditionRetry(runId, log, op) {
+    for (let attempt = 0;; attempt++) {
+        try {
+            return await op(stateUpdatedAtForCreate(log.events));
+        }
+        catch (error) {
+            if (!PreconditionFailedError.is(error) ||
+                attempt >= PRECONDITION_MAX_RELOAD_RETRIES) {
+                throw error;
+            }
+            runtimeLogger.info('Event creation rejected as stale; reloading event log and retrying', {
+                workflowRunId: runId,
+                attempt: attempt + 1,
+                maxRetries: PRECONDITION_MAX_RELOAD_RETRIES,
+            });
+            const loaded = await getWorkflowRunEvents(runId, log.cursor ?? undefined);
+            appendUniqueEvents(log.events, new Set(log.events.map((e) => e.eventId)), loaded.events);
+            // When several creates share one `log` (e.g. hook creations under
+            // `Promise.all` in `handleSuspension`), concurrent 412s can reload
+            // concurrently. The event merge above is safe — `appendUniqueEvents`
+            // builds its dedup set synchronously right before appending — but this
+            // cursor write is last-write-wins, so an interleaved older reload can
+            // briefly regress the cursor. The only consequence is refetching a few
+            // already-deduped events on a later load; correctness is unaffected.
+            log.cursor = loaded.cursor ?? log.cursor;
+        }
+    }
+}
 /**
  * CORS headers for health check responses.
  * Allows the observability UI to check endpoint health from a different origin.
@@ -459,4 +558,4 @@ 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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","sourcesContent":["import { RUN_ERROR_CODES, WorkflowWorldError } from '@workflow/errors';\nimport type {\n  Event,\n  HealthCheckPayload,\n  ValidQueueName,\n  World,\n} from '@workflow/world';\nimport {\n  getQueueTopicPrefix,\n  HealthCheckPayloadSchema,\n  resolveQueueNamespace,\n  SPEC_VERSION_CURRENT,\n  SPEC_VERSION_LEGACY,\n} from '@workflow/world';\nimport { monotonicFactory } from 'ulid';\n\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 { getWorld } from './world.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(\n  workflowName: string,\n  namespace?: string\n): 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  const prefix = getQueueTopicPrefix(\n    'workflow',\n    resolveQueueNamespace(namespace)\n  );\n  return `${prefix}${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   * `@workflow/core` version of the responding deployment, used for\n   * capability detection (see `getRunCapabilities`). Omitted when the\n   * responding deployment did not provide the field as a string —\n   * for example, an older `@workflow/core` that predates this field,\n   * or a non-JSON plain-text health response.\n   */\n  workflowCoreVersion?: string;\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 fake runId for health check streams.\n * This runId passes server validation but is not associated with a real run.\n * The server skips run validation for streams starting with `__health_check__`.\n */\nfunction generateHealthCheckRunId(): string {\n  return `wrun_${generateId()}`;\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 = getWorld();\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 fake runId that passes validation.\n  // The stream name includes the correlationId for identification.\n  // The server skips run validation for health check streams.\n  const fakeRunId = generateHealthCheckRunId();\n  await world.writeToStream(streamName, fakeRunId, response);\n  await world.closeStream(streamName, fakeRunId);\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\nclass HealthCheckTimeoutError extends Error {\n  constructor(timeout: number) {\n    super(`Health check timed out after ${timeout}ms`);\n  }\n}\n\nfunction getHealthCheckTimeRemaining(startTime: number, timeout: number) {\n  return timeout - (Date.now() - startTime);\n}\n\nasync function withHealthCheckTimeout<T>(\n  promise: Promise<T>,\n  startTime: number,\n  timeout: number\n): Promise<T> {\n  const remaining = getHealthCheckTimeRemaining(startTime, timeout);\n  if (remaining <= 0) {\n    throw new HealthCheckTimeoutError(timeout);\n  }\n\n  let timeoutId: ReturnType<typeof setTimeout> | undefined;\n  try {\n    return await Promise.race([\n      promise,\n      new Promise<never>((_, reject) => {\n        timeoutId = setTimeout(\n          () => reject(new HealthCheckTimeoutError(timeout)),\n          remaining\n        );\n      }),\n    ]);\n  } finally {\n    if (timeoutId) {\n      clearTimeout(timeoutId);\n    }\n  }\n}\n\nfunction wait(ms: number) {\n  return new Promise((resolve) => setTimeout(resolve, ms));\n}\n\nasync function waitForNextHealthCheckPoll(startTime: number, timeout: number) {\n  const remaining = getHealthCheckTimeRemaining(startTime, timeout);\n  if (remaining <= 0) {\n    return;\n  }\n  await wait(Math.min(HEALTH_CHECK_POLL_INTERVAL, remaining));\n}\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(chunks: Uint8Array[]): {\n  healthy: boolean;\n  specVersion?: number;\n  workflowCoreVersion?: string;\n} | 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: {\n    healthy: boolean;\n    specVersion?: number;\n    workflowCoreVersion?: string;\n  } = {\n    healthy: r.healthy as boolean,\n  };\n  if (typeof r.specVersion === 'number') {\n    parsed.specVersion = r.specVersion;\n  }\n  if (typeof r.workflowCoreVersion === 'string') {\n    parsed.workflowCoreVersion = r.workflowCoreVersion;\n  }\n  return parsed;\n}\n\nasync function readHealthCheckResponse(\n  world: World,\n  streamName: string,\n  startTime: number,\n  timeout: number\n): Promise<{\n  healthy: boolean;\n  specVersion?: number;\n  workflowCoreVersion?: string;\n} | null> {\n  const stream = await withHealthCheckTimeout(\n    world.readFromStream(streamName),\n    startTime,\n    timeout\n  );\n  const reader = stream.getReader();\n  const readTimeout = Math.min(\n    HEALTH_CHECK_READ_TIMEOUT,\n    Math.max(1, getHealthCheckTimeRemaining(startTime, timeout))\n  );\n  const { chunks, timedOut } = await readStreamWithTimeout(reader, readTimeout);\n\n  if (timedOut) {\n    await reader.cancel().catch(() => {});\n    return null;\n  }\n\n  return parseHealthCheckResponse(chunks);\n}\n\nexport async function healthCheck(\n  world: World,\n  endpoint: HealthCheckEndpoint,\n  options?: HealthCheckOptions & { namespace?: string }\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 =\n    `${getQueueTopicPrefix(endpoint, resolveQueueNamespace(options?.namespace))}health_check` as ValidQueueName;\n\n  const startTime = Date.now();\n\n  try {\n    await withHealthCheckTimeout(\n      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      startTime,\n      timeout\n    );\n\n    while (getHealthCheckTimeRemaining(startTime, timeout) > 0) {\n      try {\n        const response = await readHealthCheckResponse(\n          world,\n          streamName,\n          startTime,\n          timeout\n        );\n        if (response) {\n          return {\n            ...response,\n            latencyMs: Date.now() - startTime,\n          };\n        }\n      } catch (error) {\n        if (error instanceof HealthCheckTimeoutError) {\n          throw error;\n        }\n      }\n      await waitForNextHealthCheckPoll(startTime, timeout);\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\nexport interface LoadedWorkflowRunEvents {\n  events: Event[];\n  cursor: string | null;\n}\n\nfunction eventPaginationContractError(\n  runId: string,\n  message: string\n): WorkflowWorldError {\n  return new WorkflowWorldError(\n    `Event pagination ${message} for workflow run \"${runId}\".`,\n    { code: RUN_ERROR_CODES.WORLD_CONTRACT_ERROR }\n  );\n}\n\nfunction appendUniqueEvents(\n  target: Event[],\n  targetIds: Set<string>,\n  events: Event[]\n): void {\n  for (const event of events) {\n    if (!targetIds.has(event.eventId)) {\n      targetIds.add(event.eventId);\n      target.push(event);\n    }\n  }\n}\n\nfunction assertEventPaginationProgress(\n  runId: string,\n  hasMore: boolean,\n  cursor: string | null,\n  requestedCursors: Set<string>\n): void {\n  if (!hasMore) {\n    return;\n  }\n  if (cursor === null) {\n    throw eventPaginationContractError(\n      runId,\n      'returned more pages without a cursor'\n    );\n  }\n  if (requestedCursors.has(cursor)) {\n    throw eventPaginationContractError(runId, 'repeated a cursor');\n  }\n}\n\nfunction shouldRetryWithoutEventCursor(\n  error: unknown,\n  cursor: string | null,\n  alreadyRetried: boolean\n): boolean {\n  return (\n    cursor !== null &&\n    !alreadyRetried &&\n    WorkflowWorldError.is(error) &&\n    error.status === 400\n  );\n}\n\n/**\n * Loads workflow run events by iterating through all pages of paginated results.\n * When a cursor is provided, only events after that cursor are loaded.\n * Events must be in chronological order (ascending) for proper workflow replay.\n */\nexport async function getWorkflowRunEvents(\n  runId: string,\n  cursor?: string\n): Promise<LoadedWorkflowRunEvents> {\n  return trace('workflow.loadEvents', async (span) => {\n    span?.setAttributes({\n      ...Attribute.WorkflowRunId(runId),\n    });\n\n    const allEvents: Event[] = [];\n    const loadedEventIds = new Set<string>();\n    const requestedCursors = new Set<string>();\n    let nextCursor: string | null = cursor ?? null;\n    let hasMore = true;\n    let pagesLoaded = 0;\n    let retriedWithoutCursor = false;\n\n    const world = getWorld();\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 requestedCursor = nextCursor;\n      if (requestedCursor) {\n        requestedCursors.add(requestedCursor);\n      }\n\n      let response: Awaited<ReturnType<typeof world.events.list>>;\n      try {\n        response = await world.events.list({\n          runId,\n          pagination: {\n            sortOrder: 'asc', // Required: events must be in chronological order for replay\n            cursor: requestedCursor ?? undefined,\n          },\n        });\n      } catch (error) {\n        if (\n          shouldRetryWithoutEventCursor(\n            error,\n            requestedCursor,\n            retriedWithoutCursor\n          )\n        ) {\n          runtimeLogger.warn(\n            'Event cursor was rejected; retrying with a full event reload.',\n            { workflowRunId: runId }\n          );\n          allEvents.length = 0;\n          loadedEventIds.clear();\n          requestedCursors.clear();\n          nextCursor = null;\n          retriedWithoutCursor = true;\n          continue;\n        }\n        throw error;\n      }\n\n      appendUniqueEvents(allEvents, loadedEventIds, response.data);\n      hasMore = response.hasMore;\n      assertEventPaginationProgress(\n        runId,\n        hasMore,\n        response.cursor,\n        requestedCursors\n      );\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 DynamoDB query hit `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      nextCursor = response.cursor ?? nextCursor;\n      pagesLoaded++;\n\n      runtimeLogger.debug('Loaded event page', {\n        workflowRunId: runId,\n        page: pagesLoaded,\n        pageEvents: response.data.length,\n        totalEvents: allEvents.length,\n        hasMore,\n        pageMs: Date.now() - pageStart,\n      });\n    }\n\n    runtimeLogger.debug('Event loading complete', {\n      workflowRunId: runId,\n      totalEvents: allEvents.length,\n      pagesLoaded,\n      totalMs: Date.now() - loadStart,\n    });\n\n    span?.setAttributes({\n      ...Attribute.WorkflowEventsCount(allEvents.length),\n      ...Attribute.WorkflowEventsPagesLoaded(pagesLoaded),\n    });\n\n    return { events: allEvents, cursor: nextCursor };\n  });\n}\n\n/**\n * Loads all workflow run events by iterating through all pages of paginated results.\n * This ensures that *all* events are loaded into memory before running the workflow.\n * Events must be in chronological order (ascending) for proper workflow replay.\n */\nexport async function getAllWorkflowRunEvents(runId: string): Promise<Event[]> {\n  const { events } = await getWorkflowRunEvents(runId);\n  return events;\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      if (req.method === 'HEAD') {\n        return new Response(null, {\n          status: 200,\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"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"helpers.js","sourceRoot":"","sources":["../../src/runtime/helpers.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  PreconditionFailedError,\n  RUN_ERROR_CODES,\n  WorkflowWorldError,\n} from '@workflow/errors';\nimport type {\n  Event,\n  HealthCheckPayload,\n  ValidQueueName,\n  World,\n} from '@workflow/world';\nimport {\n  getQueueTopicPrefix,\n  HealthCheckPayloadSchema,\n  resolveQueueNamespace,\n  SPEC_VERSION_CURRENT,\n  SPEC_VERSION_LEGACY,\n  ulidToDate,\n} from '@workflow/world';\nimport { monotonicFactory } from 'ulid';\n\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 { getWorld } from './world.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(\n  workflowName: string,\n  namespace?: string\n): 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  const prefix = getQueueTopicPrefix(\n    'workflow',\n    resolveQueueNamespace(namespace)\n  );\n  return `${prefix}${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   * `@workflow/core` version of the responding deployment, used for\n   * capability detection (see `getRunCapabilities`). Omitted when the\n   * responding deployment did not provide the field as a string —\n   * for example, an older `@workflow/core` that predates this field,\n   * or a non-JSON plain-text health response.\n   */\n  workflowCoreVersion?: string;\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 fake runId for health check streams.\n * This runId passes server validation but is not associated with a real run.\n * The server skips run validation for streams starting with `__health_check__`.\n */\nfunction generateHealthCheckRunId(): string {\n  return `wrun_${generateId()}`;\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 = getWorld();\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 fake runId that passes validation.\n  // The stream name includes the correlationId for identification.\n  // The server skips run validation for health check streams.\n  const fakeRunId = generateHealthCheckRunId();\n  await world.writeToStream(streamName, fakeRunId, response);\n  await world.closeStream(streamName, fakeRunId);\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\nclass HealthCheckTimeoutError extends Error {\n  constructor(timeout: number) {\n    super(`Health check timed out after ${timeout}ms`);\n  }\n}\n\nfunction getHealthCheckTimeRemaining(startTime: number, timeout: number) {\n  return timeout - (Date.now() - startTime);\n}\n\nasync function withHealthCheckTimeout<T>(\n  promise: Promise<T>,\n  startTime: number,\n  timeout: number\n): Promise<T> {\n  const remaining = getHealthCheckTimeRemaining(startTime, timeout);\n  if (remaining <= 0) {\n    throw new HealthCheckTimeoutError(timeout);\n  }\n\n  let timeoutId: ReturnType<typeof setTimeout> | undefined;\n  try {\n    return await Promise.race([\n      promise,\n      new Promise<never>((_, reject) => {\n        timeoutId = setTimeout(\n          () => reject(new HealthCheckTimeoutError(timeout)),\n          remaining\n        );\n      }),\n    ]);\n  } finally {\n    if (timeoutId) {\n      clearTimeout(timeoutId);\n    }\n  }\n}\n\nfunction wait(ms: number) {\n  return new Promise((resolve) => setTimeout(resolve, ms));\n}\n\nasync function waitForNextHealthCheckPoll(startTime: number, timeout: number) {\n  const remaining = getHealthCheckTimeRemaining(startTime, timeout);\n  if (remaining <= 0) {\n    return;\n  }\n  await wait(Math.min(HEALTH_CHECK_POLL_INTERVAL, remaining));\n}\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(chunks: Uint8Array[]): {\n  healthy: boolean;\n  specVersion?: number;\n  workflowCoreVersion?: string;\n} | 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: {\n    healthy: boolean;\n    specVersion?: number;\n    workflowCoreVersion?: string;\n  } = {\n    healthy: r.healthy as boolean,\n  };\n  if (typeof r.specVersion === 'number') {\n    parsed.specVersion = r.specVersion;\n  }\n  if (typeof r.workflowCoreVersion === 'string') {\n    parsed.workflowCoreVersion = r.workflowCoreVersion;\n  }\n  return parsed;\n}\n\nasync function readHealthCheckResponse(\n  world: World,\n  streamName: string,\n  startTime: number,\n  timeout: number\n): Promise<{\n  healthy: boolean;\n  specVersion?: number;\n  workflowCoreVersion?: string;\n} | null> {\n  const stream = await withHealthCheckTimeout(\n    world.readFromStream(streamName),\n    startTime,\n    timeout\n  );\n  const reader = stream.getReader();\n  const readTimeout = Math.min(\n    HEALTH_CHECK_READ_TIMEOUT,\n    Math.max(1, getHealthCheckTimeRemaining(startTime, timeout))\n  );\n  const { chunks, timedOut } = await readStreamWithTimeout(reader, readTimeout);\n\n  if (timedOut) {\n    await reader.cancel().catch(() => {});\n    return null;\n  }\n\n  return parseHealthCheckResponse(chunks);\n}\n\nexport async function healthCheck(\n  world: World,\n  endpoint: HealthCheckEndpoint,\n  options?: HealthCheckOptions & { namespace?: string }\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 =\n    `${getQueueTopicPrefix(endpoint, resolveQueueNamespace(options?.namespace))}health_check` as ValidQueueName;\n\n  const startTime = Date.now();\n\n  try {\n    await withHealthCheckTimeout(\n      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      startTime,\n      timeout\n    );\n\n    while (getHealthCheckTimeRemaining(startTime, timeout) > 0) {\n      try {\n        const response = await readHealthCheckResponse(\n          world,\n          streamName,\n          startTime,\n          timeout\n        );\n        if (response) {\n          return {\n            ...response,\n            latencyMs: Date.now() - startTime,\n          };\n        }\n      } catch (error) {\n        if (error instanceof HealthCheckTimeoutError) {\n          throw error;\n        }\n      }\n      await waitForNextHealthCheckPoll(startTime, timeout);\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\nexport interface LoadedWorkflowRunEvents {\n  events: Event[];\n  cursor: string | null;\n}\n\nfunction eventPaginationContractError(\n  runId: string,\n  message: string\n): WorkflowWorldError {\n  return new WorkflowWorldError(\n    `Event pagination ${message} for workflow run \"${runId}\".`,\n    { code: RUN_ERROR_CODES.WORLD_CONTRACT_ERROR }\n  );\n}\n\nfunction appendUniqueEvents(\n  target: Event[],\n  targetIds: Set<string>,\n  events: Event[]\n): void {\n  for (const event of events) {\n    if (!targetIds.has(event.eventId)) {\n      targetIds.add(event.eventId);\n      target.push(event);\n    }\n  }\n}\n\nfunction assertEventPaginationProgress(\n  runId: string,\n  hasMore: boolean,\n  cursor: string | null,\n  requestedCursors: Set<string>\n): void {\n  if (!hasMore) {\n    return;\n  }\n  if (cursor === null) {\n    throw eventPaginationContractError(\n      runId,\n      'returned more pages without a cursor'\n    );\n  }\n  if (requestedCursors.has(cursor)) {\n    throw eventPaginationContractError(runId, 'repeated a cursor');\n  }\n}\n\nfunction shouldRetryWithoutEventCursor(\n  error: unknown,\n  cursor: string | null,\n  alreadyRetried: boolean\n): boolean {\n  return (\n    cursor !== null &&\n    !alreadyRetried &&\n    WorkflowWorldError.is(error) &&\n    error.status === 400\n  );\n}\n\n/**\n * Loads workflow run events by iterating through all pages of paginated results.\n * When a cursor is provided, only events after that cursor are loaded.\n * Events must be in chronological order (ascending) for proper workflow replay.\n */\nexport async function getWorkflowRunEvents(\n  runId: string,\n  cursor?: string\n): Promise<LoadedWorkflowRunEvents> {\n  return trace('workflow.loadEvents', async (span) => {\n    span?.setAttributes({\n      ...Attribute.WorkflowRunId(runId),\n    });\n\n    const allEvents: Event[] = [];\n    const loadedEventIds = new Set<string>();\n    const requestedCursors = new Set<string>();\n    let nextCursor: string | null = cursor ?? null;\n    let hasMore = true;\n    let pagesLoaded = 0;\n    let retriedWithoutCursor = false;\n\n    const world = getWorld();\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 requestedCursor = nextCursor;\n      if (requestedCursor) {\n        requestedCursors.add(requestedCursor);\n      }\n\n      let response: Awaited<ReturnType<typeof world.events.list>>;\n      try {\n        response = await world.events.list({\n          runId,\n          pagination: {\n            sortOrder: 'asc', // Required: events must be in chronological order for replay\n            cursor: requestedCursor ?? undefined,\n          },\n        });\n      } catch (error) {\n        if (\n          shouldRetryWithoutEventCursor(\n            error,\n            requestedCursor,\n            retriedWithoutCursor\n          )\n        ) {\n          runtimeLogger.warn(\n            'Event cursor was rejected; retrying with a full event reload.',\n            { workflowRunId: runId }\n          );\n          allEvents.length = 0;\n          loadedEventIds.clear();\n          requestedCursors.clear();\n          nextCursor = null;\n          retriedWithoutCursor = true;\n          continue;\n        }\n        throw error;\n      }\n\n      appendUniqueEvents(allEvents, loadedEventIds, response.data);\n      hasMore = response.hasMore;\n      assertEventPaginationProgress(\n        runId,\n        hasMore,\n        response.cursor,\n        requestedCursors\n      );\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 DynamoDB query hit `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      nextCursor = response.cursor ?? nextCursor;\n      pagesLoaded++;\n\n      runtimeLogger.debug('Loaded event page', {\n        workflowRunId: runId,\n        page: pagesLoaded,\n        pageEvents: response.data.length,\n        totalEvents: allEvents.length,\n        hasMore,\n        pageMs: Date.now() - pageStart,\n      });\n    }\n\n    runtimeLogger.debug('Event loading complete', {\n      workflowRunId: runId,\n      totalEvents: allEvents.length,\n      pagesLoaded,\n      totalMs: Date.now() - loadStart,\n    });\n\n    span?.setAttributes({\n      ...Attribute.WorkflowEventsCount(allEvents.length),\n      ...Attribute.WorkflowEventsPagesLoaded(pagesLoaded),\n    });\n\n    return { events: allEvents, cursor: nextCursor };\n  });\n}\n\n/**\n * Loads all workflow run events by iterating through all pages of paginated results.\n * This ensures that *all* events are loaded into memory before running the workflow.\n * Events must be in chronological order (ascending) for proper workflow replay.\n */\nexport async function getAllWorkflowRunEvents(runId: string): Promise<Event[]> {\n  const { events } = await getWorkflowRunEvents(runId);\n  return events;\n}\n\n/**\n * Maximum number of times a replay-context event creation will reload the\n * event log and retry after the backend rejects it as stale (412). After this\n * many failed reloads the precondition error propagates so the run is\n * re-invoked from the queue with a fresh replay.\n */\nexport const PRECONDITION_MAX_RELOAD_RETRIES = 2;\n\n/**\n * A mutable view of the runtime's in-memory event log. `withPreconditionRetry`\n * appends freshly-loaded events to `events` (in place) and advances `cursor`\n * when it reloads, so the caller's loaded snapshot stays current.\n */\nexport interface MutableEventLog {\n  events: Event[];\n  cursor: string | null;\n}\n\n/**\n * Whether the optimistic-concurrency guard for event creation is enabled.\n * **On by default** where the runtime executes: replay-context creates send a\n * `stateUpdatedAt` snapshot (and can be rejected with 412 by a supporting\n * backend) unless `WORKFLOW_PRECONDITION_GUARD` is set to `0`. Backends without\n * guard support ignore the snapshot, so enabling by default is\n * backward-compatible.\n */\nexport function isPreconditionGuardEnabled(): boolean {\n  return process.env.WORKFLOW_PRECONDITION_GUARD !== '0';\n}\n\n/**\n * The `stateUpdatedAt` value to send with a replay-context event creation: the\n * ULID time (epoch ms) of the latest event the runtime has loaded. Events are\n * stored in ascending order, so the last one is the newest. Returns `undefined`\n * when there are no events or the latest id is not a decodable ULID.\n *\n * Granularity: snapshots are epoch-milliseconds, and the backend allows an\n * equal-timestamp snapshot (an up-to-date client must not be rejected). Two\n * out-of-band events landing in the same millisecond where only the first was\n * loaded therefore pass the guard undetected — the guard is best-effort by\n * design, and fails open rather than livelocking.\n */\nexport function latestEventStateUpdatedAt(events: Event[]): number | undefined {\n  const last = events[events.length - 1];\n  if (!last) {\n    return undefined;\n  }\n  // Event IDs are prefixed ULIDs (e.g. `evnt_01ARYZ...`); ulidToDate only\n  // decodes the bare 26-char ULID, so strip the prefix first.\n  const eventId = last.eventId;\n  const underscore = eventId.lastIndexOf('_');\n  const rawUlid = underscore === -1 ? eventId : eventId.slice(underscore + 1);\n  const time = ulidToDate(rawUlid)?.getTime();\n  if (time === undefined) {\n    // Fail open: a non-decodable id disarms the guard for this create (no\n    // snapshot sent). Log so a fleet-wide silent disarm is diagnosable.\n    runtimeLogger.debug(\n      'Precondition guard: latest event id is not a decodable ULID; sending no snapshot',\n      { eventId }\n    );\n    return undefined;\n  }\n  return time;\n}\n\n/**\n * The `stateUpdatedAt` to attach to a replay-context event creation:\n * the loaded snapshot's ULID time when the precondition guard is enabled,\n * `undefined` (no guard, backend behaves as before) otherwise.\n */\nexport function stateUpdatedAtForCreate(events: Event[]): number | undefined {\n  return isPreconditionGuardEnabled()\n    ? latestEventStateUpdatedAt(events)\n    : undefined;\n}\n\n/**\n * Runs a replay-context event creation with the optimistic-concurrency guard.\n *\n * `op` receives the current `stateUpdatedAt` (the ULID time of the latest\n * loaded event) to pass to `world.events.create`. If the backend rejects the\n * creation as stale (`PreconditionFailedError` / 412), the event log is\n * reloaded to completion from the last cursor, merged into `log` in place, and\n * `op` is retried with the now-newer snapshot — up to\n * `PRECONDITION_MAX_RELOAD_RETRIES` times. If it still fails, the error is\n * rethrown so the run falls back to a queue re-invocation. Non-precondition\n * errors are rethrown immediately.\n */\nexport async function withPreconditionRetry<T>(\n  runId: string,\n  log: MutableEventLog,\n  op: (stateUpdatedAt: number | undefined) => Promise<T>\n): Promise<T> {\n  for (let attempt = 0; ; attempt++) {\n    try {\n      return await op(stateUpdatedAtForCreate(log.events));\n    } catch (error) {\n      if (\n        !PreconditionFailedError.is(error) ||\n        attempt >= PRECONDITION_MAX_RELOAD_RETRIES\n      ) {\n        throw error;\n      }\n      runtimeLogger.info(\n        'Event creation rejected as stale; reloading event log and retrying',\n        {\n          workflowRunId: runId,\n          attempt: attempt + 1,\n          maxRetries: PRECONDITION_MAX_RELOAD_RETRIES,\n        }\n      );\n      const loaded = await getWorkflowRunEvents(runId, log.cursor ?? undefined);\n      appendUniqueEvents(\n        log.events,\n        new Set(log.events.map((e) => e.eventId)),\n        loaded.events\n      );\n      // When several creates share one `log` (e.g. hook creations under\n      // `Promise.all` in `handleSuspension`), concurrent 412s can reload\n      // concurrently. The event merge above is safe — `appendUniqueEvents`\n      // builds its dedup set synchronously right before appending — but this\n      // cursor write is last-write-wins, so an interleaved older reload can\n      // briefly regress the cursor. The only consequence is refetching a few\n      // already-deduped events on a later load; correctness is unaffected.\n      log.cursor = loaded.cursor ?? log.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      if (req.method === 'HEAD') {\n        return new Response(null, {\n          status: 200,\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"]}

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

@@ -1,12 +1,21 @@
 import type { Span } from '@opentelemetry/api';
 import { type WorkflowRun, type World } from '@workflow/world';
 import type { WorkflowSuspension } from '../global.js';
+import { type MutableEventLog } from './helpers.js';
 export interface SuspensionHandlerParams {
     suspension: WorkflowSuspension;
     world: World;
     run: WorkflowRun;
     span?: Span;
     requestId?: string;
+    /**
+     * The runtime's loaded event log. Each event creation is sent with this
+     * snapshot's `stateUpdatedAt` and, if the backend rejects it as stale (412),
+     * the log is reloaded in place and the create is retried — see
+     * `withPreconditionRetry`. Guarding per-create (rather than the whole
+     * suspension) ensures a retry never re-issues an already-created event.
+     */
+    eventLog?: MutableEventLog;
 }
 export interface SuspensionHandlerResult {
     timeoutSeconds?: number;
@@ -20,5 +29,5 @@ export interface SuspensionHandlerResult {
  * 1. Hooks are processed first to prevent race conditions with webhook receivers
  * 2. Steps and waits are processed in parallel after hooks complete
  */
-export declare function handleSuspension({ suspension, world, run, span, requestId, }: SuspensionHandlerParams): Promise<SuspensionHandlerResult>;
+export declare function handleSuspension({ suspension, world, run, span, requestId, eventLog, }: 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;AAM/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;AAgED;;;;;;;;GAQG;AACH,wBAAsB,gBAAgB,CAAC,EACrC,UAAU,EACV,KAAK,EACL,GAAG,EACH,IAAI,EACJ,SAAS,GACV,EAAE,uBAAuB,GAAG,OAAO,CAAC,uBAAuB,CAAC,CAoS5D"}
+{"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;AAM/C,OAAO,EAML,KAAK,WAAW,EAChB,KAAK,KAAK,EACX,MAAM,iBAAiB,CAAC;AAEzB,OAAO,KAAK,EAIV,kBAAkB,EACnB,MAAM,cAAc,CAAC;AAKtB,OAAO,EACL,KAAK,eAAe,EAGrB,MAAM,cAAc,CAAC;AAmBtB,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;IACnB;;;;;;OAMG;IACH,QAAQ,CAAC,EAAE,eAAe,CAAC;CAC5B;AAED,MAAM,WAAW,uBAAuB;IACtC,cAAc,CAAC,EAAE,MAAM,CAAC;CACzB;AAmED;;;;;;;;GAQG;AACH,wBAAsB,gBAAgB,CAAC,EACrC,UAAU,EACV,KAAK,EACL,GAAG,EACH,IAAI,EACJ,SAAS,EACT,QAAQ,GACT,EAAE,uBAAuB,GAAG,OAAO,CAAC,uBAAuB,CAAC,CAqT5D"}