@workflow/core 5.0.0-beta.43 → 5.0.0-beta.44

package/dist/runtime/deployment-guard.d.ts

@@ -11,7 +11,7 @@ export type DeploymentAffinityOutcome =
 /** Misrouted and out of budget (or unroutable); `run_failed` recorded. */
  | 'failed';
 /**
- * `spanAttributes` is present only on a misrouted delivery — mismatches are
+ * `spanAttributes` is present only on a misrouted delivery: mismatches are
  * rare, so the presence of `workflow.deployment.pinned_id` on a span *is* the
  * signal that one happened, and `recovered` separates the ones a re-route fixed
  * from the ones that kept misrouting.
@@ -22,7 +22,7 @@ export interface DeploymentAffinityResult {
 }
 /**
  * Arguments handed to a call site's re-enqueue closure. The guard owns the
- * policy — counting, backoff, logging, telemetry, escalation — and the call
+ * policy (counting, backoff, logging, telemetry, escalation) and the call
  * site owns only the shape of the message it needs to put back on the queue.
  */
 export interface ReenqueueArgs {
@@ -42,9 +42,9 @@ export interface ReenqueueArgs {
  * Guards deployment affinity: a run may only execute on the deployment it is
  * pinned to.
  *
- * A run's `deploymentId` is fixed when it starts — the deployment that called
+ * A run's `deploymentId` is fixed when it starts: the deployment that called
  * `start()`, or whatever `start({ deploymentId })` resolved to (an explicit id
- * or `'latest'`) — and no replay or step execution may happen anywhere else:
+ * or `'latest'`). No replay or step execution may happen anywhere else:
  * the bundles here may not match the run's persisted history, and any step
  * dispatched from here derives the per-run encryption key from the wrong
  * deployment's master key, which surfaces as a `RuntimeDecryptionError` the
@@ -58,8 +58,8 @@ export interface ReenqueueArgs {
  * spent, mirroring how a replay divergence gets bounded recovery replays before
  * being recorded as a corrupted event log.
  *
- * Callers must pass a run entity they already have in hand — every call site
- * loads the run for other reasons — so the guard costs no extra round trip.
+ * Callers must pass a run entity they already have in hand (every call site
+ * loads the run for other reasons), so the guard costs no extra round trip.
  * (`world.getDeploymentId()` reads the ambient deployment id, e.g.
  * `VERCEL_DEPLOYMENT_ID`, and does not call the backend either.)
  *
@@ -92,7 +92,7 @@ export declare function guardDeploymentAffinity({ world, run, requestId, retryCo
      * Ordering barrier awaited once a mismatch is confirmed, before either
      * stopping action. Under turbo the `run_started` write is backgrounded, and
      * both outcomes hand the run off (to a `run_failed` here, or to the pinned
-     * deployment's own `run_started`) — so that write must have landed first.
+     * deployment's own `run_started`), so that write must have landed first.
      */
     beforeStop?: () => Promise<void>;
 }): Promise<DeploymentAffinityResult>;

package/dist/runtime/deployment-guard.js

@@ -26,9 +26,9 @@ function result(outcome, pinnedDeploymentId, attempts) {
  * Guards deployment affinity: a run may only execute on the deployment it is
  * pinned to.
  *
- * A run's `deploymentId` is fixed when it starts — the deployment that called
+ * A run's `deploymentId` is fixed when it starts: the deployment that called
  * `start()`, or whatever `start({ deploymentId })` resolved to (an explicit id
- * or `'latest'`) — and no replay or step execution may happen anywhere else:
+ * or `'latest'`). No replay or step execution may happen anywhere else:
  * the bundles here may not match the run's persisted history, and any step
  * dispatched from here derives the per-run encryption key from the wrong
  * deployment's master key, which surfaces as a `RuntimeDecryptionError` the
@@ -42,8 +42,8 @@ function result(outcome, pinnedDeploymentId, attempts) {
  * spent, mirroring how a replay divergence gets bounded recovery replays before
  * being recorded as a corrupted event log.
  *
- * Callers must pass a run entity they already have in hand — every call site
- * loads the run for other reasons — so the guard costs no extra round trip.
+ * Callers must pass a run entity they already have in hand (every call site
+ * loads the run for other reasons), so the guard costs no extra round trip.
  * (`world.getDeploymentId()` reads the ambient deployment id, e.g.
  * `VERCEL_DEPLOYMENT_ID`, and does not call the backend either.)
  *
@@ -99,7 +99,7 @@ export async function guardDeploymentAffinity({ world, run, requestId, retryCoun
         }
         catch (failError) {
             // Run already reached a terminal state (a concurrent writer failed it, or
-            // it was cancelled/expired) — still stop. Anything else is a transient
+            // it was canceled/expired), so still stop. Anything else is a transient
             // persistence failure: rethrow so the queue redelivers and we try again.
             if (!EntityConflictError.is(failError) &&
                 !RunExpiredError.is(failError)) {
@@ -110,7 +110,7 @@ export async function guardDeploymentAffinity({ world, run, requestId, retryCoun
     };
     if (reenqueue && retryCount < maxRetries) {
         const attempt = retryCount + 1;
-        // Exponential, capped: 1s, 2s, 4s — cheap insurance against a hot
+        // Exponential, capped: 1s, 2s, 4s. Cheap insurance against a hot
         // re-enqueue loop, and time for a mid-flight routing change to settle.
         const delaySeconds = Math.min(2 ** retryCount, MAX_REROUTE_DELAY_SECONDS);
         try {
@@ -130,7 +130,7 @@ export async function guardDeploymentAffinity({ world, run, requestId, retryCoun
             if (!isDeploymentUnavailableError?.(reenqueueError)) {
                 throw reenqueueError;
             }
-            // The World explicitly classified the target as unavailable — deleted,
+            // The World explicitly classified the target as unavailable: deleted,
             // aged out of its retention window, or otherwise undiscoverable. Burning
             // the rest of the budget on a deployment that provably cannot be reached
             // only delays the failure, so fail now.
@@ -151,4 +151,4 @@ export async function guardDeploymentAffinity({ world, run, requestId, retryCoun
         : 'Workflow run received by a deployment it is not pinned to; failing the run', logContext);
     return failRun(retryCount);
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"deployment-guard.js","sourceRoot":"","sources":["../../src/runtime/deployment-guard.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  EntityConflictError,\n  RUN_ERROR_CODES,\n  RunExpiredError,\n  WorkflowDeploymentMismatchError,\n} from '@workflow/errors';\nimport {\n  SPEC_VERSION_CURRENT,\n  SPEC_VERSION_SUPPORTS_COMPRESSION,\n  type WorkflowRun,\n  type World,\n} from '@workflow/world';\nimport { runtimeLogger } from '../logger.js';\nimport { dehydrateRunError } from '../serialization.js';\nimport * as Attribute from '../telemetry/semantic-conventions.js';\nimport { getDeploymentMismatchMaxRetries } from './constants.js';\n\n/** Cap on the re-route backoff, in seconds. */\nconst MAX_REROUTE_DELAY_SECONDS = 8;\n\n/**\n * How the guard resolved a delivery. Both non-`continue` outcomes mean the\n * caller must ack the message and return without executing anything.\n */\nexport type DeploymentAffinityOutcome =\n  /** The run belongs here (or this world has no deployment affinity). */\n  | 'continue'\n  /** Misrouted; re-enqueued at the run's own deployment. */\n  | 'rerouted'\n  /** Misrouted and out of budget (or unroutable); `run_failed` recorded. */\n  | 'failed';\n\n/**\n * `spanAttributes` is present only on a misrouted delivery — mismatches are\n * rare, so the presence of `workflow.deployment.pinned_id` on a span *is* the\n * signal that one happened, and `recovered` separates the ones a re-route fixed\n * from the ones that kept misrouting.\n */\nexport interface DeploymentAffinityResult {\n  outcome: DeploymentAffinityOutcome;\n  spanAttributes?: Record<string, string | number | boolean>;\n}\n\n/** The common case, allocation-free. */\nconst CONTINUE: DeploymentAffinityResult = { outcome: 'continue' };\n\n/**\n * Builds a stopping result. `attempts` is the re-route count *including* this\n * invocation's own attempt, so the span attribute reads as \"attempts so far\".\n */\nfunction result(\n  outcome: 'rerouted' | 'failed',\n  pinnedDeploymentId: string,\n  attempts: number\n): DeploymentAffinityResult {\n  return {\n    outcome,\n    spanAttributes: {\n      ...Attribute.WorkflowRunPinnedDeploymentId(pinnedDeploymentId),\n      ...Attribute.WorkflowDeploymentMismatchRetryCount(attempts),\n      ...Attribute.WorkflowDeploymentMismatchRecovered(outcome === 'rerouted'),\n    },\n  };\n}\n\n/**\n * Arguments handed to a call site's re-enqueue closure. The guard owns the\n * policy — counting, backoff, logging, telemetry, escalation — and the call\n * site owns only the shape of the message it needs to put back on the queue.\n */\nexport interface ReenqueueArgs {\n  /** The deployment to target: the one the run is pinned to. */\n  deploymentId: string;\n  /**\n   * The run's spec version, so the world picks the right queue transport\n   * (CBOR vs JSON). Undefined on legacy runs that predate the field; worlds\n   * then fall back to their current default.\n   */\n  specVersion: number | undefined;\n  deploymentMismatchRetryCount: number;\n  /** Backoff before the re-routed message becomes visible. */\n  delaySeconds: number;\n}\n\n/**\n * Guards deployment affinity: a run may only execute on the deployment it is\n * pinned to.\n *\n * A run's `deploymentId` is fixed when it starts — the deployment that called\n * `start()`, or whatever `start({ deploymentId })` resolved to (an explicit id\n * or `'latest'`) — and no replay or step execution may happen anywhere else:\n * the bundles here may not match the run's persisted history, and any step\n * dispatched from here derives the per-run encryption key from the wrong\n * deployment's master key, which surfaces as a `RuntimeDecryptionError` the\n * queue retry callback swallows into a blank \"exceeded max retries\".\n *\n * A misrouted delivery is not treated as permanent. Rather than failing\n * immediately, re-enqueue the message *explicitly targeted* at the run's own\n * deployment; that send is strictly better-addressed than the one that\n * misrouted, which inherited the producing deployment's ambient id. Fail only\n * once the budget (`WORKFLOW_DEPLOYMENT_MISMATCH_MAX_RETRIES`, default 3) is\n * spent, mirroring how a replay divergence gets bounded recovery replays before\n * being recorded as a corrupted event log.\n *\n * Callers must pass a run entity they already have in hand — every call site\n * loads the run for other reasons — so the guard costs no extra round trip.\n * (`world.getDeploymentId()` reads the ambient deployment id, e.g.\n * `VERCEL_DEPLOYMENT_ID`, and does not call the backend either.)\n *\n * The failure is recorded **without resolving the run's encryption key**: the\n * key is fetched from the pinned deployment's API, often unavailable once that\n * deployment is past its retention window, so depending on it would throw here\n * instead of recording the failure. The payload is written unencrypted (it\n * holds only deployment ids, nothing sensitive), and the plaintext `errorCode`\n * is the signal observability and the UI key off.\n */\nexport async function guardDeploymentAffinity({\n  world,\n  run,\n  requestId,\n  retryCount = 0,\n  reenqueue,\n  isDeploymentUnavailableError,\n  beforeStop,\n}: {\n  world: World;\n  run: Pick<WorkflowRun, 'runId' | 'deploymentId' | 'specVersion'>;\n  requestId?: string;\n  /** `deploymentMismatchRetryCount` from the incoming message, if any. */\n  retryCount?: number;\n  /**\n   * Puts this delivery's message back on the queue, targeted at the run's own\n   * deployment. Omitted by callers that cannot reconstruct their message, which\n   * makes the guard fail-fast.\n   */\n  reenqueue?: (args: ReenqueueArgs) => Promise<void>;\n  /**\n   * Classifies a re-enqueue failure as definitive proof that the pinned\n   * deployment cannot receive the message. Unclassified failures are retried\n   * by rejecting the handler and leaving the current queue message unacked.\n   */\n  isDeploymentUnavailableError?: (error: unknown) => boolean;\n  /**\n   * Ordering barrier awaited once a mismatch is confirmed, before either\n   * stopping action. Under turbo the `run_started` write is backgrounded, and\n   * both outcomes hand the run off (to a `run_failed` here, or to the pinned\n   * deployment's own `run_started`) — so that write must have landed first.\n   */\n  beforeStop?: () => Promise<void>;\n}): Promise<DeploymentAffinityResult> {\n  // Deployment affinity is only meaningful in worlds whose deployments are\n  // atomic and immutable, which the World declares (world-vercel does) and\n  // capabilities default to unsupported. Local and self-hosted worlds report a\n  // synthetic deployment id (e.g. `dpl_local@<sdk-version>`) that legitimately\n  // differs across SDK versions within one logical environment, so guarding\n  // them would fail ordinary local runs after a version bump.\n  if (world.capabilities?.deploymentAffinity !== true) {\n    return CONTINUE;\n  }\n\n  const currentDeploymentId = await world.getDeploymentId();\n  if (run.deploymentId === currentDeploymentId) {\n    return CONTINUE;\n  }\n\n  await beforeStop?.();\n\n  const maxRetries = getDeploymentMismatchMaxRetries();\n  const logContext = {\n    workflowRunId: run.runId,\n    pinnedDeploymentId: run.deploymentId,\n    actualDeploymentId: currentDeploymentId,\n    retryCount,\n    maxRetries,\n  };\n\n  /**\n   * Records the terminal `run_failed`. Mirrors `recordFatalRunError`: it\n   * records and returns rather than throwing, so the caller acks the message\n   * instead of letting the queue redeliver a run that is now terminal.\n   */\n  const failRun = async (\n    recoveryAttempts: number,\n    cause?: unknown\n  ): Promise<DeploymentAffinityResult> => {\n    const error = new WorkflowDeploymentMismatchError(\n      run.runId,\n      run.deploymentId,\n      currentDeploymentId,\n      { recoveryAttempts, cause }\n    );\n\n    try {\n      await world.events.create(\n        run.runId,\n        {\n          eventType: 'run_failed',\n          specVersion: SPEC_VERSION_CURRENT,\n          eventData: {\n            // Unencrypted (undefined key): see the note on\n            // `guardDeploymentAffinity`. dehydrate/hydrate are self-describing,\n            // so this reads back without a key.\n            error: await dehydrateRunError(\n              error,\n              run.runId,\n              undefined,\n              undefined,\n              (run.specVersion ?? 0) >= SPEC_VERSION_SUPPORTS_COMPRESSION\n            ),\n            errorCode: RUN_ERROR_CODES.DEPLOYMENT_MISMATCH,\n          },\n        },\n        { requestId }\n      );\n    } catch (failError) {\n      // Run already reached a terminal state (a concurrent writer failed it, or\n      // it was cancelled/expired) — still stop. Anything else is a transient\n      // persistence failure: rethrow so the queue redelivers and we try again.\n      if (\n        !EntityConflictError.is(failError) &&\n        !RunExpiredError.is(failError)\n      ) {\n        throw failError;\n      }\n    }\n    return result('failed', run.deploymentId, recoveryAttempts);\n  };\n\n  if (reenqueue && retryCount < maxRetries) {\n    const attempt = retryCount + 1;\n    // Exponential, capped: 1s, 2s, 4s — cheap insurance against a hot\n    // re-enqueue loop, and time for a mid-flight routing change to settle.\n    const delaySeconds = Math.min(2 ** retryCount, MAX_REROUTE_DELAY_SECONDS);\n    try {\n      await reenqueue({\n        deploymentId: run.deploymentId,\n        specVersion: run.specVersion,\n        deploymentMismatchRetryCount: attempt,\n        delaySeconds,\n      });\n      runtimeLogger.warn(\n        'Workflow run received by a deployment it is not pinned to; re-routing to its own deployment',\n        { ...logContext, attempt, delaySeconds }\n      );\n      return result('rerouted', run.deploymentId, attempt);\n    } catch (reenqueueError) {\n      // A generic send failure can be transient (429, 5xx, connect/DNS). Do not\n      // turn one infrastructure blip into a terminal run failure: reject the\n      // handler so the current message remains unacked and is redelivered.\n      if (!isDeploymentUnavailableError?.(reenqueueError)) {\n        throw reenqueueError;\n      }\n\n      // The World explicitly classified the target as unavailable — deleted,\n      // aged out of its retention window, or otherwise undiscoverable. Burning\n      // the rest of the budget on a deployment that provably cannot be reached\n      // only delays the failure, so fail now.\n      runtimeLogger.error(\n        'Cannot re-route a misrouted workflow run to its own deployment; failing the run',\n        {\n          ...logContext,\n          attempt,\n          errorMessage:\n            reenqueueError instanceof Error\n              ? reenqueueError.message\n              : String(reenqueueError),\n        }\n      );\n      // Recovery never actually happened, so report 0 attempts and let `cause`\n      // explain why.\n      return failRun(0, reenqueueError);\n    }\n  }\n\n  runtimeLogger.error(\n    retryCount > 0\n      ? 'Workflow run kept arriving at a deployment it is not pinned to after re-routing; failing the run'\n      : 'Workflow run received by a deployment it is not pinned to; failing the run',\n    logContext\n  );\n  return failRun(retryCount);\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"deployment-guard.js","sourceRoot":"","sources":["../../src/runtime/deployment-guard.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  EntityConflictError,\n  RUN_ERROR_CODES,\n  RunExpiredError,\n  WorkflowDeploymentMismatchError,\n} from '@workflow/errors';\nimport {\n  SPEC_VERSION_CURRENT,\n  SPEC_VERSION_SUPPORTS_COMPRESSION,\n  type WorkflowRun,\n  type World,\n} from '@workflow/world';\nimport { runtimeLogger } from '../logger.js';\nimport { dehydrateRunError } from '../serialization.js';\nimport * as Attribute from '../telemetry/semantic-conventions.js';\nimport { getDeploymentMismatchMaxRetries } from './constants.js';\n\n/** Cap on the re-route backoff, in seconds. */\nconst MAX_REROUTE_DELAY_SECONDS = 8;\n\n/**\n * How the guard resolved a delivery. Both non-`continue` outcomes mean the\n * caller must ack the message and return without executing anything.\n */\nexport type DeploymentAffinityOutcome =\n  /** The run belongs here (or this world has no deployment affinity). */\n  | 'continue'\n  /** Misrouted; re-enqueued at the run's own deployment. */\n  | 'rerouted'\n  /** Misrouted and out of budget (or unroutable); `run_failed` recorded. */\n  | 'failed';\n\n/**\n * `spanAttributes` is present only on a misrouted delivery: mismatches are\n * rare, so the presence of `workflow.deployment.pinned_id` on a span *is* the\n * signal that one happened, and `recovered` separates the ones a re-route fixed\n * from the ones that kept misrouting.\n */\nexport interface DeploymentAffinityResult {\n  outcome: DeploymentAffinityOutcome;\n  spanAttributes?: Record<string, string | number | boolean>;\n}\n\n/** The common case, allocation-free. */\nconst CONTINUE: DeploymentAffinityResult = { outcome: 'continue' };\n\n/**\n * Builds a stopping result. `attempts` is the re-route count *including* this\n * invocation's own attempt, so the span attribute reads as \"attempts so far\".\n */\nfunction result(\n  outcome: 'rerouted' | 'failed',\n  pinnedDeploymentId: string,\n  attempts: number\n): DeploymentAffinityResult {\n  return {\n    outcome,\n    spanAttributes: {\n      ...Attribute.WorkflowRunPinnedDeploymentId(pinnedDeploymentId),\n      ...Attribute.WorkflowDeploymentMismatchRetryCount(attempts),\n      ...Attribute.WorkflowDeploymentMismatchRecovered(outcome === 'rerouted'),\n    },\n  };\n}\n\n/**\n * Arguments handed to a call site's re-enqueue closure. The guard owns the\n * policy (counting, backoff, logging, telemetry, escalation) and the call\n * site owns only the shape of the message it needs to put back on the queue.\n */\nexport interface ReenqueueArgs {\n  /** The deployment to target: the one the run is pinned to. */\n  deploymentId: string;\n  /**\n   * The run's spec version, so the world picks the right queue transport\n   * (CBOR vs JSON). Undefined on legacy runs that predate the field; worlds\n   * then fall back to their current default.\n   */\n  specVersion: number | undefined;\n  deploymentMismatchRetryCount: number;\n  /** Backoff before the re-routed message becomes visible. */\n  delaySeconds: number;\n}\n\n/**\n * Guards deployment affinity: a run may only execute on the deployment it is\n * pinned to.\n *\n * A run's `deploymentId` is fixed when it starts: the deployment that called\n * `start()`, or whatever `start({ deploymentId })` resolved to (an explicit id\n * or `'latest'`). No replay or step execution may happen anywhere else:\n * the bundles here may not match the run's persisted history, and any step\n * dispatched from here derives the per-run encryption key from the wrong\n * deployment's master key, which surfaces as a `RuntimeDecryptionError` the\n * queue retry callback swallows into a blank \"exceeded max retries\".\n *\n * A misrouted delivery is not treated as permanent. Rather than failing\n * immediately, re-enqueue the message *explicitly targeted* at the run's own\n * deployment; that send is strictly better-addressed than the one that\n * misrouted, which inherited the producing deployment's ambient id. Fail only\n * once the budget (`WORKFLOW_DEPLOYMENT_MISMATCH_MAX_RETRIES`, default 3) is\n * spent, mirroring how a replay divergence gets bounded recovery replays before\n * being recorded as a corrupted event log.\n *\n * Callers must pass a run entity they already have in hand (every call site\n * loads the run for other reasons), so the guard costs no extra round trip.\n * (`world.getDeploymentId()` reads the ambient deployment id, e.g.\n * `VERCEL_DEPLOYMENT_ID`, and does not call the backend either.)\n *\n * The failure is recorded **without resolving the run's encryption key**: the\n * key is fetched from the pinned deployment's API, often unavailable once that\n * deployment is past its retention window, so depending on it would throw here\n * instead of recording the failure. The payload is written unencrypted (it\n * holds only deployment ids, nothing sensitive), and the plaintext `errorCode`\n * is the signal observability and the UI key off.\n */\nexport async function guardDeploymentAffinity({\n  world,\n  run,\n  requestId,\n  retryCount = 0,\n  reenqueue,\n  isDeploymentUnavailableError,\n  beforeStop,\n}: {\n  world: World;\n  run: Pick<WorkflowRun, 'runId' | 'deploymentId' | 'specVersion'>;\n  requestId?: string;\n  /** `deploymentMismatchRetryCount` from the incoming message, if any. */\n  retryCount?: number;\n  /**\n   * Puts this delivery's message back on the queue, targeted at the run's own\n   * deployment. Omitted by callers that cannot reconstruct their message, which\n   * makes the guard fail-fast.\n   */\n  reenqueue?: (args: ReenqueueArgs) => Promise<void>;\n  /**\n   * Classifies a re-enqueue failure as definitive proof that the pinned\n   * deployment cannot receive the message. Unclassified failures are retried\n   * by rejecting the handler and leaving the current queue message unacked.\n   */\n  isDeploymentUnavailableError?: (error: unknown) => boolean;\n  /**\n   * Ordering barrier awaited once a mismatch is confirmed, before either\n   * stopping action. Under turbo the `run_started` write is backgrounded, and\n   * both outcomes hand the run off (to a `run_failed` here, or to the pinned\n   * deployment's own `run_started`), so that write must have landed first.\n   */\n  beforeStop?: () => Promise<void>;\n}): Promise<DeploymentAffinityResult> {\n  // Deployment affinity is only meaningful in worlds whose deployments are\n  // atomic and immutable, which the World declares (world-vercel does) and\n  // capabilities default to unsupported. Local and self-hosted worlds report a\n  // synthetic deployment id (e.g. `dpl_local@<sdk-version>`) that legitimately\n  // differs across SDK versions within one logical environment, so guarding\n  // them would fail ordinary local runs after a version bump.\n  if (world.capabilities?.deploymentAffinity !== true) {\n    return CONTINUE;\n  }\n\n  const currentDeploymentId = await world.getDeploymentId();\n  if (run.deploymentId === currentDeploymentId) {\n    return CONTINUE;\n  }\n\n  await beforeStop?.();\n\n  const maxRetries = getDeploymentMismatchMaxRetries();\n  const logContext = {\n    workflowRunId: run.runId,\n    pinnedDeploymentId: run.deploymentId,\n    actualDeploymentId: currentDeploymentId,\n    retryCount,\n    maxRetries,\n  };\n\n  /**\n   * Records the terminal `run_failed`. Mirrors `recordFatalRunError`: it\n   * records and returns rather than throwing, so the caller acks the message\n   * instead of letting the queue redeliver a run that is now terminal.\n   */\n  const failRun = async (\n    recoveryAttempts: number,\n    cause?: unknown\n  ): Promise<DeploymentAffinityResult> => {\n    const error = new WorkflowDeploymentMismatchError(\n      run.runId,\n      run.deploymentId,\n      currentDeploymentId,\n      { recoveryAttempts, cause }\n    );\n\n    try {\n      await world.events.create(\n        run.runId,\n        {\n          eventType: 'run_failed',\n          specVersion: SPEC_VERSION_CURRENT,\n          eventData: {\n            // Unencrypted (undefined key): see the note on\n            // `guardDeploymentAffinity`. dehydrate/hydrate are self-describing,\n            // so this reads back without a key.\n            error: await dehydrateRunError(\n              error,\n              run.runId,\n              undefined,\n              undefined,\n              (run.specVersion ?? 0) >= SPEC_VERSION_SUPPORTS_COMPRESSION\n            ),\n            errorCode: RUN_ERROR_CODES.DEPLOYMENT_MISMATCH,\n          },\n        },\n        { requestId }\n      );\n    } catch (failError) {\n      // Run already reached a terminal state (a concurrent writer failed it, or\n      // it was canceled/expired), so still stop. Anything else is a transient\n      // persistence failure: rethrow so the queue redelivers and we try again.\n      if (\n        !EntityConflictError.is(failError) &&\n        !RunExpiredError.is(failError)\n      ) {\n        throw failError;\n      }\n    }\n    return result('failed', run.deploymentId, recoveryAttempts);\n  };\n\n  if (reenqueue && retryCount < maxRetries) {\n    const attempt = retryCount + 1;\n    // Exponential, capped: 1s, 2s, 4s. Cheap insurance against a hot\n    // re-enqueue loop, and time for a mid-flight routing change to settle.\n    const delaySeconds = Math.min(2 ** retryCount, MAX_REROUTE_DELAY_SECONDS);\n    try {\n      await reenqueue({\n        deploymentId: run.deploymentId,\n        specVersion: run.specVersion,\n        deploymentMismatchRetryCount: attempt,\n        delaySeconds,\n      });\n      runtimeLogger.warn(\n        'Workflow run received by a deployment it is not pinned to; re-routing to its own deployment',\n        { ...logContext, attempt, delaySeconds }\n      );\n      return result('rerouted', run.deploymentId, attempt);\n    } catch (reenqueueError) {\n      // A generic send failure can be transient (429, 5xx, connect/DNS). Do not\n      // turn one infrastructure blip into a terminal run failure: reject the\n      // handler so the current message remains unacked and is redelivered.\n      if (!isDeploymentUnavailableError?.(reenqueueError)) {\n        throw reenqueueError;\n      }\n\n      // The World explicitly classified the target as unavailable: deleted,\n      // aged out of its retention window, or otherwise undiscoverable. Burning\n      // the rest of the budget on a deployment that provably cannot be reached\n      // only delays the failure, so fail now.\n      runtimeLogger.error(\n        'Cannot re-route a misrouted workflow run to its own deployment; failing the run',\n        {\n          ...logContext,\n          attempt,\n          errorMessage:\n            reenqueueError instanceof Error\n              ? reenqueueError.message\n              : String(reenqueueError),\n        }\n      );\n      // Recovery never actually happened, so report 0 attempts and let `cause`\n      // explain why.\n      return failRun(0, reenqueueError);\n    }\n  }\n\n  runtimeLogger.error(\n    retryCount > 0\n      ? 'Workflow run kept arriving at a deployment it is not pinned to after re-routing; failing the run'\n      : 'Workflow run received by a deployment it is not pinned to; failing the run',\n    logContext\n  );\n  return failRun(retryCount);\n}\n"]}

package/dist/runtime/get-port-lazy.d.ts

@@ -10,9 +10,9 @@ export declare function getPortLazy(): Promise<number | undefined>;
 /**
  * Resets the per-process port cache. Intended for tests; not used on the hot
  * path. Callers must let any in-flight lookup settle (await the pending
- * `getPortLazy()` call) before resetting: clearing `_inFlight` here does not
+ * `getPortLazy()` call) before resetting: clearing `portState.inFlight` here does not
  * cancel an already-scheduled resolution, so a late `.then` could otherwise
- * repopulate `_cachedPort` after the reset and bleed into the next test.
+ * repopulate `portState.cachedPort` after the reset and bleed into the next test.
  */
 export declare function resetPortCacheForTesting(): void;
 /**

package/dist/runtime/get-port-lazy.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"get-port-lazy.d.ts","sourceRoot":"","sources":["../../src/runtime/get-port-lazy.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAuBH,wBAAsB,WAAW,IAAI,OAAO,CAAC,MAAM,GAAG,SAAS,CAAC,CA4C/D;AAED;;;;;;GAMG;AACH,wBAAgB,wBAAwB,IAAI,IAAI,CAI/C;AAED;;;;;GAKG;AACH,wBAAgB,yBAAyB,CACvC,EAAE,EAAE,MAAM,OAAO,CAAC,MAAM,GAAG,SAAS,CAAC,GACpC,IAAI,CAIN"}
+{"version":3,"file":"get-port-lazy.d.ts","sourceRoot":"","sources":["../../src/runtime/get-port-lazy.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AA8BH,wBAAsB,WAAW,IAAI,OAAO,CAAC,MAAM,GAAG,SAAS,CAAC,CA4C/D;AAED;;;;;;GAMG;AACH,wBAAgB,wBAAwB,IAAI,IAAI,CAI/C;AAED;;;;;GAKG;AACH,wBAAgB,yBAAyB,CACvC,EAAE,EAAE,MAAM,OAAO,CAAC,MAAM,GAAG,SAAS,CAAC,GACpC,IAAI,CAIN"}

package/dist/runtime/get-port-lazy.js

@@ -8,32 +8,39 @@
  */
 import { createRequire } from 'node:module';
 import { pathToFileURL } from 'node:url';
-let _getPort;
+import { globalSingleton } from '@workflow/utils';
+// All three live on `globalThis` (see `globalSingleton`) rather than at module
+// scope. The resolved port is a fact about the process, not about one copy of
+// this module, and per-copy caches would each pay the ~60ms `lsof` discovery
+// and could each pin their own answer.
+const portState = globalSingleton('@workflow/core//devServerPort', 1, () => ({
+    getPort: undefined,
+    cachedPort: undefined,
+    inFlight: undefined,
+}));
 // Per-process cache of the resolved port. The workflow server listens on a
 // stable port for the lifetime of the process, but `getPort()` rediscovers it
-// on every call by querying the OS for the process's listening sockets — on
+// on every call by querying the OS for the process's listening sockets. On
 // macOS that shells out to `lsof` (~60ms), which the runtime pays on EVERY
 // workflow replay or step invocation. Since the port does not change within a
-// process, resolve it once and reuse it. `_inFlight`
+// process, resolve it once and reuse it. `portState.inFlight`
 // dedupes concurrent first calls so discovery never runs more than once.
 //
-// The first concrete port is pinned for the lifetime of the process — there is
+// The first concrete port is pinned for the lifetime of the process: there is
 // no per-call re-resolution. This is safe because the runtime only runs inside
 // the already-listening dev-server process, and `getPort()` -> `getAllPorts()`
 // returns a deterministic order, so repeated calls would resolve the same port
 // anyway.
-let _cachedPort;
-let _inFlight;
 export async function getPortLazy() {
     // Fast path: already resolved a concrete port for this process.
-    if (_cachedPort !== undefined) {
-        return _cachedPort;
+    if (portState.cachedPort !== undefined) {
+        return portState.cachedPort;
     }
-    // A discovery is already running — share it rather than starting a second.
-    if (_inFlight) {
-        return _inFlight;
+    // A discovery is already running, so share it rather than starting a second.
+    if (portState.inFlight) {
+        return portState.inFlight;
     }
-    if (!_getPort) {
+    if (!portState.getPort) {
         try {
             // Construct specifier at runtime to defeat bundler static analysis.
             const spec = ['@workflow/utils', 'get-port'].join('/');
@@ -41,42 +48,42 @@ export async function getPortLazy() {
             // import.meta.url is unavailable in CJS re-bundled outputs.
             const _require = createRequire(pathToFileURL(process.cwd() + '/package.json').href);
             const mod = _require(spec);
-            _getPort = mod.getPort;
+            portState.getPort = mod.getPort;
         }
         catch {
             // Module not available (e.g., in a browser or minimal bundle)
-            _getPort = async () => undefined;
+            portState.getPort = async () => undefined;
         }
     }
-    // `_getPort` is always assigned by the block above; the fallback keeps the
+    // `portState.getPort` is always assigned by the block above; the fallback keeps the
     // type non-nullable without a non-null assertion.
-    const resolver = _getPort ?? (async () => undefined);
-    _inFlight = resolver()
+    const resolver = portState.getPort ?? (async () => undefined);
+    portState.inFlight = resolver()
         .then((port) => {
         // Only cache a concrete port. A transient `undefined` (e.g. the server is
-        // not listening yet on the very first replay) must not poison the cache —
+        // not listening yet on the first replay) must not poison the cache:
         // leaving it unset lets the next call retry discovery.
         if (typeof port === 'number') {
-            _cachedPort = port;
+            portState.cachedPort = port;
         }
         return port;
     })
         .finally(() => {
-        _inFlight = undefined;
+        portState.inFlight = undefined;
     });
-    return _inFlight;
+    return portState.inFlight;
 }
 /**
  * Resets the per-process port cache. Intended for tests; not used on the hot
  * path. Callers must let any in-flight lookup settle (await the pending
- * `getPortLazy()` call) before resetting: clearing `_inFlight` here does not
+ * `getPortLazy()` call) before resetting: clearing `portState.inFlight` here does not
  * cancel an already-scheduled resolution, so a late `.then` could otherwise
- * repopulate `_cachedPort` after the reset and bleed into the next test.
+ * repopulate `portState.cachedPort` after the reset and bleed into the next test.
  */
 export function resetPortCacheForTesting() {
-    _getPort = undefined;
-    _cachedPort = undefined;
-    _inFlight = undefined;
+    portState.getPort = undefined;
+    portState.cachedPort = undefined;
+    portState.inFlight = undefined;
 }
 /**
  * Installs a fake port resolver and clears the cache. Test-only seam: the real
@@ -85,8 +92,8 @@ export function resetPortCacheForTesting() {
  * the only deterministic way to exercise the caching contract.
  */
 export function setPortResolverForTesting(fn) {
-    _getPort = fn;
-    _cachedPort = undefined;
-    _inFlight = undefined;
+    portState.getPort = fn;
+    portState.cachedPort = undefined;
+    portState.inFlight = undefined;
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"get-port-lazy.js","sourceRoot":"","sources":["../../src/runtime/get-port-lazy.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AAC5C,OAAO,EAAE,aAAa,EAAE,MAAM,UAAU,CAAC;AACzC,OAAO,EAAE,eAAe,EAAE,MAAM,iBAAiB,CAAC;AAElD,+EAA+E;AAC/E,8EAA8E;AAC9E,6EAA6E;AAC7E,uCAAuC;AACvC,MAAM,SAAS,GAAG,eAAe,CAAC,+BAA+B,EAAE,CAAC,EAAE,GAAG,EAAE,CAAC,CAAC;IAC3E,OAAO,EAAE,SAA4D;IACrE,UAAU,EAAE,SAA+B;IAC3C,QAAQ,EAAE,SAAoD;CAC/D,CAAC,CAAC,CAAC;AAEJ,2EAA2E;AAC3E,8EAA8E;AAC9E,2EAA2E;AAC3E,2EAA2E;AAC3E,8EAA8E;AAC9E,8DAA8D;AAC9D,yEAAyE;AACzE,EAAE;AACF,8EAA8E;AAC9E,+EAA+E;AAC/E,+EAA+E;AAC/E,+EAA+E;AAC/E,UAAU;AAEV,MAAM,CAAC,KAAK,UAAU,WAAW;IAC/B,gEAAgE;IAChE,IAAI,SAAS,CAAC,UAAU,KAAK,SAAS,EAAE,CAAC;QACvC,OAAO,SAAS,CAAC,UAAU,CAAC;IAC9B,CAAC;IACD,6EAA6E;IAC7E,IAAI,SAAS,CAAC,QAAQ,EAAE,CAAC;QACvB,OAAO,SAAS,CAAC,QAAQ,CAAC;IAC5B,CAAC;IAED,IAAI,CAAC,SAAS,CAAC,OAAO,EAAE,CAAC;QACvB,IAAI,CAAC;YACH,oEAAoE;YACpE,MAAM,IAAI,GAAG,CAAC,iBAAiB,EAAE,UAAU,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;YACvD,mEAAmE;YACnE,4DAA4D;YAC5D,MAAM,QAAQ,GAAG,aAAa,CAC5B,aAAa,CAAC,OAAO,CAAC,GAAG,EAAE,GAAG,eAAe,CAAC,CAAC,IAAI,CACpD,CAAC;YACF,MAAM,GAAG,GAAG,QAAQ,CAAC,IAAI,CAAC,CAAC;YAC3B,SAAS,CAAC,OAAO,GAAG,GAAG,CAAC,OAAO,CAAC;QAClC,CAAC;QAAC,MAAM,CAAC;YACP,8DAA8D;YAC9D,SAAS,CAAC,OAAO,GAAG,KAAK,IAAI,EAAE,CAAC,SAAS,CAAC;QAC5C,CAAC;IACH,CAAC;IAED,oFAAoF;IACpF,kDAAkD;IAClD,MAAM,QAAQ,GAAG,SAAS,CAAC,OAAO,IAAI,CAAC,KAAK,IAAI,EAAE,CAAC,SAAS,CAAC,CAAC;IAC9D,SAAS,CAAC,QAAQ,GAAG,QAAQ,EAAE;SAC5B,IAAI,CAAC,CAAC,IAAI,EAAE,EAAE;QACb,0EAA0E;QAC1E,oEAAoE;QACpE,uDAAuD;QACvD,IAAI,OAAO,IAAI,KAAK,QAAQ,EAAE,CAAC;YAC7B,SAAS,CAAC,UAAU,GAAG,IAAI,CAAC;QAC9B,CAAC;QACD,OAAO,IAAI,CAAC;IACd,CAAC,CAAC;SACD,OAAO,CAAC,GAAG,EAAE;QACZ,SAAS,CAAC,QAAQ,GAAG,SAAS,CAAC;IACjC,CAAC,CAAC,CAAC;IACL,OAAO,SAAS,CAAC,QAAQ,CAAC;AAC5B,CAAC;AAED;;;;;;GAMG;AACH,MAAM,UAAU,wBAAwB;IACtC,SAAS,CAAC,OAAO,GAAG,SAAS,CAAC;IAC9B,SAAS,CAAC,UAAU,GAAG,SAAS,CAAC;IACjC,SAAS,CAAC,QAAQ,GAAG,SAAS,CAAC;AACjC,CAAC;AAED;;;;;GAKG;AACH,MAAM,UAAU,yBAAyB,CACvC,EAAqC;IAErC,SAAS,CAAC,OAAO,GAAG,EAAE,CAAC;IACvB,SAAS,CAAC,UAAU,GAAG,SAAS,CAAC;IACjC,SAAS,CAAC,QAAQ,GAAG,SAAS,CAAC;AACjC,CAAC","sourcesContent":["/**\n * Lazy loader for getPort that prevents bundlers (Turbopack, esbuild)\n * from statically tracing @workflow/utils/get-port and its filesystem\n * operations (readdir, readFile, readlink) into the flow route bundle.\n *\n * Uses createRequire with a dynamically constructed specifier so the\n * dependency is invisible to bundler static analysis.\n */\n\nimport { createRequire } from 'node:module';\nimport { pathToFileURL } from 'node:url';\nimport { globalSingleton } from '@workflow/utils';\n\n// All three live on `globalThis` (see `globalSingleton`) rather than at module\n// scope. The resolved port is a fact about the process, not about one copy of\n// this module, and per-copy caches would each pay the ~60ms `lsof` discovery\n// and could each pin their own answer.\nconst portState = globalSingleton('@workflow/core//devServerPort', 1, () => ({\n  getPort: undefined as (() => Promise<number | undefined>) | undefined,\n  cachedPort: undefined as number | undefined,\n  inFlight: undefined as Promise<number | undefined> | undefined,\n}));\n\n// Per-process cache of the resolved port. The workflow server listens on a\n// stable port for the lifetime of the process, but `getPort()` rediscovers it\n// on every call by querying the OS for the process's listening sockets. On\n// macOS that shells out to `lsof` (~60ms), which the runtime pays on EVERY\n// workflow replay or step invocation. Since the port does not change within a\n// process, resolve it once and reuse it. `portState.inFlight`\n// dedupes concurrent first calls so discovery never runs more than once.\n//\n// The first concrete port is pinned for the lifetime of the process: there is\n// no per-call re-resolution. This is safe because the runtime only runs inside\n// the already-listening dev-server process, and `getPort()` -> `getAllPorts()`\n// returns a deterministic order, so repeated calls would resolve the same port\n// anyway.\n\nexport async function getPortLazy(): Promise<number | undefined> {\n  // Fast path: already resolved a concrete port for this process.\n  if (portState.cachedPort !== undefined) {\n    return portState.cachedPort;\n  }\n  // A discovery is already running, so share it rather than starting a second.\n  if (portState.inFlight) {\n    return portState.inFlight;\n  }\n\n  if (!portState.getPort) {\n    try {\n      // Construct specifier at runtime to defeat bundler static analysis.\n      const spec = ['@workflow/utils', 'get-port'].join('/');\n      // Use process.cwd()-based createRequire for CJS/ESM compatibility.\n      // import.meta.url is unavailable in CJS re-bundled outputs.\n      const _require = createRequire(\n        pathToFileURL(process.cwd() + '/package.json').href\n      );\n      const mod = _require(spec);\n      portState.getPort = mod.getPort;\n    } catch {\n      // Module not available (e.g., in a browser or minimal bundle)\n      portState.getPort = async () => undefined;\n    }\n  }\n\n  // `portState.getPort` is always assigned by the block above; the fallback keeps the\n  // type non-nullable without a non-null assertion.\n  const resolver = portState.getPort ?? (async () => undefined);\n  portState.inFlight = resolver()\n    .then((port) => {\n      // Only cache a concrete port. A transient `undefined` (e.g. the server is\n      // not listening yet on the first replay) must not poison the cache:\n      // leaving it unset lets the next call retry discovery.\n      if (typeof port === 'number') {\n        portState.cachedPort = port;\n      }\n      return port;\n    })\n    .finally(() => {\n      portState.inFlight = undefined;\n    });\n  return portState.inFlight;\n}\n\n/**\n * Resets the per-process port cache. Intended for tests; not used on the hot\n * path. Callers must let any in-flight lookup settle (await the pending\n * `getPortLazy()` call) before resetting: clearing `portState.inFlight` here does not\n * cancel an already-scheduled resolution, so a late `.then` could otherwise\n * repopulate `portState.cachedPort` after the reset and bleed into the next test.\n */\nexport function resetPortCacheForTesting(): void {\n  portState.getPort = undefined;\n  portState.cachedPort = undefined;\n  portState.inFlight = undefined;\n}\n\n/**\n * Installs a fake port resolver and clears the cache. Test-only seam: the real\n * resolver is loaded via `createRequire` with a runtime-built specifier (to\n * hide it from bundlers), which also defeats module mocking, so injection is\n * the only deterministic way to exercise the caching contract.\n */\nexport function setPortResolverForTesting(\n  fn: () => Promise<number | undefined>\n): void {\n  portState.getPort = fn;\n  portState.cachedPort = undefined;\n  portState.inFlight = undefined;\n}\n"]}

package/dist/runtime/get-world-lazy.d.ts

@@ -9,9 +9,9 @@
  *
  * Resolution order, in priority:
  *
- * 1. `globalThis[WorldCacheKey]` — populated by a successful prior
+ * 1. `globalThis[WorldCacheKey]`: populated by a successful prior
  *    `getWorld()` call. This is the steady-state hot path.
- * 2. `globalThis[GetWorldFnKey]` — populated by the module-load side
+ * 2. `globalThis[GetWorldFnKey]`: populated by the module-load side
  *    effect at the bottom of `./world.ts`. Fires on every server bundle
  *    that reaches this file via `workflow` or `workflow/api` (which import
  *    `./world-init.ts` for its side effect; see that file for the full

package/dist/runtime/get-world-lazy.js

@@ -9,9 +9,9 @@
  *
  * Resolution order, in priority:
  *
- * 1. `globalThis[WorldCacheKey]` — populated by a successful prior
+ * 1. `globalThis[WorldCacheKey]`: populated by a successful prior
  *    `getWorld()` call. This is the steady-state hot path.
- * 2. `globalThis[GetWorldFnKey]` — populated by the module-load side
+ * 2. `globalThis[GetWorldFnKey]`: populated by the module-load side
  *    effect at the bottom of `./world.ts`. Fires on every server bundle
  *    that reaches this file via `workflow` or `workflow/api` (which import
  *    `./world-init.ts` for its side effect; see that file for the full
@@ -43,4 +43,4 @@ export async function getWorldLazy() {
     }
     throw new Error('Workflow world runtime was not initialized. Import from the host workflow entrypoints (`workflow`, `workflow/api`, or `workflow/runtime`) so @workflow/core/runtime/world-init can register getWorld before getWorldLazy() is used.');
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/dist/runtime/helpers.d.ts

@@ -20,7 +20,7 @@ export interface HealthCheckResult {
     /**
      * `@workflow/core` version of the responding deployment, used for
      * capability detection (see `getRunCapabilities`). Omitted when the
-     * responding deployment did not provide the field as a string —
+     * responding deployment did not provide the field as a string:
      * for example, an older `@workflow/core` that predates this field,
      * or a non-JSON plain-text health response.
      */
@@ -35,7 +35,7 @@ export interface HealthCheckResult {
      */
     encryptionPublicKey?: string;
     /**
-     * The responding deployment's `HOOK_RESUME_INPUT_VERSION` — the protocol
+     * The responding deployment's `HOOK_RESUME_INPUT_VERSION`: the protocol
      * version at which the *consumer* (queue-message target) re-ensures the
      * `hook_received` event from `hookInput` on replay. A cross-deployment
      * `start()` stamps the *target's* value (not the caller's) into the new
@@ -75,7 +75,7 @@ export interface HealthCheckOptions {
      * Queue namespace of the target deployment (e.g. `'eve'` for topics like
      * `__eve_wkf_workflow_*`). Falls back to `WORKFLOW_QUEUE_NAMESPACE` in the
      * calling process. Cross-context callers (e.g. the observability
-     * dashboard) must pass the target deployment's namespace explicitly —
+     * dashboard) must pass the target deployment's namespace explicitly:
      * the env fallback resolves in the caller's process, and a message
      * published to a mismatched topic has no consumer, so the check would
      * always time out.
@@ -93,7 +93,7 @@ export declare function healthCheck(world: World, options?: HealthCheckOptions):
  * re-sorted. Every append source is already in canonical order relative to the
  * tail (a cursor-delimited page, or a write-response delta), so receipt order is
  * the order to keep, and re-sorting here would only cost a pass over the log.
- * Nothing downstream may assume the tail is the newest event — see
+ * Nothing downstream may assume the tail is the newest event. See
  * {@link maxEventSlot}.
  */
 export declare function appendUniqueEvents(target: Event[], events: readonly Event[], targetIds?: Set<string>): void;
@@ -104,7 +104,7 @@ export declare function appendUniqueEvents(target: Event[], events: readonly Eve
  *
  * `preloadedEvents` is loaded `sortOrder: 'asc'` and is never re-sorted
  * client-side, so a `hook_received` spliced in by the lazy-resume consumer must
- * land in `eventId` order — a plain `push` would place a late-committing
+ * land in `eventId` order: a plain `push` would place a late-committing
  * earlier event after events that sort before it, corrupting replay.
  *
  * Lexicographic string order is the log's order: a slot id is a fixed-width
@@ -190,7 +190,7 @@ export interface SkippedSlotReport {
  * would raise the log's highest position past a position whose event is
  * missing. Later writes read that maximum to say what they have seen, so each
  * would claim a position it never saw, and the World only reports the span a
- * write skips — it would never send the missing one. Dropping costs one more
+ * write skips: it would never send the missing one. Dropping costs one more
  * round of the same events on the next write and keeps the log a prefix of the
  * truth, which the note above {@link mergeReportedEvents} explains is always an
  * available answer.
@@ -265,7 +265,7 @@ export declare function findEventSlotGap(events: readonly Event[]): EventSlotGap
  *
  * A hole can be transient. The World allocates a slot inside the insert that
  * occupies it, so two concurrent writers can collide, one retry past the other,
- * and the higher slot commit first — leaving a window in which the lower one is
+ * and the higher slot commit first, leaving a window in which the lower one is
  * genuinely absent from a strongly-consistent read and fills in a moment later.
  * The window is one commit wide, so a short backoff clears it; anything that
  * survives all three re-reads is a position no write will ever occupy.
@@ -276,7 +276,7 @@ export declare const SLOT_GAP_RECHECK_ATTEMPTS = 3;
  * out, and return the settled log alongside the hole that survived.
  *
  * Reads are strongly consistent, so a hole is not an artifact of *when* the log
- * was read — but it can be an artifact of a write that had not committed yet
+ * was read, but it can be an artifact of a write that had not committed yet
  * (see {@link SLOT_GAP_RECHECK_ATTEMPTS}). Distinguishing the two costs a
  * re-read, which is only ever paid by a replay that already found a hole.
  *
@@ -295,7 +295,7 @@ export declare function settleEventSlotGap(runId: string, loaded: LoadedEventLog
  * One integer says it because the World keeps its positions dense: a writer
  * that names slot N is claiming to hold every event from 1 to N and nothing
  * above. The World answers by numbering the write above whatever the log has
- * actually reached and handing back the events on the slots in between — the
+ * actually reached and handing back the events on the slots in between: the
  * ones this writer decided without.
  *
  * Density is the World's invariant, not a claim about this particular read. A
@@ -326,14 +326,14 @@ export declare function slotSnapshotParams(events: readonly Event[]): SlotSnapsh
  * The events a rejecting World attached to a `PreconditionFailedError`, when it
  * returned the ones the client's snapshot was missing inline.
  *
- * Returns `null` for anything else — no details, a World that did not implement
+ * Returns `null` for anything else: no details, a World that did not implement
  * this, or a payload that does not narrow cleanly. Callers fall back to
  * reloading the event log, which is always correct; this is untrusted-shaped
  * data on a failure path, so nothing here is repaired.
  *
  * `runId` is the caller's run. Every event must belong to it: the delta is
  * merged straight into the replay's log, and one foreign event there is a
- * corrupt log rather than a corrected one — the replay would consume a
+ * corrupt log rather than a corrected one: the replay would consume a
  * correlation id for an event that does not exist on this run.
  */
 export declare function preconditionEventDelta(error: unknown, runId: string): {
@@ -349,19 +349,19 @@ export type EventCreator = (data: CreateEventRequest, params?: CreateEventParams
 export declare function withHealthCheck(handler: (req: Request) => Promise<Response>, worldSpecVersion?: number): (req: Request) => Promise<Response>;
 /**
  * Idempotency key for a step's background-dispatch queue message, scoped to
- * the step's IDENTITY — correlation id plus (hashed) step name — rather than
+ * the step's IDENTITY, correlation id plus (hashed) step name, rather than
  * the bare correlation id.
  *
  * The scoping matters for resilient step dispatch under the precondition
  * guard: a guard-rejected `step_created` leaves its (revoked) step message in
  * flight, and the corrected replay may re-derive the same correlation id for
  * a DIFFERENT step. Under a bare-correlationId key the corrected replay's
- * dispatch would silently dedupe against the revoked in-flight message —
+ * dispatch would silently dedupe against the revoked in-flight message,
  * which then resolves `skipped` against the re-created entity (the server's
- * stepName fence rejects its bare start) — and the legitimate step would
+ * stepName fence rejects its bare start), and the legitimate step would
  * never be executed. Scoping by step name keeps every dedup property that
  * matters (crash recovery re-dispatch, concurrent handlers, the delayed
- * retry sharing the suspension re-dispatch's key — all name the same step)
+ * retry sharing the suspension re-dispatch's key: all name the same step)
  * while letting the corrected schedule's dispatch through.
  *
  * Every producer of a step-dispatch (or step-retry) message must use this
@@ -391,15 +391,15 @@ export declare function getQueueOverhead(message: {
  * If the world doesn't support encryption or the run has no key configured,
  * the cached value is `undefined`.
  *
- * The resolved value is deliberately the *full* capability — the symmetric AES
- * key plus the run's X25519 keypair — not just a `CryptoKey`. A run reading
+ * The resolved value is deliberately the *full* capability (the symmetric AES
+ * key plus the run's X25519 keypair), not just a `CryptoKey`. A run reading
  * its own event log can encounter sealed (`encp`) payloads that another run
  * wrote to it (a cross-deployment hook resumption, say), and opening those
  * needs the keypair. Resolving only the symmetric key would leave those
  * payloads unopenable and wedge the run.
  *
  * Used by step / workflow handlers to defer the (potentially expensive)
- * key fetch until the first code path that actually needs it — typically
+ * key fetch until the first code path that actually needs it: typically
  * input hydration on the success path, or error dehydration on a failure
  * path. Both paths can race-call the accessor without triggering duplicate
  * fetches.