eve 0.54.2 → 0.54.4

package/dist/src/compiled/@opentelemetry/api/index.d.ts

@@ -5,6 +5,8 @@ export interface TraceState {
   unset(key: string): TraceState;
 }
 
+export declare function createTraceState(rawTraceState?: string): TraceState;
+
 export interface SpanContext {
   isRemote?: boolean;
   spanId: string;

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

@@ -76,6 +76,13 @@ export interface EventsConsumerOptions {
      */
     isDeliveryIdle: () => boolean;
 }
+/** See {@link EventsConsumer.describe}. */
+export interface EventsConsumerSnapshot {
+    index: number;
+    length: number;
+    parked: number;
+    lastConsumedEventId: string | undefined;
+}
 export declare class EventsConsumer {
     eventIndex: number;
     readonly events: Event[];
@@ -113,6 +120,13 @@ export declare class EventsConsumer {
     private pendingUnconsumedCheck;
     private pendingUnconsumedTimeout;
     private unconsumedCheckVersion;
+    /**
+     * The event a callback most recently claimed, for {@link describe}. Tracked
+     * separately from {@link eventIndex} because the walk also steps over events
+     * (parked, sealed no-ops, duplicates) without anyone consuming them, so
+     * `events[eventIndex - 1]` does not say what replay last acted on.
+     */
+    private lastConsumed;
     constructor(events: Event[], options: EventsConsumerOptions);
     /**
      * The oldest event the walk stepped over that no consumer has claimed yet,
@@ -137,6 +151,18 @@ export declare class EventsConsumer {
         eventId: string;
         eventType: Event['eventType'];
     } | undefined;
+    /**
+     * Where the walk stands, for a divergence message. Everything here is
+     * already known to the consumer; the point of the method is that the
+     * orchestrator can print it without reaching into private state.
+     *
+     * `index` is the ordered walk's position (the offset of the event it is
+     * stuck on, when it is stuck), `length` the log as this consumer holds it,
+     * `parked` how many events the walk stepped over and still holds, and
+     * `lastConsumedEventId` the id of the event a callback most recently
+     * claimed, `undefined` before the first claim.
+     */
+    describe(): EventsConsumerSnapshot;
     append(events: Event[]): void;
     /**
      * Registers a callback function to be called after an event has been consumed

package/dist/src/compiled/@workflow/core/flushable-stream.d.ts

@@ -82,6 +82,30 @@ export declare const LOCK_POLL_INTERVAL_MS = 10;
 export interface FlushableStreamState extends PromiseWithResolvers<void> {
     /** Number of write operations currently in flight to the server */
     pendingOps: number;
+    /** Frames emitted by this pipe's producer. */
+    producedFrames: number;
+    /** Produced frames accepted by this pipe's sink. */
+    acceptedFrames: number;
+    /** Terminal pipe error, retained for snapshots registered after failure. */
+    pipeError?: unknown;
+    /**
+     * If the user-facing writable is unlocked, enqueue an ordered checkpoint and
+     * durably drain every write ahead of it. Returns false while a writer remains
+     * locked, so lock-held streams never block step completion.
+     */
+    settleReleasedWrites?: () => Promise<boolean>;
+    /** Whether release settlement waits for explicit step-end arming. */
+    deferReleaseSettlement?: boolean;
+    /** Whether step-end processing has armed released-writer settlement. */
+    releaseSettlementArmed?: boolean;
+    /** Whether the user-facing writable has begun a normal close. */
+    userWritableClosing?: boolean;
+    /** Step-end snapshot waiters blocked until their target reaches the sink. */
+    frameWaiters: Array<{
+        target: number;
+        resolve: () => void;
+        reject: (error: unknown) => void;
+    }>;
     /** Whether the `done` promise has been resolved */
     doneResolved: boolean;
     /** Whether the underlying stream has actually closed/errored */
@@ -99,6 +123,23 @@ export interface FlushableStreamState extends PromiseWithResolvers<void> {
     drainBarrier?: DrainBarrier;
 }
 export declare function createFlushableState(): FlushableStreamState;
+/**
+ * Capture a step-end producer watermark, wait until the pipe has handed every
+ * frame through that watermark to its sink, then await the sink's durability
+ * barrier. Unlike {@link FlushableStreamState.promise}, this never waits for a
+ * user writer lock to be released.
+ */
+export declare function drainFlushableSnapshot(state: FlushableStreamState): Promise<void>;
+/**
+ * Mark byte-stream chunks at the producer side of a flushable pipe. Serialized
+ * streams should instead use `getSerializeStream`'s synchronous output hook.
+ */
+/**
+ * Wrap the user-facing producer boundary of a flushable writable. A completed
+ * write through this handle has a sequence number before step-end snapshots,
+ * while the original writable remains the input to the serialization pipe.
+ */
+export declare function trackFlushableWritable<T>(writable: WritableStream<T>, state: FlushableStreamState, WritableStreamConstructor?: typeof WritableStream): WritableStream<T>;
 /**
  * Polls a WritableStream to check if the user has released their lock.
  * Resolves the done promise when lock is released and no pending ops remain.

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

@@ -1,2 +1,2 @@
-import"../../_chunks/workflow/dist-DDeH-1ER.js";import{$ as e,Cr as t,Fr as n,L as r,Nr as i,P as a,Pr as o,Q as s,Sr as c,T as l,_r as u,dr as d,gr as f,mr as p,nr as m,t as h,vr as g,wr as _,xr as v}from"../../_chunks/workflow/attribute-changes-C6H-fRVP.js";import{i as y,u as b}from"../../_chunks/workflow/dist-xTushGCp.js";import{n as x}from"../../_chunks/workflow/resume-hook-BRDLAb67.js";import{t as S}from"../../_chunks/workflow/sleep-6cG0F99-.js";function C(e){o(`createHook()`,`https://workflow-sdk.dev/docs/api-reference/workflow/create-hook`,C)}function w(e){o(`createWebhook()`,`https://workflow-sdk.dev/docs/api-reference/workflow/create-webhook`,w)}function T({schema:e}={}){function t(e){o(`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 x(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 x(t,r.value)}}}async function E(t,n={}){let r=e.getStore(),i=r?.workflowMetadata?.workflowRunId;if(!i)throw new y(`setAttributes() must be called from a 'use workflow' or 'use step' function. Calling it from plain host code is not supported.`);let a=h(t,n);if(a.length!==0){if(r.runReadyBarrier)try{await r.runReadyBarrier}catch{}await(await p()).events.create(i,{eventType:`attr_set`,specVersion:7,eventData:{changes:a,writer:{type:`step`,stepId:r.stepMetadata.stepId,attempt:r.stepMetadata.attempt},...n.allowReservedAttributes===!0?{allowReservedAttributes:!0}:{}}})}}function D(){let t=e.getStore();return t||i(`getStepMetadata()`,`https://workflow-sdk.dev/docs/api-reference/workflow/get-step-metadata`,D),t.stepMetadata}function O(){let t=e.getStore();return t||n(`getWorkflowMetadata()`,`https://workflow-sdk.dev/docs/api-reference/workflow/get-workflow-metadata`,O),t.workflowMetadata}function k(i={}){let o=e.getStore();o||n(`getWritable()`,`https://workflow-sdk.dev/docs/api-reference/workflow/get-writable`,k);let{namespace:p}=i,h=o.workflowMetadata.workflowRunId,y=s(h,p);o.writables??=new Map;let b=o.writables,x=b.get(y);if(x)return x.writable;let S=r(a(globalThis,o.ops,h,o.encryptionKey,!0,o.runReadyBarrier),o.encryptionKey),C=new l(h,y,o.runReadyBarrier),w=f();return o.ops.push(w.promise),u(S.readable,C,w).catch(()=>{}),g(S.writable,w),Object.defineProperty(S.writable,v,{value:y,writable:!1}),Object.defineProperty(S.writable,_,{value:h,writable:!1}),o.workflowDeploymentId&&Object.defineProperty(S.writable,c,{value:o.workflowDeploymentId,writable:!1}),m(o.encryptionKey)&&Object.defineProperty(S.writable,t,{value:d(o.encryptionKey.keyPair.publicKey),writable:!1}),b.set(y,{writable:S.writable,state:w}),S.writable}export{y as FatalError,b as RetryableError,C as createHook,w as createWebhook,T as defineHook,D as getStepMetadata,O as getWorkflowMetadata,k as getWritable,E as setAttributes,S as sleep};
+import"../../_chunks/workflow/dist-PLkAQ-U7.js";import{Ar as e,B as t,Br as n,Cr as r,Hr as i,L as a,O as o,Or as s,Sr as c,Tr as l,Vr as u,_r as d,br as f,cr as p,jr as m,kr as h,nt as g,t as _,tt as v,wr as y}from"../../_chunks/workflow/attribute-changes-BAcgmlXp.js";import{i as b,u as x}from"../../_chunks/workflow/dist-xTushGCp.js";import{n as S}from"../../_chunks/workflow/resume-hook-BEHe0Uut.js";import{t as C}from"../../_chunks/workflow/sleep-BB2HuVie.js";function w(e){u(`createHook()`,`https://workflow-sdk.dev/docs/api-reference/workflow/create-hook`,w)}function T(e){u(`createWebhook()`,`https://workflow-sdk.dev/docs/api-reference/workflow/create-webhook`,T)}function E({schema:e}={}){function t(e){u(`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=g.getStore(),r=n?.workflowMetadata?.workflowRunId;if(!r)throw new b(`setAttributes() must be called from a 'use workflow' or 'use step' function. Calling it from plain host code is not supported.`);let i=_(e,t);if(i.length!==0){if(n.runReadyBarrier)try{await n.runReadyBarrier}catch{}await(await f()).events.create(r,{eventType:`attr_set`,specVersion:7,eventData:{changes:i,writer:{type:`step`,stepId:n.stepMetadata.stepId,attempt:n.stepMetadata.attempt},...t.allowReservedAttributes===!0?{allowReservedAttributes:!0}:{}}})}}function O(){let e=g.getStore();return e||n(`getStepMetadata()`,`https://workflow-sdk.dev/docs/api-reference/workflow/get-step-metadata`,O),e.stepMetadata}function k(){let e=g.getStore();return e||i(`getWorkflowMetadata()`,`https://workflow-sdk.dev/docs/api-reference/workflow/get-workflow-metadata`,k),e.workflowMetadata}function A(n={}){let u=g.getStore();u||i(`getWritable()`,`https://workflow-sdk.dev/docs/api-reference/workflow/get-writable`,A);let{namespace:f}=n,_=u.workflowMetadata.workflowRunId,b=v(_,f);u.writables??=new Map;let x=u.writables,S=x.get(b);if(S)return S.writable;let C=c();C.deferReleaseSettlement=u.streamStates!==void 0;let w=t(a(globalThis,u.ops,_,u.encryptionKey,!0,u.runReadyBarrier),u.encryptionKey),T=new o(_,b,u.runReadyBarrier);u.streamStates??=[],u.streamStates.push(C),u.ops.push(C.promise),r(w.readable,T,C).catch(()=>{});let E=l(w.writable,C);return y(E,C),Object.defineProperty(E,s,{value:b,writable:!1}),Object.defineProperty(E,m,{value:_,writable:!1}),u.workflowDeploymentId&&Object.defineProperty(E,h,{value:u.workflowDeploymentId,writable:!1}),p(u.encryptionKey)&&Object.defineProperty(E,e,{value:d(u.encryptionKey.keyPair.publicKey),writable:!1}),x.set(b,{writable:E,state:C}),E}export{b as FatalError,x 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/replay-divergence.d.ts

@@ -0,0 +1,25 @@
+import type { Event } from '#compiled/@workflow/world/index.js';
+import type { EventsConsumer } from './events-consumer.js';
+import type { QueueItem } from './global.js';
+/**
+ * Step, wait, hook and attribute correlation ids share one ULID draw per
+ * entity, prefixed by kind (`step_<ulid>`, `wait_<ulid>`, `hook_<ulid>`,
+ * `attr_<ulid>`). A replay that drew the same ordinal for a different kind of
+ * entity than the one the log recorded there produces an event nobody can
+ * consume, and the decisive fact for diagnosing that is which pending
+ * invocation currently holds the ordinal. This looks it up by the shared ULID
+ * body, so a `wait_created` the log holds at a position where the replay is
+ * waiting on `step_<same ulid>` names that step.
+ */
+export declare function findPendingItemAtOrdinal(invocationsQueue: Map<string, QueueItem>, correlationId: string): QueueItem | undefined;
+/**
+ * The detail appended to a `ReplayDivergenceError` raised because the replay
+ * could not place an event. Callers keep their own leading sentence (tests and
+ * users match on it) and append this after it.
+ *
+ * Example:
+ * `pending at this id: step drainStep (step_01K…). consumer: index=41,
+ * length=44, parked=0, lastConsumed=evnt_01K…`
+ */
+export declare function describeDivergenceContext(event: Event, invocationsQueue: Map<string, QueueItem>, eventsConsumer: EventsConsumer): string;
+//# sourceMappingURL=replay-divergence.d.ts.map

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

@@ -1,4 +1,4 @@
-import type { CreateEventParams, CreateEventRequest, Event, EventResult, HealthCheckPayload, ValidQueueName, WorkflowRun, World } from '#compiled/@workflow/world/index.js';
+import type { CreateEventParams, CreateEventRequest, Event, EventResult, HealthCheckPayload, RunDispatchContext, ValidQueueName, WorkflowRun, World } from '#compiled/@workflow/world/index.js';
 import { type PayloadKey } from '../serialization/encryption.js';
 /**
  * Validates a workflow name and returns the corresponding queue name.
@@ -329,6 +329,53 @@ export interface SlotSnapshotParams {
  * Empty for an empty log, which is the state a `run_created` write is issued
  * from: there is no position held yet to name.
  *
+ * ## Who names a position
+ *
+ * A World can hand events back on a write's success response through two
+ * params (`CreateEventParams` in `@workflow/world`): `eventCount`, which is
+ * answered with the events on the positions the write skipped over (the
+ * skipped-slot report), and `sinceCursor`, which is answered with everything
+ * after that cursor (the inline delta). Both exist to save the writer a
+ * reload. So the rule for which writes send them is not about the event type;
+ * it is about whether **the process that writes holds a loaded log it will
+ * keep deciding from**, its own next writes or the replay it resumes. A writer
+ * with no log has nothing to merge a page into, and whoever decides next is a
+ * fresh replay that loads the log anyway.
+ *
+ * Three gates, all of which must pass for a page to come back:
+ *
+ * 1. The writer names a position. Only the replay loop's `createEvent` seam
+ *    (runtime.ts) and the suspension handler's `createGuarded` do; the QuickJS
+ *    engine's `createEvent` (quickjs-entrypoint.ts) follows the same rule. Raw
+ *    `world.events.create` calls send nothing.
+ * 2. The World reads a page for that event type. A World may decline for types
+ *    whose writer never holds a log (step executor writes, run-terminal
+ *    writes), whatever the client sent.
+ * 3. There is something to hand back: the report only when the write landed
+ *    more than one position above `eventCount`; the delta always.
+ *
+ * | Event | Writer | Sends | Why |
+ * |---|---|---|---|
+ * | `run_created` | `start()` | nothing | no log exists yet |
+ * | `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_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 |
+ * | `wait_completed` | `runs.*` out-of-band (raw) | nothing | no log |
+ * | `step_started`, `step_retrying` | step executor | nothing | no log; the next decision is a replay that reloads or receives the delta below |
+ * | `step_completed`, `step_failed` | step executor | `sinceCursor` only, outside turbo, single inline step | this is where the inline execution loop gets its log back; in turbo or from a queued delivery a fresh replay loads it anyway |
+ * | `step_failed` | suspension handler, unserializable input | `eventCount` | the handler holds a log; rare, and follows a `step_created` that drew the page |
+ * | `attr_set` | `setAttributes()` API (raw) | nothing | out-of-band |
+ * | `run_completed`, `run_failed`, `run_cancelled` | replay loop, replay budget, `runs.cancel` | `eventCount` where the node loop's seam stamps it (the QuickJS engine sends nothing); never `sinceCursor` (`deltaRequestCursor` excludes terminal types) | terminal: nothing replays the log afterwards, so a World reads no page for them |
+ *
+ * Batched writes (`events.createBatch`) are outside all of this: a batch carries
+ * no per-event position and gets no page. The user-facing version of this table
+ * is in `docs/content/docs/v5/how-it-works/event-sourcing.mdx`; keep the two in
+ * step.
+ *
  * The maximum rather than the length, for the reason {@link maxEventSlot}
  * gives: a partially-read log holds fewer events than its highest position, and
  * counting those would make the write claim to have seen less than it has, so
@@ -360,6 +407,18 @@ export type EventCreator = (data: CreateEventRequest, params?: CreateEventParams
  * based on the presence of a `__health` query parameter.
  */
 export declare function withHealthCheck(handler: (req: Request) => Promise<Response>, worldSpecVersion?: number): (req: Request) => Promise<Response>;
+/**
+ * The lineage root of a loaded run: its `$rootRunId` attribute, or its own id
+ * when it is itself a root.
+ */
+export declare function rootRunIdFrom(attributes: Record<string, string> | undefined, runId: string): string;
+/**
+ * The immutable run identity a step-execution message carries so its consumer
+ * can start the step without a blocking `runs.get` — see
+ * `RunDispatchContextSchema` in @workflow/world. Built at dispatch time from
+ * the run row the producer already holds.
+ */
+export declare function runDispatchContext(run: Pick<WorkflowRun, 'runId' | 'deploymentId' | 'specVersion' | 'startedAt' | 'attributes'>): RunDispatchContext;
 /**
  * Idempotency key for a step's background-dispatch queue message, scoped to
  * the step's IDENTITY, correlation id plus (hashed) step name, rather than
@@ -386,6 +445,21 @@ export declare function stepDispatchIdempotencyKey(correlationId: string, stepNa
  * Queues a message to the specified queue with tracing.
  */
 export declare function queueMessage(world: World, ...args: Parameters<typeof world.queue>): Promise<void>;
+/**
+ * Publishes several messages to one logical queue, using the World's batch
+ * send when it has one and falling back to concurrent single sends when it
+ * does not.
+ *
+ * Rejects if ANY message failed to publish, because every caller so far wants
+ * all-or-nothing: the recovery is to fail the delivery and let redelivery
+ * republish the whole set, deduped by the per-message `idempotencyKey`. That
+ * means a partial batch can leave some messages already out — which is
+ * exactly why the keys are required rather than advisory.
+ */
+export declare function queueMessages(world: World, queueName: Parameters<typeof world.queue>[0], messages: readonly {
+    message: Parameters<typeof world.queue>[1];
+    opts?: Parameters<typeof world.queue>[2];
+}[]): Promise<void>;
 /**
  * Calculates the queue overhead time in milliseconds for a given message.
  */

package/dist/src/compiled/@workflow/core/runtime/quickjs-entrypoint.d.ts

@@ -38,14 +38,29 @@ export declare function isFirstInvocation(preloadedEvents: readonly Event[] | un
  * This replaces the `node:vm` replay path (runWorkflow + EventsConsumer)
  * with a QuickJS VM invocation that performs the same full event replay.
  *
- * KNOWN GAP (slot snapshot): unlike the node:vm path, no event write in
- * this file carries {@link CreateEventParams.eventCount}, so a World never
- * learns which events the writer had not seen and never reports them back.
- * The engine currently relies on per-(runId, correlationId) event
- * uniqueness (EntityConflictError dedup) alone. This is a deliberate
- * simplification while the engine is experimental: wiring the snapshot is
- * tracked follow-up work; anyone adding new write paths here should not
- * assume parity with the node engine on this axis.
+ * Log position on writes. This engine follows the same rule as the node:vm
+ * replay loop for which writes tell the World where the writer stood (see the
+ * "Who names a position" table above `slotSnapshotParams` in `helpers.ts`):
+ *
+ * - Writes made from this invocation's view of the log (`step_created`,
+ *   `wait_created`, `hook_created`, `hook_disposed`, `attr_set`, the abort
+ *   `hook_received`, `wait_completed`, and the `step_created` + `step_failed`
+ *   pair for an unserializable input) carry `eventCount`, and the page a
+ *   World hands back is queued for the live VM through {@link QuickJSLogView}.
+ * - A single inline step's terminal write asks for the inline delta
+ *   (`sinceCursor`) through `executeStep`, and so does a lone `hook_created`
+ *   (see `dispatchPendingOps.deltaCursor`); the delta is queued the same
+ *   way. The step executor's other writes carry nothing: it holds no log.
+ * - Run-terminal writes (`run_completed`, `run_failed`) and the terminal drain
+ *   of pending ops carry nothing: nothing reads the log afterwards.
+ *
+ * What differs from the node engine is what "merge into the log" means. The
+ * node engine merges a returned page into the array it replays from. This
+ * engine holds a live VM that consumes events exactly once, in position
+ * order, so a returned page is queued and delivered ahead of the next
+ * `events.list`, which then only runs when the queue cannot account for the
+ * next position. Both engines fall back to a list for anything a page did
+ * not carry.
  */
 export declare function runWorkflowWithQuickJS(params: {
     workflowCode: string;
@@ -67,6 +82,13 @@ export declare function runWorkflowWithQuickJS(params: {
      * hook-resume preload would be discarded and refetched.
      */
     preloadedEventsComplete?: boolean;
+    /**
+     * The `events.list` cursor positioned after the last of `preloadedEvents`,
+     * when the caller has one. Lets this invocation read incrementally from
+     * where the preload ended and ask for an inline delta against it. Without
+     * it the first read after the preload starts from the top of the log.
+     */
+    preloadedCursor?: string | null;
     /**
      * Run input carried through the queue message on first delivery. Used
      * as a last-resort fallback for `run_created.eventData.input` when

package/dist/src/compiled/@workflow/core/runtime/quickjs-log-view.d.ts

@@ -0,0 +1,129 @@
+import { type Event } from '#compiled/@workflow/world/index.js';
+/**
+ * The QuickJS engine's bookkeeping for the run's event log, giving that engine
+ * the same relationship to a World's write responses that the node:vm replay
+ * loop has.
+ *
+ * The node engine holds the log as an array it replays from, so a page a World
+ * hands back on a write (a skipped-slot report against `eventCount`, or an
+ * inline delta against `sinceCursor`; see `CreateEventParams` in
+ * `@workflow/world`) is merged into that array and the next replay reads it
+ * there. The QuickJS engine holds a LIVE VM instead: events are delivered to it
+ * incrementally through `continueWithEvents`, in log order, exactly once. So
+ * for this engine a returned page is not merged into a log; it is queued to be
+ * delivered. This class owns that queue and the three numbers around it:
+ *
+ * - `knownMaxSlot`, the highest position this invocation has seen anywhere
+ *   (fed, buffered, or its own write). Reported as `eventCount` on every write
+ *   this invocation makes from its view of the log, so the World can hand
+ *   back what landed above it.
+ * - `fedMaxSlot`, the highest position delivered to the VM. Delivery is
+ *   strictly in position order with no gaps, because the VM consumes events
+ *   as they arrive and a later replay will read the log in position order;
+ *   feeding position 13 before 12 exists would let the two disagree.
+ * - `cursor`, the read position for `events.list`, advanced by list pages and
+ *   by a complete inline delta.
+ *
+ * Only PAGES are queued for delivery, never the created event a write returns
+ * on its own. A World reads a report or a delta the way it reads a listing,
+ * with payload refs resolved, so those events are what a listing would have
+ * delivered. The created event on a create response is not: a World may hand
+ * it back with its payload still a ref descriptor and telemetry fields
+ * stripped (the Vercel World does, for every type whose entity the runtime
+ * does not read off the response), and a VM given that copy of a `step_failed`
+ * sees a step that failed with no error in it. The created event still counts
+ * toward the position the next write names; it is delivered by the page that
+ * covers it or by the next listing. `deliverEvent` opts a write in when its
+ * event carries nothing a VM reads (`wait_completed`).
+ *
+ * Positions come from slot-numbered event ids. A log whose ids are not slots
+ * (a World on the old id scheme, or a mocked World) turns tracking off for the
+ * rest of the invocation: no `eventCount` is sent, nothing is buffered, and the
+ * engine reads the log back the way it did before any of this existed.
+ */
+export declare class QuickJSLogView {
+    private slotTracking;
+    private knownMaxSlot;
+    private fedMaxSlot;
+    /** Events handed back by a World that the VM has not been given yet. */
+    private readonly unfed;
+    private cursor;
+    constructor(fedEvents: readonly Event[], cursor: string | null);
+    /** Read position for the next `events.list`, or `null` for the start. */
+    get logCursor(): string | null;
+    /** How many events are queued for delivery to the VM. */
+    get bufferedCount(): number;
+    /** Whether positions are being tracked (see class doc). */
+    get tracking(): boolean;
+    /**
+     * The `eventCount` to attach to a write made from this view. Empty while no
+     * position is known (an empty log) or once tracking has been turned off.
+     */
+    snapshotParams(): {
+        eventCount?: number;
+    };
+    /** A page of `events.list` was read to `cursor`. */
+    advanceCursor(cursor: string | null): void;
+    /**
+     * Events delivered to the VM by the caller (the initial load, or an
+     * `events.list` page). Removes them from the delivery queue if a write
+     * response had already handed them back.
+     */
+    markFed(events: readonly Event[]): void;
+    /**
+     * Absorb a write's response: note the committed event's position, and
+     * queue the skipped-slot report a World attached to it.
+     *
+     * A truncated page (`hasMore`) is dropped whole, the same policy as
+     * `absorbSkippedSlotReport` in the node engine: it covers a span of
+     * positions but carries only some of them, and queuing part of a span
+     * would have this view claim, on its next write, to have seen positions it
+     * never received. The committed event is queued only under `deliverEvent`
+     * (see the class doc for why not by default); its position always counts.
+     */
+    absorb(result: {
+        event?: Event;
+        events?: readonly Event[];
+        hasMore?: boolean;
+    }, options?: {
+        deliverEvent?: boolean;
+    }): {
+        queued: number;
+        truncated: boolean;
+    };
+    /**
+     * Absorb the inline delta a step-terminal write returned for
+     * `sinceCursor`, and advance the read cursor past it when that is safe.
+     *
+     * The delta is everything after `sentCursor`, so it may be taken only if
+     * the view still stands at that cursor (a list in between would have moved
+     * it, and appending a delta computed from an older position could deliver
+     * events behind ones already fed). The cursor advances only when the queue
+     * then holds every position between what the VM has and the delta's end:
+     * with a hole in between, a later `events.list` from the advanced cursor
+     * would never return the missing event and the VM would stall on it.
+     *
+     * @returns whether the cursor was advanced.
+     */
+    absorbDelta(sentCursor: string, delta: {
+        events: readonly Event[];
+        cursor: string | null;
+        hasMore: boolean;
+    }): boolean;
+    /**
+     * Drain the events that can be delivered to the VM now: the queued run of
+     * consecutive positions directly above the highest one already fed. A queued
+     * event above a position nothing has filled yet stays queued until a list
+     * fills the gap.
+     */
+    takeContiguous(): Event[];
+    private queueIsDense;
+    /** Queue one event for delivery unless the VM already has it. */
+    private queue;
+    /**
+     * The event's position, bumping `knownMaxSlot`. `undefined` once an id
+     * turns out not to be a slot, which turns tracking off for good.
+     */
+    private slotOf;
+}
+//# sourceMappingURL=quickjs-log-view.d.ts.map

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

@@ -1,10 +1,11 @@
 import type { Event, SerializedData, StartedStep, World } from '#compiled/@workflow/world/index.js';
 import type { PayloadKey } from '../serialization/encryption.js';
-import { type SlotSnapshotParams } from './helpers.js';
 import { ReplayRecoveryReporter } from './replay-recovery-reporter.js';
 import { type ResumeTtrTracking } from './resume-latency.js';
 import { type StepLatencyTracking } from './step-latency.js';
 export declare const DEFAULT_STEP_MAX_RETRIES = 3;
+export declare const STEP_STREAM_DRAIN_TIMEOUT_MS = 30000;
+export declare function getStepStreamDrainTimeoutMs(): number;
 export interface StepExecutorParams {
     world: World;
     workflowRunId: string;
@@ -72,26 +73,6 @@ export interface StepExecutorParams {
      * handler is the sole inline writer for the run on this iteration.
      */
     inlineDeltaSinceCursor?: string;
-    /**
-     * How much of the run's log the caller's replay had loaded when it scheduled
-     * this step, as the highest slot that log occupies. Seeds the snapshot every
-     * write this executor makes carries; each committed event advances it to its
-     * own slot, so a later write never names a position that predates an earlier
-     * one from the same step.
-     *
-     * It matters most on the lazy inline path, where the `step_started` claim is
-     * the step's FIRST durable write (its `step_created` is deferred): without a
-     * seed the claim would name no position at all, and a replay working from a
-     * stale view could claim (and then commit) a step scheduled without
-     * observing an event it never loaded.
-     *
-     * A World that fences rejects a stale claim with `PreconditionFailedError`
-     * (412); executeStep does NOT translate that rejection (re-claiming in place
-     * would still commit the stale schedule), so it propagates for the caller to
-     * abandon the batch and restart its replay. Undefined for a caller with
-     * nothing loaded.
-     */
-    slotSnapshot?: SlotSnapshotParams;
     /**
      * Suppress optimistic inline start for this step regardless of
      * `WORKFLOW_OPTIMISTIC_INLINE_START` / `forceOptimisticStart`: take the

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

@@ -168,28 +168,6 @@ export interface SuspensionHandlerResult {
      * path, the exact machinery the lazy claim's crash window already uses.
      */
     inlineClaims: Map<string, PreclaimedInlineStart>;
-    /**
-     * The highest slot the batched fan-out committed, when it ran. The batch's
-     * own events are not in the caller's loaded log (the next reload picks
-     * them up), so the caller folds this ceiling into the slot snapshot it
-     * hands the inline executions; otherwise every inline terminal write
-     * would name a pre-batch position and be answered with a skipped-slot
-     * report echoing the events this suspension just wrote. Under
-     * {@link SuspensionHandlerParams.allowDeferredBatchWork} this covers the
-     * chunks that had committed by the handler's return (always the pair
-     * chunk); a trailing chunk that commits later is echoed back on the
-     * terminal writes like any foreign event: reports the executor reads for
-     * position and discards.
-     *
-     * So the echo is only fully suppressed for a SINGLE-chunk fold. On a
-     * multi-chunk fan-out the bodies start off the pair chunk while trailing
-     * chunks are still in flight, and an inline terminal write issued in that
-     * window still names a position below them and still draws a report for
-     * their events. Bounded (trailing chunks only, large fan-outs only) and
-     * self-correcting on the next reload, and recorded so a report seen there
-     * reads as expected rather than as a bug.
-     */
-    batchCommittedSlotCeiling?: number;
     /**
      * The batched fan-out's deferred work, present only when the caller opted
      * in via {@link SuspensionHandlerParams.allowDeferredBatchWork} and