@workflow/world-testing 5.0.0-beta.54 → 5.0.0-beta.56

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

@@ -21110,7 +21110,30 @@ var init_events2 = __esm({
         tokenRetentionUntil: external_exports2.coerce.date().optional(),
         metadata: SerializedDataSchema2.optional(),
         isWebhook: external_exports2.boolean().optional(),
-        isSystem: external_exports2.boolean().optional()
+        isSystem: external_exports2.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_exports2.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_exports2.object({
+          runId: external_exports2.string(),
+          hookId: external_exports2.string(),
+          workflowName: external_exports2.string().optional(),
+          deploymentId: external_exports2.string().optional(),
+          runSpecVersion: external_exports2.number().optional()
+        }).optional()
       })
     }));
     HookReceivedEventSchema2 = external_exports2.compile(BaseEventSchema2.extend({
@@ -21125,7 +21148,14 @@ var init_events2 = __esm({
       eventType: external_exports2.literal("hook_disposed"),
       correlationId: external_exports2.string(),
       eventData: external_exports2.object({
-        token: external_exports2.string().optional()
+        token: external_exports2.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_exports2.object({ runId: external_exports2.string(), hookId: external_exports2.string() }).optional()
       }).optional()
     }));
     HookConflictEventSchema2 = external_exports2.compile(BaseEventSchema2.extend({
@@ -21135,7 +21165,18 @@ var init_events2 = __esm({
         token: external_exports2.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_exports2.string().optional()
+        conflictingRunId: external_exports2.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_exports2.literal("victim-spec-version").optional()
       })
     }));
     NoopEventSchema2 = external_exports2.compile(BaseEventSchema2.extend({
@@ -22035,7 +22076,7 @@ var init_queue2 = __esm({
 });
 
 // ../world/dist/hooks.js
-var HookResumeContextSchema2, HOOK_RESUME_INPUT_VERSION2, HOOK_RESUME_DEDUP_VERSION2, HookResumeCapabilitiesSchema2, HookSchema2;
+var HookResumeContextSchema2, HOOK_RESUME_INPUT_VERSION2, HOOK_RESUME_DEDUP_VERSION2, HookResumeCapabilitiesSchema2, HookClaimedFromSchema2, HookSchema2;
 var init_hooks2 = __esm({
   "../world/dist/hooks.js"() {
     "use strict";
@@ -22076,6 +22117,13 @@ var init_hooks2 = __esm({
       // is engaged.
       hookResumeDedupVersion: external_exports2.number()
     }));
+    HookClaimedFromSchema2 = external_exports2.compile(external_exports2.object({
+      runId: external_exports2.string(),
+      hookId: external_exports2.string(),
+      workflowName: external_exports2.string().optional(),
+      deploymentId: external_exports2.string().optional(),
+      runSpecVersion: external_exports2.number().optional()
+    }));
     HookSchema2 = external_exports2.compile(external_exports2.object({
       runId: external_exports2.string(),
       hookId: external_exports2.string(),
@@ -22103,7 +22151,12 @@ var init_hooks2 = __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: HookResumeCapabilitiesSchema2.optional()
+      resumeCapabilities: HookResumeCapabilitiesSchema2.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: HookClaimedFromSchema2.optional()
     }));
   }
 });
@@ -22276,7 +22329,7 @@ function requiresNewerWorld(v) {
     return false;
   return v > SPEC_VERSION_MAX_SUPPORTED2;
 }
-var SPEC_VERSION_LEGACY2, SPEC_VERSION_SUPPORTS_EVENT_SOURCING, SPEC_VERSION_SUPPORTS_CBOR_QUEUE_TRANSPORT2, SPEC_VERSION_SUPPORTS_ATTRIBUTES2, SPEC_VERSION_SUPPORTS_COMPRESSION2, SPEC_VERSION_SUPPORTS_SLOT_IDENTITY2, SPEC_VERSION_SUPPORTS_SEALED_LOG2, SPEC_VERSION_CURRENT2, SEALED_LOG_ENV_VAR, SPEC_VERSION_MAX_SUPPORTED2;
+var SPEC_VERSION_LEGACY2, SPEC_VERSION_SUPPORTS_EVENT_SOURCING, SPEC_VERSION_SUPPORTS_CBOR_QUEUE_TRANSPORT2, SPEC_VERSION_SUPPORTS_ATTRIBUTES2, SPEC_VERSION_SUPPORTS_COMPRESSION2, SPEC_VERSION_SUPPORTS_SLOT_IDENTITY2, SPEC_VERSION_SUPPORTS_SEALED_LOG, SPEC_VERSION_SUPPORTS_HOOK_FORCE_CLAIM2, SPEC_VERSION_CURRENT2, SEALED_LOG_ENV_VAR, SPEC_VERSION_MAX_SUPPORTED2;
 var init_spec_version2 = __esm({
   "../world/dist/spec-version.js"() {
     "use strict";
@@ -22287,11 +22340,12 @@ var init_spec_version2 = __esm({
     SPEC_VERSION_SUPPORTS_ATTRIBUTES2 = 4;
     SPEC_VERSION_SUPPORTS_COMPRESSION2 = 5;
     SPEC_VERSION_SUPPORTS_SLOT_IDENTITY2 = 6;
-    SPEC_VERSION_SUPPORTS_SEALED_LOG2 = 7;
-    SPEC_VERSION_CURRENT2 = SPEC_VERSION_SUPPORTS_SEALED_LOG2;
+    SPEC_VERSION_SUPPORTS_SEALED_LOG = 7;
+    SPEC_VERSION_SUPPORTS_HOOK_FORCE_CLAIM2 = 8;
+    SPEC_VERSION_CURRENT2 = SPEC_VERSION_SUPPORTS_HOOK_FORCE_CLAIM2;
     SEALED_LOG_ENV_VAR = "WORKFLOW_SEALED_LOG";
     __name(mintedSpecVersion, "mintedSpecVersion");
-    SPEC_VERSION_MAX_SUPPORTED2 = SPEC_VERSION_SUPPORTS_SEALED_LOG2;
+    SPEC_VERSION_MAX_SUPPORTED2 = SPEC_VERSION_SUPPORTS_HOOK_FORCE_CLAIM2;
     __name(isLegacySpecVersion2, "isLegacySpecVersion");
     __name(requiresNewerWorld, "requiresNewerWorld");
   }
@@ -22557,6 +22611,7 @@ __export(dist_exports, {
   HOOK_RESUME_DEDUP_VERSION: () => HOOK_RESUME_DEDUP_VERSION2,
   HOOK_RESUME_INPUT_VERSION: () => HOOK_RESUME_INPUT_VERSION2,
   HealthCheckPayloadSchema: () => HealthCheckPayloadSchema2,
+  HookClaimedFromSchema: () => HookClaimedFromSchema2,
   HookCreatedEventSchema: () => HookCreatedEventSchema2,
   HookResumeCapabilitiesSchema: () => HookResumeCapabilitiesSchema2,
   HookSchema: () => HookSchema2,
@@ -22585,7 +22640,8 @@ __export(dist_exports, {
   SPEC_VERSION_SUPPORTS_CBOR_QUEUE_TRANSPORT: () => SPEC_VERSION_SUPPORTS_CBOR_QUEUE_TRANSPORT2,
   SPEC_VERSION_SUPPORTS_COMPRESSION: () => SPEC_VERSION_SUPPORTS_COMPRESSION2,
   SPEC_VERSION_SUPPORTS_EVENT_SOURCING: () => SPEC_VERSION_SUPPORTS_EVENT_SOURCING,
-  SPEC_VERSION_SUPPORTS_SEALED_LOG: () => SPEC_VERSION_SUPPORTS_SEALED_LOG2,
+  SPEC_VERSION_SUPPORTS_HOOK_FORCE_CLAIM: () => SPEC_VERSION_SUPPORTS_HOOK_FORCE_CLAIM2,
+  SPEC_VERSION_SUPPORTS_SEALED_LOG: () => SPEC_VERSION_SUPPORTS_SEALED_LOG,
   SPEC_VERSION_SUPPORTS_SLOT_IDENTITY: () => SPEC_VERSION_SUPPORTS_SLOT_IDENTITY2,
   STEP_EVENT_TYPES: () => STEP_EVENT_TYPES2,
   SerializedDataSchema: () => SerializedDataSchema2,
@@ -22730,7 +22786,7 @@ function buildFramedDetails2(hint3, slug) {
     out.push({ label: "docs", value: `${BASE_URL2}/${slug}` });
   return out;
 }
-var BASE_URL2, ERROR_SLUGS2, WorkflowError2, WorkflowWorldError2, WorkflowRunFailedError2, WorkflowRunNotCompletedError2, WorkflowRuntimeError2, CorruptedEventLogError, ReplayDivergenceError, MaxEventsExceededError, RuntimeDecryptionError2, SerializationError2, StepNotRegisteredError2, WorkflowNotRegisteredError2, WorkflowDeploymentMismatchError, WorkflowRunNotFoundError2, HookConflictError2, HookNotFoundError2, EntityConflictError2, RunExpiredError2, StreamError2, StreamExpiredError2, TooEarlyError, ThrottleError2, PreconditionFailedError, WorkflowRunCancelledError2, RunNotSupportedError, FatalError2, RetryableError2, FATAL_ERROR_KEY2, RETRYABLE_ERROR_KEY2, HOOK_CONFLICT_ERROR_KEY2, RUNTIME_DECRYPTION_ERROR_KEY2, STREAM_ERROR_KEY2;
+var BASE_URL2, ERROR_SLUGS2, WorkflowError2, WorkflowWorldError2, WorkflowRunFailedError2, WorkflowRunNotCompletedError2, WorkflowRuntimeError2, CorruptedEventLogError, ReplayDivergenceError, MaxEventsExceededError, RuntimeDecryptionError2, SerializationError2, StepNotRegisteredError2, WorkflowNotRegisteredError2, WorkflowDeploymentMismatchError, WorkflowRunNotFoundError2, HookConflictError2, HookForceClaimedError2, HookNotFoundError2, EntityConflictError2, RunExpiredError2, StreamError2, StreamExpiredError2, TooEarlyError, ThrottleError2, PreconditionFailedError, WorkflowRunCancelledError2, RunNotSupportedError, FatalError2, RetryableError2, FATAL_ERROR_KEY2, RETRYABLE_ERROR_KEY2, HOOK_CONFLICT_ERROR_KEY2, HOOK_FORCE_CLAIMED_ERROR_KEY2, RUNTIME_DECRYPTION_ERROR_KEY2, STREAM_ERROR_KEY2;
 var init_dist7 = __esm({
   "../errors/dist/index.js"() {
     "use strict";
@@ -22750,6 +22806,7 @@ var init_dist7 = __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",
@@ -23043,6 +23100,28 @@ Caused by: ${options.cause.stack}`;
         return isError2(value) && value.name === "HookConflictError";
       }
     };
+    HookForceClaimedError2 = class extends WorkflowError2 {
+      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_SLUGS2.HOOK_FORCE_CLAIMED });
+        this.name = "HookForceClaimedError";
+        this.token = token;
+        this.claimedByRunId = claimedByRunId;
+        if (claimedByHookId !== void 0) {
+          this.claimedByHookId = claimedByHookId;
+        }
+      }
+      static is(value) {
+        return isError2(value) && value.name === "HookForceClaimedError";
+      }
+    };
     HookNotFoundError2 = class extends WorkflowError2 {
       static {
         __name(this, "HookNotFoundError");
@@ -23233,6 +23312,7 @@ Caused by: ${options.cause.stack}`;
     FATAL_ERROR_KEY2 = /* @__PURE__ */ Symbol.for("@workflow/errors//FatalError");
     RETRYABLE_ERROR_KEY2 = /* @__PURE__ */ Symbol.for("@workflow/errors//RetryableError");
     HOOK_CONFLICT_ERROR_KEY2 = /* @__PURE__ */ Symbol.for("@workflow/errors//HookConflictError");
+    HOOK_FORCE_CLAIMED_ERROR_KEY2 = /* @__PURE__ */ Symbol.for("@workflow/errors//HookForceClaimedError");
     RUNTIME_DECRYPTION_ERROR_KEY2 = /* @__PURE__ */ Symbol.for("@workflow/errors//RuntimeDecryptionError");
     STREAM_ERROR_KEY2 = /* @__PURE__ */ Symbol.for("@workflow/errors//StreamError");
     if (typeof globalThis !== "undefined") {
@@ -23260,6 +23340,14 @@ Caused by: ${options.cause.stack}`;
           configurable: false
         });
       }
+      if (!Object.hasOwn(globalThis, HOOK_FORCE_CLAIMED_ERROR_KEY2)) {
+        Object.defineProperty(globalThis, HOOK_FORCE_CLAIMED_ERROR_KEY2, {
+          value: HookForceClaimedError2,
+          writable: false,
+          enumerable: false,
+          configurable: false
+        });
+      }
       if (!Object.hasOwn(globalThis, RUNTIME_DECRYPTION_ERROR_KEY2)) {
         Object.defineProperty(globalThis, RUNTIME_DECRYPTION_ERROR_KEY2, {
           value: RuntimeDecryptionError2,
@@ -54921,6 +55009,35 @@ function hookDisposeLockPath(basedir, hookId, tag) {
   const name = tag ? `${hookId}.disposed.${tag}` : `${hookId}.disposed`;
   return resolveWithinBase(basedir, ".locks", "hooks", name);
 }
+async function readHookDisposeLock(basedir, hookId, tag) {
+  const candidates = [hookDisposeLockPath(basedir, hookId)];
+  if (tag) {
+    candidates.push(hookDisposeLockPath(basedir, hookId, tag));
+  }
+  for (const lockPath of candidates) {
+    let content;
+    try {
+      content = await fs2.readFile(lockPath, "utf8");
+    } catch {
+      continue;
+    }
+    if (content.trim() === "")
+      return { committed: true };
+    try {
+      const parsed = JSON.parse(content);
+      const by = parsed.forceClaimedBy;
+      if (by && typeof by.runId === "string" && typeof by.hookId === "string") {
+        return {
+          committed: true,
+          forceClaimedBy: { runId: by.runId, hookId: by.hookId }
+        };
+      }
+    } catch {
+    }
+    return { committed: true };
+  }
+  return { committed: false };
+}
 async function isHookDisposalCommitted(basedir, hookId, tag) {
   const candidates = [hookDisposeLockPath(basedir, hookId)];
   if (tag) {
@@ -55136,6 +55253,7 @@ var init_helpers2 = __esm({
     init_fs();
     __name(hashToken, "hashToken");
     __name(hookDisposeLockPath, "hookDisposeLockPath");
+    __name(readHookDisposeLock, "readHookDisposeLock");
     __name(isHookDisposalCommitted, "isHookDisposalCommitted");
     __name(runTerminalMarkerPath, "runTerminalMarkerPath");
     __name(isRunTerminalCommitted, "isRunTerminalCommitted");
@@ -55153,7 +55271,17 @@ var init_helpers2 = __esm({
       // Legacy claims also omitted eventId. Their recovery marker pins the
       // canonical hook_created event before concurrent retries publish it.
       eventId: external_exports2.string().optional(),
-      tokenRetentionUntil: external_exports2.coerce.date().optional()
+      tokenRetentionUntil: external_exports2.coerce.date().optional(),
+      // Set when this claim took the token from another run
+      // (`experimental_force`), so a retry that adopts the claim can still
+      // report — and wake — the run it came from.
+      claimedFrom: external_exports2.object({
+        runId: external_exports2.string(),
+        hookId: external_exports2.string(),
+        workflowName: external_exports2.string().optional(),
+        deploymentId: external_exports2.string().optional(),
+        runSpecVersion: external_exports2.number().optional()
+      }).optional()
     }));
     __name(readHookTokenClaim, "readHookTokenClaim");
     __name(withHookTokenClaimLock, "withHookTokenClaimLock");
@@ -55217,7 +55345,7 @@ async function writeHookCreatedIndexEntries(basedir, token, runId, hookId, event
   assertSafeEntityId("eventId", eventId);
   if (tag !== void 0)
     assertSafeEntityId("tag", tag);
-  const fileName = tag ? `${eventId}.${tag}.json` : `${eventId}.json`;
+  const fileName = tag ? `${runId}-${eventId}.${tag}.json` : `${runId}-${eventId}.json`;
   const content = JSON.stringify({ runId });
   await Promise.all([
     writeExclusive(path5.join(tokenIndexDir(basedir, token), fileName), content),
@@ -55324,7 +55452,7 @@ async function ensureHookIndexesImpl(basedir) {
   });
   await writeExclusive(markerPath, "");
 }
-async function findNewestIndexedHookCreatedEvent(basedir, index, matches, tag) {
+async function findIndexedHookCreatedEvent(basedir, index, accept, tag) {
   await ensureHookIndexes(basedir);
   let dir;
   try {
@@ -55332,6 +55460,10 @@ async function findNewestIndexedHookCreatedEvent(basedir, index, matches, tag) {
   } catch {
     return null;
   }
+  const eventIdOf = /* @__PURE__ */ __name((entryId, runId) => {
+    const stripped = stripTag(entryId);
+    return stripped.startsWith(`${runId}-`) ? stripped.slice(runId.length + 1) : stripped;
+  }, "eventIdOf");
   const entryIds = (await listJSONFiles(dir)).filter((fileId) => isVisibleToTag(fileId, tag)).sort((a, b) => stripTag(b).localeCompare(stripTag(a)));
   for (const entryId of entryIds) {
     let entry = null;
@@ -55344,7 +55476,7 @@ async function findNewestIndexedHookCreatedEvent(basedir, index, matches, tag) {
     }
     if (!entry)
       continue;
-    const eventId = stripTag(entryId);
+    const eventId = eventIdOf(entryId, entry.runId);
     let eventPath;
     try {
       eventPath = taggedPath(basedir, "events", `${entry.runId}-${eventId}`, tagOf(entryId));
@@ -55358,7 +55490,7 @@ async function findNewestIndexedHookCreatedEvent(basedir, index, matches, tag) {
       continue;
     if (typeof event.correlationId !== "string")
       continue;
-    if (!matches(event))
+    if (!await accept(event))
       continue;
     return event;
   }
@@ -55398,7 +55530,7 @@ var init_hook_index = __esm({
     __name(ensureHookIndexes, "ensureHookIndexes");
     __name(forEachConcurrent, "forEachConcurrent");
     __name(ensureHookIndexesImpl, "ensureHookIndexesImpl");
-    __name(findNewestIndexedHookCreatedEvent, "findNewestIndexedHookCreatedEvent");
+    __name(findIndexedHookCreatedEvent, "findIndexedHookCreatedEvent");
   }
 });
 
@@ -55449,11 +55581,14 @@ function getHookCreatedToken(event) {
   return typeof token === "string" ? token : void 0;
 }
 function hookFromCreatedEvent(event) {
-  const { token, metadata, isWebhook, isSystem, tokenRetentionUntil } = event.eventData;
+  const { token, metadata, isWebhook, isSystem, tokenRetentionUntil, forceClaimedFrom } = event.eventData;
   return {
     runId: event.runId,
     hookId: event.correlationId,
     token,
+    // The journaled row is the durable record of a takeover; a rebuilt
+    // entity must say where its token came from just as the original did.
+    ...forceClaimedFrom !== void 0 && { claimedFrom: forceClaimedFrom },
     metadata,
     ownerId: "local-owner",
     projectId: "local-project",
@@ -55473,20 +55608,17 @@ async function isTerminalRunCache(basedir, runId, tag) {
   return run3 ? isTerminalWorkflowRunStatus2(run3.status) : false;
 }
 async function findAvailableHookCreatedEvent(basedir, index, matches, tag) {
-  const newest = await findNewestIndexedHookCreatedEvent(basedir, index, (event) => isMatchingHookCreatedEvent(event, matches), tag);
-  if (!newest || !isMatchingHookCreatedEvent(newest, matches)) {
-    return null;
-  }
-  if (await isTerminalRunCache(basedir, newest.runId, tag)) {
-    const retainedUntil = newest.eventData.tokenRetentionUntil;
-    if (!retainedUntil || retainedUntil.getTime() <= Date.now()) {
-      return null;
+  const isLive = /* @__PURE__ */ __name(async (event) => {
+    if (await isTerminalRunCache(basedir, event.runId, tag)) {
+      const retainedUntil = event.eventData.tokenRetentionUntil;
+      if (!retainedUntil || retainedUntil.getTime() <= Date.now()) {
+        return false;
+      }
     }
-  }
-  if (await isHookDisposalCommitted(basedir, newest.correlationId, tag)) {
-    return null;
-  }
-  return newest;
+    return !await isHookDisposalCommitted(basedir, event.correlationId, tag);
+  }, "isLive");
+  const found2 = await findIndexedHookCreatedEvent(basedir, index, (event) => isMatchingHookCreatedEvent(event, matches) && isLive(event), tag);
+  return found2 && isMatchingHookCreatedEvent(found2, matches) ? found2 : null;
 }
 async function restoreHookCachesFromEvent(basedir, event, tag) {
   const hook = hookFromCreatedEvent(event);
@@ -55496,7 +55628,8 @@ async function restoreHookCachesFromEvent(basedir, event, tag) {
     hookId: hook.hookId,
     runId: hook.runId,
     eventId: event.eventId,
-    tokenRetentionUntil: event.eventData.tokenRetentionUntil
+    tokenRetentionUntil: event.eventData.tokenRetentionUntil,
+    ...hook.claimedFrom && { claimedFrom: hook.claimedFrom }
   }));
   await writeHookByRunMarker(basedir, hook.runId, hook.hookId, tag);
   await writeExclusive(taggedPath(basedir, "hooks", hook.hookId, tag), JSON.stringify(hook, jsonReplacer, 2));
@@ -55521,36 +55654,53 @@ function createHooksStorage(basedir, tag) {
     return !await isTerminalRunCache(basedir, hook.runId, tag);
   }
   __name(isHookAvailable, "isHookAvailable");
+  async function isForceDisposed(hook) {
+    const lock2 = await readHookDisposeLock(basedir, hook.hookId, tag);
+    return lock2.committed && lock2.forceClaimedBy !== void 0;
+  }
+  __name(isForceDisposed, "isForceDisposed");
   async function findHookByToken(token) {
     const claim3 = await readHookTokenClaim(hookTokenClaimPath(basedir, token));
     if (claim3?.hookId) {
       try {
         const hook = await readJSONWithFallback(basedir, "hooks", claim3.hookId, HookSchema2, tag);
         if (hook?.token === token) {
-          if (!await isHookAvailable(hook)) {
+          if (await isHookAvailable(hook)) {
+            return { ...hook, isWebhook: hook.isWebhook ?? true };
+          }
+          if (!await isForceDisposed(hook)) {
             throw new HookNotFoundError2(token);
           }
-          return { ...hook, isWebhook: hook.isWebhook ?? true };
+        } else if (hook) {
+          return null;
         }
       } catch (error121) {
         if (!UnsafeEntityIdError.is(error121)) {
           throw error121;
         }
+        return null;
       }
-      return null;
     }
     const hooksDir = path6.join(basedir, "hooks");
     const files = await listJSONFiles(hooksDir);
+    let disposedMatch = false;
     for (const file3 of files) {
       const hookPath = path6.join(hooksDir, `${file3}.json`);
       const hook = await readJSON(hookPath, HookSchema2);
       if (hook?.token === token) {
-        if (!await isHookAvailable(hook)) {
-          throw new HookNotFoundError2(token);
+        if (await isHookAvailable(hook)) {
+          return { ...hook, isWebhook: hook.isWebhook ?? true };
+        }
+        if (await isForceDisposed(hook)) {
+          disposedMatch = true;
+          continue;
         }
-        return { ...hook, isWebhook: hook.isWebhook ?? true };
+        throw new HookNotFoundError2(token);
       }
     }
+    if (disposedMatch) {
+      throw new HookNotFoundError2(token);
+    }
     return null;
   }
   __name(findHookByToken, "findHookByToken");
@@ -56816,6 +56966,16 @@ function createEventsStorage(basedir, tag) {
     }
   }
   __name(storeEvent, "storeEvent");
+  async function refuseDisposedHookDelivery(hookId, token) {
+    const lock2 = await readHookDisposeLock(basedir, hookId, tag);
+    if (!lock2.committed)
+      return;
+    if (lock2.forceClaimedBy) {
+      throw new HookForceClaimedError2(typeof token === "string" ? token : "", lock2.forceClaimedBy.runId, lock2.forceClaimedBy.hookId);
+    }
+    throw new HookNotFoundError2(hookId);
+  }
+  __name(refuseDisposedHookDelivery, "refuseDisposedHookDelivery");
   const queryRunEvents = /* @__PURE__ */ __name((runId, pagination) => paginatedFileSystemQuery({
     directory: path10.join(basedir, "events"),
     schema: ReadEventSchema,
@@ -57006,8 +57166,8 @@ function createEventsStorage(basedir, tag) {
               }
             }
           }
-          if (data.eventType === "hook_received" && await isHookDisposalCommitted(basedir, data.correlationId, tag)) {
-            throw new HookNotFoundError2(data.correlationId);
+          if (data.eventType === "hook_received") {
+            await refuseDisposedHookDelivery(data.correlationId, data.eventData?.token);
           }
           const existingHook = await readJSONWithFallback(basedir, "hooks", data.correlationId, HookSchema2, tag);
           if (!existingHook) {
@@ -57066,6 +57226,7 @@ function createEventsStorage(basedir, tag) {
             }
           }
         }
+        let prePublishedEvent;
         let event = {
           ...data,
           runId: effectiveRunId,
@@ -57437,13 +57598,15 @@ function createEventsStorage(basedir, tag) {
         ) {
           const hookData = data.eventData;
           const constraintPath = hookTokenClaimPath(basedir, hookData.token);
-          const claimContent = JSON.stringify({
+          let claimedFrom;
+          const claimContent = /* @__PURE__ */ __name(() => JSON.stringify({
             token: hookData.token,
             hookId: data.correlationId,
             runId: effectiveRunId,
             eventId,
-            tokenRetentionUntil: hookData.tokenRetentionUntil
-          });
+            tokenRetentionUntil: hookData.tokenRetentionUntil,
+            ...claimedFrom && { claimedFrom }
+          }), "claimContent");
           const claimResult = await withHookTokenClaimLock(basedir, hookData.token, async (signal) => {
             let existingClaim = await readHookTokenClaim(constraintPath);
             if (!existingClaim) {
@@ -57454,26 +57617,114 @@ function createEventsStorage(basedir, tag) {
             }
             if (!existingClaim) {
               signal.throwIfAborted();
-              assert3(await writeExclusive(constraintPath, claimContent));
+              assert3(await writeExclusive(constraintPath, claimContent()));
               return { status: "claimed" };
             }
             if (existingClaim.runId === effectiveRunId && existingClaim.hookId === data.correlationId) {
               return { status: "owned", claim: existingClaim };
             }
             if (!await isHookTokenClaimReleasable(basedir, existingClaim, tag)) {
-              return { status: "conflict", claim: existingClaim };
+              if (hookData.force !== true || !existingClaim.hookId) {
+                return { status: "conflict", claim: existingClaim };
+              }
+              signal.throwIfAborted();
+              const victimRun = await readJSONWithFallback(basedir, "runs", existingClaim.runId, WorkflowRunSchema2, tag);
+              const victimRunning = victimRun !== null && !isTerminalWorkflowRunStatus2(victimRun.status);
+              claimedFrom = {
+                runId: existingClaim.runId,
+                hookId: existingClaim.hookId,
+                ...victimRunning && {
+                  workflowName: victimRun.workflowName,
+                  deploymentId: victimRun.deploymentId,
+                  runSpecVersion: victimRun.specVersion
+                }
+              };
+              if (victimRunning && (victimRun.specVersion ?? SPEC_VERSION_LEGACY2) < SPEC_VERSION_SUPPORTS_HOOK_FORCE_CLAIM2) {
+                return {
+                  status: "conflict",
+                  claim: existingClaim,
+                  forceRefusedReason: "victim-spec-version"
+                };
+              }
+              const journaledEventId = await findExistingHookCreatedEventId(basedir, effectiveRunId, data.correlationId);
+              if (journaledEventId) {
+                eventId = journaledEventId;
+                prePublishedEvent = { ...event, eventId };
+              } else {
+                prePublishedEvent = await storeEvent({
+                  ...event,
+                  eventData: {
+                    ...event.eventData,
+                    forceClaimedFrom: claimedFrom
+                  }
+                });
+                eventId = prePublishedEvent.eventId;
+              }
+              await writeHookByRunMarker(basedir, effectiveRunId, data.correlationId, tag);
+              await writeJSON(taggedPath(basedir, "hooks", data.correlationId, tag), {
+                runId: effectiveRunId,
+                hookId: data.correlationId,
+                token: hookData.token,
+                metadata: hookData.metadata,
+                ownerId: "local-owner",
+                projectId: "local-project",
+                environment: "local",
+                createdAt: now2,
+                specVersion: effectiveSpecVersion,
+                isWebhook: hookData.isWebhook ?? false,
+                isSystem: hookData.isSystem ?? false,
+                tokenRetentionUntil: hookData.tokenRetentionUntil,
+                claimedFrom
+              }, { overwrite: true });
+              const lockWritten = await writeExclusive(hookDisposeLockPath(basedir, existingClaim.hookId, tag), JSON.stringify({
+                forceClaimedBy: {
+                  runId: effectiveRunId,
+                  hookId: data.correlationId
+                }
+              }));
+              if (victimRunning) {
+                if (lockWritten) {
+                  const disposedEvent = {
+                    eventType: "hook_disposed",
+                    correlationId: existingClaim.hookId,
+                    eventData: {
+                      token: hookData.token,
+                      forceClaimedBy: {
+                        runId: effectiveRunId,
+                        hookId: data.correlationId
+                      }
+                    },
+                    runId: existingClaim.runId,
+                    eventId: await mintEventId(existingClaim.runId),
+                    createdAt: /* @__PURE__ */ new Date(),
+                    specVersion: victimRun.specVersion
+                  };
+                  await storeEvent(disposedEvent);
+                }
+              }
             }
             signal.throwIfAborted();
-            await deleteJSON(constraintPath);
+            if (claimedFrom) {
+              await write(constraintPath, claimContent(), {
+                overwrite: true
+              });
+            } else {
+              await deleteJSON(constraintPath);
+            }
             if (existingClaim.hookId) {
               await deleteJSON(taggedPath(basedir, "hooks", existingClaim.hookId, tag));
               await deleteJSON(hookRecoveryMarkerPath(basedir, hookData.token, existingClaim.runId, existingClaim.hookId));
               await deleteHookByRunMarker(basedir, existingClaim.runId, existingClaim.hookId, tag);
             }
             signal.throwIfAborted();
-            assert3(await writeExclusive(constraintPath, claimContent));
+            if (!claimedFrom) {
+              assert3(await writeExclusive(constraintPath, claimContent()));
+            }
             return { status: "claimed" };
           });
+          if (claimResult.status === "owned" && claimResult.claim.claimedFrom) {
+            claimedFrom = claimResult.claim.claimedFrom;
+          }
           if (claimResult.status === "owned") {
             const existingClaim = claimResult.claim;
             let canonicalEventId;
@@ -57515,7 +57766,10 @@ function createEventsStorage(basedir, tag) {
               correlationId: data.correlationId,
               eventData: {
                 token: hookData.token,
-                conflictingRunId: existingClaim.runId
+                conflictingRunId: existingClaim.runId,
+                ...claimResult.forceRefusedReason !== void 0 && {
+                  forceRefusedReason: claimResult.forceRefusedReason
+                }
               },
               runId: effectiveRunId,
               eventId,
@@ -57543,6 +57797,18 @@ function createEventsStorage(basedir, tag) {
               hasMore: conflictDelta.hasMore
             };
           }
+          if (claimedFrom) {
+            event = {
+              ...event,
+              eventData: {
+                ...event.eventData,
+                // Wake-targeting fields included: a replay of this run
+                // republishes the victim's wake from this row alone when the
+                // invocation that created the hook died before waking it.
+                forceClaimedFrom: claimedFrom
+              }
+            };
+          }
           const persistedHookData = event.eventData;
           hook = {
             runId: effectiveRunId,
@@ -57557,9 +57823,10 @@ function createEventsStorage(basedir, tag) {
             specVersion: effectiveSpecVersion,
             isWebhook: persistedHookData.isWebhook ?? false,
             isSystem: persistedHookData.isSystem ?? false,
-            tokenRetentionUntil: persistedHookData.tokenRetentionUntil
+            tokenRetentionUntil: persistedHookData.tokenRetentionUntil,
+            ...claimedFrom && { claimedFrom }
           };
-          hookEntityWriteOptions = claimResult.status === "owned" ? { overwrite: true } : void 0;
+          hookEntityWriteOptions = claimResult.status === "owned" || claimedFrom ? { overwrite: true } : void 0;
           await writeHookCreatedIndexEntries(basedir, hookData.token, effectiveRunId, data.correlationId, eventId, tag);
         } else if (data.eventType === "hook_disposed") {
           const lockPath = hookDisposeLockPath(basedir, data.correlationId, tag);
@@ -57617,8 +57884,14 @@ function createEventsStorage(basedir, tag) {
           };
           await writeJSON(taggedPath(basedir, "waits", waitCompositeKey, tag), wait, { overwrite: true });
         }
-        if (data.eventType === "hook_received" && data.correlationId && await isHookDisposalCommitted(basedir, data.correlationId, tag)) {
-          throw new HookNotFoundError2(data.correlationId);
+        if (data.eventType === "hook_received" && data.correlationId) {
+          await refuseDisposedHookDelivery(data.correlationId, data.eventData?.token);
+        }
+        if (data.eventType === "hook_created" && data.correlationId) {
+          const own3 = await readHookDisposeLock(basedir, data.correlationId, tag);
+          if (own3.committed && own3.forceClaimedBy) {
+            throw new EntityConflictError2(`Hook "${data.correlationId}" was force-claimed by another run before its creation was journaled`);
+          }
         }
         let eventPath = taggedPath(basedir, "events", `${effectiveRunId}-${eventId}`, tag);
         let serializedEvent = JSON.stringify(event, jsonReplacer, 2);
@@ -57641,7 +57914,13 @@ function createEventsStorage(basedir, tag) {
           return true;
         }, "bumpEventSlot");
         let eventPublished = false;
-        for (let attempt = 0; ; attempt++) {
+        if (prePublishedEvent) {
+          event = prePublishedEvent;
+          eventPath = taggedPath(basedir, "events", `${effectiveRunId}-${eventId}`, tag);
+          serializedEvent = JSON.stringify(event, jsonReplacer, 2);
+          eventPublished = true;
+        }
+        for (let attempt = 0; !eventPublished; attempt++) {
           if (data.eventType === "hook_received") {
             const terminalByMarker = await isRunTerminalCommitted(basedir, effectiveRunId, tag);
             const runNow = terminalByMarker ? null : await readJSONWithFallback(basedir, "runs", effectiveRunId, WorkflowRunSchema2, tag);
@@ -58010,7 +58289,11 @@ function createWorld(args) {
       // `(runId, resumeId)` via a filesystem sidecar claim (see
       // events-storage.ts `claimHookResume`), so resumeHook()'s parallel fast
       // path converges on one event in dev exactly as it does on Vercel.
-      hookResumeDedup: true
+      hookResumeDedup: true,
+      // The token claim lock serializes the takeover behind
+      // `createHook({ experimental_force: true })`; see the hook_created
+      // branch of storage/events-storage.ts.
+      hookForceClaim: true
     },
     ...queue,
     ...storage,
@@ -61842,7 +62125,7 @@ var version4;
 var init_version3 = __esm({
   "../world-vercel/dist/version.js"() {
     "use strict";
-    version4 = "5.0.0-beta.49";
+    version4 = "5.0.0-beta.51";
   }
 });
 
@@ -62424,6 +62707,10 @@ function headersToRecord(headers) {
 }
 function errorForResponse(status, message, opts = {}) {
   const { retryAfter, code: code3, url: url3, mitigated, details } = opts;
+  if (status === 409 && code3 === "hook-force-claimed") {
+    const claimedBy = details && typeof details === "object" ? details.claimedBy : void 0;
+    return new HookForceClaimedError2("", typeof claimedBy?.runId === "string" ? claimedBy.runId : "unknown", typeof claimedBy?.hookId === "string" ? claimedBy.hookId : void 0);
+  }
   if (status === 409)
     return new EntityConflictError2(message);
   if (status === 410) {
@@ -74579,10 +74866,20 @@ function toBatchResult(outcome) {
     messageId: outcome.messageId ? MessageId2.parse(outcome.messageId) : null
   };
 }
-function getHandlerErrorRetryAfterSeconds(deliveryCount) {
+function getErrorRetryAfterSeconds(error121) {
+  if (typeof error121 !== "object" || error121 === null)
+    return void 0;
+  const retryAfter = error121.retryAfter;
+  if (typeof retryAfter !== "number" || !Number.isFinite(retryAfter) || retryAfter <= 0) {
+    return void 0;
+  }
+  return Math.min(Math.ceil(retryAfter), HANDLER_ERROR_MAX_RETRY_AFTER_SECONDS);
+}
+function getHandlerErrorRetryAfterSeconds(error121, deliveryCount) {
   const backoffSeconds = Math.min(Math.max(HANDLER_ERROR_RETRY_AFTER_SECONDS, 2 ** (deliveryCount - 1)), HANDLER_ERROR_MAX_RETRY_AFTER_SECONDS);
   const jitterSeconds = Math.floor(Math.random() * (Math.ceil(backoffSeconds * HANDLER_ERROR_RETRY_JITTER_RATIO) + 1));
-  return Math.max(HANDLER_ERROR_RETRY_AFTER_SECONDS, backoffSeconds - jitterSeconds);
+  const jitteredBackoffSeconds = Math.max(HANDLER_ERROR_RETRY_AFTER_SECONDS, backoffSeconds - jitterSeconds);
+  return Math.max(jitteredBackoffSeconds, getErrorRetryAfterSeconds(error121) ?? HANDLER_ERROR_RETRY_AFTER_SECONDS);
 }
 function getRunIdFromPayload(payload) {
   if ("runId" in payload && typeof payload.runId === "string") {
@@ -74800,7 +75097,7 @@ function createQueue2(config4) {
       // redrive in lockstep. Workflow handlers are event-sourced and must
       // remain idempotent because queue retries can happen close together.
       retry: /* @__PURE__ */ __name((error121, { messageId, deliveryCount }) => {
-        const afterSeconds = getHandlerErrorRetryAfterSeconds(deliveryCount);
+        const afterSeconds = getHandlerErrorRetryAfterSeconds(error121, deliveryCount);
         console.error(`[workflow] Queue handler failed for message "${messageId}" on delivery attempt ${deliveryCount}; retrying in ${afterSeconds}s:`, error121);
         return { afterSeconds };
       }, "retry")
@@ -74931,6 +75228,7 @@ var init_queue4 = __esm({
     HANDLER_ERROR_RETRY_AFTER_SECONDS = 1;
     HANDLER_ERROR_MAX_RETRY_AFTER_SECONDS = 900;
     HANDLER_ERROR_RETRY_JITTER_RATIO = 0.25;
+    __name(getErrorRetryAfterSeconds, "getErrorRetryAfterSeconds");
     __name(getHandlerErrorRetryAfterSeconds, "getHandlerErrorRetryAfterSeconds");
     FALLBACK_REGION = "iad1";
     __name(getRunIdFromPayload, "getRunIdFromPayload");
@@ -75063,7 +75361,9 @@ function collectErrorMarkers(err, depth = 0) {
 function isRetryableEventPostError(err) {
   if (err instanceof ReplayEventObserverError)
     return false;
-  if (EntityConflictError2.is(err) || RunExpiredError2.is(err) || TooEarlyError.is(err) || ThrottleError2.is(err)) {
+  if (EntityConflictError2.is(err) || // A takeover redirect is definitive for THIS target; the runtime's
+  // resume path follows the token instead of re-issuing the write here.
+  HookForceClaimedError2.is(err) || RunExpiredError2.is(err) || TooEarlyError.is(err) || ThrottleError2.is(err)) {
     return false;
   }
   if (WorkflowWorldError2.is(err) || StreamError2.is(err)) {
@@ -75592,6 +75892,8 @@ function buildPostFrameMeta(input3) {
     meta5.hookIsWebhook = input3.hookIsWebhook;
   if (input3.hookIsSystem !== void 0)
     meta5.hookIsSystem = input3.hookIsSystem;
+  if (input3.hookForce !== void 0)
+    meta5.hookForce = input3.hookForce;
   if (input3.resumeId !== void 0)
     meta5.resumeId = input3.resumeId;
   if (input3.errorCode !== void 0)
@@ -75659,8 +75961,13 @@ function errorFromV4Response(statusCode, responseHeaders, errorBody, opName, url
       message = record3.message;
     if (typeof record3.code === "string")
       code3 = record3.code;
+    else if (typeof record3.error === "string")
+      code3 = record3.error;
     if (statusCode === 412)
       details = decodePreconditionDetails(record3);
+    if (statusCode === 409 && code3 === "hook-force-claimed") {
+      details = { claimedBy: record3.claimedBy };
+    }
   } else if (text) {
     message += ` ${text}`;
   }
@@ -76634,6 +76941,9 @@ function splitEventDataForV4(data) {
   if (typeof eventData.isSystem === "boolean") {
     meta5.hookIsSystem = eventData.isSystem;
   }
+  if (eventData.force === true) {
+    meta5.hookForce = true;
+  }
   if (typeof eventData.errorCode === "string") {
     meta5.errorCode = eventData.errorCode;
   }
@@ -76786,6 +77096,10 @@ async function createWorkflowRunEvent(id, data, params, config4) {
   } catch (err) {
     if (err instanceof ReplayEventObserverError)
       throw err.error;
+    if (HookForceClaimedError2.is(err) && data.eventType === "hook_received") {
+      const token = data.eventData?.token;
+      throw new HookForceClaimedError2(typeof token === "string" ? token : err.token, err.claimedByRunId, err.claimedByHookId);
+    }
     if (isHookEventRequiringExistence(data.eventType) && WorkflowWorldError2.is(err) && err.status === 404 && data.correlationId) {
       throw new HookNotFoundError2(data.correlationId);
     }
@@ -78258,7 +78572,15 @@ function createWorld2(config4) {
       maxConcurrency: true,
       // Vercel deployments are atomic and immutable, so a deployment id names
       // one fixed build for its whole lifetime.
-      deploymentAffinity: true
+      deploymentAffinity: true,
+      // The server implements the takeover protocol behind
+      // `createHook({ experimental_force: true })` (workflow-server
+      // docs/hook-force-claim.md). Static rather than attested per lookup,
+      // because the decision is made at `createHook()` time, before any
+      // lookup; against a server that has it switched off (or predates it)
+      // a forced creation is answered with `hook_conflict`, which the
+      // runtime reports as an unsupported-World failure rather than a win.
+      hookForceClaim: true
       // NOTE: the backend half of resumeHook()'s lazy path (that
       // the server enforces the `(runId, resumeId)` dedup constraint) is
       // NO LONGER a static world capability here. It is attested per-lookup by
@@ -82220,6 +82542,21 @@ function getCommonReducers2(_global2 = globalThis) {
       }
       return reduced;
     }, "HookConflictError"),
+    HookForceClaimedError: /* @__PURE__ */ __name((value) => {
+      const base = reduceNamedErrorSubclassBase2("HookForceClaimedError", value);
+      if (!base)
+        return false;
+      const reduced = {
+        ...base,
+        token: readProperty2(value, "token"),
+        claimedByRunId: readProperty2(value, "claimedByRunId")
+      };
+      const claimedByHookId = readProperty2(value, "claimedByHookId");
+      if (claimedByHookId !== void 0) {
+        reduced.claimedByHookId = claimedByHookId;
+      }
+      return reduced;
+    }, "HookForceClaimedError"),
     RangeError: makeErrorSubclassReducer2("RangeError"),
     ReferenceError: makeErrorSubclassReducer2("ReferenceError"),
     // RetryableError carries an extra `retryAfter` Date that we serialize as
@@ -82404,6 +82741,16 @@ function getCommonRevivers3(global2 = globalThis) {
       }
       return error121;
     }, "HookConflictError"),
+    HookForceClaimedError: /* @__PURE__ */ __name((value) => {
+      const Ctor = global2[/* @__PURE__ */ Symbol.for("@workflow/errors//HookForceClaimedError")] ?? HookForceClaimedError2;
+      const error121 = new Ctor(value.token, value.claimedByRunId, value.claimedByHookId);
+      if (value.stack !== void 0)
+        error121.stack = value.stack;
+      if ("cause" in value) {
+        error121.cause = value.cause;
+      }
+      return error121;
+    }, "HookForceClaimedError"),
     RangeError: makeErrorSubclassReviver2(global2, "RangeError"),
     ReferenceError: makeErrorSubclassReviver2(global2, "ReferenceError"),
     RetryableError: /* @__PURE__ */ __name((value) => {
@@ -86041,7 +86388,7 @@ var version5;
 var init_version4 = __esm({
   "../core/dist/version.js"() {
     "use strict";
-    version5 = "5.0.0-beta.54";
+    version5 = "5.0.0-beta.56";
   }
 });
 
@@ -86512,6 +86859,112 @@ var init_helpers3 = __esm({
   }
 });
 
+// ../core/dist/runtime/hook-wake.js
+function isRetryableWakeError2(error121, isDeploymentUnavailableError) {
+  if (isDeploymentUnavailableError?.(error121))
+    return false;
+  const status = error121 ?? {};
+  const code3 = status.status ?? status.statusCode;
+  if (typeof code3 === "number") {
+    return code3 >= 500 || code3 === 408 || code3 === 429;
+  }
+  const name = error121?.name;
+  return name !== "BadRequestError" && name !== "UnauthorizedError" && name !== "ForbiddenError";
+}
+async function publishHookWakeWithRetry2(publish, isDeploymentUnavailableError) {
+  let lastError;
+  for (let attempt = 0; attempt <= HOOK_WAKE_RETRY_DELAYS_MS2.length; attempt++) {
+    try {
+      await publish();
+      return;
+    } catch (error121) {
+      lastError = error121;
+      if (!isRetryableWakeError2(error121, isDeploymentUnavailableError))
+        break;
+      const delayMs = HOOK_WAKE_RETRY_DELAYS_MS2[attempt];
+      if (delayMs !== void 0) {
+        await new Promise((resolve3) => setTimeout(resolve3, delayMs));
+      }
+    }
+  }
+  if (HookNotFoundError2.is(lastError)) {
+    throw new WorkflowRuntimeError2("The hook resume was committed, but its workflow wake could not be published", { cause: lastError });
+  }
+  throw lastError;
+}
+async function publishForceClaimVictimWake(world, claimerRunId, hook) {
+  const from = hook.claimedFrom;
+  if (!from || from.runId === claimerRunId)
+    return "skipped";
+  if (from.workflowName === void 0) {
+    runtimeLogger2.warn("Force-claimed a hook from a run whose workflow name is unknown; not waking it", { workflowRunId: claimerRunId, victimRunId: from.runId });
+    return "skipped";
+  }
+  try {
+    await publishHookWakeWithRetry2(() => world.queue(getWorkflowQueueName2(from.workflowName), { runId: from.runId }, {
+      ...from.deploymentId !== void 0 && {
+        deploymentId: from.deploymentId
+      },
+      specVersion: from.runSpecVersion ?? SPEC_VERSION_LEGACY2,
+      idempotencyKey: `hook-force-claim-${hook.hookId}`
+    }), world.isDeploymentUnavailableError?.bind(world));
+    return "published";
+  } catch (error121) {
+    runtimeLogger2.error("Force-claimed a hook token but could not wake the run it was taken from; it will read the disposal on its next invocation", {
+      workflowRunId: claimerRunId,
+      victimRunId: from.runId,
+      error: error121 instanceof Error ? error121.message : String(error121)
+    });
+    return "failed";
+  }
+}
+function forcedCreationOwingWake(events) {
+  if (!events)
+    return void 0;
+  for (let i = events.length - 1; i >= 0; i--) {
+    const event = events[i];
+    if (event.eventType === "hook_received" || event.eventType === "noop" || event.eventType === "hook_disposed" && event.eventData?.forceClaimedBy !== void 0) {
+      continue;
+    }
+    return event.eventType === "hook_created" && event.eventData.forceClaimedFrom !== void 0 ? event : void 0;
+  }
+  return void 0;
+}
+async function republishOwedForceClaimVictimWake(world, runId, events) {
+  const owed = forcedCreationOwingWake(events);
+  if (!owed)
+    return;
+  const claimedFrom = owed.eventData.forceClaimedFrom;
+  const outcome = await publishForceClaimVictimWake(world, runId, {
+    hookId: owed.correlationId,
+    claimedFrom
+  });
+  if (outcome !== "skipped") {
+    runtimeLogger2.info("Republished the wake of a force-claimed hook victim", {
+      workflowRunId: runId,
+      hookId: owed.correlationId,
+      victimRunId: claimedFrom.runId,
+      victimWake: outcome
+    });
+  }
+}
+var HOOK_WAKE_RETRY_DELAYS_MS2;
+var init_hook_wake2 = __esm({
+  "../core/dist/runtime/hook-wake.js"() {
+    "use strict";
+    init_dist7();
+    init_dist6();
+    init_logger2();
+    init_helpers3();
+    HOOK_WAKE_RETRY_DELAYS_MS2 = [25, 100];
+    __name(isRetryableWakeError2, "isRetryableWakeError");
+    __name(publishHookWakeWithRetry2, "publishHookWakeWithRetry");
+    __name(publishForceClaimVictimWake, "publishForceClaimVictimWake");
+    __name(forcedCreationOwingWake, "forcedCreationOwingWake");
+    __name(republishOwedForceClaimVictimWake, "republishOwedForceClaimVictimWake");
+  }
+});
+
 // ../core/dist/runtime/invocations.js
 async function handleInvocation(world, runId, requestId, payload) {
   const parsed = HookInvocationSchema2.safeParse(payload);
@@ -86730,38 +87183,6 @@ async function computeResumePayloadDigest2(bytes) {
   }
   return hex5;
 }
-function isRetryableWakeError2(error121, isDeploymentUnavailableError) {
-  if (isDeploymentUnavailableError?.(error121))
-    return false;
-  const status = error121 ?? {};
-  const code3 = status.status ?? status.statusCode;
-  if (typeof code3 === "number") {
-    return code3 >= 500 || code3 === 408 || code3 === 429;
-  }
-  const name = error121?.name;
-  return name !== "BadRequestError" && name !== "UnauthorizedError" && name !== "ForbiddenError";
-}
-async function publishHookWakeWithRetry2(publish, isDeploymentUnavailableError) {
-  let lastError;
-  for (let attempt = 0; attempt <= HOOK_WAKE_RETRY_DELAYS_MS2.length; attempt++) {
-    try {
-      await publish();
-      return;
-    } catch (error121) {
-      lastError = error121;
-      if (!isRetryableWakeError2(error121, isDeploymentUnavailableError))
-        break;
-      const delayMs = HOOK_WAKE_RETRY_DELAYS_MS2[attempt];
-      if (delayMs !== void 0) {
-        await new Promise((resolve3) => setTimeout(resolve3, delayMs));
-      }
-    }
-  }
-  if (HookNotFoundError2.is(lastError)) {
-    throw new WorkflowRuntimeError2("The hook resume was committed, but its workflow wake could not be published", { cause: lastError });
-  }
-  throw lastError;
-}
 function resumeContextFromRun2(run3) {
   const coreVersion = run3.executionContext?.workflowCoreVersion;
   const traceCarrier = run3.executionContext?.traceCarrier;
@@ -86837,154 +87258,255 @@ async function getHookByToken3(token) {
 async function resumeHook2(tokenOrHook, payload, encryptionKeyOverride) {
   return resumeHookImpl2(tokenOrHook, payload, encryptionKeyOverride, false, Date.now());
 }
-async function resumeHookImpl2(tokenOrHook, payload, encryptionKeyOverride, hookFreshlyLookedUp, resumeRequestedAtMs) {
+async function resumeHookImpl2(tokenOrHook, payload, encryptionKeyOverride, hookFreshlyLookedUp, resumeRequestedAtMs, webhookOnly = false) {
   return await waitedUntil2(() => {
     return trace5("hook.resume", async (span) => {
       const world = await getWorldLazy2();
-      try {
-        const suppliedToken = typeof tokenOrHook === "string";
-        const hook = suppliedToken ? await world.hooks.getByToken(tokenOrHook) : tokenOrHook;
-        const hookResumeCapabilitiesAreFresh = suppliedToken || hookFreshlyLookedUp;
-        const info = await resolveHookResumeInfo2(hook);
-        const { resumeContext } = info;
-        span?.setAttributes({
-          ...HookToken2(hook.token),
-          ...HookId2(hook.hookId),
-          ...WorkflowRunId4(hook.runId),
-          "workflow.hook.resume_context_source": info.source
-        });
-        if (info.run && isTerminalWorkflowRunStatus2(info.run.status)) {
-          throw new HookNotFoundError2(hook.token);
-        }
-        const capabilities = getRunCapabilities2(resumeContext.workflowCoreVersion);
-        let payloadKey;
-        const runPublicKey = encryptionKeyOverride ? (
-          // The caller already holds a key (resumeWebhook resolved one to
-          // hydrate hook metadata), so sealing would add an ECDH for no
-          // saved round trip. Reuse what it resolved.
-          void 0
-        ) : decodeRunPublicKey2(resumeContext.encryptionPublicKey);
-        if (runPublicKey) {
-          payloadKey = sealTo2(runPublicKey);
-        } else {
-          let encryptionKey = encryptionKeyOverride ?? await resolveHookEncryptionKey2(hook, info);
-          if (!capabilities.supportedFormats.has(SerializationFormat2.ENCRYPTED)) {
-            encryptionKey = void 0;
-          }
-          payloadKey = encryptionKey;
-        }
-        const compression = (resumeContext.runSpecVersion ?? 0) >= SPEC_VERSION_SUPPORTS_COMPRESSION2 && capabilities.supportedFormats.has(SerializationFormat2.GZIP);
-        const ops = [];
-        const readbackOps = [];
-        const v1Compat = isLegacySpecVersion2(hook.specVersion);
-        const dehydratedPayload = await dehydrateStepReturnValue2(payload, hook.runId, payloadKey, ops, globalThis, v1Compat, capabilities.framedByteStreams, compression, void 0, readbackOps);
-        await Promise.all(ops.map((op) => op.catch((error121) => {
-          if (error121 !== void 0)
-            throw error121;
-        })));
-        safeWaitUntil2(Promise.all(readbackOps), (err) => {
-          if (err === void 0)
-            return;
-          runtimeLogger2.warn("Background readback of hook payload failed", {
-            workflowRunId: hook.runId,
-            hookId: hook.hookId,
-            error: err instanceof Error ? err.message : String(err)
+      const token = typeof tokenOrHook === "string" ? tokenOrHook : tokenOrHook.token;
+      let target2 = tokenOrHook;
+      let fresh = hookFreshlyLookedUp;
+      let keyOverride = encryptionKeyOverride;
+      let redirects = 0;
+      let lookupsAfterRedirect = 0;
+      const MAX_LOOKUPS_AFTER_REDIRECT = 5;
+      const resumeId = generateResumeId2();
+      const assertResendable = /* @__PURE__ */ __name((cause) => {
+        if (payload instanceof Request && payload.body !== null && payload.bodyUsed) {
+          span?.setAttributes({
+            "workflow.hook.resume_redirect_unresendable": true
           });
-        });
-        span?.setAttributes({
-          ...WorkflowName2(resumeContext.workflowName)
-        });
-        const originLink = await linkToTraceCarrier2(resumeContext.traceCarrier);
-        if (originLink) {
-          span?.addLink?.(originLink);
+          throw new WorkflowRuntimeError2(`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 });
         }
-        if (world.capabilities?.invoke === true && !v1Compat && dehydratedPayload instanceof Uint8Array) {
-          if (!world.invoke) {
-            throw new WorkflowRuntimeError2("World advertises invoke without implementing it");
-          }
-          span?.setAttributes({ "workflow.hook.resume_strategy": "invoke" });
-          const result2 = HookInvocationResultSchema2.parse(await world.invoke(hook.runId, {
-            type: "hook_resume",
-            version: 1,
-            hookId: hook.hookId,
-            token: hook.token,
-            payload: dehydratedPayload
-          }, { idempotencyKey: generateResumeId2() }));
-          if (result2.status === "rejected") {
-            if (result2.code === "HOOK_NOT_FOUND")
-              throw new HookNotFoundError2(hook.token);
-            throw new WorkflowRuntimeError2("Executor rejected the hook invocation input");
-          }
-          span?.setAttributes(HookResumeCommitted2(true));
-          return asLazyMetadataHook2(hook);
-        }
-        const queueName = getWorkflowQueueName2(resumeContext.workflowName);
-        const queueOptions = {
-          deploymentId: resumeContext.deploymentId,
-          specVersion: resumeContext.runSpecVersion ?? SPEC_VERSION_LEGACY2
-        };
-        const backendDedupSupported = (hookResumeCapabilitiesAreFresh ? hook.resumeCapabilities?.hookResumeDedupVersion ?? 0 : 0) >= HOOK_RESUME_DEDUP_VERSION2 || world.capabilities?.hookResumeDedup === true;
-        const canClaimResume = backendDedupSupported && !v1Compat && dehydratedPayload instanceof Uint8Array;
-        span?.setAttributes({
-          "workflow.hook.resume_strategy": "sequential"
-        });
-        const resumeId = canClaimResume ? generateResumeId2() : void 0;
-        const payloadDigest = canClaimResume ? await computeResumePayloadDigest2(dehydratedPayload) : void 0;
-        if (resumeId) {
-          span?.setAttributes({ "workflow.hook.resume_id": resumeId });
-        }
-        const isHookGoneError = /* @__PURE__ */ __name((err) => HookNotFoundError2.is(err) || RunExpiredError2.is(err), "isHookGoneError");
+      }, "assertResendable");
+      for (; ; ) {
         try {
-          await world.events.create(hook.runId, {
-            eventType: "hook_received",
-            specVersion: SPEC_VERSION_CURRENT2,
-            correlationId: hook.hookId,
-            eventData: {
-              ...v1Compat ? {} : { token: hook.token },
-              payload: dehydratedPayload
-            }
-          }, {
-            v1Compat,
-            ...resumeId && payloadDigest ? { resumeId, resumePayloadDigest: payloadDigest } : {}
-          });
+          return await resumeHookAttempt2(world, span, target2, payload, keyOverride, fresh, resumeRequestedAtMs, resumeId, webhookOnly);
         } catch (err) {
-          if (isHookGoneError(err)) {
-            throw new HookNotFoundError2(hook.token);
+          if (err !== null && typeof err === "object" && notFoundReasons2.get(err) === "not-webhook") {
+            throw err;
+          }
+          if (redirects >= MAX_FORCE_CLAIM_REDIRECTS2) {
+            if (HookForceClaimedError2.is(err)) {
+              span?.setAttributes({
+                "workflow.hook.resume_redirects_exhausted": true
+              });
+              throw new WorkflowRuntimeError2(`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 (HookForceClaimedError2.is(err)) {
+            assertResendable(err);
+            redirects++;
+            span?.setAttributes({
+              "workflow.hook.resume_redirects": redirects,
+              "workflow.hook.resume_redirect_to_run": err.claimedByRunId
+            });
+            target2 = token;
+            fresh = true;
+            keyOverride = void 0;
+            lookupsAfterRedirect = 0;
+            continue;
+          }
+          if (HookNotFoundError2.is(err) && redirects > 0 && typeof target2 === "string" && lookupsAfterRedirect < MAX_LOOKUPS_AFTER_REDIRECT) {
+            assertResendable(err);
+            lookupsAfterRedirect++;
+            await new Promise((resolve3) => setTimeout(resolve3, 50));
+            continue;
+          }
+          if (HookNotFoundError2.is(err) && notFoundReasons2.get(err) !== "lookup") {
+            const attemptedHookId = typeof target2 === "string" ? void 0 : target2.hookId;
+            let relocated;
+            try {
+              relocated = await world.hooks.getByToken(token);
+            } catch (lookupError) {
+              if (!HookNotFoundError2.is(lookupError)) {
+                runtimeLogger2.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
+              });
+              target2 = relocated;
+              fresh = true;
+              keyOverride = void 0;
+              continue;
+            }
           }
           throw err;
         }
-        span?.setAttributes(HookResumeCommitted2(true));
-        const queuePublishRequestedAtMs = Date.now();
-        await publishHookWakeWithRetry2(() => 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(HookWakePublished2(true));
-        return asLazyMetadataHook2(hook);
-      } catch (err) {
-        span?.setAttributes({
-          ...HookToken2(typeof tokenOrHook === "string" ? tokenOrHook : tokenOrHook.token),
-          ...HookFound2(false)
-        });
-        throw err;
       }
     });
   });
 }
+async function resumeHookAttempt2(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 (HookNotFoundError2.is(lookupError)) {
+          notFoundReasons2.set(lookupError, "lookup");
+        }
+        throw lookupError;
+      }
+    } else {
+      hook = tokenOrHook;
+    }
+    if (webhookOnly && hook.isWebhook === false) {
+      const notWebhook = new HookNotFoundError2(hook.token);
+      notFoundReasons2.set(notWebhook, "not-webhook");
+      throw notWebhook;
+    }
+    const hookResumeCapabilitiesAreFresh = suppliedToken || hookFreshlyLookedUp;
+    const info = await resolveHookResumeInfo2(hook);
+    const { resumeContext } = info;
+    span?.setAttributes({
+      ...HookToken2(hook.token),
+      ...HookId2(hook.hookId),
+      ...WorkflowRunId4(hook.runId),
+      "workflow.hook.resume_context_source": info.source
+    });
+    if (info.run && isTerminalWorkflowRunStatus2(info.run.status)) {
+      throw new HookNotFoundError2(hook.token);
+    }
+    const capabilities = getRunCapabilities2(resumeContext.workflowCoreVersion);
+    let payloadKey;
+    const runPublicKey = encryptionKeyOverride ? (
+      // The caller already holds a key (resumeWebhook resolved one to
+      // hydrate hook metadata), so sealing would add an ECDH for no
+      // saved round trip. Reuse what it resolved.
+      void 0
+    ) : decodeRunPublicKey2(resumeContext.encryptionPublicKey);
+    if (runPublicKey) {
+      payloadKey = sealTo2(runPublicKey);
+    } else {
+      let encryptionKey = encryptionKeyOverride ?? await resolveHookEncryptionKey2(hook, info);
+      if (!capabilities.supportedFormats.has(SerializationFormat2.ENCRYPTED)) {
+        encryptionKey = void 0;
+      }
+      payloadKey = encryptionKey;
+    }
+    const compression = (resumeContext.runSpecVersion ?? 0) >= SPEC_VERSION_SUPPORTS_COMPRESSION2 && capabilities.supportedFormats.has(SerializationFormat2.GZIP);
+    const ops = [];
+    const readbackOps = [];
+    const v1Compat = isLegacySpecVersion2(hook.specVersion);
+    const dehydratedPayload = await dehydrateStepReturnValue2(payload, hook.runId, payloadKey, ops, globalThis, v1Compat, capabilities.framedByteStreams, compression, void 0, readbackOps);
+    await Promise.all(ops.map((op) => op.catch((error121) => {
+      if (error121 !== void 0)
+        throw error121;
+    })));
+    safeWaitUntil2(Promise.all(readbackOps), (err) => {
+      if (err === void 0)
+        return;
+      runtimeLogger2.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 WorkflowRuntimeError2("World advertises invoke without implementing it");
+      }
+      span?.setAttributes({ "workflow.hook.resume_strategy": "invoke" });
+      const result2 = HookInvocationResultSchema2.parse(await world.invoke(hook.runId, {
+        type: "hook_resume",
+        version: 1,
+        hookId: hook.hookId,
+        token: hook.token,
+        payload: dehydratedPayload
+      }, { idempotencyKey: logicalResumeId }));
+      if (result2.status === "rejected") {
+        if (result2.code === "HOOK_NOT_FOUND")
+          throw new HookNotFoundError2(hook.token);
+        throw new WorkflowRuntimeError2("Executor rejected the hook invocation input");
+      }
+      span?.setAttributes(HookResumeCommitted2(true));
+      return asLazyMetadataHook2(hook);
+    }
+    span?.setAttributes({
+      ...WorkflowName2(resumeContext.workflowName)
+    });
+    const originLink = await linkToTraceCarrier2(resumeContext.traceCarrier);
+    if (originLink) {
+      span?.addLink?.(originLink);
+    }
+    const queueName = getWorkflowQueueName2(resumeContext.workflowName);
+    const queueOptions = {
+      deploymentId: resumeContext.deploymentId,
+      specVersion: resumeContext.runSpecVersion ?? SPEC_VERSION_LEGACY2
+    };
+    const backendDedupSupported = (hookResumeCapabilitiesAreFresh ? hook.resumeCapabilities?.hookResumeDedupVersion ?? 0 : 0) >= HOOK_RESUME_DEDUP_VERSION2 || 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 computeResumePayloadDigest2(dehydratedPayload) : void 0;
+    if (resumeId) {
+      span?.setAttributes({ "workflow.hook.resume_id": resumeId });
+    }
+    const isHookGoneError = /* @__PURE__ */ __name((err) => HookNotFoundError2.is(err) || RunExpiredError2.is(err), "isHookGoneError");
+    try {
+      await world.events.create(hook.runId, {
+        eventType: "hook_received",
+        specVersion: SPEC_VERSION_CURRENT2,
+        correlationId: hook.hookId,
+        eventData: {
+          ...v1Compat ? {} : { token: hook.token },
+          payload: dehydratedPayload
+        }
+      }, {
+        v1Compat,
+        ...resumeId && payloadDigest ? { resumeId, resumePayloadDigest: payloadDigest } : {}
+      });
+    } catch (err) {
+      if (HookForceClaimedError2.is(err))
+        throw err;
+      if (isHookGoneError(err)) {
+        throw new HookNotFoundError2(hook.token);
+      }
+      throw err;
+    }
+    span?.setAttributes(HookResumeCommitted2(true));
+    const queuePublishRequestedAtMs = Date.now();
+    await publishHookWakeWithRetry2(() => 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(HookWakePublished2(true));
+    return asLazyMetadataHook2(hook);
+  } catch (err) {
+    span?.setAttributes({
+      ...HookToken2(typeof tokenOrHook === "string" ? tokenOrHook : tokenOrHook.token),
+      ...HookFound2(false)
+    });
+    throw err;
+  }
+}
 async function resumeWebhook2(token, request) {
   const resumeRequestedAtMs = Date.now();
   const world = await getWorldLazy2();
@@ -87008,7 +87530,7 @@ async function resumeWebhook2(token, request) {
   } else {
     response = new Response(null, { status: 202 });
   }
-  await resumeHookImpl2(hook, request, metadataEncryptionKey(), true, resumeRequestedAtMs);
+  await resumeHookImpl2(hook, request, metadataEncryptionKey(), true, resumeRequestedAtMs, true);
   if (responseReadable) {
     const reader = responseReadable.getReader();
     const chunk = await reader.read();
@@ -87024,7 +87546,7 @@ async function resumeWebhook2(token, request) {
   }
   return response;
 }
-var generateResumeId2, HOOK_WAKE_RETRY_DELAYS_MS2;
+var generateResumeId2, MAX_FORCE_CLAIM_REDIRECTS2, notFoundReasons2;
 var init_resume_hook2 = __esm({
   "../core/dist/runtime/resume-hook.js"() {
     "use strict";
@@ -87042,13 +87564,11 @@ var init_resume_hook2 = __esm({
     init_telemetry4();
     init_get_world_lazy2();
     init_helpers3();
+    init_hook_wake2();
     init_invocations2();
     init_wait_until2();
     generateResumeId2 = monotonicFactory2();
     __name(computeResumePayloadDigest2, "computeResumePayloadDigest");
-    HOOK_WAKE_RETRY_DELAYS_MS2 = [25, 100];
-    __name(isRetryableWakeError2, "isRetryableWakeError");
-    __name(publishHookWakeWithRetry2, "publishHookWakeWithRetry");
     __name(resumeContextFromRun2, "resumeContextFromRun");
     __name(resolveHookResumeInfo2, "resolveHookResumeInfo");
     __name(resolveHookEncryptionKey2, "resolveHookEncryptionKey");
@@ -87057,7 +87577,10 @@ var init_resume_hook2 = __esm({
     __name(asLazyMetadataHook2, "asLazyMetadataHook");
     __name(getHookByToken3, "getHookByToken");
     __name(resumeHook2, "resumeHook");
+    MAX_FORCE_CLAIM_REDIRECTS2 = 3;
+    notFoundReasons2 = /* @__PURE__ */ new WeakMap();
     __name(resumeHookImpl2, "resumeHookImpl");
+    __name(resumeHookAttempt2, "resumeHookAttempt");
     __name(resumeWebhook2, "resumeWebhook");
   }
 });
@@ -89341,6 +89864,11 @@ function getInlineOwnershipLeaseSeconds() {
 function getReplayDivergenceMaxRetries() {
   return envNumber2("WORKFLOW_REPLAY_DIVERGENCE_MAX_RETRIES", REPLAY_DIVERGENCE_MAX_RETRIES, { integer: true });
 }
+function getOpenWaitClockSkewMs() {
+  return envNumber2("WORKFLOW_OPEN_WAIT_CLOCK_SKEW_MS", OPEN_WAIT_CLOCK_SKEW_MS, {
+    integer: true
+  });
+}
 function getPreconditionMaxInProcessRestarts() {
   return envNumber2("WORKFLOW_PRECONDITION_MAX_INPROCESS_RESTARTS", PRECONDITION_MAX_INPROCESS_RESTARTS, { integer: true });
 }
@@ -89353,7 +89881,7 @@ function getPreconditionReinvokeDelaySeconds() {
 function getDeploymentMismatchMaxRetries() {
   return envNumber2("WORKFLOW_DEPLOYMENT_MISMATCH_MAX_RETRIES", DEPLOYMENT_MISMATCH_MAX_RETRIES, { integer: true, min: 0 });
 }
-var MAX_QUEUE_DELIVERIES, REPLAY_TIMEOUT_MS, MIN_REPLAY_TIMEOUT_MS, MAX_REPLAY_TIMEOUT_MS, warned, REPLAY_TIMEOUT_MAX_RETRIES, MAX_INLINE_STEPS, MIN_MAX_INLINE_STEPS, MAX_MAX_INLINE_STEPS, MAX_RESILIENT_STEP_INPUT_BYTES, MAX_BATCH_FANOUT_EVENTS, INLINE_OWNERSHIP_LEASE_SECONDS, MAX_INLINE_OWNERSHIP_LEASE_SECONDS, REPLAY_DIVERGENCE_MAX_RETRIES, PRECONDITION_MAX_INPROCESS_RESTARTS, PRECONDITION_MAX_REINVOCATIONS, PRECONDITION_REINVOKE_DELAY_SECONDS, DEPLOYMENT_MISMATCH_MAX_RETRIES;
+var MAX_QUEUE_DELIVERIES, REPLAY_TIMEOUT_MS, MIN_REPLAY_TIMEOUT_MS, MAX_REPLAY_TIMEOUT_MS, warned, REPLAY_TIMEOUT_MAX_RETRIES, MAX_INLINE_STEPS, MIN_MAX_INLINE_STEPS, MAX_MAX_INLINE_STEPS, MAX_RESILIENT_STEP_INPUT_BYTES, MAX_BATCH_FANOUT_EVENTS, INLINE_OWNERSHIP_LEASE_SECONDS, MAX_INLINE_OWNERSHIP_LEASE_SECONDS, REPLAY_DIVERGENCE_MAX_RETRIES, OPEN_WAIT_CLOCK_SKEW_MS, PRECONDITION_MAX_INPROCESS_RESTARTS, PRECONDITION_MAX_REINVOCATIONS, PRECONDITION_REINVOKE_DELAY_SECONDS, DEPLOYMENT_MISMATCH_MAX_RETRIES;
 var init_constants3 = __esm({
   "../core/dist/runtime/constants.js"() {
     "use strict";
@@ -89394,6 +89922,8 @@ var init_constants3 = __esm({
     __name(getInlineOwnershipLeaseSeconds, "getInlineOwnershipLeaseSeconds");
     REPLAY_DIVERGENCE_MAX_RETRIES = 3;
     __name(getReplayDivergenceMaxRetries, "getReplayDivergenceMaxRetries");
+    OPEN_WAIT_CLOCK_SKEW_MS = 3e4;
+    __name(getOpenWaitClockSkewMs, "getOpenWaitClockSkewMs");
     PRECONDITION_MAX_INPROCESS_RESTARTS = 3;
     __name(getPreconditionMaxInProcessRestarts, "getPreconditionMaxInProcessRestarts");
     PRECONDITION_MAX_REINVOCATIONS = 5;
@@ -91438,11 +91968,11 @@ var init_step_executor = __esm({
 });
 
 // ../core/dist/runtime/step-single-flight.js
-async function runStepSingleFlight(runId, correlationId, execute) {
+async function runStepSingleFlight(runId, correlationId, execute, logLevel = "warn") {
   const key = `${runId}:${correlationId}`;
   const existing = singleFlight.inFlight.get(key);
   if (existing) {
-    runtimeLogger2.warn("Step execution already in flight in this process; awaiting its settlement instead of executing again", { workflowRunId: runId, stepId: correlationId });
+    runtimeLogger2[logLevel]("Step execution already in flight in this process; awaiting its settlement instead of executing again", { workflowRunId: runId, stepId: correlationId });
     try {
       await existing;
     } catch {
@@ -96634,6 +97164,28 @@ function createQuickJSSerde(vm, capturedRoot) {
         reduced.cause = shape.cause;
       return reduced;
     }, "HookConflictError"),
+    HookForceClaimedError: /* @__PURE__ */ __name((value) => {
+      if (!isHandle(value) || !value.isError)
+        return false;
+      if (chainedString(value, "name") !== "HookForceClaimedError")
+        return false;
+      const shape = reduceErrorShape(value);
+      const reduced = {
+        message: shape.message,
+        stack: shape.stack,
+        token: own3(value, "token"),
+        claimedByRunId: own3(value, "claimedByRunId")
+      };
+      const claimedByHookId = own3(value, "claimedByHookId");
+      if (claimedByHookId && !claimedByHookId.isUndefined) {
+        reduced.claimedByHookId = claimedByHookId;
+      } else {
+        claimedByHookId?.dispose();
+      }
+      if (Object.hasOwn(shape, "cause"))
+        reduced.cause = shape.cause;
+      return reduced;
+    }, "HookForceClaimedError"),
     RangeError: namedErrorSubclassReducer("RangeError"),
     ReferenceError: namedErrorSubclassReducer("ReferenceError"),
     RetryableError: /* @__PURE__ */ __name((value) => {
@@ -97221,6 +97773,42 @@ function createQuickJSSerde(vm, capturedRoot) {
       }
       return error121;
     }, "HookConflictError"),
+    HookForceClaimedError: /* @__PURE__ */ __name((value) => {
+      const cls = registeredErrorClass("@workflow/errors//HookForceClaimedError");
+      let error121;
+      if (cls) {
+        const token = own3(value, "token") ?? vm.undefined;
+        const claimedByRunId = own3(value, "claimedByRunId") ?? vm.undefined;
+        const claimedByHookId = own3(value, "claimedByHookId") ?? vm.undefined;
+        error121 = vm.construct(cls, token, claimedByRunId, claimedByHookId);
+        if (token !== vm.undefined)
+          token.dispose();
+        if (claimedByRunId !== vm.undefined)
+          claimedByRunId.dispose();
+        if (claimedByHookId !== vm.undefined)
+          claimedByHookId.dispose();
+        const stack = own3(value, "stack");
+        if (stack && !stack.isUndefined)
+          define2(error121, "stack", stack);
+        stack?.dispose();
+        if (guestHasOwn(value, "cause")) {
+          const cause = own3(value, "cause") ?? vm.undefined;
+          define2(error121, "cause", cause);
+          if (cause !== vm.undefined)
+            cause.dispose();
+        }
+        cls.dispose();
+      } else {
+        error121 = buildError(i.Error, value, { name: "HookForceClaimedError" });
+        for (const field of ["token", "claimedByRunId", "claimedByHookId"]) {
+          const handle = own3(value, field);
+          if (handle && !handle.isUndefined)
+            define2(error121, field, handle);
+          handle?.dispose();
+        }
+      }
+      return error121;
+    }, "HookForceClaimedError"),
     RangeError: namedErrorSubclassReviver("RangeError"),
     ReferenceError: namedErrorSubclassReviver("ReferenceError"),
     RetryableError: /* @__PURE__ */ __name((value) => {
@@ -97818,6 +98406,7 @@ var init_quickjs_serde = __esm({
       "workflow-class-registry",
       "@workflow/errors//FatalError",
       "@workflow/errors//HookConflictError",
+      "@workflow/errors//HookForceClaimedError",
       "@workflow/errors//RetryableError",
       "@workflow/errors//RuntimeDecryptionError",
       "@workflow/errors//StreamError"
@@ -98509,13 +99098,30 @@ async function processEvents(vm, serde, events, advanceClock, encryptionKey) {
       case "hook_conflict": {
         const conflictToken = eventData?.token ?? "unknown";
         const conflictingRunId = eventData?.conflictingRunId;
+        const forceRefusedReason = eventData?.forceRefusedReason;
         const didSettle = vm.dump(vm.evalCode(`(function(){
               var cid = ${JSON.stringify(cid)};
               var token = ${JSON.stringify(conflictToken)};
               var conflictingRunId = ${JSON.stringify(conflictingRunId ?? null)};
+              var forceRefused = ${JSON.stringify(forceRefusedReason !== void 0)};
               var ErrCls = globalThis[Symbol.for('@workflow/errors//HookConflictError')];
               var err;
-              if (typeof ErrCls === 'function') {
+              var hookState = globalThis.__hooks && globalThis.__hooks[cid];
+              // A forced hook asked for a guarantee the World could not give
+              // (older server, kill switch): a misconfiguration, not the
+              // ordinary conflict the caller opted out of. Mirrors hook.ts.
+              var forced = !!(hookState && hookState.force) && !forceRefused;
+              if (forced) {
+                var FatalCls = globalThis[Symbol.for('@workflow/errors//FatalError')];
+                var forcedMessage = 'createHook({ experimental_force: true }) for token "' + token + '" was answered with a hook_conflict: the configured World does not support force-claiming hook tokens' + (conflictingRunId ? ' (run "' + conflictingRunId + '" holds it)' : '') + '.';
+                if (typeof FatalCls === 'function') {
+                  err = new FatalCls(forcedMessage);
+                } else {
+                  err = new Error(forcedMessage);
+                  err.name = 'FatalError';
+                  err.fatal = true;
+                }
+              } else if (typeof ErrCls === 'function') {
                 err = new ErrCls(token, conflictingRunId || undefined);
               } else {
                 err = new Error('Hook token "' + token + '" is already in use by another workflow');
@@ -98524,7 +99130,7 @@ async function processEvents(vm, serde, events, advanceClock, encryptionKey) {
                 if (conflictingRunId) err.conflictingRunId = conflictingRunId;
               }
               var run = null;
-              if (conflictingRunId) {
+              if (conflictingRunId && !forced) {
                 var reg = globalThis[Symbol.for('workflow-class-registry')];
                 var RunCls = reg && reg.get('class//workflow//Run');
                 var des = RunCls && RunCls[Symbol.for('workflow-deserialize')];
@@ -98588,6 +99194,48 @@ async function processEvents(vm, serde, events, advanceClock, encryptionKey) {
         break;
       }
       case "hook_disposed": {
+        const claimedBy = eventData?.forceClaimedBy;
+        if (claimedBy && typeof claimedBy.runId === "string") {
+          const hookState = vm.dump(vm.evalCode(`(function(){
+                var cid = ${JSON.stringify(cid)};
+                var state = globalThis.__hooks && globalThis.__hooks[cid];
+                var token = state ? state.token : ${JSON.stringify(eventData?.token ?? "")};
+                var claimedByRunId = ${JSON.stringify(claimedBy.runId)};
+                var claimedByHookId = ${JSON.stringify(claimedBy.hookId ?? null)};
+                var ErrCls = globalThis[Symbol.for('@workflow/errors//HookForceClaimedError')];
+                var err;
+                if (typeof ErrCls === 'function') {
+                  err = new ErrCls(token, claimedByRunId, claimedByHookId || undefined);
+                } else {
+                  err = new Error('Hook token "' + token + '" was force-claimed by another workflow (run "' + claimedByRunId + '")');
+                  err.name = 'HookForceClaimedError';
+                  err.token = token;
+                  err.claimedByRunId = claimedByRunId;
+                  if (claimedByHookId) err.claimedByHookId = claimedByHookId;
+                }
+                var settled = false;
+                if (state) {
+                  state.forceClaimed = err;
+                  var gc = state.getConflictResolvers;
+                  state.getConflictResolvers = [];
+                  for (var i = 0; i < gc.length; i++) { gc[i].resolve(null); settled = true; }
+                }
+                if (globalThis.__resolvers[cid]) {
+                  globalThis.__resolvers[cid].reject(err);
+                  delete globalThis.__resolvers[cid];
+                  settled = true;
+                }
+                return settled;
+              })()`));
+          if (hookState) {
+            resolved = true;
+            let b;
+            do {
+              b = vm.executePendingJobs();
+            } while (b > 0);
+          }
+          markCreated(vm, cidJs);
+        }
         markCreated(vm, cidJs, "hook_dispose");
         break;
       }
@@ -99346,6 +99994,20 @@ globalThis[Symbol.for("WORKFLOW_CREATE_HOOK")] = function(options) {
     unsupportedRetentionError.fatal = true;
     throw unsupportedRetentionError;
   }
+  if (options.experimental_force === true) {
+    if (options.token === undefined || options.token === null) {
+      throw new Error('\`createHook()\` was called with \`experimental_force: true\` but no \`token\`. Force-claiming only applies to an explicit token another run may hold.');
+    }
+    if (options.isWebhook === true) {
+      throw new Error('Webhook hooks do not support \`experimental_force\`. Use a non-webhook \`createHook()\` with an explicit token.');
+    }
+    if (globalThis.__worldCapabilities?.hookForceClaim !== true) {
+      var unsupportedForceError = new Error('The configured World does not support \`experimental_force\` for Hooks.');
+      unsupportedForceError.name = "FatalError";
+      unsupportedForceError.fatal = true;
+      throw unsupportedForceError;
+    }
+  }
   var token = options.token || globalThis.__generateNanoid();
   var correlationId = "hook_" + globalThis.__generateUlid();
   var isDisposed = false;
@@ -99382,6 +100044,7 @@ globalThis[Symbol.for("WORKFLOW_CREATE_HOOK")] = function(options) {
     token: token,
     tokenRetentionUntil: tokenRetentionUntil,
     isWebhook: !!options.isWebhook,
+    force: options.experimental_force === true,
     metadata: options.metadata,
     hasCreatedEvent: false,
   };
@@ -99397,6 +100060,11 @@ globalThis[Symbol.for("WORKFLOW_CREATE_HOOK")] = function(options) {
     token: token,
     created: false,
     conflict: null,
+    // Set by the host on a hook_disposed{forceClaimedBy}: another run took
+    // the token. Buffered payloads (delivered before the takeover) are still
+    // drained; every await after them rejects with this error.
+    forceClaimed: null,
+    force: options.experimental_force === true,
     getConflictResolvers: [],
   };
 
@@ -99410,6 +100078,10 @@ globalThis[Symbol.for("WORKFLOW_CREATE_HOOK")] = function(options) {
     if (buf && buf.length > 0) {
       return Promise.resolve(buf.shift());
     }
+    var claimedState = globalThis.__hooks[correlationId];
+    if (claimedState && claimedState.forceClaimed) {
+      return Promise.reject(claimedState.forceClaimed);
+    }
     return new Promise(function(resolve, reject) {
       globalThis.__resolvers[correlationId] = { resolve: resolve, reject: reject };
     });
@@ -99425,7 +100097,9 @@ globalThis[Symbol.for("WORKFLOW_CREATE_HOOK")] = function(options) {
     // hook_disposed here would be rejected by the world's
     // hook-existence validation.
     var state = globalThis.__hooks[correlationId];
-    if (!state || !state.conflict) {
+    // A force-claimed hook is already disposed \u2014 the takeover journaled
+    // its hook_disposed \u2014 so there is nothing left to dispose either.
+    if (!state || (!state.conflict && !state.forceClaimed)) {
       // Signal to the entrypoint to create a hook_disposed event. The
       // token is carried so the entrypoint can order same-token hook
       // operations sequentially (a dispose must release the token before
@@ -99817,9 +100491,19 @@ async function dispatchPendingOps(params) {
             isWebhook: hook.isWebhook,
             // System hooks (AbortController) are exempt from user
             // token namespace conflict checks.
-            ...hook.isSystem ? { isSystem: true } : {}
+            ...hook.isSystem ? { isSystem: true } : {},
+            ...hook.force ? { force: true } : {}
           }
         }, hookDeltaCursor !== void 0 ? { sinceCursor: hookDeltaCursor } : void 0);
+        if (result2.hook?.claimedFrom) {
+          const outcome = await publishForceClaimVictimWake(world, runId, result2.hook);
+          runtimeLogger2.info("Hook token force-claimed from another run", {
+            workflowRunId: runId,
+            hookId: hook.correlationId,
+            victimRunId: result2.hook.claimedFrom.runId,
+            victimWake: outcome
+          });
+        }
         if (result2.event?.eventType === "hook_conflict") {
           await queueMessage(world, getWorkflowQueueName2(workflowRun.workflowName, namespace), {
             runId,
@@ -99908,16 +100592,23 @@ async function dispatchPendingOps(params) {
       hookOpsByToken.set(key, [op]);
     }
   }
-  for (const group of hookOpsByToken.values()) {
-    opsPromises.push((async () => {
-      for (const op of group) {
-        if (op.type === "hook") {
-          await processHookOp(op);
-        } else {
-          await processHookDisposeOp(op);
-        }
+  const runHookGroup = /* @__PURE__ */ __name(async (group) => {
+    for (const op of group) {
+      if (op.type === "hook") {
+        await processHookOp(op);
+      } else {
+        await processHookDisposeOp(op);
       }
-    })());
+    }
+  }, "runHookGroup");
+  const hookGroups = [...hookOpsByToken.values()];
+  const holdsForcedCreation = /* @__PURE__ */ __name((group) => group.some((op) => op.type === "hook" && op.force === true && !op.hasCreatedEvent), "holdsForcedCreation");
+  for (const group of hookGroups.filter(holdsForcedCreation)) {
+    await runHookGroup(group);
+  }
+  for (const group of hookGroups) {
+    if (!holdsForcedCreation(group))
+      opsPromises.push(runHookGroup(group));
   }
   for (const op of pendingOperations) {
     if (op.type === "step" && !op.hasCreatedEvent && !skipStepCreation?.has(op.correlationId)) {
@@ -100149,6 +100840,7 @@ async function runWorkflowWithQuickJS(params) {
     events = allEvents;
     loadedCursor = cursor;
   }
+  await republishOwedForceClaimVictimWake(world, runId, events);
   const logView = new QuickJSLogView(events, loadedCursor);
   const createEvent = /* @__PURE__ */ __name(async (data, eventParams) => {
     const result3 = await world.events.create(runId, data, {
@@ -100558,7 +101250,7 @@ async function runWorkflowWithQuickJS(params) {
           // attempt.
           authoritativeAttempt: 1,
           ...inlineDeltaSinceCursor !== void 0 ? { inlineDeltaSinceCursor } : {}
-        }))())));
+        }))(), "debug")));
       } finally {
         budget.resume();
       }
@@ -100893,6 +101585,7 @@ var init_quickjs_entrypoint = __esm({
     init_constants3();
     init_get_port_lazy();
     init_helpers3();
+    init_hook_wake2();
     init_lifecycle_hooks();
     init_quickjs_log_view();
     init_quickjs_runtime();
@@ -101341,6 +102034,7 @@ var StepNotRegisteredError;
 var WorkflowNotRegisteredError;
 var WorkflowRunNotFoundError;
 var HookConflictError;
+var HookForceClaimedError;
 var HookNotFoundError;
 var EntityConflictError;
 var RunExpiredError;
@@ -101353,6 +102047,7 @@ var RetryableError;
 var FATAL_ERROR_KEY;
 var RETRYABLE_ERROR_KEY;
 var HOOK_CONFLICT_ERROR_KEY;
+var HOOK_FORCE_CLAIMED_ERROR_KEY;
 var RUNTIME_DECRYPTION_ERROR_KEY;
 var STREAM_ERROR_KEY;
 var init_dist2 = __esm2({
@@ -101374,6 +102069,7 @@ var init_dist2 = __esm2({
       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",
@@ -101633,6 +102329,33 @@ Caused by: ${options.cause.stack}`;
         return isError(value) && value.name === "HookConflictError";
       }
     };
+    HookForceClaimedError = class extends WorkflowError {
+      static {
+        __name(this, "HookForceClaimedError");
+      }
+      static {
+        __name2(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");
@@ -101812,6 +102535,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") {
@@ -101839,6 +102563,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,
@@ -101915,7 +102647,7 @@ var SPEC_VERSION_SUPPORTS_CBOR_QUEUE_TRANSPORT;
 var SPEC_VERSION_SUPPORTS_ATTRIBUTES;
 var SPEC_VERSION_SUPPORTS_COMPRESSION;
 var SPEC_VERSION_SUPPORTS_SLOT_IDENTITY;
-var SPEC_VERSION_SUPPORTS_SEALED_LOG;
+var SPEC_VERSION_SUPPORTS_HOOK_FORCE_CLAIM;
 var SPEC_VERSION_CURRENT;
 var SPEC_VERSION_MAX_SUPPORTED;
 var init_spec_version = __esm2({
@@ -101927,9 +102659,9 @@ var init_spec_version = __esm2({
     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;
+    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;
     __name2(isLegacySpecVersion, "isLegacySpecVersion");
   }
 });
@@ -126890,7 +127622,30 @@ var init_events = __esm2({
         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({
@@ -126905,7 +127660,17 @@ var init_events = __esm2({
       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({
@@ -126915,7 +127680,18 @@ var init_events = __esm2({
         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({
@@ -127801,6 +128577,7 @@ var HookResumeContextSchema;
 var HOOK_RESUME_INPUT_VERSION;
 var HOOK_RESUME_DEDUP_VERSION;
 var HookResumeCapabilitiesSchema;
+var HookClaimedFromSchema;
 var HookSchema;
 var init_hooks = __esm2({
   "../world/dist/hooks.js"() {
@@ -127842,6 +128619,13 @@ var init_hooks = __esm2({
       // 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(),
@@ -127869,7 +128653,12 @@ var init_hooks = __esm2({
       // `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()
     }));
   }
 });
@@ -128607,6 +129396,20 @@ function getCommonReducers(_global2 = globalThis) {
       }
       return reduced;
     }, "HookConflictError"),
+    HookForceClaimedError: /* @__PURE__ */ __name2((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
@@ -128782,6 +129585,15 @@ function getCommonRevivers(global2 = globalThis) {
       }
       return error612;
     }, "HookConflictError"),
+    HookForceClaimedError: /* @__PURE__ */ __name2((value) => {
+      const Ctor = global2[/* @__PURE__ */ Symbol.for("@workflow/errors//HookForceClaimedError")] ?? HookForceClaimedError;
+      const error612 = new Ctor(value.token, value.claimedByRunId, value.claimedByHookId);
+      if (value.stack !== void 0) error612.stack = value.stack;
+      if ("cause" in value) {
+        error612.cause = value.cause;
+      }
+      return error612;
+    }, "HookForceClaimedError"),
     RangeError: makeErrorSubclassReviver(global2, "RangeError"),
     ReferenceError: makeErrorSubclassReviver(global2, "ReferenceError"),
     RetryableError: /* @__PURE__ */ __name2((value) => {
@@ -134364,7 +135176,7 @@ var version2;
 var init_version = __esm2({
   "../core/dist/version.js"() {
     "use strict";
-    version2 = "5.0.0-beta.54";
+    version2 = "5.0.0-beta.56";
   }
 });
 function getWorkflowQueueName(workflowName, namespace) {
@@ -134551,6 +135363,56 @@ var init_helpers = __esm2({
     __name2(healthCheck, "healthCheck");
   }
 });
+function isRetryableWakeError(error612, isDeploymentUnavailableError) {
+  if (isDeploymentUnavailableError?.(error612)) return false;
+  const status = error612 ?? {};
+  const code22 = status.status ?? status.statusCode;
+  if (typeof code22 === "number") {
+    return code22 >= 500 || code22 === 408 || code22 === 429;
+  }
+  const name = error612?.name;
+  return name !== "BadRequestError" && name !== "UnauthorizedError" && name !== "ForbiddenError";
+}
+__name(isRetryableWakeError, "isRetryableWakeError");
+async function publishHookWakeWithRetry(publish, isDeploymentUnavailableError) {
+  let lastError;
+  for (let attempt = 0; attempt <= HOOK_WAKE_RETRY_DELAYS_MS.length; attempt++) {
+    try {
+      await publish();
+      return;
+    } catch (error612) {
+      lastError = error612;
+      if (!isRetryableWakeError(error612, isDeploymentUnavailableError)) break;
+      const delayMs = HOOK_WAKE_RETRY_DELAYS_MS[attempt];
+      if (delayMs !== void 0) {
+        await new Promise((resolve3) => setTimeout(resolve3, 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;
+}
+__name(publishHookWakeWithRetry, "publishHookWakeWithRetry");
+var HOOK_WAKE_RETRY_DELAYS_MS;
+var init_hook_wake = __esm2({
+  "../core/dist/runtime/hook-wake.js"() {
+    "use strict";
+    init_dist2();
+    init_dist4();
+    init_logger();
+    init_helpers();
+    HOOK_WAKE_RETRY_DELAYS_MS = [
+      25,
+      100
+    ];
+    __name2(isRetryableWakeError, "isRetryableWakeError");
+    __name2(publishHookWakeWithRetry, "publishHookWakeWithRetry");
+  }
+});
 var HookInvocationSchema;
 var HookInvocationResultSchema;
 var init_invocations = __esm2({
@@ -139600,40 +140462,6 @@ async function computeResumePayloadDigest(bytes) {
   return hex32;
 }
 __name(computeResumePayloadDigest, "computeResumePayloadDigest");
-function isRetryableWakeError(error612, isDeploymentUnavailableError) {
-  if (isDeploymentUnavailableError?.(error612)) return false;
-  const status = error612 ?? {};
-  const code22 = status.status ?? status.statusCode;
-  if (typeof code22 === "number") {
-    return code22 >= 500 || code22 === 408 || code22 === 429;
-  }
-  const name = error612?.name;
-  return name !== "BadRequestError" && name !== "UnauthorizedError" && name !== "ForbiddenError";
-}
-__name(isRetryableWakeError, "isRetryableWakeError");
-async function publishHookWakeWithRetry(publish, isDeploymentUnavailableError) {
-  let lastError;
-  for (let attempt = 0; attempt <= HOOK_WAKE_RETRY_DELAYS_MS.length; attempt++) {
-    try {
-      await publish();
-      return;
-    } catch (error612) {
-      lastError = error612;
-      if (!isRetryableWakeError(error612, isDeploymentUnavailableError)) break;
-      const delayMs = HOOK_WAKE_RETRY_DELAYS_MS[attempt];
-      if (delayMs !== void 0) {
-        await new Promise((resolve3) => setTimeout(resolve3, 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;
-}
-__name(publishHookWakeWithRetry, "publishHookWakeWithRetry");
 function resumeContextFromRun(run22) {
   const coreVersion = run22.executionContext?.workflowCoreVersion;
   const traceCarrier = run22.executionContext?.traceCarrier;
@@ -139723,164 +140551,269 @@ async function resumeHook(tokenOrHook, payload, encryptionKeyOverride) {
   return resumeHookImpl(tokenOrHook, payload, encryptionKeyOverride, false, Date.now());
 }
 __name(resumeHook, "resumeHook");
-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((error612) => {
-          if (error612 !== void 0) throw error612;
-        })));
-        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 target2 = 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__ */ __name2((cause) => {
+        if (payload instanceof Request && payload.body !== null && payload.bodyUsed) {
           span?.setAttributes({
-            "workflow.hook.resume_strategy": "invoke"
+            "workflow.hook.resume_redirect_unresendable": true
           });
-          const result2 = HookInvocationResultSchema.parse(await world.invoke(hook.runId, {
-            type: "hook_resume",
-            version: 1,
-            hookId: hook.hookId,
-            token: hook.token,
-            payload: dehydratedPayload
-          }, {
-            idempotencyKey: generateResumeId()
-          }));
-          if (result2.status === "rejected") {
-            if (result2.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__ */ __name2((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, target2, 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
+            });
+            target2 = token;
+            fresh = true;
+            keyOverride = void 0;
+            lookupsAfterRedirect = 0;
+            continue;
+          }
+          if (HookNotFoundError.is(err) && redirects > 0 && typeof target2 === "string" && lookupsAfterRedirect < MAX_LOOKUPS_AFTER_REDIRECT) {
+            assertResendable(err);
+            lookupsAfterRedirect++;
+            await new Promise((resolve3) => setTimeout(resolve3, 50));
+            continue;
+          }
+          if (HookNotFoundError.is(err) && notFoundReasons.get(err) !== "lookup") {
+            const attemptedHookId = typeof target2 === "string" ? void 0 : target2.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
+              });
+              target2 = 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;
       }
     });
   });
 }
 __name(resumeHookImpl, "resumeHookImpl");
+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((error612) => {
+      if (error612 !== void 0) throw error612;
+    })));
+    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 result2 = HookInvocationResultSchema.parse(await world.invoke(hook.runId, {
+        type: "hook_resume",
+        version: 1,
+        hookId: hook.hookId,
+        token: hook.token,
+        payload: dehydratedPayload
+      }, {
+        idempotencyKey: logicalResumeId
+      }));
+      if (result2.status === "rejected") {
+        if (result2.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__ */ __name2((err) => HookNotFoundError.is(err) || RunExpiredError.is(err), "isHookGoneError");
+    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
+        } : {}
+      });
+    } 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;
+  }
+}
+__name(resumeHookAttempt, "resumeHookAttempt");
 async function resumeWebhook(token, request) {
   const resumeRequestedAtMs = Date.now();
   const world = await getWorldLazy();
@@ -139908,7 +140841,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();
@@ -139926,7 +140859,8 @@ async function resumeWebhook(token, request) {
 }
 __name(resumeWebhook, "resumeWebhook");
 var generateResumeId;
-var HOOK_WAKE_RETRY_DELAYS_MS;
+var MAX_FORCE_CLAIM_REDIRECTS;
+var notFoundReasons;
 var init_resume_hook = __esm2({
   "../core/dist/runtime/resume-hook.js"() {
     "use strict";
@@ -139944,16 +140878,11 @@ var init_resume_hook = __esm2({
     init_telemetry();
     init_get_world_lazy();
     init_helpers();
+    init_hook_wake();
     init_invocations();
     init_wait_until();
     generateResumeId = monotonicFactory();
     __name2(computeResumePayloadDigest, "computeResumePayloadDigest");
-    HOOK_WAKE_RETRY_DELAYS_MS = [
-      25,
-      100
-    ];
-    __name2(isRetryableWakeError, "isRetryableWakeError");
-    __name2(publishHookWakeWithRetry, "publishHookWakeWithRetry");
     __name2(resumeContextFromRun, "resumeContextFromRun");
     __name2(resolveHookResumeInfo, "resolveHookResumeInfo");
     __name2(resolveHookEncryptionKey, "resolveHookEncryptionKey");
@@ -139962,7 +140891,10 @@ var init_resume_hook = __esm2({
     __name2(asLazyMetadataHook, "asLazyMetadataHook");
     __name2(getHookByToken, "getHookByToken");
     __name2(resumeHook, "resumeHook");
+    MAX_FORCE_CLAIM_REDIRECTS = 3;
+    notFoundReasons = /* @__PURE__ */ new WeakMap();
     __name2(resumeHookImpl, "resumeHookImpl");
+    __name2(resumeHookAttempt, "resumeHookAttempt");
     __name2(resumeWebhook, "resumeWebhook");
   }
 });
@@ -142401,7 +143333,7 @@ __name2(start, "start");
     value: "start",
     configurable: true
   });
-})(start, "step//@workflow/core/runtime/start@5.0.0-beta.54//start");
+})(start, "step//@workflow/core/runtime/start@5.0.0-beta.56//start");
 async function wakeUpRun(world, runId, options) {
   try {
     const run22 = await world.runs.get(runId, {
@@ -142876,7 +143808,7 @@ var Run = class _Run {
     value: "wakeUp",
     configurable: true
   });
-})(Run.prototype["wakeUp"], "step//@workflow/core/runtime/run@5.0.0-beta.54//Run#wakeUp");
+})(Run.prototype["wakeUp"], "step//@workflow/core/runtime/run@5.0.0-beta.56//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);
@@ -142885,7 +143817,7 @@ var Run = class _Run {
     value: "cancel",
     configurable: true
   });
-})(Run.prototype["cancel"], "step//@workflow/core/runtime/run@5.0.0-beta.54//Run#cancel");
+})(Run.prototype["cancel"], "step//@workflow/core/runtime/run@5.0.0-beta.56//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);
@@ -142894,7 +143826,7 @@ var Run = class _Run {
     value: "getReadable",
     configurable: true
   });
-})(Run.prototype["getReadable"], "step//@workflow/core/runtime/run@5.0.0-beta.54//Run#getReadable");
+})(Run.prototype["getReadable"], "step//@workflow/core/runtime/run@5.0.0-beta.56//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);
@@ -142903,7 +143835,7 @@ var Run = class _Run {
     value: "getWritable",
     configurable: true
   });
-})(Run.prototype["getWritable"], "step//@workflow/core/runtime/run@5.0.0-beta.54//Run#getWritable");
+})(Run.prototype["getWritable"], "step//@workflow/core/runtime/run@5.0.0-beta.56//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);
@@ -142912,7 +143844,7 @@ var Run = class _Run {
     value: "exists",
     configurable: true
   });
-})(Object.getOwnPropertyDescriptor(Run.prototype, "exists").get, "step//@workflow/core/runtime/run@5.0.0-beta.54//Run#exists");
+})(Object.getOwnPropertyDescriptor(Run.prototype, "exists").get, "step//@workflow/core/runtime/run@5.0.0-beta.56//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);
@@ -142921,7 +143853,7 @@ var Run = class _Run {
     value: "status",
     configurable: true
   });
-})(Object.getOwnPropertyDescriptor(Run.prototype, "status").get, "step//@workflow/core/runtime/run@5.0.0-beta.54//Run#status");
+})(Object.getOwnPropertyDescriptor(Run.prototype, "status").get, "step//@workflow/core/runtime/run@5.0.0-beta.56//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);
@@ -142930,7 +143862,7 @@ var Run = class _Run {
     value: "returnValue",
     configurable: true
   });
-})(Object.getOwnPropertyDescriptor(Run.prototype, "returnValue").get, "step//@workflow/core/runtime/run@5.0.0-beta.54//Run#returnValue");
+})(Object.getOwnPropertyDescriptor(Run.prototype, "returnValue").get, "step//@workflow/core/runtime/run@5.0.0-beta.56//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);
@@ -142939,7 +143871,7 @@ var Run = class _Run {
     value: "workflowName",
     configurable: true
   });
-})(Object.getOwnPropertyDescriptor(Run.prototype, "workflowName").get, "step//@workflow/core/runtime/run@5.0.0-beta.54//Run#workflowName");
+})(Object.getOwnPropertyDescriptor(Run.prototype, "workflowName").get, "step//@workflow/core/runtime/run@5.0.0-beta.56//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);
@@ -142948,7 +143880,7 @@ var Run = class _Run {
     value: "createdAt",
     configurable: true
   });
-})(Object.getOwnPropertyDescriptor(Run.prototype, "createdAt").get, "step//@workflow/core/runtime/run@5.0.0-beta.54//Run#createdAt");
+})(Object.getOwnPropertyDescriptor(Run.prototype, "createdAt").get, "step//@workflow/core/runtime/run@5.0.0-beta.56//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);
@@ -142957,7 +143889,7 @@ var Run = class _Run {
     value: "startedAt",
     configurable: true
   });
-})(Object.getOwnPropertyDescriptor(Run.prototype, "startedAt").get, "step//@workflow/core/runtime/run@5.0.0-beta.54//Run#startedAt");
+})(Object.getOwnPropertyDescriptor(Run.prototype, "startedAt").get, "step//@workflow/core/runtime/run@5.0.0-beta.56//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);
@@ -142966,7 +143898,7 @@ var Run = class _Run {
     value: "completedAt",
     configurable: true
   });
-})(Object.getOwnPropertyDescriptor(Run.prototype, "completedAt").get, "step//@workflow/core/runtime/run@5.0.0-beta.54//Run#completedAt");
+})(Object.getOwnPropertyDescriptor(Run.prototype, "completedAt").get, "step//@workflow/core/runtime/run@5.0.0-beta.56//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);
@@ -142976,7 +143908,7 @@ var Run = class _Run {
     enumerable: false,
     configurable: false
   });
-})(Run, "class//@workflow/core/runtime/run@5.0.0-beta.54//Run");
+})(Run, "class//@workflow/core/runtime/run@5.0.0-beta.56//Run");
 async function fetch2(...args) {
   return globalThis.fetch(...args);
 }
@@ -143816,6 +144748,60 @@ __name(guardDeploymentAffinity, "guardDeploymentAffinity");
 init_helpers3();
 init_invocations2();
 init_lifecycle_hooks();
+
+// ../core/dist/runtime/open-hook-wait-state.js
+function openHookAndWaitState(events) {
+  const hooks = /* @__PURE__ */ new Set();
+  const waits = /* @__PURE__ */ new Map();
+  for (const event of events) {
+    switch (event.eventType) {
+      case "hook_created":
+        hooks.add(event.correlationId);
+        break;
+      case "hook_disposed":
+        hooks.delete(event.correlationId);
+        break;
+      case "wait_created":
+        waits.set(event.correlationId, resumeAtMs(event.eventData?.resumeAt));
+        break;
+      case "wait_completed":
+        waits.delete(event.correlationId);
+        break;
+    }
+  }
+  let earliestOpenWaitResumeAtMs;
+  for (const at of waits.values()) {
+    if (earliestOpenWaitResumeAtMs === void 0 || at < earliestOpenWaitResumeAtMs) {
+      earliestOpenWaitResumeAtMs = at;
+    }
+  }
+  return {
+    openHook: hooks.size > 0,
+    openWait: waits.size > 0,
+    earliestOpenWaitResumeAtMs
+  };
+}
+__name(openHookAndWaitState, "openHookAndWaitState");
+function resumeAtMs(resumeAt) {
+  let ms3;
+  if (resumeAt instanceof Date) {
+    ms3 = resumeAt.getTime();
+  } else if (typeof resumeAt === "number") {
+    ms3 = resumeAt;
+  } else if (typeof resumeAt === "string") {
+    ms3 = new Date(resumeAt).getTime();
+  } else {
+    return -Infinity;
+  }
+  return Number.isFinite(ms3) ? ms3 : -Infinity;
+}
+__name(resumeAtMs, "resumeAtMs");
+function hasOpenWaitDueBy(state, deadlineMs) {
+  return state.earliestOpenWaitResumeAtMs !== void 0 && state.earliestOpenWaitResumeAtMs <= deadlineMs;
+}
+__name(hasOpenWaitDueBy, "hasOpenWaitDueBy");
+
+// ../core/dist/runtime.js
 init_replay_budget();
 init_replay_recovery_reporter();
 init_resume_latency();
@@ -143879,9 +144865,10 @@ init_util5();
 init_compute_instance();
 init_constants3();
 init_helpers3();
+init_hook_wake2();
 init_replay_recovery_reporter();
 init_unserializable_step();
-async function createHookEvent({ runId, hookEvent, queueItem, requestId, sinceCursor, createEvent }) {
+async function createHookEvent({ runId, hookEvent, queueItem, requestId, sinceCursor, createEvent, world }) {
   try {
     const result2 = await createEvent(hookEvent, {
       requestId,
@@ -143893,6 +144880,15 @@ async function createHookEvent({ runId, hookEvent, queueItem, requestId, sinceCu
         hasAwaitedHookCreation: false
       };
     }
+    if (result2.hook?.claimedFrom) {
+      const outcome = await publishForceClaimVictimWake(world, runId, result2.hook);
+      runtimeLogger2.info("Hook token force-claimed from another run", {
+        workflowRunId: runId,
+        hookId: queueItem.correlationId,
+        victimRunId: result2.hook.claimedFrom.runId,
+        victimWake: outcome
+      });
+    }
     return {
       hasHookConflict: false,
       hasAwaitedHookCreation: queueItem.hasConflictAwaiter === true
@@ -143929,6 +144925,7 @@ async function createHookEvent({ runId, hookEvent, queueItem, requestId, sinceCu
 __name(createHookEvent, "createHookEvent");
 async function handleSuspension({ suspension, world, run: run3, span, requestId, eventLog, runReadyBarrier, replayRecoveryReporter, stepDispatch, ownerMessageId, allowDeferredBatchWork }) {
   const runId = run3.runId;
+  await republishOwedForceClaimVictimWake(world, runId, eventLog?.events);
   const ensureRunReady = /* @__PURE__ */ __name(async () => {
     if (runReadyBarrier) {
       try {
@@ -144059,7 +145056,7 @@ async function handleSuspension({ suspension, world, run: run3, span, requestId,
   if (hookItemsByToken.size > 0) {
     const hookPhaseStart = Date.now();
     await ensureRunReady();
-    await settlePhase([...hookItemsByToken.values()].map(async (items) => {
+    const processHookGroup = /* @__PURE__ */ __name(async (items) => {
       for (const queueItem of items) {
         let creationConflicted = false;
         if (!queueItem.hasCreatedEvent) {
@@ -144076,7 +145073,8 @@ async function handleSuspension({ suspension, world, run: run3, span, requestId,
               tokenRetentionUntil: queueItem.tokenRetentionUntil,
               metadata: hookMetadata,
               isWebhook: queueItem.isWebhook ?? false,
-              ...queueItem.isSystem && { isSystem: true }
+              ...queueItem.isSystem && { isSystem: true },
+              ...queueItem.force && { force: true }
             }
           };
           const result2 = await createHookEvent({
@@ -144085,7 +145083,8 @@ async function handleSuspension({ suspension, world, run: run3, span, requestId,
             queueItem,
             requestId,
             sinceCursor: hookDeltaCursor,
-            createEvent: createGuarded
+            createEvent: createGuarded,
+            world
           });
           if (result2.hasHookConflict) {
             hookConflictCorrelationIds.push(queueItem.correlationId);
@@ -144099,7 +145098,13 @@ async function handleSuspension({ suspension, world, run: run3, span, requestId,
           await disposeHook(queueItem);
         }
       }
-    }));
+    }, "processHookGroup");
+    const groups = [...hookItemsByToken.values()];
+    const holdsForcedCreation = /* @__PURE__ */ __name((items) => items.some((item) => item.force === true && !item.hasCreatedEvent), "holdsForcedCreation");
+    for (const items of groups.filter(holdsForcedCreation)) {
+      await settlePhase([processHookGroup(items)]);
+    }
+    await settlePhase(groups.filter((items) => !holdsForcedCreation(items)).map(processHookGroup));
     hookCreationMs = Date.now() - hookPhaseStart;
   }
   const hooksNeedingAbort = allHookItems.filter((item) => item.abortRequested && !item.disposed);
@@ -144693,13 +145698,14 @@ async function handleSuspension({ suspension, world, run: run3, span, requestId,
   const now2 = Date.now();
   let soonestWait;
   for (const queueItem of waitItems) {
-    const resumeAtMs = queueItem.resumeAt.getTime();
-    const delayMs = Math.max(1e3, resumeAtMs - now2);
+    const resumeAtMs2 = queueItem.resumeAt.getTime();
+    const delayMs = Math.max(1e3, resumeAtMs2 - now2);
     const timeoutSeconds = Math.ceil(delayMs / 1e3);
     if (!soonestWait || timeoutSeconds < soonestWait.seconds) {
       soonestWait = {
         seconds: timeoutSeconds,
-        correlationId: queueItem.correlationId
+        correlationId: queueItem.correlationId,
+        resumeAtMs: resumeAtMs2
       };
     }
   }
@@ -145694,6 +146700,17 @@ function createCreateHook(ctx) {
     if (options.experimental_minRetention !== void 0 && ctx.worldCapabilities?.hookRetention?.active !== true) {
       throw new FatalError2("The configured World does not support `experimental_minRetention` for Hooks.");
     }
+    if (options.experimental_force === true) {
+      if (options.token === void 0 || options.token === null) {
+        throw new Error("`createHook()` was called with `experimental_force: true` but no `token`. Force-claiming only applies to an explicit token another run may hold.");
+      }
+      if (options.isWebhook === true) {
+        throw new Error("Webhook hooks do not support `experimental_force`. Use a non-webhook `createHook()` with an explicit token.");
+      }
+      if (ctx.worldCapabilities?.hookForceClaim !== true) {
+        throw new FatalError2("The configured World does not support `experimental_force` for Hooks.");
+      }
+    }
     const correlationId = `hook_${ctx.generateUlid()}`;
     const token = options.token ?? ctx.generateNanoid();
     const tokenRetentionUntil = options.experimental_minRetention === void 0 ? void 0 : parseDurationToDate2(options.experimental_minRetention);
@@ -145703,6 +146720,7 @@ function createCreateHook(ctx) {
       correlationId,
       token,
       tokenRetentionUntil,
+      ...options.experimental_force === true && { force: true },
       metadata: options.metadata,
       isWebhook
     });
@@ -145714,6 +146732,7 @@ function createCreateHook(ctx) {
     let hasDisposedEvent = false;
     let hasConflict = false;
     let conflictErrorRef = null;
+    let forceClaimedErrorRef = null;
     let conflictRunRef = null;
     let registrationDelivered = Promise.resolve();
     function deliverRegistration(deliveredAt, settle) {
@@ -145774,10 +146793,11 @@ function createCreateHook(ctx) {
       if (event.eventType === "hook_conflict") {
         ctx.invocationsQueue.delete(correlationId);
         const conflictEvent = event;
-        const conflictError = new HookConflictError2(conflictEvent.eventData.token, conflictEvent.eventData.conflictingRunId);
+        const forced = options.experimental_force === true && conflictEvent.eventData.forceRefusedReason === void 0;
+        const conflictError = forced ? new FatalError2(`createHook({ experimental_force: true }) for token "${conflictEvent.eventData.token}" was answered with a hook_conflict: the configured World does not support force-claiming hook tokens${conflictEvent.eventData.conflictingRunId ? ` (run "${conflictEvent.eventData.conflictingRunId}" holds it)` : ""}.`) : new HookConflictError2(conflictEvent.eventData.token, conflictEvent.eventData.conflictingRunId);
         hasConflict = true;
         conflictErrorRef = conflictError;
-        conflictRunRef = createConflictingRun(ctx, conflictEvent.eventData.conflictingRunId);
+        conflictRunRef = forced ? null : createConflictingRun(ctx, conflictEvent.eventData.conflictingRunId);
         const pendingPromises = promises.slice();
         promises.length = 0;
         const pendingGetConflictPromises = getConflictPromises.slice();
@@ -145869,6 +146889,28 @@ function createCreateHook(ctx) {
       if (event.eventType === "hook_disposed") {
         ctx.invocationsQueue.delete(correlationId);
         hasDisposedEvent = true;
+        const claimedBy = event.eventData?.forceClaimedBy;
+        if (claimedBy) {
+          const error121 = new HookForceClaimedError2(token, claimedBy.runId, claimedBy.hookId);
+          forceClaimedErrorRef = error121;
+          const pendingPromises = promises.slice();
+          promises.length = 0;
+          const pendingGetConflictPromises = getConflictPromises.slice();
+          getConflictPromises.length = 0;
+          ctx.promiseQueue = ctx.promiseQueue.then(() => {
+            for (const resolver2 of pendingPromises) {
+              resolver2.reject(error121);
+            }
+            for (const resolver2 of pendingGetConflictPromises) {
+              resolver2.resolve(null);
+            }
+          });
+          webhookLogger2.debug("Hook force-claimed by another run", {
+            correlationId,
+            token,
+            claimedByRunId: claimedBy.runId
+          });
+        }
         return EventConsumerResult2.Finished;
       }
       ctx.promiseQueue = ctx.promiseQueue.then(() => {
@@ -145891,6 +146933,13 @@ function createCreateHook(ctx) {
           return nextDelivery.claim();
         }
       }
+      if (forceClaimedErrorRef) {
+        const error121 = forceClaimedErrorRef;
+        ctx.promiseQueue = ctx.promiseQueue.then(() => {
+          resolvers.reject(error121);
+        });
+        return resolvers.promise;
+      }
       if (eventLogEmpty) {
         scheduleWorkflowSuspension(ctx);
       }
@@ -146917,28 +147966,6 @@ function countMissingIds(ids, present) {
   return missing;
 }
 __name(countMissingIds, "countMissingIds");
-function openHookAndWaitState(events) {
-  const hooks = /* @__PURE__ */ new Set();
-  const waits = /* @__PURE__ */ new Set();
-  for (const event of events) {
-    switch (event.eventType) {
-      case "hook_created":
-        hooks.add(event.correlationId);
-        break;
-      case "hook_disposed":
-        hooks.delete(event.correlationId);
-        break;
-      case "wait_created":
-        waits.add(event.correlationId);
-        break;
-      case "wait_completed":
-        waits.delete(event.correlationId);
-        break;
-    }
-  }
-  return { openHook: hooks.size > 0, openWait: waits.size > 0 };
-}
-__name(openHookAndWaitState, "openHookAndWaitState");
 function getRetentionDecision({ suspension, serializationBlockerCount, hookContinuation = false, invocationContinuation = false }) {
   if (!isVmRetentionEnabled()) {
     return { retain: false, reason: "disabled" };
@@ -147104,6 +148131,8 @@ function workflowEntrypoint(workflowCode2, options) {
           });
           const invocationStartTime = Date.now();
           const noInlineReplayAfterMs = await getMaxInlineDurationMs(world, invocationStartTime);
+          const openWaitDueDeadlineMs = invocationStartTime + noInlineReplayAfterMs + getOpenWaitClockSkewMs();
+          let eventLogFromInlineDelta = false;
           let loopIteration = 0;
           const replayRecoveryReporter = replayDivergence ? new ReplayRecoveryReporter(replayDivergence.count) : ReplayRecoveryReporter.inert();
           let compiledWorkflowScripts;
@@ -147982,6 +149011,7 @@ function workflowEntrypoint(workflowCode2, options) {
                 return;
               }
               if (eventLog.type !== "ready") {
+                eventLogFromInlineDelta = false;
                 const page = await loadWorkflowRunEvents(runId, eventLog.type === "loadAfter" ? eventLog.cursor : void 0);
                 if (eventLog.type === "loadAfter") {
                   appendEventLog(eventLog, page);
@@ -148029,6 +149059,7 @@ function workflowEntrypoint(workflowCode2, options) {
               const completedWaitIdsAfterWrites = new Set(eventLog.events.filter((e) => e.eventType === "wait_completed").map((e) => e.correlationId));
               const missingWaitCompletions = waitsToComplete.filter((waitEvent) => !completedWaitIdsAfterWrites.has(waitEvent.correlationId));
               if (missingWaitCompletions.length > 0) {
+                eventLogFromInlineDelta = false;
                 if (eventLog.cursor) {
                   const page = await loadWorkflowRunEvents(runId, eventLog.cursor);
                   const completedWaitIdsAfterCursor = new Set(page.events.filter((e) => e.eventType === "wait_completed").map((e) => e.correlationId));
@@ -148329,6 +149360,18 @@ function workflowEntrypoint(workflowCode2, options) {
                   continue;
                 }
                 const pendingSteps = suspensionResult.pendingSteps;
+                if (eventLogFromInlineDelta && suspensionResult.waitTimeout !== void 0 && pendingSteps.length === 0 && !suspensionResult.hasAwaitedHookCreation && openHookWait.value.openWait) {
+                  runtimeLogger2.debug("Re-reading the event log before parking on a wait over an inline delta", {
+                    workflowRunId: runId,
+                    loopIteration,
+                    waitCorrelationId: suspensionResult.waitTimeout.correlationId
+                  });
+                  span?.setAttributes({
+                    "workflow.wait_park_reread": true
+                  });
+                  eventLog = nextEventLogLoad(eventLog);
+                  continue;
+                }
                 const lazyInlineSteps = suspensionResult.lazyInlineSteps;
                 const inlineCorrelationIds = new Set(lazyInlineSteps.map((s) => s.correlationId));
                 const traceCarrier = await nextTraceCarrier();
@@ -148476,7 +149519,13 @@ function workflowEntrypoint(workflowCode2, options) {
                   return;
                 }
                 const openHookWaitState = openHookWait.value;
-                const requestInlineDelta = typeof eventLog.cursor === "string" && err.stepCount === 1 && err.waitCount === 0 && pendingSteps.length === 1 && lazyInlineSteps.length === 1 && ownedRecoverySteps.length === 0 && !suspensionResult.waitTimeout && !openHookWaitState.openWait;
+                const waitDueThisInvocation = hasOpenWaitDueBy(openHookWaitState, openWaitDueDeadlineMs) || suspensionResult.waitTimeout !== void 0 && !(suspensionResult.waitTimeout.resumeAtMs > openWaitDueDeadlineMs);
+                const requestInlineDelta = typeof eventLog.cursor === "string" && err.stepCount === 1 && pendingSteps.length === 1 && lazyInlineSteps.length === 1 && ownedRecoverySteps.length === 0 && !waitDueThisInvocation;
+                if (requestInlineDelta && (openHookWaitState.openWait || suspensionResult.waitTimeout !== void 0)) {
+                  span?.setAttributes({
+                    "workflow.inline_delta_over_pending_wait": true
+                  });
+                }
                 const suppressOptimisticStart = openHookWaitState.openHook || err.hookCount > 0 || suspensionResult.hasHookEvents;
                 const forceOptimisticStart = turbo && !suspensionResult.hasAttributeEvents && !suspensionResult.waitTimeout && !suspensionResult.hasHookEvents && !suspensionResult.hasAwaitedHookCreation && !openHookWaitState.openHook && !openHookWaitState.openWait;
                 const latencyTracking = computeStepLatencyTracking({
@@ -148687,6 +149736,7 @@ function workflowEntrypoint(workflowCode2, options) {
                   const only = stepResults[0];
                   if (only.type === "completed" && only.inlineDelta) {
                     appendEventLog(eventLog, only.inlineDelta);
+                    eventLogFromInlineDelta = !only.inlineDelta.hasMore;
                     eventLog = only.inlineDelta.hasMore ? nextEventLogLoad(eventLog) : { ...eventLog, type: "ready" };
                     continue;
                   }
@@ -149436,6 +150486,7 @@ var ERROR_SLUGS = {
   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",
@@ -149549,6 +150600,30 @@ var HookConflictError = class extends WorkflowError {
     return isError(value) && value.name === "HookConflictError";
   }
 };
+var 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";
+  }
+};
 var StreamError = class extends WorkflowWorldError {
   static {
     __name(this, "StreamError");
@@ -149605,6 +150680,7 @@ var RetryableError = class extends Error {
 var FATAL_ERROR_KEY = /* @__PURE__ */ Symbol.for("@workflow/errors//FatalError");
 var RETRYABLE_ERROR_KEY = /* @__PURE__ */ Symbol.for("@workflow/errors//RetryableError");
 var HOOK_CONFLICT_ERROR_KEY = /* @__PURE__ */ Symbol.for("@workflow/errors//HookConflictError");
+var HOOK_FORCE_CLAIMED_ERROR_KEY = /* @__PURE__ */ Symbol.for("@workflow/errors//HookForceClaimedError");
 var RUNTIME_DECRYPTION_ERROR_KEY = /* @__PURE__ */ Symbol.for("@workflow/errors//RuntimeDecryptionError");
 var STREAM_ERROR_KEY = /* @__PURE__ */ Symbol.for("@workflow/errors//StreamError");
 if (typeof globalThis !== "undefined") {
@@ -149632,6 +150708,14 @@ if (typeof globalThis !== "undefined") {
       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,
@@ -149736,11 +150820,11 @@ var Run = class _Run {
     return this.getWritable();
   }
 };
-Run.prototype["wakeUp"] = globalThis[/* @__PURE__ */ Symbol.for("WORKFLOW_USE_STEP")]("step//@workflow/core/runtime/run@5.0.0-beta.54//Run#wakeUp");
-Run.prototype["cancel"] = globalThis[/* @__PURE__ */ Symbol.for("WORKFLOW_USE_STEP")]("step//@workflow/core/runtime/run@5.0.0-beta.54//Run#cancel");
-Run.prototype["getReadable"] = globalThis[/* @__PURE__ */ Symbol.for("WORKFLOW_USE_STEP")]("step//@workflow/core/runtime/run@5.0.0-beta.54//Run#getReadable");
-Run.prototype["getWritable"] = globalThis[/* @__PURE__ */ Symbol.for("WORKFLOW_USE_STEP")]("step//@workflow/core/runtime/run@5.0.0-beta.54//Run#getWritable");
-var __step_Run$exists = globalThis[/* @__PURE__ */ Symbol.for("WORKFLOW_USE_STEP")]("step//@workflow/core/runtime/run@5.0.0-beta.54//Run#exists");
+Run.prototype["wakeUp"] = globalThis[/* @__PURE__ */ Symbol.for("WORKFLOW_USE_STEP")]("step//@workflow/core/runtime/run@5.0.0-beta.56//Run#wakeUp");
+Run.prototype["cancel"] = globalThis[/* @__PURE__ */ Symbol.for("WORKFLOW_USE_STEP")]("step//@workflow/core/runtime/run@5.0.0-beta.56//Run#cancel");
+Run.prototype["getReadable"] = globalThis[/* @__PURE__ */ Symbol.for("WORKFLOW_USE_STEP")]("step//@workflow/core/runtime/run@5.0.0-beta.56//Run#getReadable");
+Run.prototype["getWritable"] = globalThis[/* @__PURE__ */ Symbol.for("WORKFLOW_USE_STEP")]("step//@workflow/core/runtime/run@5.0.0-beta.56//Run#getWritable");
+var __step_Run$exists = globalThis[/* @__PURE__ */ Symbol.for("WORKFLOW_USE_STEP")]("step//@workflow/core/runtime/run@5.0.0-beta.56//Run#exists");
 Object.defineProperty(Run.prototype, "exists", {
   get() {
     return __step_Run$exists.call(this);
@@ -149748,7 +150832,7 @@ Object.defineProperty(Run.prototype, "exists", {
   configurable: true,
   enumerable: false
 });
-var __step_Run$status = globalThis[/* @__PURE__ */ Symbol.for("WORKFLOW_USE_STEP")]("step//@workflow/core/runtime/run@5.0.0-beta.54//Run#status");
+var __step_Run$status = globalThis[/* @__PURE__ */ Symbol.for("WORKFLOW_USE_STEP")]("step//@workflow/core/runtime/run@5.0.0-beta.56//Run#status");
 Object.defineProperty(Run.prototype, "status", {
   get() {
     return __step_Run$status.call(this);
@@ -149756,7 +150840,7 @@ Object.defineProperty(Run.prototype, "status", {
   configurable: true,
   enumerable: false
 });
-var __step_Run$returnValue = globalThis[/* @__PURE__ */ Symbol.for("WORKFLOW_USE_STEP")]("step//@workflow/core/runtime/run@5.0.0-beta.54//Run#returnValue");
+var __step_Run$returnValue = globalThis[/* @__PURE__ */ Symbol.for("WORKFLOW_USE_STEP")]("step//@workflow/core/runtime/run@5.0.0-beta.56//Run#returnValue");
 Object.defineProperty(Run.prototype, "returnValue", {
   get() {
     return __step_Run$returnValue.call(this);
@@ -149764,7 +150848,7 @@ Object.defineProperty(Run.prototype, "returnValue", {
   configurable: true,
   enumerable: false
 });
-var __step_Run$workflowName = globalThis[/* @__PURE__ */ Symbol.for("WORKFLOW_USE_STEP")]("step//@workflow/core/runtime/run@5.0.0-beta.54//Run#workflowName");
+var __step_Run$workflowName = globalThis[/* @__PURE__ */ Symbol.for("WORKFLOW_USE_STEP")]("step//@workflow/core/runtime/run@5.0.0-beta.56//Run#workflowName");
 Object.defineProperty(Run.prototype, "workflowName", {
   get() {
     return __step_Run$workflowName.call(this);
@@ -149772,7 +150856,7 @@ Object.defineProperty(Run.prototype, "workflowName", {
   configurable: true,
   enumerable: false
 });
-var __step_Run$createdAt = globalThis[/* @__PURE__ */ Symbol.for("WORKFLOW_USE_STEP")]("step//@workflow/core/runtime/run@5.0.0-beta.54//Run#createdAt");
+var __step_Run$createdAt = globalThis[/* @__PURE__ */ Symbol.for("WORKFLOW_USE_STEP")]("step//@workflow/core/runtime/run@5.0.0-beta.56//Run#createdAt");
 Object.defineProperty(Run.prototype, "createdAt", {
   get() {
     return __step_Run$createdAt.call(this);
@@ -149780,7 +150864,7 @@ Object.defineProperty(Run.prototype, "createdAt", {
   configurable: true,
   enumerable: false
 });
-var __step_Run$startedAt = globalThis[/* @__PURE__ */ Symbol.for("WORKFLOW_USE_STEP")]("step//@workflow/core/runtime/run@5.0.0-beta.54//Run#startedAt");
+var __step_Run$startedAt = globalThis[/* @__PURE__ */ Symbol.for("WORKFLOW_USE_STEP")]("step//@workflow/core/runtime/run@5.0.0-beta.56//Run#startedAt");
 Object.defineProperty(Run.prototype, "startedAt", {
   get() {
     return __step_Run$startedAt.call(this);
@@ -149788,7 +150872,7 @@ Object.defineProperty(Run.prototype, "startedAt", {
   configurable: true,
   enumerable: false
 });
-var __step_Run$completedAt = globalThis[/* @__PURE__ */ Symbol.for("WORKFLOW_USE_STEP")]("step//@workflow/core/runtime/run@5.0.0-beta.54//Run#completedAt");
+var __step_Run$completedAt = globalThis[/* @__PURE__ */ Symbol.for("WORKFLOW_USE_STEP")]("step//@workflow/core/runtime/run@5.0.0-beta.56//Run#completedAt");
 Object.defineProperty(Run.prototype, "completedAt", {
   get() {
     return __step_Run$completedAt.call(this);
@@ -149805,7 +150889,7 @@ Object.defineProperty(Run.prototype, "completedAt", {
     enumerable: false,
     configurable: false
   });
-})(Run, "class//@workflow/core/runtime/run@5.0.0-beta.54//Run");
+})(Run, "class//@workflow/core/runtime/run@5.0.0-beta.56//Run");
 
 // ../core/dist/workflow/create-hook.js
 aliasSerializationClass(RUN_CLASS_ID, Run);
@@ -157401,7 +158485,7 @@ globalThis.__private_workflows.set("workflow//./workflows/inline-execution//hook
 var latestNoOpWarning = globalSingleton("@workflow/core//latestNoOpWarning", 1, () => ({
   warned: false
 }));
-var start = globalThis[/* @__PURE__ */ Symbol.for("WORKFLOW_USE_STEP")]("step//@workflow/core/runtime/start@5.0.0-beta.54//start");
+var start = globalThis[/* @__PURE__ */ Symbol.for("WORKFLOW_USE_STEP")]("step//@workflow/core/runtime/start@5.0.0-beta.56//start");
 
 // workflows/lineage.ts
 var noop = globalThis[/* @__PURE__ */ Symbol.for("WORKFLOW_USE_STEP")]("step//./workflows/lineage//noop");