@workflow/world-testing 5.0.0-beta.55 → 5.0.0-beta.57

package/dist/.well-known/workflow/v1/__step_registrations.mjs

@@ -412,7 +412,7 @@ function buildFramedDetails(hint2, slug) {
   });
   return out;
 }
-var BASE_URL, ERROR_SLUGS, WorkflowError, WorkflowWorldError, WorkflowRunFailedError, WorkflowRunNotCompletedError, WorkflowRuntimeError, RuntimeDecryptionError, SerializationError, StepNotRegisteredError, WorkflowNotRegisteredError, WorkflowRunNotFoundError, HookConflictError, HookNotFoundError, EntityConflictError, RunExpiredError, StreamError, StreamExpiredError, ThrottleError, WorkflowRunCancelledError, FatalError, RetryableError, FATAL_ERROR_KEY, RETRYABLE_ERROR_KEY, HOOK_CONFLICT_ERROR_KEY, RUNTIME_DECRYPTION_ERROR_KEY, STREAM_ERROR_KEY;
+var BASE_URL, ERROR_SLUGS, WorkflowError, WorkflowWorldError, WorkflowRunFailedError, WorkflowRunNotCompletedError, WorkflowRuntimeError, RuntimeDecryptionError, SerializationError, StepNotRegisteredError, WorkflowNotRegisteredError, WorkflowRunNotFoundError, HookConflictError, HookForceClaimedError, HookNotFoundError, EntityConflictError, RunExpiredError, StreamError, StreamExpiredError, ThrottleError, WorkflowRunCancelledError, FatalError, RetryableError, FATAL_ERROR_KEY, RETRYABLE_ERROR_KEY, HOOK_CONFLICT_ERROR_KEY, HOOK_FORCE_CLAIMED_ERROR_KEY, RUNTIME_DECRYPTION_ERROR_KEY, STREAM_ERROR_KEY;
 var init_dist2 = __esm({
   "../errors/dist/index.js"() {
     "use strict";
@@ -432,6 +432,7 @@ var init_dist2 = __esm({
       FETCH_IN_WORKFLOW_FUNCTION: "fetch-in-workflow",
       TIMEOUT_FUNCTIONS_IN_WORKFLOW: "timeout-in-workflow",
       HOOK_CONFLICT: "hook-conflict",
+      HOOK_FORCE_CLAIMED: "hook-force-claimed",
       CORRUPTED_EVENT_LOG: "corrupted-event-log",
       REPLAY_DIVERGENCE: "replay-divergence",
       STEP_NOT_REGISTERED: "step-not-registered",
@@ -495,6 +496,17 @@ Caused by: ${options.cause.stack}`;
       static {
         __name(this, "WorkflowRunFailedError");
       }
+      /**
+       * `failed` is terminal, and a run's terminal state is immutable. This error
+       * is only ever thrown after a *successful* read of such a run, so re-running
+       * the read returns the same record and throws the same error. Marking it
+       * non-retryable is what stops the step executor from spending a retry budget
+       * on that when the read happens inside a step — a parent awaiting a child's
+       * `returnValue` — and then replacing this error with its retry-exhaustion
+       * wrapper. A read that *fails* throws something else and stays retryable.
+       * See `FatalError.is()`.
+       */
+      fatal = true;
       runId;
       /**
        * The high-level error category (e.g. USER_ERROR, RUNTIME_ERROR) for the
@@ -658,6 +670,30 @@ Caused by: ${options.cause.stack}`;
         return isError(value) && value.name === "HookConflictError";
       }
     };
+    HookForceClaimedError = class extends WorkflowError {
+      static {
+        __name(this, "HookForceClaimedError");
+      }
+      token;
+      /** The run that took the token. */
+      claimedByRunId;
+      /** The hook (in `claimedByRunId`) the token now belongs to. */
+      claimedByHookId;
+      constructor(token, claimedByRunId, claimedByHookId) {
+        super(`Hook token "${token}" was force-claimed by another workflow (run "${claimedByRunId}")`, {
+          slug: ERROR_SLUGS.HOOK_FORCE_CLAIMED
+        });
+        this.name = "HookForceClaimedError";
+        this.token = token;
+        this.claimedByRunId = claimedByRunId;
+        if (claimedByHookId !== void 0) {
+          this.claimedByHookId = claimedByHookId;
+        }
+      }
+      static is(value) {
+        return isError(value) && value.name === "HookForceClaimedError";
+      }
+    };
     HookNotFoundError = class extends WorkflowError {
       static {
         __name(this, "HookNotFoundError");
@@ -761,6 +797,8 @@ Caused by: ${options.cause.stack}`;
       static {
         __name(this, "WorkflowRunCancelledError");
       }
+      /** Terminal and immutable, for the same reason as {@link WorkflowRunFailedError.fatal}. */
+      fatal = true;
       runId;
       constructor(runId) {
         super(`Workflow run "${runId}" cancelled`, {});
@@ -810,6 +848,7 @@ Caused by: ${options.cause.stack}`;
     FATAL_ERROR_KEY = /* @__PURE__ */ Symbol.for("@workflow/errors//FatalError");
     RETRYABLE_ERROR_KEY = /* @__PURE__ */ Symbol.for("@workflow/errors//RetryableError");
     HOOK_CONFLICT_ERROR_KEY = /* @__PURE__ */ Symbol.for("@workflow/errors//HookConflictError");
+    HOOK_FORCE_CLAIMED_ERROR_KEY = /* @__PURE__ */ Symbol.for("@workflow/errors//HookForceClaimedError");
     RUNTIME_DECRYPTION_ERROR_KEY = /* @__PURE__ */ Symbol.for("@workflow/errors//RuntimeDecryptionError");
     STREAM_ERROR_KEY = /* @__PURE__ */ Symbol.for("@workflow/errors//StreamError");
     if (typeof globalThis !== "undefined") {
@@ -837,6 +876,14 @@ Caused by: ${options.cause.stack}`;
           configurable: false
         });
       }
+      if (!Object.hasOwn(globalThis, HOOK_FORCE_CLAIMED_ERROR_KEY)) {
+        Object.defineProperty(globalThis, HOOK_FORCE_CLAIMED_ERROR_KEY, {
+          value: HookForceClaimedError,
+          writable: false,
+          enumerable: false,
+          configurable: false
+        });
+      }
       if (!Object.hasOwn(globalThis, RUNTIME_DECRYPTION_ERROR_KEY)) {
         Object.defineProperty(globalThis, RUNTIME_DECRYPTION_ERROR_KEY, {
           value: RuntimeDecryptionError,
@@ -904,27 +951,6 @@ var init_env_config = __esm({
   }
 });
 
-// ../world/dist/spec-version.js
-function isLegacySpecVersion(v) {
-  return v === void 0 || v === null || v <= SPEC_VERSION_LEGACY;
-}
-var SPEC_VERSION_LEGACY, SPEC_VERSION_SUPPORTS_CBOR_QUEUE_TRANSPORT, SPEC_VERSION_SUPPORTS_ATTRIBUTES, SPEC_VERSION_SUPPORTS_COMPRESSION, SPEC_VERSION_SUPPORTS_SLOT_IDENTITY, SPEC_VERSION_SUPPORTS_SEALED_LOG, SPEC_VERSION_CURRENT, SPEC_VERSION_MAX_SUPPORTED;
-var init_spec_version = __esm({
-  "../world/dist/spec-version.js"() {
-    "use strict";
-    init_env_config();
-    SPEC_VERSION_LEGACY = 1;
-    SPEC_VERSION_SUPPORTS_CBOR_QUEUE_TRANSPORT = 3;
-    SPEC_VERSION_SUPPORTS_ATTRIBUTES = 4;
-    SPEC_VERSION_SUPPORTS_COMPRESSION = 5;
-    SPEC_VERSION_SUPPORTS_SLOT_IDENTITY = 6;
-    SPEC_VERSION_SUPPORTS_SEALED_LOG = 7;
-    SPEC_VERSION_CURRENT = SPEC_VERSION_SUPPORTS_SEALED_LOG;
-    SPEC_VERSION_MAX_SUPPORTED = SPEC_VERSION_SUPPORTS_SEALED_LOG;
-    __name(isLegacySpecVersion, "isLegacySpecVersion");
-  }
-});
-
 // ../core/dist/encryption.js
 async function importKey(raw, usages = [
   "encrypt",
@@ -24904,7 +24930,30 @@ var init_events = __esm({
         tokenRetentionUntil: external_exports.coerce.date().optional(),
         metadata: SerializedDataSchema.optional(),
         isWebhook: external_exports.boolean().optional(),
-        isSystem: external_exports.boolean().optional()
+        isSystem: external_exports.boolean().optional(),
+        /**
+         * `createHook({ experimental_force: true })`: when the token belongs to
+         * another live run, the World takes it over — journaling
+         * `hook_disposed{forceClaimedBy}` in that run's log and re-pointing the
+         * token — instead of answering `hook_conflict`. Requires the
+         * `hookForceClaim` capability.
+         */
+        force: external_exports.boolean().optional(),
+        /**
+         * World-written on a forced creation that did take a token over: the
+         * run and hook it was taken from, plus what a queue message to that run
+         * needs (`workflowName`, `deploymentId`, `runSpecVersion`). Absent when
+         * the token was free. The wake-targeting fields are in the LOG, not only
+         * on the hook entity, so a replay can republish the victim's wake from
+         * the row alone; see `publishForceClaimVictimWake` in @workflow/core.
+         */
+        forceClaimedFrom: external_exports.object({
+          runId: external_exports.string(),
+          hookId: external_exports.string(),
+          workflowName: external_exports.string().optional(),
+          deploymentId: external_exports.string().optional(),
+          runSpecVersion: external_exports.number().optional()
+        }).optional()
       })
     }));
     HookReceivedEventSchema = external_exports.compile(BaseEventSchema.extend({
@@ -24919,7 +24968,17 @@ var init_events = __esm({
       eventType: external_exports.literal("hook_disposed"),
       correlationId: external_exports.string(),
       eventData: external_exports.object({
-        token: external_exports.string().optional()
+        token: external_exports.string().optional(),
+        /**
+         * World-written: this disposal was not the run's own. Another run
+         * took the hook's token with `experimental_force`, and this names
+         * it. The hook consumer rejects the hook's awaiters with
+         * `HookForceClaimedError` when it reads this row.
+         */
+        forceClaimedBy: external_exports.object({
+          runId: external_exports.string(),
+          hookId: external_exports.string()
+        }).optional()
       }).optional()
     }));
     HookConflictEventSchema = external_exports.compile(BaseEventSchema.extend({
@@ -24929,7 +24988,18 @@ var init_events = __esm({
         token: external_exports.string(),
         // TODO: Make this required once all persisted hook_conflict events and
         // remote World implementations always include the active hook owner's run ID.
-        conflictingRunId: external_exports.string().optional()
+        conflictingRunId: external_exports.string().optional(),
+        /**
+         * Set when the creation asked for `force` and the World declined to take
+         * the token over. `victim-spec-version`: the run holding the token was
+         * started at a spec version below
+         * `SPEC_VERSION_SUPPORTS_HOOK_FORCE_CLAIM`, so its runtime would not
+         * understand the involuntary disposal — the forced hook gets the
+         * ordinary `HookConflictError` it opted out of instead of stranding
+         * that run. Absent on a conflict answered by a World that does not
+         * implement forcing at all.
+         */
+        forceRefusedReason: external_exports.literal("victim-spec-version").optional()
       })
     }));
     NoopEventSchema = external_exports.compile(BaseEventSchema.extend({
@@ -25790,7 +25860,7 @@ var init_queue = __esm({
 });
 
 // ../world/dist/hooks.js
-var HookResumeContextSchema, HOOK_RESUME_INPUT_VERSION, HOOK_RESUME_DEDUP_VERSION, HookResumeCapabilitiesSchema, HookSchema;
+var HookResumeContextSchema, HOOK_RESUME_INPUT_VERSION, HOOK_RESUME_DEDUP_VERSION, HookResumeCapabilitiesSchema, HookClaimedFromSchema, HookSchema;
 var init_hooks = __esm({
   "../world/dist/hooks.js"() {
     "use strict";
@@ -25831,6 +25901,13 @@ var init_hooks = __esm({
       // is engaged.
       hookResumeDedupVersion: external_exports.number()
     }));
+    HookClaimedFromSchema = external_exports.compile(external_exports.object({
+      runId: external_exports.string(),
+      hookId: external_exports.string(),
+      workflowName: external_exports.string().optional(),
+      deploymentId: external_exports.string().optional(),
+      runSpecVersion: external_exports.number().optional()
+    }));
     HookSchema = external_exports.compile(external_exports.object({
       runId: external_exports.string(),
       hookId: external_exports.string(),
@@ -25858,7 +25935,12 @@ var init_hooks = __esm({
       // `resumeHook()` gates its lazy path on this being present and
       // current. Absent against an older/rolled-back server or when the kill switch
       // is active.
-      resumeCapabilities: HookResumeCapabilitiesSchema.optional()
+      resumeCapabilities: HookResumeCapabilitiesSchema.optional(),
+      // Set when this hook took its token from another run
+      // (`experimental_force`). The wake-targeting fields are the victim run's,
+      // so the claimer's runtime can publish the victim's wake without reading
+      // a run it may not be able to reach; see `HookClaimedFromSchema`.
+      claimedFrom: HookClaimedFromSchema.optional()
     }));
   }
 });
@@ -25919,6 +26001,28 @@ var init_slot_identity = __esm({
   }
 });
 
+// ../world/dist/spec-version.js
+function isLegacySpecVersion(v) {
+  return v === void 0 || v === null || v <= SPEC_VERSION_LEGACY;
+}
+var SPEC_VERSION_LEGACY, SPEC_VERSION_SUPPORTS_EVENT_SOURCING, SPEC_VERSION_SUPPORTS_CBOR_QUEUE_TRANSPORT, SPEC_VERSION_SUPPORTS_ATTRIBUTES, SPEC_VERSION_SUPPORTS_COMPRESSION, SPEC_VERSION_SUPPORTS_SLOT_IDENTITY, SPEC_VERSION_SUPPORTS_HOOK_FORCE_CLAIM, SPEC_VERSION_CURRENT, SPEC_VERSION_MAX_SUPPORTED;
+var init_spec_version = __esm({
+  "../world/dist/spec-version.js"() {
+    "use strict";
+    init_env_config();
+    SPEC_VERSION_LEGACY = 1;
+    SPEC_VERSION_SUPPORTS_EVENT_SOURCING = 2;
+    SPEC_VERSION_SUPPORTS_CBOR_QUEUE_TRANSPORT = 3;
+    SPEC_VERSION_SUPPORTS_ATTRIBUTES = 4;
+    SPEC_VERSION_SUPPORTS_COMPRESSION = 5;
+    SPEC_VERSION_SUPPORTS_SLOT_IDENTITY = 6;
+    SPEC_VERSION_SUPPORTS_HOOK_FORCE_CLAIM = 8;
+    SPEC_VERSION_CURRENT = SPEC_VERSION_SUPPORTS_HOOK_FORCE_CLAIM;
+    SPEC_VERSION_MAX_SUPPORTED = SPEC_VERSION_SUPPORTS_HOOK_FORCE_CLAIM;
+    __name(isLegacySpecVersion, "isLegacySpecVersion");
+  }
+});
+
 // ../world/dist/ulid.js
 var UlidSchema, workflowRunIdSchema, DEFAULT_TIMESTAMP_THRESHOLD_PAST_MS, DEFAULT_TIMESTAMP_THRESHOLD_FUTURE_MS;
 var init_ulid = __esm({
@@ -26549,6 +26653,20 @@ function getCommonReducers(_global = globalThis) {
       }
       return reduced;
     }, "HookConflictError"),
+    HookForceClaimedError: /* @__PURE__ */ __name((value) => {
+      const base = reduceNamedErrorSubclassBase("HookForceClaimedError", value);
+      if (!base) return false;
+      const reduced = {
+        ...base,
+        token: readProperty(value, "token"),
+        claimedByRunId: readProperty(value, "claimedByRunId")
+      };
+      const claimedByHookId = readProperty(value, "claimedByHookId");
+      if (claimedByHookId !== void 0) {
+        reduced.claimedByHookId = claimedByHookId;
+      }
+      return reduced;
+    }, "HookForceClaimedError"),
     RangeError: makeErrorSubclassReducer("RangeError"),
     ReferenceError: makeErrorSubclassReducer("ReferenceError"),
     // RetryableError carries an extra `retryAfter` Date that we serialize as
@@ -26723,6 +26841,15 @@ function getCommonRevivers(global2 = globalThis) {
       }
       return error61;
     }, "HookConflictError"),
+    HookForceClaimedError: /* @__PURE__ */ __name((value) => {
+      const Ctor = global2[/* @__PURE__ */ Symbol.for("@workflow/errors//HookForceClaimedError")] ?? HookForceClaimedError;
+      const error61 = new Ctor(value.token, value.claimedByRunId, value.claimedByHookId);
+      if (value.stack !== void 0) error61.stack = value.stack;
+      if ("cause" in value) {
+        error61.cause = value.cause;
+      }
+      return error61;
+    }, "HookForceClaimedError"),
     RangeError: makeErrorSubclassReviver(global2, "RangeError"),
     ReferenceError: makeErrorSubclassReviver(global2, "ReferenceError"),
     RetryableError: /* @__PURE__ */ __name((value) => {
@@ -27427,7 +27554,7 @@ function SemanticConvention(...names) {
     value
   ]));
 }
-var WorkflowName, WorkflowOperation, WorkflowRunId, WorkflowRunStatus, WorkflowStartedAt, WorkflowEventsCount, WorkflowExecutionMode, WorkflowBundleCompileCacheHit, WorkflowReplayLoadSource, WorkflowParkedEventsCount, WorkflowParkedEventId, WorkflowParkedEventType, WorkflowArgumentsCount, WorkflowResultType, WorkflowTracePropagated, WorkflowVm, QuickJSOutcome, QuickJSEventsPreloaded, QuickJSEventsFetchedCount, QuickJSEventsFetchedPages, QuickJSPendingOpsCount, QuickJSInlineSteps, WorkflowTraceMode, WorkflowTurbo, WorkflowErrorName, WorkflowErrorMessage, WorkflowErrorCode, WorkflowStepsCreated, WorkflowHooksCreated, WorkflowWaitsCreated, WorkflowStepsFailedSerialization, WorkflowOwnedRecoverySteps, WorkflowBackstopWakesArmed, WorkflowDispatchRepublishSkipped, WorkflowRouteType, WorkflowRouteHandlerCached, WorkflowRouteInvocationCount, WorkflowRouteEntrypointAgeMs, WorkflowRouteModuleBodyInitMs, FaasInstance, StepName, StepId, StepAttempt, StepStatus, StepMaxRetries, StepTracePropagated, StepTtfsMs, StepStsoMs, StepRsfsMs, StepFinalSchedulingReplayMs, StepLatencyOptimizations, StepStartStrategy, StepSkipped, StepSkipReason, StepArgumentsCount, StepResultType, StepErrorName, StepErrorMessage, StepFatalError, StepRetryExhausted, StepRetryTimeoutSeconds, StepRetryWillRetry, MessagingSystem, MessagingDestinationName, MessagingMessageId, MessagingOperationType, MessagingBatchMessageCount, QueueOverheadMs, DeploymentId, WorkflowRunPinnedDeploymentId, WorkflowDeploymentMismatchRetryCount, WorkflowDeploymentMismatchRecovered, HookToken, HookId, HookFound, HookResilientResume, HookResumeCommitted, HookWakePublished, HookResilientResumeMaterialized, HookResumeSetupSource, StepResilientDispatchRecovered, StepResilientDispatchMaterialized, StepDispatchPrologue, ResumeTotalMs, ResumeProducerPrepMs, ResumeQueueDeliveryMs, ResumeSetupMs, ResumeReplayMs, ResumeStepDispatchMs, ResumeStepClaimMs, ResumeStepPrepareMs, ResumeTrigger, ResumeStrategy, ResumeSetupSource, ResumeStepExecution, WebhookHandlersTriggered, WorkflowSuspensionState, WorkflowSuspensionHookCount, WorkflowSuspensionStepCount, WorkflowSuspensionWaitCount, HttpRequestMethod, HttpRoute, UrlFull, ServerAddress, ServerPort, HttpResponseStatusCode, ErrorType, WorldParseFormat, WorkflowEventsPagesLoaded, QueueDeserializeTimeMs, QueueExecutionTimeMs, QueueSerializeTimeMs, SerializationOperation, SerializationCompressed, SerializationCodec, SerializationUncompressedBytes, SerializationStoredBytes, SerializationCompressionRatio, SerializationGuestCodeExecutions, SerializationGuestCodeDetails, PeerService, RpcSystem, RpcService, RpcMethod, ErrorRetryable, ErrorCategory;
+var WorkflowName, WorkflowOperation, WorkflowRunId, WorkflowRunStatus, WorkflowStartedAt, WorkflowEventsCount, WorkflowExecutionMode, WorkflowBundleCompileCacheHit, WorkflowReplayLoadSource, WorkflowParkedEventsCount, WorkflowParkedEventId, WorkflowParkedEventType, WorkflowArgumentsCount, WorkflowResultType, WorkflowTracePropagated, WorkflowVm, QuickJSOutcome, QuickJSEventsPreloaded, QuickJSEventsFetchedCount, QuickJSEventsFetchedPages, QuickJSPendingOpsCount, QuickJSInlineSteps, WorkflowTraceMode, WorkflowTurbo, WorkflowErrorName, WorkflowErrorMessage, WorkflowErrorCode, WorkflowStepsCreated, WorkflowHooksCreated, WorkflowWaitsCreated, WorkflowStepsFailedSerialization, WorkflowOwnedRecoverySteps, WorkflowBackstopWakesArmed, WorkflowDispatchRepublishSkipped, WorkflowRouteType, WorkflowRouteHandlerCached, WorkflowRouteInvocationCount, WorkflowRouteEntrypointAgeMs, WorkflowRouteModuleBodyInitMs, FaasInstance, StepName, StepId, StepAttempt, StepStatus, StepMaxRetries, StepTracePropagated, StepTtfsMs, StepStsoMs, StepRsfsMs, StepFinalSchedulingReplayMs, StepLatencyOptimizations, StepStartStrategy, StepSkipped, StepSkipReason, StepArgumentsCount, StepResultType, StepErrorName, StepErrorMessage, StepFatalError, StepRetryExhausted, StepRetryTimeoutSeconds, StepRetryWillRetry, MessagingSystem, MessagingDestinationName, MessagingMessageId, MessagingOperationType, MessagingBatchMessageCount, QueueOverheadMs, DeploymentId, WorkflowRunPinnedDeploymentId, WorkflowDeploymentMismatchRetryCount, WorkflowDeploymentMismatchRecovered, WorkflowRunSpecVersion, WorkflowRunSpecVersionSource, WorkflowCapabilityProbeLatencyMs, WorkflowCapabilityProbeCached, WorkflowCapabilityProbeError, HookToken, HookId, HookFound, HookResilientResume, HookResumeCommitted, HookWakePublished, HookResilientResumeMaterialized, HookResumeSetupSource, StepResilientDispatchRecovered, StepResilientDispatchMaterialized, StepDispatchPrologue, ResumeTotalMs, ResumeProducerPrepMs, ResumeQueueDeliveryMs, ResumeSetupMs, ResumeReplayMs, ResumeStepDispatchMs, ResumeStepClaimMs, ResumeStepPrepareMs, ResumeTrigger, ResumeStrategy, ResumeSetupSource, ResumeStepExecution, WebhookHandlersTriggered, WorkflowSuspensionState, WorkflowSuspensionHookCount, WorkflowSuspensionStepCount, WorkflowSuspensionWaitCount, HttpRequestMethod, HttpRoute, UrlFull, ServerAddress, ServerPort, HttpResponseStatusCode, ErrorType, WorldParseFormat, WorkflowEventsPagesLoaded, QueueDeserializeTimeMs, QueueExecutionTimeMs, QueueSerializeTimeMs, SerializationOperation, SerializationCompressed, SerializationCodec, SerializationUncompressedBytes, SerializationStoredBytes, SerializationCompressionRatio, SerializationGuestCodeExecutions, SerializationGuestCodeDetails, PeerService, RpcSystem, RpcService, RpcMethod, ErrorRetryable, ErrorCategory;
 var init_semantic_conventions = __esm({
   "../core/dist/telemetry/semantic-conventions.js"() {
     "use strict";
@@ -27504,6 +27631,11 @@ var init_semantic_conventions = __esm({
     WorkflowRunPinnedDeploymentId = SemanticConvention("workflow.deployment.pinned_id");
     WorkflowDeploymentMismatchRetryCount = SemanticConvention("workflow.deployment_mismatch.retry_count");
     WorkflowDeploymentMismatchRecovered = SemanticConvention("workflow.deployment_mismatch.recovered");
+    WorkflowRunSpecVersion = SemanticConvention("workflow.run.spec_version");
+    WorkflowRunSpecVersionSource = SemanticConvention("workflow.run.spec_version_source");
+    WorkflowCapabilityProbeLatencyMs = SemanticConvention("workflow.capability_probe.latency_ms");
+    WorkflowCapabilityProbeCached = SemanticConvention("workflow.capability_probe.cached");
+    WorkflowCapabilityProbeError = SemanticConvention("workflow.capability_probe.error");
     HookToken = SemanticConvention("workflow.hook.token");
     HookId = SemanticConvention("workflow.hook.id");
     HookFound = SemanticConvention("workflow.hook.found");
@@ -32182,7 +32314,7 @@ var version2;
 var init_version = __esm({
   "../core/dist/version.js"() {
     "use strict";
-    version2 = "5.0.0-beta.55";
+    version2 = "5.0.0-beta.57";
   }
 });
 
@@ -32250,7 +32382,8 @@ function parseHealthCheckResponse(chunks) {
   } catch {
     if (responseText.length > 0) {
       return {
-        healthy: true
+        healthy: true,
+        format: "text"
       };
     }
     return null;
@@ -32260,7 +32393,8 @@ function parseHealthCheckResponse(chunks) {
   }
   const r = response;
   const parsed = {
-    healthy: r.healthy
+    healthy: r.healthy,
+    format: "json"
   };
   if (typeof r.specVersion === "number") {
     parsed.specVersion = r.specVersion;
@@ -32361,6 +32495,57 @@ var init_helpers = __esm({
   }
 });
 
+// ../core/dist/runtime/hook-wake.js
+function isRetryableWakeError(error61, isDeploymentUnavailableError) {
+  if (isDeploymentUnavailableError?.(error61)) return false;
+  const status = error61 ?? {};
+  const code2 = status.status ?? status.statusCode;
+  if (typeof code2 === "number") {
+    return code2 >= 500 || code2 === 408 || code2 === 429;
+  }
+  const name = error61?.name;
+  return name !== "BadRequestError" && name !== "UnauthorizedError" && name !== "ForbiddenError";
+}
+async function publishHookWakeWithRetry(publish, isDeploymentUnavailableError) {
+  let lastError;
+  for (let attempt = 0; attempt <= HOOK_WAKE_RETRY_DELAYS_MS.length; attempt++) {
+    try {
+      await publish();
+      return;
+    } catch (error61) {
+      lastError = error61;
+      if (!isRetryableWakeError(error61, isDeploymentUnavailableError)) break;
+      const delayMs = HOOK_WAKE_RETRY_DELAYS_MS[attempt];
+      if (delayMs !== void 0) {
+        await new Promise((resolve) => setTimeout(resolve, delayMs));
+      }
+    }
+  }
+  if (HookNotFoundError.is(lastError)) {
+    throw new WorkflowRuntimeError("The hook resume was committed, but its workflow wake could not be published", {
+      cause: lastError
+    });
+  }
+  throw lastError;
+}
+var HOOK_WAKE_RETRY_DELAYS_MS, FORCE_CLAIM_WAKE_REPUBLISH_WINDOW_MS;
+var init_hook_wake = __esm({
+  "../core/dist/runtime/hook-wake.js"() {
+    "use strict";
+    init_dist2();
+    init_dist4();
+    init_logger();
+    init_helpers();
+    HOOK_WAKE_RETRY_DELAYS_MS = [
+      25,
+      100
+    ];
+    __name(isRetryableWakeError, "isRetryableWakeError");
+    __name(publishHookWakeWithRetry, "publishHookWakeWithRetry");
+    FORCE_CLAIM_WAKE_REPUBLISH_WINDOW_MS = 24 * 60 * 60 * 1e3;
+  }
+});
+
 // ../core/dist/runtime/invocations.js
 var HookInvocationSchema, HookInvocationResultSchema;
 var init_invocations = __esm({
@@ -32393,6 +32578,18 @@ var init_invocations = __esm({
   }
 });
 
+// ../core/dist/runtime/run-spec-version.js
+function specVersionForRunWrite(runSpecVersion, whenUnknown = SPEC_VERSION_CURRENT) {
+  return Math.min(SPEC_VERSION_CURRENT, runSpecVersion ?? whenUnknown);
+}
+var init_run_spec_version = __esm({
+  "../core/dist/runtime/run-spec-version.js"() {
+    "use strict";
+    init_spec_version();
+    __name(specVersionForRunWrite, "specVersionForRunWrite");
+  }
+});
+
 // ../../node_modules/.pnpm/@vercel+functions@3.8.0_@aws-sdk+credential-provider-web-identity@3.972.49_ws@8.20.0/node_modules/@vercel/functions/headers.js
 var require_headers = __commonJS({
   "../../node_modules/.pnpm/@vercel+functions@3.8.0_@aws-sdk+credential-provider-web-identity@3.972.49_ws@8.20.0/node_modules/@vercel/functions/headers.js"(exports, module) {
@@ -37356,38 +37553,6 @@ async function computeResumePayloadDigest(bytes) {
   }
   return hex3;
 }
-function isRetryableWakeError(error61, isDeploymentUnavailableError) {
-  if (isDeploymentUnavailableError?.(error61)) return false;
-  const status = error61 ?? {};
-  const code2 = status.status ?? status.statusCode;
-  if (typeof code2 === "number") {
-    return code2 >= 500 || code2 === 408 || code2 === 429;
-  }
-  const name = error61?.name;
-  return name !== "BadRequestError" && name !== "UnauthorizedError" && name !== "ForbiddenError";
-}
-async function publishHookWakeWithRetry(publish, isDeploymentUnavailableError) {
-  let lastError;
-  for (let attempt = 0; attempt <= HOOK_WAKE_RETRY_DELAYS_MS.length; attempt++) {
-    try {
-      await publish();
-      return;
-    } catch (error61) {
-      lastError = error61;
-      if (!isRetryableWakeError(error61, isDeploymentUnavailableError)) break;
-      const delayMs = HOOK_WAKE_RETRY_DELAYS_MS[attempt];
-      if (delayMs !== void 0) {
-        await new Promise((resolve) => setTimeout(resolve, delayMs));
-      }
-    }
-  }
-  if (HookNotFoundError.is(lastError)) {
-    throw new WorkflowRuntimeError("The hook resume was committed, but its workflow wake could not be published", {
-      cause: lastError
-    });
-  }
-  throw lastError;
-}
 function resumeContextFromRun(run2) {
   const coreVersion = run2.executionContext?.workflowCoreVersion;
   const traceCarrier = run2.executionContext?.traceCarrier;
@@ -37469,163 +37634,268 @@ async function getHookByToken(token) {
 async function resumeHook(tokenOrHook, payload, encryptionKeyOverride) {
   return resumeHookImpl(tokenOrHook, payload, encryptionKeyOverride, false, Date.now());
 }
-async function resumeHookImpl(tokenOrHook, payload, encryptionKeyOverride, hookFreshlyLookedUp, resumeRequestedAtMs) {
+async function resumeHookImpl(tokenOrHook, payload, encryptionKeyOverride, hookFreshlyLookedUp, resumeRequestedAtMs, webhookOnly = false) {
   return await waitedUntil(() => {
     return trace("hook.resume", async (span) => {
       const world = await getWorldLazy();
-      try {
-        const suppliedToken = typeof tokenOrHook === "string";
-        const hook = suppliedToken ? await world.hooks.getByToken(tokenOrHook) : tokenOrHook;
-        const hookResumeCapabilitiesAreFresh = suppliedToken || hookFreshlyLookedUp;
-        const info = await resolveHookResumeInfo(hook);
-        const { resumeContext } = info;
-        span?.setAttributes({
-          ...HookToken(hook.token),
-          ...HookId(hook.hookId),
-          ...WorkflowRunId(hook.runId),
-          "workflow.hook.resume_context_source": info.source
-        });
-        if (info.run && isTerminalWorkflowRunStatus(info.run.status)) {
-          throw new HookNotFoundError(hook.token);
-        }
-        const capabilities = getRunCapabilities(resumeContext.workflowCoreVersion);
-        let payloadKey;
-        const runPublicKey = encryptionKeyOverride ? (
-          // hydrate hook metadata), so sealing would add an ECDH for no
-          // saved round trip. Reuse what it resolved.
-          void 0
-        ) : decodeRunPublicKey(resumeContext.encryptionPublicKey);
-        if (runPublicKey) {
-          payloadKey = sealTo(runPublicKey);
-        } else {
-          let encryptionKey = encryptionKeyOverride ?? await resolveHookEncryptionKey(hook, info);
-          if (!capabilities.supportedFormats.has(SerializationFormat.ENCRYPTED)) {
-            encryptionKey = void 0;
-          }
-          payloadKey = encryptionKey;
-        }
-        const compression = (resumeContext.runSpecVersion ?? 0) >= SPEC_VERSION_SUPPORTS_COMPRESSION && capabilities.supportedFormats.has(SerializationFormat.GZIP);
-        const ops = [];
-        const readbackOps = [];
-        const v1Compat = isLegacySpecVersion(hook.specVersion);
-        const dehydratedPayload = await dehydrateStepReturnValue(payload, hook.runId, payloadKey, ops, globalThis, v1Compat, capabilities.framedByteStreams, compression, void 0, readbackOps);
-        await Promise.all(ops.map((op) => op.catch((error61) => {
-          if (error61 !== void 0) throw error61;
-        })));
-        safeWaitUntil(Promise.all(readbackOps), (err) => {
-          if (err === void 0) return;
-          runtimeLogger.warn("Background readback of hook payload failed", {
-            workflowRunId: hook.runId,
-            hookId: hook.hookId,
-            error: err instanceof Error ? err.message : String(err)
-          });
-        });
-        span?.setAttributes({
-          ...WorkflowName(resumeContext.workflowName)
-        });
-        const originLink = await linkToTraceCarrier(resumeContext.traceCarrier);
-        if (originLink) {
-          span?.addLink?.(originLink);
-        }
-        if (world.capabilities?.invoke === true && !v1Compat && dehydratedPayload instanceof Uint8Array) {
-          if (!world.invoke) {
-            throw new WorkflowRuntimeError("World advertises invoke without implementing it");
-          }
+      const token = typeof tokenOrHook === "string" ? tokenOrHook : tokenOrHook.token;
+      let target = tokenOrHook;
+      let fresh = hookFreshlyLookedUp;
+      let keyOverride = encryptionKeyOverride;
+      let redirects = 0;
+      let lookupsAfterRedirect = 0;
+      const MAX_LOOKUPS_AFTER_REDIRECT = 5;
+      const resumeId = generateResumeId();
+      const assertResendable = /* @__PURE__ */ __name((cause) => {
+        if (payload instanceof Request && payload.body !== null && payload.bodyUsed) {
           span?.setAttributes({
-            "workflow.hook.resume_strategy": "invoke"
+            "workflow.hook.resume_redirect_unresendable": true
           });
-          const result = HookInvocationResultSchema.parse(await world.invoke(hook.runId, {
-            type: "hook_resume",
-            version: 1,
-            hookId: hook.hookId,
-            token: hook.token,
-            payload: dehydratedPayload
-          }, {
-            idempotencyKey: generateResumeId()
-          }));
-          if (result.status === "rejected") {
-            if (result.code === "HOOK_NOT_FOUND") throw new HookNotFoundError(hook.token);
-            throw new WorkflowRuntimeError("Executor rejected the hook invocation input");
-          }
-          span?.setAttributes(HookResumeCommitted(true));
-          return asLazyMetadataHook(hook);
-        }
-        const queueName = getWorkflowQueueName(resumeContext.workflowName);
-        const queueOptions = {
-          deploymentId: resumeContext.deploymentId,
-          specVersion: resumeContext.runSpecVersion ?? SPEC_VERSION_LEGACY
-        };
-        const backendDedupSupported = (hookResumeCapabilitiesAreFresh ? hook.resumeCapabilities?.hookResumeDedupVersion ?? 0 : 0) >= HOOK_RESUME_DEDUP_VERSION || world.capabilities?.hookResumeDedup === true;
-        const canClaimResume = backendDedupSupported && !v1Compat && dehydratedPayload instanceof Uint8Array;
-        span?.setAttributes({
-          "workflow.hook.resume_strategy": "sequential"
-        });
-        const resumeId = canClaimResume ? generateResumeId() : void 0;
-        const payloadDigest = canClaimResume ? await computeResumePayloadDigest(dehydratedPayload) : void 0;
-        if (resumeId) {
-          span?.setAttributes({
-            "workflow.hook.resume_id": resumeId
+          throw new WorkflowRuntimeError(`Hook token "${token}" changed owner while this webhook request was being delivered; a request body can be sent only once and it was not delivered anywhere \u2014 retry the request, which will reach the token's new owner`, {
+            cause
           });
         }
-        const isHookGoneError = /* @__PURE__ */ __name((err) => HookNotFoundError.is(err) || RunExpiredError.is(err), "isHookGoneError");
+      }, "assertResendable");
+      for (; ; ) {
         try {
-          await world.events.create(hook.runId, {
-            eventType: "hook_received",
-            specVersion: SPEC_VERSION_CURRENT,
-            correlationId: hook.hookId,
-            eventData: {
-              ...v1Compat ? {} : {
-                token: hook.token
-              },
-              payload: dehydratedPayload
-            }
-          }, {
-            v1Compat,
-            ...resumeId && payloadDigest ? {
-              resumeId,
-              resumePayloadDigest: payloadDigest
-            } : {}
-          });
+          return await resumeHookAttempt(world, span, target, payload, keyOverride, fresh, resumeRequestedAtMs, resumeId, webhookOnly);
         } catch (err) {
-          if (isHookGoneError(err)) {
-            throw new HookNotFoundError(hook.token);
+          if (err !== null && typeof err === "object" && notFoundReasons.get(err) === "not-webhook") {
+            throw err;
+          }
+          if (redirects >= MAX_FORCE_CLAIM_REDIRECTS) {
+            if (HookForceClaimedError.is(err)) {
+              span?.setAttributes({
+                "workflow.hook.resume_redirects_exhausted": true
+              });
+              throw new WorkflowRuntimeError(`Hook token "${token}" changed owner ${redirects} times while this resume was in flight; nothing was delivered \u2014 retry the resume`, {
+                cause: err
+              });
+            }
+            throw err;
+          }
+          if (HookForceClaimedError.is(err)) {
+            assertResendable(err);
+            redirects++;
+            span?.setAttributes({
+              "workflow.hook.resume_redirects": redirects,
+              "workflow.hook.resume_redirect_to_run": err.claimedByRunId
+            });
+            target = token;
+            fresh = true;
+            keyOverride = void 0;
+            lookupsAfterRedirect = 0;
+            continue;
+          }
+          if (HookNotFoundError.is(err) && redirects > 0 && typeof target === "string" && lookupsAfterRedirect < MAX_LOOKUPS_AFTER_REDIRECT) {
+            assertResendable(err);
+            lookupsAfterRedirect++;
+            await new Promise((resolve) => setTimeout(resolve, 50));
+            continue;
+          }
+          if (HookNotFoundError.is(err) && notFoundReasons.get(err) !== "lookup") {
+            const attemptedHookId = typeof target === "string" ? void 0 : target.hookId;
+            let relocated;
+            try {
+              relocated = await world.hooks.getByToken(token);
+            } catch (lookupError) {
+              if (!HookNotFoundError.is(lookupError)) {
+                runtimeLogger.warn("Hook resume: re-resolving the token after a not-found failed; surfacing the original error", {
+                  token,
+                  error: lookupError instanceof Error ? lookupError.message : String(lookupError)
+                });
+              }
+            }
+            if (relocated?.claimedFrom !== void 0 && relocated.hookId !== attemptedHookId && (attemptedHookId === void 0 || relocated.claimedFrom.hookId === attemptedHookId) && !(webhookOnly && relocated.isWebhook === false)) {
+              assertResendable(err);
+              redirects++;
+              span?.setAttributes({
+                "workflow.hook.resume_redirects": redirects,
+                "workflow.hook.resume_redirect_to_run": relocated.runId
+              });
+              target = relocated;
+              fresh = true;
+              keyOverride = void 0;
+              continue;
+            }
           }
           throw err;
         }
-        span?.setAttributes(HookResumeCommitted(true));
-        const queuePublishRequestedAtMs = Date.now();
-        await publishHookWakeWithRetry(() => world.queue(queueName, {
-          runId: hook.runId,
-          traceCarrier: resumeContext.traceCarrier ?? void 0,
-          hookResumeTiming: {
-            resumeRequestedAtMs,
-            queuePublishRequestedAtMs,
-            strategy: "sequential"
-          }
-        }, {
-          ...queueOptions,
-          // Dedup retried publishes whose response was lost: a
-          // duplicate wake is harmless for correctness (deterministic
-          // replay) but costs a full replay of the run, and the queue
-          // accepts a repeated idempotency key by delivering only one
-          // of the messages. Claim-less writes have no resumeId and
-          // keep the previous behavior.
-          ...resumeId ? {
-            idempotencyKey: `hook-${resumeId}`
-          } : {}
-        }), world.isDeploymentUnavailableError?.bind(world));
-        span?.setAttributes(HookWakePublished(true));
-        return asLazyMetadataHook(hook);
-      } catch (err) {
-        span?.setAttributes({
-          ...HookToken(typeof tokenOrHook === "string" ? tokenOrHook : tokenOrHook.token),
-          ...HookFound(false)
-        });
-        throw err;
       }
     });
   });
 }
+async function resumeHookAttempt(world, span, tokenOrHook, payload, encryptionKeyOverride, hookFreshlyLookedUp, resumeRequestedAtMs, logicalResumeId, webhookOnly) {
+  try {
+    const suppliedToken = typeof tokenOrHook === "string";
+    let hook;
+    if (suppliedToken) {
+      try {
+        hook = await world.hooks.getByToken(tokenOrHook);
+      } catch (lookupError) {
+        if (HookNotFoundError.is(lookupError)) {
+          notFoundReasons.set(lookupError, "lookup");
+        }
+        throw lookupError;
+      }
+    } else {
+      hook = tokenOrHook;
+    }
+    if (webhookOnly && hook.isWebhook === false) {
+      const notWebhook = new HookNotFoundError(hook.token);
+      notFoundReasons.set(notWebhook, "not-webhook");
+      throw notWebhook;
+    }
+    const hookResumeCapabilitiesAreFresh = suppliedToken || hookFreshlyLookedUp;
+    const info = await resolveHookResumeInfo(hook);
+    const { resumeContext } = info;
+    span?.setAttributes({
+      ...HookToken(hook.token),
+      ...HookId(hook.hookId),
+      ...WorkflowRunId(hook.runId),
+      "workflow.hook.resume_context_source": info.source
+    });
+    if (info.run && isTerminalWorkflowRunStatus(info.run.status)) {
+      throw new HookNotFoundError(hook.token);
+    }
+    const capabilities = getRunCapabilities(resumeContext.workflowCoreVersion);
+    let payloadKey;
+    const runPublicKey = encryptionKeyOverride ? (
+      // hydrate hook metadata), so sealing would add an ECDH for no
+      // saved round trip. Reuse what it resolved.
+      void 0
+    ) : decodeRunPublicKey(resumeContext.encryptionPublicKey);
+    if (runPublicKey) {
+      payloadKey = sealTo(runPublicKey);
+    } else {
+      let encryptionKey = encryptionKeyOverride ?? await resolveHookEncryptionKey(hook, info);
+      if (!capabilities.supportedFormats.has(SerializationFormat.ENCRYPTED)) {
+        encryptionKey = void 0;
+      }
+      payloadKey = encryptionKey;
+    }
+    const compression = (resumeContext.runSpecVersion ?? 0) >= SPEC_VERSION_SUPPORTS_COMPRESSION && capabilities.supportedFormats.has(SerializationFormat.GZIP);
+    const ops = [];
+    const readbackOps = [];
+    const v1Compat = isLegacySpecVersion(hook.specVersion);
+    const dehydratedPayload = await dehydrateStepReturnValue(payload, hook.runId, payloadKey, ops, globalThis, v1Compat, capabilities.framedByteStreams, compression, void 0, readbackOps);
+    await Promise.all(ops.map((op) => op.catch((error61) => {
+      if (error61 !== void 0) throw error61;
+    })));
+    safeWaitUntil(Promise.all(readbackOps), (err) => {
+      if (err === void 0) return;
+      runtimeLogger.warn("Background readback of hook payload failed", {
+        workflowRunId: hook.runId,
+        hookId: hook.hookId,
+        error: err instanceof Error ? err.message : String(err)
+      });
+    });
+    if (world.capabilities?.invoke === true && !v1Compat && dehydratedPayload instanceof Uint8Array) {
+      if (!world.invoke) {
+        throw new WorkflowRuntimeError("World advertises invoke without implementing it");
+      }
+      span?.setAttributes({
+        "workflow.hook.resume_strategy": "invoke"
+      });
+      const result = HookInvocationResultSchema.parse(await world.invoke(hook.runId, {
+        type: "hook_resume",
+        version: 1,
+        hookId: hook.hookId,
+        token: hook.token,
+        payload: dehydratedPayload
+      }, {
+        idempotencyKey: logicalResumeId
+      }));
+      if (result.status === "rejected") {
+        if (result.code === "HOOK_NOT_FOUND") throw new HookNotFoundError(hook.token);
+        throw new WorkflowRuntimeError("Executor rejected the hook invocation input");
+      }
+      span?.setAttributes(HookResumeCommitted(true));
+      return asLazyMetadataHook(hook);
+    }
+    span?.setAttributes({
+      ...WorkflowName(resumeContext.workflowName)
+    });
+    const originLink = await linkToTraceCarrier(resumeContext.traceCarrier);
+    if (originLink) {
+      span?.addLink?.(originLink);
+    }
+    const queueName = getWorkflowQueueName(resumeContext.workflowName);
+    const queueOptions = {
+      deploymentId: resumeContext.deploymentId,
+      specVersion: resumeContext.runSpecVersion ?? SPEC_VERSION_LEGACY
+    };
+    const backendDedupSupported = (hookResumeCapabilitiesAreFresh ? hook.resumeCapabilities?.hookResumeDedupVersion ?? 0 : 0) >= HOOK_RESUME_DEDUP_VERSION || world.capabilities?.hookResumeDedup === true;
+    const canClaimResume = backendDedupSupported && !v1Compat && dehydratedPayload instanceof Uint8Array;
+    span?.setAttributes({
+      "workflow.hook.resume_strategy": "sequential"
+    });
+    const resumeId = canClaimResume ? logicalResumeId : void 0;
+    const payloadDigest = canClaimResume ? await computeResumePayloadDigest(dehydratedPayload) : void 0;
+    if (resumeId) {
+      span?.setAttributes({
+        "workflow.hook.resume_id": resumeId
+      });
+    }
+    const isHookGoneError = /* @__PURE__ */ __name((err) => HookNotFoundError.is(err) || RunExpiredError.is(err), "isHookGoneError");
+    try {
+      await world.events.create(hook.runId, {
+        eventType: "hook_received",
+        // The payload is already encoded for the run (see `compression`).
+        specVersion: specVersionForRunWrite(resumeContext.runSpecVersion),
+        correlationId: hook.hookId,
+        eventData: {
+          ...v1Compat ? {} : {
+            token: hook.token
+          },
+          payload: dehydratedPayload
+        }
+      }, {
+        v1Compat,
+        ...resumeId && payloadDigest ? {
+          resumeId,
+          resumePayloadDigest: payloadDigest
+        } : {}
+      });
+    } catch (err) {
+      if (HookForceClaimedError.is(err)) throw err;
+      if (isHookGoneError(err)) {
+        throw new HookNotFoundError(hook.token);
+      }
+      throw err;
+    }
+    span?.setAttributes(HookResumeCommitted(true));
+    const queuePublishRequestedAtMs = Date.now();
+    await publishHookWakeWithRetry(() => world.queue(queueName, {
+      runId: hook.runId,
+      traceCarrier: resumeContext.traceCarrier ?? void 0,
+      hookResumeTiming: {
+        resumeRequestedAtMs,
+        queuePublishRequestedAtMs,
+        strategy: "sequential"
+      }
+    }, {
+      ...queueOptions,
+      // Dedup retried publishes whose response was lost: a
+      // duplicate wake is harmless for correctness (deterministic
+      // replay) but costs a full replay of the run, and the queue
+      // accepts a repeated idempotency key by delivering only one
+      // of the messages. Claim-less writes have no resumeId and
+      // keep the previous behavior.
+      ...resumeId ? {
+        idempotencyKey: `hook-${resumeId}`
+      } : {}
+    }), world.isDeploymentUnavailableError?.bind(world));
+    span?.setAttributes(HookWakePublished(true));
+    return asLazyMetadataHook(hook);
+  } catch (err) {
+    span?.setAttributes({
+      ...HookToken(typeof tokenOrHook === "string" ? tokenOrHook : tokenOrHook.token),
+      ...HookFound(false)
+    });
+    throw err;
+  }
+}
 async function resumeWebhook(token, request) {
   const resumeRequestedAtMs = Date.now();
   const world = await getWorldLazy();
@@ -37653,7 +37923,7 @@ async function resumeWebhook(token, request) {
       status: 202
     });
   }
-  await resumeHookImpl(hook, request, metadataEncryptionKey(), true, resumeRequestedAtMs);
+  await resumeHookImpl(hook, request, metadataEncryptionKey(), true, resumeRequestedAtMs, true);
   if (responseReadable) {
     const reader = responseReadable.getReader();
     const chunk = await reader.read();
@@ -37669,7 +37939,7 @@ async function resumeWebhook(token, request) {
   }
   return response;
 }
-var generateResumeId, HOOK_WAKE_RETRY_DELAYS_MS;
+var generateResumeId, MAX_FORCE_CLAIM_REDIRECTS, notFoundReasons;
 var init_resume_hook = __esm({
   "../core/dist/runtime/resume-hook.js"() {
     "use strict";
@@ -37687,16 +37957,12 @@ var init_resume_hook = __esm({
     init_telemetry();
     init_get_world_lazy();
     init_helpers();
+    init_hook_wake();
     init_invocations();
+    init_run_spec_version();
     init_wait_until();
     generateResumeId = monotonicFactory();
     __name(computeResumePayloadDigest, "computeResumePayloadDigest");
-    HOOK_WAKE_RETRY_DELAYS_MS = [
-      25,
-      100
-    ];
-    __name(isRetryableWakeError, "isRetryableWakeError");
-    __name(publishHookWakeWithRetry, "publishHookWakeWithRetry");
     __name(resumeContextFromRun, "resumeContextFromRun");
     __name(resolveHookResumeInfo, "resolveHookResumeInfo");
     __name(resolveHookEncryptionKey, "resolveHookEncryptionKey");
@@ -37705,7 +37971,10 @@ var init_resume_hook = __esm({
     __name(asLazyMetadataHook, "asLazyMetadataHook");
     __name(getHookByToken, "getHookByToken");
     __name(resumeHook, "resumeHook");
+    MAX_FORCE_CLAIM_REDIRECTS = 3;
+    notFoundReasons = /* @__PURE__ */ new WeakMap();
     __name(resumeHookImpl, "resumeHookImpl");
+    __name(resumeHookAttempt, "resumeHookAttempt");
     __name(resumeWebhook, "resumeWebhook");
   }
 });
@@ -39145,13 +39414,13 @@ async function dehydrateStepReturnValue(value, runId, key, ops = [], global2 = g
     });
   }
 }
-async function hydrateRunError(value, runId, key, ops = [], global2 = globalThis, extraRevivers = {}) {
+async function hydrateRunError(value, runId, key, ops = [], global2 = globalThis, extraRevivers = {}, options) {
   const compressionStats = {};
   const decrypted = await decompress(await decrypt2(value, key), compressionStats);
   await recordCompression(compressionStats, "deserialize");
   if (!(decrypted instanceof Uint8Array)) {
     return unflatten(decrypted, {
-      ...getExternalRevivers(global2, ops, runId, key),
+      ...getExternalRevivers(global2, ops, runId, key, options),
       ...extraRevivers
     });
   }
@@ -39159,7 +39428,7 @@ async function hydrateRunError(value, runId, key, ops = [], global2 = globalThis
   if (format === SerializationFormat.DEVALUE_V1) {
     const str = new TextDecoder().decode(payload);
     return parse(str, {
-      ...getExternalRevivers(global2, ops, runId, key),
+      ...getExternalRevivers(global2, ops, runId, key, options),
       ...extraRevivers
     });
   }
@@ -39685,11 +39954,11 @@ __builtin_set_attributes.maxRetries = INTERNAL_ATTRIBUTES_MAX_ATTEMPTS - 1;
 init_dist2();
 init_dist3();
 init_env_config();
-init_spec_version();
 init_encryption2();
 init_serialization2();
 init_util2();
 init_get_world_lazy();
+init_run_spec_version();
 
 // ../core/dist/runtime/runs.js
 init_dist2();
@@ -39697,6 +39966,7 @@ init_dist4();
 init_encryption2();
 init_serialization2();
 init_helpers();
+init_run_spec_version();
 
 // ../core/dist/runtime/start.js
 init_dist2();
@@ -39814,8 +40084,34 @@ __name(getWorkflowVmFromEnv, "getWorkflowVmFromEnv");
 // ../core/dist/runtime/start.js
 init_wait_until();
 init_world_compatibility();
-var CROSS_DEPLOYMENT_CAPABILITY_PROBE_TIMEOUT_MS = 2e3;
+var CROSS_DEPLOYMENT_CAPABILITY_PROBE_TIMEOUT_MS = 1e4;
+var CROSS_DEPLOYMENT_PROBE_RETRY_TIMEOUT_MS = 2e3;
+var CROSS_DEPLOYMENT_PROBE_CACHE_TTL_MS = 10 * 6e4;
+var CROSS_DEPLOYMENT_PROBE_MISS_TTL_MS = 6e4;
+var CROSS_DEPLOYMENT_PROBE_CACHE_MAX_ENTRIES = 256;
 var RETENTION_ZERO_ATTRIBUTE_VALUE = "0";
+function resolveCrossDeploymentSpecVersion(probe, callerSpecVersion) {
+  let target;
+  let source;
+  if (typeof probe?.specVersion === "number" && Number.isInteger(probe.specVersion) && probe.specVersion >= 1) {
+    target = probe.specVersion;
+    source = "probe";
+  } else if (probe?.format === "json") {
+    target = SPEC_VERSION_SUPPORTS_CBOR_QUEUE_TRANSPORT;
+    source = "probe-malformed";
+  } else if (probe?.healthy) {
+    target = SPEC_VERSION_SUPPORTS_EVENT_SOURCING;
+    source = "probe-unversioned";
+  } else {
+    target = SPEC_VERSION_SUPPORTS_SLOT_IDENTITY;
+    source = probe ? "probe-miss" : "no-probe-channel";
+  }
+  return {
+    specVersion: Math.min(target, callerSpecVersion),
+    source
+  };
+}
+__name(resolveCrossDeploymentSpecVersion, "resolveCrossDeploymentSpecVersion");
 var ulid3 = monotonicFactory();
 function resolveLineageAttributes() {
   const store = contextStorage.getStore();
@@ -39830,6 +40126,54 @@ __name(resolveLineageAttributes, "resolveLineageAttributes");
 var latestNoOpWarning = globalSingleton("@workflow/core//latestNoOpWarning", 1, () => ({
   warned: false
 }));
+var probeMissWarning = globalSingleton("@workflow/core//crossDeploymentProbeMissWarning", 1, () => ({
+  warned: false
+}));
+var crossDeploymentProbeCache = globalSingleton("@workflow/core//crossDeploymentProbeCache", 1, () => /* @__PURE__ */ new WeakMap());
+async function probeCrossDeployment(world, options) {
+  let byDeployment = crossDeploymentProbeCache.get(world);
+  if (!byDeployment) {
+    byDeployment = /* @__PURE__ */ new Map();
+    crossDeploymentProbeCache.set(world, byDeployment);
+  }
+  const key = `${options.namespace ?? ""}\0${options.deploymentId}`;
+  const now = Date.now();
+  const entry = byDeployment.get(key);
+  if (entry?.probe !== void 0 && now - entry.at < CROSS_DEPLOYMENT_PROBE_CACHE_TTL_MS) {
+    return {
+      probe: entry.probe,
+      cached: true
+    };
+  }
+  const recentMiss = entry !== void 0 && entry.probe === void 0 && now - entry.at < CROSS_DEPLOYMENT_PROBE_MISS_TTL_MS;
+  const probe = await healthCheck(world, {
+    deploymentId: options.deploymentId,
+    runId: options.runId,
+    timeout: recentMiss ? CROSS_DEPLOYMENT_PROBE_RETRY_TIMEOUT_MS : CROSS_DEPLOYMENT_CAPABILITY_PROBE_TIMEOUT_MS,
+    namespace: options.namespace
+  }).catch(() => void 0);
+  const answered = probe?.format !== void 0;
+  byDeployment.delete(key);
+  byDeployment.set(key, {
+    // A repeated miss keeps the first miss's time, so the short budget ends
+    // `CROSS_DEPLOYMENT_PROBE_MISS_TTL_MS` after it.
+    at: !answered && recentMiss ? entry.at : Date.now(),
+    // The run public key is per run, so it is never reused.
+    probe: answered ? {
+      ...probe,
+      encryptionPublicKey: void 0
+    } : void 0
+  });
+  if (byDeployment.size > CROSS_DEPLOYMENT_PROBE_CACHE_MAX_ENTRIES) {
+    const oldest = byDeployment.keys().next().value;
+    if (oldest !== void 0) byDeployment.delete(oldest);
+  }
+  return {
+    probe,
+    cached: false
+  };
+}
+__name(probeCrossDeployment, "probeCrossDeployment");
 async function start(workflow, argsOrOptions, options) {
   return await waitedUntil(() => {
     const workflowName = workflow?.workflowId;
@@ -39856,19 +40200,34 @@ async function start(workflow, argsOrOptions, options) {
       });
       const world = opts.world ?? await getWorldLazy();
       assertWorldSupportsRuntimeProtocol(world);
-      const currentDeploymentId = await world.getDeploymentId();
-      let deploymentId = opts.deploymentId ?? currentDeploymentId;
-      if (deploymentId === "latest") {
-        if (world.resolveLatestDeploymentId) {
-          deploymentId = await world.resolveLatestDeploymentId();
-        } else {
-          if (!latestNoOpWarning.warned) {
-            latestNoOpWarning.warned = true;
-            runtimeLogger.warn("deploymentId: 'latest' has no effect in this world and was ignored. It is only supported by worlds with atomic deployments, such as Vercel. The run will target the current deployment.", {
-              currentDeploymentId
-            });
+      let currentDeploymentId;
+      let deploymentId;
+      if (opts.deploymentId === void 0 || opts.deploymentId === "latest") {
+        const current = await world.getDeploymentId();
+        currentDeploymentId = current;
+        deploymentId = opts.deploymentId ?? current;
+        if (deploymentId === "latest") {
+          if (world.resolveLatestDeploymentId) {
+            deploymentId = await world.resolveLatestDeploymentId();
+          } else {
+            if (!latestNoOpWarning.warned) {
+              latestNoOpWarning.warned = true;
+              runtimeLogger.warn("deploymentId: 'latest' has no effect in this world and was ignored. It is only supported by worlds with atomic deployments, such as Vercel. The run will target the current deployment.", {
+                currentDeploymentId
+              });
+            }
+            deploymentId = current;
           }
-          deploymentId = currentDeploymentId;
+        }
+      } else {
+        deploymentId = opts.deploymentId;
+        try {
+          currentDeploymentId = await world.getDeploymentId();
+        } catch (err) {
+          runtimeLogger.debug("Current deployment is unavailable; starting as a cross-deployment run", {
+            deploymentId,
+            error: String(err)
+          });
         }
       }
       const runId = `wrun_${world.createRunId ? world.createRunId(opts) : ulid3()}`;
@@ -39876,36 +40235,61 @@ async function start(workflow, argsOrOptions, options) {
       let targetSupportsCompression;
       let targetHookResumeInputVersion;
       let probedRunPublicKey;
-      if (deploymentId === currentDeploymentId) {
+      let targetSpecVersion;
+      let specVersionSource;
+      const crossDeployment = deploymentId !== currentDeploymentId;
+      if (!crossDeployment) {
         framedByteStreams = true;
         targetSupportsCompression = true;
         targetHookResumeInputVersion = HOOK_RESUME_INPUT_VERSION;
+        targetSpecVersion = world.specVersion;
+        specVersionSource = "same-deployment";
       } else if (typeof world.streams?.get !== "function") {
         framedByteStreams = false;
         targetSupportsCompression = false;
         targetHookResumeInputVersion = void 0;
+        ({ specVersion: targetSpecVersion, source: specVersionSource } = resolveCrossDeploymentSpecVersion(void 0, world.specVersion));
       } else {
-        const probe = await healthCheck(world, {
+        const { probe, cached: cached2 } = await probeCrossDeployment(world, {
           deploymentId,
           runId,
-          timeout: CROSS_DEPLOYMENT_CAPABILITY_PROBE_TIMEOUT_MS,
           namespace: opts.namespace
-        }).catch(() => void 0);
+        });
         probedRunPublicKey = probe?.encryptionPublicKey;
         const capabilities = getRunCapabilities(probe?.workflowCoreVersion);
         framedByteStreams = capabilities.framedByteStreams;
         targetSupportsCompression = capabilities.supportedFormats.has(SerializationFormat.GZIP);
         targetHookResumeInputVersion = probe?.hookResumeInputVersion;
+        ({ specVersion: targetSpecVersion, source: specVersionSource } = resolveCrossDeploymentSpecVersion(probe, world.specVersion));
+        span?.setAttributes({
+          ...WorkflowCapabilityProbeCached(cached2),
+          ...!cached2 && probe?.latencyMs !== void 0 ? WorkflowCapabilityProbeLatencyMs(probe.latencyMs) : {},
+          ...!cached2 && probe?.error ? WorkflowCapabilityProbeError(probe.error) : {}
+        });
+        if (specVersionSource === "probe-miss" && opts.specVersion === void 0 && !probeMissWarning.warned) {
+          probeMissWarning.warned = true;
+          runtimeLogger.warn("The target deployment did not answer the capability probe, so the run was stamped with a fallback spec version instead of the target's own. A target on an older major version may not be able to execute it.", {
+            deploymentId,
+            specVersion: targetSpecVersion,
+            error: probe?.error
+          });
+        }
       }
       const ops = [];
       const traceCarrier = await serializeTraceCarrier();
-      const specVersion = opts.specVersion ?? world.specVersion;
+      const specVersion = opts.specVersion ?? targetSpecVersion;
+      if (opts.specVersion !== void 0) specVersionSource = "explicit";
+      span?.setAttributes({
+        ...WorkflowRunSpecVersion(specVersion),
+        ...WorkflowRunSpecVersionSource(specVersionSource)
+      });
+      const specGateError = /* @__PURE__ */ __name((featureRequires) => new WorkflowRuntimeError(crossDeployment && opts.specVersion === void 0 ? `${featureRequires} spec version ${SPEC_VERSION_SUPPORTS_ATTRIBUTES} or later, but the target deployment (${deploymentId}) runs spec version ${specVersion}.` : `${featureRequires} a World that supports spec version ${SPEC_VERSION_SUPPORTS_ATTRIBUTES} or later.`), "specGateError");
       const v1Compat = isLegacySpecVersion(specVersion);
       const allowReservedAttributes = opts.allowReservedAttributes === true;
       let attributes;
       if (opts.attributes && Object.keys(opts.attributes).length > 0) {
         if (specVersion < SPEC_VERSION_SUPPORTS_ATTRIBUTES) {
-          throw new WorkflowRuntimeError("Initial workflow attributes require a World that supports spec version 4 or later.");
+          throw specGateError("Initial workflow attributes require");
         }
         for (const [key, value] of Object.entries(opts.attributes)) {
           if (typeof value !== "string") {
@@ -39926,7 +40310,7 @@ async function start(workflow, argsOrOptions, options) {
           throw new WorkflowRuntimeError(`start({ experimental_retention }) must be 0 or 'default'; received ${JSON.stringify(opts.experimental_retention)}.`);
         }
         if (specVersion < SPEC_VERSION_SUPPORTS_ATTRIBUTES) {
-          throw new WorkflowRuntimeError("start({ experimental_retention }) requires a World that supports spec version 4 or later.");
+          throw specGateError("start({ experimental_retention }) requires");
         }
         retentionAttribute = {
           [RETENTION_ATTRIBUTE]: RETENTION_ZERO_ATTRIBUTE_VALUE
@@ -40086,7 +40470,7 @@ __name(start, "start");
     value: "start",
     configurable: true
   });
-})(start, "step//@workflow/core/runtime/start@5.0.0-beta.55//start");
+})(start, "step//@workflow/core/runtime/start@5.0.0-beta.57//start");
 
 // ../core/dist/runtime/runs.js
 async function wakeUpRun(world, runId, options) {
@@ -40128,7 +40512,7 @@ async function wakeUpRun(world, runId, options) {
       } : {
         eventType: "wait_completed",
         correlationId: waitEvent.correlationId,
-        specVersion: run2.specVersion,
+        specVersion: specVersionForRunWrite(run2.specVersion),
         eventData: {
           resumeAt: waitEvent.eventData.resumeAt
         }
@@ -40151,7 +40535,7 @@ async function wakeUpRun(world, runId, options) {
         runId
       }, {
         deploymentId: run2.deploymentId,
-        specVersion: run2.specVersion ?? SPEC_VERSION_LEGACY
+        specVersion: specVersionForRunWrite(run2.specVersion, SPEC_VERSION_LEGACY)
       });
     }
     if (errors.length > 0) {
@@ -40302,9 +40686,12 @@ var Run = class _Run {
    */
   async cancel(options) {
     const world = await this.#lazyWorldPromise;
+    const run2 = await world.runs.get(this.runId, {
+      resolveData: "none"
+    });
     await world.events.create(this.runId, {
       eventType: "run_cancelled",
-      specVersion: SPEC_VERSION_CURRENT,
+      specVersion: specVersionForRunWrite(run2.specVersion),
       ...options?.cancelReason !== void 0 ? {
         eventData: {
           cancelReason: options.cancelReason
@@ -40557,7 +40944,7 @@ var Run = class _Run {
     value: "wakeUp",
     configurable: true
   });
-})(Run.prototype["wakeUp"], "step//@workflow/core/runtime/run@5.0.0-beta.55//Run#wakeUp");
+})(Run.prototype["wakeUp"], "step//@workflow/core/runtime/run@5.0.0-beta.57//Run#wakeUp");
 (function(__wf_fn, __wf_id) {
   var __wf_sym = /* @__PURE__ */ Symbol.for("@workflow/core//registeredSteps"), __wf_reg = globalThis[__wf_sym] || (globalThis[__wf_sym] = /* @__PURE__ */ new Map());
   __wf_reg.set(__wf_id, __wf_fn);
@@ -40566,7 +40953,7 @@ var Run = class _Run {
     value: "cancel",
     configurable: true
   });
-})(Run.prototype["cancel"], "step//@workflow/core/runtime/run@5.0.0-beta.55//Run#cancel");
+})(Run.prototype["cancel"], "step//@workflow/core/runtime/run@5.0.0-beta.57//Run#cancel");
 (function(__wf_fn, __wf_id) {
   var __wf_sym = /* @__PURE__ */ Symbol.for("@workflow/core//registeredSteps"), __wf_reg = globalThis[__wf_sym] || (globalThis[__wf_sym] = /* @__PURE__ */ new Map());
   __wf_reg.set(__wf_id, __wf_fn);
@@ -40575,7 +40962,7 @@ var Run = class _Run {
     value: "getReadable",
     configurable: true
   });
-})(Run.prototype["getReadable"], "step//@workflow/core/runtime/run@5.0.0-beta.55//Run#getReadable");
+})(Run.prototype["getReadable"], "step//@workflow/core/runtime/run@5.0.0-beta.57//Run#getReadable");
 (function(__wf_fn, __wf_id) {
   var __wf_sym = /* @__PURE__ */ Symbol.for("@workflow/core//registeredSteps"), __wf_reg = globalThis[__wf_sym] || (globalThis[__wf_sym] = /* @__PURE__ */ new Map());
   __wf_reg.set(__wf_id, __wf_fn);
@@ -40584,7 +40971,7 @@ var Run = class _Run {
     value: "getWritable",
     configurable: true
   });
-})(Run.prototype["getWritable"], "step//@workflow/core/runtime/run@5.0.0-beta.55//Run#getWritable");
+})(Run.prototype["getWritable"], "step//@workflow/core/runtime/run@5.0.0-beta.57//Run#getWritable");
 (function(__wf_fn, __wf_id) {
   var __wf_sym = /* @__PURE__ */ Symbol.for("@workflow/core//registeredSteps"), __wf_reg = globalThis[__wf_sym] || (globalThis[__wf_sym] = /* @__PURE__ */ new Map());
   __wf_reg.set(__wf_id, __wf_fn);
@@ -40593,7 +40980,7 @@ var Run = class _Run {
     value: "exists",
     configurable: true
   });
-})(Object.getOwnPropertyDescriptor(Run.prototype, "exists").get, "step//@workflow/core/runtime/run@5.0.0-beta.55//Run#exists");
+})(Object.getOwnPropertyDescriptor(Run.prototype, "exists").get, "step//@workflow/core/runtime/run@5.0.0-beta.57//Run#exists");
 (function(__wf_fn, __wf_id) {
   var __wf_sym = /* @__PURE__ */ Symbol.for("@workflow/core//registeredSteps"), __wf_reg = globalThis[__wf_sym] || (globalThis[__wf_sym] = /* @__PURE__ */ new Map());
   __wf_reg.set(__wf_id, __wf_fn);
@@ -40602,7 +40989,7 @@ var Run = class _Run {
     value: "status",
     configurable: true
   });
-})(Object.getOwnPropertyDescriptor(Run.prototype, "status").get, "step//@workflow/core/runtime/run@5.0.0-beta.55//Run#status");
+})(Object.getOwnPropertyDescriptor(Run.prototype, "status").get, "step//@workflow/core/runtime/run@5.0.0-beta.57//Run#status");
 (function(__wf_fn, __wf_id) {
   var __wf_sym = /* @__PURE__ */ Symbol.for("@workflow/core//registeredSteps"), __wf_reg = globalThis[__wf_sym] || (globalThis[__wf_sym] = /* @__PURE__ */ new Map());
   __wf_reg.set(__wf_id, __wf_fn);
@@ -40611,7 +40998,7 @@ var Run = class _Run {
     value: "returnValue",
     configurable: true
   });
-})(Object.getOwnPropertyDescriptor(Run.prototype, "returnValue").get, "step//@workflow/core/runtime/run@5.0.0-beta.55//Run#returnValue");
+})(Object.getOwnPropertyDescriptor(Run.prototype, "returnValue").get, "step//@workflow/core/runtime/run@5.0.0-beta.57//Run#returnValue");
 (function(__wf_fn, __wf_id) {
   var __wf_sym = /* @__PURE__ */ Symbol.for("@workflow/core//registeredSteps"), __wf_reg = globalThis[__wf_sym] || (globalThis[__wf_sym] = /* @__PURE__ */ new Map());
   __wf_reg.set(__wf_id, __wf_fn);
@@ -40620,7 +41007,7 @@ var Run = class _Run {
     value: "workflowName",
     configurable: true
   });
-})(Object.getOwnPropertyDescriptor(Run.prototype, "workflowName").get, "step//@workflow/core/runtime/run@5.0.0-beta.55//Run#workflowName");
+})(Object.getOwnPropertyDescriptor(Run.prototype, "workflowName").get, "step//@workflow/core/runtime/run@5.0.0-beta.57//Run#workflowName");
 (function(__wf_fn, __wf_id) {
   var __wf_sym = /* @__PURE__ */ Symbol.for("@workflow/core//registeredSteps"), __wf_reg = globalThis[__wf_sym] || (globalThis[__wf_sym] = /* @__PURE__ */ new Map());
   __wf_reg.set(__wf_id, __wf_fn);
@@ -40629,7 +41016,7 @@ var Run = class _Run {
     value: "createdAt",
     configurable: true
   });
-})(Object.getOwnPropertyDescriptor(Run.prototype, "createdAt").get, "step//@workflow/core/runtime/run@5.0.0-beta.55//Run#createdAt");
+})(Object.getOwnPropertyDescriptor(Run.prototype, "createdAt").get, "step//@workflow/core/runtime/run@5.0.0-beta.57//Run#createdAt");
 (function(__wf_fn, __wf_id) {
   var __wf_sym = /* @__PURE__ */ Symbol.for("@workflow/core//registeredSteps"), __wf_reg = globalThis[__wf_sym] || (globalThis[__wf_sym] = /* @__PURE__ */ new Map());
   __wf_reg.set(__wf_id, __wf_fn);
@@ -40638,7 +41025,7 @@ var Run = class _Run {
     value: "startedAt",
     configurable: true
   });
-})(Object.getOwnPropertyDescriptor(Run.prototype, "startedAt").get, "step//@workflow/core/runtime/run@5.0.0-beta.55//Run#startedAt");
+})(Object.getOwnPropertyDescriptor(Run.prototype, "startedAt").get, "step//@workflow/core/runtime/run@5.0.0-beta.57//Run#startedAt");
 (function(__wf_fn, __wf_id) {
   var __wf_sym = /* @__PURE__ */ Symbol.for("@workflow/core//registeredSteps"), __wf_reg = globalThis[__wf_sym] || (globalThis[__wf_sym] = /* @__PURE__ */ new Map());
   __wf_reg.set(__wf_id, __wf_fn);
@@ -40647,7 +41034,7 @@ var Run = class _Run {
     value: "completedAt",
     configurable: true
   });
-})(Object.getOwnPropertyDescriptor(Run.prototype, "completedAt").get, "step//@workflow/core/runtime/run@5.0.0-beta.55//Run#completedAt");
+})(Object.getOwnPropertyDescriptor(Run.prototype, "completedAt").get, "step//@workflow/core/runtime/run@5.0.0-beta.57//Run#completedAt");
 (function(__wf_cls, __wf_id) {
   var __wf_sym = /* @__PURE__ */ Symbol.for("workflow-class-registry"), __wf_reg = globalThis[__wf_sym] || (globalThis[__wf_sym] = /* @__PURE__ */ new Map());
   __wf_reg.set(__wf_id, __wf_cls);
@@ -40657,7 +41044,7 @@ var Run = class _Run {
     enumerable: false,
     configurable: false
   });
-})(Run, "class//@workflow/core/runtime/run@5.0.0-beta.55//Run");
+})(Run, "class//@workflow/core/runtime/run@5.0.0-beta.57//Run");
 
 // ../workflow/dist/stdlib.js
 async function fetch2(...args) {