@workflow/core 5.0.0-beta.50 → 5.0.0-beta.51

package/dist/runtime/helpers.js

@@ -1,5 +1,5 @@
 import { PreconditionFailedError, RUN_ERROR_CODES, WorkflowWorldError, } from '@workflow/errors';
-import { FIRST_EVENT_SLOT, getQueueTopicPrefix, HealthCheckPayloadSchema, HOOK_RESUME_INPUT_VERSION, requireEventSlot, resolveQueueNamespace, SPEC_VERSION_CURRENT, SPEC_VERSION_LEGACY, } from '@workflow/world';
+import { FIRST_EVENT_SLOT, getQueueTopicPrefix, HealthCheckPayloadSchema, HOOK_RESUME_INPUT_VERSION, ROOT_RUN_ID_ATTRIBUTE, requireEventSlot, resolveQueueNamespace, SPEC_VERSION_CURRENT, SPEC_VERSION_LEGACY, } from '@workflow/world';
 import { monotonicFactory } from 'ulid';
 import { runtimeLogger } from '../logger.js';
 import { bytesToBase64, deriveRunKeyPair } from '../sealed-box.js';
@@ -709,6 +709,53 @@ export async function settleEventSlotGap(runId, loaded) {
  * Empty for an empty log, which is the state a `run_created` write is issued
  * from: there is no position held yet to name.
  *
+ * ## Who names a position
+ *
+ * A World can hand events back on a write's success response through two
+ * params (`CreateEventParams` in `@workflow/world`): `eventCount`, which is
+ * answered with the events on the positions the write skipped over (the
+ * skipped-slot report), and `sinceCursor`, which is answered with everything
+ * after that cursor (the inline delta). Both exist to save the writer a
+ * reload. So the rule for which writes send them is not about the event type;
+ * it is about whether **the process that writes holds a loaded log it will
+ * keep deciding from**, its own next writes or the replay it resumes. A writer
+ * with no log has nothing to merge a page into, and whoever decides next is a
+ * fresh replay that loads the log anyway.
+ *
+ * Three gates, all of which must pass for a page to come back:
+ *
+ * 1. The writer names a position. Only the replay loop's `createEvent` seam
+ *    (runtime.ts) and the suspension handler's `createGuarded` do; the QuickJS
+ *    engine's `createEvent` (quickjs-entrypoint.ts) follows the same rule. Raw
+ *    `world.events.create` calls send nothing.
+ * 2. The World reads a page for that event type. A World may decline for types
+ *    whose writer never holds a log (step executor writes, run-terminal
+ *    writes), whatever the client sent.
+ * 3. There is something to hand back: the report only when the write landed
+ *    more than one position above `eventCount`; the delta always.
+ *
+ * | Event | Writer | Sends | Why |
+ * |---|---|---|---|
+ * | `run_created` | `start()` | nothing | no log exists yet |
+ * | `run_started` | replay loop, first write of a delivery | `eventCount` when a log is loaded; no cursor, the `run_started` preload owns the response fields | the preload already returns the full log |
+ * | `step_created`, `wait_created`, `hook_disposed`, `attr_set` | suspension handler (`createGuarded`) | `eventCount` | the handler keeps writing from, and resumes replay from, this log |
+ * | `step_created` | queue-consumer re-ensure (raw) | nothing | runs from a queue message, no log |
+ * | `hook_created` | suspension handler (node), `dispatchPendingOps` (QuickJS) | `eventCount` + `sinceCursor` (only when the suspension creates exactly one hook) | the delta is how an already-received hook resolves without a re-invocation; two creates against one cursor would give two deltas of which only the first could be taken |
+ * | `hook_received` | replay loop lazy resume; handler in-suspension resume | `eventCount` (preload owns the cursor fields) | both replay from the log right after |
+ * | `hook_received` | webhook / `resumeHook` (raw) | nothing | out-of-band, enqueues a delivery that loads the log |
+ * | `wait_completed` | replay loop timer path | `eventCount` | the loop keeps replaying from the log |
+ * | `wait_completed` | `runs.*` out-of-band (raw) | nothing | no log |
+ * | `step_started`, `step_retrying` | step executor | nothing | no log; the next decision is a replay that reloads or receives the delta below |
+ * | `step_completed`, `step_failed` | step executor | `sinceCursor` only, outside turbo, single inline step | this is where the inline execution loop gets its log back; in turbo or from a queued delivery a fresh replay loads it anyway |
+ * | `step_failed` | suspension handler, unserializable input | `eventCount` | the handler holds a log; rare, and follows a `step_created` that drew the page |
+ * | `attr_set` | `setAttributes()` API (raw) | nothing | out-of-band |
+ * | `run_completed`, `run_failed`, `run_cancelled` | replay loop, replay budget, `runs.cancel` | `eventCount` where the node loop's seam stamps it (the QuickJS engine sends nothing); never `sinceCursor` (`deltaRequestCursor` excludes terminal types) | terminal: nothing replays the log afterwards, so a World reads no page for them |
+ *
+ * Batched writes (`events.createBatch`) are outside all of this: a batch carries
+ * no per-event position and gets no page. The user-facing version of this table
+ * is in `docs/content/docs/v5/how-it-works/event-sourcing.mdx`; keep the two in
+ * step.
+ *
  * The maximum rather than the length, for the reason {@link maxEventSlot}
  * gives: a partially-read log holds fewer events than its highest position, and
  * counting those would make the write claim to have seen less than it has, so
@@ -798,6 +845,27 @@ export function withHealthCheck(handler, worldSpecVersion) {
         return await handler(req);
     };
 }
+/**
+ * The lineage root of a loaded run: its `$rootRunId` attribute, or its own id
+ * when it is itself a root.
+ */
+export function rootRunIdFrom(attributes, runId) {
+    return attributes?.[ROOT_RUN_ID_ATTRIBUTE] ?? runId;
+}
+/**
+ * The immutable run identity a step-execution message carries so its consumer
+ * can start the step without a blocking `runs.get` — see
+ * `RunDispatchContextSchema` in @workflow/world. Built at dispatch time from
+ * the run row the producer already holds.
+ */
+export function runDispatchContext(run) {
+    return {
+        deploymentId: run.deploymentId,
+        specVersion: run.specVersion ?? 0,
+        ...(run.startedAt ? { startedAt: +run.startedAt } : {}),
+        rootRunId: rootRunIdFrom(run.attributes, run.runId),
+    };
+}
 /** FNV-1a 32-bit hash of a string, as 8 hex chars. Tiny, deterministic, and
  *  dependency-free. Used only to scope idempotency keys, not for security. */
 function fnv1a32Hex(value) {
@@ -857,6 +925,65 @@ export async function queueMessage(world, ...args) {
         }
     });
 }
+/**
+ * Publishes several messages to one logical queue, using the World's batch
+ * send when it has one and falling back to concurrent single sends when it
+ * does not.
+ *
+ * Rejects if ANY message failed to publish, because every caller so far wants
+ * all-or-nothing: the recovery is to fail the delivery and let redelivery
+ * republish the whole set, deduped by the per-message `idempotencyKey`. That
+ * means a partial batch can leave some messages already out — which is
+ * exactly why the keys are required rather than advisory.
+ */
+export async function queueMessages(world, queueName, messages) {
+    if (messages.length === 0)
+        return;
+    const batch = world.queueBatch?.bind(world);
+    if (!batch) {
+        await Promise.all(messages.map((entry) => queueMessage(world, queueName, entry.message, entry.opts)));
+        return;
+    }
+    await trace('queue.publish', {
+        attributes: {
+            ...Attribute.MessagingSystem('vercel-queue'),
+            ...Attribute.MessagingDestinationName(queueName),
+            ...Attribute.MessagingOperationType('publish'),
+            ...Attribute.MessagingBatchMessageCount(messages.length),
+            ...Attribute.PeerService('vercel-queue'),
+            ...Attribute.RpcSystem('vercel-queue'),
+            ...Attribute.RpcService('vqs'),
+            ...Attribute.RpcMethod('publishBatch'),
+        },
+        kind: await getSpanKind('PRODUCER'),
+    }, async () => {
+        const results = await batch(queueName, messages);
+        // A World that answers with the wrong number of results has told us
+        // nothing about the messages it left out. Treated as a failure of the
+        // whole batch rather than read as success for the entries that ARE
+        // present: republishing under the same idempotency keys is safe,
+        // silently never dispatching a step is not (the run makes no progress
+        // and nothing surfaces an error).
+        if (results.length !== messages.length) {
+            throw Object.assign(new Error(`Queue batch for ${queueName} returned ${results.length} ` +
+                `result(s) for ${messages.length} message(s)`), { retryable: true });
+        }
+        const failures = results.filter((result) => result.error !== undefined);
+        if (failures.length === 0)
+            return;
+        const retryable = failures.some((failure) => failure.error !== undefined && failure.retryable);
+        const error = new Error(`Failed to publish ${failures.length} of ${messages.length} queue ` +
+            `message(s) to ${queueName}: ${failures[0]?.error}`);
+        // Carried on the error so a caller CAN tell a transient partial batch
+        // from a permanent rejection. Nothing reads it yet: today every caller
+        // rejects the delivery either way, so a permanently rejected entry
+        // still costs the full redelivery budget. Left in place because the
+        // information is only available here, and a fast-fail on
+        // `retryable: false` needs it.
+        Object.assign(error, { retryable });
+        throw error;
+    });
+}
 /**
  * Calculates the queue overhead time in milliseconds for a given message.
  */
@@ -895,4 +1022,4 @@ export function memoizeEncryptionKey(world, runOrId) {
         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 {\n  PreconditionFailedError,\n  RUN_ERROR_CODES,\n  WorkflowWorldError,\n} from '@workflow/errors';\nimport type {\n  CreateEventParams,\n  CreateEventRequest,\n  Event,\n  EventResult,\n  HealthCheckPayload,\n  ValidQueueName,\n  WorkflowRun,\n  World,\n} from '@workflow/world';\nimport {\n  FIRST_EVENT_SLOT,\n  getQueueTopicPrefix,\n  HealthCheckPayloadSchema,\n  HOOK_RESUME_INPUT_VERSION,\n  requireEventSlot,\n  resolveQueueNamespace,\n  SPEC_VERSION_CURRENT,\n  SPEC_VERSION_LEGACY,\n} from '@workflow/world';\nimport { monotonicFactory } from 'ulid';\nimport { runtimeLogger } from '../logger.js';\nimport { bytesToBase64, deriveRunKeyPair } from '../sealed-box.js';\nimport {\n  deriveRunPayloadKeys,\n  type PayloadKey,\n} from '../serialization/encryption.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(\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   * The target run's X25519 public key (base64), returned only when the probe\n   * carried a `runId` and the responding deployment has encryption enabled.\n   *\n   * Lets a cross-deployment `start()` seal the workflow arguments using a\n   * response it was already waiting on, instead of making a separate\n   * key-lookup request.\n   */\n  encryptionPublicKey?: string;\n  /**\n   * The responding deployment's `HOOK_RESUME_INPUT_VERSION`: the protocol\n   * version at which the *consumer* (queue-message target) materializes the\n   * `hook_received` event from `hookInput` on replay. A cross-deployment\n   * `start()` stamps the *target's* value (not the caller's) into the new\n   * run's `executionContext.hookResumeInputVersion`. Current producers write\n   * the event durably before publishing the wake and do not read the marker;\n   * OLDER producers still gate their lazy path on it, so it keeps being\n   * stamped. Omitted when the responding deployment predates this field,\n   * which fails that gate closed.\n   */\n  hookResumeInputVersion?: 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 */\nexport async function handleHealthCheckMessage(\n  healthCheck: HealthCheckPayload,\n  worldSpecVersion?: number\n): Promise<void> {\n  const world = await getWorldLazy();\n  const streamName = getHealthCheckStreamName(healthCheck.correlationId);\n\n  // When the probe names a run the caller is about to create, publish that\n  // run's public key. We are executing inside the target deployment, so its\n  // key material is available locally (no API call), and the caller can then\n  // seal the workflow arguments straight from this response rather than\n  // making a separate key-lookup request.\n  //\n  // Only a *public* key may travel this way: the probe response stream is\n  // deliberately unauthenticated, so anything secret would be exposed.\n  // Best-effort: a failure here must not fail the health check itself, which\n  // callers also rely on for plain capability detection.\n  let encryptionPublicKey: string | undefined;\n  if (healthCheck.runId) {\n    try {\n      const rawKey = await world.getEncryptionKeyForRun?.(healthCheck.runId);\n      if (rawKey) {\n        encryptionPublicKey = bytesToBase64(\n          (await deriveRunKeyPair(rawKey)).publicKey\n        );\n      }\n    } catch (err) {\n      runtimeLogger.warn(\n        'Health check could not derive a run public key; the caller will fall back to a key lookup',\n        {\n          correlationId: healthCheck.correlationId,\n          error: err instanceof Error ? err.message : String(err),\n        }\n      );\n    }\n  }\n\n  const response = JSON.stringify({\n    healthy: true,\n    correlationId: healthCheck.correlationId,\n    specVersion: worldSpecVersion ?? SPEC_VERSION_CURRENT,\n    workflowCoreVersion,\n    // We are executing inside the target deployment, so this constant reflects\n    // the *consumer's* hook-resume protocol version, exactly what a\n    // cross-deployment caller needs to gate its parallel resume path on.\n    hookResumeInputVersion: HOOK_RESUME_INPUT_VERSION,\n    ...(encryptionPublicKey ? { encryptionPublicKey } : {}),\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 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   * The run id the caller is about to create. When set, the responding\n   * deployment derives that run's public key locally and returns it as\n   * `encryptionPublicKey`, letting a cross-deployment `start()` seal the\n   * workflow arguments without a separate key lookup.\n   */\n  runId?: string;\n  /**\n   * Queue namespace of the target deployment (e.g. `'eve'` for topics like\n   * `__eve_wkf_workflow_*`). Falls back to `WORKFLOW_QUEUE_NAMESPACE` in the\n   * calling process. Cross-context callers (e.g. the observability\n   * dashboard) must pass the target deployment's namespace explicitly:\n   * the env fallback resolves in the caller's process, and a message\n   * published to a mismatched topic has no consumer, so the check would\n   * always time out.\n   */\n  namespace?: 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 combined workflow 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 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 */\n/**\n * Race a promise against a deadline. Rejects with a timeout error when the\n * deadline elapses first. Used to bound `world.streams.get()` inside the\n * health-check poll loop: some worlds hold that request open until the\n * stream has data (e.g. workflow-server holds unwritten streams open for\n * ~2 minutes), which would otherwise blow through the configured health\n * check timeout, since the `while` condition is only re-checked between\n * iterations.\n */\nfunction withDeadline<T>(promise: Promise<T>, ms: number): Promise<T> {\n  let timer: ReturnType<typeof setTimeout> | undefined;\n  return Promise.race([\n    promise,\n    new Promise<never>((_, reject) => {\n      timer = setTimeout(\n        () => reject(new Error(`Operation timed out after ${ms}ms`)),\n        ms\n      );\n    }),\n  ]).finally(() => clearTimeout(timer));\n}\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  encryptionPublicKey?: 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    encryptionPublicKey?: string;\n    hookResumeInputVersion?: number;\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  if (typeof r.encryptionPublicKey === 'string') {\n    parsed.encryptionPublicKey = r.encryptionPublicKey;\n  }\n  if (typeof r.hookResumeInputVersion === 'number') {\n    parsed.hookResumeInputVersion = r.hookResumeInputVersion;\n  }\n  return parsed;\n}\n\nexport async function healthCheck(\n  world: World,\n  options?: HealthCheckOptions\n): Promise<HealthCheckResult> {\n  const timeout = options?.timeout ?? DEFAULT_HEALTH_CHECK_TIMEOUT;\n  // Use the world's ID generator when available so the correlationId is a\n  // region-tagged ULID. The health-check response is delivered over a stream\n  // whose name embeds this correlationId; under platform-directed routing the\n  // reader and the responding endpoint can be served from different physical\n  // regions, so the region must be encoded in the ID itself for both sides to\n  // resolve the same (region-pinned) backend. Falls back to a plain ULID for\n  // worlds that don't tag IDs (e.g. local), which resolve to the default\n  // region on both sides.\n  const correlationId = world.createRunId?.() ?? generateId();\n  const streamName = getHealthCheckStreamName(correlationId);\n\n  const queueName =\n    `${getQueueTopicPrefix('workflow', resolveQueueNamespace(options?.namespace))}health_check` as ValidQueueName;\n\n  const startTime = Date.now();\n\n  try {\n    await world.queue(\n      queueName,\n      {\n        __healthCheck: true,\n        correlationId,\n        ...(options?.runId ? { runId: options.runId } : {}),\n      },\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 remainingMs = timeout - (Date.now() - startTime);\n        const stream = await withDeadline(\n          world.streams.get(\n            generateHealthCheckRunId(correlationId),\n            streamName\n          ),\n          remainingMs\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\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 recordRequestedEventCursor(\n  runId: string,\n  cursor: string | null,\n  requestedCursors: Set<string>\n): void {\n  if (!cursor) {\n    return;\n  }\n  if (requestedCursors.has(cursor)) {\n    throw eventPaginationContractError(runId, 'did not advance');\n  }\n  requestedCursors.add(cursor);\n}\n\n/**\n * Appends events whose IDs are not already present in `target`.\n *\n * Pass the IDs currently present in `target` when appending repeatedly to the\n * same array. The set is updated alongside `target`.\n *\n * Events are appended in the order the World returned them, and are not\n * re-sorted. Every append source is already in canonical order relative to the\n * tail (a cursor-delimited page, or a write-response delta), so receipt order is\n * the order to keep, and re-sorting here would only cost a pass over the log.\n * Nothing downstream may assume the tail is the newest event. See\n * {@link maxEventSlot}.\n */\nexport function appendUniqueEvents(\n  target: Event[],\n  events: readonly Event[],\n  targetIds?: Set<string>\n): void {\n  if (events.length === 0) {\n    return;\n  }\n\n  const ids = targetIds ?? new Set(target.map((event) => event.eventId));\n  for (const event of events) {\n    if (ids.has(event.eventId)) {\n      continue;\n    }\n    ids.add(event.eventId);\n    target.push(event);\n  }\n}\n\n/**\n * Inserts `event` into `target` at the position that keeps `target` ordered by\n * ascending `eventId`, or no-ops if an event with the same `eventId` is already\n * present (idempotent).\n *\n * `preloadedEvents` is loaded `sortOrder: 'asc'` and is never re-sorted\n * client-side, so a `hook_received` spliced in by the lazy-resume consumer must\n * land in `eventId` order: a plain `push` would place a late-committing\n * earlier event after events that sort before it, corrupting replay.\n *\n * Lexicographic string order is the log's order: a slot id is a fixed-width\n * zero-padded position, so comparing the strings compares the positions. This\n * needs no parse of its own for that reason, and the comparison is exact rather\n * than a reconstruction.\n */\nexport function insertEventByEventId(target: Event[], event: Event): void {\n  // Linear scan from the end: the spliced event is almost always the newest\n  // (it sorts at or near the tail), so this finds the slot in O(1)–O(k) for the\n  // common case while still handling an out-of-order late arrival correctly.\n  let i = target.length;\n  while (i > 0) {\n    const existing = target[i - 1];\n    if (existing.eventId === event.eventId) {\n      // Already present: keep the splice idempotent.\n      return;\n    }\n    if (existing.eventId < event.eventId) {\n      break;\n    }\n    i--;\n  }\n  target.splice(i, 0, event);\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\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<LoadedEventLog> {\n  const incremental = afterCursor !== undefined;\n  return trace('workflow.replay.load', async (span) => {\n    span?.setAttributes({\n      ...Attribute.WorkflowRunId(runId),\n      ...Attribute.WorkflowReplayLoadSource(\n        incremental ? 'events_list_incremental' : 'events_list'\n      ),\n    });\n\n    const loadedEvents: Event[] = [];\n    const loadedEventIds = new Set<string>();\n    const requestedCursors = new Set<string>();\n    let cursor: string | null = afterCursor ?? null;\n    let hasMore = true;\n    let pagesLoaded = 0;\n    let retriedWithoutCursor = false;\n    const world = await getWorldLazy();\n    const loadStart = Date.now();\n    while (hasMore) {\n      // TODO: we're currently loading all the data with resolveRef behavior. 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 = cursor;\n      recordRequestedEventCursor(runId, requestedCursor, requestedCursors);\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',\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          loadedEvents.length = 0;\n          loadedEventIds.clear();\n          requestedCursors.clear();\n          cursor = null;\n          retriedWithoutCursor = true;\n          continue;\n        }\n        throw error;\n      }\n\n      appendUniqueEvents(loadedEvents, response.data, loadedEventIds);\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 DB query hit the limit exactly and returned a\n      // precautionary `LastEvaluatedKey`. 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 * The runtime's loaded event-log snapshot: the events replayed so far and the\n * cursor positioned after them. Handed to helpers that derive the precondition\n * snapshot from it; they do not mutate it.\n */\nexport interface LoadedEventLog {\n  events: Event[];\n  cursor: string | null;\n}\n\n/**\n * Extend a loaded log with a page that continues it — a listed page, or the\n * inline delta a write handed back — and move its read position with it.\n *\n * The cursor is only advanced when the page carries one, so a source with no\n * position of its own (a skipped-slot report) cannot walk the read position\n * past events it did not carry. Appending does not re-sort; see\n * {@link appendUniqueEvents} for why receipt order is the order to keep.\n */\nexport function appendEventLog(\n  log: LoadedEventLog,\n  appended: { events: readonly Event[]; cursor?: string | null }\n): void {\n  appendUniqueEvents(log.events, appended.events);\n  log.cursor = appended.cursor ?? log.cursor;\n}\n\n/**\n * Whether a replay refuses to run over a log with a hole in it (see\n * {@link findEventSlotGap}). **On by default**; set\n * `WORKFLOW_SLOT_GAP_CHECK=0` to replay across holes instead.\n *\n * A World that allocates a position at the moment it commits leaves no hole\n * behind when a write fails, so density is a property the log has by\n * construction rather than one this check maintains. What the check is for is\n * the reads and the Worlds where that does not hold, and by the time it runs\n * the benign explanations are spent: a position missing because a concurrent\n * commit is not visible yet clears on a re-read, which is what\n * {@link settleEventSlotGap} does first.\n *\n * What is left is a hole that persists, and its two causes are\n * indistinguishable from the log. Either a World allocated the position outside\n * the commit and lost the write, in which case nothing happened there and\n * replaying past it is correct, or an event that did happen is missing, in\n * which case replaying past it decides a branch on absence and produces a wrong\n * result with nothing to show for it. Failing is the recoverable side of that\n * trade, and this is the way back out if a fleet turns out to carry holes of\n * the first kind.\n */\nexport function isSlotGapCheckEnabled(): boolean {\n  return process.env.WORKFLOW_SLOT_GAP_CHECK !== '0';\n}\n\n/*\n * Merging into a log a replay is midway through reading.\n *\n * Three paths add events to a loaded log after the replay has started: a\n * bump-and-report write hands back the slots it skipped ({@link\n * mergeReportedEvents}), an inline delta extends the tail (`absorbCreateDelta`\n * in `runtime.ts`), and a listed page appends ({@link appendUniqueEvents}).\n * They look alarming (the replay is reading an array while something else\n * writes to it) and they are safe for one reason worth stating plainly, since\n * every correctness argument in this file leans on it.\n *\n * **An event in the log is a fact, and a longer log cannot retract one.** The\n * log is append-only and positions are never reused, so a replay that produced\n * event E from the prefix it had loaded has made E true for every replay that\n * follows. A later replay reading a fuller log does not get to decide E should\n * not be there; it consumes E and reconciles to it, which is what the events\n * consumer does when it walks a log holding writes from a replay that raced it.\n *\n * Merging is therefore monotone: it can only add facts this replay has yet to\n * reconcile to, never remove one it already has. That is why absorbing is\n * always optional and never wrong to decline (an unabsorbed event is one the\n * next read returns), and why the guards below can afford to be strict.\n */\n\n/**\n * Merge the events a bump-and-report write handed back into the log it was\n * derived from, and answer how many of them were new.\n *\n * Unlike {@link appendUniqueEvents}, this re-sorts. The reported events occupy\n * slots *below* the write that reported them, so appending them would put them\n * after events they precede. Sorting by id restores the World's canonical order\n * rather than guessing at it: a slot id is that order, written down.\n */\nexport function mergeReportedEvents(\n  target: Event[],\n  events: readonly Event[]\n): number {\n  const before = target.length;\n  appendUniqueEvents(target, events);\n  const added = target.length - before;\n  if (added > 0) {\n    target.sort((a, b) =>\n      a.eventId < b.eventId ? -1 : a.eventId > b.eventId ? 1 : 0\n    );\n  }\n  return added;\n}\n\n/** What {@link absorbSkippedSlotReport} did with a write's report. */\nexport interface SkippedSlotReport {\n  /** How many of the reported events were new to the log. Zero if dropped. */\n  added: number;\n  /** How many events the report offered, whether or not they were taken. */\n  offered: number;\n  /** The report was truncated, so it was dropped whole instead of merged. */\n  truncated: boolean;\n}\n\n/**\n * Apply a write's skipped-slot report to the log it was derived from, deciding\n * whether the report may be taken at all.\n *\n * Every replay-context write can come back carrying the events on the slots it\n * skipped over, and every caller wants the same thing from them: fold them in\n * so the writes that follow name a position above them, and so the replay\n * resuming from this log sees them without a reload.\n *\n * The one policy is that a **truncated report is dropped whole**. It covers a\n * span of positions but carries only some of the events on them, so merging it\n * would raise the log's highest position past a position whose event is\n * missing. Later writes read that maximum to say what they have seen, so each\n * would claim a position it never saw, and the World only reports the span a\n * write skips: it would never send the missing one. Dropping costs one more\n * round of the same events on the next write and keeps the log a prefix of the\n * truth, which the note above {@link mergeReportedEvents} explains is always an\n * available answer.\n *\n * Callers that log do so from the returned counts; the decision is not theirs\n * to re-derive.\n */\nexport function absorbSkippedSlotReport(\n  target: Event[],\n  result: { events?: readonly Event[]; hasMore?: boolean }\n): SkippedSlotReport {\n  const offered = result.events?.length ?? 0;\n  if (offered === 0) {\n    return { added: 0, offered: 0, truncated: false };\n  }\n  if (result.hasMore === true) {\n    return { added: 0, offered, truncated: true };\n  }\n  return {\n    added: mergeReportedEvents(target, result.events ?? []),\n    offered,\n    truncated: false,\n  };\n}\n\n/**\n * The highest slot the loaded log occupies, or `undefined` for an empty log.\n *\n * The maximum, not the count, and the two are not interchangeable even though\n * a healthy log makes them equal. A World hands a position to the insert that\n * occupies it, so a write that never lands leaves no hole behind and the log\n * stays dense. What the count cannot survive is a *partial* read: a log\n * assembled from a truncated report, or read while a concurrent write is\n * committing, holds fewer events than its highest position. Counting those\n * would make the next write claim to have seen less than it has, so the World\n * would report the same events back to it on every attempt.\n *\n * A hole below the maximum is therefore a property of the read, not of the log,\n * which is what lets {@link settleEventSlotGap} re-read instead of giving up.\n *\n * @throws if any event id carries no slot. Every World the runtime replays\n * against numbers events by slot, so an id that does not is a broken log rather\n * than an older one, and a maximum derived by skipping it would understate the\n * log to every write that reads it.\n */\nexport function maxEventSlot(events: readonly Event[]): number | undefined {\n  let max: number | undefined;\n  for (const event of events) {\n    const slot = requireEventSlot(event.eventId);\n    if (max === undefined || slot > max) {\n      max = slot;\n    }\n  }\n  return max;\n}\n\n/** A position the log skips over, described well enough to name in an error. */\nexport interface EventSlotGap {\n  /** The lowest slot below the log's maximum that no event occupies. */\n  firstMissingSlot: number;\n  /** How many slots below the maximum no event occupies. */\n  missingCount: number;\n  /** The highest slot the log occupies. */\n  maxSlot: number;\n}\n\n/**\n * The hole in a loaded log, or `undefined` when there is none to find.\n *\n * The World allocates every position, so a log that holds `n` events below slot\n * `n` is missing one. That matters before a replay\n * and nowhere else: the replay reads the log as the complete record of what has\n * happened, and an absent position is indistinguishable from an event that\n * never occurred. The branch it would have decided gets decided the other way,\n * and the run diverges quietly rather than failing.\n *\n * Order-independent, unlike the equivalent audit the World runs over a page it\n * just read. A loaded log is assembled from listed pages plus whatever a\n * bump-and-report write handed back, and while {@link mergeReportedEvents}\n * restores id order, a check that can fail a healthy run should not depend on\n * that having happened.\n *\n * The first slot is never counted. It belongs to `run_created`, which `start()`\n * posts concurrently with the queue send, so a log read in that window\n * legitimately begins at the second slot and fills in on its own. Every replay\n * that races a run's own start would otherwise report a hole.\n *\n * Returns `undefined` for an empty log, which has no density to check.\n *\n * @throws if any event id carries no slot, for the reason {@link maxEventSlot}\n * gives.\n */\nexport function findEventSlotGap(\n  events: readonly Event[]\n): EventSlotGap | undefined {\n  const occupied = new Set<number>();\n  let maxSlot = 0;\n  for (const event of events) {\n    const slot = requireEventSlot(event.eventId);\n    occupied.add(slot);\n    if (slot > maxSlot) {\n      maxSlot = slot;\n    }\n  }\n  if (maxSlot === 0) {\n    return undefined;\n  }\n  const floor = occupied.has(FIRST_EVENT_SLOT)\n    ? FIRST_EVENT_SLOT\n    : FIRST_EVENT_SLOT + 1;\n  // Every slot is at or above `floor` by construction, so the log is dense\n  // exactly when it holds one event per position in `[floor, maxSlot]`. The\n  // scan below only runs once that has already answered no.\n  if (occupied.size === maxSlot - floor + 1) {\n    return undefined;\n  }\n  let firstMissingSlot: number | undefined;\n  let missingCount = 0;\n  for (let slot = floor; slot <= maxSlot; slot++) {\n    if (!occupied.has(slot)) {\n      firstMissingSlot ??= slot;\n      missingCount++;\n    }\n  }\n  if (firstMissingSlot === undefined) {\n    return undefined;\n  }\n  return { firstMissingSlot, missingCount, maxSlot };\n}\n\n/**\n * How many times a detected hole is re-read before the log is taken at its\n * word, and the backoff before each re-read (doubling per attempt).\n *\n * A hole can be transient. The World allocates a slot inside the insert that\n * occupies it, so two concurrent writers can collide, one retry past the other,\n * and the higher slot commit first, leaving a window in which the lower one is\n * genuinely absent from a strongly-consistent read and fills in a moment later.\n * The window is one commit wide, so a short backoff clears it; anything that\n * survives all three re-reads is a position no write will ever occupy.\n */\nexport const SLOT_GAP_RECHECK_ATTEMPTS = 3;\nconst SLOT_GAP_RECHECK_BASE_DELAY_MS = 25;\n\n/**\n * Re-read a log that looks holey until the hole fills in or the re-reads run\n * out, and return the settled log alongside the hole that survived.\n *\n * Reads are strongly consistent, so a hole is not an artifact of *when* the log\n * was read, but it can be an artifact of a write that had not committed yet\n * (see {@link SLOT_GAP_RECHECK_ATTEMPTS}). Distinguishing the two costs a\n * re-read, which is only ever paid by a replay that already found a hole.\n *\n * The reload is full rather than incremental: the missing position is below the\n * log's maximum, so a cursor-anchored read starts past it and can never see it\n * arrive.\n */\nexport async function settleEventSlotGap(\n  runId: string,\n  loaded: LoadedEventLog\n): Promise<{ log: LoadedEventLog; gap: EventSlotGap | undefined }> {\n  let log = loaded;\n  let gap = findEventSlotGap(log.events);\n  for (\n    let attempt = 0;\n    gap !== undefined && attempt < SLOT_GAP_RECHECK_ATTEMPTS;\n    attempt++\n  ) {\n    await new Promise((resolve) =>\n      setTimeout(resolve, SLOT_GAP_RECHECK_BASE_DELAY_MS * 2 ** attempt)\n    );\n    log = await loadWorkflowRunEvents(runId);\n    gap = findEventSlotGap(log.events);\n  }\n  return { log, gap };\n}\n\n/**\n * How much of its run's log a replay-context event creation had loaded when it\n * decided to write, as the highest slot that log occupies.\n *\n * One integer says it because the World keeps its positions dense: a writer\n * that names slot N is claiming to hold every event from 1 to N and nothing\n * above. The World answers by numbering the write above whatever the log has\n * actually reached and handing back the events on the slots in between: the\n * ones this writer decided without.\n *\n * Density is the World's invariant, not a claim about this particular read. A\n * reader that is short of a position it holds no event for names a lower N,\n * which understates what it has seen and only costs it a wider report. Naming\n * a position it cannot account for is the direction that is unsafe, which is\n * why {@link slotSnapshotParams} takes the maximum rather than the count.\n *\n * Its own object rather than a bare number so a call site cannot half-send it,\n * and so the empty case spreads to nothing.\n */\nexport interface SlotSnapshotParams {\n  eventCount?: number;\n}\n\n/**\n * Build the slot snapshot to attach to a replay-context event creation.\n *\n * Empty for an empty log, which is the state a `run_created` write is issued\n * from: there is no position held yet to name.\n *\n * The maximum rather than the length, for the reason {@link maxEventSlot}\n * gives: a partially-read log holds fewer events than its highest position, and\n * counting those would make the write claim to have seen less than it has, so\n * the World would report the same events back on every attempt.\n */\nexport function slotSnapshotParams(\n  events: readonly Event[]\n): SlotSnapshotParams {\n  const eventCount = maxEventSlot(events);\n  return eventCount === undefined ? {} : { eventCount };\n}\n\n/**\n * The events a rejecting World attached to a `PreconditionFailedError`, when it\n * returned the ones the client's snapshot was missing inline.\n *\n * Returns `null` for anything else: no details, a World that did not implement\n * this, or a payload that does not narrow cleanly. Callers fall back to\n * reloading the event log, which is always correct; this is untrusted-shaped\n * data on a failure path, so nothing here is repaired.\n *\n * `runId` is the caller's run. Every event must belong to it: the delta is\n * merged straight into the replay's log, and one foreign event there is a\n * corrupt log rather than a corrected one: the replay would consume a\n * correlation id for an event that does not exist on this run.\n */\nexport function preconditionEventDelta(\n  error: unknown,\n  runId: string\n): { events: Event[]; cursor: string | null } | null {\n  if (!PreconditionFailedError.is(error)) {\n    return null;\n  }\n  const details = error.details;\n  if (typeof details !== 'object' || details === null) {\n    return null;\n  }\n  const { events, cursor } = details as { events?: unknown; cursor?: unknown };\n  if (!Array.isArray(events) || events.length === 0) {\n    return null;\n  }\n  for (const event of events) {\n    if (\n      typeof event !== 'object' ||\n      event === null ||\n      typeof (event as { eventId?: unknown }).eventId !== 'string' ||\n      (event as { runId?: unknown }).runId !== runId\n    ) {\n      return null;\n    }\n  }\n  return {\n    events: events as Event[],\n    cursor: typeof cursor === 'string' ? cursor : null,\n  };\n}\n\n/** Creates one event on a bound run, carrying replay-recovery telemetry. */\nexport type EventCreator = (\n  data: CreateEventRequest,\n  params?: CreateEventParams\n) => Promise<EventResult>;\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/** FNV-1a 32-bit hash of a string, as 8 hex chars. Tiny, deterministic, and\n *  dependency-free. Used only to scope idempotency keys, not for security. */\nfunction fnv1a32Hex(value: string): string {\n  let hash = 0x811c9dc5;\n  for (let i = 0; i < value.length; i++) {\n    hash ^= value.charCodeAt(i);\n    hash = Math.imul(hash, 0x01000193);\n  }\n  return (hash >>> 0).toString(16).padStart(8, '0');\n}\n\n/**\n * Idempotency key for a step's background-dispatch queue message, scoped to\n * the step's IDENTITY, correlation id plus (hashed) step name, rather than\n * the bare correlation id.\n *\n * The scoping matters for resilient step dispatch under the precondition\n * guard: a guard-rejected `step_created` leaves its (revoked) step message in\n * flight, and the corrected replay may re-derive the same correlation id for\n * a DIFFERENT step. Under a bare-correlationId key the corrected replay's\n * dispatch would silently dedupe against the revoked in-flight message,\n * which then resolves `skipped` against the re-created entity (the server's\n * stepName fence rejects its bare start), and the legitimate step would\n * never be executed. Scoping by step name keeps every dedup property that\n * matters (crash recovery re-dispatch, concurrent handlers, the delayed\n * retry sharing the suspension re-dispatch's key: all name the same step)\n * while letting the corrected schedule's dispatch through.\n *\n * Every producer of a step-dispatch (or step-retry) message must use this\n * key. Cross-version mixing is not a concern: queue messages are pinned to\n * the deployment that produced them, so one run never sees two key schemes.\n */\nexport function stepDispatchIdempotencyKey(\n  correlationId: string,\n  stepName: string\n): string {\n  return `${correlationId}:${fnv1a32Hex(stepName)}`;\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 * Resolve the run's full payload-encryption capability. This includes the\n * symmetric key and X25519 keypair needed to open cross-run sealed payloads.\n * Missing world support or key material resolves to `undefined`; lookup and\n * derivation failures propagate rather than silently falling back to plaintext.\n */\nexport async function resolveRunEncryptionKey(\n  world: World,\n  runOrId: WorkflowRun | string,\n  context?: Record<string, unknown>\n): Promise<PayloadKey | undefined> {\n  const rawKey =\n    typeof runOrId === 'string'\n      ? await world.getEncryptionKeyForRun?.(runOrId, context)\n      : await world.getEncryptionKeyForRun?.(runOrId);\n  return rawKey ? await deriveRunPayloadKeys(rawKey) : undefined;\n}\n\n/**\n * Return a lazy, memoized accessor around {@link resolveRunEncryptionKey}.\n * Concurrent callers share the same promise, including its rejection.\n */\nexport function memoizeEncryptionKey(\n  world: World,\n  runOrId: WorkflowRun | string\n): () => Promise<PayloadKey | undefined> {\n  let cached: Promise<PayloadKey | undefined> | undefined;\n  return () => {\n    if (!cached) {\n      cached = resolveRunEncryptionKey(world, runOrId);\n    }\n    return cached;\n  };\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"helpers.js","sourceRoot":"","sources":["../../src/runtime/helpers.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,uBAAuB,EACvB,eAAe,EACf,kBAAkB,GACnB,MAAM,kBAAkB,CAAC;AAY1B,OAAO,EACL,gBAAgB,EAChB,mBAAmB,EACnB,wBAAwB,EACxB,yBAAyB,EACzB,qBAAqB,EACrB,gBAAgB,EAChB,qBAAqB,EACrB,oBAAoB,EACpB,mBAAmB,GACpB,MAAM,iBAAiB,CAAC;AACzB,OAAO,EAAE,gBAAgB,EAAE,MAAM,MAAM,CAAC;AACxC,OAAO,EAAE,aAAa,EAAE,MAAM,cAAc,CAAC;AAC7C,OAAO,EAAE,aAAa,EAAE,gBAAgB,EAAE,MAAM,kBAAkB,CAAC;AACnE,OAAO,EACL,oBAAoB,GAErB,MAAM,gCAAgC,CAAC;AACxC,OAAO,KAAK,SAAS,MAAM,sCAAsC,CAAC;AAClE,OAAO,EAAE,WAAW,EAAE,KAAK,EAAE,MAAM,iBAAiB,CAAC;AACrD,OAAO,EAAE,OAAO,IAAI,mBAAmB,EAAE,MAAM,eAAe,CAAC;AAC/D,OAAO,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAC;AAEnD,wDAAwD;AACxD,MAAM,4BAA4B,GAAG,MAAM,CAAC;AAE5C;;;;GAIG;AACH,MAAM,0BAA0B,GAAG,sBAAsB,CAAC;AAE1D;;;;GAIG;AACH,MAAM,UAAU,oBAAoB,CAClC,YAAoB,EACpB,SAAkB;IAElB,IAAI,CAAC,0BAA0B,CAAC,IAAI,CAAC,YAAY,CAAC,EAAE,CAAC;QACnD,MAAM,IAAI,KAAK,CACb,0BAA0B,YAAY,wGAAwG,CAC/I,CAAC;IACJ,CAAC;IACD,MAAM,MAAM,GAAG,mBAAmB,CAChC,UAAU,EACV,qBAAqB,CAAC,SAAS,CAAC,CACjC,CAAC;IACF,OAAO,GAAG,MAAM,GAAG,YAAY,EAAoB,CAAC;AACtD,CAAC;AAED,MAAM,UAAU,GAAG,gBAAgB,EAAE,CAAC;AAEtC;;GAEG;AACH,SAAS,wBAAwB,CAAC,aAAqB;IACrD,OAAO,mBAAmB,aAAa,EAAE,CAAC;AAC5C,CAAC;AA4CD;;;GAGG;AACH,MAAM,UAAU,uBAAuB,CACrC,OAAgB;IAEhB,MAAM,MAAM,GAAG,wBAAwB,CAAC,SAAS,CAAC,OAAO,CAAC,CAAC;IAC3D,IAAI,MAAM,CAAC,OAAO,EAAE,CAAC;QACnB,OAAO,MAAM,CAAC,IAAI,CAAC;IACrB,CAAC;IACD,OAAO,SAAS,CAAC;AACnB,CAAC;AAED;;;;;GAKG;AACH,SAAS,wBAAwB,CAAC,aAAqB;IACrD,OAAO,WAAW,aAAa,EAAE,CAAC;AACpC,CAAC;AAED;;;;;GAKG;AACH,MAAM,CAAC,KAAK,UAAU,wBAAwB,CAC5C,WAA+B,EAC/B,gBAAyB;IAEzB,MAAM,KAAK,GAAG,MAAM,YAAY,EAAE,CAAC;IACnC,MAAM,UAAU,GAAG,wBAAwB,CAAC,WAAW,CAAC,aAAa,CAAC,CAAC;IAEvE,yEAAyE;IACzE,0EAA0E;IAC1E,2EAA2E;IAC3E,sEAAsE;IACtE,wCAAwC;IACxC,EAAE;IACF,wEAAwE;IACxE,qEAAqE;IACrE,2EAA2E;IAC3E,uDAAuD;IACvD,IAAI,mBAAuC,CAAC;IAC5C,IAAI,WAAW,CAAC,KAAK,EAAE,CAAC;QACtB,IAAI,CAAC;YACH,MAAM,MAAM,GAAG,MAAM,KAAK,CAAC,sBAAsB,EAAE,CAAC,WAAW,CAAC,KAAK,CAAC,CAAC;YACvE,IAAI,MAAM,EAAE,CAAC;gBACX,mBAAmB,GAAG,aAAa,CACjC,CAAC,MAAM,gBAAgB,CAAC,MAAM,CAAC,CAAC,CAAC,SAAS,CAC3C,CAAC;YACJ,CAAC;QACH,CAAC;QAAC,OAAO,GAAG,EAAE,CAAC;YACb,aAAa,CAAC,IAAI,CAChB,2FAA2F,EAC3F;gBACE,aAAa,EAAE,WAAW,CAAC,aAAa;gBACxC,KAAK,EAAE,GAAG,YAAY,KAAK,CAAC,CAAC,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC,CAAC,MAAM,CAAC,GAAG,CAAC;aACxD,CACF,CAAC;QACJ,CAAC;IACH,CAAC;IAED,MAAM,QAAQ,GAAG,IAAI,CAAC,SAAS,CAAC;QAC9B,OAAO,EAAE,IAAI;QACb,aAAa,EAAE,WAAW,CAAC,aAAa;QACxC,WAAW,EAAE,gBAAgB,IAAI,oBAAoB;QACrD,mBAAmB;QACnB,2EAA2E;QAC3E,gEAAgE;QAChE,qEAAqE;QACrE,sBAAsB,EAAE,yBAAyB;QACjD,GAAG,CAAC,mBAAmB,CAAC,CAAC,CAAC,EAAE,mBAAmB,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;QACvD,SAAS,EAAE,IAAI,CAAC,GAAG,EAAE;KACtB,CAAC,CAAC;IACH,wEAAwE;IACxE,2CAA2C;IAC3C,MAAM,SAAS,GAAG,wBAAwB,CAAC,WAAW,CAAC,aAAa,CAAC,CAAC;IACtE,MAAM,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,SAAS,EAAE,UAAU,EAAE,QAAQ,CAAC,CAAC;IAC3D,MAAM,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,SAAS,EAAE,UAAU,CAAC,CAAC;AACnD,CAAC;AA0BD;;;;;;;;;;GAUG;AACH,8CAA8C;AAC9C,MAAM,0BAA0B,GAAG,GAAG,CAAC;AACvC,6EAA6E;AAC7E,wCAAwC;AACxC,MAAM,yBAAyB,GAAG,GAAG,CAAC;AAEtC;;;GAGG;AACH;;;;;;;;GAQG;AACH,SAAS,YAAY,CAAI,OAAmB,EAAE,EAAU;IACtD,IAAI,KAAgD,CAAC;IACrD,OAAO,OAAO,CAAC,IAAI,CAAC;QAClB,OAAO;QACP,IAAI,OAAO,CAAQ,CAAC,CAAC,EAAE,MAAM,EAAE,EAAE;YAC/B,KAAK,GAAG,UAAU,CAChB,GAAG,EAAE,CAAC,MAAM,CAAC,IAAI,KAAK,CAAC,6BAA6B,EAAE,IAAI,CAAC,CAAC,EAC5D,EAAE,CACH,CAAC;QACJ,CAAC,CAAC;KACH,CAAC,CAAC,OAAO,CAAC,GAAG,EAAE,CAAC,YAAY,CAAC,KAAK,CAAC,CAAC,CAAC;AACxC,CAAC;AAED,KAAK,UAAU,qBAAqB,CAClC,MAA+C,EAC/C,WAAmB;IAEnB,MAAM,MAAM,GAAiB,EAAE,CAAC;IAChC,IAAI,IAAI,GAAG,KAAK,CAAC;IACjB,IAAI,QAAQ,GAAG,KAAK,CAAC;IAErB,OAAO,CAAC,IAAI,IAAI,CAAC,QAAQ,EAAE,CAAC;QAC1B,MAAM,WAAW,GAAG,MAAM,CAAC,IAAI,EAAE,CAAC;QAClC,MAAM,cAAc,GAAG,IAAI,OAAO,CAChC,CAAC,OAAO,EAAE,EAAE,CACV,UAAU,CAAC,GAAG,EAAE;YACd,QAAQ,GAAG,IAAI,CAAC;YAChB,OAAO,CAAC,EAAE,IAAI,EAAE,IAAI,EAAE,KAAK,EAAE,SAAS,EAAE,CAAC,CAAC;QAC5C,CAAC,EAAE,WAAW,CAAC,CAClB,CAAC;QAEF,MAAM,MAAM,GAAG,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC,WAAW,EAAE,cAAc,CAAC,CAAC,CAAC;QACjE,IAAI,GAAG,MAAM,CAAC,IAAI,CAAC;QACnB,IAAI,MAAM,CAAC,KAAK;YAAE,MAAM,CAAC,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC;IAC9C,CAAC;IAED,OAAO,EAAE,MAAM,EAAE,QAAQ,EAAE,CAAC;AAC9B,CAAC;AAED;;;GAGG;AACH,SAAS,wBAAwB,CAAC,MAAoB;IAMpD,IAAI,MAAM,CAAC,MAAM,KAAK,CAAC;QAAE,OAAO,IAAI,CAAC;IAErC,MAAM,WAAW,GAAG,MAAM,CAAC,MAAM,CAAC,CAAC,GAAG,EAAE,KAAK,EAAE,EAAE,CAAC,GAAG,GAAG,KAAK,CAAC,MAAM,EAAE,CAAC,CAAC,CAAC;IACzE,MAAM,QAAQ,GAAG,IAAI,UAAU,CAAC,WAAW,CAAC,CAAC;IAC7C,IAAI,MAAM,GAAG,CAAC,CAAC;IACf,KAAK,MAAM,KAAK,IAAI,MAAM,EAAE,CAAC;QAC3B,QAAQ,CAAC,GAAG,CAAC,KAAK,EAAE,MAAM,CAAC,CAAC;QAC5B,MAAM,IAAI,KAAK,CAAC,MAAM,CAAC;IACzB,CAAC;IACD,MAAM,YAAY,GAAG,IAAI,WAAW,EAAE,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC;IAExD,IAAI,QAAiB,CAAC;IACtB,IAAI,CAAC;QACH,QAAQ,GAAG,IAAI,CAAC,KAAK,CAAC,YAAY,CAAC,CAAC;IACtC,CAAC;IAAC,MAAM,CAAC;QACP,2DAA2D;QAC3D,gEAAgE;QAChE,kEAAkE;QAClE,IAAI,YAAY,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;YAC5B,OAAO,EAAE,OAAO,EAAE,IAAI,EAAE,CAAC;QAC3B,CAAC;QACD,OAAO,IAAI,CAAC;IACd,CAAC;IAED,IACE,OAAO,QAAQ,KAAK,QAAQ;QAC5B,QAAQ,KAAK,IAAI;QACjB,CAAC,CAAC,SAAS,IAAI,QAAQ,CAAC;QACxB,OAAQ,QAAiC,CAAC,OAAO,KAAK,SAAS,EAC/D,CAAC;QACD,OAAO,IAAI,CAAC;IACd,CAAC;IAED,MAAM,CAAC,GAAG,QAAmC,CAAC;IAC9C,MAAM,MAAM,GAMR;QACF,OAAO,EAAE,CAAC,CAAC,OAAkB;KAC9B,CAAC;IACF,IAAI,OAAO,CAAC,CAAC,WAAW,KAAK,QAAQ,EAAE,CAAC;QACtC,MAAM,CAAC,WAAW,GAAG,CAAC,CAAC,WAAW,CAAC;IACrC,CAAC;IACD,IAAI,OAAO,CAAC,CAAC,mBAAmB,KAAK,QAAQ,EAAE,CAAC;QAC9C,MAAM,CAAC,mBAAmB,GAAG,CAAC,CAAC,mBAAmB,CAAC;IACrD,CAAC;IACD,IAAI,OAAO,CAAC,CAAC,mBAAmB,KAAK,QAAQ,EAAE,CAAC;QAC9C,MAAM,CAAC,mBAAmB,GAAG,CAAC,CAAC,mBAAmB,CAAC;IACrD,CAAC;IACD,IAAI,OAAO,CAAC,CAAC,sBAAsB,KAAK,QAAQ,EAAE,CAAC;QACjD,MAAM,CAAC,sBAAsB,GAAG,CAAC,CAAC,sBAAsB,CAAC;IAC3D,CAAC;IACD,OAAO,MAAM,CAAC;AAChB,CAAC;AAED,MAAM,CAAC,KAAK,UAAU,WAAW,CAC/B,KAAY,EACZ,OAA4B;IAE5B,MAAM,OAAO,GAAG,OAAO,EAAE,OAAO,IAAI,4BAA4B,CAAC;IACjE,wEAAwE;IACxE,2EAA2E;IAC3E,4EAA4E;IAC5E,2EAA2E;IAC3E,4EAA4E;IAC5E,2EAA2E;IAC3E,uEAAuE;IACvE,wBAAwB;IACxB,MAAM,aAAa,GAAG,KAAK,CAAC,WAAW,EAAE,EAAE,IAAI,UAAU,EAAE,CAAC;IAC5D,MAAM,UAAU,GAAG,wBAAwB,CAAC,aAAa,CAAC,CAAC;IAE3D,MAAM,SAAS,GACb,GAAG,mBAAmB,CAAC,UAAU,EAAE,qBAAqB,CAAC,OAAO,EAAE,SAAS,CAAC,CAAC,cAAgC,CAAC;IAEhH,MAAM,SAAS,GAAG,IAAI,CAAC,GAAG,EAAE,CAAC;IAE7B,IAAI,CAAC;QACH,MAAM,KAAK,CAAC,KAAK,CACf,SAAS,EACT;YACE,aAAa,EAAE,IAAI;YACnB,aAAa;YACb,GAAG,CAAC,OAAO,EAAE,KAAK,CAAC,CAAC,CAAC,EAAE,KAAK,EAAE,OAAO,CAAC,KAAK,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;SACpD,EACD;YACE,4DAA4D;YAC5D,8CAA8C;YAC9C,WAAW,EAAE,mBAAmB;YAChC,YAAY,EAAE,OAAO,EAAE,YAAY;SACpC,CACF,CAAC;QAEF,OAAO,IAAI,CAAC,GAAG,EAAE,GAAG,SAAS,GAAG,OAAO,EAAE,CAAC;YACxC,IAAI,CAAC;gBACH,MAAM,WAAW,GAAG,OAAO,GAAG,CAAC,IAAI,CAAC,GAAG,EAAE,GAAG,SAAS,CAAC,CAAC;gBACvD,MAAM,MAAM,GAAG,MAAM,YAAY,CAC/B,KAAK,CAAC,OAAO,CAAC,GAAG,CACf,wBAAwB,CAAC,aAAa,CAAC,EACvC,UAAU,CACX,EACD,WAAW,CACZ,CAAC;gBACF,MAAM,MAAM,GAAG,MAAM,CAAC,SAAS,EAAE,CAAC;gBAClC,MAAM,EAAE,MAAM,EAAE,QAAQ,EAAE,GAAG,MAAM,qBAAqB,CACtD,MAAM,EACN,yBAAyB,CAC1B,CAAC;gBAEF,IAAI,QAAQ,EAAE,CAAC;oBACb,IAAI,CAAC;wBACH,MAAM,CAAC,MAAM,EAAE,CAAC;oBAClB,CAAC;oBAAC,MAAM,CAAC;wBACP,uBAAuB;oBACzB,CAAC;oBACD,MAAM,IAAI,OAAO,CAAC,CAAC,OAAO,EAAE,EAAE,CAC5B,UAAU,CAAC,OAAO,EAAE,0BAA0B,CAAC,CAChD,CAAC;oBACF,SAAS;gBACX,CAAC;gBAED,MAAM,QAAQ,GAAG,wBAAwB,CAAC,MAAM,CAAC,CAAC;gBAClD,IAAI,QAAQ,EAAE,CAAC;oBACb,OAAO;wBACL,GAAG,QAAQ;wBACX,SAAS,EAAE,IAAI,CAAC,GAAG,EAAE,GAAG,SAAS;qBAClC,CAAC;gBACJ,CAAC;gBAED,MAAM,IAAI,OAAO,CAAC,CAAC,OAAO,EAAE,EAAE,CAC5B,UAAU,CAAC,OAAO,EAAE,0BAA0B,CAAC,CAChD,CAAC;YACJ,CAAC;YAAC,MAAM,CAAC;gBACP,MAAM,IAAI,OAAO,CAAC,CAAC,OAAO,EAAE,EAAE,CAC5B,UAAU,CAAC,OAAO,EAAE,0BAA0B,CAAC,CAChD,CAAC;YACJ,CAAC;QACH,CAAC;QACD,OAAO;YACL,OAAO,EAAE,KAAK;YACd,KAAK,EAAE,gCAAgC,OAAO,IAAI;SACnD,CAAC;IACJ,CAAC;IAAC,OAAO,KAAK,EAAE,CAAC;QACf,OAAO;YACL,OAAO,EAAE,KAAK;YACd,KAAK,EAAE,KAAK,YAAY,KAAK,CAAC,CAAC,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,MAAM,CAAC,KAAK,CAAC;SAC9D,CAAC;IACJ,CAAC;AACH,CAAC;AAED,SAAS,4BAA4B,CACnC,KAAa,EACb,OAAe;IAEf,OAAO,IAAI,kBAAkB,CAC3B,oBAAoB,OAAO,sBAAsB,KAAK,IAAI,EAC1D,EAAE,IAAI,EAAE,eAAe,CAAC,oBAAoB,EAAE,CAC/C,CAAC;AACJ,CAAC;AAED,SAAS,0BAA0B,CACjC,KAAa,EACb,MAAqB,EACrB,gBAA6B;IAE7B,IAAI,CAAC,MAAM,EAAE,CAAC;QACZ,OAAO;IACT,CAAC;IACD,IAAI,gBAAgB,CAAC,GAAG,CAAC,MAAM,CAAC,EAAE,CAAC;QACjC,MAAM,4BAA4B,CAAC,KAAK,EAAE,iBAAiB,CAAC,CAAC;IAC/D,CAAC;IACD,gBAAgB,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC;AAC/B,CAAC;AAED;;;;;;;;;;;;GAYG;AACH,MAAM,UAAU,kBAAkB,CAChC,MAAe,EACf,MAAwB,EACxB,SAAuB;IAEvB,IAAI,MAAM,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;QACxB,OAAO;IACT,CAAC;IAED,MAAM,GAAG,GAAG,SAAS,IAAI,IAAI,GAAG,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC;IACvE,KAAK,MAAM,KAAK,IAAI,MAAM,EAAE,CAAC;QAC3B,IAAI,GAAG,CAAC,GAAG,CAAC,KAAK,CAAC,OAAO,CAAC,EAAE,CAAC;YAC3B,SAAS;QACX,CAAC;QACD,GAAG,CAAC,GAAG,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC;QACvB,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;IACrB,CAAC;AACH,CAAC;AAED;;;;;;;;;;;;;;GAcG;AACH,MAAM,UAAU,oBAAoB,CAAC,MAAe,EAAE,KAAY;IAChE,0EAA0E;IAC1E,8EAA8E;IAC9E,2EAA2E;IAC3E,IAAI,CAAC,GAAG,MAAM,CAAC,MAAM,CAAC;IACtB,OAAO,CAAC,GAAG,CAAC,EAAE,CAAC;QACb,MAAM,QAAQ,GAAG,MAAM,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC;QAC/B,IAAI,QAAQ,CAAC,OAAO,KAAK,KAAK,CAAC,OAAO,EAAE,CAAC;YACvC,+CAA+C;YAC/C,OAAO;QACT,CAAC;QACD,IAAI,QAAQ,CAAC,OAAO,GAAG,KAAK,CAAC,OAAO,EAAE,CAAC;YACrC,MAAM;QACR,CAAC;QACD,CAAC,EAAE,CAAC;IACN,CAAC;IACD,MAAM,CAAC,MAAM,CAAC,CAAC,EAAE,CAAC,EAAE,KAAK,CAAC,CAAC;AAC7B,CAAC;AAED,SAAS,6BAA6B,CACpC,KAAa,EACb,OAAgB,EAChB,MAAqB,EACrB,gBAA6B;IAE7B,IAAI,CAAC,OAAO,EAAE,CAAC;QACb,OAAO;IACT,CAAC;IACD,IAAI,MAAM,KAAK,IAAI,EAAE,CAAC;QACpB,MAAM,4BAA4B,CAChC,KAAK,EACL,sCAAsC,CACvC,CAAC;IACJ,CAAC;IACD,IAAI,gBAAgB,CAAC,GAAG,CAAC,MAAM,CAAC,EAAE,CAAC;QACjC,MAAM,4BAA4B,CAAC,KAAK,EAAE,mBAAmB,CAAC,CAAC;IACjE,CAAC;AACH,CAAC;AAED,SAAS,6BAA6B,CACpC,KAAc,EACd,MAAqB,EACrB,cAAuB;IAEvB,OAAO,CACL,MAAM,KAAK,IAAI;QACf,CAAC,cAAc;QACf,kBAAkB,CAAC,EAAE,CAAC,KAAK,CAAC;QAC5B,KAAK,CAAC,MAAM,KAAK,GAAG,CACrB,CAAC;AACJ,CAAC;AAED;;;;;;;;;;GAUG;AACH,MAAM,CAAC,KAAK,UAAU,qBAAqB,CACzC,KAAa,EACb,WAAoB;IAEpB,MAAM,WAAW,GAAG,WAAW,KAAK,SAAS,CAAC;IAC9C,OAAO,KAAK,CAAC,sBAAsB,EAAE,KAAK,EAAE,IAAI,EAAE,EAAE;QAClD,IAAI,EAAE,aAAa,CAAC;YAClB,GAAG,SAAS,CAAC,aAAa,CAAC,KAAK,CAAC;YACjC,GAAG,SAAS,CAAC,wBAAwB,CACnC,WAAW,CAAC,CAAC,CAAC,yBAAyB,CAAC,CAAC,CAAC,aAAa,CACxD;SACF,CAAC,CAAC;QAEH,MAAM,YAAY,GAAY,EAAE,CAAC;QACjC,MAAM,cAAc,GAAG,IAAI,GAAG,EAAU,CAAC;QACzC,MAAM,gBAAgB,GAAG,IAAI,GAAG,EAAU,CAAC;QAC3C,IAAI,MAAM,GAAkB,WAAW,IAAI,IAAI,CAAC;QAChD,IAAI,OAAO,GAAG,IAAI,CAAC;QACnB,IAAI,WAAW,GAAG,CAAC,CAAC;QACpB,IAAI,oBAAoB,GAAG,KAAK,CAAC;QACjC,MAAM,KAAK,GAAG,MAAM,YAAY,EAAE,CAAC;QACnC,MAAM,SAAS,GAAG,IAAI,CAAC,GAAG,EAAE,CAAC;QAC7B,OAAO,OAAO,EAAE,CAAC;YACf,8FAA8F;YAC9F,qGAAqG;YACrG,mCAAmC;YACnC,MAAM,SAAS,GAAG,IAAI,CAAC,GAAG,EAAE,CAAC;YAC7B,MAAM,eAAe,GAAG,MAAM,CAAC;YAC/B,0BAA0B,CAAC,KAAK,EAAE,eAAe,EAAE,gBAAgB,CAAC,CAAC;YAErE,IAAI,QAAuD,CAAC;YAC5D,IAAI,CAAC;gBACH,QAAQ,GAAG,MAAM,KAAK,CAAC,MAAM,CAAC,IAAI,CAAC;oBACjC,KAAK;oBACL,UAAU,EAAE;wBACV,SAAS,EAAE,KAAK;wBAChB,MAAM,EAAE,eAAe,IAAI,SAAS;qBACrC;iBACF,CAAC,CAAC;YACL,CAAC;YAAC,OAAO,KAAK,EAAE,CAAC;gBACf,IACE,6BAA6B,CAC3B,KAAK,EACL,eAAe,EACf,oBAAoB,CACrB,EACD,CAAC;oBACD,aAAa,CAAC,IAAI,CAChB,+DAA+D,EAC/D,EAAE,aAAa,EAAE,KAAK,EAAE,CACzB,CAAC;oBACF,YAAY,CAAC,MAAM,GAAG,CAAC,CAAC;oBACxB,cAAc,CAAC,KAAK,EAAE,CAAC;oBACvB,gBAAgB,CAAC,KAAK,EAAE,CAAC;oBACzB,MAAM,GAAG,IAAI,CAAC;oBACd,oBAAoB,GAAG,IAAI,CAAC;oBAC5B,SAAS;gBACX,CAAC;gBACD,MAAM,KAAK,CAAC;YACd,CAAC;YAED,kBAAkB,CAAC,YAAY,EAAE,QAAQ,CAAC,IAAI,EAAE,cAAc,CAAC,CAAC;YAChE,OAAO,GAAG,QAAQ,CAAC,OAAO,CAAC;YAC3B,6BAA6B,CAC3B,KAAK,EACL,OAAO,EACP,QAAQ,CAAC,MAAM,EACf,gBAAgB,CACjB,CAAC;YACF,8DAA8D;YAC9D,mEAAmE;YACnE,iEAAiE;YACjE,2DAA2D;YAC3D,+DAA+D;YAC/D,iEAAiE;YACjE,kEAAkE;YAClE,wDAAwD;YACxD,MAAM,GAAG,QAAQ,CAAC,MAAM,IAAI,MAAM,CAAC;YACnC,WAAW,EAAE,CAAC;YAEd,aAAa,CAAC,KAAK,CAAC,mBAAmB,EAAE;gBACvC,aAAa,EAAE,KAAK;gBACpB,WAAW;gBACX,IAAI,EAAE,WAAW;gBACjB,UAAU,EAAE,QAAQ,CAAC,IAAI,CAAC,MAAM;gBAChC,WAAW,EAAE,YAAY,CAAC,MAAM;gBAChC,OAAO;gBACP,MAAM,EAAE,IAAI,CAAC,GAAG,EAAE,GAAG,SAAS;aAC/B,CAAC,CAAC;QACL,CAAC;QAED,aAAa,CAAC,KAAK,CAAC,qBAAqB,EAAE;YACzC,aAAa,EAAE,KAAK;YACpB,WAAW;YACX,WAAW,EAAE,YAAY,CAAC,MAAM;YAChC,WAAW;YACX,OAAO,EAAE,IAAI,CAAC,GAAG,EAAE,GAAG,SAAS;SAChC,CAAC,CAAC;QAEH,IAAI,EAAE,aAAa,CAAC;YAClB,GAAG,SAAS,CAAC,mBAAmB,CAAC,YAAY,CAAC,MAAM,CAAC;YACrD,GAAG,SAAS,CAAC,yBAAyB,CAAC,WAAW,CAAC;SACpD,CAAC,CAAC;QAEH,OAAO,EAAE,MAAM,EAAE,YAAY,EAAE,MAAM,EAAE,CAAC;IAC1C,CAAC,CAAC,CAAC;AACL,CAAC;AAYD;;;;;;;;GAQG;AACH,MAAM,UAAU,cAAc,CAC5B,GAAmB,EACnB,QAA8D;IAE9D,kBAAkB,CAAC,GAAG,CAAC,MAAM,EAAE,QAAQ,CAAC,MAAM,CAAC,CAAC;IAChD,GAAG,CAAC,MAAM,GAAG,QAAQ,CAAC,MAAM,IAAI,GAAG,CAAC,MAAM,CAAC;AAC7C,CAAC;AAED;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,MAAM,UAAU,qBAAqB;IACnC,OAAO,OAAO,CAAC,GAAG,CAAC,uBAAuB,KAAK,GAAG,CAAC;AACrD,CAAC;AAED;;;;;;;;;;;;;;;;;;;;;;GAsBG;AAEH;;;;;;;;GAQG;AACH,MAAM,UAAU,mBAAmB,CACjC,MAAe,EACf,MAAwB;IAExB,MAAM,MAAM,GAAG,MAAM,CAAC,MAAM,CAAC;IAC7B,kBAAkB,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACnC,MAAM,KAAK,GAAG,MAAM,CAAC,MAAM,GAAG,MAAM,CAAC;IACrC,IAAI,KAAK,GAAG,CAAC,EAAE,CAAC;QACd,MAAM,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CACnB,CAAC,CAAC,OAAO,GAAG,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,OAAO,GAAG,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAC3D,CAAC;IACJ,CAAC;IACD,OAAO,KAAK,CAAC;AACf,CAAC;AAYD;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,MAAM,UAAU,uBAAuB,CACrC,MAAe,EACf,MAAwD;IAExD,MAAM,OAAO,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,IAAI,CAAC,CAAC;IAC3C,IAAI,OAAO,KAAK,CAAC,EAAE,CAAC;QAClB,OAAO,EAAE,KAAK,EAAE,CAAC,EAAE,OAAO,EAAE,CAAC,EAAE,SAAS,EAAE,KAAK,EAAE,CAAC;IACpD,CAAC;IACD,IAAI,MAAM,CAAC,OAAO,KAAK,IAAI,EAAE,CAAC;QAC5B,OAAO,EAAE,KAAK,EAAE,CAAC,EAAE,OAAO,EAAE,SAAS,EAAE,IAAI,EAAE,CAAC;IAChD,CAAC;IACD,OAAO;QACL,KAAK,EAAE,mBAAmB,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,IAAI,EAAE,CAAC;QACvD,OAAO;QACP,SAAS,EAAE,KAAK;KACjB,CAAC;AACJ,CAAC;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,MAAM,UAAU,YAAY,CAAC,MAAwB;IACnD,IAAI,GAAuB,CAAC;IAC5B,KAAK,MAAM,KAAK,IAAI,MAAM,EAAE,CAAC;QAC3B,MAAM,IAAI,GAAG,gBAAgB,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC;QAC7C,IAAI,GAAG,KAAK,SAAS,IAAI,IAAI,GAAG,GAAG,EAAE,CAAC;YACpC,GAAG,GAAG,IAAI,CAAC;QACb,CAAC;IACH,CAAC;IACD,OAAO,GAAG,CAAC;AACb,CAAC;AAYD;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,MAAM,UAAU,gBAAgB,CAC9B,MAAwB;IAExB,MAAM,QAAQ,GAAG,IAAI,GAAG,EAAU,CAAC;IACnC,IAAI,OAAO,GAAG,CAAC,CAAC;IAChB,KAAK,MAAM,KAAK,IAAI,MAAM,EAAE,CAAC;QAC3B,MAAM,IAAI,GAAG,gBAAgB,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC;QAC7C,QAAQ,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;QACnB,IAAI,IAAI,GAAG,OAAO,EAAE,CAAC;YACnB,OAAO,GAAG,IAAI,CAAC;QACjB,CAAC;IACH,CAAC;IACD,IAAI,OAAO,KAAK,CAAC,EAAE,CAAC;QAClB,OAAO,SAAS,CAAC;IACnB,CAAC;IACD,MAAM,KAAK,GAAG,QAAQ,CAAC,GAAG,CAAC,gBAAgB,CAAC;QAC1C,CAAC,CAAC,gBAAgB;QAClB,CAAC,CAAC,gBAAgB,GAAG,CAAC,CAAC;IACzB,yEAAyE;IACzE,0EAA0E;IAC1E,0DAA0D;IAC1D,IAAI,QAAQ,CAAC,IAAI,KAAK,OAAO,GAAG,KAAK,GAAG,CAAC,EAAE,CAAC;QAC1C,OAAO,SAAS,CAAC;IACnB,CAAC;IACD,IAAI,gBAAoC,CAAC;IACzC,IAAI,YAAY,GAAG,CAAC,CAAC;IACrB,KAAK,IAAI,IAAI,GAAG,KAAK,EAAE,IAAI,IAAI,OAAO,EAAE,IAAI,EAAE,EAAE,CAAC;QAC/C,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,IAAI,CAAC,EAAE,CAAC;YACxB,gBAAgB,KAAK,IAAI,CAAC;YAC1B,YAAY,EAAE,CAAC;QACjB,CAAC;IACH,CAAC;IACD,IAAI,gBAAgB,KAAK,SAAS,EAAE,CAAC;QACnC,OAAO,SAAS,CAAC;IACnB,CAAC;IACD,OAAO,EAAE,gBAAgB,EAAE,YAAY,EAAE,OAAO,EAAE,CAAC;AACrD,CAAC;AAED;;;;;;;;;;GAUG;AACH,MAAM,CAAC,MAAM,yBAAyB,GAAG,CAAC,CAAC;AAC3C,MAAM,8BAA8B,GAAG,EAAE,CAAC;AAE1C;;;;;;;;;;;;GAYG;AACH,MAAM,CAAC,KAAK,UAAU,kBAAkB,CACtC,KAAa,EACb,MAAsB;IAEtB,IAAI,GAAG,GAAG,MAAM,CAAC;IACjB,IAAI,GAAG,GAAG,gBAAgB,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC;IACvC,KACE,IAAI,OAAO,GAAG,CAAC,EACf,GAAG,KAAK,SAAS,IAAI,OAAO,GAAG,yBAAyB,EACxD,OAAO,EAAE,EACT,CAAC;QACD,MAAM,IAAI,OAAO,CAAC,CAAC,OAAO,EAAE,EAAE,CAC5B,UAAU,CAAC,OAAO,EAAE,8BAA8B,GAAG,CAAC,IAAI,OAAO,CAAC,CACnE,CAAC;QACF,GAAG,GAAG,MAAM,qBAAqB,CAAC,KAAK,CAAC,CAAC;QACzC,GAAG,GAAG,gBAAgB,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC;IACrC,CAAC;IACD,OAAO,EAAE,GAAG,EAAE,GAAG,EAAE,CAAC;AACtB,CAAC;AAyBD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyDG;AACH,MAAM,UAAU,kBAAkB,CAChC,MAAwB;IAExB,MAAM,UAAU,GAAG,YAAY,CAAC,MAAM,CAAC,CAAC;IACxC,OAAO,UAAU,KAAK,SAAS,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,UAAU,EAAE,CAAC;AACxD,CAAC;AAED;;;;;;;;;;;;;GAaG;AACH,MAAM,UAAU,sBAAsB,CACpC,KAAc,EACd,KAAa;IAEb,IAAI,CAAC,uBAAuB,CAAC,EAAE,CAAC,KAAK,CAAC,EAAE,CAAC;QACvC,OAAO,IAAI,CAAC;IACd,CAAC;IACD,MAAM,OAAO,GAAG,KAAK,CAAC,OAAO,CAAC;IAC9B,IAAI,OAAO,OAAO,KAAK,QAAQ,IAAI,OAAO,KAAK,IAAI,EAAE,CAAC;QACpD,OAAO,IAAI,CAAC;IACd,CAAC;IACD,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,GAAG,OAAiD,CAAC;IAC7E,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,MAAM,CAAC,IAAI,MAAM,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;QAClD,OAAO,IAAI,CAAC;IACd,CAAC;IACD,KAAK,MAAM,KAAK,IAAI,MAAM,EAAE,CAAC;QAC3B,IACE,OAAO,KAAK,KAAK,QAAQ;YACzB,KAAK,KAAK,IAAI;YACd,OAAQ,KAA+B,CAAC,OAAO,KAAK,QAAQ;YAC3D,KAA6B,CAAC,KAAK,KAAK,KAAK,EAC9C,CAAC;YACD,OAAO,IAAI,CAAC;QACd,CAAC;IACH,CAAC;IACD,OAAO;QACL,MAAM,EAAE,MAAiB;QACzB,MAAM,EAAE,OAAO,MAAM,KAAK,QAAQ,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,IAAI;KACnD,CAAC;AACJ,CAAC;AAQD;;;GAGG;AACH,MAAM,yBAAyB,GAAG;IAChC,6BAA6B,EAAE,GAAG;IAClC,8BAA8B,EAAE,0BAA0B;IAC1D,8BAA8B,EAAE,cAAc;CAC/C,CAAC;AAEF;;;GAGG;AACH,MAAM,UAAU,eAAe,CAC7B,OAA4C,EAC5C,gBAAyB;IAEzB,OAAO,KAAK,EAAE,GAAY,EAAE,EAAE;QAC5B,MAAM,GAAG,GAAG,IAAI,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;QAC7B,MAAM,aAAa,GAAG,GAAG,CAAC,YAAY,CAAC,GAAG,CAAC,UAAU,CAAC,CAAC;QACvD,IAAI,aAAa,EAAE,CAAC;YAClB,yCAAyC;YACzC,IAAI,GAAG,CAAC,MAAM,KAAK,SAAS,EAAE,CAAC;gBAC7B,OAAO,IAAI,QAAQ,CAAC,IAAI,EAAE;oBACxB,MAAM,EAAE,GAAG;oBACX,OAAO,EAAE,yBAAyB;iBACnC,CAAC,CAAC;YACL,CAAC;YACD,OAAO,IAAI,QAAQ,CACjB,IAAI,CAAC,SAAS,CAAC;gBACb,OAAO,EAAE,IAAI;gBACb,QAAQ,EAAE,GAAG,CAAC,QAAQ;gBACtB,WAAW,EAAE,gBAAgB,IAAI,oBAAoB;gBACrD,mBAAmB;aACpB,CAAC,EACF;gBACE,MAAM,EAAE,GAAG;gBACX,OAAO,EAAE;oBACP,cAAc,EAAE,kBAAkB;oBAClC,GAAG,yBAAyB;iBAC7B;aACF,CACF,CAAC;QACJ,CAAC;QACD,OAAO,MAAM,OAAO,CAAC,GAAG,CAAC,CAAC;IAC5B,CAAC,CAAC;AACJ,CAAC;AAED;;;GAGG;AACH,MAAM,UAAU,aAAa,CAC3B,UAA8C,EAC9C,KAAa;IAEb,OAAO,UAAU,EAAE,CAAC,qBAAqB,CAAC,IAAI,KAAK,CAAC;AACtD,CAAC;AAED;;;;;GAKG;AACH,MAAM,UAAU,kBAAkB,CAChC,GAGC;IAED,OAAO;QACL,YAAY,EAAE,GAAG,CAAC,YAAY;QAC9B,WAAW,EAAE,GAAG,CAAC,WAAW,IAAI,CAAC;QACjC,GAAG,CAAC,GAAG,CAAC,SAAS,CAAC,CAAC,CAAC,EAAE,SAAS,EAAE,CAAC,GAAG,CAAC,SAAS,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;QACvD,SAAS,EAAE,aAAa,CAAC,GAAG,CAAC,UAAU,EAAE,GAAG,CAAC,KAAK,CAAC;KACpD,CAAC;AACJ,CAAC;AAED;8EAC8E;AAC9E,SAAS,UAAU,CAAC,KAAa;IAC/B,IAAI,IAAI,GAAG,UAAU,CAAC;IACtB,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,KAAK,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE,CAAC;QACtC,IAAI,IAAI,KAAK,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC;QAC5B,IAAI,GAAG,IAAI,CAAC,IAAI,CAAC,IAAI,EAAE,UAAU,CAAC,CAAC;IACrC,CAAC;IACD,OAAO,CAAC,IAAI,KAAK,CAAC,CAAC,CAAC,QAAQ,CAAC,EAAE,CAAC,CAAC,QAAQ,CAAC,CAAC,EAAE,GAAG,CAAC,CAAC;AACpD,CAAC;AAED;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,MAAM,UAAU,0BAA0B,CACxC,aAAqB,EACrB,QAAgB;IAEhB,OAAO,GAAG,aAAa,IAAI,UAAU,CAAC,QAAQ,CAAC,EAAE,CAAC;AACpD,CAAC;AAED;;GAEG;AACH,MAAM,CAAC,KAAK,UAAU,YAAY,CAChC,KAAY,EACZ,GAAG,IAAoC;IAEvC,MAAM,SAAS,GAAG,IAAI,CAAC,CAAC,CAAC,CAAC;IAC1B,MAAM,KAAK,CACT,eAAe,EACf;QACE,sCAAsC;QACtC,UAAU,EAAE;YACV,GAAG,SAAS,CAAC,eAAe,CAAC,cAAc,CAAC;YAC5C,GAAG,SAAS,CAAC,wBAAwB,CAAC,SAAS,CAAC;YAChD,GAAG,SAAS,CAAC,sBAAsB,CAAC,SAAS,CAAC;YAC9C,wCAAwC;YACxC,GAAG,SAAS,CAAC,WAAW,CAAC,cAAc,CAAC;YACxC,GAAG,SAAS,CAAC,SAAS,CAAC,cAAc,CAAC;YACtC,GAAG,SAAS,CAAC,UAAU,CAAC,KAAK,CAAC;YAC9B,GAAG,SAAS,CAAC,SAAS,CAAC,SAAS,CAAC;SAClC;QACD,IAAI,EAAE,MAAM,WAAW,CAAC,UAAU,CAAC;KACpC,EACD,KAAK,EAAE,IAAI,EAAE,EAAE;QACb,MAAM,EAAE,SAAS,EAAE,GAAG,MAAM,KAAK,CAAC,KAAK,CAAC,GAAG,IAAI,CAAC,CAAC;QACjD,IAAI,SAAS,EAAE,CAAC;YACd,IAAI,EAAE,aAAa,CAAC,SAAS,CAAC,kBAAkB,CAAC,SAAS,CAAC,CAAC,CAAC;QAC/D,CAAC;IACH,CAAC,CACF,CAAC;AACJ,CAAC;AAED;;;;;;;;;;GAUG;AACH,MAAM,CAAC,KAAK,UAAU,aAAa,CACjC,KAAY,EACZ,SAA4C,EAC5C,QAGG;IAEH,IAAI,QAAQ,CAAC,MAAM,KAAK,CAAC;QAAE,OAAO;IAClC,MAAM,KAAK,GAAG,KAAK,CAAC,UAAU,EAAE,IAAI,CAAC,KAAK,CAAC,CAAC;IAC5C,IAAI,CAAC,KAAK,EAAE,CAAC;QACX,MAAM,OAAO,CAAC,GAAG,CACf,QAAQ,CAAC,GAAG,CAAC,CAAC,KAAK,EAAE,EAAE,CACrB,YAAY,CAAC,KAAK,EAAE,SAAS,EAAE,KAAK,CAAC,OAAO,EAAE,KAAK,CAAC,IAAI,CAAC,CAC1D,CACF,CAAC;QACF,OAAO;IACT,CAAC;IACD,MAAM,KAAK,CACT,eAAe,EACf;QACE,UAAU,EAAE;YACV,GAAG,SAAS,CAAC,eAAe,CAAC,cAAc,CAAC;YAC5C,GAAG,SAAS,CAAC,wBAAwB,CAAC,SAAS,CAAC;YAChD,GAAG,SAAS,CAAC,sBAAsB,CAAC,SAAS,CAAC;YAC9C,GAAG,SAAS,CAAC,0BAA0B,CAAC,QAAQ,CAAC,MAAM,CAAC;YACxD,GAAG,SAAS,CAAC,WAAW,CAAC,cAAc,CAAC;YACxC,GAAG,SAAS,CAAC,SAAS,CAAC,cAAc,CAAC;YACtC,GAAG,SAAS,CAAC,UAAU,CAAC,KAAK,CAAC;YAC9B,GAAG,SAAS,CAAC,SAAS,CAAC,cAAc,CAAC;SACvC;QACD,IAAI,EAAE,MAAM,WAAW,CAAC,UAAU,CAAC;KACpC,EACD,KAAK,IAAI,EAAE;QACT,MAAM,OAAO,GAAG,MAAM,KAAK,CAAC,SAAS,EAAE,QAAQ,CAAC,CAAC;QACjD,oEAAoE;QACpE,sEAAsE;QACtE,mEAAmE;QACnE,iEAAiE;QACjE,sEAAsE;QACtE,kCAAkC;QAClC,IAAI,OAAO,CAAC,MAAM,KAAK,QAAQ,CAAC,MAAM,EAAE,CAAC;YACvC,MAAM,MAAM,CAAC,MAAM,CACjB,IAAI,KAAK,CACP,mBAAmB,SAAS,aAAa,OAAO,CAAC,MAAM,GAAG;gBACxD,iBAAiB,QAAQ,CAAC,MAAM,aAAa,CAChD,EACD,EAAE,SAAS,EAAE,IAAI,EAAE,CACpB,CAAC;QACJ,CAAC;QACD,MAAM,QAAQ,GAAG,OAAO,CAAC,MAAM,CAAC,CAAC,MAAM,EAAE,EAAE,CAAC,MAAM,CAAC,KAAK,KAAK,SAAS,CAAC,CAAC;QACxE,IAAI,QAAQ,CAAC,MAAM,KAAK,CAAC;YAAE,OAAO;QAClC,MAAM,SAAS,GAAG,QAAQ,CAAC,IAAI,CAC7B,CAAC,OAAO,EAAE,EAAE,CAAC,OAAO,CAAC,KAAK,KAAK,SAAS,IAAI,OAAO,CAAC,SAAS,CAC9D,CAAC;QACF,MAAM,KAAK,GAAG,IAAI,KAAK,CACrB,qBAAqB,QAAQ,CAAC,MAAM,OAAO,QAAQ,CAAC,MAAM,SAAS;YACjE,iBAAiB,SAAS,KAAK,QAAQ,CAAC,CAAC,CAAC,EAAE,KAAK,EAAE,CACtD,CAAC;QACF,sEAAsE;QACtE,uEAAuE;QACvE,mEAAmE;QACnE,oEAAoE;QACpE,yDAAyD;QACzD,+BAA+B;QAC/B,MAAM,CAAC,MAAM,CAAC,KAAK,EAAE,EAAE,SAAS,EAAE,CAAC,CAAC;QACpC,MAAM,KAAK,CAAC;IACd,CAAC,CACF,CAAC;AACJ,CAAC;AAED;;GAEG;AACH,MAAM,UAAU,gBAAgB,CAAC,OAA+B;IAC9D,IAAI,CAAC,OAAO,CAAC,WAAW;QAAE,OAAO;IACjC,IAAI,CAAC;QACH,OAAO,SAAS,CAAC,eAAe,CAC9B,IAAI,CAAC,GAAG,EAAE,GAAG,OAAO,CAAC,WAAW,CAAC,OAAO,EAAE,CAC3C,CAAC;IACJ,CAAC;IAAC,MAAM,CAAC;QACP,OAAO;IACT,CAAC;AACH,CAAC;AAED;;;;;GAKG;AACH,MAAM,CAAC,KAAK,UAAU,uBAAuB,CAC3C,KAAY,EACZ,OAA6B,EAC7B,OAAiC;IAEjC,MAAM,MAAM,GACV,OAAO,OAAO,KAAK,QAAQ;QACzB,CAAC,CAAC,MAAM,KAAK,CAAC,sBAAsB,EAAE,CAAC,OAAO,EAAE,OAAO,CAAC;QACxD,CAAC,CAAC,MAAM,KAAK,CAAC,sBAAsB,EAAE,CAAC,OAAO,CAAC,CAAC;IACpD,OAAO,MAAM,CAAC,CAAC,CAAC,MAAM,oBAAoB,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC;AACjE,CAAC;AAED;;;GAGG;AACH,MAAM,UAAU,oBAAoB,CAClC,KAAY,EACZ,OAA6B;IAE7B,IAAI,MAAmD,CAAC;IACxD,OAAO,GAAG,EAAE;QACV,IAAI,CAAC,MAAM,EAAE,CAAC;YACZ,MAAM,GAAG,uBAAuB,CAAC,KAAK,EAAE,OAAO,CAAC,CAAC;QACnD,CAAC;QACD,OAAO,MAAM,CAAC;IAChB,CAAC,CAAC;AACJ,CAAC","sourcesContent":["import {\n  PreconditionFailedError,\n  RUN_ERROR_CODES,\n  WorkflowWorldError,\n} from '@workflow/errors';\nimport type {\n  CreateEventParams,\n  CreateEventRequest,\n  Event,\n  EventResult,\n  HealthCheckPayload,\n  RunDispatchContext,\n  ValidQueueName,\n  WorkflowRun,\n  World,\n} from '@workflow/world';\nimport {\n  FIRST_EVENT_SLOT,\n  getQueueTopicPrefix,\n  HealthCheckPayloadSchema,\n  HOOK_RESUME_INPUT_VERSION,\n  ROOT_RUN_ID_ATTRIBUTE,\n  requireEventSlot,\n  resolveQueueNamespace,\n  SPEC_VERSION_CURRENT,\n  SPEC_VERSION_LEGACY,\n} from '@workflow/world';\nimport { monotonicFactory } from 'ulid';\nimport { runtimeLogger } from '../logger.js';\nimport { bytesToBase64, deriveRunKeyPair } from '../sealed-box.js';\nimport {\n  deriveRunPayloadKeys,\n  type PayloadKey,\n} from '../serialization/encryption.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(\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   * The target run's X25519 public key (base64), returned only when the probe\n   * carried a `runId` and the responding deployment has encryption enabled.\n   *\n   * Lets a cross-deployment `start()` seal the workflow arguments using a\n   * response it was already waiting on, instead of making a separate\n   * key-lookup request.\n   */\n  encryptionPublicKey?: string;\n  /**\n   * The responding deployment's `HOOK_RESUME_INPUT_VERSION`: the protocol\n   * version at which the *consumer* (queue-message target) materializes the\n   * `hook_received` event from `hookInput` on replay. A cross-deployment\n   * `start()` stamps the *target's* value (not the caller's) into the new\n   * run's `executionContext.hookResumeInputVersion`. Current producers write\n   * the event durably before publishing the wake and do not read the marker;\n   * OLDER producers still gate their lazy path on it, so it keeps being\n   * stamped. Omitted when the responding deployment predates this field,\n   * which fails that gate closed.\n   */\n  hookResumeInputVersion?: 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 */\nexport async function handleHealthCheckMessage(\n  healthCheck: HealthCheckPayload,\n  worldSpecVersion?: number\n): Promise<void> {\n  const world = await getWorldLazy();\n  const streamName = getHealthCheckStreamName(healthCheck.correlationId);\n\n  // When the probe names a run the caller is about to create, publish that\n  // run's public key. We are executing inside the target deployment, so its\n  // key material is available locally (no API call), and the caller can then\n  // seal the workflow arguments straight from this response rather than\n  // making a separate key-lookup request.\n  //\n  // Only a *public* key may travel this way: the probe response stream is\n  // deliberately unauthenticated, so anything secret would be exposed.\n  // Best-effort: a failure here must not fail the health check itself, which\n  // callers also rely on for plain capability detection.\n  let encryptionPublicKey: string | undefined;\n  if (healthCheck.runId) {\n    try {\n      const rawKey = await world.getEncryptionKeyForRun?.(healthCheck.runId);\n      if (rawKey) {\n        encryptionPublicKey = bytesToBase64(\n          (await deriveRunKeyPair(rawKey)).publicKey\n        );\n      }\n    } catch (err) {\n      runtimeLogger.warn(\n        'Health check could not derive a run public key; the caller will fall back to a key lookup',\n        {\n          correlationId: healthCheck.correlationId,\n          error: err instanceof Error ? err.message : String(err),\n        }\n      );\n    }\n  }\n\n  const response = JSON.stringify({\n    healthy: true,\n    correlationId: healthCheck.correlationId,\n    specVersion: worldSpecVersion ?? SPEC_VERSION_CURRENT,\n    workflowCoreVersion,\n    // We are executing inside the target deployment, so this constant reflects\n    // the *consumer's* hook-resume protocol version, exactly what a\n    // cross-deployment caller needs to gate its parallel resume path on.\n    hookResumeInputVersion: HOOK_RESUME_INPUT_VERSION,\n    ...(encryptionPublicKey ? { encryptionPublicKey } : {}),\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 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   * The run id the caller is about to create. When set, the responding\n   * deployment derives that run's public key locally and returns it as\n   * `encryptionPublicKey`, letting a cross-deployment `start()` seal the\n   * workflow arguments without a separate key lookup.\n   */\n  runId?: string;\n  /**\n   * Queue namespace of the target deployment (e.g. `'eve'` for topics like\n   * `__eve_wkf_workflow_*`). Falls back to `WORKFLOW_QUEUE_NAMESPACE` in the\n   * calling process. Cross-context callers (e.g. the observability\n   * dashboard) must pass the target deployment's namespace explicitly:\n   * the env fallback resolves in the caller's process, and a message\n   * published to a mismatched topic has no consumer, so the check would\n   * always time out.\n   */\n  namespace?: 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 combined workflow 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 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 */\n/**\n * Race a promise against a deadline. Rejects with a timeout error when the\n * deadline elapses first. Used to bound `world.streams.get()` inside the\n * health-check poll loop: some worlds hold that request open until the\n * stream has data (e.g. workflow-server holds unwritten streams open for\n * ~2 minutes), which would otherwise blow through the configured health\n * check timeout, since the `while` condition is only re-checked between\n * iterations.\n */\nfunction withDeadline<T>(promise: Promise<T>, ms: number): Promise<T> {\n  let timer: ReturnType<typeof setTimeout> | undefined;\n  return Promise.race([\n    promise,\n    new Promise<never>((_, reject) => {\n      timer = setTimeout(\n        () => reject(new Error(`Operation timed out after ${ms}ms`)),\n        ms\n      );\n    }),\n  ]).finally(() => clearTimeout(timer));\n}\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  encryptionPublicKey?: 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    encryptionPublicKey?: string;\n    hookResumeInputVersion?: number;\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  if (typeof r.encryptionPublicKey === 'string') {\n    parsed.encryptionPublicKey = r.encryptionPublicKey;\n  }\n  if (typeof r.hookResumeInputVersion === 'number') {\n    parsed.hookResumeInputVersion = r.hookResumeInputVersion;\n  }\n  return parsed;\n}\n\nexport async function healthCheck(\n  world: World,\n  options?: HealthCheckOptions\n): Promise<HealthCheckResult> {\n  const timeout = options?.timeout ?? DEFAULT_HEALTH_CHECK_TIMEOUT;\n  // Use the world's ID generator when available so the correlationId is a\n  // region-tagged ULID. The health-check response is delivered over a stream\n  // whose name embeds this correlationId; under platform-directed routing the\n  // reader and the responding endpoint can be served from different physical\n  // regions, so the region must be encoded in the ID itself for both sides to\n  // resolve the same (region-pinned) backend. Falls back to a plain ULID for\n  // worlds that don't tag IDs (e.g. local), which resolve to the default\n  // region on both sides.\n  const correlationId = world.createRunId?.() ?? generateId();\n  const streamName = getHealthCheckStreamName(correlationId);\n\n  const queueName =\n    `${getQueueTopicPrefix('workflow', resolveQueueNamespace(options?.namespace))}health_check` as ValidQueueName;\n\n  const startTime = Date.now();\n\n  try {\n    await world.queue(\n      queueName,\n      {\n        __healthCheck: true,\n        correlationId,\n        ...(options?.runId ? { runId: options.runId } : {}),\n      },\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 remainingMs = timeout - (Date.now() - startTime);\n        const stream = await withDeadline(\n          world.streams.get(\n            generateHealthCheckRunId(correlationId),\n            streamName\n          ),\n          remainingMs\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\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 recordRequestedEventCursor(\n  runId: string,\n  cursor: string | null,\n  requestedCursors: Set<string>\n): void {\n  if (!cursor) {\n    return;\n  }\n  if (requestedCursors.has(cursor)) {\n    throw eventPaginationContractError(runId, 'did not advance');\n  }\n  requestedCursors.add(cursor);\n}\n\n/**\n * Appends events whose IDs are not already present in `target`.\n *\n * Pass the IDs currently present in `target` when appending repeatedly to the\n * same array. The set is updated alongside `target`.\n *\n * Events are appended in the order the World returned them, and are not\n * re-sorted. Every append source is already in canonical order relative to the\n * tail (a cursor-delimited page, or a write-response delta), so receipt order is\n * the order to keep, and re-sorting here would only cost a pass over the log.\n * Nothing downstream may assume the tail is the newest event. See\n * {@link maxEventSlot}.\n */\nexport function appendUniqueEvents(\n  target: Event[],\n  events: readonly Event[],\n  targetIds?: Set<string>\n): void {\n  if (events.length === 0) {\n    return;\n  }\n\n  const ids = targetIds ?? new Set(target.map((event) => event.eventId));\n  for (const event of events) {\n    if (ids.has(event.eventId)) {\n      continue;\n    }\n    ids.add(event.eventId);\n    target.push(event);\n  }\n}\n\n/**\n * Inserts `event` into `target` at the position that keeps `target` ordered by\n * ascending `eventId`, or no-ops if an event with the same `eventId` is already\n * present (idempotent).\n *\n * `preloadedEvents` is loaded `sortOrder: 'asc'` and is never re-sorted\n * client-side, so a `hook_received` spliced in by the lazy-resume consumer must\n * land in `eventId` order: a plain `push` would place a late-committing\n * earlier event after events that sort before it, corrupting replay.\n *\n * Lexicographic string order is the log's order: a slot id is a fixed-width\n * zero-padded position, so comparing the strings compares the positions. This\n * needs no parse of its own for that reason, and the comparison is exact rather\n * than a reconstruction.\n */\nexport function insertEventByEventId(target: Event[], event: Event): void {\n  // Linear scan from the end: the spliced event is almost always the newest\n  // (it sorts at or near the tail), so this finds the slot in O(1)–O(k) for the\n  // common case while still handling an out-of-order late arrival correctly.\n  let i = target.length;\n  while (i > 0) {\n    const existing = target[i - 1];\n    if (existing.eventId === event.eventId) {\n      // Already present: keep the splice idempotent.\n      return;\n    }\n    if (existing.eventId < event.eventId) {\n      break;\n    }\n    i--;\n  }\n  target.splice(i, 0, event);\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\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<LoadedEventLog> {\n  const incremental = afterCursor !== undefined;\n  return trace('workflow.replay.load', async (span) => {\n    span?.setAttributes({\n      ...Attribute.WorkflowRunId(runId),\n      ...Attribute.WorkflowReplayLoadSource(\n        incremental ? 'events_list_incremental' : 'events_list'\n      ),\n    });\n\n    const loadedEvents: Event[] = [];\n    const loadedEventIds = new Set<string>();\n    const requestedCursors = new Set<string>();\n    let cursor: string | null = afterCursor ?? null;\n    let hasMore = true;\n    let pagesLoaded = 0;\n    let retriedWithoutCursor = false;\n    const world = await getWorldLazy();\n    const loadStart = Date.now();\n    while (hasMore) {\n      // TODO: we're currently loading all the data with resolveRef behavior. 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 = cursor;\n      recordRequestedEventCursor(runId, requestedCursor, requestedCursors);\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',\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          loadedEvents.length = 0;\n          loadedEventIds.clear();\n          requestedCursors.clear();\n          cursor = null;\n          retriedWithoutCursor = true;\n          continue;\n        }\n        throw error;\n      }\n\n      appendUniqueEvents(loadedEvents, response.data, loadedEventIds);\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 DB query hit the limit exactly and returned a\n      // precautionary `LastEvaluatedKey`. 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 * The runtime's loaded event-log snapshot: the events replayed so far and the\n * cursor positioned after them. Handed to helpers that derive the precondition\n * snapshot from it; they do not mutate it.\n */\nexport interface LoadedEventLog {\n  events: Event[];\n  cursor: string | null;\n}\n\n/**\n * Extend a loaded log with a page that continues it — a listed page, or the\n * inline delta a write handed back — and move its read position with it.\n *\n * The cursor is only advanced when the page carries one, so a source with no\n * position of its own (a skipped-slot report) cannot walk the read position\n * past events it did not carry. Appending does not re-sort; see\n * {@link appendUniqueEvents} for why receipt order is the order to keep.\n */\nexport function appendEventLog(\n  log: LoadedEventLog,\n  appended: { events: readonly Event[]; cursor?: string | null }\n): void {\n  appendUniqueEvents(log.events, appended.events);\n  log.cursor = appended.cursor ?? log.cursor;\n}\n\n/**\n * Whether a replay refuses to run over a log with a hole in it (see\n * {@link findEventSlotGap}). **On by default**; set\n * `WORKFLOW_SLOT_GAP_CHECK=0` to replay across holes instead.\n *\n * A World that allocates a position at the moment it commits leaves no hole\n * behind when a write fails, so density is a property the log has by\n * construction rather than one this check maintains. What the check is for is\n * the reads and the Worlds where that does not hold, and by the time it runs\n * the benign explanations are spent: a position missing because a concurrent\n * commit is not visible yet clears on a re-read, which is what\n * {@link settleEventSlotGap} does first.\n *\n * What is left is a hole that persists, and its two causes are\n * indistinguishable from the log. Either a World allocated the position outside\n * the commit and lost the write, in which case nothing happened there and\n * replaying past it is correct, or an event that did happen is missing, in\n * which case replaying past it decides a branch on absence and produces a wrong\n * result with nothing to show for it. Failing is the recoverable side of that\n * trade, and this is the way back out if a fleet turns out to carry holes of\n * the first kind.\n */\nexport function isSlotGapCheckEnabled(): boolean {\n  return process.env.WORKFLOW_SLOT_GAP_CHECK !== '0';\n}\n\n/*\n * Merging into a log a replay is midway through reading.\n *\n * Three paths add events to a loaded log after the replay has started: a\n * bump-and-report write hands back the slots it skipped ({@link\n * mergeReportedEvents}), an inline delta extends the tail (`absorbCreateDelta`\n * in `runtime.ts`), and a listed page appends ({@link appendUniqueEvents}).\n * They look alarming (the replay is reading an array while something else\n * writes to it) and they are safe for one reason worth stating plainly, since\n * every correctness argument in this file leans on it.\n *\n * **An event in the log is a fact, and a longer log cannot retract one.** The\n * log is append-only and positions are never reused, so a replay that produced\n * event E from the prefix it had loaded has made E true for every replay that\n * follows. A later replay reading a fuller log does not get to decide E should\n * not be there; it consumes E and reconciles to it, which is what the events\n * consumer does when it walks a log holding writes from a replay that raced it.\n *\n * Merging is therefore monotone: it can only add facts this replay has yet to\n * reconcile to, never remove one it already has. That is why absorbing is\n * always optional and never wrong to decline (an unabsorbed event is one the\n * next read returns), and why the guards below can afford to be strict.\n */\n\n/**\n * Merge the events a bump-and-report write handed back into the log it was\n * derived from, and answer how many of them were new.\n *\n * Unlike {@link appendUniqueEvents}, this re-sorts. The reported events occupy\n * slots *below* the write that reported them, so appending them would put them\n * after events they precede. Sorting by id restores the World's canonical order\n * rather than guessing at it: a slot id is that order, written down.\n */\nexport function mergeReportedEvents(\n  target: Event[],\n  events: readonly Event[]\n): number {\n  const before = target.length;\n  appendUniqueEvents(target, events);\n  const added = target.length - before;\n  if (added > 0) {\n    target.sort((a, b) =>\n      a.eventId < b.eventId ? -1 : a.eventId > b.eventId ? 1 : 0\n    );\n  }\n  return added;\n}\n\n/** What {@link absorbSkippedSlotReport} did with a write's report. */\nexport interface SkippedSlotReport {\n  /** How many of the reported events were new to the log. Zero if dropped. */\n  added: number;\n  /** How many events the report offered, whether or not they were taken. */\n  offered: number;\n  /** The report was truncated, so it was dropped whole instead of merged. */\n  truncated: boolean;\n}\n\n/**\n * Apply a write's skipped-slot report to the log it was derived from, deciding\n * whether the report may be taken at all.\n *\n * Every replay-context write can come back carrying the events on the slots it\n * skipped over, and every caller wants the same thing from them: fold them in\n * so the writes that follow name a position above them, and so the replay\n * resuming from this log sees them without a reload.\n *\n * The one policy is that a **truncated report is dropped whole**. It covers a\n * span of positions but carries only some of the events on them, so merging it\n * would raise the log's highest position past a position whose event is\n * missing. Later writes read that maximum to say what they have seen, so each\n * would claim a position it never saw, and the World only reports the span a\n * write skips: it would never send the missing one. Dropping costs one more\n * round of the same events on the next write and keeps the log a prefix of the\n * truth, which the note above {@link mergeReportedEvents} explains is always an\n * available answer.\n *\n * Callers that log do so from the returned counts; the decision is not theirs\n * to re-derive.\n */\nexport function absorbSkippedSlotReport(\n  target: Event[],\n  result: { events?: readonly Event[]; hasMore?: boolean }\n): SkippedSlotReport {\n  const offered = result.events?.length ?? 0;\n  if (offered === 0) {\n    return { added: 0, offered: 0, truncated: false };\n  }\n  if (result.hasMore === true) {\n    return { added: 0, offered, truncated: true };\n  }\n  return {\n    added: mergeReportedEvents(target, result.events ?? []),\n    offered,\n    truncated: false,\n  };\n}\n\n/**\n * The highest slot the loaded log occupies, or `undefined` for an empty log.\n *\n * The maximum, not the count, and the two are not interchangeable even though\n * a healthy log makes them equal. A World hands a position to the insert that\n * occupies it, so a write that never lands leaves no hole behind and the log\n * stays dense. What the count cannot survive is a *partial* read: a log\n * assembled from a truncated report, or read while a concurrent write is\n * committing, holds fewer events than its highest position. Counting those\n * would make the next write claim to have seen less than it has, so the World\n * would report the same events back to it on every attempt.\n *\n * A hole below the maximum is therefore a property of the read, not of the log,\n * which is what lets {@link settleEventSlotGap} re-read instead of giving up.\n *\n * @throws if any event id carries no slot. Every World the runtime replays\n * against numbers events by slot, so an id that does not is a broken log rather\n * than an older one, and a maximum derived by skipping it would understate the\n * log to every write that reads it.\n */\nexport function maxEventSlot(events: readonly Event[]): number | undefined {\n  let max: number | undefined;\n  for (const event of events) {\n    const slot = requireEventSlot(event.eventId);\n    if (max === undefined || slot > max) {\n      max = slot;\n    }\n  }\n  return max;\n}\n\n/** A position the log skips over, described well enough to name in an error. */\nexport interface EventSlotGap {\n  /** The lowest slot below the log's maximum that no event occupies. */\n  firstMissingSlot: number;\n  /** How many slots below the maximum no event occupies. */\n  missingCount: number;\n  /** The highest slot the log occupies. */\n  maxSlot: number;\n}\n\n/**\n * The hole in a loaded log, or `undefined` when there is none to find.\n *\n * The World allocates every position, so a log that holds `n` events below slot\n * `n` is missing one. That matters before a replay\n * and nowhere else: the replay reads the log as the complete record of what has\n * happened, and an absent position is indistinguishable from an event that\n * never occurred. The branch it would have decided gets decided the other way,\n * and the run diverges quietly rather than failing.\n *\n * Order-independent, unlike the equivalent audit the World runs over a page it\n * just read. A loaded log is assembled from listed pages plus whatever a\n * bump-and-report write handed back, and while {@link mergeReportedEvents}\n * restores id order, a check that can fail a healthy run should not depend on\n * that having happened.\n *\n * The first slot is never counted. It belongs to `run_created`, which `start()`\n * posts concurrently with the queue send, so a log read in that window\n * legitimately begins at the second slot and fills in on its own. Every replay\n * that races a run's own start would otherwise report a hole.\n *\n * Returns `undefined` for an empty log, which has no density to check.\n *\n * @throws if any event id carries no slot, for the reason {@link maxEventSlot}\n * gives.\n */\nexport function findEventSlotGap(\n  events: readonly Event[]\n): EventSlotGap | undefined {\n  const occupied = new Set<number>();\n  let maxSlot = 0;\n  for (const event of events) {\n    const slot = requireEventSlot(event.eventId);\n    occupied.add(slot);\n    if (slot > maxSlot) {\n      maxSlot = slot;\n    }\n  }\n  if (maxSlot === 0) {\n    return undefined;\n  }\n  const floor = occupied.has(FIRST_EVENT_SLOT)\n    ? FIRST_EVENT_SLOT\n    : FIRST_EVENT_SLOT + 1;\n  // Every slot is at or above `floor` by construction, so the log is dense\n  // exactly when it holds one event per position in `[floor, maxSlot]`. The\n  // scan below only runs once that has already answered no.\n  if (occupied.size === maxSlot - floor + 1) {\n    return undefined;\n  }\n  let firstMissingSlot: number | undefined;\n  let missingCount = 0;\n  for (let slot = floor; slot <= maxSlot; slot++) {\n    if (!occupied.has(slot)) {\n      firstMissingSlot ??= slot;\n      missingCount++;\n    }\n  }\n  if (firstMissingSlot === undefined) {\n    return undefined;\n  }\n  return { firstMissingSlot, missingCount, maxSlot };\n}\n\n/**\n * How many times a detected hole is re-read before the log is taken at its\n * word, and the backoff before each re-read (doubling per attempt).\n *\n * A hole can be transient. The World allocates a slot inside the insert that\n * occupies it, so two concurrent writers can collide, one retry past the other,\n * and the higher slot commit first, leaving a window in which the lower one is\n * genuinely absent from a strongly-consistent read and fills in a moment later.\n * The window is one commit wide, so a short backoff clears it; anything that\n * survives all three re-reads is a position no write will ever occupy.\n */\nexport const SLOT_GAP_RECHECK_ATTEMPTS = 3;\nconst SLOT_GAP_RECHECK_BASE_DELAY_MS = 25;\n\n/**\n * Re-read a log that looks holey until the hole fills in or the re-reads run\n * out, and return the settled log alongside the hole that survived.\n *\n * Reads are strongly consistent, so a hole is not an artifact of *when* the log\n * was read, but it can be an artifact of a write that had not committed yet\n * (see {@link SLOT_GAP_RECHECK_ATTEMPTS}). Distinguishing the two costs a\n * re-read, which is only ever paid by a replay that already found a hole.\n *\n * The reload is full rather than incremental: the missing position is below the\n * log's maximum, so a cursor-anchored read starts past it and can never see it\n * arrive.\n */\nexport async function settleEventSlotGap(\n  runId: string,\n  loaded: LoadedEventLog\n): Promise<{ log: LoadedEventLog; gap: EventSlotGap | undefined }> {\n  let log = loaded;\n  let gap = findEventSlotGap(log.events);\n  for (\n    let attempt = 0;\n    gap !== undefined && attempt < SLOT_GAP_RECHECK_ATTEMPTS;\n    attempt++\n  ) {\n    await new Promise((resolve) =>\n      setTimeout(resolve, SLOT_GAP_RECHECK_BASE_DELAY_MS * 2 ** attempt)\n    );\n    log = await loadWorkflowRunEvents(runId);\n    gap = findEventSlotGap(log.events);\n  }\n  return { log, gap };\n}\n\n/**\n * How much of its run's log a replay-context event creation had loaded when it\n * decided to write, as the highest slot that log occupies.\n *\n * One integer says it because the World keeps its positions dense: a writer\n * that names slot N is claiming to hold every event from 1 to N and nothing\n * above. The World answers by numbering the write above whatever the log has\n * actually reached and handing back the events on the slots in between: the\n * ones this writer decided without.\n *\n * Density is the World's invariant, not a claim about this particular read. A\n * reader that is short of a position it holds no event for names a lower N,\n * which understates what it has seen and only costs it a wider report. Naming\n * a position it cannot account for is the direction that is unsafe, which is\n * why {@link slotSnapshotParams} takes the maximum rather than the count.\n *\n * Its own object rather than a bare number so a call site cannot half-send it,\n * and so the empty case spreads to nothing.\n */\nexport interface SlotSnapshotParams {\n  eventCount?: number;\n}\n\n/**\n * Build the slot snapshot to attach to a replay-context event creation.\n *\n * Empty for an empty log, which is the state a `run_created` write is issued\n * from: there is no position held yet to name.\n *\n * ## Who names a position\n *\n * A World can hand events back on a write's success response through two\n * params (`CreateEventParams` in `@workflow/world`): `eventCount`, which is\n * answered with the events on the positions the write skipped over (the\n * skipped-slot report), and `sinceCursor`, which is answered with everything\n * after that cursor (the inline delta). Both exist to save the writer a\n * reload. So the rule for which writes send them is not about the event type;\n * it is about whether **the process that writes holds a loaded log it will\n * keep deciding from**, its own next writes or the replay it resumes. A writer\n * with no log has nothing to merge a page into, and whoever decides next is a\n * fresh replay that loads the log anyway.\n *\n * Three gates, all of which must pass for a page to come back:\n *\n * 1. The writer names a position. Only the replay loop's `createEvent` seam\n *    (runtime.ts) and the suspension handler's `createGuarded` do; the QuickJS\n *    engine's `createEvent` (quickjs-entrypoint.ts) follows the same rule. Raw\n *    `world.events.create` calls send nothing.\n * 2. The World reads a page for that event type. A World may decline for types\n *    whose writer never holds a log (step executor writes, run-terminal\n *    writes), whatever the client sent.\n * 3. There is something to hand back: the report only when the write landed\n *    more than one position above `eventCount`; the delta always.\n *\n * | Event | Writer | Sends | Why |\n * |---|---|---|---|\n * | `run_created` | `start()` | nothing | no log exists yet |\n * | `run_started` | replay loop, first write of a delivery | `eventCount` when a log is loaded; no cursor, the `run_started` preload owns the response fields | the preload already returns the full log |\n * | `step_created`, `wait_created`, `hook_disposed`, `attr_set` | suspension handler (`createGuarded`) | `eventCount` | the handler keeps writing from, and resumes replay from, this log |\n * | `step_created` | queue-consumer re-ensure (raw) | nothing | runs from a queue message, no log |\n * | `hook_created` | suspension handler (node), `dispatchPendingOps` (QuickJS) | `eventCount` + `sinceCursor` (only when the suspension creates exactly one hook) | the delta is how an already-received hook resolves without a re-invocation; two creates against one cursor would give two deltas of which only the first could be taken |\n * | `hook_received` | replay loop lazy resume; handler in-suspension resume | `eventCount` (preload owns the cursor fields) | both replay from the log right after |\n * | `hook_received` | webhook / `resumeHook` (raw) | nothing | out-of-band, enqueues a delivery that loads the log |\n * | `wait_completed` | replay loop timer path | `eventCount` | the loop keeps replaying from the log |\n * | `wait_completed` | `runs.*` out-of-band (raw) | nothing | no log |\n * | `step_started`, `step_retrying` | step executor | nothing | no log; the next decision is a replay that reloads or receives the delta below |\n * | `step_completed`, `step_failed` | step executor | `sinceCursor` only, outside turbo, single inline step | this is where the inline execution loop gets its log back; in turbo or from a queued delivery a fresh replay loads it anyway |\n * | `step_failed` | suspension handler, unserializable input | `eventCount` | the handler holds a log; rare, and follows a `step_created` that drew the page |\n * | `attr_set` | `setAttributes()` API (raw) | nothing | out-of-band |\n * | `run_completed`, `run_failed`, `run_cancelled` | replay loop, replay budget, `runs.cancel` | `eventCount` where the node loop's seam stamps it (the QuickJS engine sends nothing); never `sinceCursor` (`deltaRequestCursor` excludes terminal types) | terminal: nothing replays the log afterwards, so a World reads no page for them |\n *\n * Batched writes (`events.createBatch`) are outside all of this: a batch carries\n * no per-event position and gets no page. The user-facing version of this table\n * is in `docs/content/docs/v5/how-it-works/event-sourcing.mdx`; keep the two in\n * step.\n *\n * The maximum rather than the length, for the reason {@link maxEventSlot}\n * gives: a partially-read log holds fewer events than its highest position, and\n * counting those would make the write claim to have seen less than it has, so\n * the World would report the same events back on every attempt.\n */\nexport function slotSnapshotParams(\n  events: readonly Event[]\n): SlotSnapshotParams {\n  const eventCount = maxEventSlot(events);\n  return eventCount === undefined ? {} : { eventCount };\n}\n\n/**\n * The events a rejecting World attached to a `PreconditionFailedError`, when it\n * returned the ones the client's snapshot was missing inline.\n *\n * Returns `null` for anything else: no details, a World that did not implement\n * this, or a payload that does not narrow cleanly. Callers fall back to\n * reloading the event log, which is always correct; this is untrusted-shaped\n * data on a failure path, so nothing here is repaired.\n *\n * `runId` is the caller's run. Every event must belong to it: the delta is\n * merged straight into the replay's log, and one foreign event there is a\n * corrupt log rather than a corrected one: the replay would consume a\n * correlation id for an event that does not exist on this run.\n */\nexport function preconditionEventDelta(\n  error: unknown,\n  runId: string\n): { events: Event[]; cursor: string | null } | null {\n  if (!PreconditionFailedError.is(error)) {\n    return null;\n  }\n  const details = error.details;\n  if (typeof details !== 'object' || details === null) {\n    return null;\n  }\n  const { events, cursor } = details as { events?: unknown; cursor?: unknown };\n  if (!Array.isArray(events) || events.length === 0) {\n    return null;\n  }\n  for (const event of events) {\n    if (\n      typeof event !== 'object' ||\n      event === null ||\n      typeof (event as { eventId?: unknown }).eventId !== 'string' ||\n      (event as { runId?: unknown }).runId !== runId\n    ) {\n      return null;\n    }\n  }\n  return {\n    events: events as Event[],\n    cursor: typeof cursor === 'string' ? cursor : null,\n  };\n}\n\n/** Creates one event on a bound run, carrying replay-recovery telemetry. */\nexport type EventCreator = (\n  data: CreateEventRequest,\n  params?: CreateEventParams\n) => Promise<EventResult>;\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 * The lineage root of a loaded run: its `$rootRunId` attribute, or its own id\n * when it is itself a root.\n */\nexport function rootRunIdFrom(\n  attributes: Record<string, string> | undefined,\n  runId: string\n): string {\n  return attributes?.[ROOT_RUN_ID_ATTRIBUTE] ?? runId;\n}\n\n/**\n * The immutable run identity a step-execution message carries so its consumer\n * can start the step without a blocking `runs.get` — see\n * `RunDispatchContextSchema` in @workflow/world. Built at dispatch time from\n * the run row the producer already holds.\n */\nexport function runDispatchContext(\n  run: Pick<\n    WorkflowRun,\n    'runId' | 'deploymentId' | 'specVersion' | 'startedAt' | 'attributes'\n  >\n): RunDispatchContext {\n  return {\n    deploymentId: run.deploymentId,\n    specVersion: run.specVersion ?? 0,\n    ...(run.startedAt ? { startedAt: +run.startedAt } : {}),\n    rootRunId: rootRunIdFrom(run.attributes, run.runId),\n  };\n}\n\n/** FNV-1a 32-bit hash of a string, as 8 hex chars. Tiny, deterministic, and\n *  dependency-free. Used only to scope idempotency keys, not for security. */\nfunction fnv1a32Hex(value: string): string {\n  let hash = 0x811c9dc5;\n  for (let i = 0; i < value.length; i++) {\n    hash ^= value.charCodeAt(i);\n    hash = Math.imul(hash, 0x01000193);\n  }\n  return (hash >>> 0).toString(16).padStart(8, '0');\n}\n\n/**\n * Idempotency key for a step's background-dispatch queue message, scoped to\n * the step's IDENTITY, correlation id plus (hashed) step name, rather than\n * the bare correlation id.\n *\n * The scoping matters for resilient step dispatch under the precondition\n * guard: a guard-rejected `step_created` leaves its (revoked) step message in\n * flight, and the corrected replay may re-derive the same correlation id for\n * a DIFFERENT step. Under a bare-correlationId key the corrected replay's\n * dispatch would silently dedupe against the revoked in-flight message,\n * which then resolves `skipped` against the re-created entity (the server's\n * stepName fence rejects its bare start), and the legitimate step would\n * never be executed. Scoping by step name keeps every dedup property that\n * matters (crash recovery re-dispatch, concurrent handlers, the delayed\n * retry sharing the suspension re-dispatch's key: all name the same step)\n * while letting the corrected schedule's dispatch through.\n *\n * Every producer of a step-dispatch (or step-retry) message must use this\n * key. Cross-version mixing is not a concern: queue messages are pinned to\n * the deployment that produced them, so one run never sees two key schemes.\n */\nexport function stepDispatchIdempotencyKey(\n  correlationId: string,\n  stepName: string\n): string {\n  return `${correlationId}:${fnv1a32Hex(stepName)}`;\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 * Publishes several messages to one logical queue, using the World's batch\n * send when it has one and falling back to concurrent single sends when it\n * does not.\n *\n * Rejects if ANY message failed to publish, because every caller so far wants\n * all-or-nothing: the recovery is to fail the delivery and let redelivery\n * republish the whole set, deduped by the per-message `idempotencyKey`. That\n * means a partial batch can leave some messages already out — which is\n * exactly why the keys are required rather than advisory.\n */\nexport async function queueMessages(\n  world: World,\n  queueName: Parameters<typeof world.queue>[0],\n  messages: readonly {\n    message: Parameters<typeof world.queue>[1];\n    opts?: Parameters<typeof world.queue>[2];\n  }[]\n): Promise<void> {\n  if (messages.length === 0) return;\n  const batch = world.queueBatch?.bind(world);\n  if (!batch) {\n    await Promise.all(\n      messages.map((entry) =>\n        queueMessage(world, queueName, entry.message, entry.opts)\n      )\n    );\n    return;\n  }\n  await trace(\n    'queue.publish',\n    {\n      attributes: {\n        ...Attribute.MessagingSystem('vercel-queue'),\n        ...Attribute.MessagingDestinationName(queueName),\n        ...Attribute.MessagingOperationType('publish'),\n        ...Attribute.MessagingBatchMessageCount(messages.length),\n        ...Attribute.PeerService('vercel-queue'),\n        ...Attribute.RpcSystem('vercel-queue'),\n        ...Attribute.RpcService('vqs'),\n        ...Attribute.RpcMethod('publishBatch'),\n      },\n      kind: await getSpanKind('PRODUCER'),\n    },\n    async () => {\n      const results = await batch(queueName, messages);\n      // A World that answers with the wrong number of results has told us\n      // nothing about the messages it left out. Treated as a failure of the\n      // whole batch rather than read as success for the entries that ARE\n      // present: republishing under the same idempotency keys is safe,\n      // silently never dispatching a step is not (the run makes no progress\n      // and nothing surfaces an error).\n      if (results.length !== messages.length) {\n        throw Object.assign(\n          new Error(\n            `Queue batch for ${queueName} returned ${results.length} ` +\n              `result(s) for ${messages.length} message(s)`\n          ),\n          { retryable: true }\n        );\n      }\n      const failures = results.filter((result) => result.error !== undefined);\n      if (failures.length === 0) return;\n      const retryable = failures.some(\n        (failure) => failure.error !== undefined && failure.retryable\n      );\n      const error = new Error(\n        `Failed to publish ${failures.length} of ${messages.length} queue ` +\n          `message(s) to ${queueName}: ${failures[0]?.error}`\n      );\n      // Carried on the error so a caller CAN tell a transient partial batch\n      // from a permanent rejection. Nothing reads it yet: today every caller\n      // rejects the delivery either way, so a permanently rejected entry\n      // still costs the full redelivery budget. Left in place because the\n      // information is only available here, and a fast-fail on\n      // `retryable: false` needs it.\n      Object.assign(error, { retryable });\n      throw error;\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 * Resolve the run's full payload-encryption capability. This includes the\n * symmetric key and X25519 keypair needed to open cross-run sealed payloads.\n * Missing world support or key material resolves to `undefined`; lookup and\n * derivation failures propagate rather than silently falling back to plaintext.\n */\nexport async function resolveRunEncryptionKey(\n  world: World,\n  runOrId: WorkflowRun | string,\n  context?: Record<string, unknown>\n): Promise<PayloadKey | undefined> {\n  const rawKey =\n    typeof runOrId === 'string'\n      ? await world.getEncryptionKeyForRun?.(runOrId, context)\n      : await world.getEncryptionKeyForRun?.(runOrId);\n  return rawKey ? await deriveRunPayloadKeys(rawKey) : undefined;\n}\n\n/**\n * Return a lazy, memoized accessor around {@link resolveRunEncryptionKey}.\n * Concurrent callers share the same promise, including its rejection.\n */\nexport function memoizeEncryptionKey(\n  world: World,\n  runOrId: WorkflowRun | string\n): () => Promise<PayloadKey | undefined> {\n  let cached: Promise<PayloadKey | undefined> | undefined;\n  return () => {\n    if (!cached) {\n      cached = resolveRunEncryptionKey(world, runOrId);\n    }\n    return cached;\n  };\n}\n"]}