eve 0.67.1 → 0.67.2

package/dist/src/client/session-utils.d.ts

@@ -1,14 +1,14 @@
 import type { AuthorizationRequiredStreamEvent, MessageStreamEvent, TurnFailureStreamEvent, UnstampedMessageStreamEvent } from "#protocol/message.js";
 import type { InputRequest } from "#shared/input.js";
 /** A connection authorization challenge that remains unresolved at a turn boundary. */
-export interface PendingAuthorization {
+interface PendingAuthorization {
     readonly authorization?: AuthorizationRequiredStreamEvent["data"]["authorization"];
     readonly description: string;
     readonly name: string;
     readonly webhookUrl?: string;
 }
 /** Canonical projection of the lifecycle state represented by one turn's events. */
-export interface TurnEventSummary {
+interface TurnEventSummary {
     readonly boundary: UnstampedMessageStreamEvent | undefined;
     readonly failure: TurnFailureStreamEvent | undefined;
     readonly inputRequests: readonly InputRequest[];
@@ -21,3 +21,4 @@ export declare function summarizeTurnEvents(events: readonly UnstampedMessageStr
 /** Collects one segment of an event stream through its current-turn boundary. */
 export declare function collectTurnEvents(stream: AsyncIterable<UnstampedMessageStreamEvent>): Promise<readonly UnstampedMessageStreamEvent[]>;
 export declare function updatePendingAuthorizations(pending: Set<string>, event: MessageStreamEvent): void;
+export {};

package/dist/src/compiled/.vendor-stamp.json

@@ -47,16 +47,16 @@
     "@vercel/otel": "2.1.3",
     "@vercel/sandbox": "3.3.0",
     "@vercel/sdk": "1.28.8",
-    "@workflow/core": "5.0.0-beta.56",
-    "@workflow/errors": "5.0.0-beta.23",
+    "@workflow/core": "5.0.0-beta.57",
+    "@workflow/errors": "5.0.0-beta.24",
     "@workflow/serde": "5.0.0-beta.2",
-    "@workflow/world": "5.0.0-beta.38",
-    "@workflow/world-local": "5.0.0-beta.47",
-    "@workflow/world-vercel": "5.0.0-beta.51",
+    "@workflow/world": "5.0.0-beta.39",
+    "@workflow/world-local": "5.0.0-beta.48",
+    "@workflow/world-vercel": "5.0.0-beta.52",
     "zod": "4.5.4",
     "zod-validation-error": "5.0.0"
   },
-  "scriptHash": "175f2363880eee924053e04383385b7692b92db4c87f947c473f4ef1d2f7e8d0",
+  "scriptHash": "1e89a7356b687014be1b3dd2000b50976522132468554b4609c30d6182915242",
   "toolVersions": {
     "rolldown": "1.2.9",
     "typescript": "7.0.2"

package/dist/src/compiled/@workflow/core/index.js

@@ -1,2 +1,2 @@
-import"../../_chunks/workflow/dist-BQSf8Hax.js";import{An as e,Kn as t,Vn as n}from"../../_chunks/workflow/logger-BCEj9caG.js";import{d as r,i}from"../../_chunks/workflow/dist-BfMqXLK3.js";import{G as a,W as o,b as s,ct as c,i as l,it as u,lt as d,nt as f,rt as p,st as m,tt as h,ut as g,w as _}from"../../_chunks/workflow/serialization-CJ265vSe.js";import{a as v,i as y,r as b,t as x}from"../../_chunks/workflow/attribute-changes-DzJovO_f.js";import{n as S}from"../../_chunks/workflow/resume-hook-QS_cMwHn.js";import{t as C}from"../../_chunks/workflow/sleep-CBn94Ayv.js";function w(e){y(`createHook()`,`https://workflow-sdk.dev/docs/api-reference/workflow/create-hook`,w)}function T(e){y(`createWebhook()`,`https://workflow-sdk.dev/docs/api-reference/workflow/create-webhook`,T)}function E({schema:e}={}){function t(e){y(`defineHook().create()`,`https://workflow-sdk.dev/docs/api-reference/workflow/define-hook`,t)}return{create:t,async resume(t,n){if(!e?.[`~standard`])return await S(t,n);let r=e[`~standard`].validate(n);if(r instanceof Promise&&(r=await r),r.issues){let e=r.issues.map(e=>{let t=e.path?.map(e=>String(typeof e==`object`&&e?e.key:e)).join(`.`);return t?`  at "${t}": ${e.message}`:`  ${e.message}`});throw Error(`Hook payload did not match the defined schema:\n${e.join(`
-`)}`)}return await S(t,r.value)}}}async function D(e,n={}){let r=a.getStore(),o=r?.workflowMetadata?.workflowRunId;if(!o)throw new i(`setAttributes() must be called from a 'use workflow' or 'use step' function. Calling it from plain host code is not supported.`);let s={type:`step`,stepId:r.stepMetadata.stepId,attempt:r.stepMetadata.attempt},c=x(e,n,s);if(c.length!==0){if(r.runReadyBarrier)try{await r.runReadyBarrier}catch{}await(await t()).events.create(o,{eventType:`attr_set`,specVersion:8,eventData:{changes:c,writer:s,...n.allowReservedAttributes===!0?{allowReservedAttributes:!0}:{}}})}}function O(){let e=a.getStore();return e||b(`getStepMetadata()`,`https://workflow-sdk.dev/docs/api-reference/workflow/get-step-metadata`,O),e.stepMetadata}function k(){let e=a.getStore();return e||v(`getWorkflowMetadata()`,`https://workflow-sdk.dev/docs/api-reference/workflow/get-workflow-metadata`,k),e.workflowMetadata}function A(t={}){let r=a.getStore();r||v(`getWritable()`,`https://workflow-sdk.dev/docs/api-reference/workflow/get-writable`,A);let{namespace:i}=t,y=r.workflowMetadata.workflowRunId,b=o(y,i);r.writables??=new Map;let x=r.writables,S=x.get(b);if(S)return S.writable;let C=h();C.deferReleaseSettlement=r.streamStates!==void 0;let w=_(s(globalThis,r.ops,y,r.encryptionKey,!0,r.runReadyBarrier),r.encryptionKey),T=new l(y,b,r.runReadyBarrier);r.streamStates??=[],r.streamStates.push(C),r.ops.push(C.promise),f(w.readable,T,C).catch(()=>{});let E=u(w.writable,C);return p(E,C),Object.defineProperty(E,m,{value:b,writable:!1}),Object.defineProperty(E,g,{value:y,writable:!1}),r.workflowDeploymentId&&Object.defineProperty(E,c,{value:r.workflowDeploymentId,writable:!1}),e(r.encryptionKey)&&Object.defineProperty(E,d,{value:n(r.encryptionKey.keyPair.publicKey),writable:!1}),x.set(b,{writable:E,state:C}),E}export{i as FatalError,r as RetryableError,w as createHook,T as createWebhook,E as defineHook,O as getStepMetadata,k as getWorkflowMetadata,A as getWritable,D as setAttributes,C as sleep};
+import"../../_chunks/workflow/dist-BUFGAKRb.js";import{Fn as e,Kn as t,Zn as n}from"../../_chunks/workflow/logger-D4GJNTk4.js";import{d as r,i}from"../../_chunks/workflow/dist-CaNNONeg.js";import{G as a,W as o,b as s,ct as c,i as l,it as u,lt as d,nt as f,rt as p,st as m,tt as h,ut as g,w as _}from"../../_chunks/workflow/serialization-CNIYl1D3.js";import{a as v,i as y,r as b,t as x}from"../../_chunks/workflow/attribute-changes-D721NpZv.js";import{n as S}from"../../_chunks/workflow/resume-hook-uTW-jBYz.js";import{t as C}from"../../_chunks/workflow/sleep-DFKgN7UG.js";function w(e){y(`createHook()`,`https://workflow-sdk.dev/docs/api-reference/workflow/create-hook`,w)}function T(e){y(`createWebhook()`,`https://workflow-sdk.dev/docs/api-reference/workflow/create-webhook`,T)}function E({schema:e}={}){function t(e){y(`defineHook().create()`,`https://workflow-sdk.dev/docs/api-reference/workflow/define-hook`,t)}return{create:t,async resume(t,n){if(!e?.[`~standard`])return await S(t,n);let r=e[`~standard`].validate(n);if(r instanceof Promise&&(r=await r),r.issues){let e=r.issues.map(e=>{let t=e.path?.map(e=>String(typeof e==`object`&&e?e.key:e)).join(`.`);return t?`  at "${t}": ${e.message}`:`  ${e.message}`});throw Error(`Hook payload did not match the defined schema:\n${e.join(`
+`)}`)}return await S(t,r.value)}}}async function D(e,t={}){let r=a.getStore(),o=r?.workflowMetadata?.workflowRunId;if(!o)throw new i(`setAttributes() must be called from a 'use workflow' or 'use step' function. Calling it from plain host code is not supported.`);let s={type:`step`,stepId:r.stepMetadata.stepId,attempt:r.stepMetadata.attempt},c=x(e,t,s);if(c.length!==0){if(r.runReadyBarrier)try{await r.runReadyBarrier}catch{}await(await n()).events.create(o,{eventType:`attr_set`,specVersion:8,eventData:{changes:c,writer:s,...t.allowReservedAttributes===!0?{allowReservedAttributes:!0}:{}}})}}function O(){let e=a.getStore();return e||b(`getStepMetadata()`,`https://workflow-sdk.dev/docs/api-reference/workflow/get-step-metadata`,O),e.stepMetadata}function k(){let e=a.getStore();return e||v(`getWorkflowMetadata()`,`https://workflow-sdk.dev/docs/api-reference/workflow/get-workflow-metadata`,k),e.workflowMetadata}function A(n={}){let r=a.getStore();r||v(`getWritable()`,`https://workflow-sdk.dev/docs/api-reference/workflow/get-writable`,A);let{namespace:i}=n,y=r.workflowMetadata.workflowRunId,b=o(y,i);r.writables??=new Map;let x=r.writables,S=x.get(b);if(S)return S.writable;let C=h();C.deferReleaseSettlement=r.streamStates!==void 0;let w=_(s(globalThis,r.ops,y,r.encryptionKey,!0,r.runReadyBarrier),r.encryptionKey),T=new l(y,b,r.runReadyBarrier);r.streamStates??=[],r.streamStates.push(C),r.ops.push(C.promise),f(w.readable,T,C).catch(()=>{});let E=u(w.writable,C);return p(E,C),Object.defineProperty(E,m,{value:b,writable:!1}),Object.defineProperty(E,g,{value:y,writable:!1}),r.workflowDeploymentId&&Object.defineProperty(E,c,{value:r.workflowDeploymentId,writable:!1}),e(r.encryptionKey)&&Object.defineProperty(E,d,{value:t(r.encryptionKey.keyPair.publicKey),writable:!1}),x.set(b,{writable:E,state:C}),E}export{i as FatalError,r as RetryableError,w as createHook,T as createWebhook,E as defineHook,O as getStepMetadata,k as getWorkflowMetadata,A as getWritable,D as setAttributes,C as sleep};

package/dist/src/compiled/@workflow/core/private.js

@@ -1 +1 @@
-import{A as e}from"../../_chunks/workflow/dist-BfMqXLK3.js";import{i as t,n}from"../../_chunks/workflow/global-BQnKzRXo.js";const r=Symbol.for(`@workflow/core//registeredSteps`),i=globalThis,a=i[r]??=new Map,o=new Set([`__builtin_response_array_buffer`,`__builtin_response_json`,`__builtin_response_text`]);function s(e){let t=e.split(`//`);if(t.length!==3||t[0]!==`step`)return[];let n=t[1],r=t[2],i=new Set,a=e=>{e!==n&&i.add(e)};if(n.startsWith(`./workflows/`)){let e=n.slice(2);a(`./example/${e}`),a(`./src/${e}`)}else if(n.startsWith(`./example/workflows/`)){let e=n.slice(10);a(`./${e}`),a(`./src/${e}`)}else if(n.startsWith(`./src/workflows/`)){let e=n.slice(6);a(`./${e}`),a(`./example/${e}`)}return Array.from(i,e=>`step//${e}//${r}`)}function c(e){if(o.has(e)){for(let[t,n]of a.entries())if(t.endsWith(`//${e}`))return n}}function l(e,t){a.set(e,t),t.stepId=e}function u(e){let t=a.get(e);if(t)return t;for(let t of s(e)){let e=a.get(t);if(e)return e}let n=c(e);if(n)return n}const d={hook:[`hook`,`wait`,`step`],wait:[`hook`,`step`],step:[`wait`,`hook`,`step`]};function f(e,t,n,r){return n>=t||!d[e].includes(r.kind)?!1:!(e===`step`&&!r.armed)}function p(e,t,n,r){let i=r.get(t);if(i!==void 0)return i;let a=m(e,t,n,r);return r.set(t,a),a}function m(e,t,n,r){if(!n.armed)return!1;for(let[i,a]of e)if(f(n.kind,t,i,a)&&!p(e,i,a,r))return!1;return!0}function h(){return process.env.WORKFLOW_LOG_ORDER_DRAWS!==`0`}function g(e){return e===0&&typeof setImmediate==`function`?new Promise(e=>setImmediate(e)):new Promise(t=>setTimeout(t,e))}async function _(e,t){for(;;){let n=e.mintCount??0,r=e.pendingDeliveries;if(await g(await e.promiseQueue.then(()=>!1,()=>!0)?50:0),(e.mintCount??0)!==n||r!==0||e.pendingDeliveries!==0)continue;let i=!1;for(let[n,r]of e.pendingDeliveryBarriers??[])if(n<t&&r.armed){i=!0;break}if(!i)return}}async function v(e,t,n){if(t===void 0||!e.pendingDeliveryBarriers)return;let r=e.pendingDeliveryBarriers,i=[];for(let[e,a]of r)f(n,t,e,a)&&i.push(a.released);if(i.length>0&&await Promise.all(i),h()){await _(e,t);return}i.length>0&&await new Promise(e=>setTimeout(e,0))}function y(n,r,i,a){let o=!1,s=()=>!o&&(o=!0,n.advanceClock?.(a.deliveredAt),!0),c=n.pendingDeliveryBarriers;if(!c||r===void 0)return{markDelivered:()=>{s()},arm:()=>{}};let l=a=>{if(c.has(r))throw new e(`Delivery barrier already registered at event index ${r}`);let{promise:o,resolve:s}=t(),l={kind:i,released:o,armed:a,retired:!1,retire:()=>{l.retired||(l.retired=!0,c.get(r)===l&&c.delete(r),s())}};return c.set(r,l),x(n),l},u=l(a.armed??!0);return{markDelivered:()=>{s()&&u.retire()},arm:()=>{if(!o){if(u.retired){u=l(!0);return}if(c.get(r)!==u)throw new e(`Delivery barrier lost ownership of event index ${r}`);u.armed=!0}}}}const b=new WeakSet;function x(e){let t=e.pendingDeliveryBarriers;if(!t||b.has(e))return;b.add(e);let n=()=>{setTimeout(i,0)},r=()=>{setTimeout(i,50)},i=()=>{if(t.size===0){b.delete(e);return}if(!S(e)){e.promiseQueue.then(n,r);return}for(;t.size>0&&S(e);){let e,n;for(let[r,i]of t)(e===void 0||r<e)&&(e=r,n=i);n?.retire()}setTimeout(i,0)};setTimeout(i,0)}function S(e){return e.pendingDeliveries===0&&!C(e)}function C(e){let t=e.pendingDeliveryBarriers;if(!t||t.size===0)return!1;let n=new Map;for(let[e,r]of t)if(p(t,e,r,n))return!0;return!1}function w(e){return e.pendingDeliveries===0&&(!e.pendingDeliveryBarriers||e.pendingDeliveryBarriers.size===0)}function T(e,t){let n=()=>{w(e)?t():e.promiseQueue.then(()=>{setTimeout(n,0)})};setTimeout(n,0)}function E(e){let t=e.suspensionGeneration;T(e,()=>{t===e.suspensionGeneration&&e.onWorkflowError(new n(e.invocationsQueue,e.globalThis))})}export{v as awaitEarlierDeliveries,u as getStepFunction,C as hasParkedCommittedDelivery,w as isDeliveryIdle,y as registerDeliveryBarrier,l as registerStepFunction,T as scheduleWhenIdle,E as scheduleWorkflowSuspension};
+import{A as e}from"../../_chunks/workflow/dist-CaNNONeg.js";import{i as t,n}from"../../_chunks/workflow/global-DKbOgrts.js";const r=Symbol.for(`@workflow/core//registeredSteps`),i=globalThis,a=i[r]??=new Map,o=new Set([`__builtin_response_array_buffer`,`__builtin_response_json`,`__builtin_response_text`]);function s(e){let t=e.split(`//`);if(t.length!==3||t[0]!==`step`)return[];let n=t[1],r=t[2],i=new Set,a=e=>{e!==n&&i.add(e)};if(n.startsWith(`./workflows/`)){let e=n.slice(2);a(`./example/${e}`),a(`./src/${e}`)}else if(n.startsWith(`./example/workflows/`)){let e=n.slice(10);a(`./${e}`),a(`./src/${e}`)}else if(n.startsWith(`./src/workflows/`)){let e=n.slice(6);a(`./${e}`),a(`./example/${e}`)}return Array.from(i,e=>`step//${e}//${r}`)}function c(e){if(o.has(e)){for(let[t,n]of a.entries())if(t.endsWith(`//${e}`))return n}}function l(e,t){a.set(e,t),t.stepId=e}function u(e){let t=a.get(e);if(t)return t;for(let t of s(e)){let e=a.get(t);if(e)return e}let n=c(e);if(n)return n}const d={hook:[`hook`,`wait`,`step`],wait:[`hook`,`step`],step:[`wait`,`hook`,`step`]};function f(e,t,n,r){return n>=t||!d[e].includes(r.kind)?!1:!(e===`step`&&!r.armed)}function p(e,t,n,r){let i=r.get(t);if(i!==void 0)return i;let a=m(e,t,n,r);return r.set(t,a),a}function m(e,t,n,r){if(!n.armed)return!1;for(let[i,a]of e)if(f(n.kind,t,i,a)&&!p(e,i,a,r))return!1;return!0}function h(){return process.env.WORKFLOW_LOG_ORDER_DRAWS!==`0`}function g(e){return e===0&&typeof setImmediate==`function`?new Promise(e=>setImmediate(e)):new Promise(t=>setTimeout(t,e))}async function _(e,t){for(;;){let n=e.mintCount??0,r=e.pendingDeliveries;if(await g(await e.promiseQueue.then(()=>!1,()=>!0)?50:0),(e.mintCount??0)!==n||r!==0||e.pendingDeliveries!==0)continue;let i=!1;for(let[n,r]of e.pendingDeliveryBarriers??[])if(n<t&&r.armed){i=!0;break}if(!i)return}}async function v(e,t,n){if(t===void 0||!e.pendingDeliveryBarriers)return;let r=e.pendingDeliveryBarriers,i=[];for(let[e,a]of r)f(n,t,e,a)&&i.push(a.released);if(i.length>0&&await Promise.all(i),h()){await _(e,t);return}i.length>0&&await new Promise(e=>setTimeout(e,0))}function y(n,r,i,a){let o=!1,s=()=>!o&&(o=!0,n.advanceClock?.(a.deliveredAt),!0),c=n.pendingDeliveryBarriers;if(!c||r===void 0)return{markDelivered:()=>{s()},arm:()=>{}};let l=a=>{if(c.has(r))throw new e(`Delivery barrier already registered at event index ${r}`);let{promise:o,resolve:s}=t(),l={kind:i,released:o,armed:a,retired:!1,retire:()=>{l.retired||(l.retired=!0,c.get(r)===l&&c.delete(r),s())}};return c.set(r,l),x(n),l},u=l(a.armed??!0);return{markDelivered:()=>{s()&&u.retire()},arm:()=>{if(!o){if(u.retired){u=l(!0);return}if(c.get(r)!==u)throw new e(`Delivery barrier lost ownership of event index ${r}`);u.armed=!0}}}}const b=new WeakSet;function x(e){let t=e.pendingDeliveryBarriers;if(!t||b.has(e))return;b.add(e);let n=()=>{setTimeout(i,0)},r=()=>{setTimeout(i,50)},i=()=>{if(t.size===0){b.delete(e);return}if(!S(e)){e.promiseQueue.then(n,r);return}for(;t.size>0&&S(e);){let e,n;for(let[r,i]of t)(e===void 0||r<e)&&(e=r,n=i);n?.retire()}setTimeout(i,0)};setTimeout(i,0)}function S(e){return e.pendingDeliveries===0&&!C(e)}function C(e){let t=e.pendingDeliveryBarriers;if(!t||t.size===0)return!1;let n=new Map;for(let[e,r]of t)if(p(t,e,r,n))return!0;return!1}function w(e){return e.pendingDeliveries===0&&(!e.pendingDeliveryBarriers||e.pendingDeliveryBarriers.size===0)}function T(e,t){let n=()=>{w(e)?t():e.promiseQueue.then(()=>{setTimeout(n,0)})};setTimeout(n,0)}function E(e){let t=e.suspensionGeneration;T(e,()=>{t===e.suspensionGeneration&&e.onWorkflowError(new n(e.invocationsQueue,e.globalThis))})}export{v as awaitEarlierDeliveries,u as getStepFunction,C as hasParkedCommittedDelivery,w as isDeliveryIdle,y as registerDeliveryBarrier,l as registerStepFunction,T as scheduleWhenIdle,E as scheduleWorkflowSuspension};

package/dist/src/compiled/@workflow/core/runtime/constants.d.ts

@@ -126,9 +126,10 @@ export declare function isResilientStepDispatchEnabled(): boolean;
  * `world.events.createBatch` call (one durable write, per-event outcomes)
  * instead of one write per event. Only engages when the World implements the
  * optional `events.createBatch` AND the run is on slot identity
- * (specVersion >= 6) AND the suspension carries no attribute/hook writes and
- * no resilient step dispatch. Everything else keeps the single-event path
- * byte-for-byte.
+ * (specVersion >= 6) AND the suspension carries no attribute writes and no
+ * resilient step dispatch. Hook writes in the same suspension go through the
+ * single-event path concurrently with the batch. Everything else keeps the
+ * single-event path byte-for-byte.
  *
  * Reads `process.env.WORKFLOW_BATCH_TRANSITIONS` lazily. Default **ON**;
  * disabled only by an explicit `'0'` / `'false'` (case-insensitive), the

package/dist/src/compiled/@workflow/core/runtime/helpers.d.ts

@@ -46,6 +46,14 @@ export interface HealthCheckResult {
      * which fails that gate closed.
      */
     hookResumeInputVersion?: number;
+    /**
+     * The format the responding deployment answered in, set whenever it
+     * answered: `'text'` for the plain-text reply of deployments that predate
+     * the versioned JSON response (spec 3), `'json'` otherwise. A JSON reply
+     * proves the responder runs spec 3 or later even when its `specVersion`
+     * field is missing or malformed.
+     */
+    format?: 'json' | 'text';
 }
 /**
  * Checks if the given message is a health check payload.
@@ -113,6 +121,21 @@ export declare function appendUniqueEvents(target: Event[], events: readonly Eve
  * than a reconstruction.
  */
 export declare function insertEventByEventId(target: Event[], event: Event): void;
+/**
+ * How replay reads the event log. Replay recomputes every step's arguments by
+ * re-running workflow code and never reads the recorded ones (a step reads its
+ * input from the step entity), so replay reads let the World leave them out.
+ * For a workflow passing growing state into its steps, they are the part of
+ * the log that grows quadratically.
+ */
+export declare const REPLAY_RESOLVE_DATA: "skip-step-inputs";
+/**
+ * Params for a write whose inline delta (`sinceCursor`) is folded into a
+ * replay log: that delta is read the way replay reads the log. The created
+ * event and `step` entity are unaffected, so a write that asks for no delta
+ * is left exactly as it was.
+ */
+export declare function withReplayDelta(params: CreateEventParams | undefined): CreateEventParams | undefined;
 /**
  * Loads workflow run events by iterating through all pages of paginated
  * results. Events are returned in chronological (ascending) order for

package/dist/src/compiled/@workflow/core/runtime/helpers.js

@@ -1 +1 @@
-import{C as e,E as t,S as n,T as r,_ as i,a,b as o,c as s,d as c,f as l,g as u,h as d,i as f,l as p,m,n as h,o as g,p as _,r as v,s as y,t as b,u as x,v as S,w as C,x as w,y as T}from"../../../_chunks/workflow/helpers-CNMO7zB1.js";export{b as SLOT_GAP_RECHECK_ATTEMPTS,h as absorbSkippedSlotReport,v as appendEventLog,f as appendUniqueEvents,a as findEventSlotGap,g as getQueueOverhead,y as getWorkflowQueueName,s as handleHealthCheckMessage,p as healthCheck,x as insertEventByEventId,c as isSlotGapCheckEnabled,l as loadWorkflowRunEvents,_ as maxEventSlot,m as memoizeEncryptionKey,d as mergeReportedEvents,u as parseHealthCheckPayload,i as preconditionEventDelta,S as queueMessage,T as queueMessages,o as resolveRunEncryptionKey,w as rootRunIdFrom,n as runDispatchContext,e as settleEventSlotGap,C as slotSnapshotParams,r as stepDispatchIdempotencyKey,t as withHealthCheck};
+import{C as e,D as t,E as n,O as r,S as i,T as a,_ as o,a as s,b as c,c as l,d as u,f as d,g as f,h as p,i as m,l as h,m as g,n as _,o as v,p as y,r as b,s as x,t as S,u as C,v as w,w as T,x as E,y as D}from"../../../_chunks/workflow/helpers-DkKxg_yn.js";export{S as REPLAY_RESOLVE_DATA,_ as SLOT_GAP_RECHECK_ATTEMPTS,b as absorbSkippedSlotReport,m as appendEventLog,s as appendUniqueEvents,v as findEventSlotGap,x as getQueueOverhead,l as getWorkflowQueueName,h as handleHealthCheckMessage,C as healthCheck,u as insertEventByEventId,d as isSlotGapCheckEnabled,y as loadWorkflowRunEvents,g as maxEventSlot,p as memoizeEncryptionKey,f as mergeReportedEvents,o as parseHealthCheckPayload,w as preconditionEventDelta,D as queueMessage,c as queueMessages,E as resolveRunEncryptionKey,i as rootRunIdFrom,e as runDispatchContext,T as settleEventSlotGap,a as slotSnapshotParams,n as stepDispatchIdempotencyKey,t as withHealthCheck,r as withReplayDelta};

package/dist/src/compiled/@workflow/core/runtime/hook-wake.d.ts

@@ -33,9 +33,11 @@ export declare function publishHookWakeWithRetry(publish: () => Promise<unknown>
  * Same durability contract as `resumeHook()`'s wake: the row is durable
  * before this runs, the publish is retried on transport-shaped failures, and
  * a publish that still fails is logged rather than failing the claimer —
- * nothing of the claimer's is wrong, and the victim reads the row on its
- * next invocation for any reason. The idempotency key is the claimer's hook
- * id, so a claimer retrying its creation republishes at most one wake.
+ * nothing of the claimer's is wrong, every later replay of the claimer inside
+ * the republish window tries again ({@link forcedCreationsOwingWake}), and
+ * the victim reads the row on its next invocation for any reason. The
+ * idempotency key is the claimer's hook id, so those republishes collapse
+ * into one wake.
  *
  * Skipped when the victim is the claimer itself (a run taking over its own
  * earlier hook is already running) and when the World recorded no
@@ -44,46 +46,77 @@ export declare function publishHookWakeWithRetry(publish: () => Promise<unknown>
  */
 export declare function publishForceClaimVictimWake(world: World, claimerRunId: string, hook: Pick<Hook, 'hookId' | 'claimedFrom'>): Promise<'published' | 'skipped' | 'failed'>;
 /**
- * The forced hook creation whose victim wake this run still owes, if any: the
- * forced `hook_created` is the last event the run's own replay appended.
+ * How long after a forced `hook_created` a replay of the claimer keeps
+ * republishing its victim's wake: 24 hours, measured from the row's
+ * `createdAt`.
+ *
+ * The bound has to outlast every redelivery of the invocation that journaled
+ * the creation, because that redelivery is the replay that must repay a wake
+ * the invocation died before publishing. A queue message is retained for 24
+ * hours from its send and the creation is written after the send, so any such
+ * redelivery arrives within 24 hours of the creation. The same 24 hours is the
+ * Vercel queue's idempotency window (`min(retention, 24h)`), so every
+ * republish inside it collapses, under `hook-force-claim-<hookId>`, into the
+ * one wake that was (or now is) delivered. Past it a republish would be a
+ * genuinely new message, which is what the bound saves. world-postgres
+ * remembers a completed key in-process to the same effect; world-local
+ * dedupes a key only while its message is in flight, so there a republish can
+ * deliver the victim one more replay, which reads nothing new.
+ */
+export declare const FORCE_CLAIM_WAKE_REPUBLISH_WINDOW_MS: number;
+/**
+ * The forced hook creations whose victim wake this run may still owe: every
+ * forced `hook_created` (one carrying `forceClaimedFrom`) in the log whose
+ * `createdAt` is within {@link FORCE_CLAIM_WAKE_REPUBLISH_WINDOW_MS} of
+ * `nowMs`.
  *
  * A forced creation is followed by a wake of the run it took the token from.
  * If the invocation died between the two, the creation is in the log and the
- * victim was never told; the row itself is the durable record of that debt.
- * As long as it is the last event THIS RUN wrote, the run has made no progress
- * since, so the invocation that should have woken the victim did not finish,
- * and the replay republishes (under the hook's idempotency key, so a wake that
- * did go out is not duplicated). The first event the run appends after it
- * ends the republishing.
+ * victim was never told; the row itself is the durable record of that debt,
+ * and nothing records that the wake went out. So the replay does not try to
+ * infer it: it republishes for every recent forced creation, and the hook's
+ * idempotency key collapses a wake that did go out (a duplicate that slips
+ * past a World's dedupe is one harmless replay of the victim).
  *
- * "This run wrote" matters: a delivery appends `hook_received` to this log
- * from another request, a sealed-log World appends `noop`, and a LATER
- * claimer taking the token from this run appends
- * `hook_disposed{forceClaimedBy}`. None is progress of this run — the model
- * (`ForceWakeOnce.cfg`'s sibling trace) has a delivery land between the crash
- * and the retry, and a rule that looked at the bare tail would then never
- * wake the victim. The foreign disposal is the chain case: this run took the
- * token from A, died before waking A, and was itself taken from by C. Its own
- * wake (from C) is the very invocation that must repay A's — the run's own
- * `hook_disposed` (a `dispose()` in its code) IS its progress and still ends
- * the debt, but a row another run put here does not. Both engines call this
- * on the log they loaded for the invocation, before writing anything.
+ * The rule reads nothing written after the creation, which is what makes it
+ * sound. Any row can land between the creation and the wake: a step, wait,
+ * attribute or other hook row the same suspension writes concurrently
+ * (neither engine holds those for the wake), a step or wait terminal from
+ * another invocation, a delivery's `hook_received`, a sealed-log `noop`, or a
+ * later claimer's `hook_disposed{forceClaimedBy}` taking the token from this
+ * run. None of them says the wake was published. The last is the chain case:
+ * this run took the token from A, died before waking A, and was taken from by
+ * C; C's wake of this run is the invocation that repays A's.
  *
- * Reading only the last own row is sound because both engines keep every
- * other write of the invocation off that tail until the wake is out: a token
- * group holding a forced creation runs first, one group at a time, publishing
- * its wake before its next write, and nothing else is dispatched until those
- * groups have settled. Were a sibling hook's creation (or, in QuickJS, a step
- * or wait) allowed to land concurrently, a crash before the publish would
- * leave that row last and hide the debt.
+ * The time is the row's `createdAt`, never one decoded from its event id (a
+ * slot-numbered id carries none). Under slot identity it is the writer's
+ * client clock, clamped by the World to at most an hour ahead of its own, so
+ * skew moves the window's edge by at most that much; a creation dated ahead of
+ * `nowMs` counts as recent, and one whose time cannot be read is treated as
+ * recent too, erring toward a wake rather than a stranded victim.
  */
-export declare function forcedCreationOwingWake(events: readonly Event[] | undefined): (Event & {
+export declare function forcedCreationsOwingWake(events: readonly Event[] | undefined, nowMs?: number): (Event & {
     eventType: 'hook_created';
-}) | undefined;
+})[];
 /**
- * Republish the wake {@link forcedCreationOwingWake} says is owed. Shared by
- * the node:vm suspension handler and the QuickJS entrypoint so the two engines
- * cannot drift on the durability contract.
+ * Republish the wakes {@link forcedCreationsOwingWake} says may be owed.
+ * Shared by the node:vm suspension handler and the QuickJS entrypoint so the
+ * two engines cannot drift on the durability contract.
+ *
+ * `alreadyWoken` is the invocation's record of the hooks whose victim wake it
+ * has already published or attempted, the forced creations it made itself
+ * included: an engine that replays more than once per invocation passes the
+ * same set every time, so each hook costs one send per invocation. Hooks this
+ * call publishes are added to it.
+ *
+ * Self-claims and victims with no recorded `workflowName` are skipped
+ * silently: the creating invocation already logged the latter, and a replay
+ * repeating it would say nothing new. Never rejects; a publish that fails
+ * after its retries is logged, and the next replay inside the window tries
+ * again.
  */
-export declare function republishOwedForceClaimVictimWake(world: World, runId: string, events: readonly Event[] | undefined): Promise<void>;
+export declare function republishOwedForceClaimVictimWakes(world: World, runId: string, events: readonly Event[] | undefined, options?: {
+    alreadyWoken?: Set<string>;
+    nowMs?: number;
+}): Promise<void>;
 //# sourceMappingURL=hook-wake.d.ts.map

package/dist/src/compiled/@workflow/core/runtime/lifecycle-hooks.d.ts

@@ -1,40 +1,39 @@
 import { WorkflowRunFailedError } from '#compiled/@workflow/errors/index.js';
 import type { PayloadKey } from '../serialization/encryption.js';
 import { Run } from './run.js';
-/**
- * Parameters passed to an {@link WorkflowLifecycleHooks.onRunCompleted}
- * handler.
- */
-export interface RunCompletedHookParams {
-    /** The workflow name, available without fetching the run. */
+interface RunHookParams {
+    /**
+     * The machine-readable workflow identifier, such as
+     * `workflow//./src/workflows/order//processOrder`, available without a read.
+     * Unlike this string, `run.workflowName` is a Promise that fetches metadata.
+     */
     workflowName: string;
     /**
-     * The completed run. The instance hydrates lazily, so reading
+     * The transitioned run. The instance hydrates lazily, so reading
      * `run.returnValue` (or any other accessor) fetches from the backend only
      * when the handler actually uses it.
      */
     run: Run<unknown>;
 }
+/** Parameters passed to an {@link WorkflowLifecycleHooks.onRunCompleted} handler. */
+export interface RunCompletedHookParams extends RunHookParams {
+}
 /**
  * Parameters passed to an {@link WorkflowLifecycleHooks.onRunFailed}
  * handler.
  */
-export interface RunFailedHookParams {
-    /** The workflow name, available without fetching the run. */
-    workflowName: string;
-    /**
-     * The failed run. The instance hydrates lazily, so accessors fetch from
-     * the backend only when the handler actually uses them.
-     */
-    run: Run<unknown>;
+export interface RunFailedHookParams extends RunHookParams {
     /**
-     * The failure, in the same shape `run.returnValue` rejects with: a
-     * `WorkflowRunFailedError` whose `errorCode` carries the failure
-     * classification (e.g. `USER_ERROR`, `RUNTIME_ERROR`) and whose `cause` is
+     * The persisted failure hydrated for reporting. Unlike `run.returnValue`,
+     * readable streams load only when consumed and abort signals reflect their
+     * persisted state without live subscriptions. Writable streams retain their
+     * normal forwarding setup.
+     *
+     * This `WorkflowRunFailedError` has an `errorCode` carrying the failure
+     * classification (e.g. `USER_ERROR`, `RUNTIME_ERROR`). Its `cause` is
      * the hydrated persisted value (registered Error subclass identity preserved).
-     * Streams are read only when consumed; abort signals reflect their persisted
-     * state without live subscriptions. If hydration fails, `cause` is a generic
-     * Error, matching `run.returnValue`'s fallback.
+     * If hydration fails, `cause` is a generic Error, matching
+     * `run.returnValue`'s fallback.
      */
     error: WorkflowRunFailedError;
 }
@@ -65,11 +64,14 @@ export interface WorkflowLifecycleHooks {
  *   CLI or dashboard) do not fire handlers in the app.
  * - Handlers are fire-and-forget: they cannot delay or change the run's
  *   outcome, and a throwing handler is logged and swallowed. On Vercel,
- *   `waitUntil` keeps the invocation alive. On other hosts handlers run
+ *   `waitUntil` keeps the invocation alive for handlers and background stream
+ *   operations from the hydrated failure. On other hosts handlers run
  *   detached, and freezing serverless hosts may not let them finish.
  * - Reporting is best effort: callbacks are not retried if the invocation
  *   dies before they finish. Use the event log as the system of record.
  * - Multiple registrations are allowed; handlers run in registration order.
+ *   Registrations are not deduplicated. Unregister the previous hooks before
+ *   registering again during hot reload or module re-evaluation.
  *
  * @returns A function that unregisters these hooks.
  */
@@ -87,4 +89,5 @@ export declare function dispatchRunCompletedHooks(runId: string, workflowName: s
  * @param errorCode - The classification written to the event's `errorCode`.
  */
 export declare function dispatchRunFailedHooks(runId: string, workflowName: string, error: unknown, encryptionKey: PayloadKey | undefined, errorCode: string): void;
+export {};
 //# sourceMappingURL=lifecycle-hooks.d.ts.map

package/dist/src/compiled/@workflow/core/runtime/run-spec-version.d.ts

@@ -0,0 +1,16 @@
+/**
+ * The spec version to stamp on an event written to a run by a process that may
+ * not be the one executing it: the run's own version when it is lower than this
+ * SDK's.
+ *
+ * The runtime executing a run reads every event in its log, and one built
+ * against a lower spec version (an older deployment, or another SDK) rejects an
+ * event stamped above what it supports. The Python SDK rejects the run's whole
+ * event log over a single such event. Capped at this SDK's version too, since
+ * that is the newest format this SDK can write.
+ *
+ * `whenUnknown` is used for a run with no recorded version. It defaults to this
+ * SDK's; callers that treat such a run as legacy pass `SPEC_VERSION_LEGACY`.
+ */
+export declare function specVersionForRunWrite(runSpecVersion: number | undefined, whenUnknown?: number): number;
+//# sourceMappingURL=run-spec-version.d.ts.map

package/dist/src/compiled/@workflow/core/runtime/start.d.ts

@@ -1,5 +1,53 @@
 import type { RunRetention, World } from '#compiled/@workflow/world/index.js';
+import { type HealthCheckResult } from './helpers.js';
 import { Run } from './run.js';
+/**
+ * Where a run's stamped spec version came from, recorded on the `start()`
+ * span so "why is this run on spec N?" is answerable without reading code.
+ */
+export type SpecVersionSource = 'same-deployment' | 'explicit' | 'probe' | 'probe-unversioned' | 'probe-malformed' | 'probe-miss' | 'no-probe-channel';
+/**
+ * The spec version to stamp on a run that another deployment will execute.
+ *
+ * A run's spec version is a promise about the runtime that reads and writes
+ * its event log, and for a cross-deployment start that is the target, not
+ * this caller. The capability probe runs inside the target and reports the
+ * version the target itself mints (which already honours the target's own
+ * `WORKFLOW_SEALED_LOG` switch), so that is the answer, capped at what this
+ * caller's World mints: the caller writes `run_created` and the arguments,
+ * and must never stamp a version it could not have written itself.
+ *
+ * When the target does not report a usable version:
+ *
+ * - a plain-text reply predates the versioned JSON health response, which
+ *   arrived with spec 3 (CBOR queue transport), so it is stamped as
+ *   event-sourced: such a target cannot read a CBOR `runInput`.
+ * - a JSON reply without a usable `specVersion` still proves the target is
+ *   at spec 3 or later, so it is stamped with CBOR queue transport rather
+ *   than losing it (and resilient start with it) to a malformed field.
+ * - a probe that times out, or no probe channel at all, is a guess.
+ *   `SPEC_VERSION_SUPPORTS_SLOT_IDENTITY` is the lowest version a v5 runtime
+ *   can execute on the Vercel World (it requires slot event ids), so it is
+ *   the only floor that keeps same-major targets working. It is NOT safe for
+ *   an older-major target such as `stable` (spec 3): that target rejects the
+ *   run when it picks it up. No single floor serves both, which is why the
+ *   probe budget is generous; the miss is logged and recorded on the span.
+ *
+ * Once executors attest their version on `run_started` and the backend
+ * raises a run to it (vercel/workflow#4366, vercel/workflow-server#1044), a
+ * v5 target heals an under-stamped run, and this miss floor may drop, but
+ * only once the raise is enabled on the whole server fleet AND every v5
+ * target a caller can reach attests its version (a published beta that does
+ * not would be stamped below slot identity and fail). Even then a floor
+ * below `SPEC_VERSION_SUPPORTS_ATTRIBUTES` would refuse `attributes` on every
+ * miss. Tracked in vercel/workflow#4401.
+ *
+ * Exported for tests.
+ */
+export declare function resolveCrossDeploymentSpecVersion(probe: Pick<HealthCheckResult, 'healthy' | 'specVersion' | 'format'> | undefined, callerSpecVersion: number): {
+    specVersion: number;
+    source: SpecVersionSource;
+};
 /**
  * Reset the `deploymentId: 'latest'` no-op warn-once guard. Test-only,
  * exported so unit tests can exercise the warn path across `start()` calls.
@@ -7,6 +55,12 @@ import { Run } from './run.js';
  * @internal
  */
 export declare function _resetLatestNoOpWarnForTests(): void;
+/**
+ * Reset the cross-deployment probe-miss warn-once guard. Test-only.
+ *
+ * @internal
+ */
+export declare function _resetProbeMissWarnForTests(): void;
 export interface StartOptionsBase {
     /**
      * The world to use for the workflow run creation,
@@ -14,7 +68,11 @@ export interface StartOptionsBase {
      */
     world?: World;
     /**
-     * The spec version to use for the workflow run. Defaults to the latest version.
+     * The spec version to use for the workflow run. Defaults to the spec
+     * version of the deployment that will execute the run: the configured
+     * World's for a same-deployment start, and for a cross-deployment start
+     * (`deploymentId` naming another deployment) the version the target
+     * reports on its capability probe, capped at the configured World's.
      */
     specVersion?: number;
     /**

package/dist/src/compiled/@workflow/core/runtime/step-latency.d.ts

@@ -160,8 +160,9 @@ export declare function computeStepLatencyTracking(params: {
     /** See {@link StepLatencyTracking.preStepBlockingMs}. */
     preStepBlockingMs: number;
     /**
-     * The accumulator's value as of the suspension that wrote the run's first
-     * attr_set (its hook phase runs before its attr writes). When the
+     * The accumulator's value as of the start of the suspension that wrote the
+     * run's first attr_set (that suspension's hook writes run alongside its attr
+     * writes, so the hook time it reports falls after the attr commit). When the
      * measurement ends at the attr write, only hook time from before that
      * point may be subtracted; later hook writes fall outside the measured
      * window. Undefined when no attr suspension happened in this invocation

package/dist/src/compiled/@workflow/core/runtime/suspension-handler.d.ts

@@ -84,6 +84,15 @@ export interface SuspensionHandlerParams {
      * keep the everything-durable-at-return behavior.
      */
     allowDeferredBatchWork?: boolean;
+    /**
+     * The invocation's record of hooks whose force-claim victim wake it has
+     * already published or attempted, whether as the forced creation's own wake
+     * or as a replay's republish (see `republishOwedForceClaimVictimWakes`). The
+     * caller passes one set for the whole invocation so a run that suspends more
+     * than once per invocation sends each hook's wake once, not once per
+     * suspension. Omitted, every suspension republishes on its own.
+     */
+    forceClaimVictimWakes?: Set<string>;
 }
 /**
  * Result of handling a suspension. Returns pending step items so the caller
@@ -200,9 +209,13 @@ export interface SuspensionHandlerResult {
     };
     /**
      * Whether a hook create committed a `hook_conflict` — the token was already
-     * claimed, so this run's hook was never created and the workflow must
-     * observe the conflict before anything else this suspension scheduled runs.
-     * The caller answers it by advancing the workflow over the committed event.
+     * claimed, so this run's hook was never created. The caller answers it by
+     * advancing the workflow over the committed event before it dispatches or
+     * runs the steps this suspension scheduled. Those steps were written
+     * alongside the hook create, not after it, so their `step_created` events
+     * (and, on the batched path, their step messages and any pre-claimed inline
+     * pairs in {@link inlineClaims}) may already be out: work the workflow
+     * started concurrently with the hook is not held back by its conflict.
      */
     hasHookConflict: boolean;
     /** Whether a `hook.getConflict()` awaiter needs the workflow to continue immediately */
@@ -243,7 +256,8 @@ export interface SuspensionHandlerResult {
      * folded in (see `hookDeltaCursor` below), and nothing else in this
      * suspension wrote an event. False whenever a read is needed first: no
      * delta was asked for or returned, it was truncated, or a step / wait /
-     * attribute / abort write landed above it and is therefore not in it.
+     * attribute / abort write (single or batched) also committed and may not be
+     * in it.
      *
      * Indifferent to which event the create committed: the delta is the slice
      * of the log after the caller's cursor either way, so it carries a
@@ -261,10 +275,12 @@ export interface SuspensionHandlerResult {
      */
     hasHookEvents: boolean;
     /**
-     * Wall-clock ms spent committing this suspension's `hook_created` events
-     * (0 when it created none). The caller accumulates this across iterations
-     * and subtracts it from the TTFS latency measurement, so time spent
-     * durably creating the user's hooks doesn't count as runtime overhead.
+     * Wall-clock ms this suspension spent blocked on nothing but committing its
+     * `hook_created` events (0 when it created none): the stretch the hook
+     * writes outlasted every other write, since until then the suspension was
+     * waiting on those too. The caller accumulates this across iterations and
+     * subtracts it from the TTFS latency measurement, so time spent durably
+     * creating the user's hooks doesn't count as runtime overhead.
      */
     hookCreationMs: number;
     /** Exact number of workflow-code executions observed during serialization. */
@@ -281,9 +297,15 @@ export interface SuspensionSerializationBlocker extends GuestCodeExecution {
  * Creates events for all operations but does NOT queue step messages; returns the pending
  * steps so the caller can decide which to execute inline vs queue to background.
  *
- * Processing order:
- * 1. Hooks are processed first to prevent race conditions with webhook receivers
- * 2. Step events and wait events are created in parallel
+ * Every write is issued concurrently: hook creations and disposals (in code
+ * order per token, then abort deliveries), step and wait events (batched where
+ * the World supports it), and attribute events.
+ *
+ * Hooks are not written ahead of the steps created alongside them. A step
+ * started in the same suspension as a hook can therefore run before that hook
+ * is registered; a workflow that needs the hook registered first (say, a step
+ * that hands the token to something that resumes it at once) awaits
+ * `hook.getConflict()` before calling the step.
  */
-export declare function handleSuspension({ suspension, world, run, span, requestId, eventLog, runReadyBarrier, replayRecoveryReporter, stepDispatch, ownerMessageId, allowDeferredBatchWork, }: SuspensionHandlerParams): Promise<SuspensionHandlerResult>;
+export declare function handleSuspension({ suspension, world, run, span, requestId, eventLog, runReadyBarrier, replayRecoveryReporter, stepDispatch, ownerMessageId, allowDeferredBatchWork, forceClaimVictimWakes, }: SuspensionHandlerParams): Promise<SuspensionHandlerResult>;
 //# sourceMappingURL=suspension-handler.d.ts.map