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

package/dist/runtime/runs.js

@@ -1,6 +1,6 @@
 import { EntityConflictError } from '@workflow/errors';
-import { isLegacySpecVersion, SPEC_VERSION_LEGACY, } from '@workflow/world';
-import { importKey } from '../encryption.js';
+import { BULK_CANCEL_MAX_RUN_IDS, isLegacySpecVersion, SPEC_VERSION_LEGACY, } from '@workflow/world';
+import { deriveRunPayloadKeys } from '../serialization/encryption.js';
 import { hydrateWorkflowArguments } from '../serialization.js';
 import { getWorkflowQueueName } from './helpers.js';
 import { start } from './start.js';
@@ -14,7 +14,9 @@ export async function recreateRunFromExisting(world, runId, options = {}) {
     try {
         const run = await world.runs.get(runId, { resolveData: 'all' });
         const rawKey = await world.getEncryptionKeyForRun?.(run);
-        const encryptionKey = rawKey ? await importKey(rawKey) : undefined;
+        const encryptionKey = rawKey
+            ? await deriveRunPayloadKeys(rawKey)
+            : undefined;
         const workflowArgs = normalizeWorkflowArgs(await hydrateWorkflowArguments(run.input, runId, encryptionKey, globalThis));
         const specVersion = options.specVersion ?? run.specVersion ?? SPEC_VERSION_LEGACY;
         const deploymentId = options.deploymentId ?? run.deploymentId;
@@ -22,6 +24,8 @@ export async function recreateRunFromExisting(world, runId, options = {}) {
             deploymentId,
             world,
             specVersion,
+            replayedFromRunId: runId,
+            namespace: options.namespace,
         });
         return newRun.runId;
     }
@@ -31,29 +35,129 @@ export async function recreateRunFromExisting(world, runId, options = {}) {
 }
 /**
  * Cancel a workflow run.
+ *
+ * @param options - Optional cancellation settings. `cancelReason` records a
+ *   free-text reason (max 512 chars) on the run_cancelled event.
  */
-export async function cancelRun(world, runId) {
+export async function cancelRun(world, runId, options) {
     try {
         const run = await world.runs.get(runId, { resolveData: 'none' });
         const specVersion = run.specVersion ?? SPEC_VERSION_LEGACY;
         const compatMode = isLegacySpecVersion(specVersion);
-        const eventData = {
+        const eventRequest = {
             eventType: 'run_cancelled',
             specVersion,
+            ...(options?.cancelReason !== undefined
+                ? { eventData: { cancelReason: options.cancelReason } }
+                : {}),
         };
-        await world.events.create(runId, eventData, { v1Compat: compatMode });
+        await world.events.create(runId, eventRequest, { v1Compat: compatMode });
     }
     catch (err) {
         throw new Error(`Failed to cancel run ${runId}: ${err instanceof Error ? err.message : String(err)}`, { cause: err });
     }
 }
+/**
+ * Maximum number of single-run cancellations issued concurrently by the
+ * fallback path (worlds without `runs.cancelMany`).
+ */
+const CANCEL_RUNS_FALLBACK_CONCURRENCY = 20;
+/**
+ * Cancel many runs in one call.
+ *
+ * Fast path: if the world implements `runs.cancelMany`, the whole batch is
+ * delegated to it in a single operation (one backend round-trip on
+ * `@workflow/world-vercel`).
+ *
+ * Fallback: for worlds without `cancelMany`, this issues single-run
+ * `cancelRun()` calls with at most {@link CANCEL_RUNS_FALLBACK_CONCURRENCY}
+ * in flight at a time. Fallback successes are reported as `cancelled`;
+ * failures are reported as `failed` with `code: 'internal_error'` and
+ * `retryable: true` — deliberately without per-world error classification.
+ *
+ * @throws if `runIds` is empty, contains duplicates, or exceeds
+ *   {@link BULK_CANCEL_MAX_RUN_IDS}.
+ */
+export async function cancelRuns(world, runIds, options) {
+    if (runIds.length === 0) {
+        throw new Error('cancelRuns requires at least one run ID.');
+    }
+    if (runIds.length > BULK_CANCEL_MAX_RUN_IDS) {
+        throw new Error(`cancelRuns accepts at most ${BULK_CANCEL_MAX_RUN_IDS} run IDs (received ${runIds.length}).`);
+    }
+    if (new Set(runIds).size !== runIds.length) {
+        throw new Error('cancelRuns requires unique run IDs (duplicates found).');
+    }
+    // Fast path: a single batch operation when the world supports it.
+    if (world.runs.cancelMany) {
+        return world.runs.cancelMany({
+            runIds,
+            ...(options?.cancelReason !== undefined
+                ? { cancelReason: options.cancelReason }
+                : {}),
+        });
+    }
+    // Fallback: bounded-concurrency single-run cancellation.
+    const results = new Array(runIds.length);
+    let nextIndex = 0;
+    const worker = async () => {
+        while (true) {
+            const index = nextIndex++;
+            if (index >= runIds.length)
+                return;
+            const runId = runIds[index];
+            try {
+                await cancelRun(world, runId, options);
+                results[index] = { runId, outcome: 'cancelled' };
+            }
+            catch {
+                results[index] = {
+                    runId,
+                    outcome: 'failed',
+                    code: 'internal_error',
+                    retryable: true,
+                };
+            }
+        }
+    };
+    const workerCount = Math.min(CANCEL_RUNS_FALLBACK_CONCURRENCY, runIds.length);
+    await Promise.all(Array.from({ length: workerCount }, () => worker()));
+    const summary = {
+        requested: runIds.length,
+        cancelled: 0,
+        alreadyCancelled: 0,
+        notCancellable: 0,
+        notFound: 0,
+        failed: 0,
+    };
+    for (const result of results) {
+        switch (result.outcome) {
+            case 'cancelled':
+                summary.cancelled++;
+                break;
+            case 'already_cancelled':
+                summary.alreadyCancelled++;
+                break;
+            case 'not_cancellable':
+                summary.notCancellable++;
+                break;
+            case 'not_found':
+                summary.notFound++;
+                break;
+            case 'failed':
+                summary.failed++;
+                break;
+        }
+    }
+    return { summary, results };
+}
 /**
  * Re-enqueue a workflow run.
  */
-export async function reenqueueRun(world, runId) {
+export async function reenqueueRun(world, runId, options) {
     try {
         const run = await world.runs.get(runId, { resolveData: 'none' });
-        await world.queue(getWorkflowQueueName(run.workflowName), {
+        await world.queue(getWorkflowQueueName(run.workflowName, options?.namespace), {
             runId,
         }, {
             deploymentId: run.deploymentId,
@@ -107,6 +211,9 @@ export async function wakeUpRun(world, runId, options) {
                     eventType: 'wait_completed',
                     correlationId: waitEvent.correlationId,
                     specVersion: run.specVersion,
+                    eventData: {
+                        resumeAt: waitEvent.eventData.resumeAt,
+                    },
                 };
             try {
                 await world.events.create(runId, eventData, { v1Compat: compatMode });
@@ -122,7 +229,7 @@ export async function wakeUpRun(world, runId, options) {
             }
         }
         if (stoppedCount > 0) {
-            await world.queue(getWorkflowQueueName(run.workflowName), {
+            await world.queue(getWorkflowQueueName(run.workflowName, options?.namespace), {
                 runId,
             }, {
                 deploymentId: run.deploymentId,
@@ -164,4 +271,4 @@ export async function listStreams(world, runId) {
         throw new Error(`Failed to list streams for run ${runId}: ${err instanceof Error ? err.message : String(err)}`, { cause: err });
     }
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"runs.js","sourceRoot":"","sources":["../../src/runtime/runs.ts"],"names":[],"mappings":"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","sourcesContent":["import { EntityConflictError } from '@workflow/errors';\nimport {\n  type Event,\n  isLegacySpecVersion,\n  SPEC_VERSION_LEGACY,\n  type World,\n} from '@workflow/world';\nimport { importKey } from '../encryption.js';\nimport { hydrateWorkflowArguments } from '../serialization.js';\nimport { getWorkflowQueueName } from './helpers.js';\nimport { start } from './start.js';\n\nexport interface RecreateRunOptions {\n  deploymentId?: string;\n  specVersion?: number;\n}\n\nexport interface StopSleepResult {\n  /** Number of pending sleeps that were stopped */\n  stoppedCount: number;\n}\n\nexport interface ReadStreamOptions {\n  /**\n   * The index to start reading from. Defaults to 0.\n   * Negative values start from the end (e.g. -3 reads the last 3 chunks).\n   */\n  startIndex?: number;\n}\n\nexport interface StopSleepOptions {\n  /**\n   * Optional list of specific correlation IDs to target.\n   * If provided, only these sleep calls will be interrupted.\n   * If not provided, all pending sleep calls will be interrupted.\n   */\n  correlationIds?: string[];\n}\n\nconst normalizeWorkflowArgs = (args: unknown): unknown[] => {\n  return Array.isArray(args) ? args : [args];\n};\n\n/**\n * Start a new workflow run based on an existing run.\n */\nexport async function recreateRunFromExisting(\n  world: World,\n  runId: string,\n  options: RecreateRunOptions = {}\n): Promise<string> {\n  try {\n    const run = await world.runs.get(runId, { resolveData: 'all' });\n    const rawKey = await world.getEncryptionKeyForRun?.(run);\n    const encryptionKey = rawKey ? await importKey(rawKey) : undefined;\n    const workflowArgs = normalizeWorkflowArgs(\n      await hydrateWorkflowArguments(\n        run.input,\n        runId,\n        encryptionKey,\n        globalThis\n      )\n    );\n    const specVersion =\n      options.specVersion ?? run.specVersion ?? SPEC_VERSION_LEGACY;\n    const deploymentId = options.deploymentId ?? run.deploymentId;\n\n    const newRun = await start(\n      { workflowId: run.workflowName },\n      workflowArgs as unknown[],\n      {\n        deploymentId,\n        world,\n        specVersion,\n      }\n    );\n    return newRun.runId;\n  } catch (err) {\n    throw new Error(\n      `Failed to recreate run from ${runId}: ${err instanceof Error ? err.message : String(err)}`,\n      { cause: err }\n    );\n  }\n}\n\n/**\n * Cancel a workflow run.\n */\nexport async function cancelRun(world: World, runId: string): Promise<void> {\n  try {\n    const run = await world.runs.get(runId, { resolveData: 'none' });\n    const specVersion = run.specVersion ?? SPEC_VERSION_LEGACY;\n    const compatMode = isLegacySpecVersion(specVersion);\n    const eventData = {\n      eventType: 'run_cancelled' as const,\n      specVersion,\n    };\n    await world.events.create(runId, eventData, { v1Compat: compatMode });\n  } catch (err) {\n    throw new Error(\n      `Failed to cancel run ${runId}: ${err instanceof Error ? err.message : String(err)}`,\n      { cause: err }\n    );\n  }\n}\n\n/**\n * Re-enqueue a workflow run.\n */\nexport async function reenqueueRun(world: World, runId: string): Promise<void> {\n  try {\n    const run = await world.runs.get(runId, { resolveData: 'none' });\n    await world.queue(\n      getWorkflowQueueName(run.workflowName),\n      {\n        runId,\n      },\n      {\n        deploymentId: run.deploymentId,\n        specVersion: run.specVersion ?? SPEC_VERSION_LEGACY,\n      }\n    );\n  } catch (err) {\n    throw new Error(\n      `Failed to re-enqueue run ${runId}: ${err instanceof Error ? err.message : String(err)}`,\n      { cause: err }\n    );\n  }\n}\n\n/**\n * Wake up a workflow run by interrupting pending sleep() calls.\n */\nexport async function wakeUpRun(\n  world: World,\n  runId: string,\n  options?: StopSleepOptions\n): Promise<StopSleepResult> {\n  try {\n    const run = await world.runs.get(runId, { resolveData: 'none' });\n    const compatMode = isLegacySpecVersion(run.specVersion);\n\n    // Paginate through all events to ensure we don't miss any sleeps\n    // in long-running workflows with more than 1000 events.\n    const allEvents: Event[] = [];\n    let cursor: string | null = null;\n    do {\n      const eventsResult = await world.events.list({\n        runId,\n        pagination: { limit: 1000, ...(cursor ? { cursor } : {}) },\n        resolveData: 'none',\n      });\n      allEvents.push(...eventsResult.data);\n      cursor = eventsResult.hasMore ? eventsResult.cursor : null;\n    } while (cursor);\n\n    const waitCreatedEvents = allEvents.filter(\n      (event: Event) => event.eventType === 'wait_created'\n    );\n    const waitCompletedCorrelationIds = new Set(\n      allEvents\n        .filter((event: Event) => event.eventType === 'wait_completed')\n        .map((event: Event) => event.correlationId)\n    );\n\n    let pendingWaits = waitCreatedEvents.filter(\n      (event: Event) => !waitCompletedCorrelationIds.has(event.correlationId)\n    );\n\n    if (options?.correlationIds && options.correlationIds.length > 0) {\n      const targetCorrelationIds = new Set(options.correlationIds);\n      pendingWaits = pendingWaits.filter(\n        (event: Event) =>\n          event.correlationId && targetCorrelationIds.has(event.correlationId)\n      );\n    }\n\n    const errors: Error[] = [];\n    let stoppedCount = 0;\n\n    for (const waitEvent of pendingWaits) {\n      if (!waitEvent.correlationId) continue;\n      const eventData = compatMode\n        ? {\n            eventType: 'wait_completed' as const,\n            correlationId: waitEvent.correlationId,\n          }\n        : {\n            eventType: 'wait_completed' as const,\n            correlationId: waitEvent.correlationId,\n            specVersion: run.specVersion,\n          };\n      try {\n        await world.events.create(runId, eventData, { v1Compat: compatMode });\n        stoppedCount++;\n      } catch (err) {\n        if (EntityConflictError.is(err)) {\n          stoppedCount++;\n        } else {\n          errors.push(err instanceof Error ? err : new Error(String(err)));\n        }\n      }\n    }\n\n    if (stoppedCount > 0) {\n      await world.queue(\n        getWorkflowQueueName(run.workflowName),\n        {\n          runId,\n        },\n        {\n          deploymentId: run.deploymentId,\n          specVersion: run.specVersion ?? SPEC_VERSION_LEGACY,\n        }\n      );\n    }\n\n    if (errors.length > 0) {\n      throw new AggregateError(\n        errors,\n        `Failed to complete ${errors.length}/${pendingWaits.length} pending wait(s) for run ${runId}`\n      );\n    }\n\n    return { stoppedCount };\n  } catch (err) {\n    if (err instanceof AggregateError) {\n      throw err;\n    }\n    throw new Error(\n      `Failed to wake up run ${runId}: ${err instanceof Error ? err.message : String(err)}`,\n      { cause: err }\n    );\n  }\n}\n\n/**\n * Read from a stream by stream ID.\n * Returns a ReadableStream of Uint8Array chunks.\n */\nexport async function readStream(\n  world: World,\n  runId: string,\n  streamId: string,\n  options?: ReadStreamOptions\n): Promise<ReadableStream<Uint8Array>> {\n  try {\n    return await world.streams.get(runId, streamId, options?.startIndex);\n  } catch (err) {\n    throw new Error(\n      `Failed to read stream ${streamId}: ${err instanceof Error ? err.message : String(err)}`,\n      { cause: err }\n    );\n  }\n}\n\n/**\n * List all stream IDs for a workflow run.\n */\nexport async function listStreams(\n  world: World,\n  runId: string\n): Promise<string[]> {\n  try {\n    return await world.streams.list(runId);\n  } catch (err) {\n    throw new Error(\n      `Failed to list streams for run ${runId}: ${err instanceof Error ? err.message : String(err)}`,\n      { cause: err }\n    );\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"runs.js","sourceRoot":"","sources":["../../src/runtime/runs.ts"],"names":[],"mappings":"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","sourcesContent":["import { EntityConflictError } from '@workflow/errors';\nimport {\n  BULK_CANCEL_MAX_RUN_IDS,\n  type BulkCancelWorkflowRunResult,\n  type BulkCancelWorkflowRunsResult,\n  type Event,\n  isLegacySpecVersion,\n  SPEC_VERSION_LEGACY,\n  type World,\n} from '@workflow/world';\nimport { deriveRunPayloadKeys } from '../serialization/encryption.js';\nimport { hydrateWorkflowArguments } from '../serialization.js';\nimport { getWorkflowQueueName } from './helpers.js';\nimport { start } from './start.js';\n\nexport interface RecreateRunOptions {\n  deploymentId?: string;\n  specVersion?: number;\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\n   * the calling process. Cross-context callers (e.g. the observability\n   * dashboard) must pass the target deployment's namespace explicitly —\n   * a run enqueued to a topic the target deployment has no consumer for\n   * is never picked up.\n   */\n  namespace?: string;\n}\n\nexport interface StopSleepResult {\n  /** Number of pending sleeps that were stopped */\n  stoppedCount: number;\n}\n\nexport interface ReadStreamOptions {\n  /**\n   * The index to start reading from. Defaults to 0.\n   * Negative values start from the end (e.g. -3 reads the last 3 chunks).\n   */\n  startIndex?: number;\n}\n\nexport interface StopSleepOptions {\n  /**\n   * Optional list of specific correlation IDs to target.\n   * If provided, only these sleep calls will be interrupted.\n   * If not provided, all pending sleep calls will be interrupted.\n   */\n  correlationIds?: string[];\n  /**\n   * Queue namespace of the run's deployment (e.g. `'eve'`), used when\n   * re-enqueueing the run after completing its waits. Falls back to\n   * `WORKFLOW_QUEUE_NAMESPACE` in the calling process. Cross-context\n   * callers (e.g. the observability dashboard) must pass it explicitly.\n   */\n  namespace?: string;\n}\n\nexport interface ReenqueueRunOptions {\n  /**\n   * Queue namespace of the run's deployment (e.g. `'eve'`). Falls back to\n   * `WORKFLOW_QUEUE_NAMESPACE` in the calling process. Cross-context\n   * callers (e.g. the observability dashboard) must pass it explicitly.\n   */\n  namespace?: string;\n}\n\nexport interface CancelRunOptions {\n  /**\n   * Optional free-text reason for the cancellation (max 512 chars), recorded\n   * on the run_cancelled event and surfaced in the run detail view.\n   */\n  cancelReason?: string;\n}\n\nconst normalizeWorkflowArgs = (args: unknown): unknown[] => {\n  return Array.isArray(args) ? args : [args];\n};\n\n/**\n * Start a new workflow run based on an existing run.\n */\nexport async function recreateRunFromExisting(\n  world: World,\n  runId: string,\n  options: RecreateRunOptions = {}\n): Promise<string> {\n  try {\n    const run = await world.runs.get(runId, { resolveData: 'all' });\n    const rawKey = await world.getEncryptionKeyForRun?.(run);\n    const encryptionKey = rawKey\n      ? await deriveRunPayloadKeys(rawKey)\n      : undefined;\n    const workflowArgs = normalizeWorkflowArgs(\n      await hydrateWorkflowArguments(\n        run.input,\n        runId,\n        encryptionKey,\n        globalThis\n      )\n    );\n    const specVersion =\n      options.specVersion ?? run.specVersion ?? SPEC_VERSION_LEGACY;\n    const deploymentId = options.deploymentId ?? run.deploymentId;\n\n    const newRun = await start(\n      { workflowId: run.workflowName },\n      workflowArgs as unknown[],\n      {\n        deploymentId,\n        world,\n        specVersion,\n        replayedFromRunId: runId,\n        namespace: options.namespace,\n      }\n    );\n    return newRun.runId;\n  } catch (err) {\n    throw new Error(\n      `Failed to recreate run from ${runId}: ${err instanceof Error ? err.message : String(err)}`,\n      { cause: err }\n    );\n  }\n}\n\n/**\n * Cancel a workflow run.\n *\n * @param options - Optional cancellation settings. `cancelReason` records a\n *   free-text reason (max 512 chars) on the run_cancelled event.\n */\nexport async function cancelRun(\n  world: World,\n  runId: string,\n  options?: CancelRunOptions\n): Promise<void> {\n  try {\n    const run = await world.runs.get(runId, { resolveData: 'none' });\n    const specVersion = run.specVersion ?? SPEC_VERSION_LEGACY;\n    const compatMode = isLegacySpecVersion(specVersion);\n    const eventRequest = {\n      eventType: 'run_cancelled' as const,\n      specVersion,\n      ...(options?.cancelReason !== undefined\n        ? { eventData: { cancelReason: options.cancelReason } }\n        : {}),\n    };\n    await world.events.create(runId, eventRequest, { v1Compat: compatMode });\n  } catch (err) {\n    throw new Error(\n      `Failed to cancel run ${runId}: ${err instanceof Error ? err.message : String(err)}`,\n      { cause: err }\n    );\n  }\n}\n\n/**\n * Maximum number of single-run cancellations issued concurrently by the\n * fallback path (worlds without `runs.cancelMany`).\n */\nconst CANCEL_RUNS_FALLBACK_CONCURRENCY = 20;\n\n/**\n * Cancel many runs in one call.\n *\n * Fast path: if the world implements `runs.cancelMany`, the whole batch is\n * delegated to it in a single operation (one backend round-trip on\n * `@workflow/world-vercel`).\n *\n * Fallback: for worlds without `cancelMany`, this issues single-run\n * `cancelRun()` calls with at most {@link CANCEL_RUNS_FALLBACK_CONCURRENCY}\n * in flight at a time. Fallback successes are reported as `cancelled`;\n * failures are reported as `failed` with `code: 'internal_error'` and\n * `retryable: true` — deliberately without per-world error classification.\n *\n * @throws if `runIds` is empty, contains duplicates, or exceeds\n *   {@link BULK_CANCEL_MAX_RUN_IDS}.\n */\nexport async function cancelRuns(\n  world: World,\n  runIds: string[],\n  options?: CancelRunOptions\n): Promise<BulkCancelWorkflowRunsResult> {\n  if (runIds.length === 0) {\n    throw new Error('cancelRuns requires at least one run ID.');\n  }\n  if (runIds.length > BULK_CANCEL_MAX_RUN_IDS) {\n    throw new Error(\n      `cancelRuns accepts at most ${BULK_CANCEL_MAX_RUN_IDS} run IDs (received ${runIds.length}).`\n    );\n  }\n  if (new Set(runIds).size !== runIds.length) {\n    throw new Error('cancelRuns requires unique run IDs (duplicates found).');\n  }\n\n  // Fast path: a single batch operation when the world supports it.\n  if (world.runs.cancelMany) {\n    return world.runs.cancelMany({\n      runIds,\n      ...(options?.cancelReason !== undefined\n        ? { cancelReason: options.cancelReason }\n        : {}),\n    });\n  }\n\n  // Fallback: bounded-concurrency single-run cancellation.\n  const results: BulkCancelWorkflowRunResult[] = new Array(runIds.length);\n  let nextIndex = 0;\n\n  const worker = async (): Promise<void> => {\n    while (true) {\n      const index = nextIndex++;\n      if (index >= runIds.length) return;\n      const runId = runIds[index];\n      try {\n        await cancelRun(world, runId, options);\n        results[index] = { runId, outcome: 'cancelled' };\n      } catch {\n        results[index] = {\n          runId,\n          outcome: 'failed',\n          code: 'internal_error',\n          retryable: true,\n        };\n      }\n    }\n  };\n\n  const workerCount = Math.min(CANCEL_RUNS_FALLBACK_CONCURRENCY, runIds.length);\n  await Promise.all(Array.from({ length: workerCount }, () => worker()));\n\n  const summary = {\n    requested: runIds.length,\n    cancelled: 0,\n    alreadyCancelled: 0,\n    notCancellable: 0,\n    notFound: 0,\n    failed: 0,\n  };\n  for (const result of results) {\n    switch (result.outcome) {\n      case 'cancelled':\n        summary.cancelled++;\n        break;\n      case 'already_cancelled':\n        summary.alreadyCancelled++;\n        break;\n      case 'not_cancellable':\n        summary.notCancellable++;\n        break;\n      case 'not_found':\n        summary.notFound++;\n        break;\n      case 'failed':\n        summary.failed++;\n        break;\n    }\n  }\n\n  return { summary, results };\n}\n\n/**\n * Re-enqueue a workflow run.\n */\nexport async function reenqueueRun(\n  world: World,\n  runId: string,\n  options?: ReenqueueRunOptions\n): Promise<void> {\n  try {\n    const run = await world.runs.get(runId, { resolveData: 'none' });\n    await world.queue(\n      getWorkflowQueueName(run.workflowName, options?.namespace),\n      {\n        runId,\n      },\n      {\n        deploymentId: run.deploymentId,\n        specVersion: run.specVersion ?? SPEC_VERSION_LEGACY,\n      }\n    );\n  } catch (err) {\n    throw new Error(\n      `Failed to re-enqueue run ${runId}: ${err instanceof Error ? err.message : String(err)}`,\n      { cause: err }\n    );\n  }\n}\n\n/**\n * Wake up a workflow run by interrupting pending sleep() calls.\n */\nexport async function wakeUpRun(\n  world: World,\n  runId: string,\n  options?: StopSleepOptions\n): Promise<StopSleepResult> {\n  try {\n    const run = await world.runs.get(runId, { resolveData: 'none' });\n    const compatMode = isLegacySpecVersion(run.specVersion);\n\n    // Paginate through all events to ensure we don't miss any sleeps\n    // in long-running workflows with more than 1000 events.\n    const allEvents: Event[] = [];\n    let cursor: string | null = null;\n    do {\n      const eventsResult = await world.events.list({\n        runId,\n        pagination: { limit: 1000, ...(cursor ? { cursor } : {}) },\n        resolveData: 'none',\n      });\n      allEvents.push(...eventsResult.data);\n      cursor = eventsResult.hasMore ? eventsResult.cursor : null;\n    } while (cursor);\n\n    const waitCreatedEvents = allEvents.filter(\n      (event: Event) => event.eventType === 'wait_created'\n    );\n    const waitCompletedCorrelationIds = new Set(\n      allEvents\n        .filter((event: Event) => event.eventType === 'wait_completed')\n        .map((event: Event) => event.correlationId)\n    );\n\n    let pendingWaits = waitCreatedEvents.filter(\n      (event: Event) => !waitCompletedCorrelationIds.has(event.correlationId)\n    );\n\n    if (options?.correlationIds && options.correlationIds.length > 0) {\n      const targetCorrelationIds = new Set(options.correlationIds);\n      pendingWaits = pendingWaits.filter(\n        (event: Event) =>\n          event.correlationId && targetCorrelationIds.has(event.correlationId)\n      );\n    }\n\n    const errors: Error[] = [];\n    let stoppedCount = 0;\n\n    for (const waitEvent of pendingWaits) {\n      if (!waitEvent.correlationId) continue;\n      const eventData = compatMode\n        ? {\n            eventType: 'wait_completed' as const,\n            correlationId: waitEvent.correlationId,\n          }\n        : {\n            eventType: 'wait_completed' as const,\n            correlationId: waitEvent.correlationId,\n            specVersion: run.specVersion,\n            eventData: {\n              resumeAt: waitEvent.eventData.resumeAt,\n            },\n          };\n      try {\n        await world.events.create(runId, eventData, { v1Compat: compatMode });\n        stoppedCount++;\n      } catch (err) {\n        if (EntityConflictError.is(err)) {\n          stoppedCount++;\n        } else {\n          errors.push(err instanceof Error ? err : new Error(String(err)));\n        }\n      }\n    }\n\n    if (stoppedCount > 0) {\n      await world.queue(\n        getWorkflowQueueName(run.workflowName, options?.namespace),\n        {\n          runId,\n        },\n        {\n          deploymentId: run.deploymentId,\n          specVersion: run.specVersion ?? SPEC_VERSION_LEGACY,\n        }\n      );\n    }\n\n    if (errors.length > 0) {\n      throw new AggregateError(\n        errors,\n        `Failed to complete ${errors.length}/${pendingWaits.length} pending wait(s) for run ${runId}`\n      );\n    }\n\n    return { stoppedCount };\n  } catch (err) {\n    if (err instanceof AggregateError) {\n      throw err;\n    }\n    throw new Error(\n      `Failed to wake up run ${runId}: ${err instanceof Error ? err.message : String(err)}`,\n      { cause: err }\n    );\n  }\n}\n\n/**\n * Read from a stream by stream ID.\n * Returns a ReadableStream of Uint8Array chunks.\n */\nexport async function readStream(\n  world: World,\n  runId: string,\n  streamId: string,\n  options?: ReadStreamOptions\n): Promise<ReadableStream<Uint8Array>> {\n  try {\n    return await world.streams.get(runId, streamId, options?.startIndex);\n  } catch (err) {\n    throw new Error(\n      `Failed to read stream ${streamId}: ${err instanceof Error ? err.message : String(err)}`,\n      { cause: err }\n    );\n  }\n}\n\n/**\n * List all stream IDs for a workflow run.\n */\nexport async function listStreams(\n  world: World,\n  runId: string\n): Promise<string[]> {\n  try {\n    return await world.streams.list(runId);\n  } catch (err) {\n    throw new Error(\n      `Failed to list streams for run ${runId}: ${err instanceof Error ? err.message : String(err)}`,\n      { cause: err }\n    );\n  }\n}\n"]}

package/dist/runtime/start.d.ts

@@ -1,5 +1,12 @@
 import type { World } from '@workflow/world';
 import { Run } from './run.js';
+/**
+ * Reset the `deploymentId: 'latest'` no-op warn-once guard. Test-only —
+ * exported so unit tests can exercise the warn path across `start()` calls.
+ *
+ * @internal
+ */
+export declare function _resetLatestNoOpWarnForTests(): void;
 export interface StartOptionsBase {
     /**
      * The world to use for the workflow run creation,
@@ -10,6 +17,65 @@ export interface StartOptionsBase {
      * The spec version to use for the workflow run. Defaults to the latest version.
      */
     specVersion?: number;
+    /**
+     * Optional region identifier for the new run. Currently consumed only
+     * by `@workflow/world-vercel`, which embeds the region into the tagged
+     * run ID and routes the initial workflow message to the matching
+     * regional queue. When omitted, the world falls back to its own
+     * default (for `world-vercel`: the `VERCEL_REGION` environment
+     * variable, then the server-side default region `iad1` — a concrete,
+     * routable region is always chosen).
+     *
+     * Worlds without a regional dimension ignore this field.
+     */
+    region?: string;
+    /**
+     * Plaintext attributes to seed on the run as it is created.
+     *
+     * Available for native-attributes runs (spec version 4 and later).
+     */
+    attributes?: Record<string, string>;
+    /**
+     * Permit reserved `$`-prefixed keys in `attributes`. The `$` namespace
+     * is reserved for framework/library code built on top of the workflow
+     * SDK (telemetry, agent metadata, platform-emitted tags, etc.); user
+     * code MUST NOT write keys in it, and validation rejects them so
+     * accidental collisions with tooling-owned keys can't slip through.
+     *
+     * Only flip this to `true` if your caller is itself a framework or
+     * library that owns a `$`-prefixed sub-namespace and knows the
+     * conventions of any other tools writing into it. Same semantics as
+     * the `setAttributes` option of the same name.
+     */
+    allowReservedAttributes?: boolean;
+    /**
+     * The ID of an existing run this run is being replayed from, if any.
+     *
+     * Recorded on the new run's `executionContext` as `replayedFromRunId` so
+     * tooling (e.g. the dashboard runs list) can show that a run originated as
+     * a replay and link back to its source. Set automatically by
+     * {@link recreateRunFromExisting}; there's usually no reason to pass it
+     * directly.
+     *
+     * Must be a run ID: `wrun_` followed by a 26-char ULID. It's a foreign key
+     * to the source run, so `start()` validates the exact shape and rejects
+     * anything else rather than persist a lineage link that points at garbage.
+     */
+    replayedFromRunId?: string;
+    /**
+     * Queue namespace of the target deployment. Scopes the workflow queue
+     * topic to `__{namespace}_wkf_workflow_*` (e.g. `'eve'`) instead of the
+     * default `__wkf_workflow_*`, and is also used for the cross-deployment
+     * capability probe. Falls back to `WORKFLOW_QUEUE_NAMESPACE` in the
+     * calling process.
+     *
+     * Within a deployment the env fallback is correct. Cross-context callers
+     * (e.g. the observability dashboard replaying a run) must pass the
+     * TARGET deployment's namespace explicitly: the env fallback resolves in
+     * the caller's process, and a run enqueued to a topic the target has no
+     * consumer for is never picked up.
+     */
+    namespace?: string;
 }
 export interface StartOptionsWithDeploymentId extends StartOptionsBase {
     /**
@@ -20,7 +86,10 @@ export interface StartOptionsWithDeploymentId extends StartOptionsBase {
      *
      * Set to `'latest'` to automatically resolve the most recent deployment
      * for the current environment (same production target or git branch).
-     * This is currently a Vercel-specific feature.
+     * This is only meaningful in worlds with atomic, immutable deployments
+     * (currently Vercel). In other worlds (local dev, Postgres) there is no
+     * notion of multiple deployments to resolve between, so `'latest'` has no
+     * effect — a warning is logged and the run targets the current deployment.
      *
      * **Note:** When `deploymentId` is provided, the argument and return types become `unknown`
      * since there is no guarantee the types will be consistent across deployments.

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

@@ -1 +1 @@
-{"version":3,"file":"start.d.ts","sourceRoot":"","sources":["../../src/runtime/start.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,EAAyB,KAAK,EAAE,MAAM,iBAAiB,CAAC;AAgBpE,OAAO,EAAE,GAAG,EAAE,MAAM,UAAU,CAAC;AAM/B,MAAM,WAAW,gBAAgB;IAC/B;;;OAGG;IACH,KAAK,CAAC,EAAE,KAAK,CAAC;IAEd;;OAEG;IACH,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB;AAED,MAAM,WAAW,4BAA6B,SAAQ,gBAAgB;IACpE;;;;;;;;;;;;OAYG;IACH,YAAY,EAAE,QAAQ,GAAG,CAAC,MAAM,GAAG,EAAE,CAAC,CAAC;CACxC;AAED,MAAM,WAAW,+BAAgC,SAAQ,gBAAgB;IACvE,YAAY,CAAC,EAAE,SAAS,CAAC;CAC1B;AAED;;GAEG;AACH,MAAM,MAAM,YAAY,GACpB,4BAA4B,GAC5B,+BAA+B,CAAC;AAEpC;;GAEG;AACH,MAAM,MAAM,gBAAgB,CAAC,KAAK,SAAS,OAAO,EAAE,EAAE,OAAO,IAAI,CAC/D,GAAG,IAAI,EAAE,KAAK,KACX,OAAO,CAAC,OAAO,CAAC,CAAC;AAEtB;;GAEG;AACH,MAAM,MAAM,gBAAgB,GAAG;IAAE,UAAU,EAAE,MAAM,CAAA;CAAE,CAAC;AAEtD;;;;;;;GAOG;AAIH,wBAAgB,KAAK,CAAC,KAAK,SAAS,OAAO,EAAE,EAAE,OAAO,EACpD,QAAQ,EAAE,gBAAgB,CAAC,KAAK,EAAE,OAAO,CAAC,GAAG,gBAAgB,EAC7D,IAAI,EAAE,OAAO,EAAE,EACf,OAAO,EAAE,4BAA4B,GACpC,OAAO,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC,CAAC;AAEzB,wBAAgB,KAAK,CAAC,OAAO,EAC3B,QAAQ,EAAE,gBAAgB,CAAC,EAAE,EAAE,OAAO,CAAC,GAAG,gBAAgB,EAC1D,OAAO,EAAE,4BAA4B,GACpC,OAAO,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC,CAAC;AAGzB,wBAAgB,KAAK,CAAC,KAAK,SAAS,OAAO,EAAE,EAAE,OAAO,EACpD,QAAQ,EAAE,gBAAgB,CAAC,KAAK,EAAE,OAAO,CAAC,GAAG,gBAAgB,EAC7D,IAAI,EAAE,KAAK,EACX,OAAO,CAAC,EAAE,+BAA+B,GACxC,OAAO,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC,CAAC;AAEzB,wBAAgB,KAAK,CAAC,OAAO,EAC3B,QAAQ,EAAE,gBAAgB,CAAC,EAAE,EAAE,OAAO,CAAC,GAAG,gBAAgB,EAC1D,OAAO,CAAC,EAAE,+BAA+B,GACxC,OAAO,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC,CAAC"}
+{"version":3,"file":"start.d.ts","sourceRoot":"","sources":["../../src/runtime/start.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAyB,KAAK,EAAE,MAAM,iBAAiB,CAAC;AAmCpE,OAAO,EAAE,GAAG,EAAE,MAAM,UAAU,CAAC;AA+C/B;;;;;GAKG;AACH,wBAAgB,4BAA4B,IAAI,IAAI,CAEnD;AAED,MAAM,WAAW,gBAAgB;IAC/B;;;OAGG;IACH,KAAK,CAAC,EAAE,KAAK,CAAC;IAEd;;OAEG;IACH,WAAW,CAAC,EAAE,MAAM,CAAC;IAErB;;;;;;;;;;OAUG;IACH,MAAM,CAAC,EAAE,MAAM,CAAC;IAEhB;;;;OAIG;IACH,UAAU,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAEpC;;;;;;;;;;;OAWG;IACH,uBAAuB,CAAC,EAAE,OAAO,CAAC;IAElC;;;;;;;;;;;;OAYG;IACH,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAC3B;;;;;;;;;;;;OAYG;IACH,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB;AAED,MAAM,WAAW,4BAA6B,SAAQ,gBAAgB;IACpE;;;;;;;;;;;;;;;OAeG;IACH,YAAY,EAAE,QAAQ,GAAG,CAAC,MAAM,GAAG,EAAE,CAAC,CAAC;CACxC;AAED,MAAM,WAAW,+BAAgC,SAAQ,gBAAgB;IACvE,YAAY,CAAC,EAAE,SAAS,CAAC;CAC1B;AAED;;GAEG;AACH,MAAM,MAAM,YAAY,GACpB,4BAA4B,GAC5B,+BAA+B,CAAC;AAEpC;;GAEG;AACH,MAAM,MAAM,gBAAgB,CAAC,KAAK,SAAS,OAAO,EAAE,EAAE,OAAO,IAAI,CAC/D,GAAG,IAAI,EAAE,KAAK,KACX,OAAO,CAAC,OAAO,CAAC,CAAC;AAEtB;;GAEG;AACH,MAAM,MAAM,gBAAgB,GAAG;IAAE,UAAU,EAAE,MAAM,CAAA;CAAE,CAAC;AAEtD;;;;;;;GAOG;AAIH,wBAAgB,KAAK,CAAC,KAAK,SAAS,OAAO,EAAE,EAAE,OAAO,EACpD,QAAQ,EAAE,gBAAgB,CAAC,KAAK,EAAE,OAAO,CAAC,GAAG,gBAAgB,EAC7D,IAAI,EAAE,OAAO,EAAE,EACf,OAAO,EAAE,4BAA4B,GACpC,OAAO,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC,CAAC;AAEzB,wBAAgB,KAAK,CAAC,OAAO,EAC3B,QAAQ,EAAE,gBAAgB,CAAC,EAAE,EAAE,OAAO,CAAC,GAAG,gBAAgB,EAC1D,OAAO,EAAE,4BAA4B,GACpC,OAAO,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC,CAAC;AAGzB,wBAAgB,KAAK,CAAC,KAAK,SAAS,OAAO,EAAE,EAAE,OAAO,EACpD,QAAQ,EAAE,gBAAgB,CAAC,KAAK,EAAE,OAAO,CAAC,GAAG,gBAAgB,EAC7D,IAAI,EAAE,KAAK,EACX,OAAO,CAAC,EAAE,+BAA+B,GACxC,OAAO,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC,CAAC;AAEzB,wBAAgB,KAAK,CAAC,OAAO,EAC3B,QAAQ,EAAE,gBAAgB,CAAC,EAAE,EAAE,OAAO,CAAC,GAAG,gBAAgB,EAC1D,OAAO,CAAC,EAAE,+BAA+B,GACxC,OAAO,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC,CAAC"}