eve 0.29.4 → 0.30.0

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

@@ -0,0 +1,155 @@
+/**
+ * Hardened introspection for serializing values that may originate inside a
+ * workflow VM (`node:vm`) sandbox realm.
+ *
+ * Serialization runs on the host, but the values it inspects were
+ * constructed by workflow code — so a naive dynamic operation like
+ * `value.toISOString()`, `Array.from(map)`, or `Object.prototype.toString`
+ * dispatches into the sandbox realm and executes workflow code (patched
+ * prototype methods, getters, proxy traps, `Symbol.toStringTag` accessors).
+ * That is a determinism hazard: serialization happens exactly once per
+ * payload (never again on replay), so any workflow-visible side effect it
+ * triggers exists only on the live execution path and diverges from replay.
+ *
+ * This module makes serialization side-effect free wherever the data allows
+ * it, and *observable* where it does not:
+ *
+ * - **Classification** uses engine-level brand checks (`node:util` `types`,
+ *   internal-slot probes) instead of `instanceof` / `Object.prototype.toString`
+ *   — immune to `Symbol.hasInstance`, `Symbol.toStringTag`, and reassigned
+ *   globals.
+ * - **Extraction** goes through intrinsics captured at module load (host
+ *   boot, before any workflow code runs). Internal slots are realm-agnostic,
+ *   so host intrinsics read VM-realm objects without touching the sandbox's
+ *   (patchable) prototypes.
+ * - **Property access** reads through descriptors, so plain data never
+ *   invokes anything. Where workflow code *must* run because the data itself
+ *   lives behind it — getters, proxies, custom `[WORKFLOW_SERIALIZE]`
+ *   methods, `toString()` on toStringTag-branded objects (e.g. Temporal
+ *   polyfills) — the execution is preserved for compatibility and recorded
+ *   in the active {@link GuestCodeStats} sink, so callers (e.g. a retained-VM
+ *   gate) can react.
+ *
+ * **Recording is not prevention.** For the recorded cases the determinism
+ * hazard is still live: a getter that calls `Math.random()` advances the
+ * run's seeded PRNG during serialization, and because serialization happens
+ * exactly once and is never replayed, every subsequent draw — including the
+ * correlation ids derived from that stream — shifts relative to replay. The
+ * report is the only trace of that; acting on it (warning, demoting a
+ * retained VM to replay) is left to the caller.
+ *
+ * The recorder is ambient module state, set for the duration of a
+ * synchronous `stringify` call via {@link withGuestCodeStats}. devalue's
+ * `stringify` is fully synchronous, so this is safe without async context.
+ */
+import type { StringifyOperations } from '../_devalue.js';
+/**
+ * A single instance of workflow (guest) code executing during serialization.
+ */
+export interface GuestCodeExecution {
+    /**
+     * What forced the execution:
+     * - `getter`: an accessor property was invoked to read data
+     * - `proxy`: a proxy was introspected, firing its traps. Note this also
+     *   implies a **shape change**: brand checks answer "not that type" for a
+     *   proxy, so a proxied `Map` serializes as a plain object rather than as a
+     *   `Map`, and this report is the only evidence of it. (Such values were
+     *   never serializable before — the internal-slot reads in the previous
+     *   implementation threw on them — so the shape change replaces a crash,
+     *   but it is silent.)
+     * - `method`: a workflow-defined function was invoked (e.g. a custom
+     *   `[WORKFLOW_SERIALIZE]` serializer, `toString()` on a
+     *   `Symbol.toStringTag`-branded object, a duck-typed `getTime()`, or a
+     *   `__closureVarsFn` this package did not generate)
+     */
+    kind: 'getter' | 'proxy' | 'method';
+    /** Best-effort context: the property key, method name, or tag involved. */
+    detail?: string;
+}
+/**
+ * Mutable sink recording every workflow-code execution serialization could
+ * not avoid. Pass via `CodecOptions.guestCodeStats`; consumers that retain
+ * the VM across steps can use a non-empty `executions` array as a signal
+ * that the VM state may have been perturbed by serialization.
+ */
+export interface GuestCodeStats {
+    executions: GuestCodeExecution[];
+}
+/**
+ * Runs `fn` (synchronously) with `stats` as the active guest-code sink.
+ * Nested calls stack correctly; a `null`/`undefined` sink disables
+ * recording without disabling hardening.
+ */
+export declare function withGuestCodeStats<T>(stats: GuestCodeStats | undefined, fn: () => T): T;
+/** Marks a function as having been passed to `useStep`. */
+export declare function markUseStepClosureFn<T extends object>(fn: T): T;
+/** Whether `fn` was marked by {@link markUseStepClosureFn}. */
+export declare function isUseStepClosureFn(fn: unknown): boolean;
+export declare function recordGuestCode(kind: GuestCodeExecution['kind'], detail?: string): void;
+/** `Date.prototype.getDate`, for invalid-date checks. */
+export declare const dateGetDate: (thisArg: unknown) => number;
+/** `Date.prototype.getTime`. */
+export declare const dateGetTime: (thisArg: unknown) => number;
+/** `Date.prototype.toISOString`. */
+export declare const dateToISOString: (thisArg: unknown) => string;
+/** `RegExp.prototype.source` getter. */
+export declare const regExpSource: (value: unknown) => string;
+/** `RegExp.prototype.flags` getter. */
+export declare const regExpFlags: (value: unknown) => string;
+/** `ArrayBuffer.prototype.byteLength` getter (internal slot read). */
+export declare const arrayBufferByteLength: (value: unknown) => number;
+/**
+ * Reads `value[key]` with `[[Get]]` semantics, but through descriptors:
+ * plain data properties never invoke anything; accessor properties are
+ * invoked (the data lives behind them) and recorded; proxies fall back to
+ * a plain read (their traps are the only access path) and are recorded.
+ */
+export declare function readProperty(value: unknown, key: PropertyKey): unknown;
+/**
+ * `key in value` semantics without firing proxy traps for ordinary
+ * objects. Proxies fall back to the `in` operator and are recorded.
+ */
+export declare function hasProperty(value: unknown, key: PropertyKey): boolean;
+/**
+ * `value instanceof C` semantics for a known `C.prototype`, without
+ * consulting `Symbol.hasInstance` (which workflow code can define). Used
+ * for host classes that are injected into the sandbox (Headers, URL,
+ * URLSearchParams, DOMException), where the instances — from any realm the
+ * host handed the class to — carry the host prototype in their chain.
+ *
+ * Proxies are walked rather than rejected: `Reflect.getPrototypeOf` fires
+ * the proxy's `getPrototypeOf` trap, matching `instanceof` semantics, and
+ * real values depend on that — Next.js hands the runtime a proxied
+ * `NextRequest`, and answering "not a Request" for it would silently break
+ * webhooks. The traps are guest-observable, so the proxy is recorded.
+ */
+export declare function isInstanceOfPrototype(value: unknown, prototype: object | undefined): boolean;
+/** `URL.prototype.href` getter. */
+export declare function urlHref(value: URL): string;
+/** `URLSearchParams.prototype.toString` — returns `''` iff empty. */
+export declare function urlSearchParamsToString(value: URLSearchParams): string;
+/**
+ * Iterates a Headers instance through the captured host iterator, so the
+ * iterator object — and its `next` — are host-realm.
+ */
+export declare function headersToEntries(value: Headers): [string, string][];
+/**
+ * Iterates a genuine Map's entries entirely through host intrinsics: the
+ * iterator object is created by the host `Map.prototype.entries`, so its
+ * realm — and therefore its `next` — is the host's, not the sandbox's.
+ */
+export declare function mapToEntries(value: Map<unknown, unknown>): [unknown, unknown][];
+/** See {@link mapToEntries}. */
+export declare function setToValues(value: Set<unknown>): unknown[];
+/**
+ * The bytes of an `ArrayBufferView`, read via internal-slot getters —
+ * own-property shadowing and prototype patches cannot change which bytes
+ * are serialized.
+ */
+export declare function viewInfo(value: ArrayBufferView): {
+    buffer: ArrayBufferLike;
+    byteOffset: number;
+    byteLength: number;
+};
+export declare const hardenedStringifyOperations: Partial<StringifyOperations>;
+//# sourceMappingURL=hardened.d.ts.map

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

@@ -4,11 +4,12 @@
  * Re-exports the mode-specific serialize/deserialize functions and
  * the codec/format/encryption abstractions.
  */
-export type { Codec, SerializationMode } from './codec.js';
+export type { Codec, CodecOptions, SerializationMode } from './codec.js';
 export { devalueCodec } from './codec-devalue.js';
 export { COMPRESSION_MIN_BYTES, type CompressionCodec, type CompressionStats, compress, decompress, isCompressed, } from './compression.js';
 export { type CryptoKey, decrypt, type EncryptionKeyParam, encrypt, } from './encryption.js';
 export { decodeFormatPrefix, encodeWithFormatPrefix, isEncrypted, peekFormatPrefix, } from './format.js';
+export type { GuestCodeExecution, GuestCodeStats } from './hardened.js';
 export type { FormatPrefix, Reducers, Revivers, SerializableSpecial, } from './types.js';
 export { isFormatPrefix, SerializationFormat } from './types.js';
 import * as client from './client.js';

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

@@ -10,7 +10,7 @@
  */
 import type { Reducers, Revivers } from '../types.js';
 declare function revive(str: string): any;
-export declare function getCommonReducers(global?: Record<string, any>): Partial<Reducers>;
+export declare function getCommonReducers(_global?: Record<string, any>): Partial<Reducers>;
 export declare function getCommonRevivers(global?: Record<string, any>): Partial<Revivers>;
 export { revive };
 //# sourceMappingURL=common.d.ts.map

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

@@ -1,6 +1,7 @@
 import { compress, decompress } from './serialization/compression.js';
 import { aesKeyOf, decrypt, deriveRunPayloadKeys, type EncryptionKeyParam, encrypt, isRunPayloadKeys, isSealTarget, type PayloadKey, type RunPayloadKeys, runPayloadKeys, type SealTarget, sealTo } from './serialization/encryption.js';
 import { decodeFormatPrefix, encodeWithFormatPrefix, isEncrypted, peekFormatPrefix } from './serialization/format.js';
+import { type GuestCodeStats } from './serialization/hardened.js';
 import { type FormatPrefix, isFormatPrefix, SerializationFormat } from './serialization/types.js';
 export { SerializationFormat, type FormatPrefix, isFormatPrefix, encodeWithFormatPrefix, decodeFormatPrefix, peekFormatPrefix, isEncrypted, encrypt, decrypt, compress, decompress, type EncryptionKeyParam, type PayloadKey, type RunPayloadKeys, type SealTarget, sealTo, runPayloadKeys, deriveRunPayloadKeys, isSealTarget, isRunPayloadKeys, aesKeyOf, };
 export type SerializationFormatType = (typeof SerializationFormat)[keyof typeof SerializationFormat];
@@ -121,13 +122,6 @@ import type { ByteStreamFraming, Reducers, Revivers } from './serialization/type
  * @returns
  */
 export declare function getExternalReducers(global: Record<string, any> | undefined, ops: Promise<void>[], runId: string, cryptoKey: EncryptionKeyParam, framedByteStreams?: boolean, runReadyBarrier?: Promise<unknown>): Partial<Reducers>;
-/**
- * Reducers for serialization boundary from within the workflow execution
- * environment, passing return value to the client side and into step arguments.
- *
- * @param global
- * @returns
- */
 export declare function getWorkflowReducers(global?: Record<string, any>): Partial<Reducers>;
 /**
  * Cancel dangling abort-stream readers on any AbortController instances found
@@ -394,7 +388,15 @@ export declare function hydrateWorkflowArguments(value: Uint8Array | unknown, _r
 /**
  * Dehydrate workflow return value for storage.
  */
-export declare function dehydrateWorkflowReturnValue(value: unknown, _runId: string, key: PayloadKey | undefined, global?: Record<string, any>, v1Compat?: boolean, compression?: boolean): Promise<Uint8Array | unknown>;
+export declare function dehydrateWorkflowReturnValue(value: unknown, _runId: string, key: PayloadKey | undefined, global?: Record<string, any>, v1Compat?: boolean, compression?: boolean, 
+/**
+ * Optional sink receiving every workflow-code execution serialization could
+ * not avoid, for callers that need them programmatically (e.g. a
+ * retained-VM gate deciding whether the VM is still reusable). The
+ * executions are emitted as span attributes either way, so omitting this
+ * loses nothing observability-wise. No runtime caller passes one yet.
+ */
+guestCodeStatsOut?: GuestCodeStats): Promise<Uint8Array | unknown>;
 /**
  * Called from the client side to hydrate the workflow return value
  * of a completed workflow run.
@@ -404,7 +406,9 @@ export declare function hydrateWorkflowReturnValue(value: Uint8Array | unknown,
  * Called from the workflow handler when a step is being created.
  * Dehydrates values from within the workflow execution environment.
  */
-export declare function dehydrateStepArguments(value: unknown, _runId: string, key: PayloadKey | undefined, global?: Record<string, any>, v1Compat?: boolean, compression?: boolean): Promise<Uint8Array | unknown>;
+export declare function dehydrateStepArguments(value: unknown, _runId: string, key: PayloadKey | undefined, global?: Record<string, any>, v1Compat?: boolean, compression?: boolean, 
+/** See `dehydrateWorkflowReturnValue`. */
+guestCodeStatsOut?: GuestCodeStats): Promise<Uint8Array | unknown>;
 /**
  * Called from the step executor to hydrate the arguments of a step
  * from the database at the start of the step execution.

package/dist/src/compiled/@workflow/core/step/context-storage.d.ts

@@ -1,6 +1,6 @@
 import { AsyncLocalStorage } from 'node:async_hooks';
-import type { PayloadKey } from '../serialization/encryption.js';
 import type { FlushableStreamState } from '../flushable-stream.js';
+import type { PayloadKey } from '../serialization/encryption.js';
 import type { WorkflowMetadata } from '../workflow/get-workflow-metadata.js';
 import type { StepMetadata } from './get-step-metadata.js';
 /**

package/dist/src/compiled/@workflow/core/telemetry/semantic-conventions.d.ts

@@ -140,6 +140,15 @@ export declare const WorkflowRouteEntrypointAgeMs: (value: number) => {
 export declare const WorkflowRouteModuleBodyInitMs: (value: number) => {
     [k: string]: number;
 };
+/**
+ * Compute instance handling this route — the synthesized `COMPUTE_INSTANCE_ID`.
+ * Uses OTEL `faas.instance` (execution-environment id, reused across
+ * invocations to the same function):
+ * https://opentelemetry.io/docs/specs/semconv/attributes-registry/faas/
+ */
+export declare const FaasInstance: (value: string) => {
+    [k: string]: string;
+};
 /** Name of the step function being executed */
 export declare const StepName: (value: string) => {
     [k: string]: string;
@@ -289,6 +298,24 @@ export declare const HookId: (value: string) => {
 export declare const HookFound: (value: boolean) => {
     [k: string]: boolean;
 };
+/**
+ * Producer-side signal (on the `hook.resume` span) that the direct
+ * `hook_received` write failed transiently but the queue dispatch succeeded, so
+ * the resume is recovered via the consumer's re-ensure. Corresponds to
+ * `ResumedHook.resilientResume === true`.
+ */
+export declare const HookResilientResume: (value: boolean) => {
+    [k: string]: boolean;
+};
+/**
+ * Consumer-side signal (on the workflow execution span) that this replay
+ * materialized the `hook_received` event from the queue message's `hookInput`
+ * because the producer's direct write had not landed — the completion of the
+ * recovery path {@link HookResilientResume} began.
+ */
+export declare const HookResilientResumeMaterialized: (value: boolean) => {
+    [k: string]: boolean;
+};
 /** Number of webhook handlers triggered */
 export declare const WebhookHandlersTriggered: (value: number) => {
     [k: string]: number;
@@ -377,6 +404,20 @@ export declare const SerializationStoredBytes: (value: number) => {
 export declare const SerializationCompressionRatio: (value: number) => {
     [k: string]: number;
 };
+/**
+ * Number of workflow (guest) code executions serialization could not avoid
+ * (getters, proxies, custom serializers); set only when non-zero.
+ */
+export declare const SerializationGuestCodeExecutions: (value: number) => {
+    [k: string]: number;
+};
+/**
+ * Deduplicated `kind (detail)` descriptions of the guest-code executions;
+ * set only when non-zero.
+ */
+export declare const SerializationGuestCodeDetails: (value: string[]) => {
+    [k: string]: string[];
+};
 /** The remote service name for Datadog service maps (Datadog-specific: peer.service) */
 export declare const PeerService: (value: string) => {
     [k: string]: string;

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

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

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

@@ -1 +1 @@
-import{Fn as e,Nn as t,On as n,Pn as r,_n as i,gn as a}from"../../_chunks/workflow/wait-until-z48sPUjU.js";import"../../_chunks/workflow/dist-B-vbuNqP.js";import{i as o}from"../../_chunks/workflow/workflow-routes-CwqB063q.js";import{i as s,u as c}from"../../_chunks/workflow/dist-BeQ_csYA.js";import{c as l,i as u,o as d,r as f,t as p}from"../../_chunks/workflow/attribute-changes-1LmTKuTT.js";import{t as m}from"../../_chunks/workflow/sleep-De802yfX.js";import{t as h}from"../../_chunks/workflow/run-C240Ctf4.js";i(a,h);function g(e){let n=globalThis[t];return n||u(`createHook()`,`https://workflow-sdk.dev/docs/api-reference/workflow/create-hook`,g),n(e)}function _(e){let{respondWith:t,token:n,...r}=e??{};if(n!==void 0)throw Error("`createWebhook()` does not accept a `token` option. Webhook tokens are always randomly generated. Use `createHook()` with `resumeHook()` for deterministic token patterns.");let i;t!==void 0&&(i={respondWith:t});let a=g({...r,metadata:i,isWebhook:!0}),{url:s}=l();return a.url=o(s,{type:`webhook`,token:a.token}),a}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[e];if(!a)throw new s("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,i=globalThis[r](t);return Object.create(globalThis.WritableStream.prototype,{[n]:{value:i,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{s as FatalError,c 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{Cn as e,Gn as t,Kn as n,Wn as r,wn as i,zn as a}from"../../_chunks/workflow/wait-until-DoW76jdb.js";import"../../_chunks/workflow/dist-B-vbuNqP.js";import{i as o}from"../../_chunks/workflow/workflow-routes-CwqB063q.js";import{i as s,u as c}from"../../_chunks/workflow/dist-dNxTT6nO.js";import{c as l,i as u,o as d,r as f,t as p}from"../../_chunks/workflow/attribute-changes-DROfGk6l.js";import{t as m}from"../../_chunks/workflow/sleep-D5iWly6-.js";import{t as h}from"../../_chunks/workflow/run-DM3ouA3U.js";i(e,h);function g(e){let t=globalThis[r];return t||u(`createHook()`,`https://workflow-sdk.dev/docs/api-reference/workflow/create-hook`,g),t(e)}function _(e){let{respondWith:t,token:n,...r}=e??{};if(n!==void 0)throw Error("`createWebhook()` does not accept a `token` option. Webhook tokens are always randomly generated. Use `createHook()` with `resumeHook()` for deterministic token patterns.");let i;t!==void 0&&(i={respondWith:t});let a=g({...r,metadata:i,isWebhook:!0}),{url:s}=l();return a.url=o(s,{type:`webhook`,token:a.token}),a}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,t={}){let r=p(e,t);if(r.length===0)return;let i=t.allowReservedAttributes===!0,a=globalThis[n];if(!a)throw new s("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:n}=e,r=globalThis[t](n);return Object.create(globalThis.WritableStream.prototype,{[a]:{value:r,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{s as FatalError,c 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

@@ -446,21 +446,29 @@ export declare class ThrottleError extends WorkflowWorldError {
 }
 /**
  * Thrown when the backend rejects an event creation because the client's
- * event-log snapshot is stale — a newer out-of-band event (e.g. a received
- * hook or a completed step) was recorded after the snapshot the client
- * replayed from (HTTP 412).
+ * event-log snapshot is stale — the log the client replayed from is missing
+ * an event the backend has already recorded (HTTP 412).
  *
- * The workflow runtime handles this automatically: it reloads the event log
- * and retries, ultimately re-enqueueing the run if it cannot catch up. Users
- * interacting with world storage backends directly may encounter it.
+ * The workflow runtime handles this automatically: it restarts the replay from
+ * a corrected event log, ultimately re-enqueueing the run if it cannot catch
+ * up. Users interacting with world storage backends directly may encounter it.
  *
  * @property retryAfter - Delay in seconds before retrying. Accepted for
- *   forward-compatibility; the runtime currently reloads and retries
- *   immediately and does not read this field.
+ *   forward-compatibility; the runtime restarts its replay immediately and
+ *   does not read this field.
+ * @property details - Optional rejection detail supplied by the World. A World
+ *   MAY attach the events the client's snapshot was missing so the client can
+ *   correct its log without a follow-up fetch; see the `stateCursor` contract
+ *   on `CreateEventParams`. Typed `unknown` because this package cannot depend
+ *   on the event type — consumers narrow it themselves and must treat a
+ *   missing or malformed value as "no detail" (a full reload is always
+ *   correct).
  */
 export declare class PreconditionFailedError extends WorkflowWorldError {
+    readonly details?: unknown;
     constructor(message: string, options?: {
         retryAfter?: number;
+        details?: unknown;
     });
     static is(value: unknown): value is PreconditionFailedError;
 }

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

@@ -1 +1 @@
-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/dist-BeQ_csYA.js";export{S as CorruptedEventLogError,_ as ERROR_SLUGS,b as EntityConflictError,m as FatalError,s as HookConflictError,v as HookNotFoundError,x as MaxEventsExceededError,l as PreconditionFailedError,r as RUN_ERROR_CODES,h as ReplayDivergenceError,C as RetryableError,u as RunExpiredError,d as RunNotSupportedError,y as RuntimeDecryptionError,g as SerializationError,p as StepNotRegisteredError,f as ThrottleError,o as TooEarlyError,w as VERCEL_403_ERROR_MESSAGE,D as WorkflowBuildError,c as WorkflowError,E as WorkflowNotRegisteredError,i as WorkflowRunCancelledError,e as WorkflowRunFailedError,T as WorkflowRunNotCompletedError,a as WorkflowRunNotFoundError,n as WorkflowRuntimeError,t as WorkflowWorldError};
+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/dist-dNxTT6nO.js";export{S as CorruptedEventLogError,_ as ERROR_SLUGS,b as EntityConflictError,m as FatalError,s as HookConflictError,v as HookNotFoundError,x as MaxEventsExceededError,l as PreconditionFailedError,r as RUN_ERROR_CODES,h as ReplayDivergenceError,C as RetryableError,u as RunExpiredError,d as RunNotSupportedError,y as RuntimeDecryptionError,g as SerializationError,p as StepNotRegisteredError,f as ThrottleError,o as TooEarlyError,w as VERCEL_403_ERROR_MESSAGE,D as WorkflowBuildError,c as WorkflowError,E as WorkflowNotRegisteredError,i as WorkflowRunCancelledError,e as WorkflowRunFailedError,T as WorkflowRunNotCompletedError,a as WorkflowRunNotFoundError,n as WorkflowRuntimeError,t as WorkflowWorldError};

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

@@ -41,6 +41,7 @@ export declare const AnalyticsStepSchema: z.ZodObject<{
     errorCode: z.ZodOptional<z.ZodNullable<z.ZodString>>;
     workflowCoreVersion: z.ZodOptional<z.ZodNullable<z.ZodString>>;
     workflowEncryptionEnabled: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
+    computeInstanceId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
 }, z.core.$strip>;
 export declare const AnalyticsEventSchema: z.ZodObject<{
     runId: z.ZodString;
@@ -75,6 +76,7 @@ export declare const AnalyticsEventSchema: z.ZodObject<{
     region: z.ZodOptional<z.ZodNullable<z.ZodString>>;
     vercelId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
     requestId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    computeInstanceId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
     resumeAt: z.ZodOptional<z.ZodNullable<z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodCoercedDate<unknown>>>>;
     retryAfter: z.ZodOptional<z.ZodNullable<z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodCoercedDate<unknown>>>>;
     errorCode: z.ZodOptional<z.ZodNullable<z.ZodString>>;

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

@@ -548,6 +548,7 @@ export declare const EventSchema: z.ZodIntersection<z.ZodDiscriminatedUnion<[z.Z
     createdAt: z.ZodCoercedDate<unknown>;
     occurredAt: z.ZodOptional<z.ZodCoercedDate<unknown>>;
     specVersion: z.ZodOptional<z.ZodNumber>;
+    resumeId: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>>;
 export type Event = z.infer<typeof EventSchema>;
 export type EventOfType<T extends EventType> = Extract<Event, {
@@ -586,8 +587,31 @@ export type CreateEventRequest = Exclude<AnyEventRequest, RunCreatedEventRequest
 export interface CreateEventParams {
     v1Compat?: boolean;
     resolveData?: ResolveData;
+    /**
+     * Lazy hook resume idempotency key. Set only by `resumeHook()` when it
+     * persists a `hook_received` event whose creation must be deduplicated
+     * against a concurrent re-ensure from the queue consumer. The World routes
+     * it to the backend's `(runId, resumeId)` constraint so both writers
+     * converge on exactly one event. Only meaningful for `hook_received`.
+     */
+    resumeId?: string;
+    /**
+     * Content digest of the serialized resume payload, computed once by
+     * `resumeHook()` and forwarded identically on the direct write and the queue
+     * re-ensure. The World routes it to the backend so both writers record the
+     * same digest on the `(runId, resumeId)` constraint. Only meaningful
+     * alongside {@link resumeId}.
+     */
+    resumePayloadDigest?: string;
     /** Request ID (x-vercel-id when on Vercel) for correlating request logs with workflow events. */
     requestId?: string;
+    /**
+     * Compute instance whose handler is writing this event (`COMPUTE_INSTANCE_ID`
+     * in @workflow/core). Ambient per-event identity like {@link requestId},
+     * which distinguishes invocations *within* an instance. Read back via
+     * `AnalyticsEventSchema` / `AnalyticsStepSchema`.
+     */
+    computeInstanceId?: string;
     /**
      * Epoch ms (the ULID time of the latest event the runtime has loaded during
      * replay). Sent by replay-context creates so the backend can reject the event
@@ -604,14 +628,77 @@ export interface CreateEventParams {
      * timestamp must pass (anti-livelock, so an up-to-date client is never
      * rejected). A backend that ignores this field simply disables the guard —
      * the client falls open and behaves as before.
+     *
+     * A watermark alone cannot see an event *missing at or below* it, which is
+     * the failure that actually corrupts a replay — see {@link stateEventCount}
+     * for the second half of the guard.
      */
     stateUpdatedAt?: number;
+    /**
+     * How many loaded events have a ULID time at or below {@link stateUpdatedAt}.
+     * Since `stateUpdatedAt` is the *maximum* ULID time in the loaded log, this
+     * equals the loaded array's length. Sent **only** together with
+     * `stateUpdatedAt`; a World must ignore a count that arrives without one.
+     *
+     * This closes the hole a watermark cannot: the watermark proves only "no
+     * newer event exists", while a replay corrupts its log by missing an event
+     * at or *below* its own frontier — a concurrent writer commits in the same
+     * ULID millisecond as the client's last loaded event, so the two watermarks
+     * compare equal and the write is accepted against a log that is one event
+     * short. Because correlation IDs are positional ordinals of a single seeded
+     * sequence, that one-event difference renames every entity after it.
+     *
+     * Backend contract (for World implementers who want to support this half):
+     *
+     * - Count **every** created event for the run, including replay-origin ones.
+     *   Unlike the watermark, this is not restricted to out-of-band writes: the
+     *   race being fenced is one replay against another.
+     * - Reject with 412 when the count of recorded events at ULID time
+     *   `<= stateUpdatedAt` is strictly **greater** than `stateEventCount`.
+     * - Compare **at or below** `stateUpdatedAt`, never strictly below (the
+     *   missing event routinely shares the client's frontier millisecond) and
+     *   never against a total (all the creates of one suspension share one
+     *   snapshot, so a total would reject every sibling after the first).
+     * - **One-sided safety is mandatory.** Anything that makes the backend's
+     *   count incomplete, uncomputable, or expired must *allow* the write. A
+     *   rejection has to imply a real hole, because the client responds to it by
+     *   discarding and re-deriving its whole replay.
+     *
+     * See also the millisecond-granularity caveat on `stateUpdatedAt`: the count
+     * is what makes an equal-timestamp snapshot safe to accept.
+     */
+    stateEventCount?: number;
+    /**
+     * The client's current event-log cursor (advisory). Sent alongside the other
+     * two snapshot fields so a World that rejects the write MAY return the
+     * events the client is missing on the 412 itself, saving the client a
+     * follow-up `events.list`.
+     *
+     * Distinct from {@link sinceCursor}: a World must **not** compute a delta for
+     * this on the accepted path — it exists purely to make a rejection cheaper.
+     * Returning events on a 412 is OPTIONAL, and the returned set must be
+     * provably complete (it must account for the entire discrepancy the
+     * rejection reported) or omitted entirely: a cursor filters by lexicographic
+     * event id while a hole is defined by ULID time, so a naive
+     * "everything after the cursor" delta can silently exclude the very event
+     * the client is missing. A client that receives nothing does the
+     * authoritative full reload, which is always correct.
+     */
+    stateCursor?: string;
     /**
      * Timestamp for when the event occurred on the client side. Worlds that
      * support this can persist it separately from `createdAt`, which represents
      * when the backing service accepted or stored the event.
      */
     occurredAt?: Date;
+    /**
+     * Number of consecutive replay divergences resolved by this event write.
+     *
+     * This is request telemetry, not workflow state. Worlds may use it for
+     * metrics and diagnostics, but must not require it for event
+     * materialization or persist it into the event log.
+     */
+    replayDivergenceCount?: number;
     /**
      * Inline-delta optimization (opt-in). When set, the World MAY return,
      * on the resulting {@link EventResult}, the first page of events written

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

@@ -18,8 +18,43 @@ export declare const HookResumeContextSchema: z.ZodObject<{
     workflowCoreVersion: z.ZodOptional<z.ZodString>;
     traceCarrier: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
     encryptionPublicKey: z.ZodOptional<z.ZodString>;
+    hookResumeInputVersion: z.ZodOptional<z.ZodNumber>;
 }, z.core.$strip>;
 export type HookResumeContext = z.infer<typeof HookResumeContextSchema>;
+/**
+ * Current version of the lazy-hook-resume consumer protocol. A run's creating
+ * deployment stamps this into its execution context (and the server mirrors it
+ * onto `HookResumeContext.hookResumeInputVersion`) to attest that its
+ * `@workflow/core` re-ensures the `hook_received` event from a queue message's
+ * `hookInput`. `resumeHook()`'s parallel fast path requires the target run's
+ * marker to be at least this value. Bump only on a breaking change to the
+ * `hookInput` re-ensure contract.
+ */
+export declare const HOOK_RESUME_INPUT_VERSION = 1;
+/**
+ * Current version of the backend lazy-hook-resume dedup contract: the live
+ * backend enforces a `(runId, resumeId)` constraint so the direct write and the
+ * queue consumer's re-ensure converge on exactly one `hook_received`.
+ * `resumeHook()`'s parallel fast path requires the backend to attest at least
+ * this version. Bump only on a breaking change to the constraint semantics.
+ */
+export declare const HOOK_RESUME_DEDUP_VERSION = 1;
+/**
+ * Backend-attested capabilities for lazy hook resume, computed FRESH on every
+ * by-token hook lookup and returned inline on {@link HookSchema.resumeCapabilities}.
+ *
+ * Response-only and transient: NEVER persisted on the hook entity and NEVER
+ * part of {@link HookResumeContextSchema}. Recomputing it per response is what
+ * makes a server rollback or kill switch take effect immediately — a rolled-back
+ * or kill-switched server simply stops emitting it, dropping new resumes to the
+ * sequential path with no stranded hooks. (Contrast with the per-run, persisted
+ * `hookResumeInputVersion`, which attests the *consumer* and is fixed at run
+ * creation.)
+ */
+export declare const HookResumeCapabilitiesSchema: z.ZodObject<{
+    hookResumeDedupVersion: z.ZodNumber;
+}, z.core.$strip>;
+export type HookResumeCapabilities = z.infer<typeof HookResumeCapabilitiesSchema>;
 /**
  * Schema for workflow hooks.
  *
@@ -46,6 +81,10 @@ export declare const HookSchema: z.ZodObject<{
         workflowCoreVersion: z.ZodOptional<z.ZodString>;
         traceCarrier: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
         encryptionPublicKey: z.ZodOptional<z.ZodString>;
+        hookResumeInputVersion: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>;
+    resumeCapabilities: z.ZodOptional<z.ZodObject<{
+        hookResumeDedupVersion: z.ZodNumber;
     }, z.core.$strip>>;
 }, z.core.$strip>;
 /**

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

@@ -6,7 +6,7 @@ export { _resetEnvWarnCacheForTests, type EnvNumberOptions, envNumber, } from '.
 export type * from './events.js';
 export { BaseEventSchema, CHILD_ENTITY_CREATION_EVENT_TYPES, CreateEventSchema, EVENT_DATA_PAYLOAD_FIELD_BY_EVENT_TYPE, EVENT_DATA_REF_FIELDS, EventSchema, EventTypeSchema, getEventDataPayloadField, getEventDataRefFields, HOOK_EVENTS_REQUIRING_EXISTENCE, HOOK_LIFECYCLE_EVENT_TYPES, HookCreatedEventSchema, isChildEntityCreationEvent, isChildEntityCreationEventType, isHookEventRequiringExistence, isHookLifecycleEventType, isRunEventType, isStepEventType, isTerminalRunEventType, isTerminalStepEventType, isWaitEventType, RUN_EVENT_TYPES, STEP_EVENT_TYPES, stripEventDataRefs, TERMINAL_RUN_EVENT_TYPES, TERMINAL_STEP_EVENT_TYPES, TerminalRunEventTypeSchema, WAIT_EVENT_TYPES, } from './events.js';
 export type * from './hooks.js';
-export { HookSchema } from './hooks.js';
+export { HOOK_RESUME_DEDUP_VERSION, HOOK_RESUME_INPUT_VERSION, HookResumeCapabilitiesSchema, HookSchema, } from './hooks.js';
 export type * from './interfaces.js';
 export type * from './queue.js';
 export { getQueueTopicPrefix, HealthCheckPayloadSchema, MessageId, parseQueueName, QueuePayloadSchema, QueuePrefix, RunInputSchema, resolveQueueNamespace, ValidQueueName, WorkflowInvokePayloadSchema, } from './queue.js';