@workflow/core 5.0.0-beta.49 → 5.0.0-beta.50

package/dist/runtime/resume-hook.js

@@ -140,36 +140,87 @@ async function resolveHookEncryptionKey(hook, info) {
         });
     return rawKey ? await importKey(rawKey) : undefined;
 }
-async function getHookByTokenWithKey(token) {
-    const world = await getWorldLazy();
-    const hook = await world.hooks.getByToken(token);
-    // 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.
+/** Whether `metadata` on this record is already the lazy Promise accessor. */
+function hasLazyMetadata(hook) {
+    const descriptor = Object.getOwnPropertyDescriptor(hook, 'metadata');
+    return descriptor !== undefined && typeof descriptor.get === 'function';
+}
+/**
+ * Wraps a raw hook record from a World in a {@link Hook},
+ * replacing its serialized `metadata` with a memoized Promise getter that
+ * hydrates on first access.
+ *
+ * Nothing here touches the network: the wrap is a property definition. All of
+ * the cost — resolving the run's payload keys and decrypting — moves inside the
+ * getter, so a lookup that never reads metadata pays for exactly one
+ * `hooks.getByToken`.
+ *
+ * The getter is defined in place on the record the World returned (the same
+ * object the eager path used to mutate), so no copy is made.
+ */
+function withLazyMetadata(raw) {
+    const serialized = raw.metadata;
+    let hydrated;
     let encryptionKey;
-    if (typeof hook.metadata !== 'undefined') {
-        const info = await resolveHookResumeInfo(hook);
+    // Hydrating metadata is a decrypting READ, so it derives the full
+    // RunPayloadKeys (which open sealed `encp` metadata, not just symmetric
+    // `encr`) rather than the bare write key the resume path uses.
+    const hydrate = async () => {
+        const world = await getWorldLazy();
+        const info = await resolveHookResumeInfo(raw);
         // 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, {
+            : await world.getEncryptionKeyForRun?.(raw.runId, {
                 deploymentId: info.resumeContext.deploymentId,
             });
         encryptionKey = rawKey ? await deriveRunPayloadKeys(rawKey) : undefined;
-        hook.metadata = await hydrateStepArguments(hook.metadata, hook.runId, encryptionKey);
-    }
-    return { hook, encryptionKey };
+        return await hydrateStepArguments(serialized, raw.runId, encryptionKey);
+    };
+    const hook = raw;
+    Object.defineProperty(hook, 'metadata', {
+        // A hook with no metadata resolves `undefined` without any I/O, so callers
+        // can await unconditionally. Memoized either way: metadata is fixed at
+        // hook-creation time, so hydration runs at most once per hook object.
+        get: () => (hydrated ??=
+            typeof serialized === 'undefined'
+                ? Promise.resolve(undefined)
+                : hydrate()),
+        // Non-enumerable, matching `Run.returnValue` (a prototype getter, so it is
+        // absent from an instance's own keys). Spreading or `JSON.stringify`-ing a
+        // hook therefore cannot trigger hydration nobody asked for — which would
+        // otherwise leave a floating rejection when the run key is unreachable, and
+        // an unconsumed rejected Promise crashes Node as an unhandledRejection.
+        enumerable: false,
+        configurable: true,
+    });
+    return { hook, metadataEncryptionKey: () => 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.
+ * Normalizes any hook record the resume path accepted into a
+ * {@link Hook} to return to the caller. Idempotent: a hook that
+ * already carries the lazy accessor (one that came from `getHookByToken`) is
+ * returned as-is rather than double-wrapped, which would hand
+ * `hydrateStepArguments` a Promise.
+ */
+function asLazyMetadataHook(hook) {
+    return hasLazyMetadata(hook)
+        ? hook
+        : withLazyMetadata(hook).hook;
+}
+/**
+ * Get the hook by token to find the associated workflow run.
+ *
+ * This is a single read. The returned hook's `metadata` is a getter that
+ * resolves a Promise (see {@link Hook}), so the run fetch and
+ * `run-key` round trip that hydrating it can require are only paid by callers
+ * that actually await it:
+ *
+ * ```ts
+ * const hook = await getHookByToken(token);
+ * const metadata = await hook.metadata;
+ * ```
  *
  * A Hook kept by minimum retention remains available here after its run ends,
  * but cannot be resumed.
@@ -177,8 +228,8 @@ async function getHookByTokenWithKey(token) {
  * @param token - The unique token identifying the hook
  */
 export async function getHookByToken(token) {
-    const { hook } = await getHookByTokenWithKey(token);
-    return hook;
+    const world = await getWorldLazy();
+    return withLazyMetadata(await world.hooks.getByToken(token)).hook;
 }
 /**
  * Resumes a workflow run by sending a payload to a hook identified by its token.
@@ -493,7 +544,7 @@ async function resumeHookImpl(tokenOrHook, payload, encryptionKeyOverride, hookF
                     ...(resumeId ? { idempotencyKey: `hook-${resumeId}` } : {}),
                 }), world.isDeploymentUnavailableError?.bind(world));
                 span?.setAttributes(Attribute.HookWakePublished(true));
-                return hook;
+                return asLazyMetadataHook(hook);
             }
             catch (err) {
                 span?.setAttributes({
@@ -547,7 +598,8 @@ export async function resumeWebhook(token, request) {
     // and not inside `resumeHookImpl`; otherwise webhook resumes would report a
     // systematically shorter total than `resumeHook` ones into the same metric.
     const resumeRequestedAtMs = Date.now();
-    const { hook, encryptionKey } = await getHookByTokenWithKey(token);
+    const world = await getWorldLazy();
+    const { hook, metadataEncryptionKey } = withLazyMetadata(await world.hooks.getByToken(token));
     // Only webhooks can be resumed via the public endpoint.
     // If the hook was created via createHook() (isWebhook !== true),
     // throw the same "not found" error the world would throw for a missing
@@ -555,35 +607,44 @@ export async function resumeWebhook(token, request) {
     if (hook.isWebhook === false) {
         throw new HookNotFoundError(token);
     }
+    // `respondWith` lives in the hook's metadata, so this is the one resume path
+    // that has to read it. Only a webhook that actually stored metadata pays for
+    // the hydration: the common default webhook — createWebhook() with no
+    // `respondWith` — stores none, so this resolves `undefined` with no ~350ms
+    // `run-key` API round trip, and hands `resumeHook` no key, leaving it free to
+    // seal the payload to the run's published public key instead.
+    const metadata = await hook.metadata;
     let response;
     let responseReadable;
-    if (hook.metadata &&
-        typeof hook.metadata === 'object' &&
-        'respondWith' in hook.metadata) {
-        if (hook.metadata.respondWith === 'manual') {
+    if (metadata && typeof metadata === 'object' && 'respondWith' in metadata) {
+        if (metadata.respondWith === 'manual') {
             const { readable, writable } = new TransformStream();
             responseReadable = readable;
             // The request instance includes the writable stream which will be used
             // to write the response to the client from within the workflow run
             request[WEBHOOK_RESPONSE_WRITABLE] = writable;
         }
-        else if (hook.metadata.respondWith instanceof Response) {
-            response = hook.metadata.respondWith;
+        else if (metadata.respondWith instanceof Response) {
+            response = metadata.respondWith;
         }
         else {
-            throw new WorkflowRuntimeError(`Invalid \`respondWith\` value: ${hook.metadata.respondWith}`, { slug: ERROR_SLUGS.WEBHOOK_INVALID_RESPOND_WITH_VALUE });
+            throw new WorkflowRuntimeError(`Invalid \`respondWith\` value: ${metadata.respondWith}`, { slug: ERROR_SLUGS.WEBHOOK_INVALID_RESPOND_WITH_VALUE });
         }
     }
     else {
         // No `respondWith` value implies the default behavior of returning a 202
         response = new Response(null, { status: 202 });
     }
-    // `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 write's idempotency claim stays available without a second GET. (The
-    // public `resumeHook` never sets this, so a caller cannot forge it.)
-    await resumeHookImpl(hook, request, encryptionKey, true, resumeRequestedAtMs);
+    // `hook` was just fetched by token above, so its response-only
+    // `resumeCapabilities` reflects the live backend. Call the internal
+    // implementation with the fresh attestation so the write's idempotency claim
+    // stays available without a second GET. (The public `resumeHook` never sets
+    // this, so a caller cannot forge it.)
+    //
+    // Reuse whatever key the metadata hydration above resolved (`undefined` when
+    // it resolved none) so a metadata-bearing webhook resolves the run key
+    // exactly once end to end.
+    await resumeHookImpl(hook, request, metadataEncryptionKey(), true, resumeRequestedAtMs);
     if (responseReadable) {
         // Wait for the readable stream to emit one chunk,
         // which is the `Response` object
@@ -601,4 +662,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":"AAAA,OAAO,EACL,WAAW,EACX,iBAAiB,EACjB,eAAe,EACf,oBAAoB,GACrB,MAAM,kBAAkB,CAAC;AAC1B,OAAO,EACL,yBAAyB,EAGzB,mBAAmB,EACnB,2BAA2B,EAC3B,oBAAoB,EACpB,mBAAmB,EACnB,iCAAiC,GAGlC,MAAM,iBAAiB,CAAC;AACzB,OAAO,EAAE,gBAAgB,EAAE,MAAM,MAAM,CAAC;AACxC,OAAO,EAAE,kBAAkB,EAAE,MAAM,oBAAoB,CAAC;AACxD,OAAO,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAC;AAC7C,OAAO,EAAE,aAAa,EAAE,MAAM,cAAc,CAAC;AAC7C,OAAO,EAAE,kBAAkB,EAAE,MAAM,kBAAkB,CAAC;AACtD,OAAO,EAAE,oBAAoB,EAAE,MAAM,gCAAgC,CAAC;AACtE,OAAO,EACL,wBAAwB,EACxB,oBAAoB,EAEpB,mBAAmB,EACnB,MAAM,GACP,MAAM,qBAAqB,CAAC;AAC7B,OAAO,EAAE,yBAAyB,EAAE,MAAM,eAAe,CAAC;AAC1D,OAAO,KAAK,SAAS,MAAM,sCAAsC,CAAC;AAClE,OAAO,EAAE,kBAAkB,EAAE,KAAK,EAAE,MAAM,iBAAiB,CAAC;AAC5D,OAAO,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAC;AACnD,OAAO,EAAE,oBAAoB,EAAE,MAAM,cAAc,CAAC;AACpD,OAAO,EAAE,aAAa,EAAE,WAAW,EAAE,MAAM,iBAAiB,CAAC;AAE7D,mEAAmE;AACnE,MAAM,gBAAgB,GAAG,gBAAgB,EAAE,CAAC;AAE5C;;;;GAIG;AACH,KAAK,UAAU,0BAA0B,CAAC,KAAiB;IACzD,MAAM,MAAM,GAAG,MAAM,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,SAAS,EAAE,KAAK,CAAC,CAAC;IAC5D,MAAM,IAAI,GAAG,IAAI,UAAU,CAAC,MAAM,CAAC,CAAC;IACpC,IAAI,GAAG,GAAG,EAAE,CAAC;IACb,KAAK,MAAM,CAAC,IAAI,IAAI,EAAE,CAAC;QACrB,GAAG,IAAI,CAAC,CAAC,QAAQ,CAAC,EAAE,CAAC,CAAC,QAAQ,CAAC,CAAC,EAAE,GAAG,CAAC,CAAC;IACzC,CAAC;IACD,OAAO,GAAG,CAAC;AACb,CAAC;AAED,MAAM,yBAAyB,GAAG,CAAC,EAAE,EAAE,GAAG,CAAU,CAAC;AAErD;;;;;;;;;;;GAWG;AACH,SAAS,oBAAoB,CAC3B,KAAc,EACd,4BAA0D;IAE1D,IAAI,4BAA4B,EAAE,CAAC,KAAK,CAAC;QAAE,OAAO,KAAK,CAAC;IACxD,MAAM,MAAM,GAAI,KAAoD,IAAI,EAAE,CAAC;IAC3E,MAAM,IAAI,GAAG,MAAM,CAAC,MAAM,IAAI,MAAM,CAAC,UAAU,CAAC;IAChD,IAAI,OAAO,IAAI,KAAK,QAAQ,EAAE,CAAC;QAC7B,OAAO,IAAI,IAAI,GAAG,IAAI,IAAI,KAAK,GAAG,IAAI,IAAI,KAAK,GAAG,CAAC;IACrD,CAAC;IACD,MAAM,IAAI,GAAI,KAAsB,EAAE,IAAI,CAAC;IAC3C,OAAO,CACL,IAAI,KAAK,iBAAiB;QAC1B,IAAI,KAAK,mBAAmB;QAC5B,IAAI,KAAK,gBAAgB,CAC1B,CAAC;AACJ,CAAC;AAED,uEAAuE;AACvE,4EAA4E;AAC5E,4EAA4E;AAC5E,KAAK,UAAU,wBAAwB,CACrC,OAA+B,EAC/B,4BAA0D;IAE1D,IAAI,SAAkB,CAAC;IACvB,KACE,IAAI,OAAO,GAAG,CAAC,EACf,OAAO,IAAI,yBAAyB,CAAC,MAAM,EAC3C,OAAO,EAAE,EACT,CAAC;QACD,IAAI,CAAC;YACH,MAAM,OAAO,EAAE,CAAC;YAChB,OAAO;QACT,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,SAAS,GAAG,KAAK,CAAC;YAClB,IAAI,CAAC,oBAAoB,CAAC,KAAK,EAAE,4BAA4B,CAAC;gBAAE,MAAM;YACtE,MAAM,OAAO,GAAG,yBAAyB,CAAC,OAAO,CAAC,CAAC;YACnD,IAAI,OAAO,KAAK,SAAS,EAAE,CAAC;gBAC1B,MAAM,IAAI,OAAO,CAAC,CAAC,OAAO,EAAE,EAAE,CAAC,UAAU,CAAC,OAAO,EAAE,OAAO,CAAC,CAAC,CAAC;YAC/D,CAAC;QACH,CAAC;IACH,CAAC;IAED,wEAAwE;IACxE,0EAA0E;IAC1E,0EAA0E;IAC1E,wEAAwE;IACxE,wBAAwB;IACxB,IAAI,iBAAiB,CAAC,EAAE,CAAC,SAAS,CAAC,EAAE,CAAC;QACpC,MAAM,IAAI,oBAAoB,CAC5B,6EAA6E,EAC7E,EAAE,KAAK,EAAE,SAAS,EAAE,CACrB,CAAC;IACJ,CAAC;IACD,MAAM,SAAS,CAAC;AAClB,CAAC;AAcD,wFAAwF;AACxF,SAAS,oBAAoB,CAAC,GAAgB;IAC5C,MAAM,WAAW,GAAG,GAAG,CAAC,gBAAgB,EAAE,mBAAmB,CAAC;IAC9D,MAAM,YAAY,GAAG,GAAG,CAAC,gBAAgB,EAAE,YAAY,CAAC;IACxD,MAAM,sBAAsB,GAAG,GAAG,CAAC,gBAAgB,EAAE,sBAAsB,CAAC;IAC5E,OAAO;QACL,YAAY,EAAE,GAAG,CAAC,YAAY;QAC9B,YAAY,EAAE,GAAG,CAAC,YAAY;QAC9B,cAAc,EAAE,GAAG,CAAC,WAAW;QAC/B,mBAAmB,EACjB,OAAO,WAAW,KAAK,QAAQ,CAAC,CAAC,CAAC,WAAW,CAAC,CAAC,CAAC,SAAS;QAC3D,YAAY,EACV,YAAY,IAAI,OAAO,YAAY,KAAK,QAAQ;YAC9C,CAAC,CAAE,YAAkD;YACrD,CAAC,CAAC,SAAS;QACf,mBAAmB,EAAE,GAAG,CAAC,mBAAmB;QAC5C,sBAAsB,EACpB,OAAO,sBAAsB,KAAK,QAAQ;YACxC,CAAC,CAAC,sBAAsB;YACxB,CAAC,CAAC,SAAS;KAChB,CAAC;AACJ,CAAC;AAED;;;;;;;;GAQG;AACH,KAAK,UAAU,qBAAqB,CAAC,IAAU;IAC7C,IAAI,IAAI,CAAC,aAAa,EAAE,CAAC;QACvB,OAAO,EAAE,aAAa,EAAE,IAAI,CAAC,aAAa,EAAE,MAAM,EAAE,MAAM,EAAE,CAAC;IAC/D,CAAC;IACD,MAAM,GAAG,GAAG,MAAM,CAAC,MAAM,YAAY,EAAE,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;IAC9D,OAAO;QACL,aAAa,EAAE,oBAAoB,CAAC,GAAG,CAAC;QACxC,MAAM,EAAE,cAAc;QACtB,GAAG;KACJ,CAAC;AACJ,CAAC;AAED;;;;;;GAMG;AACH,KAAK,UAAU,wBAAwB,CACrC,IAAU,EACV,IAAoB;IAEpB,MAAM,KAAK,GAAG,MAAM,YAAY,EAAE,CAAC;IACnC,MAAM,MAAM,GAAG,IAAI,CAAC,GAAG;QACrB,CAAC,CAAC,MAAM,KAAK,CAAC,sBAAsB,EAAE,CAAC,IAAI,CAAC,GAAG,CAAC;QAChD,CAAC,CAAC,MAAM,KAAK,CAAC,sBAAsB,EAAE,CAAC,IAAI,CAAC,KAAK,EAAE;YAC/C,YAAY,EAAE,IAAI,CAAC,aAAa,CAAC,YAAY;SAC9C,CAAC,CAAC;IACP,OAAO,MAAM,CAAC,CAAC,CAAC,MAAM,SAAS,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC;AACtD,CAAC;AAED,KAAK,UAAU,qBAAqB,CAAC,KAAa;IAIhD,MAAM,KAAK,GAAG,MAAM,YAAY,EAAE,CAAC;IACnC,MAAM,IAAI,GAAG,MAAM,KAAK,CAAC,KAAK,CAAC,UAAU,CAAC,KAAK,CAAC,CAAC;IAEjD,0EAA0E;IAC1E,6EAA6E;IAC7E,8EAA8E;IAC9E,oEAAoE;IACpE,2EAA2E;IAC3E,6EAA6E;IAC7E,wEAAwE;IACxE,iEAAiE;IACjE,IAAI,aAAqC,CAAC;IAC1C,IAAI,OAAO,IAAI,CAAC,QAAQ,KAAK,WAAW,EAAE,CAAC;QACzC,MAAM,IAAI,GAAG,MAAM,qBAAqB,CAAC,IAAI,CAAC,CAAC;QAC/C,yEAAyE;QACzE,iEAAiE;QACjE,MAAM,MAAM,GAAG,IAAI,CAAC,GAAG;YACrB,CAAC,CAAC,MAAM,KAAK,CAAC,sBAAsB,EAAE,CAAC,IAAI,CAAC,GAAG,CAAC;YAChD,CAAC,CAAC,MAAM,KAAK,CAAC,sBAAsB,EAAE,CAAC,IAAI,CAAC,KAAK,EAAE;gBAC/C,YAAY,EAAE,IAAI,CAAC,aAAa,CAAC,YAAY;aAC9C,CAAC,CAAC;QACP,aAAa,GAAG,MAAM,CAAC,CAAC,CAAC,MAAM,oBAAoB,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC;QACxE,IAAI,CAAC,QAAQ,GAAG,MAAM,oBAAoB,CACxC,IAAI,CAAC,QAAe,EACpB,IAAI,CAAC,KAAK,EACV,aAAa,CACd,CAAC;IACJ,CAAC;IACD,OAAO,EAAE,IAAI,EAAE,aAAa,EAAE,CAAC;AACjC,CAAC;AAED;;;;;;;;;GASG;AACH,MAAM,CAAC,KAAK,UAAU,cAAc,CAAC,KAAa;IAChD,MAAM,EAAE,IAAI,EAAE,GAAG,MAAM,qBAAqB,CAAC,KAAK,CAAC,CAAC;IACpD,OAAO,IAAI,CAAC;AACd,CAAC;AAaD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4CG;AACH,MAAM,CAAC,KAAK,UAAU,UAAU,CAC9B,WAA0B,EAC1B,OAAU,EACV,qBAAkC;IAElC,wEAAwE;IACxE,wEAAwE;IACxE,2EAA2E;IAC3E,yEAAyE;IACzE,wEAAwE;IACxE,sEAAsE;IACtE,6EAA6E;IAC7E,kEAAkE;IAClE,uBAAuB;IACvB,EAAE;IACF,6EAA6E;IAC7E,0EAA0E;IAC1E,OAAO,cAAc,CACnB,WAAW,EACX,OAAO,EACP,qBAAqB,EACrB,KAAK,EACL,IAAI,CAAC,GAAG,EAAE,CACX,CAAC;AACJ,CAAC;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,KAAK,UAAU,cAAc,CAC3B,WAA0B,EAC1B,OAAU,EACV,qBAA6C,EAC7C,mBAA4B,EAC5B,mBAA2B;IAE3B,OAAO,MAAM,WAAW,CAAC,GAAG,EAAE;QAC5B,OAAO,KAAK,CAAC,aAAa,EAAE,KAAK,EAAE,IAAI,EAAE,EAAE;YACzC,MAAM,KAAK,GAAG,MAAM,YAAY,EAAE,CAAC;YAEnC,IAAI,CAAC;gBACH,MAAM,aAAa,GAAG,OAAO,WAAW,KAAK,QAAQ,CAAC;gBACtD,MAAM,IAAI,GAAS,aAAa;oBAC9B,CAAC,CAAC,MAAM,KAAK,CAAC,KAAK,CAAC,UAAU,CAAC,WAAW,CAAC;oBAC3C,CAAC,CAAC,WAAW,CAAC;gBAChB,sEAAsE;gBACtE,oEAAoE;gBACpE,MAAM,8BAA8B,GAClC,aAAa,IAAI,mBAAmB,CAAC;gBAEvC,MAAM,IAAI,GAAG,MAAM,qBAAqB,CAAC,IAAI,CAAC,CAAC;gBAC/C,MAAM,EAAE,aAAa,EAAE,GAAG,IAAI,CAAC;gBAE/B,IAAI,EAAE,aAAa,CAAC;oBAClB,GAAG,SAAS,CAAC,SAAS,CAAC,IAAI,CAAC,KAAK,CAAC;oBAClC,GAAG,SAAS,CAAC,MAAM,CAAC,IAAI,CAAC,MAAM,CAAC;oBAChC,GAAG,SAAS,CAAC,aAAa,CAAC,IAAI,CAAC,KAAK,CAAC;oBACtC,qCAAqC,EAAE,IAAI,CAAC,MAAM;iBACnD,CAAC,CAAC;gBAEH,mEAAmE;gBACnE,+DAA+D;gBAC/D,uEAAuE;gBACvE,qEAAqE;gBACrE,uEAAuE;gBACvE,gEAAgE;gBAChE,IAAI,IAAI,CAAC,GAAG,IAAI,2BAA2B,CAAC,IAAI,CAAC,GAAG,CAAC,MAAM,CAAC,EAAE,CAAC;oBAC7D,MAAM,IAAI,iBAAiB,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;gBAC1C,CAAC;gBAED,8DAA8D;gBAC9D,oEAAoE;gBACpE,iEAAiE;gBACjE,2DAA2D;gBAC3D,iEAAiE;gBACjE,MAAM,YAAY,GAAG,kBAAkB,CACrC,aAAa,CAAC,mBAAmB,CAClC,CAAC;gBAEF,mEAAmE;gBACnE,EAAE;gBACF,uEAAuE;gBACvE,sEAAsE;gBACtE,oEAAoE;gBACpE,kEAAkE;gBAClE,mEAAmE;gBACnE,gDAAgD;gBAChD,EAAE;gBACF,oEAAoE;gBACpE,iEAAiE;gBACjE,uDAAuD;gBACvD,EAAE;gBACF,oEAAoE;gBACpE,wEAAwE;gBACxE,iEAAiE;gBACjE,sEAAsE;gBACtE,wEAAwE;gBACxE,iEAAiE;gBACjE,kBAAkB;gBAClB,IAAI,UAAkC,CAAC;gBACvC,MAAM,YAAY,GAAG,qBAAqB;oBACxC,CAAC,CAAC,gEAAgE;wBAChE,8DAA8D;wBAC9D,4CAA4C;wBAC5C,SAAS;oBACX,CAAC,CAAC,kBAAkB,CAAC,aAAa,CAAC,mBAAmB,CAAC,CAAC;gBAE1D,IAAI,YAAY,EAAE,CAAC;oBACjB,UAAU,GAAG,MAAM,CAAC,YAAY,CAAC,CAAC;gBACpC,CAAC;qBAAM,CAAC;oBACN,0DAA0D;oBAC1D,6DAA6D;oBAC7D,4BAA4B;oBAC5B,IAAI,aAAa,GACf,qBAAqB;wBACrB,CAAC,MAAM,wBAAwB,CAAC,IAAI,EAAE,IAAI,CAAC,CAAC,CAAC;oBAC/C,IACE,CAAC,YAAY,CAAC,gBAAgB,CAAC,GAAG,CAAC,mBAAmB,CAAC,SAAS,CAAC,EACjE,CAAC;wBACD,aAAa,GAAG,SAAS,CAAC;oBAC5B,CAAC;oBACD,UAAU,GAAG,aAAa,CAAC;gBAC7B,CAAC;gBAED,mEAAmE;gBACnE,sDAAsD;gBACtD,MAAM,WAAW,GACf,CAAC,aAAa,CAAC,cAAc,IAAI,CAAC,CAAC;oBACjC,iCAAiC;oBACnC,YAAY,CAAC,gBAAgB,CAAC,GAAG,CAAC,mBAAmB,CAAC,IAAI,CAAC,CAAC;gBAE9D,oCAAoC;gBACpC,MAAM,GAAG,GAAmB,EAAE,CAAC;gBAC/B,MAAM,WAAW,GAAmB,EAAE,CAAC;gBACvC,MAAM,QAAQ,GAAG,mBAAmB,CAAC,IAAI,CAAC,WAAW,CAAC,CAAC;gBACvD,MAAM,iBAAiB,GAAG,MAAM,wBAAwB,CACtD,OAAO,EACP,IAAI,CAAC,KAAK,EACV,UAAU,EACV,GAAG,EACH,UAAU,EACV,QAAQ,EACR,YAAY,CAAC,iBAAiB,EAC9B,WAAW,EACX,SAAS,EACT,WAAW,CACZ,CAAC;gBACF,sEAAsE;gBACtE,kEAAkE;gBAClE,gEAAgE;gBAChE,uEAAuE;gBACvE,sEAAsE;gBACtE,iEAAiE;gBACjE,mEAAmE;gBACnE,EAAE;gBACF,sEAAsE;gBACtE,oEAAoE;gBACpE,uDAAuD;gBACvD,MAAM,OAAO,CAAC,GAAG,CACf,GAAG,CAAC,GAAG,CAAC,CAAC,EAAE,EAAE,EAAE,CACb,EAAE,CAAC,KAAK,CAAC,CAAC,KAAK,EAAE,EAAE;oBACjB,IAAI,KAAK,KAAK,SAAS;wBAAE,MAAM,KAAK,CAAC;gBACvC,CAAC,CAAC,CACH,CACF,CAAC;gBACF,uEAAuE;gBACvE,uEAAuE;gBACvE,wDAAwD;gBACxD,aAAa,CAAC,OAAO,CAAC,GAAG,CAAC,WAAW,CAAC,EAAE,CAAC,GAAG,EAAE,EAAE;oBAC9C,IAAI,GAAG,KAAK,SAAS;wBAAE,OAAO;oBAC9B,aAAa,CAAC,IAAI,CAAC,4CAA4C,EAAE;wBAC/D,aAAa,EAAE,IAAI,CAAC,KAAK;wBACzB,MAAM,EAAE,IAAI,CAAC,MAAM;wBACnB,KAAK,EAAE,GAAG,YAAY,KAAK,CAAC,CAAC,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC,CAAC,MAAM,CAAC,GAAG,CAAC;qBACxD,CAAC,CAAC;gBACL,CAAC,CAAC,CAAC;gBAEH,IAAI,EAAE,aAAa,CAAC;oBAClB,GAAG,SAAS,CAAC,YAAY,CAAC,aAAa,CAAC,YAAY,CAAC;iBACtD,CAAC,CAAC;gBAEH,+DAA+D;gBAC/D,oEAAoE;gBACpE,4DAA4D;gBAC5D,MAAM,UAAU,GAAG,MAAM,kBAAkB,CAAC,aAAa,CAAC,YAAY,CAAC,CAAC;gBACxE,IAAI,UAAU,EAAE,CAAC;oBACf,IAAI,EAAE,OAAO,EAAE,CAAC,UAAU,CAAC,CAAC;gBAC9B,CAAC;gBAED,MAAM,SAAS,GAAG,oBAAoB,CAAC,aAAa,CAAC,YAAY,CAAC,CAAC;gBACnE,MAAM,YAAY,GAAG;oBACnB,YAAY,EAAE,aAAa,CAAC,YAAY;oBACxC,WAAW,EAAE,aAAa,CAAC,cAAc,IAAI,mBAAmB;iBACjE,CAAC;gBAEF,mEAAmE;gBACnE,mEAAmE;gBACnE,oEAAoE;gBACpE,qEAAqE;gBACrE,uEAAuE;gBACvE,qEAAqE;gBACrE,+BAA+B;gBAC/B,EAAE;gBACF,mEAAmE;gBACnE,uEAAuE;gBACvE,sEAAsE;gBACtE,sEAAsE;gBACtE,oEAAoE;gBACpE,uEAAuE;gBACvE,qEAAqE;gBACrE,kEAAkE;gBAClE,mCAAmC;gBACnC,MAAM,qBAAqB,GACzB,CAAC,8BAA8B;oBAC7B,CAAC,CAAC,CAAC,IAAI,CAAC,kBAAkB,EAAE,sBAAsB,IAAI,CAAC,CAAC;oBACxD,CAAC,CAAC,CAAC,CAAC,IAAI,yBAAyB;oBACnC,KAAK,CAAC,YAAY,EAAE,eAAe,KAAK,IAAI,CAAC;gBAC/C,MAAM,cAAc,GAClB,qBAAqB;oBACrB,CAAC,QAAQ;oBACT,iBAAiB,YAAY,UAAU,CAAC;gBAE1C,IAAI,EAAE,aAAa,CAAC;oBAClB,+BAA+B,EAAE,YAAY;iBAC9C,CAAC,CAAC;gBAEH,MAAM,QAAQ,GAAG,cAAc,CAAC,CAAC,CAAC,gBAAgB,EAAE,CAAC,CAAC,CAAC,SAAS,CAAC;gBACjE,MAAM,aAAa,GAAG,cAAc;oBAClC,CAAC,CAAC,MAAM,0BAA0B,CAAC,iBAAiB,CAAC;oBACrD,CAAC,CAAC,SAAS,CAAC;gBACd,IAAI,QAAQ,EAAE,CAAC;oBACb,IAAI,EAAE,aAAa,CAAC,EAAE,yBAAyB,EAAE,QAAQ,EAAE,CAAC,CAAC;gBAC/D,CAAC;gBAED,2DAA2D;gBAC3D,mEAAmE;gBACnE,qDAAqD;gBACrD,mEAAmE;gBACnE,0CAA0C;gBAC1C,qEAAqE;gBACrE,8CAA8C;gBAC9C,kEAAkE;gBAClE,uBAAuB;gBACvB,EAAE;gBACF,kEAAkE;gBAClE,oEAAoE;gBACpE,sEAAsE;gBACtE,qEAAqE;gBACrE,oEAAoE;gBACpE,qEAAqE;gBACrE,qEAAqE;gBACrE,oEAAoE;gBACpE,oEAAoE;gBACpE,qEAAqE;gBACrE,sDAAsD;gBACtD,MAAM,eAAe,GAAG,CAAC,GAAY,EAAW,EAAE,CAChD,iBAAiB,CAAC,EAAE,CAAC,GAAG,CAAC,IAAI,eAAe,CAAC,EAAE,CAAC,GAAG,CAAC,CAAC;gBACvD,IAAI,CAAC;oBACH,MAAM,KAAK,CAAC,MAAM,CAAC,MAAM,CACvB,IAAI,CAAC,KAAK,EACV;wBACE,SAAS,EAAE,eAAe;wBAC1B,WAAW,EAAE,oBAAoB;wBACjC,aAAa,EAAE,IAAI,CAAC,MAAM;wBAC1B,SAAS,EAAE;4BACT,GAAG,CAAC,QAAQ,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,KAAK,EAAE,IAAI,CAAC,KAAK,EAAE,CAAC;4BAC1C,OAAO,EAAE,iBAAiB;yBAC3B;qBACF,EACD;wBACE,QAAQ;wBACR,GAAG,CAAC,QAAQ,IAAI,aAAa;4BAC3B,CAAC,CAAC,EAAE,QAAQ,EAAE,mBAAmB,EAAE,aAAa,EAAE;4BAClD,CAAC,CAAC,EAAE,CAAC;qBACR,CACF,CAAC;gBACJ,CAAC;gBAAC,OAAO,GAAG,EAAE,CAAC;oBACb,IAAI,eAAe,CAAC,GAAG,CAAC,EAAE,CAAC;wBACzB,MAAM,IAAI,iBAAiB,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;oBAC1C,CAAC;oBACD,MAAM,GAAG,CAAC;gBACZ,CAAC;gBACD,sEAAsE;gBACtE,2DAA2D;gBAC3D,oEAAoE;gBACpE,qEAAqE;gBACrE,qEAAqE;gBACrE,IAAI,EAAE,aAAa,CAAC,SAAS,CAAC,mBAAmB,CAAC,IAAI,CAAC,CAAC,CAAC;gBAEzD,kEAAkE;gBAClE,qEAAqE;gBACrE,kEAAkE;gBAClE,mCAAmC;gBACnC,MAAM,yBAAyB,GAAG,IAAI,CAAC,GAAG,EAAE,CAAC;gBAC7C,MAAM,wBAAwB,CAC5B,GAAG,EAAE,CACH,KAAK,CAAC,KAAK,CACT,SAAS,EACT;oBACE,KAAK,EAAE,IAAI,CAAC,KAAK;oBACjB,YAAY,EAAE,aAAa,CAAC,YAAY,IAAI,SAAS;oBACrD,gBAAgB,EAAE;wBAChB,mBAAmB;wBACnB,yBAAyB;wBACzB,QAAQ,EAAE,YAAY;qBACvB;iBAC8B,EACjC;oBACE,GAAG,YAAY;oBACf,qDAAqD;oBACrD,4DAA4D;oBAC5D,4DAA4D;oBAC5D,4DAA4D;oBAC5D,0DAA0D;oBAC1D,8BAA8B;oBAC9B,GAAG,CAAC,QAAQ,CAAC,CAAC,CAAC,EAAE,cAAc,EAAE,QAAQ,QAAQ,EAAE,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;iBAC5D,CACF,EACH,KAAK,CAAC,4BAA4B,EAAE,IAAI,CAAC,KAAK,CAAC,CAChD,CAAC;gBACF,IAAI,EAAE,aAAa,CAAC,SAAS,CAAC,iBAAiB,CAAC,IAAI,CAAC,CAAC,CAAC;gBAEvD,OAAO,IAA0B,CAAC;YACpC,CAAC;YAAC,OAAO,GAAG,EAAE,CAAC;gBACb,IAAI,EAAE,aAAa,CAAC;oBAClB,GAAG,SAAS,CAAC,SAAS,CACpB,OAAO,WAAW,KAAK,QAAQ,CAAC,CAAC,CAAC,WAAW,CAAC,CAAC,CAAC,WAAW,CAAC,KAAK,CAClE;oBACD,GAAG,SAAS,CAAC,SAAS,CAAC,KAAK,CAAC;iBAC9B,CAAC,CAAC;gBACH,MAAM,GAAG,CAAC;YACZ,CAAC;QACH,CAAC,CAAC,CAAC;IACL,CAAC,CAAC,CAAC;AACL,CAAC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AACH,MAAM,CAAC,KAAK,UAAU,aAAa,CACjC,KAAa,EACb,OAAgB;IAEhB,2EAA2E;IAC3E,yEAAyE;IACzE,0EAA0E;IAC1E,4EAA4E;IAC5E,4EAA4E;IAC5E,MAAM,mBAAmB,GAAG,IAAI,CAAC,GAAG,EAAE,CAAC;IACvC,MAAM,EAAE,IAAI,EAAE,aAAa,EAAE,GAAG,MAAM,qBAAqB,CAAC,KAAK,CAAC,CAAC;IAEnE,wDAAwD;IACxD,iEAAiE;IACjE,uEAAuE;IACvE,wDAAwD;IACxD,IAAI,IAAI,CAAC,SAAS,KAAK,KAAK,EAAE,CAAC;QAC7B,MAAM,IAAI,iBAAiB,CAAC,KAAK,CAAC,CAAC;IACrC,CAAC;IAED,IAAI,QAA8B,CAAC;IACnC,IAAI,gBAAsD,CAAC;IAC3D,IACE,IAAI,CAAC,QAAQ;QACb,OAAO,IAAI,CAAC,QAAQ,KAAK,QAAQ;QACjC,aAAa,IAAI,IAAI,CAAC,QAAQ,EAC9B,CAAC;QACD,IAAI,IAAI,CAAC,QAAQ,CAAC,WAAW,KAAK,QAAQ,EAAE,CAAC;YAC3C,MAAM,EAAE,QAAQ,EAAE,QAAQ,EAAE,GAAG,IAAI,eAAe,EAAsB,CAAC;YACzE,gBAAgB,GAAG,QAAQ,CAAC;YAE5B,uEAAuE;YACvE,mEAAmE;YAClE,OAAe,CAAC,yBAAyB,CAAC,GAAG,QAAQ,CAAC;QACzD,CAAC;aAAM,IAAI,IAAI,CAAC,QAAQ,CAAC,WAAW,YAAY,QAAQ,EAAE,CAAC;YACzD,QAAQ,GAAG,IAAI,CAAC,QAAQ,CAAC,WAAW,CAAC;QACvC,CAAC;aAAM,CAAC;YACN,MAAM,IAAI,oBAAoB,CAC5B,kCAAkC,IAAI,CAAC,QAAQ,CAAC,WAAW,EAAE,EAC7D,EAAE,IAAI,EAAE,WAAW,CAAC,kCAAkC,EAAE,CACzD,CAAC;QACJ,CAAC;IACH,CAAC;SAAM,CAAC;QACN,yEAAyE;QACzE,QAAQ,GAAG,IAAI,QAAQ,CAAC,IAAI,EAAE,EAAE,MAAM,EAAE,GAAG,EAAE,CAAC,CAAC;IACjD,CAAC;IAED,wEAAwE;IACxE,6EAA6E;IAC7E,0EAA0E;IAC1E,2EAA2E;IAC3E,qEAAqE;IACrE,MAAM,cAAc,CAAC,IAAI,EAAE,OAAO,EAAE,aAAa,EAAE,IAAI,EAAE,mBAAmB,CAAC,CAAC;IAE9E,IAAI,gBAAgB,EAAE,CAAC;QACrB,kDAAkD;QAClD,iCAAiC;QACjC,MAAM,MAAM,GAAG,gBAAgB,CAAC,SAAS,EAAE,CAAC;QAC5C,MAAM,KAAK,GAAG,MAAM,MAAM,CAAC,IAAI,EAAE,CAAC;QAClC,IAAI,KAAK,CAAC,KAAK,EAAE,CAAC;YAChB,QAAQ,GAAG,KAAK,CAAC,KAAK,CAAC;QACzB,CAAC;QACD,MAAM,CAAC,MAAM,EAAE,CAAC;IAClB,CAAC;IAED,IAAI,CAAC,QAAQ,EAAE,CAAC;QACd,MAAM,IAAI,oBAAoB,CAAC,sCAAsC,EAAE;YACrE,IAAI,EAAE,WAAW,CAAC,yBAAyB;SAC5C,CAAC,CAAC;IACL,CAAC;IAED,OAAO,QAAQ,CAAC;AAClB,CAAC","sourcesContent":["import {\n  ERROR_SLUGS,\n  HookNotFoundError,\n  RunExpiredError,\n  WorkflowRuntimeError,\n} from '@workflow/errors';\nimport {\n  HOOK_RESUME_DEDUP_VERSION,\n  type Hook,\n  type HookResumeContext,\n  isLegacySpecVersion,\n  isTerminalWorkflowRunStatus,\n  SPEC_VERSION_CURRENT,\n  SPEC_VERSION_LEGACY,\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 { 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 * Hex SHA-256 of the serialized resume payload bytes. Computed once by the\n * producer and sent with its durable `hook_received` write so transport and\n * slot retries converge through the server's `(runId, resumeId)` constraint.\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\nconst HOOK_WAKE_RETRY_DELAYS_MS = [25, 100] as const;\n\n/**\n * A wake failure worth retrying is transport-shaped (network error, 5xx,\n * throttle). A definitive rejection will not change on a 25ms retry, so\n * spending the budget on it only delays the caller's error.\n *\n * `@vercel/queue` errors carry no `status` field — they are bare `Error`\n * subclasses distinguished by `name` — so classification checks the World's\n * deployment-unavailable hook first (a deployment the queue cannot discover\n * will not come back within this function's ~125ms budget), then a numeric\n * status when one exists (non-Vercel queue implementations), then the queue\n * client's definitive-4xx error names.\n */\nfunction isRetryableWakeError(\n  error: unknown,\n  isDeploymentUnavailableError?: (error: unknown) => boolean\n): boolean {\n  if (isDeploymentUnavailableError?.(error)) return false;\n  const status = (error as { status?: unknown; statusCode?: unknown }) ?? {};\n  const code = status.status ?? status.statusCode;\n  if (typeof code === 'number') {\n    return code >= 500 || code === 408 || code === 429;\n  }\n  const name = (error as Error | null)?.name;\n  return (\n    name !== 'BadRequestError' &&\n    name !== 'UnauthorizedError' &&\n    name !== 'ForbiddenError'\n  );\n}\n\n// A publish may succeed even when its response is lost, so a retry can\n// enqueue a duplicate wake. That is harmless: the event is already durable,\n// and deterministic replay makes a second delivery of the same run a no-op.\nasync function publishHookWakeWithRetry(\n  publish: () => Promise<unknown>,\n  isDeploymentUnavailableError?: (error: unknown) => boolean\n): Promise<void> {\n  let lastError: unknown;\n  for (\n    let attempt = 0;\n    attempt <= HOOK_WAKE_RETRY_DELAYS_MS.length;\n    attempt++\n  ) {\n    try {\n      await publish();\n      return;\n    } catch (error) {\n      lastError = error;\n      if (!isRetryableWakeError(error, isDeploymentUnavailableError)) break;\n      const delayMs = HOOK_WAKE_RETRY_DELAYS_MS[attempt];\n      if (delayMs !== undefined) {\n        await new Promise((resolve) => setTimeout(resolve, delayMs));\n      }\n    }\n  }\n\n  // The wake only runs after the hook_received write committed, so a wake\n  // failure here is necessarily \"durable but not yet dispatched\": the event\n  // survives, and any later wake of the run delivers it. Do not let a queue\n  // implementation reuse HookNotFoundError and accidentally imply that no\n  // hook_received exists.\n  if (HookNotFoundError.is(lastError)) {\n    throw new WorkflowRuntimeError(\n      'The hook resume was committed, but its workflow wake could not be published',\n      { cause: lastError }\n    );\n  }\n  throw lastError;\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 * `resilientResume` is retained for source compatibility and is never set.\n * `resumeHook()` now requires the durable `hook_received` write and workflow\n * wake to both succeed before it resolves. Treat the result as a plain\n * {@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 * Resolving means BOTH that the `hook_received` event is durably recorded in\n * the run's event log and that the workflow wake was accepted by the queue, in\n * that order. A {@link HookNotFoundError} means this invocation committed no\n * event. Any other error after the write is ambiguous only in dispatch, never\n * in durability: the event may already be committed, and a later wake of the\n * run (from any source) will deliver it.\n *\n * Prefer passing the token string over a cached {@link Hook} object. A token\n * is looked up fresh, so the live backend can attest its atomic resume claim\n * and the durable write becomes idempotent-on-retry (transport retries of the\n * same write converge on one event). A supplied Hook object may carry a stale\n * attestation, so it is deliberately ignored and the write is claim-less —\n * meaning a lost response cannot be retried safely: retrying at the\n * application level mints a fresh claim and can commit a second\n * `hook_received`.\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 a plain, claim-less write. Only `resumeWebhook`, which\n  // fetches the hook by token in-line during the same resume, reaches the\n  // internal implementation with the fresh attestation set. Keeping the\n  // freshness flag off the exported signature prevents a caller from passing a\n  // stale Hook plus `true` and reactivating dynamic dedup against a\n  // rolled-back backend.\n  //\n  // T0 of the hook-resume TTR window is taken HERE, at the public entry point,\n  // rather than inside the implementation; see the parameter's doc comment.\n  return resumeHookImpl(\n    tokenOrHook,\n    payload,\n    encryptionKeyOverride,\n    false,\n    Date.now()\n  );\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 * @param resumeRequestedAtMs - T0 of the hook-resume TTR window (see\n *   runtime/resume-latency.ts), stamped by the PUBLIC entry point the caller\n *   used. It is a parameter rather than a local because `resumeWebhook` does\n *   real work before it gets here (the by-token lookup, the run-key\n *   resolution that hydrates hook metadata, and the `respondWith` setup) and\n *   stamping locally would silently exclude all of it, so the two entry points\n *   would report the same metric over different windows.\n */\nasync function resumeHookImpl<T = any>(\n  tokenOrHook: string | Hook,\n  payload: T,\n  encryptionKeyOverride: PayloadKey | undefined,\n  hookFreshlyLookedUp: boolean,\n  resumeRequestedAtMs: number\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 readbackOps: 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          undefined,\n          readbackOps\n        );\n        // A hook_received event is not durable while its payload still points\n        // at stream uploads in flight. Finish those before committing the\n        // event — but ONLY the producer-push ops in `ops`. A dehydrated\n        // WritableStream lands in `readbackOps` instead: it is a server-stream\n        // READER that resolves only once the woken workflow writes into it (a\n        // manual webhook's `responseWritable` is the canonical case), so\n        // awaiting it here would deadlock the resume against its own wake.\n        //\n        // A rejection with `undefined` is an expected artifact of the webhook\n        // bundle and was historically ignored by the background flush. Keep\n        // that tolerance now that the flush is awaited inline.\n        await Promise.all(\n          ops.map((op) =>\n            op.catch((error) => {\n              if (error !== undefined) throw error;\n            })\n          )\n        );\n        // Readback pipes (notably a manual webhook response writable) can only\n        // finish after the workflow wakes and writes to them. Keep them alive,\n        // but never place them in the durability barrier above.\n        safeWaitUntil(Promise.all(readbackOps), (err) => {\n          if (err === undefined) return;\n          runtimeLogger.warn('Background readback of hook payload 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 the\n        // write and the wake both sit under a span that carries it.\n        const originLink = await linkToTraceCarrier(resumeContext.traceCarrier);\n        if (originLink) {\n          span?.addLink?.(originLink);\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        // The dispatch is strictly serial: the hook_received event is made\n        // durable FIRST, and the workflow wake is published only after the\n        // write is acknowledged. This is what lets `resumeHook()` resolving\n        // mean \"the resume survives anything that happens next\" — a disposal\n        // or run completion racing the queue delivery cannot erase a committed\n        // event, and the wake itself carries no payload, so nothing rides on\n        // the message but the trigger.\n        //\n        // Backend dedup is attested 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). When attested, the write carries a per-call resumeId +\n        // payload digest so transport-level retries of the SAME write converge\n        // on exactly one committed event via the backend's (runId, resumeId)\n        // constraint. Without it the write is a plain single-shot create,\n        // exactly as before dedup existed.\n        const backendDedupSupported =\n          (hookResumeCapabilitiesAreFresh\n            ? (hook.resumeCapabilities?.hookResumeDedupVersion ?? 0)\n            : 0) >= HOOK_RESUME_DEDUP_VERSION ||\n          world.capabilities?.hookResumeDedup === true;\n        const canClaimResume =\n          backendDedupSupported &&\n          !v1Compat &&\n          dehydratedPayload instanceof Uint8Array;\n\n        span?.setAttributes({\n          'workflow.hook.resume_strategy': 'sequential',\n        });\n\n        const resumeId = canClaimResume ? generateResumeId() : undefined;\n        const payloadDigest = canClaimResume\n          ? await computeResumePayloadDigest(dehydratedPayload)\n          : undefined;\n        if (resumeId) {\n          span?.setAttributes({ 'workflow.hook.resume_id': resumeId });\n        }\n\n        // Re-key any \"hook can no longer be received\" rejection to\n        // HookNotFoundError(hook.token) so `.token` matches the historical\n        // contract. The specific error depends on the World:\n        //   - a genuinely missing hook maps to HookNotFoundError (keyed on\n        //     the 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        // An EntityConflictError (HTTP 409) is deliberately NOT re-keyed,\n        // breaking with the historical mapping: every 409 the backend emits\n        // on this write today is TRANSIENT — a slot conflict that escaped the\n        // server's own retry budget under contention, or a resume-claim race\n        // mid-resolution — and its transaction committed nothing. Re-keying\n        // it to HookNotFoundError told the caller (and a webhook sender, via\n        // 404) that a retryable failure was permanent, silently dropping the\n        // resume. It now surfaces as-is: retryable, with nothing committed.\n        // (A 422 resumeId-reuse error likewise passes through unmapped — it\n        // means the caller replayed a resumeId with a different payload, and\n        // hiding that behind \"not found\" would mask the bug.)\n        const isHookGoneError = (err: unknown): boolean =>\n          HookNotFoundError.is(err) || RunExpiredError.is(err);\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                ...(v1Compat ? {} : { token: hook.token }),\n                payload: dehydratedPayload,\n              },\n            },\n            {\n              v1Compat,\n              ...(resumeId && payloadDigest\n                ? { resumeId, resumePayloadDigest: payloadDigest }\n                : {}),\n            }\n          );\n        } catch (err) {\n          if (isHookGoneError(err)) {\n            throw new HookNotFoundError(hook.token);\n          }\n          throw err;\n        }\n        // Stamped AFTER the write resolves (entry-time attributes cannot tell\n        // an attempted resume from a committed one): together with\n        // HookWakePublished below, this is what makes a stranded resume — a\n        // committed event whose wake never went out or was never delivered —\n        // queryable from traces. See the alerting note on HookWakePublished.\n        span?.setAttributes(Attribute.HookResumeCommitted(true));\n\n        // T1 of the TTR window. Stamped immediately before the publish so\n        // `producer_prep` covers exactly the work above it (hook lookup, key\n        // resolution, serialization, and the awaited hook_received write,\n        // which is genuinely serial here).\n        const queuePublishRequestedAtMs = Date.now();\n        await publishHookWakeWithRetry(\n          () =>\n            world.queue(\n              queueName,\n              {\n                runId: hook.runId,\n                traceCarrier: resumeContext.traceCarrier ?? undefined,\n                hookResumeTiming: {\n                  resumeRequestedAtMs,\n                  queuePublishRequestedAtMs,\n                  strategy: 'sequential',\n                },\n              } satisfies WorkflowInvokePayload,\n              {\n                ...queueOptions,\n                // Dedup retried publishes whose response was lost: a\n                // duplicate wake is harmless for correctness (deterministic\n                // replay) but costs a full replay of the run, and the queue\n                // accepts a repeated idempotency key by delivering only one\n                // of the messages. Claim-less writes have no resumeId and\n                // keep the previous behavior.\n                ...(resumeId ? { idempotencyKey: `hook-${resumeId}` } : {}),\n              }\n            ),\n          world.isDeploymentUnavailableError?.bind(world)\n        );\n        span?.setAttributes(Attribute.HookWakePublished(true));\n\n        return hook 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  // T0 of the hook-resume TTR window. Everything below (the by-token lookup,\n  // the run-key resolution it may trigger, and the `respondWith` setup) is\n  // real producer-side latency on this path, so the window has to open here\n  // and not inside `resumeHookImpl`; otherwise webhook resumes would report a\n  // systematically shorter total than `resumeHook` ones into the same metric.\n  const resumeRequestedAtMs = Date.now();\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 write's idempotency claim stays available without a second GET. (The\n  // public `resumeHook` never sets this, so a caller cannot forge it.)\n  await resumeHookImpl(hook, request, encryptionKey, true, resumeRequestedAtMs);\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  ERROR_SLUGS,\n  HookNotFoundError,\n  RunExpiredError,\n  WorkflowRuntimeError,\n} from '@workflow/errors';\nimport {\n  HOOK_RESUME_DEDUP_VERSION,\n  type HookResumeContext,\n  isLegacySpecVersion,\n  isTerminalWorkflowRunStatus,\n  SPEC_VERSION_CURRENT,\n  SPEC_VERSION_LEGACY,\n  SPEC_VERSION_SUPPORTS_COMPRESSION,\n  type WorkflowInvokePayload,\n  type WorkflowRun,\n  type Hook as WorldHook,\n} from '@workflow/world';\nimport { monotonicFactory } from 'ulid';\nimport { getRunCapabilities } from '../capabilities.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 * Hex SHA-256 of the serialized resume payload bytes. Computed once by the\n * producer and sent with its durable `hook_received` write so transport and\n * slot retries converge through the server's `(runId, resumeId)` constraint.\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\nconst HOOK_WAKE_RETRY_DELAYS_MS = [25, 100] as const;\n\n/**\n * A wake failure worth retrying is transport-shaped (network error, 5xx,\n * throttle). A definitive rejection will not change on a 25ms retry, so\n * spending the budget on it only delays the caller's error.\n *\n * `@vercel/queue` errors carry no `status` field — they are bare `Error`\n * subclasses distinguished by `name` — so classification checks the World's\n * deployment-unavailable hook first (a deployment the queue cannot discover\n * will not come back within this function's ~125ms budget), then a numeric\n * status when one exists (non-Vercel queue implementations), then the queue\n * client's definitive-4xx error names.\n */\nfunction isRetryableWakeError(\n  error: unknown,\n  isDeploymentUnavailableError?: (error: unknown) => boolean\n): boolean {\n  if (isDeploymentUnavailableError?.(error)) return false;\n  const status = (error as { status?: unknown; statusCode?: unknown }) ?? {};\n  const code = status.status ?? status.statusCode;\n  if (typeof code === 'number') {\n    return code >= 500 || code === 408 || code === 429;\n  }\n  const name = (error as Error | null)?.name;\n  return (\n    name !== 'BadRequestError' &&\n    name !== 'UnauthorizedError' &&\n    name !== 'ForbiddenError'\n  );\n}\n\n// A publish may succeed even when its response is lost, so a retry can\n// enqueue a duplicate wake. That is harmless: the event is already durable,\n// and deterministic replay makes a second delivery of the same run a no-op.\nasync function publishHookWakeWithRetry(\n  publish: () => Promise<unknown>,\n  isDeploymentUnavailableError?: (error: unknown) => boolean\n): Promise<void> {\n  let lastError: unknown;\n  for (\n    let attempt = 0;\n    attempt <= HOOK_WAKE_RETRY_DELAYS_MS.length;\n    attempt++\n  ) {\n    try {\n      await publish();\n      return;\n    } catch (error) {\n      lastError = error;\n      if (!isRetryableWakeError(error, isDeploymentUnavailableError)) break;\n      const delayMs = HOOK_WAKE_RETRY_DELAYS_MS[attempt];\n      if (delayMs !== undefined) {\n        await new Promise((resolve) => setTimeout(resolve, delayMs));\n      }\n    }\n  }\n\n  // The wake only runs after the hook_received write committed, so a wake\n  // failure here is necessarily \"durable but not yet dispatched\": the event\n  // survives, and any later wake of the run delivers it. Do not let a queue\n  // implementation reuse HookNotFoundError and accidentally imply that no\n  // hook_received exists.\n  if (HookNotFoundError.is(lastError)) {\n    throw new WorkflowRuntimeError(\n      'The hook resume was committed, but its workflow wake could not be published',\n      { cause: lastError }\n    );\n  }\n  throw lastError;\n}\n\n/**\n * A hook record with its serialized `metadata` omitted: everything a resume\n * actually reads. Resuming never looks at metadata, so the resume path accepts\n * both a raw {@link WorldHook} straight out of a World and a {@link Hook}\n * whose `metadata` is a Promise.\n */\ntype ResumableHook = Omit<WorldHook, 'metadata'>;\n\n/**\n * A hook as returned by {@link getHookByToken} and {@link resumeHook}: the\n * World's {@link WorldHook} record with its user-defined `metadata` hydrated\n * lazily.\n *\n * `metadata` is a getter that returns a Promise — the same shape as\n * `Run.returnValue` — so looking a hook up by token costs exactly one read.\n * Hydrating metadata is a decrypting READ that needs the owning run's payload\n * keys, and resolving those can cost a run fetch plus a `run-key` API round\n * trip (~350ms). Deferring that to first access keeps the lookup fast for the\n * many callers that only need `runId`/`token` — most importantly hook\n * resumption, which never reads metadata at all.\n *\n * The promise is memoized: hydration (and the key resolution behind it) runs at\n * most once per hook object. Awaiting it on a hook that stored no metadata\n * resolves `undefined` and performs no I/O.\n *\n * Like `Run.returnValue`, the accessor is non-enumerable, so it is absent from\n * `{ ...hook }` and `JSON.stringify(hook)` — read it explicitly and include the\n * awaited value if you need to forward it.\n *\n * @example\n *\n * ```ts\n * const hook = await getHookByToken(token);\n * console.log(hook.runId); // no metadata work\n * const metadata = (await hook.metadata) as { allowedUserId?: string } | undefined;\n * ```\n */\nexport interface Hook extends ResumableHook {\n  /**\n   * The hook's user-defined metadata, hydrated on first access and memoized.\n   * Resolves `undefined` when the hook carries no metadata.\n   */\n  readonly metadata: Promise<unknown>;\n}\n\n/**\n * A by-token hook lookup: the hook itself plus access to the payload keys that\n * hydrating its `metadata` resolved, if anything ever awaited it.\n */\ninterface HookLookup {\n  hook: Hook;\n  /**\n   * The read-side payload keys resolved while hydrating `metadata`, or\n   * `undefined` when `metadata` was never awaited, the hook stored none, or the\n   * run has no key (encryption disabled). Lets `resumeWebhook` — the one caller\n   * that must read metadata — reuse that key for the payload WRITE instead of\n   * paying a second `run-key` round trip. Only meaningful after awaiting\n   * `hook.metadata`.\n   */\n  metadataEncryptionKey(): PayloadKey | undefined;\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(\n  hook: ResumableHook\n): 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: ResumableHook,\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\n/** Whether `metadata` on this record is already the lazy Promise accessor. */\nfunction hasLazyMetadata(hook: ResumableHook): boolean {\n  const descriptor = Object.getOwnPropertyDescriptor(hook, 'metadata');\n  return descriptor !== undefined && typeof descriptor.get === 'function';\n}\n\n/**\n * Wraps a raw hook record from a World in a {@link Hook},\n * replacing its serialized `metadata` with a memoized Promise getter that\n * hydrates on first access.\n *\n * Nothing here touches the network: the wrap is a property definition. All of\n * the cost — resolving the run's payload keys and decrypting — moves inside the\n * getter, so a lookup that never reads metadata pays for exactly one\n * `hooks.getByToken`.\n *\n * The getter is defined in place on the record the World returned (the same\n * object the eager path used to mutate), so no copy is made.\n */\nfunction withLazyMetadata(raw: WorldHook): HookLookup {\n  const serialized = raw.metadata;\n  let hydrated: Promise<unknown> | undefined;\n  let encryptionKey: PayloadKey | undefined;\n\n  // Hydrating metadata is a decrypting READ, so it derives the full\n  // RunPayloadKeys (which open sealed `encp` metadata, not just symmetric\n  // `encr`) rather than the bare write key the resume path uses.\n  const hydrate = async (): Promise<unknown> => {\n    const world = await getWorldLazy();\n    const info = await resolveHookResumeInfo(raw);\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?.(raw.runId, {\n          deploymentId: info.resumeContext.deploymentId,\n        });\n    encryptionKey = rawKey ? await deriveRunPayloadKeys(rawKey) : undefined;\n    return await hydrateStepArguments(\n      serialized as any,\n      raw.runId,\n      encryptionKey\n    );\n  };\n\n  const hook = raw as unknown as Hook;\n  Object.defineProperty(hook, 'metadata', {\n    // A hook with no metadata resolves `undefined` without any I/O, so callers\n    // can await unconditionally. Memoized either way: metadata is fixed at\n    // hook-creation time, so hydration runs at most once per hook object.\n    get: () =>\n      (hydrated ??=\n        typeof serialized === 'undefined'\n          ? Promise.resolve(undefined)\n          : hydrate()),\n    // Non-enumerable, matching `Run.returnValue` (a prototype getter, so it is\n    // absent from an instance's own keys). Spreading or `JSON.stringify`-ing a\n    // hook therefore cannot trigger hydration nobody asked for — which would\n    // otherwise leave a floating rejection when the run key is unreachable, and\n    // an unconsumed rejected Promise crashes Node as an unhandledRejection.\n    enumerable: false,\n    configurable: true,\n  });\n\n  return { hook, metadataEncryptionKey: () => encryptionKey };\n}\n\n/**\n * Normalizes any hook record the resume path accepted into a\n * {@link Hook} to return to the caller. Idempotent: a hook that\n * already carries the lazy accessor (one that came from `getHookByToken`) is\n * returned as-is rather than double-wrapped, which would hand\n * `hydrateStepArguments` a Promise.\n */\nfunction asLazyMetadataHook(hook: ResumableHook): Hook {\n  return hasLazyMetadata(hook)\n    ? (hook as Hook)\n    : withLazyMetadata(hook as WorldHook).hook;\n}\n\n/**\n * Get the hook by token to find the associated workflow run.\n *\n * This is a single read. The returned hook's `metadata` is a getter that\n * resolves a Promise (see {@link Hook}), so the run fetch and\n * `run-key` round trip that hydrating it can require are only paid by callers\n * that actually await it:\n *\n * ```ts\n * const hook = await getHookByToken(token);\n * const metadata = await hook.metadata;\n * ```\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 world = await getWorldLazy();\n  return withLazyMetadata(await world.hooks.getByToken(token)).hook;\n}\n\n/**\n * The result of {@link resumeHook}: a {@link Hook} augmented\n * with an optional resilience signal.\n *\n * `resilientResume` is retained for source compatibility and is never set.\n * `resumeHook()` now requires the durable `hook_received` write and workflow\n * wake to both succeed before it resolves. Treat the result as a plain\n * {@link Hook}.\n */\nexport type ResumedHook = Hook & {\n  resilientResume?: boolean;\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 * Resolving means BOTH that the `hook_received` event is durably recorded in\n * the run's event log and that the workflow wake was accepted by the queue, in\n * that order. A {@link HookNotFoundError} means this invocation committed no\n * event. Any other error after the write is ambiguous only in dispatch, never\n * in durability: the event may already be committed, and a later wake of the\n * run (from any source) will deliver it.\n *\n * Prefer passing the token string over a cached {@link Hook} object. A token\n * is looked up fresh, so the live backend can attest its atomic resume claim\n * and the durable write becomes idempotent-on-retry (transport retries of the\n * same write converge on one event). A supplied Hook object may carry a stale\n * attestation, so it is deliberately ignored and the write is claim-less —\n * meaning a lost response cannot be retried safely: retrying at the\n * application level mints a fresh claim and can commit a second\n * `hook_received`.\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 | ResumableHook,\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 a plain, claim-less write. Only `resumeWebhook`, which\n  // fetches the hook by token in-line during the same resume, reaches the\n  // internal implementation with the fresh attestation set. Keeping the\n  // freshness flag off the exported signature prevents a caller from passing a\n  // stale Hook plus `true` and reactivating dynamic dedup against a\n  // rolled-back backend.\n  //\n  // T0 of the hook-resume TTR window is taken HERE, at the public entry point,\n  // rather than inside the implementation; see the parameter's doc comment.\n  return resumeHookImpl(\n    tokenOrHook,\n    payload,\n    encryptionKeyOverride,\n    false,\n    Date.now()\n  );\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 * @param resumeRequestedAtMs - T0 of the hook-resume TTR window (see\n *   runtime/resume-latency.ts), stamped by the PUBLIC entry point the caller\n *   used. It is a parameter rather than a local because `resumeWebhook` does\n *   real work before it gets here (the by-token lookup, the run-key\n *   resolution that hydrates hook metadata, and the `respondWith` setup) and\n *   stamping locally would silently exclude all of it, so the two entry points\n *   would report the same metric over different windows.\n */\nasync function resumeHookImpl<T = any>(\n  tokenOrHook: string | ResumableHook,\n  payload: T,\n  encryptionKeyOverride: PayloadKey | undefined,\n  hookFreshlyLookedUp: boolean,\n  resumeRequestedAtMs: number\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: ResumableHook = 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 readbackOps: 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          undefined,\n          readbackOps\n        );\n        // A hook_received event is not durable while its payload still points\n        // at stream uploads in flight. Finish those before committing the\n        // event — but ONLY the producer-push ops in `ops`. A dehydrated\n        // WritableStream lands in `readbackOps` instead: it is a server-stream\n        // READER that resolves only once the woken workflow writes into it (a\n        // manual webhook's `responseWritable` is the canonical case), so\n        // awaiting it here would deadlock the resume against its own wake.\n        //\n        // A rejection with `undefined` is an expected artifact of the webhook\n        // bundle and was historically ignored by the background flush. Keep\n        // that tolerance now that the flush is awaited inline.\n        await Promise.all(\n          ops.map((op) =>\n            op.catch((error) => {\n              if (error !== undefined) throw error;\n            })\n          )\n        );\n        // Readback pipes (notably a manual webhook response writable) can only\n        // finish after the workflow wakes and writes to them. Keep them alive,\n        // but never place them in the durability barrier above.\n        safeWaitUntil(Promise.all(readbackOps), (err) => {\n          if (err === undefined) return;\n          runtimeLogger.warn('Background readback of hook payload 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 the\n        // write and the wake both sit under a span that carries it.\n        const originLink = await linkToTraceCarrier(resumeContext.traceCarrier);\n        if (originLink) {\n          span?.addLink?.(originLink);\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        // The dispatch is strictly serial: the hook_received event is made\n        // durable FIRST, and the workflow wake is published only after the\n        // write is acknowledged. This is what lets `resumeHook()` resolving\n        // mean \"the resume survives anything that happens next\" — a disposal\n        // or run completion racing the queue delivery cannot erase a committed\n        // event, and the wake itself carries no payload, so nothing rides on\n        // the message but the trigger.\n        //\n        // Backend dedup is attested 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). When attested, the write carries a per-call resumeId +\n        // payload digest so transport-level retries of the SAME write converge\n        // on exactly one committed event via the backend's (runId, resumeId)\n        // constraint. Without it the write is a plain single-shot create,\n        // exactly as before dedup existed.\n        const backendDedupSupported =\n          (hookResumeCapabilitiesAreFresh\n            ? (hook.resumeCapabilities?.hookResumeDedupVersion ?? 0)\n            : 0) >= HOOK_RESUME_DEDUP_VERSION ||\n          world.capabilities?.hookResumeDedup === true;\n        const canClaimResume =\n          backendDedupSupported &&\n          !v1Compat &&\n          dehydratedPayload instanceof Uint8Array;\n\n        span?.setAttributes({\n          'workflow.hook.resume_strategy': 'sequential',\n        });\n\n        const resumeId = canClaimResume ? generateResumeId() : undefined;\n        const payloadDigest = canClaimResume\n          ? await computeResumePayloadDigest(dehydratedPayload)\n          : undefined;\n        if (resumeId) {\n          span?.setAttributes({ 'workflow.hook.resume_id': resumeId });\n        }\n\n        // Re-key any \"hook can no longer be received\" rejection to\n        // HookNotFoundError(hook.token) so `.token` matches the historical\n        // contract. The specific error depends on the World:\n        //   - a genuinely missing hook maps to HookNotFoundError (keyed on\n        //     the 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        // An EntityConflictError (HTTP 409) is deliberately NOT re-keyed,\n        // breaking with the historical mapping: every 409 the backend emits\n        // on this write today is TRANSIENT — a slot conflict that escaped the\n        // server's own retry budget under contention, or a resume-claim race\n        // mid-resolution — and its transaction committed nothing. Re-keying\n        // it to HookNotFoundError told the caller (and a webhook sender, via\n        // 404) that a retryable failure was permanent, silently dropping the\n        // resume. It now surfaces as-is: retryable, with nothing committed.\n        // (A 422 resumeId-reuse error likewise passes through unmapped — it\n        // means the caller replayed a resumeId with a different payload, and\n        // hiding that behind \"not found\" would mask the bug.)\n        const isHookGoneError = (err: unknown): boolean =>\n          HookNotFoundError.is(err) || RunExpiredError.is(err);\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                ...(v1Compat ? {} : { token: hook.token }),\n                payload: dehydratedPayload,\n              },\n            },\n            {\n              v1Compat,\n              ...(resumeId && payloadDigest\n                ? { resumeId, resumePayloadDigest: payloadDigest }\n                : {}),\n            }\n          );\n        } catch (err) {\n          if (isHookGoneError(err)) {\n            throw new HookNotFoundError(hook.token);\n          }\n          throw err;\n        }\n        // Stamped AFTER the write resolves (entry-time attributes cannot tell\n        // an attempted resume from a committed one): together with\n        // HookWakePublished below, this is what makes a stranded resume — a\n        // committed event whose wake never went out or was never delivered —\n        // queryable from traces. See the alerting note on HookWakePublished.\n        span?.setAttributes(Attribute.HookResumeCommitted(true));\n\n        // T1 of the TTR window. Stamped immediately before the publish so\n        // `producer_prep` covers exactly the work above it (hook lookup, key\n        // resolution, serialization, and the awaited hook_received write,\n        // which is genuinely serial here).\n        const queuePublishRequestedAtMs = Date.now();\n        await publishHookWakeWithRetry(\n          () =>\n            world.queue(\n              queueName,\n              {\n                runId: hook.runId,\n                traceCarrier: resumeContext.traceCarrier ?? undefined,\n                hookResumeTiming: {\n                  resumeRequestedAtMs,\n                  queuePublishRequestedAtMs,\n                  strategy: 'sequential',\n                },\n              } satisfies WorkflowInvokePayload,\n              {\n                ...queueOptions,\n                // Dedup retried publishes whose response was lost: a\n                // duplicate wake is harmless for correctness (deterministic\n                // replay) but costs a full replay of the run, and the queue\n                // accepts a repeated idempotency key by delivering only one\n                // of the messages. Claim-less writes have no resumeId and\n                // keep the previous behavior.\n                ...(resumeId ? { idempotencyKey: `hook-${resumeId}` } : {}),\n              }\n            ),\n          world.isDeploymentUnavailableError?.bind(world)\n        );\n        span?.setAttributes(Attribute.HookWakePublished(true));\n\n        return asLazyMetadataHook(hook) 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  // T0 of the hook-resume TTR window. Everything below (the by-token lookup,\n  // the run-key resolution it may trigger, and the `respondWith` setup) is\n  // real producer-side latency on this path, so the window has to open here\n  // and not inside `resumeHookImpl`; otherwise webhook resumes would report a\n  // systematically shorter total than `resumeHook` ones into the same metric.\n  const resumeRequestedAtMs = Date.now();\n  const world = await getWorldLazy();\n  const { hook, metadataEncryptionKey } = withLazyMetadata(\n    await world.hooks.getByToken(token)\n  );\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  // `respondWith` lives in the hook's metadata, so this is the one resume path\n  // that has to read it. Only a webhook that actually stored metadata pays for\n  // the hydration: the common default webhook — createWebhook() with no\n  // `respondWith` — stores none, so this resolves `undefined` with no ~350ms\n  // `run-key` API round trip, and hands `resumeHook` no key, leaving it free to\n  // seal the payload to the run's published public key instead.\n  const metadata = await hook.metadata;\n\n  let response: Response | undefined;\n  let responseReadable: ReadableStream<Response> | undefined;\n  if (metadata && typeof metadata === 'object' && 'respondWith' in metadata) {\n    if (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 (metadata.respondWith instanceof Response) {\n      response = metadata.respondWith;\n    } else {\n      throw new WorkflowRuntimeError(\n        `Invalid \\`respondWith\\` value: ${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 by token above, so its response-only\n  // `resumeCapabilities` reflects the live backend. Call the internal\n  // implementation with the fresh attestation so the write's idempotency claim\n  // stays available without a second GET. (The public `resumeHook` never sets\n  // this, so a caller cannot forge it.)\n  //\n  // Reuse whatever key the metadata hydration above resolved (`undefined` when\n  // it resolved none) so a metadata-bearing webhook resolves the run key\n  // exactly once end to end.\n  await resumeHookImpl(\n    hook,\n    request,\n    metadataEncryptionKey(),\n    true,\n    resumeRequestedAtMs\n  );\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"]}

package/dist/runtime.d.ts

@@ -2,7 +2,7 @@ import { type Event, type WorkflowRun } from '@workflow/world';
 export type { Event, WorkflowRun };
 export { WorkflowSuspension } from './global.js';
 export { type HealthCheckOptions, type HealthCheckResult, healthCheck, } from './runtime/helpers.js';
-export { getHookByToken, type ResumedHook, resumeHook, resumeWebhook, } from './runtime/resume-hook.js';
+export { getHookByToken, type Hook, type ResumedHook, resumeHook, resumeWebhook, } from './runtime/resume-hook.js';
 export { getRun, Run, type WorkflowReadableStream, type WorkflowReadableStreamOptions, type WorkflowRunWritableStreamOptions, } from './runtime/run.js';
 export { type CancelRunOptions, cancelRun, cancelRuns, listStreams, type ReadStreamOptions, type RecreateRunOptions, type ReenqueueRunOptions, readStream, recreateRunFromExisting, reenqueueRun, type StopSleepOptions, type StopSleepResult, wakeUpRun, } from './runtime/runs.js';
 export { type StartOptions, type StartOptionsBase, type StartOptionsWithDeploymentId, type StartOptionsWithoutDeploymentId, start, } from './runtime/start.js';

package/dist/runtime.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"runtime.d.ts","sourceRoot":"","sources":["../src/runtime.ts"],"names":[],"mappings":"AAqBA,OAAO,EAGL,KAAK,KAAK,EAaV,KAAK,WAAW,EAEjB,MAAM,iBAAiB,CAAC;AA0GzB,YAAY,EAAE,KAAK,EAAE,WAAW,EAAE,CAAC;AACnC,OAAO,EAAE,kBAAkB,EAAE,MAAM,aAAa,CAAC;AACjD,OAAO,EACL,KAAK,kBAAkB,EACvB,KAAK,iBAAiB,EACtB,WAAW,GACZ,MAAM,sBAAsB,CAAC;AAC9B,OAAO,EACL,cAAc,EACd,KAAK,WAAW,EAChB,UAAU,EACV,aAAa,GACd,MAAM,0BAA0B,CAAC;AAClC,OAAO,EACL,MAAM,EACN,GAAG,EACH,KAAK,sBAAsB,EAC3B,KAAK,6BAA6B,EAClC,KAAK,gCAAgC,GACtC,MAAM,kBAAkB,CAAC;AAC1B,OAAO,EACL,KAAK,gBAAgB,EACrB,SAAS,EACT,UAAU,EACV,WAAW,EACX,KAAK,iBAAiB,EACtB,KAAK,kBAAkB,EACvB,KAAK,mBAAmB,EACxB,UAAU,EACV,uBAAuB,EACvB,YAAY,EACZ,KAAK,gBAAgB,EACrB,KAAK,eAAe,EACpB,SAAS,GACV,MAAM,mBAAmB,CAAC;AAC3B,OAAO,EACL,KAAK,YAAY,EACjB,KAAK,gBAAgB,EACrB,KAAK,4BAA4B,EACjC,KAAK,+BAA+B,EACpC,KAAK,GACN,MAAM,oBAAoB,CAAC;AAC5B,OAAO,EACL,WAAW,EACX,qBAAqB,EACrB,QAAQ,EACR,gBAAgB,EAChB,QAAQ,EACR,KAAK,kBAAkB,GACxB,MAAM,oBAAoB,CAAC;AAsf5B;;;;;;;;;;GAUG;AACH,wBAAgB,kBAAkB,CAChC,YAAY,EAAE,MAAM,EACpB,OAAO,CAAC,EAAE;IACR,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,wBAAwB,CAAC,EAAE,MAAM,CAAC;IAClC,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB,GACA,CAAC,GAAG,EAAE,OAAO,KAAK,OAAO,CAAC,QAAQ,CAAC,CAkxIrC"}
+{"version":3,"file":"runtime.d.ts","sourceRoot":"","sources":["../src/runtime.ts"],"names":[],"mappings":"AAqBA,OAAO,EAGL,KAAK,KAAK,EAaV,KAAK,WAAW,EAEjB,MAAM,iBAAiB,CAAC;AA0GzB,YAAY,EAAE,KAAK,EAAE,WAAW,EAAE,CAAC;AACnC,OAAO,EAAE,kBAAkB,EAAE,MAAM,aAAa,CAAC;AACjD,OAAO,EACL,KAAK,kBAAkB,EACvB,KAAK,iBAAiB,EACtB,WAAW,GACZ,MAAM,sBAAsB,CAAC;AAC9B,OAAO,EACL,cAAc,EACd,KAAK,IAAI,EACT,KAAK,WAAW,EAChB,UAAU,EACV,aAAa,GACd,MAAM,0BAA0B,CAAC;AAClC,OAAO,EACL,MAAM,EACN,GAAG,EACH,KAAK,sBAAsB,EAC3B,KAAK,6BAA6B,EAClC,KAAK,gCAAgC,GACtC,MAAM,kBAAkB,CAAC;AAC1B,OAAO,EACL,KAAK,gBAAgB,EACrB,SAAS,EACT,UAAU,EACV,WAAW,EACX,KAAK,iBAAiB,EACtB,KAAK,kBAAkB,EACvB,KAAK,mBAAmB,EACxB,UAAU,EACV,uBAAuB,EACvB,YAAY,EACZ,KAAK,gBAAgB,EACrB,KAAK,eAAe,EACpB,SAAS,GACV,MAAM,mBAAmB,CAAC;AAC3B,OAAO,EACL,KAAK,YAAY,EACjB,KAAK,gBAAgB,EACrB,KAAK,4BAA4B,EACjC,KAAK,+BAA+B,EACpC,KAAK,GACN,MAAM,oBAAoB,CAAC;AAC5B,OAAO,EACL,WAAW,EACX,qBAAqB,EACrB,QAAQ,EACR,gBAAgB,EAChB,QAAQ,EACR,KAAK,kBAAkB,GACxB,MAAM,oBAAoB,CAAC;AAsf5B;;;;;;;;;;GAUG;AACH,wBAAgB,kBAAkB,CAChC,YAAY,EAAE,MAAM,EACpB,OAAO,CAAC,EAAE;IACR,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,wBAAwB,CAAC,EAAE,MAAM,CAAC;IAClC,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB,GACA,CAAC,GAAG,EAAE,OAAO,KAAK,OAAO,CAAC,QAAQ,CAAC,CAkxIrC"}