@workflow/core 5.0.0-beta.4 → 5.0.0-beta.40

package/dist/events-consumer.js

@@ -1,4 +1,27 @@
+import { envNumber } from '@workflow/world';
 import { eventsLogger } from './logger.js';
+/**
+ * Delay before firing the deferred unconsumed-event check after the promise
+ * queue has drained. Must be long enough for cross-VM microtask chains to
+ * propagate (resolve in host → workflow code in VM → subscribe call back
+ * in host). Any subscribe() arriving during this window cancels the check.
+ */
+export const DEFERRED_CHECK_DELAY_MS = 100;
+/**
+ * Effective deferred-check delay. Override: `WORKFLOW_DEFERRED_CHECK_DELAY_MS`.
+ *
+ * Unlike the other timing knobs this is not a polling interval but a
+ * determinism safety margin: firing the unconsumed-event check before the
+ * cross-VM subscribe() chain has landed rejects a healthy run with
+ * `ReplayDivergenceError`. Floored at 10ms so a too-low override can't
+ * manufacture spurious divergence (each false positive burns a
+ * divergence-recovery retry and can escalate to a terminal
+ * `CorruptedEventLogError`).
+ */
+const getDeferredCheckDelayMs = () => envNumber('WORKFLOW_DEFERRED_CHECK_DELAY_MS', DEFERRED_CHECK_DELAY_MS, {
+    integer: true,
+    min: 10,
+});
 export var EventConsumerResult;
 (function (EventConsumerResult) {
     /**
@@ -16,19 +39,29 @@ export var EventConsumerResult;
 })(EventConsumerResult || (EventConsumerResult = {}));
 export class EventsConsumer {
     eventIndex;
-    events = [];
+    events;
     callbacks = [];
+    onConsumedEvent;
     onUnconsumedEvent;
     getPromiseQueue;
     pendingUnconsumedCheck = null;
     pendingUnconsumedTimeout = null;
     unconsumedCheckVersion = 0;
     constructor(events, options) {
-        this.events = events;
+        // Own copy: the runtime mutates its event array in place, and a retained
+        // session must only observe new events through append() so resume()'s
+        // strict-extension check stays meaningful.
+        this.events = [...events];
         this.eventIndex = 0;
+        this.onConsumedEvent = options.onConsumedEvent;
         this.onUnconsumedEvent = options.onUnconsumedEvent;
         this.getPromiseQueue = options.getPromiseQueue;
     }
+    append(events) {
+        for (const event of events)
+            this.events.push(event);
+        process.nextTick(this.consume);
+    }
     /**
      * Registers a callback function to be called after an event has been consumed
      * by a different callback. The callback can return:
@@ -53,8 +86,54 @@ export class EventsConsumer {
         }
         process.nextTick(this.consume);
     }
+    notifyConsumedEvent(event) {
+        if (!this.onConsumedEvent) {
+            return;
+        }
+        try {
+            this.onConsumedEvent(event);
+        }
+        catch (error) {
+            eventsLogger.error('onConsumedEvent callback threw an error', {
+                error,
+            });
+        }
+    }
     consume = () => {
-        const currentEvent = this.events[this.eventIndex] ?? null;
+        // Drain consecutively consumable events synchronously within a single
+        // pass instead of paying one `process.nextTick` per consumed event.
+        //
+        // Why this is safe: a callback only consumes an event using a consumer
+        // that is ALREADY registered (e.g. a long-lived step consumer walking
+        // `step_created` → `step_started` → `step_completed`, or the structural
+        // lifecycle consumer). New consumers are only ever registered by workflow
+        // VM body code that runs asynchronously off `ctx.promiseQueue` after a
+        // delivery `resolve()`; none of the callbacks here call `subscribe()`
+        // synchronously. So within one pass `this.callbacks` is mutated only by
+        // this loop (the `Finished` splice), and the next event's consumer is
+        // either already present (advance now) or not yet registered — in which
+        // case no callback consumes the event and we fall through to the
+        // cross-VM-safe deferred unconsumed-event check below, exactly as before.
+        while (true) {
+            const currentEvent = this.events[this.eventIndex] ?? null;
+            if (!this.consumeOne(currentEvent)) {
+                // No callback consumed the current event; handle the terminal case.
+                this.handleUnconsumed(currentEvent);
+                return;
+            }
+            // A real event was consumed — advance to the next in the same pass. A
+            // consumed `null` sentinel never returns true (see consumeOne), so the
+            // synchronous drain can't spin past the end of the log.
+        }
+    };
+    /**
+     * Offer `currentEvent` to each registered callback in turn. Returns true
+     * when a callback consumed a real (non-null) event and the drain should
+     * advance to the next event in the same synchronous pass; false otherwise
+     * (nothing consumed it, or the consumed event was the end-of-events
+     * sentinel).
+     */
+    consumeOne(currentEvent) {
         for (let i = 0; i < this.callbacks.length; i++) {
             const callback = this.callbacks[i];
             let handled = EventConsumerResult.NotConsumed;
@@ -64,20 +143,28 @@ export class EventsConsumer {
             catch (error) {
                 eventsLogger.error('EventConsumer callback threw an error', { error });
             }
-            if (handled === EventConsumerResult.Consumed ||
-                handled === EventConsumerResult.Finished) {
-                // consumer handled this event, so increase the event index
-                this.eventIndex++;
-                // remove the callback if it has finished
-                if (handled === EventConsumerResult.Finished) {
-                    this.callbacks.splice(i, 1);
-                }
-                // continue to the next event
-                process.nextTick(this.consume);
-                return;
+            if (handled !== EventConsumerResult.Consumed &&
+                handled !== EventConsumerResult.Finished) {
+                continue;
+            }
+            if (currentEvent !== null) {
+                this.notifyConsumedEvent(currentEvent);
             }
+            // consumer handled this event, so increase the event index
+            this.eventIndex++;
+            // remove the callback if it has finished
+            if (handled === EventConsumerResult.Finished) {
+                this.callbacks.splice(i, 1);
+            }
+            // Continue draining only for real events. Real consumers return
+            // NotConsumed for the `null` sentinel, but guard against a pathological
+            // callback consuming it so the drain never spins past end-of-log.
+            return currentEvent !== null;
         }
-        // If we reach here, all callbacks returned NotConsumed.
+        return false;
+    }
+    handleUnconsumed(currentEvent) {
+        // All callbacks returned NotConsumed for the current event.
         // If the current event is non-null (a real event, not end-of-events),
         // schedule a deferred check. We chain onto the promiseQueue so that any
         // pending async work (e.g., deserialization/decryption that triggers
@@ -108,9 +195,9 @@ export class EventsConsumer {
                         this.pendingUnconsumedCheck = null;
                         this.onUnconsumedEvent(currentEvent);
                     }
-                }, 100);
+                }, getDeferredCheckDelayMs());
             });
         }
-    };
+    }
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"events-consumer.js","sourceRoot":"","sources":["../src/events-consumer.ts"],"names":[],"mappings":"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","sourcesContent":["import type { Event } from '@workflow/world';\nimport { eventsLogger } from './logger.js';\n\nexport enum EventConsumerResult {\n  /**\n   * Callback consumed the event, but should not be removed from the callbacks list\n   */\n  Consumed,\n  /**\n   * Callback did not consume the event, so it should be passed to the next callback\n   */\n  NotConsumed,\n  /**\n   * Callback consumed the event, and should be removed from the callbacks list\n   */\n  Finished,\n}\n\ntype EventConsumerCallback = (event: Event | null) => EventConsumerResult;\n\nexport interface EventsConsumerOptions {\n  /**\n   * Callback invoked when a non-null event cannot be consumed by any registered\n   * callback, indicating an orphaned or invalid event in the event log. The\n   * check is deferred until after the promise queue has drained, ensuring that\n   * any pending async work (e.g., deserialization/decryption) completes and\n   * downstream subscribe() calls have a chance to cancel the check first.\n   */\n  onUnconsumedEvent: (event: Event) => void;\n  /**\n   * Returns the current promise queue. The unconsumed event check is chained\n   * onto this queue so it only fires after all pending async work (e.g.,\n   * deserialization) has completed. This prevents false positives when async\n   * deserialization delays the resolve() that triggers the next subscribe().\n   */\n  getPromiseQueue: () => Promise<void>;\n}\n\nexport class EventsConsumer {\n  eventIndex: number;\n  readonly events: Event[] = [];\n  readonly callbacks: EventConsumerCallback[] = [];\n  private onUnconsumedEvent: (event: Event) => void;\n  private getPromiseQueue: () => Promise<void>;\n  private pendingUnconsumedCheck: Promise<void> | null = null;\n  private pendingUnconsumedTimeout: ReturnType<typeof setTimeout> | null = null;\n  private unconsumedCheckVersion = 0;\n\n  constructor(events: Event[], options: EventsConsumerOptions) {\n    this.events = events;\n    this.eventIndex = 0;\n    this.onUnconsumedEvent = options.onUnconsumedEvent;\n    this.getPromiseQueue = options.getPromiseQueue;\n  }\n\n  /**\n   * Registers a callback function to be called after an event has been consumed\n   * by a different callback. The callback can return:\n   *  - `EventConsumerResult.Consumed` the event is considered consumed and will not be passed to any other callback, but the callback will remain in the callbacks list\n   *  - `EventConsumerResult.NotConsumed` the event is passed to the next callback\n   *  - `EventConsumerResult.Finished` the event is considered consumed and the callback is removed from the callbacks list\n   *\n   * @param fn - The callback function to register.\n   */\n  subscribe(fn: EventConsumerCallback) {\n    this.callbacks.push(fn);\n    // Cancel any pending unconsumed check since a new callback may consume the event.\n    // Incrementing the version causes any in-flight promise chain check to no-op.\n    // Also clear the pending setTimeout if it hasn't fired yet.\n    if (this.pendingUnconsumedCheck !== null) {\n      this.unconsumedCheckVersion++;\n      this.pendingUnconsumedCheck = null;\n      if (this.pendingUnconsumedTimeout !== null) {\n        clearTimeout(this.pendingUnconsumedTimeout);\n        this.pendingUnconsumedTimeout = null;\n      }\n    }\n    process.nextTick(this.consume);\n  }\n\n  private consume = () => {\n    const currentEvent = this.events[this.eventIndex] ?? null;\n    for (let i = 0; i < this.callbacks.length; i++) {\n      const callback = this.callbacks[i];\n      let handled = EventConsumerResult.NotConsumed;\n      try {\n        handled = callback(currentEvent);\n      } catch (error) {\n        eventsLogger.error('EventConsumer callback threw an error', { error });\n      }\n      if (\n        handled === EventConsumerResult.Consumed ||\n        handled === EventConsumerResult.Finished\n      ) {\n        // consumer handled this event, so increase the event index\n        this.eventIndex++;\n\n        // remove the callback if it has finished\n        if (handled === EventConsumerResult.Finished) {\n          this.callbacks.splice(i, 1);\n        }\n\n        // continue to the next event\n        process.nextTick(this.consume);\n        return;\n      }\n    }\n\n    // If we reach here, all callbacks returned NotConsumed.\n    // If the current event is non-null (a real event, not end-of-events),\n    // schedule a deferred check. We chain onto the promiseQueue so that any\n    // pending async work (e.g., deserialization/decryption that triggers\n    // resolve() → user code → subscribe()) completes first. If the event\n    // is still unconsumed after the queue drains, it's truly orphaned.\n    if (currentEvent !== null) {\n      const checkVersion = ++this.unconsumedCheckVersion;\n      this.pendingUnconsumedCheck = this.getPromiseQueue()\n        .then(\n          // Yield once after the first queue drain so promise chains resumed by\n          // that drain can run across the VM boundary and append any follow-up\n          // async work (for example: step_completed resolves -> for-await loop\n          // resumes -> the next hook payload starts hydrating).\n          () => new Promise<void>((resolve) => setTimeout(resolve, 0))\n        )\n        .then(() => this.getPromiseQueue())\n        .then(() => {\n          // Use a delayed setTimeout after the queue drains. The delay must be\n          // long enough for promise chains to propagate across the VM boundary\n          // (from resolve() in the host context through to the workflow code\n          // calling subscribe() in the VM context). Node.js does not guarantee\n          // that setTimeout(0) fires after all cross-context microtasks settle,\n          // so we use a small but non-zero delay. Any subscribe() call that\n          // arrives during this window will cancel the check via version\n          // invalidation + clearTimeout.\n          this.pendingUnconsumedTimeout = setTimeout(() => {\n            this.pendingUnconsumedTimeout = null;\n            if (this.unconsumedCheckVersion === checkVersion) {\n              this.pendingUnconsumedCheck = null;\n              this.onUnconsumedEvent(currentEvent);\n            }\n          }, 100);\n        });\n    }\n  };\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"events-consumer.js","sourceRoot":"","sources":["../src/events-consumer.ts"],"names":[],"mappings":"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","sourcesContent":["import { type Event, envNumber } from '@workflow/world';\nimport { eventsLogger } from './logger.js';\n\n/**\n * Delay before firing the deferred unconsumed-event check after the promise\n * queue has drained. Must be long enough for cross-VM microtask chains to\n * propagate (resolve in host → workflow code in VM → subscribe call back\n * in host). Any subscribe() arriving during this window cancels the check.\n */\nexport const DEFERRED_CHECK_DELAY_MS = 100;\n\n/**\n * Effective deferred-check delay. Override: `WORKFLOW_DEFERRED_CHECK_DELAY_MS`.\n *\n * Unlike the other timing knobs this is not a polling interval but a\n * determinism safety margin: firing the unconsumed-event check before the\n * cross-VM subscribe() chain has landed rejects a healthy run with\n * `ReplayDivergenceError`. Floored at 10ms so a too-low override can't\n * manufacture spurious divergence (each false positive burns a\n * divergence-recovery retry and can escalate to a terminal\n * `CorruptedEventLogError`).\n */\nconst getDeferredCheckDelayMs = (): number =>\n  envNumber('WORKFLOW_DEFERRED_CHECK_DELAY_MS', DEFERRED_CHECK_DELAY_MS, {\n    integer: true,\n    min: 10,\n  });\n\nexport enum EventConsumerResult {\n  /**\n   * Callback consumed the event, but should not be removed from the callbacks list\n   */\n  Consumed,\n  /**\n   * Callback did not consume the event, so it should be passed to the next callback\n   */\n  NotConsumed,\n  /**\n   * Callback consumed the event, and should be removed from the callbacks list\n   */\n  Finished,\n}\n\ntype EventConsumerCallback = (event: Event | null) => EventConsumerResult;\n\nexport interface EventsConsumerOptions {\n  /**\n   * Callback invoked after an event has been consumed. Consumers such as the\n   * deterministic workflow clock must not observe events that are merely\n   * inspected while waiting for user code to subscribe to the next operation.\n   */\n  onConsumedEvent?: (event: Event) => void;\n  /**\n   * Callback invoked when a non-null event cannot be consumed by any registered\n   * callback, indicating an orphaned or invalid event in the event log. The\n   * check is deferred until after the promise queue has drained, ensuring that\n   * any pending async work (e.g., deserialization/decryption) completes and\n   * downstream subscribe() calls have a chance to cancel the check first.\n   */\n  onUnconsumedEvent: (event: Event) => void;\n  /**\n   * Returns the current promise queue. The unconsumed event check is chained\n   * onto this queue so it only fires after all pending async work (e.g.,\n   * deserialization) has completed. This prevents false positives when async\n   * deserialization delays the resolve() that triggers the next subscribe().\n   */\n  getPromiseQueue: () => Promise<void>;\n}\n\nexport class EventsConsumer {\n  eventIndex: number;\n  readonly events: Event[];\n  readonly callbacks: EventConsumerCallback[] = [];\n  private onConsumedEvent?: (event: Event) => void;\n  private onUnconsumedEvent: (event: Event) => void;\n  private getPromiseQueue: () => Promise<void>;\n  private pendingUnconsumedCheck: Promise<void> | null = null;\n  private pendingUnconsumedTimeout: ReturnType<typeof setTimeout> | null = null;\n  private unconsumedCheckVersion = 0;\n\n  constructor(events: Event[], options: EventsConsumerOptions) {\n    // Own copy: the runtime mutates its event array in place, and a retained\n    // session must only observe new events through append() so resume()'s\n    // strict-extension check stays meaningful.\n    this.events = [...events];\n    this.eventIndex = 0;\n    this.onConsumedEvent = options.onConsumedEvent;\n    this.onUnconsumedEvent = options.onUnconsumedEvent;\n    this.getPromiseQueue = options.getPromiseQueue;\n  }\n\n  append(events: Event[]): void {\n    for (const event of events) this.events.push(event);\n    process.nextTick(this.consume);\n  }\n\n  /**\n   * Registers a callback function to be called after an event has been consumed\n   * by a different callback. The callback can return:\n   *  - `EventConsumerResult.Consumed` the event is considered consumed and will not be passed to any other callback, but the callback will remain in the callbacks list\n   *  - `EventConsumerResult.NotConsumed` the event is passed to the next callback\n   *  - `EventConsumerResult.Finished` the event is considered consumed and the callback is removed from the callbacks list\n   *\n   * @param fn - The callback function to register.\n   */\n  subscribe(fn: EventConsumerCallback) {\n    this.callbacks.push(fn);\n    // Cancel any pending unconsumed check since a new callback may consume the event.\n    // Incrementing the version causes any in-flight promise chain check to no-op.\n    // Also clear the pending setTimeout if it hasn't fired yet.\n    if (this.pendingUnconsumedCheck !== null) {\n      this.unconsumedCheckVersion++;\n      this.pendingUnconsumedCheck = null;\n      if (this.pendingUnconsumedTimeout !== null) {\n        clearTimeout(this.pendingUnconsumedTimeout);\n        this.pendingUnconsumedTimeout = null;\n      }\n    }\n    process.nextTick(this.consume);\n  }\n\n  private notifyConsumedEvent(event: Event) {\n    if (!this.onConsumedEvent) {\n      return;\n    }\n    try {\n      this.onConsumedEvent(event);\n    } catch (error) {\n      eventsLogger.error('onConsumedEvent callback threw an error', {\n        error,\n      });\n    }\n  }\n\n  private consume = () => {\n    // Drain consecutively consumable events synchronously within a single\n    // pass instead of paying one `process.nextTick` per consumed event.\n    //\n    // Why this is safe: a callback only consumes an event using a consumer\n    // that is ALREADY registered (e.g. a long-lived step consumer walking\n    // `step_created` → `step_started` → `step_completed`, or the structural\n    // lifecycle consumer). New consumers are only ever registered by workflow\n    // VM body code that runs asynchronously off `ctx.promiseQueue` after a\n    // delivery `resolve()`; none of the callbacks here call `subscribe()`\n    // synchronously. So within one pass `this.callbacks` is mutated only by\n    // this loop (the `Finished` splice), and the next event's consumer is\n    // either already present (advance now) or not yet registered — in which\n    // case no callback consumes the event and we fall through to the\n    // cross-VM-safe deferred unconsumed-event check below, exactly as before.\n    while (true) {\n      const currentEvent = this.events[this.eventIndex] ?? null;\n      if (!this.consumeOne(currentEvent)) {\n        // No callback consumed the current event; handle the terminal case.\n        this.handleUnconsumed(currentEvent);\n        return;\n      }\n      // A real event was consumed — advance to the next in the same pass. A\n      // consumed `null` sentinel never returns true (see consumeOne), so the\n      // synchronous drain can't spin past the end of the log.\n    }\n  };\n\n  /**\n   * Offer `currentEvent` to each registered callback in turn. Returns true\n   * when a callback consumed a real (non-null) event and the drain should\n   * advance to the next event in the same synchronous pass; false otherwise\n   * (nothing consumed it, or the consumed event was the end-of-events\n   * sentinel).\n   */\n  private consumeOne(currentEvent: Event | null): boolean {\n    for (let i = 0; i < this.callbacks.length; i++) {\n      const callback = this.callbacks[i];\n      let handled = EventConsumerResult.NotConsumed;\n      try {\n        handled = callback(currentEvent);\n      } catch (error) {\n        eventsLogger.error('EventConsumer callback threw an error', { error });\n      }\n      if (\n        handled !== EventConsumerResult.Consumed &&\n        handled !== EventConsumerResult.Finished\n      ) {\n        continue;\n      }\n      if (currentEvent !== null) {\n        this.notifyConsumedEvent(currentEvent);\n      }\n      // consumer handled this event, so increase the event index\n      this.eventIndex++;\n      // remove the callback if it has finished\n      if (handled === EventConsumerResult.Finished) {\n        this.callbacks.splice(i, 1);\n      }\n      // Continue draining only for real events. Real consumers return\n      // NotConsumed for the `null` sentinel, but guard against a pathological\n      // callback consuming it so the drain never spins past end-of-log.\n      return currentEvent !== null;\n    }\n    return false;\n  }\n\n  private handleUnconsumed(currentEvent: Event | null) {\n    // All callbacks returned NotConsumed for the current event.\n    // If the current event is non-null (a real event, not end-of-events),\n    // schedule a deferred check. We chain onto the promiseQueue so that any\n    // pending async work (e.g., deserialization/decryption that triggers\n    // resolve() → user code → subscribe()) completes first. If the event\n    // is still unconsumed after the queue drains, it's truly orphaned.\n    if (currentEvent !== null) {\n      const checkVersion = ++this.unconsumedCheckVersion;\n      this.pendingUnconsumedCheck = this.getPromiseQueue()\n        .then(\n          // Yield once after the first queue drain so promise chains resumed by\n          // that drain can run across the VM boundary and append any follow-up\n          // async work (for example: step_completed resolves -> for-await loop\n          // resumes -> the next hook payload starts hydrating).\n          () => new Promise<void>((resolve) => setTimeout(resolve, 0))\n        )\n        .then(() => this.getPromiseQueue())\n        .then(() => {\n          // Use a delayed setTimeout after the queue drains. The delay must be\n          // long enough for promise chains to propagate across the VM boundary\n          // (from resolve() in the host context through to the workflow code\n          // calling subscribe() in the VM context). Node.js does not guarantee\n          // that setTimeout(0) fires after all cross-context microtasks settle,\n          // so we use a small but non-zero delay. Any subscribe() call that\n          // arrives during this window will cancel the check via version\n          // invalidation + clearTimeout.\n          this.pendingUnconsumedTimeout = setTimeout(() => {\n            this.pendingUnconsumedTimeout = null;\n            if (this.unconsumedCheckVersion === checkVersion) {\n              this.pendingUnconsumedCheck = null;\n              this.onUnconsumedEvent(currentEvent);\n            }\n          }, getDeferredCheckDelayMs());\n        });\n    }\n  }\n}\n"]}

package/dist/flushable-stream.d.ts

@@ -1,4 +1,51 @@
 import { type PromiseWithResolvers } from '@workflow/utils';
+/**
+ * A durability barrier a sink may expose under {@link STREAM_DRAIN_SYMBOL}:
+ * resolves once every chunk the sink has accepted is durably written, rejects
+ * if any server write failed. See `WorkflowServerWritableStream`.
+ */
+type DrainBarrier = () => Promise<void>;
+/**
+ * Flow-control knob: upper bound on chunks read-but-not-yet-durably-written
+ * while coalescing. Once this many chunks are outstanding the producer stops
+ * reading until the consumer drains a batch, so a fast producer paired with a
+ * slow server can't grow the in-memory queue without bound. Override:
+ * `WORKFLOW_STREAM_MAX_INFLIGHT_CHUNKS`.
+ *
+ * This is deliberately distinct from the per-request batch caps below: this
+ * bounds how much is *buffered*, those bound how much goes out in one
+ * `writeMulti`. Raising this must never let a single request exceed a wire
+ * limit — batch sizing enforces that independently.
+ */
+export declare const MAX_INFLIGHT_CHUNKS = 1000;
+export declare const getMaxInflightChunks: () => number;
+/**
+ * Wire limit: maximum number of chunks in a single coalesced `writeMulti`.
+ * The server enforces a per-multi-write chunk cap (1,000 today); a batch is
+ * split at this bound so it can never be rejected wholesale, independently of
+ * the backpressure knob above. Override: `WORKFLOW_STREAM_MAX_CHUNKS_PER_BATCH`.
+ */
+export declare const MAX_CHUNKS_PER_BATCH = 1000;
+export declare const getMaxChunksPerBatch: () => number;
+/**
+ * Wire limit: maximum cumulative bytes in a single coalesced `writeMulti`.
+ * Chunk *count* alone is not enough — 1,000 small chunks are ~100KB but 1,000
+ * file-sized chunks can be hundreds of MB, which platform request-body limits
+ * reject long before the count cap matters. A batch is split once adding the
+ * next chunk would exceed this (a single chunk larger than the cap still goes
+ * out alone). Default 1 MiB. Override: `WORKFLOW_STREAM_MAX_BYTES_PER_BATCH`.
+ */
+export declare const MAX_BYTES_PER_BATCH: number;
+export declare const getMaxBytesPerBatch: () => number;
+/**
+ * Buffer bound (bytes) for the server writable's group-commit buffer — the
+ * byte-denominated counterpart of {@link MAX_INFLIGHT_CHUNKS}. `write()`
+ * blocks once this much data is buffered-but-not-durable, so a fast producer
+ * of large chunks can't grow client memory without bound. Default 8 MiB
+ * (eight request-sized groups). Override: `WORKFLOW_STREAM_MAX_BUFFERED_BYTES`.
+ */
+export declare const MAX_BUFFERED_BYTES: number;
+export declare const getMaxBufferedBytes: () => number;
 /**
  * Polling interval (in ms) for lock release detection.
  *
@@ -7,17 +54,17 @@ import { type PromiseWithResolvers } from '@workflow/utils';
  * to acquire a reader/writer. For that reason we use polling instead of a
  * fully event-driven approach here.
  *
- * 100ms is a compromise between:
- * - Latency: how quickly we notice that the user has released their lock, and
- * - Cost/CPU usage: how often timers fire, especially with many concurrent
- *   streams or in serverless environments where billed time matters.
- *
- * This value should only be changed with care, as decreasing it will
- * increase polling frequency (and thus potential cost), while increasing it
- * will add worst-case delay before the `done` promise resolves after a lock
- * is released.
+ * 10ms is chosen so the polling tick almost never sits on the critical path:
+ * the V2 step-executor's `opsSettled` race waits for this state to resolve
+ * after each step body returns, so a coarser interval (the previous 100ms)
+ * adds visible per-step latency to streaming workflows. With a uniformly
+ * distributed offset between step return and the next tick, the expected
+ * wait is half the interval — so 10ms means ~5ms average wait per step
+ * instead of ~50ms. The per-tick work is `writable.locked` plus a
+ * `getWriter()`/`releaseLock()` probe, both microsecond-scale; 10× more
+ * ticks during a stream's lifetime is not measurable in practice.
  */
-export declare const LOCK_POLL_INTERVAL_MS = 100;
+export declare const LOCK_POLL_INTERVAL_MS = 10;
 /**
  * State tracker for flushable stream operations.
  * Resolves when either:
@@ -43,6 +90,13 @@ export interface FlushableStreamState extends PromiseWithResolvers<void> {
     writablePollingInterval?: ReturnType<typeof setInterval>;
     /** Interval ID for readable lock polling (if active) */
     readablePollingInterval?: ReturnType<typeof setInterval>;
+    /**
+     * Durability barrier of the pipe's sink, when it acks writes on buffer
+     * entry (see {@link STREAM_DRAIN_SYMBOL}). Lock-release completion awaits
+     * this before resolving so `pendingOps === 0` (fast, buffered acks) can't
+     * complete a step while data is still client-side.
+     */
+    drainBarrier?: DrainBarrier;
 }
 export declare function createFlushableState(): FlushableStreamState;
 /**
@@ -79,4 +133,5 @@ export declare function pollReadableLock(readable: ReadableStream, state: Flusha
  * @returns Promise that resolves when stream ends (not when done promise resolves)
  */
 export declare function flushablePipe(source: ReadableStream, sink: WritableStream, state: FlushableStreamState): Promise<void>;
+export {};
 //# sourceMappingURL=flushable-stream.d.ts.map

package/dist/flushable-stream.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"flushable-stream.d.ts","sourceRoot":"","sources":["../src/flushable-stream.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,oBAAoB,EAAiB,MAAM,iBAAiB,CAAC;AAE3E;;;;;;;;;;;;;;;;;GAiBG;AACH,eAAO,MAAM,qBAAqB,MAAM,CAAC;AAEzC;;;;;;;;;;;;;GAaG;AACH,MAAM,WAAW,oBAAqB,SAAQ,oBAAoB,CAAC,IAAI,CAAC;IACtE,mEAAmE;IACnE,UAAU,EAAE,MAAM,CAAC;IACnB,mDAAmD;IACnD,YAAY,EAAE,OAAO,CAAC;IACtB,gEAAgE;IAChE,WAAW,EAAE,OAAO,CAAC;IACrB,wDAAwD;IACxD,uBAAuB,CAAC,EAAE,UAAU,CAAC,OAAO,WAAW,CAAC,CAAC;IACzD,wDAAwD;IACxD,uBAAuB,CAAC,EAAE,UAAU,CAAC,OAAO,WAAW,CAAC,CAAC;CAC1D;AAED,wBAAgB,oBAAoB,IAAI,oBAAoB,CAO3D;AA2DD;;;;;;;;;GASG;AACH,wBAAgB,gBAAgB,CAC9B,QAAQ,EAAE,cAAc,EACxB,KAAK,EAAE,oBAAoB,GAC1B,IAAI,CAwBN;AAED;;;;;;;;;GASG;AACH,wBAAgB,gBAAgB,CAC9B,QAAQ,EAAE,cAAc,EACxB,KAAK,EAAE,oBAAoB,GAC1B,IAAI,CAwBN;AAED;;;;;;;;;;GAUG;AACH,wBAAsB,aAAa,CACjC,MAAM,EAAE,cAAc,EACtB,IAAI,EAAE,cAAc,EACpB,KAAK,EAAE,oBAAoB,GAC1B,OAAO,CAAC,IAAI,CAAC,CAoEf"}
+{"version":3,"file":"flushable-stream.d.ts","sourceRoot":"","sources":["../src/flushable-stream.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,oBAAoB,EAAiB,MAAM,iBAAiB,CAAC;AAI3E;;;;GAIG;AACH,KAAK,YAAY,GAAG,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;AAExC;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,mBAAmB,OAAO,CAAC;AAExC,eAAO,MAAM,oBAAoB,QAAO,MAIpC,CAAC;AAEL;;;;;GAKG;AACH,eAAO,MAAM,oBAAoB,OAAO,CAAC;AAEzC,eAAO,MAAM,oBAAoB,QAAO,MAIpC,CAAC;AAEL;;;;;;;GAOG;AACH,eAAO,MAAM,mBAAmB,QAAc,CAAC;AAE/C,eAAO,MAAM,mBAAmB,QAAO,MAInC,CAAC;AAEL;;;;;;GAMG;AACH,eAAO,MAAM,kBAAkB,QAAkB,CAAC;AAElD,eAAO,MAAM,mBAAmB,QAAO,MAInC,CAAC;AAEL;;;;;;;;;;;;;;;;;GAiBG;AACH,eAAO,MAAM,qBAAqB,KAAK,CAAC;AASxC;;;;;;;;;;;;;GAaG;AACH,MAAM,WAAW,oBAAqB,SAAQ,oBAAoB,CAAC,IAAI,CAAC;IACtE,mEAAmE;IACnE,UAAU,EAAE,MAAM,CAAC;IACnB,mDAAmD;IACnD,YAAY,EAAE,OAAO,CAAC;IACtB,gEAAgE;IAChE,WAAW,EAAE,OAAO,CAAC;IACrB,wDAAwD;IACxD,uBAAuB,CAAC,EAAE,UAAU,CAAC,OAAO,WAAW,CAAC,CAAC;IACzD,wDAAwD;IACxD,uBAAuB,CAAC,EAAE,UAAU,CAAC,OAAO,WAAW,CAAC,CAAC;IACzD;;;;;OAKG;IACH,YAAY,CAAC,EAAE,YAAY,CAAC;CAC7B;AAED,wBAAgB,oBAAoB,IAAI,oBAAoB,CAa3D;AAgFD;;;;;;;;;GASG;AACH,wBAAgB,gBAAgB,CAC9B,QAAQ,EAAE,cAAc,EACxB,KAAK,EAAE,oBAAoB,GAC1B,IAAI,CAwBN;AAED;;;;;;;;;GASG;AACH,wBAAgB,gBAAgB,CAC9B,QAAQ,EAAE,cAAc,EACxB,KAAK,EAAE,oBAAoB,GAC1B,IAAI,CAwBN;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,aAAa,CAC3B,MAAM,EAAE,cAAc,EACtB,IAAI,EAAE,cAAc,EACpB,KAAK,EAAE,oBAAoB,GAC1B,OAAO,CAAC,IAAI,CAAC,CAcf"}