eve 0.66.2 → 0.67.0

package/dist/src/compiled/@workflow/core/serialization/types.d.ts

@@ -95,6 +95,14 @@ export interface SerializableSpecial {
         token: string;
         conflictingRunId?: string;
     };
+    HookForceClaimedError: {
+        message: string;
+        stack?: string;
+        cause?: unknown;
+        token: string;
+        claimedByRunId: string;
+        claimedByHookId?: string;
+    };
     Int8Array: string;
     Int16Array: string;
     Int32Array: string;

package/dist/src/compiled/@workflow/core/serialization.d.ts

@@ -183,6 +183,14 @@ export declare function getCommonRevivers(global?: Record<string, any>): {
         token: string;
         conflictingRunId?: string;
     }) => any) | undefined;
+    HookForceClaimedError?: ((value: {
+        message: string;
+        stack?: string;
+        cause?: unknown;
+        token: string;
+        claimedByRunId: string;
+        claimedByHookId?: string;
+    }) => any) | undefined;
     Int8Array?: ((value: string) => any) | undefined;
     Int16Array?: ((value: string) => any) | undefined;
     Int32Array?: ((value: string) => any) | undefined;

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

@@ -1 +1 @@
-import{An as e,Bn as t,Dn as n,En as r,Fn as i,In as a,Ln as o,Nn as s,On as c,Pn as l,Rn as u,jn as d,kn as f,zn as p}from"../../_chunks/workflow/logger-Bzc8jWWj.js";import{A as m,C as h,D as g,E as _,F as v,I as y,J as b,L as x,M as S,N as C,O as w,P as T,S as E,T as D,_ as O,a as k,b as A,c as j,d as M,f as N,g as P,h as F,i as I,j as L,k as R,l as z,m as B,n as V,o as H,p as U,q as W,r as G,s as K,t as q,u as J,v as Y,w as X,x as Z,y as Q}from"../../_chunks/workflow/serialization-HCDeQWcR.js";export{q as FRAMED_STREAM_MAX_RECONNECTS,V as FRAMED_STREAM_MAX_TOTAL_RECONNECTS,p as SerializationFormat,G as WorkflowServerReadableStream,I as WorkflowServerWritableStream,r as aesKeyOf,k as cancelAbortReaders,W as compress,H as createForwardedWritable,K as createReconnectingFramedStream,i as decodeFormatPrefix,b as decompress,n as decrypt,j as dehydrateRunError,z as dehydrateStepArguments,J as dehydrateStepError,M as dehydrateStepReturnValue,N as dehydrateWorkflowArguments,U as dehydrateWorkflowReturnValue,c as deriveRunPayloadKeys,B as deserializePreparedReplayPayload,F as deserializePreparedStepError,a as encodeWithFormatPrefix,f as encrypt,P as getByteFramingStream,O as getByteUnframingStream,Y as getCommonRevivers,Q as getDeserializeStream,A as getExternalReducers,Z as getExternalRevivers,E as getForwardedWritableEncryptionKey,h as getRunReadableStream,X as getSerializeStream,D as getStreamType,_ as getWorkflowReducers,g as getWorkflowRevivers,w as hydrateRunError,R as hydrateStepArguments,m as hydrateStepError,L as hydrateStepReturnValue,S as hydrateWorkflowArguments,C as hydrateWorkflowReturnValue,o as isEncrypted,t as isFormatPrefix,e as isRunPayloadKeys,d as isSealTarget,T as maybeDecrypt,v as maybeEncrypt,u as peekFormatPrefix,y as prepareReplayPayload,s as runPayloadKeys,l as sealTo,x as tagForwardedWritableTarget};
+import{An as e,Bn as t,Dn as n,En as r,Fn as i,In as a,Ln as o,Nn as s,On as c,Pn as l,Rn as u,jn as d,kn as f,zn as p}from"../../_chunks/workflow/logger-BCEj9caG.js";import{A as m,C as h,D as g,E as _,F as v,I as y,J as b,L as x,M as S,N as C,O as w,P as T,S as E,T as D,_ as O,a as k,b as A,c as j,d as M,f as N,g as P,h as F,i as I,j as L,k as R,l as z,m as B,n as V,o as H,p as U,q as W,r as G,s as K,t as q,u as J,v as Y,w as X,x as Z,y as Q}from"../../_chunks/workflow/serialization-CJ265vSe.js";export{q as FRAMED_STREAM_MAX_RECONNECTS,V as FRAMED_STREAM_MAX_TOTAL_RECONNECTS,p as SerializationFormat,G as WorkflowServerReadableStream,I as WorkflowServerWritableStream,r as aesKeyOf,k as cancelAbortReaders,W as compress,H as createForwardedWritable,K as createReconnectingFramedStream,i as decodeFormatPrefix,b as decompress,n as decrypt,j as dehydrateRunError,z as dehydrateStepArguments,J as dehydrateStepError,M as dehydrateStepReturnValue,N as dehydrateWorkflowArguments,U as dehydrateWorkflowReturnValue,c as deriveRunPayloadKeys,B as deserializePreparedReplayPayload,F as deserializePreparedStepError,a as encodeWithFormatPrefix,f as encrypt,P as getByteFramingStream,O as getByteUnframingStream,Y as getCommonRevivers,Q as getDeserializeStream,A as getExternalReducers,Z as getExternalRevivers,E as getForwardedWritableEncryptionKey,h as getRunReadableStream,X as getSerializeStream,D as getStreamType,_ as getWorkflowReducers,g as getWorkflowRevivers,w as hydrateRunError,R as hydrateStepArguments,m as hydrateStepError,L as hydrateStepReturnValue,S as hydrateWorkflowArguments,C as hydrateWorkflowReturnValue,o as isEncrypted,t as isFormatPrefix,e as isRunPayloadKeys,d as isSealTarget,T as maybeDecrypt,v as maybeEncrypt,u as peekFormatPrefix,y as prepareReplayPayload,s as runPayloadKeys,l as sealTo,x as tagForwardedWritableTarget};

package/dist/src/compiled/@workflow/core/version.d.ts

@@ -1,2 +1,2 @@
-export declare const version = "5.0.0-beta.55";
+export declare const version = "5.0.0-beta.56";
 //# sourceMappingURL=version.d.ts.map

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

@@ -1 +1 @@
-import{i as e,u as t}from"../../_chunks/workflow/dist-DtXwQbZr.js";import{i as n}from"../../_chunks/workflow/workflow-routes-CwqB063q.js";import{X as r,Y as i,ft as a,mt as o,pt as s,st as c}from"../../_chunks/workflow/serialization-HCDeQWcR.js";import{c as l,i as u,o as d,r as f,t as p}from"../../_chunks/workflow/attribute-changes-89Nwz7XW.js";import{t as m}from"../../_chunks/workflow/sleep-Bi508qmg.js";import{t as h}from"../../_chunks/workflow/run-NLvREued.js";r(i,h);function g(e){let t=globalThis[a];return t||u(`createHook()`,`https://workflow-sdk.dev/docs/api-reference/workflow/create-hook`,g),t(e)}function _(e){let{respondWith:t,token:r,...i}=e??{};if(r!==void 0)throw Error("`createWebhook()` does not accept a `token` option. Webhook tokens are always generated for you. Use `createHook()` with `resumeHook()` for deterministic token patterns.");let a;t!==void 0&&(a={respondWith:t});let o=g({...i,metadata:a,isWebhook:!0}),{url:s}=l();return o.url=n(s,{type:`webhook`,token:o.token}),o}function v(){function e(t,n){d(`defineHook().resume()`,`https://workflow-sdk.dev/docs/api-reference/workflow-api/resume-hook`,e)}return{create(e){return g(e)},resume:e}}async function y(t,n={}){let r=p(t,n);if(r.length===0)return;let i=n.allowReservedAttributes===!0,a=globalThis[o];if(!a)throw new e("setAttributes() called outside a workflow runtime context. It must be called from within a workflow body (`use workflow`).");await a(r,i?{allowReservedAttributes:!0}:{})}function b(e={}){let{namespace:t}=e,n=globalThis[s](t);return Object.create(globalThis.WritableStream.prototype,{[c]:{value:n,writable:!1}})}function x(){f(`getStepMetadata()`,`https://workflow-sdk.dev/docs/api-reference/workflow/get-step-metadata`,x)}function S(){d(`resumeHook()`,`https://workflow-sdk.dev/docs/api-reference/workflow-api/resume-hook`,S)}export{e as FatalError,t as RetryableError,g as createHook,_ as createWebhook,v as defineHook,x as getStepMetadata,l as getWorkflowMetadata,b as getWritable,S as resumeHook,y as setAttributes,m as sleep};
+import{d as e,i as t}from"../../_chunks/workflow/dist-BfMqXLK3.js";import{i as n}from"../../_chunks/workflow/workflow-routes-CwqB063q.js";import{X as r,Y as i,ft as a,mt as o,pt as s,st as c}from"../../_chunks/workflow/serialization-CJ265vSe.js";import{c as l,i as u,o as d,r as f,t as p}from"../../_chunks/workflow/attribute-changes-DzJovO_f.js";import{t as m}from"../../_chunks/workflow/sleep-CBn94Ayv.js";import{t as h}from"../../_chunks/workflow/run-CA5wWV2S.js";r(i,h);function g(e){let t=globalThis[a];return t||u(`createHook()`,`https://workflow-sdk.dev/docs/api-reference/workflow/create-hook`,g),t(e)}function _(e){let{respondWith:t,token:r,...i}=e??{};if(r!==void 0)throw Error("`createWebhook()` does not accept a `token` option. Webhook tokens are always generated for you. Use `createHook()` with `resumeHook()` for deterministic token patterns.");let a;t!==void 0&&(a={respondWith:t});let o=g({...i,metadata:a,isWebhook:!0}),{url:s}=l();return o.url=n(s,{type:`webhook`,token:o.token}),o}function v(){function e(t,n){d(`defineHook().resume()`,`https://workflow-sdk.dev/docs/api-reference/workflow-api/resume-hook`,e)}return{create(e){return g(e)},resume:e}}async function y(e,n={}){let r=p(e,n);if(r.length===0)return;let i=n.allowReservedAttributes===!0,a=globalThis[o];if(!a)throw new t("setAttributes() called outside a workflow runtime context. It must be called from within a workflow body (`use workflow`).");await a(r,i?{allowReservedAttributes:!0}:{})}function b(e={}){let{namespace:t}=e,n=globalThis[s](t);return Object.create(globalThis.WritableStream.prototype,{[c]:{value:n,writable:!1}})}function x(){f(`getStepMetadata()`,`https://workflow-sdk.dev/docs/api-reference/workflow/get-step-metadata`,x)}function S(){d(`resumeHook()`,`https://workflow-sdk.dev/docs/api-reference/workflow-api/resume-hook`,S)}export{t as FatalError,e as RetryableError,g as createHook,_ as createWebhook,v as defineHook,x as getStepMetadata,l as getWorkflowMetadata,b as getWritable,S as resumeHook,y as setAttributes,m as sleep};

package/dist/src/compiled/@workflow/errors/index.d.ts

@@ -12,6 +12,7 @@ export declare const ERROR_SLUGS: {
     readonly FETCH_IN_WORKFLOW_FUNCTION: "fetch-in-workflow";
     readonly TIMEOUT_FUNCTIONS_IN_WORKFLOW: "timeout-in-workflow";
     readonly HOOK_CONFLICT: "hook-conflict";
+    readonly HOOK_FORCE_CLAIMED: "hook-force-claimed";
     readonly CORRUPTED_EVENT_LOG: "corrupted-event-log";
     readonly REPLAY_DIVERGENCE: "replay-divergence";
     readonly STEP_NOT_REGISTERED: "step-not-registered";
@@ -387,6 +388,28 @@ export declare class HookConflictError extends WorkflowError {
     constructor(token: string, conflictingRunId?: string);
     static is(value: unknown): value is HookConflictError;
 }
+/**
+ * Thrown from `await hook` (or the hook's async iterator) when another run
+ * took this hook's token with `createHook({ token, experimental_force: true })`.
+ *
+ * The hook is disposed: payloads it received before the takeover were still
+ * delivered, everything after goes to the new owner, and this run's log holds
+ * a `hook_disposed` naming the run that took it. Whether that ends the run is
+ * the workflow's call — catch it to hand over gracefully, or let it fail.
+ *
+ * Use the static `HookForceClaimedError.is()` method for type-safe checking
+ * in catch blocks; the class identity differs between the workflow VM and the
+ * host, so `instanceof` is not reliable across that boundary.
+ */
+export declare class HookForceClaimedError extends WorkflowError {
+    token: string;
+    /** The run that took the token. */
+    claimedByRunId: string;
+    /** The hook (in `claimedByRunId`) the token now belongs to. */
+    claimedByHookId?: string;
+    constructor(token: string, claimedByRunId: string, claimedByHookId?: string);
+    static is(value: unknown): value is HookForceClaimedError;
+}
 /**
  * Thrown when calling `resumeHook()` or `resumeWebhook()` with a token that
  * does not match any active hook.

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

@@ -1 +1 @@
-import{A as e,C as t,D as n,E as r,O as i,S as a,T as o,_ as s,a as c,b as l,c as u,d,f,g as p,h as m,i as h,j as g,k as _,l as v,m as y,n as b,o as x,p as S,r as C,s as w,t as T,u as E,v as D,w as O,x as k,y as A}from"../../_chunks/workflow/dist-DtXwQbZr.js";export{T as CorruptedEventLogError,b as ERROR_SLUGS,C as EntityConflictError,h as FatalError,c as HookConflictError,x as HookNotFoundError,w as MaxEventsExceededError,u as PreconditionFailedError,g as RUN_ERROR_CODES,v as ReplayDivergenceError,E as RetryableError,d as RunExpiredError,f as RunNotSupportedError,S as RuntimeDecryptionError,y as SerializationError,m as StepNotRegisteredError,p as StreamError,s as StreamExpiredError,D as ThrottleError,A as TooEarlyError,l as VERCEL_403_ERROR_MESSAGE,k as WorkflowBuildError,a as WorkflowDeploymentMismatchError,t as WorkflowError,O as WorkflowNotRegisteredError,o as WorkflowRunCancelledError,r as WorkflowRunFailedError,n as WorkflowRunNotCompletedError,i as WorkflowRunNotFoundError,_ as WorkflowRuntimeError,e as WorkflowWorldError};
+import{A as e,C as t,D as n,E as r,M as i,O as a,S as o,T as s,_ as c,a as l,b as u,c as d,d as f,f as p,g as m,h,i as g,j as _,k as v,l as y,m as b,n as x,o as S,p as C,r as w,s as T,t as E,u as D,v as O,w as k,x as A,y as j}from"../../_chunks/workflow/dist-BfMqXLK3.js";export{E as CorruptedEventLogError,x as ERROR_SLUGS,w as EntityConflictError,g as FatalError,l as HookConflictError,S as HookForceClaimedError,T as HookNotFoundError,d as MaxEventsExceededError,y as PreconditionFailedError,i as RUN_ERROR_CODES,D as ReplayDivergenceError,f as RetryableError,p as RunExpiredError,C as RunNotSupportedError,b as RuntimeDecryptionError,h as SerializationError,m as StepNotRegisteredError,c as StreamError,O as StreamExpiredError,j as ThrottleError,u as TooEarlyError,A as VERCEL_403_ERROR_MESSAGE,o as WorkflowBuildError,t as WorkflowDeploymentMismatchError,k as WorkflowError,s as WorkflowNotRegisteredError,r as WorkflowRunCancelledError,n as WorkflowRunFailedError,a as WorkflowRunNotCompletedError,v as WorkflowRunNotFoundError,e as WorkflowRuntimeError,_ as WorkflowWorldError};

package/dist/src/compiled/@workflow/world/events.d.ts

@@ -135,6 +135,14 @@ export declare const HookCreatedEventSchema: z.ZodObject<{
         metadata: z.ZodOptional<z.ZodUnion<readonly [z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>]>>;
         isWebhook: z.ZodOptional<z.ZodBoolean>;
         isSystem: z.ZodOptional<z.ZodBoolean>;
+        force: z.ZodOptional<z.ZodBoolean>;
+        forceClaimedFrom: z.ZodOptional<z.ZodObject<{
+            runId: z.ZodString;
+            hookId: z.ZodString;
+            workflowName: z.ZodOptional<z.ZodString>;
+            deploymentId: z.ZodOptional<z.ZodString>;
+            runSpecVersion: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>>;
     }, z.core.$strip>;
 }, z.core.$strip>;
 declare const HookReceivedEventSchema: z.ZodObject<{
@@ -161,6 +169,7 @@ declare const HookConflictEventSchema: z.ZodObject<{
     eventData: z.ZodObject<{
         token: z.ZodString;
         conflictingRunId: z.ZodOptional<z.ZodString>;
+        forceRefusedReason: z.ZodOptional<z.ZodLiteral<"victim-spec-version">>;
     }, z.core.$strip>;
 }, z.core.$strip>;
 /**
@@ -317,6 +326,14 @@ export declare const CreateEventSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
         metadata: z.ZodOptional<z.ZodUnion<readonly [z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>]>>;
         isWebhook: z.ZodOptional<z.ZodBoolean>;
         isSystem: z.ZodOptional<z.ZodBoolean>;
+        force: z.ZodOptional<z.ZodBoolean>;
+        forceClaimedFrom: z.ZodOptional<z.ZodObject<{
+            runId: z.ZodString;
+            hookId: z.ZodString;
+            workflowName: z.ZodOptional<z.ZodString>;
+            deploymentId: z.ZodOptional<z.ZodString>;
+            runSpecVersion: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>>;
     }, z.core.$strip>;
 }, z.core.$strip>, z.ZodObject<{
     specVersion: z.ZodOptional<z.ZodNumber>;
@@ -332,6 +349,10 @@ export declare const CreateEventSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
     correlationId: z.ZodString;
     eventData: z.ZodOptional<z.ZodObject<{
         token: z.ZodOptional<z.ZodString>;
+        forceClaimedBy: z.ZodOptional<z.ZodObject<{
+            runId: z.ZodString;
+            hookId: z.ZodString;
+        }, z.core.$strip>>;
     }, z.core.$strip>>;
 }, z.core.$strip>, z.ZodObject<{
     specVersion: z.ZodOptional<z.ZodNumber>;
@@ -484,6 +505,14 @@ export declare const EventSchema: z.ZodIntersection<z.ZodDiscriminatedUnion<[z.Z
         metadata: z.ZodOptional<z.ZodUnion<readonly [z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>]>>;
         isWebhook: z.ZodOptional<z.ZodBoolean>;
         isSystem: z.ZodOptional<z.ZodBoolean>;
+        force: z.ZodOptional<z.ZodBoolean>;
+        forceClaimedFrom: z.ZodOptional<z.ZodObject<{
+            runId: z.ZodString;
+            hookId: z.ZodString;
+            workflowName: z.ZodOptional<z.ZodString>;
+            deploymentId: z.ZodOptional<z.ZodString>;
+            runSpecVersion: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>>;
     }, z.core.$strip>;
 }, z.core.$strip>, z.ZodObject<{
     specVersion: z.ZodOptional<z.ZodNumber>;
@@ -499,6 +528,10 @@ export declare const EventSchema: z.ZodIntersection<z.ZodDiscriminatedUnion<[z.Z
     correlationId: z.ZodString;
     eventData: z.ZodOptional<z.ZodObject<{
         token: z.ZodOptional<z.ZodString>;
+        forceClaimedBy: z.ZodOptional<z.ZodObject<{
+            runId: z.ZodString;
+            hookId: z.ZodString;
+        }, z.core.$strip>>;
     }, z.core.$strip>>;
 }, z.core.$strip>, z.ZodObject<{
     specVersion: z.ZodOptional<z.ZodNumber>;
@@ -507,6 +540,7 @@ export declare const EventSchema: z.ZodIntersection<z.ZodDiscriminatedUnion<[z.Z
     eventData: z.ZodObject<{
         token: z.ZodString;
         conflictingRunId: z.ZodOptional<z.ZodString>;
+        forceRefusedReason: z.ZodOptional<z.ZodLiteral<"victim-spec-version">>;
     }, z.core.$strip>;
 }, z.core.$strip>, z.ZodObject<{
     specVersion: z.ZodOptional<z.ZodNumber>;

package/dist/src/compiled/@workflow/world/hooks.d.ts

@@ -63,6 +63,26 @@ export type HookResumeCapabilities = z.infer<typeof HookResumeCapabilitiesSchema
  * - specVersion >= 2: Uint8Array (binary devalue format)
  * - specVersion 1: any (legacy JSON format)
  */
+/**
+ * Who a force-claimed hook took its token from. Written by the World in the
+ * same transaction that re-points the token, and returned on the
+ * `hook_created` response and on every later read of the hook.
+ *
+ * `workflowName`, `deploymentId` and `runSpecVersion` are the VICTIM run's:
+ * the claimer's runtime publishes the victim's wake from them (the victim's
+ * replay has to read the `hook_disposed{forceClaimedBy}` row the takeover
+ * left in its log). They are optional only because a World may not have them
+ * for a legacy victim; when absent the runtime skips the wake and the victim
+ * reads the row on its next invocation.
+ */
+export declare const HookClaimedFromSchema: z.ZodObject<{
+    runId: z.ZodString;
+    hookId: z.ZodString;
+    workflowName: z.ZodOptional<z.ZodString>;
+    deploymentId: z.ZodOptional<z.ZodString>;
+    runSpecVersion: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export type HookClaimedFrom = z.infer<typeof HookClaimedFromSchema>;
 export declare const HookSchema: z.ZodObject<{
     runId: z.ZodString;
     hookId: z.ZodString;
@@ -88,6 +108,13 @@ export declare const HookSchema: z.ZodObject<{
     resumeCapabilities: z.ZodOptional<z.ZodObject<{
         hookResumeDedupVersion: z.ZodNumber;
     }, z.core.$strip>>;
+    claimedFrom: z.ZodOptional<z.ZodObject<{
+        runId: z.ZodString;
+        hookId: z.ZodString;
+        workflowName: z.ZodOptional<z.ZodString>;
+        deploymentId: z.ZodOptional<z.ZodString>;
+        runSpecVersion: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>;
 }, z.core.$strip>;
 /**
  * Represents a Hook. Hooks kept by minimum retention remain readable after

package/dist/src/compiled/@workflow/world/index.d.ts

@@ -6,7 +6,7 @@ export { _resetEnvWarnCacheForTests, type EnvNumberOptions, envFlag, envNumber,
 export type * from './events.js';
 export { BaseEventSchema, CHILD_ENTITY_CREATION_EVENT_TYPES, CreateEventSchema, classifyEntityEvent, EventSchema, EventTypeSchema, entityEventClass, getEventDataPayloadField, getEventDataRefFields, HOOK_EVENTS_REQUIRING_EXISTENCE, HOOK_LIFECYCLE_EVENT_TYPES, HookCreatedEventSchema, isChildEntityCreationEvent, isChildEntityCreationEventType, isHookEventRequiringExistence, isHookLifecycleEventType, isRunEventType, isSealedNoopEvent, isStepEventType, isTerminalRunEventType, isTerminalStepEventType, isWaitEventType, RUN_ENTITY_KEY, RUN_EVENT_TYPES, STEP_EVENT_TYPES, stripEventDataRefs, TERMINAL_EVENT_CLASSES, TERMINAL_RUN_EVENT_TYPES, TERMINAL_STEP_EVENT_TYPES, TerminalRunEventTypeSchema, WAIT_EVENT_TYPES, } from './events.js';
 export type * from './hooks.js';
-export { HOOK_RESUME_DEDUP_VERSION, HOOK_RESUME_INPUT_VERSION, HookResumeCapabilitiesSchema, HookSchema, } from './hooks.js';
+export { HOOK_RESUME_DEDUP_VERSION, HOOK_RESUME_INPUT_VERSION, HookClaimedFromSchema, HookResumeCapabilitiesSchema, HookSchema, } from './hooks.js';
 export type * from './interfaces.js';
 export type { InvocationOutcome, SerializedWorkflowError, } from './invocation.js';
 export { isNodeHttpEnabled, NODE_HTTP_DEFAULT, NODE_HTTP_ENV_VAR, } from './node-http-flag.js';
@@ -22,7 +22,7 @@ export type { GetChunksOptions, StreamChunk, StreamChunksResponse, StreamInfoRes
 export { PaginatedResponseSchema, StructuredErrorSchema, } from './shared.js';
 export { EVENT_ID_BODY_LENGTH, EVENT_ID_PREFIX, eventIdToSlot, FIRST_EVENT_SLOT, isSlotBody, isSlotEventId, MAX_EVENT_SLOT, requireEventSlot, slotToEventId, } from './slot-identity.js';
 export type { SpecVersion } from './spec-version.js';
-export { isLegacySpecVersion, mintedSpecVersion, requiresNewerWorld, SEALED_LOG_ENV_VAR, SPEC_VERSION_CURRENT, SPEC_VERSION_LEGACY, SPEC_VERSION_MAX_SUPPORTED, SPEC_VERSION_SUPPORTS_ATTRIBUTES, SPEC_VERSION_SUPPORTS_CBOR_QUEUE_TRANSPORT, SPEC_VERSION_SUPPORTS_COMPRESSION, SPEC_VERSION_SUPPORTS_EVENT_SOURCING, SPEC_VERSION_SUPPORTS_SEALED_LOG, SPEC_VERSION_SUPPORTS_SLOT_IDENTITY, } from './spec-version.js';
+export { isLegacySpecVersion, mintedSpecVersion, requiresNewerWorld, SEALED_LOG_ENV_VAR, SPEC_VERSION_CURRENT, SPEC_VERSION_LEGACY, SPEC_VERSION_MAX_SUPPORTED, SPEC_VERSION_SUPPORTS_ATTRIBUTES, SPEC_VERSION_SUPPORTS_CBOR_QUEUE_TRANSPORT, SPEC_VERSION_SUPPORTS_COMPRESSION, SPEC_VERSION_SUPPORTS_EVENT_SOURCING, SPEC_VERSION_SUPPORTS_HOOK_FORCE_CLAIM, SPEC_VERSION_SUPPORTS_SEALED_LOG, SPEC_VERSION_SUPPORTS_SLOT_IDENTITY, } from './spec-version.js';
 export type * from './steps.js';
 export { isTerminalStepStatus, StepSchema, StepStatusSchema, TERMINAL_STEP_STATUSES, TerminalStepStatusSchema, } from './steps.js';
 export type { WorkflowRunId } from './ulid.js';

package/dist/src/compiled/@workflow/world/interfaces.d.ts

@@ -433,6 +433,30 @@ export interface WorldCapabilities {
      * `resumeCapabilities.hookResumeDedupVersion` on the by-token hook.
      */
     hookResumeDedup?: boolean;
+    /**
+     * Supports `createHook({ experimental_force: true })`: a `hook_created`
+     * carrying `eventData.force` whose token is held by another live run takes
+     * the token over instead of returning `hook_conflict`. The World must:
+     *
+     *   1. append `hook_disposed{forceClaimedBy: { runId, hookId }}` to the
+     *      current owner's log — atomically with whatever that World uses to
+     *      refuse later `hook_received` writes to it — BEFORE re-pointing the
+     *      token, so a delivery that already resolved the old owner is refused
+     *      rather than landing in a run that no longer holds the token;
+     *   2. re-point the token to the claimer atomically, recording
+     *      `Hook.claimedFrom` on the claimer's hook;
+     *   3. journal the claimer's `hook_created{force, forceClaimedFrom}`,
+     *      refusing it if the claimer's own hook was taken over in between;
+     *   4. answer a `hook_received` refused by a takeover with
+     *      `HookForceClaimedError` (not `HookNotFoundError`), after completing
+     *      the re-pointing if the claimer had not, so `resumeHook()` can follow
+     *      the token to its new owner and retry with the same `resumeId`.
+     *
+     * Formalised in `workflow-server/specs/HookForceClaim.tla`. A World that
+     * cannot give these guarantees must leave this unset; the runtime then
+     * rejects `experimental_force` at `createHook()` time.
+     */
+    hookForceClaim?: boolean;
     /**
      * Deployments are atomic and immutable: a deployment id names one fixed
      * build for its whole lifetime, so a run pinned to one may only execute

package/dist/src/compiled/@workflow/world/spec-version.d.ts

@@ -64,9 +64,29 @@ export declare const SPEC_VERSION_SUPPORTS_SLOT_IDENTITY: SpecVersion;
  * that does so needs the sealing half.
  */
 export declare const SPEC_VERSION_SUPPORTS_SEALED_LOG: SpecVersion;
+/**
+ * Runs at this spec version or later understand an INVOLUNTARY hook disposal:
+ * a `hook_disposed` carrying `forceClaimedBy`, written into the run's log by
+ * another run's `createHook({ experimental_force: true })`. A reader at this
+ * version rejects the hook's awaiters with `HookForceClaimedError` and settles
+ * `getConflict()`; a reader below it treats the row as its own `dispose()`
+ * and leaves every `await hook` pending forever — the run is not corrupted,
+ * but it is silently stranded. Like the sealed log, this is a READER contract,
+ * and the version is what lets a World tell the two readers apart: a World
+ * only takes a token from a running victim stamped at or above this version,
+ * and answers the forced creation with an ordinary `hook_conflict`
+ * (`forceRefusedReason: 'victim-spec-version'`) otherwise. A finished victim
+ * has no reader to strand, so a retained token is taken over at any version.
+ *
+ * The Python SDK stamps its own spec versions below this one, so a Python
+ * run's token can never be taken over — its runtime knows nothing of
+ * `forceClaimedBy` either.
+ */
+export declare const SPEC_VERSION_SUPPORTS_HOOK_FORCE_CLAIM: SpecVersion;
 /**
  * Current spec version: event-sourced architecture with native attributes,
- * compressed payloads, slot-numbered event ids, and sealed-log sequencing.
+ * compressed payloads, slot-numbered event ids, sealed-log sequencing, and
+ * involuntary hook disposal.
  *
  * This is both the version a World stamps on the runs it creates and the
  * *lowest* one this runtime accepts from a World (see
@@ -98,9 +118,12 @@ export declare const SPEC_VERSION_CURRENT: SpecVersion;
  */
 export declare const SEALED_LOG_ENV_VAR = "WORKFLOW_SEALED_LOG";
 /**
- * The spec version a World should stamp on the runs it creates: the sealed log
- * unless {@link SEALED_LOG_ENV_VAR} switches it off, in which case the
- * slot-identity version it supersedes.
+ * The spec version a World should stamp on the runs it creates: the current
+ * version (sealed log plus involuntary hook disposal) unless
+ * {@link SEALED_LOG_ENV_VAR} switches the sealed log off, in which case the
+ * slot-identity version it supersedes. Versions are linear, so switching the
+ * sealed log off also drops below {@link SPEC_VERSION_SUPPORTS_HOOK_FORCE_CLAIM}:
+ * runs minted that way can force-claim, but cannot be force-claimed from.
  *
  * Same shape, and the same reasoning, as the flag slot identity itself shipped
  * behind before going unconditional: default on, with one env var to put a
@@ -135,14 +158,12 @@ export declare function mintedSpecVersion(env?: Record<string, string | undefine
 /**
  * The highest spec version this SDK can read.
  *
- * Kept distinct from `SPEC_VERSION_CURRENT`, and right now they genuinely
- * differ. They answer different questions, "what do we write?" versus "what
- * can we still read?", and they come apart in exactly the release order a spec
- * bump follows: a reader that can already handle the next version raises this
+ * Kept distinct from `SPEC_VERSION_CURRENT` even when they coincide. They
+ * answer different questions, "what do we write?" versus "what can we still
+ * read?", and they come apart in exactly the release order a spec bump
+ * follows: a reader that can already handle the next version raises this
  * ceiling first, and stamping follows only once the version is safe to mint
- * everywhere. Sealed-log support is at that first stage. Every build reads
- * spec 7 and skips `noop`, while {@link mintedSpecVersion} still has to be
- * turned on before anything creates a spec-7 run.
+ * everywhere.
  */
 export declare const SPEC_VERSION_MAX_SUPPORTED: SpecVersion;
 /**