@workflow/core 5.0.0-beta.50 → 5.0.0-beta.52

package/dist/runtime/quickjs-log-view.d.ts

@@ -0,0 +1,129 @@
+import { type Event } from '@workflow/world';
+/**
+ * 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/runtime/quickjs-log-view.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"quickjs-log-view.d.ts","sourceRoot":"","sources":["../../src/runtime/quickjs-log-view.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,KAAK,EAAmC,MAAM,iBAAiB,CAAC;AAE9E;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyCG;AACH,qBAAa,cAAc;IACzB,OAAO,CAAC,YAAY,CAAQ;IAC5B,OAAO,CAAC,YAAY,CAAqB;IACzC,OAAO,CAAC,UAAU,CAAqB;IACvC,wEAAwE;IACxE,OAAO,CAAC,QAAQ,CAAC,KAAK,CAA4B;IAClD,OAAO,CAAC,MAAM,CAAgB;gBAElB,SAAS,EAAE,SAAS,KAAK,EAAE,EAAE,MAAM,EAAE,MAAM,GAAG,IAAI;IAK9D,yEAAyE;IACzE,IAAI,SAAS,IAAI,MAAM,GAAG,IAAI,CAE7B;IAED,yDAAyD;IACzD,IAAI,aAAa,IAAI,MAAM,CAE1B;IAED,2DAA2D;IAC3D,IAAI,QAAQ,IAAI,OAAO,CAEtB;IAED;;;OAGG;IACH,cAAc,IAAI;QAAE,UAAU,CAAC,EAAE,MAAM,CAAA;KAAE;IAMzC,oDAAoD;IACpD,aAAa,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI,GAAG,IAAI;IAM1C;;;;OAIG;IACH,OAAO,CAAC,MAAM,EAAE,SAAS,KAAK,EAAE,GAAG,IAAI;IAWvC;;;;;;;;;;OAUG;IACH,MAAM,CACJ,MAAM,EAAE;QACN,KAAK,CAAC,EAAE,KAAK,CAAC;QACd,MAAM,CAAC,EAAE,SAAS,KAAK,EAAE,CAAC;QAC1B,OAAO,CAAC,EAAE,OAAO,CAAC;KACnB,EACD,OAAO,GAAE;QAAE,YAAY,CAAC,EAAE,OAAO,CAAA;KAAO,GACvC;QAAE,MAAM,EAAE,MAAM,CAAC;QAAC,SAAS,EAAE,OAAO,CAAA;KAAE;IAsBzC;;;;;;;;;;;;;OAaG;IACH,WAAW,CACT,UAAU,EAAE,MAAM,EAClB,KAAK,EAAE;QAAE,MAAM,EAAE,SAAS,KAAK,EAAE,CAAC;QAAC,MAAM,EAAE,MAAM,GAAG,IAAI,CAAC;QAAC,OAAO,EAAE,OAAO,CAAA;KAAE,GAC3E,OAAO;IAiBV;;;;;OAKG;IACH,cAAc,IAAI,KAAK,EAAE;IAqBzB,OAAO,CAAC,YAAY;IAQpB,iEAAiE;IACjE,OAAO,CAAC,KAAK;IAWb;;;OAGG;IACH,OAAO,CAAC,MAAM;CAef"}

package/dist/runtime/quickjs-log-view.js

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

package/dist/runtime/step-executor.d.ts

@@ -1,10 +1,11 @@
 import type { Event, SerializedData, StartedStep, World } from '@workflow/world';
 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/runtime/step-executor.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"step-executor.d.ts","sourceRoot":"","sources":["../../src/runtime/step-executor.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"step-executor.d.ts","sourceRoot":"","sources":["../../src/runtime/step-executor.ts"],"names":[],"mappings":"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"}