eve 0.82.0 → 0.83.0

package/dist/src/compiled/@workflow/core/events-consumer.d.ts

@@ -115,6 +115,8 @@ export declare class EventsConsumer {
      * {@link EventsConsumer.firstEventTypeOfClass}.
      */
     private readonly seenEventClasses;
+    /** Correlation ids whose terminal event was consumed, with its type. */
+    private readonly closedEntities;
     private onConsumedEvent?;
     private onUnconsumedEvent;
     private onDuplicateEvent?;

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

@@ -1,2 +1,2 @@
-import"../../_chunks/workflow/dist-CyBgVS7g.js";import{$r as e,Br as t,Gr as n,Jr as r,K as i,Kr as a,Qr as o,Sr as s,T as c,Ur as l,Zr as u,ei as d,i as f,q as p,qr as m,x as h}from"../../_chunks/workflow/serialization-DPdYS_w2.js";import{d as g,i as _}from"../../_chunks/workflow/dist-T5NnW-0k.js";import{a as v,i as y,r as b,t as x}from"../../_chunks/workflow/attribute-changes-BW-kbMMn.js";import{n as S}from"../../_chunks/workflow/resume-hook-DMsV_b4n.js";import{t as C}from"../../_chunks/workflow/sleep-BY6leHh8.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 n=p.getStore(),r=n?.workflowMetadata?.workflowRunId;if(!r)throw new _(`setAttributes() must be called from a 'use workflow' or 'use step' function. Calling it from plain host code is not supported.`);let i={type:`step`,stepId:n.stepMetadata.stepId,attempt:n.stepMetadata.attempt},a=x(e,t,i);if(a.length!==0){if(n.runReadyBarrier)try{await n.runReadyBarrier}catch{}await(await l()).events.create(r,{eventType:`attr_set`,specVersion:8,eventData:{changes:a,writer:i,...t.allowReservedAttributes===!0?{allowReservedAttributes:!0}:{}}})}}function O(){let e=p.getStore();return e||b(`getStepMetadata()`,`https://workflow-sdk.dev/docs/api-reference/workflow/get-step-metadata`,O),e.stepMetadata}function k(){let e=p.getStore();return e||v(`getWorkflowMetadata()`,`https://workflow-sdk.dev/docs/api-reference/workflow/get-workflow-metadata`,k),e.workflowMetadata}function A(l={}){let g=p.getStore();g||v(`getWritable()`,`https://workflow-sdk.dev/docs/api-reference/workflow/get-writable`,A);let{namespace:_}=l,y=g.workflowMetadata.workflowRunId,b=i(y,_);g.writables??=new Map;let x=g.writables,S=x.get(b);if(S)return S.writable;let C=n();C.deferReleaseSettlement=g.streamStates!==void 0;let w=c(h(globalThis,g.ops,y,g.encryptionKey,!0,g.runReadyBarrier),g.encryptionKey),T=new f(y,b,g.runReadyBarrier);g.streamStates??=[],g.streamStates.push(C),g.ops.push(C.promise),a(w.readable,T,C).catch(()=>{});let E=r(w.writable,C);return m(E,C),Object.defineProperty(E,u,{value:b,writable:!1}),Object.defineProperty(E,d,{value:y,writable:!1}),g.workflowDeploymentId&&Object.defineProperty(E,o,{value:g.workflowDeploymentId,writable:!1}),s(g.encryptionKey)&&Object.defineProperty(E,e,{value:t(g.encryptionKey.keyPair.publicKey),writable:!1}),x.set(b,{writable:E,state:C}),E}export{_ as FatalError,g 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-CcnNPAp4.js";import{Gr as e,K as t,Kr as n,Qr as r,Rr as i,T as a,Ur as o,Vr as s,Wr as c,Xr as l,Yr as u,Zr as d,br as f,i as p,q as m,x as h}from"../../_chunks/workflow/serialization-B9gneT9Z.js";import{i as g,m as _}from"../../_chunks/workflow/dist-S9cZRway.js";import{a as v,i as y,r as b,t as x}from"../../_chunks/workflow/attribute-changes-7se_SE2q.js";import{n as S}from"../../_chunks/workflow/resume-hook-CPiIfe8r.js";import{t as C}from"../../_chunks/workflow/sleep-BL0oQs3R.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 n=m.getStore(),r=n?.workflowMetadata?.workflowRunId;if(!r)throw new g(`setAttributes() must be called from a 'use workflow' or 'use step' function. Calling it from plain host code is not supported.`);let i={type:`step`,stepId:n.stepMetadata.stepId,attempt:n.stepMetadata.attempt},a=x(e,t,i);if(a.length!==0){if(n.runReadyBarrier)try{await n.runReadyBarrier}catch{}await(await s()).events.create(r,{eventType:`attr_set`,specVersion:8,eventData:{changes:a,writer:i,...t.allowReservedAttributes===!0?{allowReservedAttributes:!0}:{}}})}}function O(){let e=m.getStore();return e||b(`getStepMetadata()`,`https://workflow-sdk.dev/docs/api-reference/workflow/get-step-metadata`,O),e.stepMetadata}function k(){let e=m.getStore();return e||v(`getWorkflowMetadata()`,`https://workflow-sdk.dev/docs/api-reference/workflow/get-workflow-metadata`,k),e.workflowMetadata}function A(s={}){let g=m.getStore();g||v(`getWritable()`,`https://workflow-sdk.dev/docs/api-reference/workflow/get-writable`,A);let{namespace:_}=s,y=g.workflowMetadata.workflowRunId,b=t(y,_);g.writables??=new Map;let x=g.writables,S=x.get(b);if(S)return S.writable;let C=o();C.deferReleaseSettlement=g.streamStates!==void 0;let w=a(h(globalThis,g.ops,y,g.encryptionKey,!0,g.runReadyBarrier),g.encryptionKey),T=new p(y,b,g.runReadyBarrier);g.streamStates??=[],g.streamStates.push(C),g.ops.push(C.promise),c(w.readable,T,C).catch(()=>{});let E=n(w.writable,C);return e(E,C),Object.defineProperty(E,u,{value:b,writable:!1}),Object.defineProperty(E,r,{value:y,writable:!1}),g.workflowDeploymentId&&Object.defineProperty(E,l,{value:g.workflowDeploymentId,writable:!1}),f(g.encryptionKey)&&Object.defineProperty(E,d,{value:i(g.encryptionKey.keyPair.publicKey),writable:!1}),x.set(b,{writable:E,state:C}),E}export{g as FatalError,_ 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.d.ts

@@ -155,7 +155,7 @@ export interface WorkflowOrchestratorContext {
     replayPayloadCache: ReplayPayloadCache;
 }
 /** The kind of branch-deciding delivery a barrier represents. */
-export type DeliveryKind = 'hook' | 'wait' | 'step';
+export type DeliveryKind = 'hook' | 'wait' | 'step' | 'attribute';
 interface DeliveryBarrierEntry {
     kind: DeliveryKind;
     /** Resolves once this delivery is handed to the workflow or retired. */
@@ -231,9 +231,11 @@ export declare function registerDeliveryBarrier(ctx: WorkflowOrchestratorContext
      * so `Date.now()` in the cascade this delivery wakes reads the delivery's
      * own time, whatever the consumer walk has read ahead of it. Required so
      * that a new delivery site cannot forget the clock: a delivery that does
-     * not move it leaves the cascade it wakes reading a stale time.
+     * not move it leaves the cascade it wakes reading a stale time. `null`
+     * opts out explicitly; attribute acknowledgements use it because they
+     * have never moved the clock, and recorded histories may branch on it.
      */
-    deliveredAt: number;
+    deliveredAt: number | null;
 }): DeliveryBarrier;
 /**
  * Whether some registered branch-deciding delivery is going to reach the

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

@@ -1 +1 @@
-import{a as e,c as t,i as n,n as r,o as i,r as a,s as o,t as s}from"../../_chunks/workflow/private-tQUuwBoQ.js";export{s as awaitEarlierDeliveries,r as getStepFunction,a as hasParkedCommittedDelivery,n as isDeliveryIdle,e as registerDeliveryBarrier,i as registerStepFunction,o as scheduleWhenIdle,t as scheduleWorkflowSuspension};
+import{a as e,c as t,i as n,n as r,o as i,r as a,s as o,t as s}from"../../_chunks/workflow/private-DLYTSBbu.js";export{s as awaitEarlierDeliveries,r as getStepFunction,a as hasParkedCommittedDelivery,n as isDeliveryIdle,e as registerDeliveryBarrier,i as registerStepFunction,o as scheduleWhenIdle,t as scheduleWorkflowSuspension};

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

@@ -85,49 +85,13 @@ export declare const MAX_MAX_INLINE_STEPS = 16;
  * one-time warning so misconfiguration is observable.
  */
 export declare function getMaxInlineSteps(): number;
-/**
- * Upper bound on the serialized step input that resilient step dispatch will
- * inline into the queue message's `stepInput`.
- *
- * Vercel Queues has no hard message-size cap (bodies above its ~256 KB
- * inline threshold transparently spill to S3-backed storage), so this bound
- * is a cost/latency choice, not a rejection guard: the message also carries
- * the runId, stepId, stepName, and trace carrier alongside CBOR framing
- * overhead, and staying under the queue's inline threshold keeps step
- * messages on its fast inline path instead of paying an S3 store+fetch
- * double-hop for bytes that already live in the event log. Above this size
- * the dispatch falls back to the sequential path (`step_created` write, then
- * a payload-less queue message).
- */
-export declare const MAX_RESILIENT_STEP_INPUT_BYTES: number;
-/**
- * Whether resilient step dispatch is enabled: the suspension handler
- * parallelizes each newly created step's `step_created` event write with its
- * step-execution queue publish, carrying the serialized step input in the
- * queue message (`stepInput`) so the consumer can idempotently re-ensure the
- * event if the direct write failed transiently. Mirrors the resilient start
- * (`runInput`) pattern (and the legacy lazy hook resume's `hookInput`, which
- * current producers no longer send).
- *
- * **Off by default.** Enable via `WORKFLOW_RESILIENT_STEP_DISPATCH=1`.
- *
- * The queue publish races the create's verdict, and a create can come back
- * refused: as a duplicate this replay should stop pursuing, or as a stale
- * write on a World that refuses rather than reports. Either way the message
- * carrying the payload is already out, so the consumer can materialize a step
- * whose create was refused, and nothing orders the verdict before the
- * consumer's redelivery re-ensure. Enabling this trades that window for the
- * latency the parallel publish saves.
- */
-export declare function isResilientStepDispatchEnabled(): boolean;
 /**
  * Whether batched event transitions are enabled: the suspension handler folds
  * a clean fan-out's `step_created` + `wait_created` writes into one
  * `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 writes and no
- * resilient step dispatch. Hook writes in the same suspension go through the
+ * (specVersion >= 6) AND the suspension carries no attribute writes. 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.
  *

package/dist/src/compiled/@workflow/core/runtime/event-limit-warning.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Fractions of the per-run event ceiling at which a run logs a warning
+ * recommending the QuickJS VM with snapshotting, before it is failed with
+ * `MAX_EVENTS_EXCEEDED`. Ascending.
+ */
+export declare const EVENT_LIMIT_WARNING_FRACTIONS: readonly [0.5, 0.8, 0.95];
+/**
+ * The highest milestone in {@link EVENT_LIMIT_WARNING_FRACTIONS} that
+ * `eventCount` has reached for `limit`, or `undefined` when below the first
+ * one (or the run has no effective ceiling).
+ */
+export declare function getEventLimitMilestone(eventCount: number, limit: number | undefined): number | undefined;
+/**
+ * Log a warning when a run's event log crosses a milestone of the per-run
+ * event ceiling, recommending the QuickJS VM with snapshotting. Logged once
+ * per (run, milestone) per process: every invocation replays the full log,
+ * so without dedupe a run past a milestone would warn on every step.
+ *
+ * `isQuickJS` tailors the hint for QuickJS runs that still have a ceiling
+ * (snapshotting disabled, or the run's `executionContext` doesn't record
+ * the QuickJS snapshot policy).
+ */
+export declare function maybeWarnApproachingEventLimit(args: {
+    runId: string;
+    workflowName: string;
+    eventCount: number;
+    limit: number | undefined;
+    isQuickJS: boolean;
+}): void;
+/** @internal Test-only. */
+export declare function _resetEventLimitWarningsForTests(): void;
+//# sourceMappingURL=event-limit-warning.d.ts.map

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

@@ -396,7 +396,7 @@ export interface SlotSnapshotParams {
  * | `run_started` | replay loop, first write of a delivery | `eventCount` when a log is loaded; no cursor, the `run_started` preload owns the response fields | the preload already returns the full log |
  * | `step_created`, `wait_created`, `hook_disposed`, `attr_set` | suspension handler (`createGuarded`) | `eventCount` | the handler keeps writing from, and resumes replay from, this log |
  * | `step_created` | queue-consumer re-ensure (raw) | nothing | runs from a queue message, no log |
- * | `hook_created` | suspension handler (node), `dispatchPendingOps` (QuickJS) | `eventCount` + `sinceCursor` (only when the suspension creates exactly one hook) | the delta is how an already-received hook resolves without a re-invocation; two creates against one cursor would give two deltas of which only the first could be taken |
+ * | `hook_created` | suspension handler (node), `dispatchPendingOps` (QuickJS) | `eventCount` + `sinceCursor` (only when the suspension creates exactly one hook); independent concurrent node registrations in a hooks-only suspension defer both | a lone create returns a delta; concurrent registrations reconcile committed responses together, reloading when they do not prove a consecutive suffix |
  * | `hook_received` | replay loop lazy resume; handler in-suspension resume | `eventCount` (preload owns the cursor fields) | both replay from the log right after |
  * | `hook_received` | webhook / `resumeHook` (raw) | nothing | out-of-band, enqueues a delivery that loads the log |
  * | `wait_completed` | replay loop timer path | `eventCount` | the loop keeps replaying from the log |
@@ -460,11 +460,10 @@ export declare function runDispatchContext(run: Pick<WorkflowRun, 'runId' | 'dep
  * the step's IDENTITY, correlation id plus (hashed) step name, rather than
  * the bare correlation id.
  *
- * The scoping matters for resilient step dispatch under the precondition
- * guard: a guard-rejected `step_created` leaves its (revoked) step message in
- * flight, and the corrected replay may re-derive the same correlation id for
- * a DIFFERENT step. Under a bare-correlationId key the corrected replay's
- * dispatch would silently dedupe against the revoked in-flight message,
+ * The scoping matters when a step message is still in flight for a
+ * correlation id that a corrected replay re-derives for a DIFFERENT step.
+ * Under a bare-correlationId key the corrected replay's dispatch would
+ * silently dedupe against the stale in-flight message,
  * which then resolves `skipped` against the re-created entity (the server's
  * stepName fence rejects its bare start), and the legitimate step would
  * never be executed. Scoping by step name keeps every dedup property that

package/dist/src/compiled/@workflow/core/runtime/helpers.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,k as h,l as g,m as _,n as v,o as y,p as b,r as x,s as S,t as C,u as w,v as T,w as E,x as D,y as O}from"../../../_chunks/workflow/helpers-DlLD3ov_.js";export{C as DYNAMIC_WORKFLOW_VERSION,v as REPLAY_RESOLVE_DATA,x as SLOT_GAP_RECHECK_ATTEMPTS,m as absorbSkippedSlotReport,s as appendEventLog,y as appendUniqueEvents,S as findEventSlotGap,l as getQueueOverhead,g as getWorkflowQueueName,w as handleHealthCheckMessage,u as healthCheck,d as insertEventByEventId,b as isSlotGapCheckEnabled,_ as loadWorkflowRunEvents,p as maxEventSlot,f as memoizeEncryptionKey,o as mergeReportedEvents,T as parseHealthCheckPayload,O as preconditionEventDelta,c as queueMessage,D as queueMessages,i as resolveRunEncryptionKey,e as rootRunIdFrom,E as runDispatchContext,a as settleEventSlotGap,n as slotSnapshotParams,t as stepDispatchIdempotencyKey,r as withHealthCheck,h as withReplayDelta};
+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,k as h,l as g,m as _,n as v,o as y,p as b,r as x,s as S,t as C,u as w,v as T,w as E,x as D,y as O}from"../../../_chunks/workflow/helpers-CxNRXH0a.js";export{C as DYNAMIC_WORKFLOW_VERSION,v as REPLAY_RESOLVE_DATA,x as SLOT_GAP_RECHECK_ATTEMPTS,m as absorbSkippedSlotReport,s as appendEventLog,y as appendUniqueEvents,S as findEventSlotGap,l as getQueueOverhead,g as getWorkflowQueueName,w as handleHealthCheckMessage,u as healthCheck,d as insertEventByEventId,b as isSlotGapCheckEnabled,_ as loadWorkflowRunEvents,p as maxEventSlot,f as memoizeEncryptionKey,o as mergeReportedEvents,T as parseHealthCheckPayload,O as preconditionEventDelta,c as queueMessage,D as queueMessages,i as resolveRunEncryptionKey,e as rootRunIdFrom,E as runDispatchContext,a as settleEventSlotGap,n as slotSnapshotParams,t as stepDispatchIdempotencyKey,r as withHealthCheck,h as withReplayDelta};

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

@@ -11,6 +11,14 @@ export interface RecreateRunOptions {
      * for is never picked up.
      */
     namespace?: string;
+    /**
+     * Region for the new run. Defaults to the source run's region, as reported
+     * by `World.regionForRunId`, so a replay is placed where the original run's
+     * data lives instead of in whatever region the calling process runs in.
+     * When the world can't derive one, `start()`'s own region resolution
+     * applies.
+     */
+    region?: string;
 }
 export interface StopSleepResult {
     /** Number of pending sleeps that were stopped */

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

@@ -137,6 +137,22 @@ export interface StartOptionsBase {
      * recognize the value keeps the data.
      */
     experimental_retention?: RunRetention;
+    /**
+     * Set to `false` to store the run's arguments uncompressed.
+     *
+     * Arguments are compressed by default when the target run can decode
+     * them. The attempt costs CPU proportional to the input size and is
+     * wasted on incompressible data (media, encrypted or random bytes),
+     * so callers that know their inputs will not shrink can skip it.
+     *
+     * `true` is the default and does not force compression: a target that
+     * cannot decode compressed payloads, or a process with
+     * `WORKFLOW_DISABLE_COMPRESSION=1` set, still stores them uncompressed.
+     * This option is the per-call counterpart of that environment variable
+     * and only affects the arguments; a dynamic workflow's code is
+     * compressed regardless.
+     */
+    compressArguments?: boolean;
     /**
      * The ID of an existing run this run is being replayed from, if any.
      *

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

@@ -12,14 +12,17 @@ export interface SuspensionHandlerParams {
     span?: Span;
     requestId?: string;
     /**
-     * The runtime's loaded event log. Every event creation this suspension makes
-     * names the position it was derived from, so a backend that has recorded
+     * The runtime's loaded event log. Event creations normally name the position
+     * they were derived from, so a backend that has recorded
      * events the replay did not see can report them back on the write, or, if
      * it would rather refuse than report, reject it with a 412. A rejection is
      * not retried here: the event's correlation id was minted by *this* replay's
      * seeded sequence, so re-committing it against a corrected log would persist
      * an event no correct replay produces. The caller restarts the replay
      * instead.
+     * Independent concurrent hook registrations defer advisory catch-up until
+     * all of their existing single-event requests settle; a gap in their returned
+     * committed positions retains the caller's normal reload path.
      *
      * Extended in place by what those writes report back — the events on slots
      * they skipped over, and (on the hook create) the inline delta since its
@@ -40,15 +43,12 @@ export interface SuspensionHandlerParams {
     /** One-shot telemetry reporter, activated only after replay has recovered. */
     replayRecoveryReporter?: ReplayRecoveryReporter;
     /**
-     * Resilient step dispatch: when provided (and the per-step eligibility gates
-     * pass, see the step ops below), each newly created non-inline step's
-     * `step_created` write is parallelized with its step-execution queue
-     * publish, and the queue message carries the serialized step input
-     * (`stepInput`) so the consumer can idempotently re-ensure the event if the
-     * direct write failed transiently. Steps queued this way are reported in
+     * Step dispatch target. When provided, the batched fan-out publishes the
+     * step-execution queue message for each eagerly created step after its
+     * chunk commits, and reports those steps in
      * {@link SuspensionHandlerResult.queuedStepCorrelationIds} so the caller
      * skips them in its own dispatch pass. Omitted by callers that must not
-     * queue (terminal drain, tests); creates then behave exactly as before.
+     * queue (terminal drain, tests); creates then never publish.
      */
     stepDispatch?: {
         /** The unified workflow queue this run's step messages are published to. */
@@ -124,9 +124,8 @@ export interface SuspensionHandlerResult {
     failedStepCorrelationIds: Set<string>;
     /**
      * Correlation IDs of steps this suspension call already published
-     * step-execution queue messages for, via resilient step dispatch (the
-     * `step_created` write parallelized with a `stepInput`-carrying queue
-     * publish). The caller MUST NOT dispatch these again: the message is
+     * step-execution queue messages for (the batched fan-out's per-chunk
+     * publishes). The caller MUST NOT dispatch these again: the message is
      * already out (a duplicate would be deduped by its idempotency key, but
      * costs a wasted round-trip). Empty when {@link SuspensionHandlerParams.stepDispatch}
      * was not provided or no step was eligible.
@@ -252,12 +251,10 @@ export interface SuspensionHandlerResult {
      * committed, so a caller that continues in this process can replay — or
      * resume a retained VM — straight off it with no read.
      *
-     * True only when the hook create's inline delta came back complete and was
-     * 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 (single or batched) also committed and may not be
-     * in it.
+     * True when a lone hook create returns a complete inline delta, or when
+     * concurrent hook responses prove a complete consecutive suffix. In either
+     * case every write in this suspension must be accounted for. Missing events,
+     * intervening writers, or other suspension writes retain the reload path.
      *
      * 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

package/dist/src/compiled/@workflow/core/runtime/vm-mode.d.ts

@@ -65,6 +65,21 @@ export declare const DEFAULT_QUICKJS_SNAPSHOT_THRESHOLD = 1000;
  * Throws {@link WorkflowRuntimeError} for non-integer or negative values.
  */
 export declare function getSnapshotThresholdFromEnv(env?: NodeJS.ProcessEnv): number | undefined;
+/**
+ * The snapshot threshold `start()` stamps into a new run's
+ * `executionContext`: the client's `WORKFLOW_SNAPSHOT_THRESHOLD` when set,
+ * otherwise {@link DEFAULT_QUICKJS_SNAPSHOT_THRESHOLD} for QuickJS runs.
+ *
+ * Stamping the default (rather than leaving it implicit) matters because
+ * the World keys the per-run event limit on the persisted policy: runs with
+ * `workflowVm: "quickjs"` and a positive `snapshotThreshold` are exempt
+ * from the default event-count ceiling. Without the stamp, a run started
+ * with only `WORKFLOW_VM=quickjs` would snapshot at runtime but still be
+ * failed at the ceiling.
+ *
+ * Throws {@link WorkflowRuntimeError} on an invalid env value.
+ */
+export declare function getSnapshotThresholdForStart(workflowVm: WorkflowVmMode | undefined, env?: NodeJS.ProcessEnv): number | undefined;
 /**
  * Resolve the snapshot threshold for a run: the run's stamped
  * `executionContext.snapshotThreshold` (set by the SDK at `start()` when
@@ -90,6 +105,11 @@ export declare function getConfiguredSnapshotThreshold(workflowRun: WorkflowRun)
  * Whether the run's snapshot threshold was explicitly configured rather
  * than falling back to {@link DEFAULT_QUICKJS_SNAPSHOT_THRESHOLD}. Never
  * throws: an invalid value counts as configured.
+ *
+ * `start()` stamps the default into QuickJS runs (see
+ * {@link getSnapshotThresholdForStart}), so a stamped value equal to the
+ * default is treated as unconfigured unless `WORKFLOW_SNAPSHOT_THRESHOLD`
+ * is also set on the handler.
  */
 export declare function isSnapshotThresholdConfigured(workflowRun: WorkflowRun): boolean;
 /**