@workflow/core 5.0.0-beta.40 → 5.0.0-beta.42

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

@@ -1,3 +1,4 @@
+import { type SlotSnapshotParams } from './helpers.js';
 /**
  * Per-invocation accounting of the *non-step* portion of a workflow
  * handler run: deterministic event-log replay, workflow-VM execution
@@ -72,21 +73,12 @@ export declare class ReplayBudget {
      */
     isExhausted(): boolean;
 }
+export declare class ReplayTimeoutRetryError extends Error {
+    readonly name = "ReplayTimeoutRetryError";
+}
 /**
- * Fail the run (or retry, on early attempts) when the replay budget is
- * exhausted. The handling depends on whether the underlying World
- * supports `process.exit(1)` as a queue redelivery signal (see
- * `World.processExitTriggersQueueRedelivery`):
- *
- * - **Managed-platform Worlds** (`world-vercel`): on attempts <=
- *   `REPLAY_TIMEOUT_MAX_RETRIES` exit the process so the platform fails
- *   the invocation and the queue redelivers; on the next attempt write
- *   `run_failed` with `RUN_ERROR_CODES.REPLAY_TIMEOUT` and exit.
- *
- * - **In-process Worlds** (`world-local`, dev servers): calling
- *   `process.exit()` would terminate the host (e.g. `pnpm dev`), so
- *   instead log a warning, write `run_failed` best-effort, and return.
- *   The framework completes the request normally.
+ * Reject the current delivery while replay-timeout retries remain. Once
+ * exhausted, fail the run and let the queue acknowledge the delivery.
  */
 export declare function handleReplayBudgetExhausted(args: {
     runId: string;
@@ -94,5 +86,12 @@ export declare function handleReplayBudgetExhausted(args: {
     requestId: string | undefined;
     attempt: number;
     limitMs: number;
+    /**
+     * How much of the log the replay that ran out of budget had loaded. Carried
+     * onto the terminal write for the same reason every other write from that
+     * replay carries it: the run is being failed on a view of the log, and the
+     * World should be told which view.
+     */
+    slotSnapshot?: SlotSnapshotParams;
 }): Promise<void>;
 //# sourceMappingURL=replay-budget.d.ts.map

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

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

package/dist/runtime/replay-budget.js

@@ -97,63 +97,26 @@ export class ReplayBudget {
         return this.elapsed() >= this.limitMs;
     }
 }
+export class ReplayTimeoutRetryError extends Error {
+    name = 'ReplayTimeoutRetryError';
+}
 /**
- * Fail the run (or retry, on early attempts) when the replay budget is
- * exhausted. The handling depends on whether the underlying World
- * supports `process.exit(1)` as a queue redelivery signal (see
- * `World.processExitTriggersQueueRedelivery`):
- *
- * - **Managed-platform Worlds** (`world-vercel`): on attempts <=
- *   `REPLAY_TIMEOUT_MAX_RETRIES` exit the process so the platform fails
- *   the invocation and the queue redelivers; on the next attempt write
- *   `run_failed` with `RUN_ERROR_CODES.REPLAY_TIMEOUT` and exit.
- *
- * - **In-process Worlds** (`world-local`, dev servers): calling
- *   `process.exit()` would terminate the host (e.g. `pnpm dev`), so
- *   instead log a warning, write `run_failed` best-effort, and return.
- *   The framework completes the request normally.
+ * Reject the current delivery while replay-timeout retries remain. Once
+ * exhausted, fail the run and let the queue acknowledge the delivery.
  */
 export async function handleReplayBudgetExhausted(args) {
-    const { runId, workflowName, requestId, attempt, limitMs } = args;
+    const { runId, workflowName, requestId, attempt, limitMs, slotSnapshot } = args;
     const runLogger = runtimeLogger.forRun(runId, workflowName);
-    const world = await getWorld();
-    const canExitForRedelivery = world.processExitTriggersQueueRedelivery === true;
-    // Worlds without managed-platform redelivery (e.g. world-local, custom
-    // in-process worlds) must not have us exit the process — that would
-    // kill the user's host (`pnpm dev`, CLI, etc.) without producing a
-    // retry. Surface the failure via the event log if we can, then return.
-    if (!canExitForRedelivery) {
-        runLogger.warn('Workflow replay exceeded timeout; current World does not support process exit for redelivery — failing the run and returning', { timeoutMs: limitMs, attempt });
-        try {
-            const getEncryptionKey = memoizeEncryptionKey(world, runId);
-            const timeoutErr = new FatalError(`Workflow replay exceeded maximum duration (${limitMs / 1000}s)`);
-            await world.events.create(runId, {
-                eventType: 'run_failed',
-                specVersion: SPEC_VERSION_CURRENT,
-                eventData: {
-                    error: await dehydrateRunError(timeoutErr, runId, await getEncryptionKey()),
-                    errorCode: RUN_ERROR_CODES.REPLAY_TIMEOUT,
-                },
-            }, { requestId });
-        }
-        catch (err) {
-            runLogger.warn('Unable to mark run as failed', {
-                attempt,
-                errorName: err instanceof Error ? err.name : 'UnknownError',
-                errorMessage: err instanceof Error ? err.message : String(err),
-            });
-        }
-        return;
-    }
     const maxRetries = getReplayTimeoutMaxRetries();
     if (attempt <= maxRetries) {
-        runLogger.warn('Workflow replay exceeded timeout but will be re-attempted (attempt < maxRetries)', {
+        runLogger.warn('Workflow replay exceeded timeout; retrying delivery', {
             timeoutMs: limitMs,
             attempt,
             maxRetries,
         });
-        process.exit(1);
+        throw new ReplayTimeoutRetryError(`Workflow replay exceeded maximum duration (${limitMs / 1000}s)`);
     }
+    const world = await getWorld();
     const replayTimeoutDescription = describeError(undefined, RUN_ERROR_CODES.REPLAY_TIMEOUT);
     runLogger.error('Workflow replay exceeded timeout and max retries exceeded. Failing the run', {
         timeoutMs: limitMs,
@@ -162,31 +125,15 @@ export async function handleReplayBudgetExhausted(args) {
         errorCode: replayTimeoutDescription.errorCode,
         errorAttribution: replayTimeoutDescription.attribution,
     });
-    try {
-        const getEncryptionKey = memoizeEncryptionKey(world, runId);
-        const timeoutErr = new FatalError(`Workflow replay exceeded maximum duration (${limitMs / 1000}s) after ${attempt} attempts`);
-        await world.events.create(runId, {
-            eventType: 'run_failed',
-            specVersion: SPEC_VERSION_CURRENT,
-            eventData: {
-                error: await dehydrateRunError(timeoutErr, runId, await getEncryptionKey()),
-                errorCode: RUN_ERROR_CODES.REPLAY_TIMEOUT,
-            },
-        }, { requestId });
-    }
-    catch (err) {
-        // Best effort — process exits regardless. Surface why so operators
-        // can diagnose repeat timeouts against the backend.
-        runLogger.warn('Unable to mark run as failed. The queue will continue to retry', {
-            attempt,
-            errorName: err instanceof Error ? err.name : 'UnknownError',
-            errorMessage: err instanceof Error ? err.message : String(err),
-            errorStack: err instanceof Error ? err.stack : undefined,
-        });
-    }
-    // Note that this also prevents the runtime from acking the queue
-    // message, so the queue will call back once, after which a 410 will
-    // get it to exit early.
-    process.exit(1);
+    const getEncryptionKey = memoizeEncryptionKey(world, runId);
+    const timeoutErr = new FatalError(`Workflow replay exceeded maximum duration (${limitMs / 1000}s) after ${attempt} attempts`);
+    await world.events.create(runId, {
+        eventType: 'run_failed',
+        specVersion: SPEC_VERSION_CURRENT,
+        eventData: {
+            error: await dehydrateRunError(timeoutErr, runId, await getEncryptionKey()),
+            errorCode: RUN_ERROR_CODES.REPLAY_TIMEOUT,
+        },
+    }, { requestId, ...slotSnapshot });
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"replay-budget.js","sourceRoot":"","sources":["../../src/runtime/replay-budget.ts"],"names":[],"mappings":"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","sourcesContent":["import { FatalError, RUN_ERROR_CODES } from '@workflow/errors';\nimport { SPEC_VERSION_CURRENT } from '@workflow/world';\nimport { describeError } from '../describe-error.js';\nimport { runtimeLogger } from '../logger.js';\nimport { dehydrateRunError } from '../serialization.js';\nimport { getReplayTimeoutMaxRetries, getReplayTimeoutMs } from './constants.js';\nimport { memoizeEncryptionKey } from './helpers.js';\nimport { getWorld } from './world.js';\n\n/**\n * Per-invocation accounting of the *non-step* portion of a workflow\n * handler run: deterministic event-log replay, workflow-VM execution\n * between step boundaries, suspension handling, queue round-trips, etc.\n * Inline step bodies (`\"use step\"` functions invoked via `executeStep`)\n * are intentionally excluded — they are bounded by the platform's\n * function `maxDuration` and the `NO_INLINE_REPLAY_AFTER_MS` early-return\n * guard.\n *\n * Usage:\n *\n * ```ts\n * const budget = new ReplayBudget();\n * // …non-step work happens here, accumulates against the budget…\n * budget.pause();\n * try {\n *   await executeStep(...); // not charged\n * } finally {\n *   budget.resume();\n * }\n * // back to charging\n * if (budget.isExhausted()) { ... }\n * ```\n *\n * Implementation notes:\n *\n * - `pause()` and `resume()` are idempotent: calling `pause()` while\n *   already paused (or `resume()` while already resumed) is a no-op.\n *   This protects against double-counting in future refactors that nest\n *   step execution or take an early-return path between a `pause()` and\n *   the matching `resume()`.\n * - `isExhausted()` is checked at loop boundaries by the caller — the\n *   budget itself does not arm any timers. This means an in-flight\n *   pathological `runWorkflow` call (e.g. a huge event-log replay) can\n *   overshoot the budget by up to one iteration's worth of work before\n *   the next check fires. In practice the 20s headroom built into\n *   `MAX_REPLAY_TIMEOUT_MS` (and the function `maxDuration` ceiling)\n *   gives us slack; the old `setTimeout`-based approach also ultimately\n *   relied on the platform SIGTERM as the hard backstop.\n */\nexport class ReplayBudget {\n  private readonly limitMs: number;\n  private elapsedMs = 0;\n  private intervalStart: number | null;\n\n  constructor(limitMs: number = getReplayTimeoutMs()) {\n    this.limitMs = limitMs;\n    this.intervalStart = Date.now();\n  }\n\n  /**\n   * The configured replay-timeout limit, in ms. Useful for log messages.\n   */\n  get configuredLimitMs(): number {\n    return this.limitMs;\n  }\n\n  /**\n   * Total non-step time accumulated so far, in ms. Includes the\n   * currently-active interval if the budget is not paused.\n   */\n  elapsed(): number {\n    const open =\n      this.intervalStart === null ? 0 : Date.now() - this.intervalStart;\n    return this.elapsedMs + open;\n  }\n\n  /**\n   * Stop counting elapsed time toward the budget. Idempotent — safe to\n   * call multiple times in a row; subsequent calls are no-ops until\n   * `resume()` reopens an interval.\n   */\n  pause(): void {\n    if (this.intervalStart === null) return;\n    this.elapsedMs += Date.now() - this.intervalStart;\n    this.intervalStart = null;\n  }\n\n  /**\n   * Resume counting elapsed time toward the budget. Idempotent — safe to\n   * call multiple times in a row; subsequent calls re-anchor the\n   * interval start to `now()`, which is fine because no time accrues\n   * between back-to-back `resume()` calls.\n   */\n  resume(): void {\n    this.intervalStart = Date.now();\n  }\n\n  /**\n   * True if the budget has been exhausted (`elapsed() >= limitMs`).\n   * Callers should invoke `handleExhausted(...)` afterward and return\n   * from the handler.\n   */\n  isExhausted(): boolean {\n    return this.elapsed() >= this.limitMs;\n  }\n}\n\n/**\n * Fail the run (or retry, on early attempts) when the replay budget is\n * exhausted. The handling depends on whether the underlying World\n * supports `process.exit(1)` as a queue redelivery signal (see\n * `World.processExitTriggersQueueRedelivery`):\n *\n * - **Managed-platform Worlds** (`world-vercel`): on attempts <=\n *   `REPLAY_TIMEOUT_MAX_RETRIES` exit the process so the platform fails\n *   the invocation and the queue redelivers; on the next attempt write\n *   `run_failed` with `RUN_ERROR_CODES.REPLAY_TIMEOUT` and exit.\n *\n * - **In-process Worlds** (`world-local`, dev servers): calling\n *   `process.exit()` would terminate the host (e.g. `pnpm dev`), so\n *   instead log a warning, write `run_failed` best-effort, and return.\n *   The framework completes the request normally.\n */\nexport async function handleReplayBudgetExhausted(args: {\n  runId: string;\n  workflowName: string;\n  requestId: string | undefined;\n  attempt: number;\n  limitMs: number;\n}): Promise<void> {\n  const { runId, workflowName, requestId, attempt, limitMs } = args;\n  const runLogger = runtimeLogger.forRun(runId, workflowName);\n\n  const world = await getWorld();\n  const canExitForRedelivery =\n    world.processExitTriggersQueueRedelivery === true;\n\n  // Worlds without managed-platform redelivery (e.g. world-local, custom\n  // in-process worlds) must not have us exit the process — that would\n  // kill the user's host (`pnpm dev`, CLI, etc.) without producing a\n  // retry. Surface the failure via the event log if we can, then return.\n  if (!canExitForRedelivery) {\n    runLogger.warn(\n      'Workflow replay exceeded timeout; current World does not support process exit for redelivery — failing the run and returning',\n      { timeoutMs: limitMs, attempt }\n    );\n    try {\n      const getEncryptionKey = memoizeEncryptionKey(world, runId);\n      const timeoutErr = new FatalError(\n        `Workflow replay exceeded maximum duration (${limitMs / 1000}s)`\n      );\n      await world.events.create(\n        runId,\n        {\n          eventType: 'run_failed',\n          specVersion: SPEC_VERSION_CURRENT,\n          eventData: {\n            error: await dehydrateRunError(\n              timeoutErr,\n              runId,\n              await getEncryptionKey()\n            ),\n            errorCode: RUN_ERROR_CODES.REPLAY_TIMEOUT,\n          },\n        },\n        { requestId }\n      );\n    } catch (err) {\n      runLogger.warn('Unable to mark run as failed', {\n        attempt,\n        errorName: err instanceof Error ? err.name : 'UnknownError',\n        errorMessage: err instanceof Error ? err.message : String(err),\n      });\n    }\n    return;\n  }\n\n  const maxRetries = getReplayTimeoutMaxRetries();\n  if (attempt <= maxRetries) {\n    runLogger.warn(\n      'Workflow replay exceeded timeout but will be re-attempted (attempt < maxRetries)',\n      {\n        timeoutMs: limitMs,\n        attempt,\n        maxRetries,\n      }\n    );\n    process.exit(1);\n  }\n\n  const replayTimeoutDescription = describeError(\n    undefined,\n    RUN_ERROR_CODES.REPLAY_TIMEOUT\n  );\n  runLogger.error(\n    'Workflow replay exceeded timeout and max retries exceeded. Failing the run',\n    {\n      timeoutMs: limitMs,\n      attempt,\n      maxRetries,\n      errorCode: replayTimeoutDescription.errorCode,\n      errorAttribution: replayTimeoutDescription.attribution,\n    }\n  );\n\n  try {\n    const getEncryptionKey = memoizeEncryptionKey(world, runId);\n    const timeoutErr = new FatalError(\n      `Workflow replay exceeded maximum duration (${limitMs / 1000}s) after ${attempt} attempts`\n    );\n    await world.events.create(\n      runId,\n      {\n        eventType: 'run_failed',\n        specVersion: SPEC_VERSION_CURRENT,\n        eventData: {\n          error: await dehydrateRunError(\n            timeoutErr,\n            runId,\n            await getEncryptionKey()\n          ),\n          errorCode: RUN_ERROR_CODES.REPLAY_TIMEOUT,\n        },\n      },\n      { requestId }\n    );\n  } catch (err) {\n    // Best effort — process exits regardless. Surface why so operators\n    // can diagnose repeat timeouts against the backend.\n    runLogger.warn(\n      'Unable to mark run as failed. The queue will continue to retry',\n      {\n        attempt,\n        errorName: err instanceof Error ? err.name : 'UnknownError',\n        errorMessage: err instanceof Error ? err.message : String(err),\n        errorStack: err instanceof Error ? err.stack : undefined,\n      }\n    );\n  }\n  // Note that this also prevents the runtime from acking the queue\n  // message, so the queue will call back once, after which a 410 will\n  // get it to exit early.\n  process.exit(1);\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"replay-budget.js","sourceRoot":"","sources":["../../src/runtime/replay-budget.ts"],"names":[],"mappings":"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","sourcesContent":["import { FatalError, RUN_ERROR_CODES } from '@workflow/errors';\nimport { SPEC_VERSION_CURRENT } from '@workflow/world';\nimport { describeError } from '../describe-error.js';\nimport { runtimeLogger } from '../logger.js';\nimport { dehydrateRunError } from '../serialization.js';\nimport { getReplayTimeoutMaxRetries, getReplayTimeoutMs } from './constants.js';\nimport { memoizeEncryptionKey, type SlotSnapshotParams } from './helpers.js';\nimport { getWorld } from './world.js';\n\n/**\n * Per-invocation accounting of the *non-step* portion of a workflow\n * handler run: deterministic event-log replay, workflow-VM execution\n * between step boundaries, suspension handling, queue round-trips, etc.\n * Inline step bodies (`\"use step\"` functions invoked via `executeStep`)\n * are intentionally excluded — they are bounded by the platform's\n * function `maxDuration` and the `NO_INLINE_REPLAY_AFTER_MS` early-return\n * guard.\n *\n * Usage:\n *\n * ```ts\n * const budget = new ReplayBudget();\n * // …non-step work happens here, accumulates against the budget…\n * budget.pause();\n * try {\n *   await executeStep(...); // not charged\n * } finally {\n *   budget.resume();\n * }\n * // back to charging\n * if (budget.isExhausted()) { ... }\n * ```\n *\n * Implementation notes:\n *\n * - `pause()` and `resume()` are idempotent: calling `pause()` while\n *   already paused (or `resume()` while already resumed) is a no-op.\n *   This protects against double-counting in future refactors that nest\n *   step execution or take an early-return path between a `pause()` and\n *   the matching `resume()`.\n * - `isExhausted()` is checked at loop boundaries by the caller — the\n *   budget itself does not arm any timers. This means an in-flight\n *   pathological `runWorkflow` call (e.g. a huge event-log replay) can\n *   overshoot the budget by up to one iteration's worth of work before\n *   the next check fires. In practice the 20s headroom built into\n *   `MAX_REPLAY_TIMEOUT_MS` (and the function `maxDuration` ceiling)\n *   gives us slack; the old `setTimeout`-based approach also ultimately\n *   relied on the platform SIGTERM as the hard backstop.\n */\nexport class ReplayBudget {\n  private readonly limitMs: number;\n  private elapsedMs = 0;\n  private intervalStart: number | null;\n\n  constructor(limitMs: number = getReplayTimeoutMs()) {\n    this.limitMs = limitMs;\n    this.intervalStart = Date.now();\n  }\n\n  /**\n   * The configured replay-timeout limit, in ms. Useful for log messages.\n   */\n  get configuredLimitMs(): number {\n    return this.limitMs;\n  }\n\n  /**\n   * Total non-step time accumulated so far, in ms. Includes the\n   * currently-active interval if the budget is not paused.\n   */\n  elapsed(): number {\n    const open =\n      this.intervalStart === null ? 0 : Date.now() - this.intervalStart;\n    return this.elapsedMs + open;\n  }\n\n  /**\n   * Stop counting elapsed time toward the budget. Idempotent — safe to\n   * call multiple times in a row; subsequent calls are no-ops until\n   * `resume()` reopens an interval.\n   */\n  pause(): void {\n    if (this.intervalStart === null) return;\n    this.elapsedMs += Date.now() - this.intervalStart;\n    this.intervalStart = null;\n  }\n\n  /**\n   * Resume counting elapsed time toward the budget. Idempotent — safe to\n   * call multiple times in a row; subsequent calls re-anchor the\n   * interval start to `now()`, which is fine because no time accrues\n   * between back-to-back `resume()` calls.\n   */\n  resume(): void {\n    this.intervalStart = Date.now();\n  }\n\n  /**\n   * True if the budget has been exhausted (`elapsed() >= limitMs`).\n   * Callers should invoke `handleExhausted(...)` afterward and return\n   * from the handler.\n   */\n  isExhausted(): boolean {\n    return this.elapsed() >= this.limitMs;\n  }\n}\n\nexport class ReplayTimeoutRetryError extends Error {\n  override readonly name = 'ReplayTimeoutRetryError';\n}\n\n/**\n * Reject the current delivery while replay-timeout retries remain. Once\n * exhausted, fail the run and let the queue acknowledge the delivery.\n */\nexport async function handleReplayBudgetExhausted(args: {\n  runId: string;\n  workflowName: string;\n  requestId: string | undefined;\n  attempt: number;\n  limitMs: number;\n  /**\n   * How much of the log the replay that ran out of budget had loaded. Carried\n   * onto the terminal write for the same reason every other write from that\n   * replay carries it: the run is being failed on a view of the log, and the\n   * World should be told which view.\n   */\n  slotSnapshot?: SlotSnapshotParams;\n}): Promise<void> {\n  const { runId, workflowName, requestId, attempt, limitMs, slotSnapshot } =\n    args;\n  const runLogger = runtimeLogger.forRun(runId, workflowName);\n\n  const maxRetries = getReplayTimeoutMaxRetries();\n  if (attempt <= maxRetries) {\n    runLogger.warn('Workflow replay exceeded timeout; retrying delivery', {\n      timeoutMs: limitMs,\n      attempt,\n      maxRetries,\n    });\n    throw new ReplayTimeoutRetryError(\n      `Workflow replay exceeded maximum duration (${limitMs / 1000}s)`\n    );\n  }\n\n  const world = await getWorld();\n\n  const replayTimeoutDescription = describeError(\n    undefined,\n    RUN_ERROR_CODES.REPLAY_TIMEOUT\n  );\n  runLogger.error(\n    'Workflow replay exceeded timeout and max retries exceeded. Failing the run',\n    {\n      timeoutMs: limitMs,\n      attempt,\n      maxRetries,\n      errorCode: replayTimeoutDescription.errorCode,\n      errorAttribution: replayTimeoutDescription.attribution,\n    }\n  );\n\n  const getEncryptionKey = memoizeEncryptionKey(world, runId);\n  const timeoutErr = new FatalError(\n    `Workflow replay exceeded maximum duration (${limitMs / 1000}s) after ${attempt} attempts`\n  );\n  await world.events.create(\n    runId,\n    {\n      eventType: 'run_failed',\n      specVersion: SPEC_VERSION_CURRENT,\n      eventData: {\n        error: await dehydrateRunError(\n          timeoutErr,\n          runId,\n          await getEncryptionKey()\n        ),\n        errorCode: RUN_ERROR_CODES.REPLAY_TIMEOUT,\n      },\n    },\n    { requestId, ...slotSnapshot }\n  );\n}\n"]}

package/dist/runtime/resume-hook.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"resume-hook.d.ts","sourceRoot":"","sources":["../../src/runtime/resume-hook.ts"],"names":[],"mappings":"AAOA,OAAO,EAGL,KAAK,IAAI,EAUV,MAAM,iBAAiB,CAAC;AAQzB,OAAO,EAGL,KAAK,UAAU,EAGhB,MAAM,qBAAqB,CAAC;AAwJ7B;;;;;;;;;GASG;AACH,wBAAsB,cAAc,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAGjE;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,MAAM,MAAM,WAAW,GAAG,IAAI,GAAG;IAAE,eAAe,CAAC,EAAE,OAAO,CAAA;CAAE,CAAC;AAE/D;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,wBAAsB,UAAU,CAAC,CAAC,GAAG,GAAG,EACtC,WAAW,EAAE,MAAM,GAAG,IAAI,EAC1B,OAAO,EAAE,CAAC,EACV,qBAAqB,CAAC,EAAE,UAAU,GACjC,OAAO,CAAC,WAAW,CAAC,CAUtB;AA8ZD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AACH,wBAAsB,aAAa,CACjC,KAAK,EAAE,MAAM,EACb,OAAO,EAAE,OAAO,GACf,OAAO,CAAC,QAAQ,CAAC,CA+DnB"}
+{"version":3,"file":"resume-hook.d.ts","sourceRoot":"","sources":["../../src/runtime/resume-hook.ts"],"names":[],"mappings":"AAOA,OAAO,EAGL,KAAK,IAAI,EAUV,MAAM,iBAAiB,CAAC;AAQzB,OAAO,EAGL,KAAK,UAAU,EAGhB,MAAM,qBAAqB,CAAC;AAwJ7B;;;;;;;;;GASG;AACH,wBAAsB,cAAc,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAGjE;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,MAAM,MAAM,WAAW,GAAG,IAAI,GAAG;IAAE,eAAe,CAAC,EAAE,OAAO,CAAA;CAAE,CAAC;AAE/D;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,wBAAsB,UAAU,CAAC,CAAC,GAAG,GAAG,EACtC,WAAW,EAAE,MAAM,GAAG,IAAI,EAC1B,OAAO,EAAE,CAAC,EACV,qBAAqB,CAAC,EAAE,UAAU,GACjC,OAAO,CAAC,WAAW,CAAC,CAmBtB;AAkcD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AACH,wBAAsB,aAAa,CACjC,KAAK,EAAE,MAAM,EACb,OAAO,EAAE,OAAO,GACf,OAAO,CAAC,QAAQ,CAAC,CAqEnB"}