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

package/dist/runtime/resume-hook.js

@@ -1,35 +1,138 @@
-import { waitUntil } from '@vercel/functions';
-import { ERROR_SLUGS, HookNotFoundError, WorkflowRuntimeError, } from '@workflow/errors';
-import { isLegacySpecVersion, SPEC_VERSION_CURRENT, SPEC_VERSION_LEGACY, } from '@workflow/world';
+import { EntityConflictError, ERROR_SLUGS, HookNotFoundError, RunExpiredError, WorkflowRuntimeError, } from '@workflow/errors';
+import { HOOK_RESUME_DEDUP_VERSION, HOOK_RESUME_INPUT_VERSION, isLegacySpecVersion, isTerminalWorkflowRunStatus, SPEC_VERSION_CURRENT, SPEC_VERSION_LEGACY, SPEC_VERSION_SUPPORTS_CBOR_QUEUE_TRANSPORT, SPEC_VERSION_SUPPORTS_COMPRESSION, } from '@workflow/world';
+import { monotonicFactory } from 'ulid';
 import { getRunCapabilities } from '../capabilities.js';
+import { isRetryableWorldError } from '../classify-error.js';
 import { importKey } from '../encryption.js';
-import { dehydrateStepReturnValue, hydrateStepArguments, SerializationFormat, } from '../serialization.js';
+import { runtimeLogger } from '../logger.js';
+import { decodeRunPublicKey } from '../sealed-box.js';
+import { deriveRunPayloadKeys } from '../serialization/encryption.js';
+import { dehydrateStepReturnValue, hydrateStepArguments, SerializationFormat, sealTo, } from '../serialization.js';
 import { WEBHOOK_RESPONSE_WRITABLE } from '../symbols.js';
 import * as Attribute from '../telemetry/semantic-conventions.js';
-import { getSpanContextForTraceCarrier, trace } from '../telemetry.js';
-import { waitedUntil } from '../util.js';
+import { linkToTraceCarrier, trace } from '../telemetry.js';
+import { getWorldLazy } from './get-world-lazy.js';
 import { getWorkflowQueueName } from './helpers.js';
-import { getWorld } from './world.js';
+import { safeWaitUntil, waitedUntil } from './wait-until.js';
+/** Monotonic ULID factory for per-call resume idempotency keys. */
+const generateResumeId = monotonicFactory();
 /**
- * Internal helper that returns the hook, the associated workflow run,
- * and the resolved encryption key.
+ * Upper bound on the serialized hook payload that the parallel fast path will
+ * inline into the queue message's `hookInput`. Vercel Queues caps a single
+ * message at ~256 KiB, and the message also carries the runId, hookId, token,
+ * resumeId, digest, and trace carrier alongside CBOR framing overhead. Staying
+ * well under that ceiling keeps the queue publish from rejecting an oversized
+ * message — which, on the parallel path, would persist `hook_received` but never
+ * re-trigger the run. Above this size we fall back to the sequential path, whose
+ * queue message carries only the run ID (the payload lives in the event log).
  */
+const MAX_INLINE_RESUME_PAYLOAD_BYTES = 128 * 1024;
+/**
+ * Hex SHA-256 of the serialized resume payload bytes. Computed once by the
+ * producer and forwarded verbatim on both the direct `hook_received` write and
+ * the queue `hookInput`, so both writers of the same `resumeId` record an
+ * identical digest on the server's `(runId, resumeId)` constraint. Hashing the
+ * already-serialized bytes (not the raw value) keeps producer and consumer in
+ * lockstep — the consumer forwards this string without recomputing.
+ */
+async function computeResumePayloadDigest(bytes) {
+    const digest = await crypto.subtle.digest('SHA-256', bytes);
+    const view = new Uint8Array(digest);
+    let hex = '';
+    for (const b of view) {
+        hex += b.toString(16).padStart(2, '0');
+    }
+    return hex;
+}
+/** Derive a resume context from a full run (fallback for pre-`resumeContext` hooks). */
+function resumeContextFromRun(run) {
+    const coreVersion = run.executionContext?.workflowCoreVersion;
+    const traceCarrier = run.executionContext?.traceCarrier;
+    const hookResumeInputVersion = run.executionContext?.hookResumeInputVersion;
+    return {
+        deploymentId: run.deploymentId,
+        workflowName: run.workflowName,
+        runSpecVersion: run.specVersion,
+        workflowCoreVersion: typeof coreVersion === 'string' ? coreVersion : undefined,
+        traceCarrier: traceCarrier && typeof traceCarrier === 'object'
+            ? traceCarrier
+            : undefined,
+        encryptionPublicKey: run.encryptionPublicKey,
+        hookResumeInputVersion: typeof hookResumeInputVersion === 'number'
+            ? hookResumeInputVersion
+            : undefined,
+    };
+}
+/**
+ * Resolve resume context for a hook. Uses the stored `resumeContext` when
+ * present (fast path — no run read); otherwise fetches the run and synthesizes
+ * it. Does NOT resolve the encryption key — callers do that separately. Only
+ * the fallback path can gate key work behind a local terminal-run check (it
+ * has the fetched run); the fast path's stored context carries no status, so
+ * seal/serialization work may run before the receiving side rejects
+ * `hook_received` for an ended run.
+ */
+async function resolveHookResumeInfo(hook) {
+    if (hook.resumeContext) {
+        return { resumeContext: hook.resumeContext, source: 'hook' };
+    }
+    const run = await (await getWorldLazy()).runs.get(hook.runId);
+    return {
+        resumeContext: resumeContextFromRun(run),
+        source: 'run_fallback',
+        run,
+    };
+}
+/**
+ * Resolve the run's symmetric key for a payload WRITE, as a bare `CryptoKey`
+ * (`importKey`) — the `encr` write fallback used when the run published no
+ * public key to seal to. Writing needs only the AES key, not the read-side
+ * keypair. On the fast path this needs only `runId` + `deploymentId` (no run
+ * entity); on the fallback path the already fetched run is reused.
+ */
+async function resolveHookEncryptionKey(hook, info) {
+    const world = await getWorldLazy();
+    const rawKey = info.run
+        ? await world.getEncryptionKeyForRun?.(info.run)
+        : await world.getEncryptionKeyForRun?.(hook.runId, {
+            deploymentId: info.resumeContext.deploymentId,
+        });
+    return rawKey ? await importKey(rawKey) : undefined;
+}
 async function getHookByTokenWithKey(token) {
-    const world = await getWorld();
+    const world = await getWorldLazy();
     const hook = await world.hooks.getByToken(token);
-    const run = await world.runs.get(hook.runId);
-    const rawKey = await world.getEncryptionKeyForRun?.(run);
-    const encryptionKey = rawKey ? await importKey(rawKey) : undefined;
+    // Only a hook that actually carries metadata needs the run's key resolved
+    // here: hydrating that metadata is a READ, so derive the full RunPayloadKeys
+    // (which opens sealed `encp` metadata, not just symmetric `encr`). The common
+    // default webhook — createWebhook() with no `respondWith` — stores no
+    // metadata, so it skips this entirely: no ~350ms `run-key` API round trip,
+    // and, crucially, no resolved key handed to `resumeHook`, leaving it free to
+    // seal the payload to the run's published public key instead. Metadata-
+    // bearing webhooks still legitimately pay one lookup to hydrate.
+    let encryptionKey;
     if (typeof hook.metadata !== 'undefined') {
+        const info = await resolveHookResumeInfo(hook);
+        // On the fast path this resolves the key by runId + deploymentId (no run
+        // read); on the fallback path it reuses the already-fetched run.
+        const rawKey = info.run
+            ? await world.getEncryptionKeyForRun?.(info.run)
+            : await world.getEncryptionKeyForRun?.(hook.runId, {
+                deploymentId: info.resumeContext.deploymentId,
+            });
+        encryptionKey = rawKey ? await deriveRunPayloadKeys(rawKey) : undefined;
         hook.metadata = await hydrateStepArguments(hook.metadata, hook.runId, encryptionKey);
     }
-    return { hook, run, encryptionKey };
+    return { hook, encryptionKey };
 }
 /**
  * Get the hook by token to find the associated workflow run,
  * and hydrate the `metadata` property if it was set from within
  * the workflow run.
  *
+ * A Hook kept by minimum retention remains available here after its run ends,
+ * but cannot be resumed.
+ *
  * @param token - The unique token identifying the hook
  */
 export async function getHookByToken(token) {
@@ -44,8 +147,8 @@ export async function getHookByToken(token) {
  *
  * @param tokenOrHook - The unique token identifying the hook, or the hook object itself
  * @param payload - The data payload to send to the hook
- * @returns Promise resolving to the hook
- * @throws Error if the hook is not found or if there's an error during the process
+ * @returns Promise resolving to the {@link ResumedHook}
+ * @throws {HookNotFoundError} If the Hook does not exist or its run has ended
  *
  * @example
  *
@@ -66,83 +169,347 @@ export async function getHookByToken(token) {
  * ```
  */
 export async function resumeHook(tokenOrHook, payload, encryptionKeyOverride) {
+    // Public entry point. It never attests hook freshness, so a Hook object
+    // supplied here — which may carry a `resumeCapabilities` cached before a
+    // server rollback or kill switch — is ignored by the dynamic-dedup gate and
+    // fails closed to the sequential path. Only `resumeWebhook`, which fetches
+    // the hook by token in-line during the same resume, reaches the internal
+    // implementation with the fresh attestation set. Keeping the freshness flag
+    // off the exported signature prevents a caller from passing a stale Hook plus
+    // `true` and reactivating dynamic dedup against a rolled-back backend.
+    return resumeHookImpl(tokenOrHook, payload, encryptionKeyOverride, false);
+}
+/**
+ * Internal implementation of {@link resumeHook}. NOT exported: the
+ * `hookFreshlyLookedUp` attestation must never be reachable by public callers
+ * (see the wrapper above).
+ *
+ * @param hookFreshlyLookedUp - Attests that a supplied Hook object was fetched
+ *   by token during THIS resume, so its response-only `resumeCapabilities`
+ *   reflects the live backend and may be trusted for the dynamic-dedup gate.
+ *   A token string is always fetched fresh here, so it is implicitly fresh.
+ */
+async function resumeHookImpl(tokenOrHook, payload, encryptionKeyOverride, hookFreshlyLookedUp) {
     return await waitedUntil(() => {
         return trace('hook.resume', async (span) => {
-            const world = await getWorld();
+            const world = await getWorldLazy();
             try {
-                let hook;
-                let workflowRun;
-                let encryptionKey;
-                if (typeof tokenOrHook === 'string') {
-                    const result = await getHookByTokenWithKey(tokenOrHook);
-                    hook = result.hook;
-                    workflowRun = result.run;
-                    encryptionKey = encryptionKeyOverride ?? result.encryptionKey;
-                }
-                else {
-                    hook = tokenOrHook;
-                    workflowRun = await world.runs.get(hook.runId);
-                    if (encryptionKeyOverride) {
-                        encryptionKey = encryptionKeyOverride;
-                    }
-                    else {
-                        const rawKey = await world.getEncryptionKeyForRun?.(workflowRun);
-                        encryptionKey = rawKey ? await importKey(rawKey) : undefined;
-                    }
-                }
+                const suppliedToken = typeof tokenOrHook === 'string';
+                const hook = suppliedToken
+                    ? await world.hooks.getByToken(tokenOrHook)
+                    : tokenOrHook;
+                // The dynamic, response-only `resumeCapabilities` may only be trusted
+                // when it came from a by-token lookup performed during this resume.
+                const hookResumeCapabilitiesAreFresh = suppliedToken || hookFreshlyLookedUp;
+                const info = await resolveHookResumeInfo(hook);
+                const { resumeContext } = info;
                 span?.setAttributes({
                     ...Attribute.HookToken(hook.token),
                     ...Attribute.HookId(hook.hookId),
                     ...Attribute.WorkflowRunId(hook.runId),
+                    'workflow.hook.resume_context_source': info.source,
                 });
+                // The stored `resumeContext` intentionally omits the run's mutable
+                // status, so this early client-side rejection only runs on the
+                // fallback path (which fetched the run). On the fast path the terminal
+                // check happens server-side: `hook_received` against an ended run is
+                // rejected, which the catch around `world.events.create` below re-keys
+                // to HookNotFoundError — same public contract, no run pre-fetch.
+                if (info.run && isTerminalWorkflowRunStatus(info.run.status)) {
+                    throw new HookNotFoundError(hook.token);
+                }
                 // Check the target run's capabilities to ensure we encode the
                 // payload in a format the run's deployment can decode. For example,
                 // runs created before encryption support was added cannot decode
-                // the 'encr' serialization format.
-                const rawVersion = workflowRun.executionContext?.workflowCoreVersion;
-                const { supportedFormats } = getRunCapabilities(typeof rawVersion === 'string' ? rawVersion : undefined);
-                if (!supportedFormats.has(SerializationFormat.ENCRYPTED)) {
-                    encryptionKey = undefined;
+                // the 'encr' serialization format, and runs created before
+                // byte-stream framing support cannot decode framed byte streams.
+                const capabilities = getRunCapabilities(resumeContext.workflowCoreVersion);
+                // Resolve how to encrypt the payload for the target run (a WRITE).
+                //
+                // Preferred path: seal to the run's published X25519 public key, which
+                // the stored `resumeContext` carries inline. On the fast path this is
+                // the whole win — no run read AND no `getEncryptionKeyForRun`, whose
+                // ~350ms `run-key` API round trip dominates cross-deployment hook
+                // resumption latency. (On the fallback path the key is synthesized
+                // from the fetched run, which also carries it.)
+                //
+                // Sealing also drops privilege: the resumer ends up able to write a
+                // payload for the run without being able to read anything of the
+                // run's, where fetching the symmetric key grants both.
+                //
+                // Deliberately NOT gated on `capabilities.supportedFormats` the way
+                // the symmetric fallback below gates `encr`: presence of the public key
+                // is itself the gate. A run only carries one if the runtime that
+                // created it could also open a sealed payload, and runs are pinned to
+                // their creating deployment, so presence is a more reliable attestation
+                // than a version compare — and it stays correct even when package
+                // versions drift.
+                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.
+                        undefined
+                    : decodeRunPublicKey(resumeContext.encryptionPublicKey);
+                if (runPublicKey) {
+                    payloadKey = sealTo(runPublicKey);
                 }
+                else {
+                    // Symmetric `encr` write fallback: needs only the AES key
+                    // (a bare CryptoKey via `resolveHookEncryptionKey`), not the
+                    // read-side RunPayloadKeys.
+                    let encryptionKey = encryptionKeyOverride ??
+                        (await resolveHookEncryptionKey(hook, info));
+                    if (!capabilities.supportedFormats.has(SerializationFormat.ENCRYPTED)) {
+                        encryptionKey = undefined;
+                    }
+                    payloadKey = encryptionKey;
+                }
+                // Compress only when the target run and its deployment support the
+                // compression formats introduced with spec version 5.
+                const compression = (resumeContext.runSpecVersion ?? 0) >=
+                    SPEC_VERSION_SUPPORTS_COMPRESSION &&
+                    capabilities.supportedFormats.has(SerializationFormat.GZIP);
                 // Dehydrate the payload for storage
                 const ops = [];
                 const v1Compat = isLegacySpecVersion(hook.specVersion);
-                const dehydratedPayload = await dehydrateStepReturnValue(payload, hook.runId, encryptionKey, ops, globalThis, v1Compat);
-                // NOTE: Workaround instead of injecting catching undefined unhandled rejections in webhook bundle
-                waitUntil(Promise.all(ops).catch((err) => {
-                    if (err !== undefined)
-                        throw err;
-                }));
-                // Create a hook_received event with the payload
-                await world.events.create(hook.runId, {
-                    eventType: 'hook_received',
-                    specVersion: SPEC_VERSION_CURRENT,
-                    correlationId: hook.hookId,
-                    eventData: {
-                        payload: dehydratedPayload,
-                    },
-                }, { v1Compat });
+                const dehydratedPayload = await dehydrateStepReturnValue(payload, hook.runId, payloadKey, ops, globalThis, v1Compat, capabilities.framedByteStreams, compression);
+                // These payload-stream ops are flushed in the background; the
+                // promise handed to waitUntil must never reject (an unconsumed
+                // waitUntil rejection crashes the process as unhandledRejection),
+                // so unexpected failures are logged instead.
+                // NOTE: rejections with `undefined` are an expected artifact of the
+                // webhook bundle and are ignored entirely.
+                safeWaitUntil(Promise.all(ops), (err) => {
+                    if (err === undefined)
+                        return;
+                    runtimeLogger.warn('Background flush of hook payload ops failed', {
+                        workflowRunId: hook.runId,
+                        hookId: hook.hookId,
+                        error: err instanceof Error ? err.message : String(err),
+                    });
+                });
                 span?.setAttributes({
-                    ...Attribute.WorkflowName(workflowRun.workflowName),
+                    ...Attribute.WorkflowName(resumeContext.workflowName),
                 });
-                const traceCarrier = workflowRun.executionContext?.traceCarrier;
-                if (traceCarrier) {
-                    const context = await getSpanContextForTraceCarrier(traceCarrier);
-                    if (context) {
-                        span?.addLink?.({ context });
-                    }
+                // Link to the run-origin context from the stored trace carrier
+                // (skipped when absent or invalid). Resolved before dispatch so both
+                // the sequential and parallel paths attach it.
+                const originLink = await linkToTraceCarrier(resumeContext.traceCarrier);
+                if (originLink) {
+                    span?.addLink?.(originLink);
                 }
-                // Re-trigger the workflow against the deployment ID associated
-                // with the workflow run that the hook belongs to
-                await world.queue(getWorkflowQueueName(workflowRun.workflowName), {
-                    runId: hook.runId,
-                    // attach the trace carrier from the workflow run
-                    traceCarrier: workflowRun.executionContext?.traceCarrier ?? undefined,
-                }, {
-                    deploymentId: workflowRun.deploymentId,
-                    specVersion: workflowRun.specVersion ?? SPEC_VERSION_LEGACY,
+                const eventData = {
+                    ...(v1Compat ? {} : { token: hook.token }),
+                    payload: dehydratedPayload,
+                };
+                const queueName = getWorkflowQueueName(resumeContext.workflowName);
+                const queueOptions = {
+                    deploymentId: resumeContext.deploymentId,
+                    specVersion: resumeContext.runSpecVersion ?? SPEC_VERSION_LEGACY,
+                };
+                // Decide whether to parallelize the `hook_received` write and the queue
+                // publish. The fast path is only safe when EVERY precondition holds; the
+                // first that fails names the fallback reason (emitted as a span
+                // attribute for observability, and to make "why did this run sequential"
+                // answerable in production). All conditions:
+                //
+                //  - kill switch: `WORKFLOW_DISABLE_LAZY_HOOK_RESUME` forces sequential
+                //    if the fast path ever misbehaves. It is an SDK-deployment env var,
+                //    so changing it generally requires redeploying the workflow
+                //    deployment. (The backend can independently drop new resumes to the
+                //    sequential path fleet-wide by ceasing to attest dedup support on
+                //    the by-token lookup — see the backend-dedup condition below.)
+                //  - backend dedup: the live backend must enforce the
+                //    `(runId, resumeId)` constraint, or the two writers would commit two
+                //    `hook_received` events. Fail closed. Attested by EITHER a fresh,
+                //    response-only `hook.resumeCapabilities.hookResumeDedupVersion` from
+                //    the by-token lookup (world-vercel — recomputed every read, so a
+                //    server rollback or kill switch drops to sequential immediately) OR
+                //    the static `world.capabilities.hookResumeDedup` (world-local, whose
+                //    adapter and backend ship together). The response-only capability is
+                //    trusted ONLY when the hook was looked up by token during this
+                //    resume (`hookResumeCapabilitiesAreFresh`); a Hook object handed in
+                //    by a public caller may carry a capability cached before a rollback,
+                //    so it is ignored and the path falls back to sequential.
+                //  - consumer support: the target run's deployment must re-ensure the
+                //    event from `hookInput` on replay. Attested by the run's explicit
+                //    `hookResumeInputVersion` execution-context marker (mirrored onto
+                //    resumeContext), NOT a version-compare against a predicted release
+                //    cutoff. Absent → a lost producer write would be a lost resume.
+                //  - not legacy: v1Compat runs omit `token` from the producer's event
+                //    body but the consumer's re-ensure always includes it, so the two
+                //    writers would disagree on the event body. Legacy stays sequential.
+                //  - CBOR transport: the run must use CBOR queue transport so the binary
+                //    payload survives the queue message.
+                //  - raw bytes: the dehydrated payload must be a `Uint8Array` (the
+                //    content digest that keys the dedup constraint is over these bytes).
+                //  - size: a payload above the queue's message ceiling would fail the
+                //    publish — which, on the parallel path, would persist the event but
+                //    never re-trigger the run — so oversized payloads stay sequential
+                //    (their queue message carries only the run ID).
+                const parallelResumeDisabled = process.env.WORKFLOW_DISABLE_LAZY_HOOK_RESUME === '1';
+                // Backend dedup is supported when EITHER the live server attests it
+                // fresh on this by-token hook (world-vercel: response-only, recomputed
+                // every read, so rollback/kill-switch take effect immediately) OR the
+                // static world capability is set (world-local: adapter + backend ship
+                // together). Both are re-evaluated per resume, so every rollout and
+                // rollback direction degrades safely to the sequential path.
+                const backendDedupSupported = (hookResumeCapabilitiesAreFresh
+                    ? (hook.resumeCapabilities?.hookResumeDedupVersion ?? 0)
+                    : 0) >= HOOK_RESUME_DEDUP_VERSION ||
+                    world.capabilities?.hookResumeDedup === true;
+                const fallbackReason = parallelResumeDisabled
+                    ? 'disabled'
+                    : !backendDedupSupported
+                        ? 'backend_unsupported'
+                        : (resumeContext.hookResumeInputVersion ?? 0) <
+                            HOOK_RESUME_INPUT_VERSION
+                            ? 'consumer_unsupported'
+                            : v1Compat
+                                ? 'legacy'
+                                : (resumeContext.runSpecVersion ?? 0) <
+                                    SPEC_VERSION_SUPPORTS_CBOR_QUEUE_TRANSPORT
+                                    ? 'non_cbor_transport'
+                                    : !(dehydratedPayload instanceof Uint8Array)
+                                        ? 'non_bytes'
+                                        : dehydratedPayload.byteLength >
+                                            MAX_INLINE_RESUME_PAYLOAD_BYTES
+                                            ? 'oversized'
+                                            : null;
+                const useParallelResume = fallbackReason === null;
+                span?.setAttributes({
+                    'workflow.hook.resume_strategy': useParallelResume
+                        ? 'parallel'
+                        : 'sequential',
+                    ...(fallbackReason
+                        ? { 'workflow.hook.resume_fallback_reason': fallbackReason }
+                        : {}),
                 });
-                return hook;
+                // Re-key any "hook can no longer be received" rejection to
+                // HookNotFoundError(hook.token) so `.token` matches the pre-fast-path
+                // contract, where resumeHook threw `HookNotFoundError(hook.token)`
+                // after its own terminal check. The specific error depends on the
+                // World:
+                //   - a genuinely missing hook maps to HookNotFoundError (keyed on the
+                //     event correlationId / hook ID);
+                //   - a terminal run on Vercel rejects hook_received with 404, which
+                //     world-vercel maps to HookNotFoundError;
+                //   - a terminal run on world-local / world-postgres rejects with
+                //     RunExpiredError.
+                //
+                // On the SEQUENTIAL path an EntityConflictError (HTTP 409) is also
+                // treated as "hook gone" for historical / conflict-shaped-rejection
+                // compatibility: there is no queue message in flight, so a conflict has
+                // no re-ensuring consumer to converge on. The PARALLEL path handles 409
+                // differently (see below) — it published the queue message before the
+                // conflict, so the consumer will converge the event.
+                const isHookGoneError = (err) => HookNotFoundError.is(err) ||
+                    EntityConflictError.is(err) ||
+                    RunExpiredError.is(err);
+                if (!useParallelResume) {
+                    // Sequential path: create a hook_received event, then re-trigger.
+                    try {
+                        await world.events.create(hook.runId, {
+                            eventType: 'hook_received',
+                            specVersion: SPEC_VERSION_CURRENT,
+                            correlationId: hook.hookId,
+                            eventData,
+                        }, { v1Compat });
+                    }
+                    catch (err) {
+                        if (isHookGoneError(err)) {
+                            throw new HookNotFoundError(hook.token);
+                        }
+                        throw err;
+                    }
+                    await world.queue(queueName, {
+                        runId: hook.runId,
+                        traceCarrier: resumeContext.traceCarrier ?? undefined,
+                    }, queueOptions);
+                    return hook;
+                }
+                // Parallel fast path. A stable idempotency key ties the direct write to
+                // the queue consumer's re-ensure; the payload digest lets the server
+                // detect key reuse across byte-identical payloads.
+                const resumeId = generateResumeId();
+                const payloadDigest = await computeResumePayloadDigest(dehydratedPayload);
+                span?.setAttributes({ 'workflow.hook.resume_id': resumeId });
+                const [eventResult, queueResult] = await Promise.allSettled([
+                    world.events.create(hook.runId, {
+                        eventType: 'hook_received',
+                        specVersion: SPEC_VERSION_CURRENT,
+                        correlationId: hook.hookId,
+                        eventData,
+                    }, { v1Compat, resumeId, resumePayloadDigest: payloadDigest }),
+                    world.queue(queueName, {
+                        runId: hook.runId,
+                        traceCarrier: resumeContext.traceCarrier ?? undefined,
+                        hookInput: {
+                            resumeId,
+                            hookId: hook.hookId,
+                            token: hook.token,
+                            payload: dehydratedPayload,
+                            payloadDigest,
+                        },
+                    }, queueOptions),
+                ]);
+                // Queue failure is always fatal — the run was not re-triggered, so no
+                // consumer will re-ensure the event.
+                if (queueResult.status === 'rejected') {
+                    throw queueResult.reason;
+                }
+                // Set when the direct write did not land but the queue dispatch did, so
+                // the consumer materializes the event before replay. Surfaced to the
+                // caller as `ResumedHook.resilientResume` and on the span.
+                let resilientResume = false;
+                if (eventResult.status === 'rejected') {
+                    const err = eventResult.reason;
+                    if (HookNotFoundError.is(err) || RunExpiredError.is(err)) {
+                        // The hook's run has genuinely ended: surface the same contract as
+                        // the sequential path. The queue message already went out, but the
+                        // consumer's re-ensure will also reject against the terminal run
+                        // and no-op, so the workflow does not resume.
+                        throw new HookNotFoundError(hook.token);
+                    }
+                    if (EntityConflictError.is(err) || isRetryableWorldError(err)) {
+                        // Resilient. Two shapes reach here, both non-terminal:
+                        //   - EntityConflict (409): this write raced its own re-ensuring
+                        //     consumer (or a redrive) on the shared `resumeId` — the run is
+                        //     NOT gone, and the consumer converges on the one committed
+                        //     event. Unlike the sequential path, a 409 here is expected
+                        //     concurrency, not a vanished hook.
+                        //   - 429 / 5xx / transport: a transient backend failure.
+                        // In both cases the run WAS re-triggered via the queue and the
+                        // consumer idempotently ensures the hook_received before replay, so
+                        // swallow rather than failing the caller.
+                        //
+                        // Producer telemetry: record that the direct write did not land but
+                        // the resume is still guaranteed via queue-delivered `hookInput`.
+                        // This is the operational signal that the recovery path fired,
+                        // surfaced both on the span and as the public `resilientResume`
+                        // flag on the returned hook (the resume outcome is otherwise
+                        // identical to the happy path from the caller's perspective).
+                        resilientResume = true;
+                        span?.setAttributes({
+                            ...Attribute.HookResilientResume(true),
+                            'workflow.hook.resume_event_write_recovered': true,
+                            'workflow.hook.resume_event_write_error': err instanceof Error ? err.name : 'unknown',
+                        });
+                        runtimeLogger.warn('Hook resume event write failed, but the run was re-triggered via ' +
+                            'the queue. The hook_received event will be ensured by the ' +
+                            'queue consumer.', {
+                            workflowRunId: hook.runId,
+                            hookId: hook.hookId,
+                            resumeId,
+                            error: err instanceof Error ? err.message : String(err),
+                        });
+                    }
+                    else {
+                        throw err;
+                    }
+                }
+                return (resilientResume ? { ...hook, resilientResume: true } : hook);
             }
             catch (err) {
                 span?.setAttributes({
@@ -221,7 +588,12 @@ export async function resumeWebhook(token, request) {
         // No `respondWith` value implies the default behavior of returning a 202
         response = new Response(null, { status: 202 });
     }
-    await resumeHook(hook, request, encryptionKey);
+    // `hook` was just fetched via `getHookByTokenWithKey` (a fresh by-token
+    // lookup) above, so its response-only `resumeCapabilities` reflects the live
+    // backend — call the internal implementation with the fresh attestation so
+    // the parallel fast path stays available without a second GET. (The public
+    // `resumeHook` never sets this, so a caller cannot forge it.)
+    await resumeHookImpl(hook, request, encryptionKey, true);
     if (responseReadable) {
         // Wait for the readable stream to emit one chunk,
         // which is the `Response` object
@@ -239,4 +611,4 @@ export async function resumeWebhook(token, request) {
     }
     return response;
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"resume-hook.js","sourceRoot":"","sources":["../../src/runtime/resume-hook.ts"],"names":[],"mappings":"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","sourcesContent":["import { waitUntil } from '@vercel/functions';\nimport {\n  ERROR_SLUGS,\n  HookNotFoundError,\n  WorkflowRuntimeError,\n} from '@workflow/errors';\nimport {\n  type Hook,\n  isLegacySpecVersion,\n  SPEC_VERSION_CURRENT,\n  SPEC_VERSION_LEGACY,\n  type WorkflowInvokePayload,\n  type WorkflowRun,\n} from '@workflow/world';\nimport { getRunCapabilities } from '../capabilities.js';\nimport { type CryptoKey, importKey } from '../encryption.js';\nimport {\n  dehydrateStepReturnValue,\n  hydrateStepArguments,\n  SerializationFormat,\n} from '../serialization.js';\nimport { WEBHOOK_RESPONSE_WRITABLE } from '../symbols.js';\nimport * as Attribute from '../telemetry/semantic-conventions.js';\nimport { getSpanContextForTraceCarrier, trace } from '../telemetry.js';\nimport { waitedUntil } from '../util.js';\nimport { getWorkflowQueueName } from './helpers.js';\nimport { getWorld } from './world.js';\n\n/**\n * Internal helper that returns the hook, the associated workflow run,\n * and the resolved encryption key.\n */\nasync function getHookByTokenWithKey(token: string): Promise<{\n  hook: Hook;\n  run: WorkflowRun;\n  encryptionKey: CryptoKey | undefined;\n}> {\n  const world = await getWorld();\n  const hook = await world.hooks.getByToken(token);\n  const run = await world.runs.get(hook.runId);\n  const rawKey = await world.getEncryptionKeyForRun?.(run);\n  const encryptionKey = rawKey ? await importKey(rawKey) : undefined;\n  if (typeof hook.metadata !== 'undefined') {\n    hook.metadata = await hydrateStepArguments(\n      hook.metadata as any,\n      hook.runId,\n      encryptionKey\n    );\n  }\n  return { hook, run, encryptionKey };\n}\n\n/**\n * Get the hook by token to find the associated workflow run,\n * and hydrate the `metadata` property if it was set from within\n * the workflow run.\n *\n * @param token - The unique token identifying the hook\n */\nexport async function getHookByToken(token: string): Promise<Hook> {\n  const { hook } = await getHookByTokenWithKey(token);\n  return hook;\n}\n\n/**\n * Resumes a workflow run by sending a payload to a hook identified by its token.\n *\n * This function is called externally (e.g., from an API route or server action)\n * to send data to a hook and resume the associated workflow run.\n *\n * @param tokenOrHook - The unique token identifying the hook, or the hook object itself\n * @param payload - The data payload to send to the hook\n * @returns Promise resolving to the hook\n * @throws Error if the hook is not found or if there's an error during the process\n *\n * @example\n *\n * ```ts\n * // In an API route\n * import { resumeHook } from '@workflow/core/runtime';\n *\n * export async function POST(request: Request) {\n *   const { token, data } = await request.json();\n *\n *   try {\n *     const hook = await resumeHook(token, data);\n *     return Response.json({ runId: hook.runId });\n *   } catch (error) {\n *     return new Response('Hook not found', { status: 404 });\n *   }\n * }\n * ```\n */\nexport async function resumeHook<T = any>(\n  tokenOrHook: string | Hook,\n  payload: T,\n  encryptionKeyOverride?: CryptoKey\n): Promise<Hook> {\n  return await waitedUntil(() => {\n    return trace('hook.resume', async (span) => {\n      const world = await getWorld();\n\n      try {\n        let hook: Hook;\n        let workflowRun: WorkflowRun;\n        let encryptionKey: CryptoKey | undefined;\n        if (typeof tokenOrHook === 'string') {\n          const result = await getHookByTokenWithKey(tokenOrHook);\n          hook = result.hook;\n          workflowRun = result.run;\n          encryptionKey = encryptionKeyOverride ?? result.encryptionKey;\n        } else {\n          hook = tokenOrHook;\n          workflowRun = await world.runs.get(hook.runId);\n          if (encryptionKeyOverride) {\n            encryptionKey = encryptionKeyOverride;\n          } else {\n            const rawKey = await world.getEncryptionKeyForRun?.(workflowRun);\n            encryptionKey = rawKey ? await importKey(rawKey) : undefined;\n          }\n        }\n\n        span?.setAttributes({\n          ...Attribute.HookToken(hook.token),\n          ...Attribute.HookId(hook.hookId),\n          ...Attribute.WorkflowRunId(hook.runId),\n        });\n\n        // Check the target run's capabilities to ensure we encode the\n        // payload in a format the run's deployment can decode. For example,\n        // runs created before encryption support was added cannot decode\n        // the 'encr' serialization format.\n        const rawVersion = workflowRun.executionContext?.workflowCoreVersion;\n        const { supportedFormats } = getRunCapabilities(\n          typeof rawVersion === 'string' ? rawVersion : undefined\n        );\n        if (!supportedFormats.has(SerializationFormat.ENCRYPTED)) {\n          encryptionKey = undefined;\n        }\n\n        // Dehydrate the payload for storage\n        const ops: Promise<any>[] = [];\n        const v1Compat = isLegacySpecVersion(hook.specVersion);\n        const dehydratedPayload = await dehydrateStepReturnValue(\n          payload,\n          hook.runId,\n          encryptionKey,\n          ops,\n          globalThis,\n          v1Compat\n        );\n        // NOTE: Workaround instead of injecting catching undefined unhandled rejections in webhook bundle\n        waitUntil(\n          Promise.all(ops).catch((err) => {\n            if (err !== undefined) throw err;\n          })\n        );\n\n        // Create a hook_received event with the payload\n        await world.events.create(\n          hook.runId,\n          {\n            eventType: 'hook_received',\n            specVersion: SPEC_VERSION_CURRENT,\n            correlationId: hook.hookId,\n            eventData: {\n              payload: dehydratedPayload,\n            },\n          },\n          { v1Compat }\n        );\n\n        span?.setAttributes({\n          ...Attribute.WorkflowName(workflowRun.workflowName),\n        });\n\n        const traceCarrier = workflowRun.executionContext?.traceCarrier;\n\n        if (traceCarrier) {\n          const context = await getSpanContextForTraceCarrier(traceCarrier);\n          if (context) {\n            span?.addLink?.({ context });\n          }\n        }\n\n        // Re-trigger the workflow against the deployment ID associated\n        // with the workflow run that the hook belongs to\n        await world.queue(\n          getWorkflowQueueName(workflowRun.workflowName),\n          {\n            runId: hook.runId,\n            // attach the trace carrier from the workflow run\n            traceCarrier:\n              workflowRun.executionContext?.traceCarrier ?? undefined,\n          } satisfies WorkflowInvokePayload,\n          {\n            deploymentId: workflowRun.deploymentId,\n            specVersion: workflowRun.specVersion ?? SPEC_VERSION_LEGACY,\n          }\n        );\n\n        return hook;\n      } catch (err) {\n        span?.setAttributes({\n          ...Attribute.HookToken(\n            typeof tokenOrHook === 'string' ? tokenOrHook : tokenOrHook.token\n          ),\n          ...Attribute.HookFound(false),\n        });\n        throw err;\n      }\n    });\n  });\n}\n\n/**\n * Resumes a webhook by sending a {@link https://developer.mozilla.org/en-US/docs/Web/API/Request | Request}\n * object to a hook identified by its token.\n *\n * This function is called externally (e.g., from an API route or server action)\n * to send a request to a webhook and resume the associated workflow run.\n *\n * @param token - The unique token identifying the hook\n * @param request - The request to send to the hook\n * @returns Promise resolving to the response\n * @throws Error if the hook is not found or if there's an error during the process\n *\n * @example\n *\n * ```ts\n * // In an API route\n * import { resumeWebhook } from '@workflow/core/runtime';\n *\n * export async function POST(request: Request) {\n *   const url = new URL(request.url);\n *   const token = url.searchParams.get('token');\n *\n *   if (!token) {\n *     return new Response('Missing token', { status: 400 });\n *   }\n *\n *   try {\n *     const response = await resumeWebhook(token, request);\n *     return response;\n *   } catch (error) {\n *     return new Response('Webhook not found', { status: 404 });\n *   }\n * }\n * ```\n */\nexport async function resumeWebhook(\n  token: string,\n  request: Request\n): Promise<Response> {\n  const { hook, encryptionKey } = await getHookByTokenWithKey(token);\n\n  // Only webhooks can be resumed via the public endpoint.\n  // If the hook was created via createHook() (isWebhook !== true),\n  // throw the same \"not found\" error the world would throw for a missing\n  // token. This prevents leaking that the token is valid.\n  if (hook.isWebhook === false) {\n    throw new HookNotFoundError(token);\n  }\n\n  let response: Response | undefined;\n  let responseReadable: ReadableStream<Response> | undefined;\n  if (\n    hook.metadata &&\n    typeof hook.metadata === 'object' &&\n    'respondWith' in hook.metadata\n  ) {\n    if (hook.metadata.respondWith === 'manual') {\n      const { readable, writable } = new TransformStream<Response, Response>();\n      responseReadable = readable;\n\n      // The request instance includes the writable stream which will be used\n      // to write the response to the client from within the workflow run\n      (request as any)[WEBHOOK_RESPONSE_WRITABLE] = writable;\n    } else if (hook.metadata.respondWith instanceof Response) {\n      response = hook.metadata.respondWith;\n    } else {\n      throw new WorkflowRuntimeError(\n        `Invalid \\`respondWith\\` value: ${hook.metadata.respondWith}`,\n        { slug: ERROR_SLUGS.WEBHOOK_INVALID_RESPOND_WITH_VALUE }\n      );\n    }\n  } else {\n    // No `respondWith` value implies the default behavior of returning a 202\n    response = new Response(null, { status: 202 });\n  }\n\n  await resumeHook(hook, request, encryptionKey);\n\n  if (responseReadable) {\n    // Wait for the readable stream to emit one chunk,\n    // which is the `Response` object\n    const reader = responseReadable.getReader();\n    const chunk = await reader.read();\n    if (chunk.value) {\n      response = chunk.value;\n    }\n    reader.cancel();\n  }\n\n  if (!response) {\n    throw new WorkflowRuntimeError('Workflow run did not send a response', {\n      slug: ERROR_SLUGS.WEBHOOK_RESPONSE_NOT_SENT,\n    });\n  }\n\n  return response;\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"resume-hook.js","sourceRoot":"","sources":["../../src/runtime/resume-hook.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  EntityConflictError,\n  ERROR_SLUGS,\n  HookNotFoundError,\n  RunExpiredError,\n  WorkflowRuntimeError,\n} from '@workflow/errors';\nimport {\n  HOOK_RESUME_DEDUP_VERSION,\n  HOOK_RESUME_INPUT_VERSION,\n  type Hook,\n  type HookResumeContext,\n  isLegacySpecVersion,\n  isTerminalWorkflowRunStatus,\n  SPEC_VERSION_CURRENT,\n  SPEC_VERSION_LEGACY,\n  SPEC_VERSION_SUPPORTS_CBOR_QUEUE_TRANSPORT,\n  SPEC_VERSION_SUPPORTS_COMPRESSION,\n  type WorkflowInvokePayload,\n  type WorkflowRun,\n} from '@workflow/world';\nimport { monotonicFactory } from 'ulid';\nimport { getRunCapabilities } from '../capabilities.js';\nimport { isRetryableWorldError } from '../classify-error.js';\nimport { importKey } from '../encryption.js';\nimport { runtimeLogger } from '../logger.js';\nimport { decodeRunPublicKey } from '../sealed-box.js';\nimport { deriveRunPayloadKeys } from '../serialization/encryption.js';\nimport {\n  dehydrateStepReturnValue,\n  hydrateStepArguments,\n  type PayloadKey,\n  SerializationFormat,\n  sealTo,\n} from '../serialization.js';\nimport { WEBHOOK_RESPONSE_WRITABLE } from '../symbols.js';\nimport * as Attribute from '../telemetry/semantic-conventions.js';\nimport { linkToTraceCarrier, trace } from '../telemetry.js';\nimport { getWorldLazy } from './get-world-lazy.js';\nimport { getWorkflowQueueName } from './helpers.js';\nimport { safeWaitUntil, waitedUntil } from './wait-until.js';\n\n/** Monotonic ULID factory for per-call resume idempotency keys. */\nconst generateResumeId = monotonicFactory();\n\n/**\n * Upper bound on the serialized hook payload that the parallel fast path will\n * inline into the queue message's `hookInput`. Vercel Queues caps a single\n * message at ~256 KiB, and the message also carries the runId, hookId, token,\n * resumeId, digest, and trace carrier alongside CBOR framing overhead. Staying\n * well under that ceiling keeps the queue publish from rejecting an oversized\n * message — which, on the parallel path, would persist `hook_received` but never\n * re-trigger the run. Above this size we fall back to the sequential path, whose\n * queue message carries only the run ID (the payload lives in the event log).\n */\nconst MAX_INLINE_RESUME_PAYLOAD_BYTES = 128 * 1024;\n\n/**\n * Hex SHA-256 of the serialized resume payload bytes. Computed once by the\n * producer and forwarded verbatim on both the direct `hook_received` write and\n * the queue `hookInput`, so both writers of the same `resumeId` record an\n * identical digest on the server's `(runId, resumeId)` constraint. Hashing the\n * already-serialized bytes (not the raw value) keeps producer and consumer in\n * lockstep — the consumer forwards this string without recomputing.\n */\nasync function computeResumePayloadDigest(bytes: Uint8Array): Promise<string> {\n  const digest = await crypto.subtle.digest('SHA-256', bytes);\n  const view = new Uint8Array(digest);\n  let hex = '';\n  for (const b of view) {\n    hex += b.toString(16).padStart(2, '0');\n  }\n  return hex;\n}\n\n/**\n * The resume context for a hook plus where it came from. `run` is present only\n * on the fallback path (pre-`resumeContext` hooks), where it also carries the\n * run's mutable status for the terminal-run check. Key resolution is kept\n * separate so callers can gate it behind that check.\n */\ninterface HookResumeInfo {\n  resumeContext: HookResumeContext;\n  source: 'hook' | 'run_fallback';\n  run?: WorkflowRun;\n}\n\n/** Derive a resume context from a full run (fallback for pre-`resumeContext` hooks). */\nfunction resumeContextFromRun(run: WorkflowRun): HookResumeContext {\n  const coreVersion = run.executionContext?.workflowCoreVersion;\n  const traceCarrier = run.executionContext?.traceCarrier;\n  const hookResumeInputVersion = run.executionContext?.hookResumeInputVersion;\n  return {\n    deploymentId: run.deploymentId,\n    workflowName: run.workflowName,\n    runSpecVersion: run.specVersion,\n    workflowCoreVersion:\n      typeof coreVersion === 'string' ? coreVersion : undefined,\n    traceCarrier:\n      traceCarrier && typeof traceCarrier === 'object'\n        ? (traceCarrier as HookResumeContext['traceCarrier'])\n        : undefined,\n    encryptionPublicKey: run.encryptionPublicKey,\n    hookResumeInputVersion:\n      typeof hookResumeInputVersion === 'number'\n        ? hookResumeInputVersion\n        : undefined,\n  };\n}\n\n/**\n * Resolve resume context for a hook. Uses the stored `resumeContext` when\n * present (fast path — no run read); otherwise fetches the run and synthesizes\n * it. Does NOT resolve the encryption key — callers do that separately. Only\n * the fallback path can gate key work behind a local terminal-run check (it\n * has the fetched run); the fast path's stored context carries no status, so\n * seal/serialization work may run before the receiving side rejects\n * `hook_received` for an ended run.\n */\nasync function resolveHookResumeInfo(hook: Hook): Promise<HookResumeInfo> {\n  if (hook.resumeContext) {\n    return { resumeContext: hook.resumeContext, source: 'hook' };\n  }\n  const run = await (await getWorldLazy()).runs.get(hook.runId);\n  return {\n    resumeContext: resumeContextFromRun(run),\n    source: 'run_fallback',\n    run,\n  };\n}\n\n/**\n * Resolve the run's symmetric key for a payload WRITE, as a bare `CryptoKey`\n * (`importKey`) — the `encr` write fallback used when the run published no\n * public key to seal to. Writing needs only the AES key, not the read-side\n * keypair. On the fast path this needs only `runId` + `deploymentId` (no run\n * entity); on the fallback path the already fetched run is reused.\n */\nasync function resolveHookEncryptionKey(\n  hook: Hook,\n  info: HookResumeInfo\n): Promise<Awaited<ReturnType<typeof importKey>> | undefined> {\n  const world = await getWorldLazy();\n  const rawKey = info.run\n    ? await world.getEncryptionKeyForRun?.(info.run)\n    : await world.getEncryptionKeyForRun?.(hook.runId, {\n        deploymentId: info.resumeContext.deploymentId,\n      });\n  return rawKey ? await importKey(rawKey) : undefined;\n}\n\nasync function getHookByTokenWithKey(token: string): Promise<{\n  hook: Hook;\n  encryptionKey: PayloadKey | undefined;\n}> {\n  const world = await getWorldLazy();\n  const hook = await world.hooks.getByToken(token);\n\n  // Only a hook that actually carries metadata needs the run's key resolved\n  // here: hydrating that metadata is a READ, so derive the full RunPayloadKeys\n  // (which opens sealed `encp` metadata, not just symmetric `encr`). The common\n  // default webhook — createWebhook() with no `respondWith` — stores no\n  // metadata, so it skips this entirely: no ~350ms `run-key` API round trip,\n  // and, crucially, no resolved key handed to `resumeHook`, leaving it free to\n  // seal the payload to the run's published public key instead. Metadata-\n  // bearing webhooks still legitimately pay one lookup to hydrate.\n  let encryptionKey: PayloadKey | undefined;\n  if (typeof hook.metadata !== 'undefined') {\n    const info = await resolveHookResumeInfo(hook);\n    // On the fast path this resolves the key by runId + deploymentId (no run\n    // read); on the fallback path it reuses the already-fetched run.\n    const rawKey = info.run\n      ? await world.getEncryptionKeyForRun?.(info.run)\n      : await world.getEncryptionKeyForRun?.(hook.runId, {\n          deploymentId: info.resumeContext.deploymentId,\n        });\n    encryptionKey = rawKey ? await deriveRunPayloadKeys(rawKey) : undefined;\n    hook.metadata = await hydrateStepArguments(\n      hook.metadata as any,\n      hook.runId,\n      encryptionKey\n    );\n  }\n  return { hook, encryptionKey };\n}\n\n/**\n * Get the hook by token to find the associated workflow run,\n * and hydrate the `metadata` property if it was set from within\n * the workflow run.\n *\n * A Hook kept by minimum retention remains available here after its run ends,\n * but cannot be resumed.\n *\n * @param token - The unique token identifying the hook\n */\nexport async function getHookByToken(token: string): Promise<Hook> {\n  const { hook } = await getHookByTokenWithKey(token);\n  return hook;\n}\n\n/**\n * The result of {@link resumeHook}: a {@link Hook} augmented with an optional\n * resilience signal.\n *\n * On the parallel fast path, `resumeHook()` writes the `hook_received` event and\n * dispatches the workflow queue message concurrently. When the direct event\n * write fails *transiently* — a 429/5xx, a transport error, or an expected\n * `(runId, resumeId)` conflict with its own re-ensuring consumer — but the queue\n * dispatch succeeds, the resume is still guaranteed: the queue consumer\n * idempotently materializes the `hook_received` event from the payload carried\n * on the message before replay. In that recovered case the returned hook carries\n * `resilientResume: true`.\n *\n * On the happy path (the direct write landed) and on the sequential fallback\n * path, the flag is absent (`undefined`). Callers that don't care about the\n * distinction can treat the result as a plain {@link Hook}.\n */\nexport type ResumedHook = Hook & { resilientResume?: boolean };\n\n/**\n * Resumes a workflow run by sending a payload to a hook identified by its token.\n *\n * This function is called externally (e.g., from an API route or server action)\n * to send data to a hook and resume the associated workflow run.\n *\n * @param tokenOrHook - The unique token identifying the hook, or the hook object itself\n * @param payload - The data payload to send to the hook\n * @returns Promise resolving to the {@link ResumedHook}\n * @throws {HookNotFoundError} If the Hook does not exist or its run has ended\n *\n * @example\n *\n * ```ts\n * // In an API route\n * import { resumeHook } from '@workflow/core/runtime';\n *\n * export async function POST(request: Request) {\n *   const { token, data } = await request.json();\n *\n *   try {\n *     const hook = await resumeHook(token, data);\n *     return Response.json({ runId: hook.runId });\n *   } catch (error) {\n *     return new Response('Hook not found', { status: 404 });\n *   }\n * }\n * ```\n */\nexport async function resumeHook<T = any>(\n  tokenOrHook: string | Hook,\n  payload: T,\n  encryptionKeyOverride?: PayloadKey\n): Promise<ResumedHook> {\n  // Public entry point. It never attests hook freshness, so a Hook object\n  // supplied here — which may carry a `resumeCapabilities` cached before a\n  // server rollback or kill switch — is ignored by the dynamic-dedup gate and\n  // fails closed to the sequential path. Only `resumeWebhook`, which fetches\n  // the hook by token in-line during the same resume, reaches the internal\n  // implementation with the fresh attestation set. Keeping the freshness flag\n  // off the exported signature prevents a caller from passing a stale Hook plus\n  // `true` and reactivating dynamic dedup against a rolled-back backend.\n  return resumeHookImpl(tokenOrHook, payload, encryptionKeyOverride, false);\n}\n\n/**\n * Internal implementation of {@link resumeHook}. NOT exported: the\n * `hookFreshlyLookedUp` attestation must never be reachable by public callers\n * (see the wrapper above).\n *\n * @param hookFreshlyLookedUp - Attests that a supplied Hook object was fetched\n *   by token during THIS resume, so its response-only `resumeCapabilities`\n *   reflects the live backend and may be trusted for the dynamic-dedup gate.\n *   A token string is always fetched fresh here, so it is implicitly fresh.\n */\nasync function resumeHookImpl<T = any>(\n  tokenOrHook: string | Hook,\n  payload: T,\n  encryptionKeyOverride: PayloadKey | undefined,\n  hookFreshlyLookedUp: boolean\n): Promise<ResumedHook> {\n  return await waitedUntil(() => {\n    return trace('hook.resume', async (span) => {\n      const world = await getWorldLazy();\n\n      try {\n        const suppliedToken = typeof tokenOrHook === 'string';\n        const hook: Hook = suppliedToken\n          ? await world.hooks.getByToken(tokenOrHook)\n          : tokenOrHook;\n        // The dynamic, response-only `resumeCapabilities` may only be trusted\n        // when it came from a by-token lookup performed during this resume.\n        const hookResumeCapabilitiesAreFresh =\n          suppliedToken || hookFreshlyLookedUp;\n\n        const info = await resolveHookResumeInfo(hook);\n        const { resumeContext } = info;\n\n        span?.setAttributes({\n          ...Attribute.HookToken(hook.token),\n          ...Attribute.HookId(hook.hookId),\n          ...Attribute.WorkflowRunId(hook.runId),\n          'workflow.hook.resume_context_source': info.source,\n        });\n\n        // The stored `resumeContext` intentionally omits the run's mutable\n        // status, so this early client-side rejection only runs on the\n        // fallback path (which fetched the run). On the fast path the terminal\n        // check happens server-side: `hook_received` against an ended run is\n        // rejected, which the catch around `world.events.create` below re-keys\n        // to HookNotFoundError — same public contract, no run pre-fetch.\n        if (info.run && isTerminalWorkflowRunStatus(info.run.status)) {\n          throw new HookNotFoundError(hook.token);\n        }\n\n        // Check the target run's capabilities to ensure we encode the\n        // payload in a format the run's deployment can decode. For example,\n        // runs created before encryption support was added cannot decode\n        // the 'encr' serialization format, and runs created before\n        // byte-stream framing support cannot decode framed byte streams.\n        const capabilities = getRunCapabilities(\n          resumeContext.workflowCoreVersion\n        );\n\n        // Resolve how to encrypt the payload for the target run (a WRITE).\n        //\n        // Preferred path: seal to the run's published X25519 public key, which\n        // the stored `resumeContext` carries inline. On the fast path this is\n        // the whole win — no run read AND no `getEncryptionKeyForRun`, whose\n        // ~350ms `run-key` API round trip dominates cross-deployment hook\n        // resumption latency. (On the fallback path the key is synthesized\n        // from the fetched run, which also carries it.)\n        //\n        // Sealing also drops privilege: the resumer ends up able to write a\n        // payload for the run without being able to read anything of the\n        // run's, where fetching the symmetric key grants both.\n        //\n        // Deliberately NOT gated on `capabilities.supportedFormats` the way\n        // the symmetric fallback below gates `encr`: presence of the public key\n        // is itself the gate. A run only carries one if the runtime that\n        // created it could also open a sealed payload, and runs are pinned to\n        // their creating deployment, so presence is a more reliable attestation\n        // than a version compare — and it stays correct even when package\n        // versions drift.\n        let payloadKey: PayloadKey | undefined;\n        const runPublicKey = encryptionKeyOverride\n          ? // The caller already holds a key (resumeWebhook resolved one to\n            // hydrate hook metadata), so sealing would add an ECDH for no\n            // saved round trip. Reuse what it resolved.\n            undefined\n          : decodeRunPublicKey(resumeContext.encryptionPublicKey);\n\n        if (runPublicKey) {\n          payloadKey = sealTo(runPublicKey);\n        } else {\n          // Symmetric `encr` write fallback: needs only the AES key\n          // (a bare CryptoKey via `resolveHookEncryptionKey`), not the\n          // read-side RunPayloadKeys.\n          let encryptionKey =\n            encryptionKeyOverride ??\n            (await resolveHookEncryptionKey(hook, info));\n          if (\n            !capabilities.supportedFormats.has(SerializationFormat.ENCRYPTED)\n          ) {\n            encryptionKey = undefined;\n          }\n          payloadKey = encryptionKey;\n        }\n\n        // Compress only when the target run and its deployment support the\n        // compression formats introduced with spec version 5.\n        const compression =\n          (resumeContext.runSpecVersion ?? 0) >=\n            SPEC_VERSION_SUPPORTS_COMPRESSION &&\n          capabilities.supportedFormats.has(SerializationFormat.GZIP);\n\n        // Dehydrate the payload for storage\n        const ops: Promise<any>[] = [];\n        const v1Compat = isLegacySpecVersion(hook.specVersion);\n        const dehydratedPayload = await dehydrateStepReturnValue(\n          payload,\n          hook.runId,\n          payloadKey,\n          ops,\n          globalThis,\n          v1Compat,\n          capabilities.framedByteStreams,\n          compression\n        );\n        // These payload-stream ops are flushed in the background; the\n        // promise handed to waitUntil must never reject (an unconsumed\n        // waitUntil rejection crashes the process as unhandledRejection),\n        // so unexpected failures are logged instead.\n        // NOTE: rejections with `undefined` are an expected artifact of the\n        // webhook bundle and are ignored entirely.\n        safeWaitUntil(Promise.all(ops), (err) => {\n          if (err === undefined) return;\n          runtimeLogger.warn('Background flush of hook payload ops failed', {\n            workflowRunId: hook.runId,\n            hookId: hook.hookId,\n            error: err instanceof Error ? err.message : String(err),\n          });\n        });\n\n        span?.setAttributes({\n          ...Attribute.WorkflowName(resumeContext.workflowName),\n        });\n\n        // Link to the run-origin context from the stored trace carrier\n        // (skipped when absent or invalid). Resolved before dispatch so both\n        // the sequential and parallel paths attach it.\n        const originLink = await linkToTraceCarrier(resumeContext.traceCarrier);\n        if (originLink) {\n          span?.addLink?.(originLink);\n        }\n\n        const eventData = {\n          ...(v1Compat ? {} : { token: hook.token }),\n          payload: dehydratedPayload,\n        };\n\n        const queueName = getWorkflowQueueName(resumeContext.workflowName);\n        const queueOptions = {\n          deploymentId: resumeContext.deploymentId,\n          specVersion: resumeContext.runSpecVersion ?? SPEC_VERSION_LEGACY,\n        };\n\n        // Decide whether to parallelize the `hook_received` write and the queue\n        // publish. The fast path is only safe when EVERY precondition holds; the\n        // first that fails names the fallback reason (emitted as a span\n        // attribute for observability, and to make \"why did this run sequential\"\n        // answerable in production). All conditions:\n        //\n        //  - kill switch: `WORKFLOW_DISABLE_LAZY_HOOK_RESUME` forces sequential\n        //    if the fast path ever misbehaves. It is an SDK-deployment env var,\n        //    so changing it generally requires redeploying the workflow\n        //    deployment. (The backend can independently drop new resumes to the\n        //    sequential path fleet-wide by ceasing to attest dedup support on\n        //    the by-token lookup — see the backend-dedup condition below.)\n        //  - backend dedup: the live backend must enforce the\n        //    `(runId, resumeId)` constraint, or the two writers would commit two\n        //    `hook_received` events. Fail closed. Attested by EITHER a fresh,\n        //    response-only `hook.resumeCapabilities.hookResumeDedupVersion` from\n        //    the by-token lookup (world-vercel — recomputed every read, so a\n        //    server rollback or kill switch drops to sequential immediately) OR\n        //    the static `world.capabilities.hookResumeDedup` (world-local, whose\n        //    adapter and backend ship together). The response-only capability is\n        //    trusted ONLY when the hook was looked up by token during this\n        //    resume (`hookResumeCapabilitiesAreFresh`); a Hook object handed in\n        //    by a public caller may carry a capability cached before a rollback,\n        //    so it is ignored and the path falls back to sequential.\n        //  - consumer support: the target run's deployment must re-ensure the\n        //    event from `hookInput` on replay. Attested by the run's explicit\n        //    `hookResumeInputVersion` execution-context marker (mirrored onto\n        //    resumeContext), NOT a version-compare against a predicted release\n        //    cutoff. Absent → a lost producer write would be a lost resume.\n        //  - not legacy: v1Compat runs omit `token` from the producer's event\n        //    body but the consumer's re-ensure always includes it, so the two\n        //    writers would disagree on the event body. Legacy stays sequential.\n        //  - CBOR transport: the run must use CBOR queue transport so the binary\n        //    payload survives the queue message.\n        //  - raw bytes: the dehydrated payload must be a `Uint8Array` (the\n        //    content digest that keys the dedup constraint is over these bytes).\n        //  - size: a payload above the queue's message ceiling would fail the\n        //    publish — which, on the parallel path, would persist the event but\n        //    never re-trigger the run — so oversized payloads stay sequential\n        //    (their queue message carries only the run ID).\n        const parallelResumeDisabled =\n          process.env.WORKFLOW_DISABLE_LAZY_HOOK_RESUME === '1';\n        // Backend dedup is supported when EITHER the live server attests it\n        // fresh on this by-token hook (world-vercel: response-only, recomputed\n        // every read, so rollback/kill-switch take effect immediately) OR the\n        // static world capability is set (world-local: adapter + backend ship\n        // together). Both are re-evaluated per resume, so every rollout and\n        // rollback direction degrades safely to the sequential path.\n        const backendDedupSupported =\n          (hookResumeCapabilitiesAreFresh\n            ? (hook.resumeCapabilities?.hookResumeDedupVersion ?? 0)\n            : 0) >= HOOK_RESUME_DEDUP_VERSION ||\n          world.capabilities?.hookResumeDedup === true;\n        const fallbackReason: string | null = parallelResumeDisabled\n          ? 'disabled'\n          : !backendDedupSupported\n            ? 'backend_unsupported'\n            : (resumeContext.hookResumeInputVersion ?? 0) <\n                HOOK_RESUME_INPUT_VERSION\n              ? 'consumer_unsupported'\n              : v1Compat\n                ? 'legacy'\n                : (resumeContext.runSpecVersion ?? 0) <\n                    SPEC_VERSION_SUPPORTS_CBOR_QUEUE_TRANSPORT\n                  ? 'non_cbor_transport'\n                  : !(dehydratedPayload instanceof Uint8Array)\n                    ? 'non_bytes'\n                    : dehydratedPayload.byteLength >\n                        MAX_INLINE_RESUME_PAYLOAD_BYTES\n                      ? 'oversized'\n                      : null;\n        const useParallelResume = fallbackReason === null;\n\n        span?.setAttributes({\n          'workflow.hook.resume_strategy': useParallelResume\n            ? 'parallel'\n            : 'sequential',\n          ...(fallbackReason\n            ? { 'workflow.hook.resume_fallback_reason': fallbackReason }\n            : {}),\n        });\n\n        // Re-key any \"hook can no longer be received\" rejection to\n        // HookNotFoundError(hook.token) so `.token` matches the pre-fast-path\n        // contract, where resumeHook threw `HookNotFoundError(hook.token)`\n        // after its own terminal check. The specific error depends on the\n        // World:\n        //   - a genuinely missing hook maps to HookNotFoundError (keyed on the\n        //     event correlationId / hook ID);\n        //   - a terminal run on Vercel rejects hook_received with 404, which\n        //     world-vercel maps to HookNotFoundError;\n        //   - a terminal run on world-local / world-postgres rejects with\n        //     RunExpiredError.\n        //\n        // On the SEQUENTIAL path an EntityConflictError (HTTP 409) is also\n        // treated as \"hook gone\" for historical / conflict-shaped-rejection\n        // compatibility: there is no queue message in flight, so a conflict has\n        // no re-ensuring consumer to converge on. The PARALLEL path handles 409\n        // differently (see below) — it published the queue message before the\n        // conflict, so the consumer will converge the event.\n        const isHookGoneError = (err: unknown): boolean =>\n          HookNotFoundError.is(err) ||\n          EntityConflictError.is(err) ||\n          RunExpiredError.is(err);\n\n        if (!useParallelResume) {\n          // Sequential path: create a hook_received event, then re-trigger.\n          try {\n            await world.events.create(\n              hook.runId,\n              {\n                eventType: 'hook_received',\n                specVersion: SPEC_VERSION_CURRENT,\n                correlationId: hook.hookId,\n                eventData,\n              },\n              { v1Compat }\n            );\n          } catch (err) {\n            if (isHookGoneError(err)) {\n              throw new HookNotFoundError(hook.token);\n            }\n            throw err;\n          }\n\n          await world.queue(\n            queueName,\n            {\n              runId: hook.runId,\n              traceCarrier: resumeContext.traceCarrier ?? undefined,\n            } satisfies WorkflowInvokePayload,\n            queueOptions\n          );\n\n          return hook;\n        }\n\n        // Parallel fast path. A stable idempotency key ties the direct write to\n        // the queue consumer's re-ensure; the payload digest lets the server\n        // detect key reuse across byte-identical payloads.\n        const resumeId = generateResumeId();\n        const payloadDigest = await computeResumePayloadDigest(\n          dehydratedPayload as Uint8Array\n        );\n        span?.setAttributes({ 'workflow.hook.resume_id': resumeId });\n\n        const [eventResult, queueResult] = await Promise.allSettled([\n          world.events.create(\n            hook.runId,\n            {\n              eventType: 'hook_received',\n              specVersion: SPEC_VERSION_CURRENT,\n              correlationId: hook.hookId,\n              eventData,\n            },\n            { v1Compat, resumeId, resumePayloadDigest: payloadDigest }\n          ),\n          world.queue(\n            queueName,\n            {\n              runId: hook.runId,\n              traceCarrier: resumeContext.traceCarrier ?? undefined,\n              hookInput: {\n                resumeId,\n                hookId: hook.hookId,\n                token: hook.token,\n                payload: dehydratedPayload,\n                payloadDigest,\n              },\n            } satisfies WorkflowInvokePayload,\n            queueOptions\n          ),\n        ]);\n\n        // Queue failure is always fatal — the run was not re-triggered, so no\n        // consumer will re-ensure the event.\n        if (queueResult.status === 'rejected') {\n          throw queueResult.reason;\n        }\n\n        // Set when the direct write did not land but the queue dispatch did, so\n        // the consumer materializes the event before replay. Surfaced to the\n        // caller as `ResumedHook.resilientResume` and on the span.\n        let resilientResume = false;\n        if (eventResult.status === 'rejected') {\n          const err = eventResult.reason;\n          if (HookNotFoundError.is(err) || RunExpiredError.is(err)) {\n            // The hook's run has genuinely ended: surface the same contract as\n            // the sequential path. The queue message already went out, but the\n            // consumer's re-ensure will also reject against the terminal run\n            // and no-op, so the workflow does not resume.\n            throw new HookNotFoundError(hook.token);\n          }\n          if (EntityConflictError.is(err) || isRetryableWorldError(err)) {\n            // Resilient. Two shapes reach here, both non-terminal:\n            //   - EntityConflict (409): this write raced its own re-ensuring\n            //     consumer (or a redrive) on the shared `resumeId` — the run is\n            //     NOT gone, and the consumer converges on the one committed\n            //     event. Unlike the sequential path, a 409 here is expected\n            //     concurrency, not a vanished hook.\n            //   - 429 / 5xx / transport: a transient backend failure.\n            // In both cases the run WAS re-triggered via the queue and the\n            // consumer idempotently ensures the hook_received before replay, so\n            // swallow rather than failing the caller.\n            //\n            // Producer telemetry: record that the direct write did not land but\n            // the resume is still guaranteed via queue-delivered `hookInput`.\n            // This is the operational signal that the recovery path fired,\n            // surfaced both on the span and as the public `resilientResume`\n            // flag on the returned hook (the resume outcome is otherwise\n            // identical to the happy path from the caller's perspective).\n            resilientResume = true;\n            span?.setAttributes({\n              ...Attribute.HookResilientResume(true),\n              'workflow.hook.resume_event_write_recovered': true,\n              'workflow.hook.resume_event_write_error':\n                err instanceof Error ? err.name : 'unknown',\n            });\n            runtimeLogger.warn(\n              'Hook resume event write failed, but the run was re-triggered via ' +\n                'the queue. The hook_received event will be ensured by the ' +\n                'queue consumer.',\n              {\n                workflowRunId: hook.runId,\n                hookId: hook.hookId,\n                resumeId,\n                error: err instanceof Error ? err.message : String(err),\n              }\n            );\n          } else {\n            throw err;\n          }\n        }\n\n        return (\n          resilientResume ? { ...hook, resilientResume: true } : hook\n        ) satisfies ResumedHook;\n      } catch (err) {\n        span?.setAttributes({\n          ...Attribute.HookToken(\n            typeof tokenOrHook === 'string' ? tokenOrHook : tokenOrHook.token\n          ),\n          ...Attribute.HookFound(false),\n        });\n        throw err;\n      }\n    });\n  });\n}\n\n/**\n * Resumes a webhook by sending a {@link https://developer.mozilla.org/en-US/docs/Web/API/Request | Request}\n * object to a hook identified by its token.\n *\n * This function is called externally (e.g., from an API route or server action)\n * to send a request to a webhook and resume the associated workflow run.\n *\n * @param token - The unique token identifying the hook\n * @param request - The request to send to the hook\n * @returns Promise resolving to the response\n * @throws Error if the hook is not found or if there's an error during the process\n *\n * @example\n *\n * ```ts\n * // In an API route\n * import { resumeWebhook } from '@workflow/core/runtime';\n *\n * export async function POST(request: Request) {\n *   const url = new URL(request.url);\n *   const token = url.searchParams.get('token');\n *\n *   if (!token) {\n *     return new Response('Missing token', { status: 400 });\n *   }\n *\n *   try {\n *     const response = await resumeWebhook(token, request);\n *     return response;\n *   } catch (error) {\n *     return new Response('Webhook not found', { status: 404 });\n *   }\n * }\n * ```\n */\nexport async function resumeWebhook(\n  token: string,\n  request: Request\n): Promise<Response> {\n  const { hook, encryptionKey } = await getHookByTokenWithKey(token);\n\n  // Only webhooks can be resumed via the public endpoint.\n  // If the hook was created via createHook() (isWebhook !== true),\n  // throw the same \"not found\" error the world would throw for a missing\n  // token. This prevents leaking that the token is valid.\n  if (hook.isWebhook === false) {\n    throw new HookNotFoundError(token);\n  }\n\n  let response: Response | undefined;\n  let responseReadable: ReadableStream<Response> | undefined;\n  if (\n    hook.metadata &&\n    typeof hook.metadata === 'object' &&\n    'respondWith' in hook.metadata\n  ) {\n    if (hook.metadata.respondWith === 'manual') {\n      const { readable, writable } = new TransformStream<Response, Response>();\n      responseReadable = readable;\n\n      // The request instance includes the writable stream which will be used\n      // to write the response to the client from within the workflow run\n      (request as any)[WEBHOOK_RESPONSE_WRITABLE] = writable;\n    } else if (hook.metadata.respondWith instanceof Response) {\n      response = hook.metadata.respondWith;\n    } else {\n      throw new WorkflowRuntimeError(\n        `Invalid \\`respondWith\\` value: ${hook.metadata.respondWith}`,\n        { slug: ERROR_SLUGS.WEBHOOK_INVALID_RESPOND_WITH_VALUE }\n      );\n    }\n  } else {\n    // No `respondWith` value implies the default behavior of returning a 202\n    response = new Response(null, { status: 202 });\n  }\n\n  // `hook` was just fetched via `getHookByTokenWithKey` (a fresh by-token\n  // lookup) above, so its response-only `resumeCapabilities` reflects the live\n  // backend — call the internal implementation with the fresh attestation so\n  // the parallel fast path stays available without a second GET. (The public\n  // `resumeHook` never sets this, so a caller cannot forge it.)\n  await resumeHookImpl(hook, request, encryptionKey, true);\n\n  if (responseReadable) {\n    // Wait for the readable stream to emit one chunk,\n    // which is the `Response` object\n    const reader = responseReadable.getReader();\n    const chunk = await reader.read();\n    if (chunk.value) {\n      response = chunk.value;\n    }\n    reader.cancel();\n  }\n\n  if (!response) {\n    throw new WorkflowRuntimeError('Workflow run did not send a response', {\n      slug: ERROR_SLUGS.WEBHOOK_RESPONSE_NOT_SENT,\n    });\n  }\n\n  return response;\n}\n"]}