@actuallab/rpc 12.3.85 → 12.4.1

package/dist/index.d.cts

@@ -995,7 +995,7 @@ interface RpcStreamRef {
     readonly hostId: string;
     readonly localId: number;
     readonly ackPeriod: number;
-    readonly ackAdvance: number;
+    readonly bufferSize: number;
     readonly allowReconnect: boolean;
     readonly isRealTime: boolean;
 }
@@ -1009,13 +1009,13 @@ type RpcStreamSource<T> = AsyncIterable<T> | ((abortSignal: AbortSignal) => Asyn
 /** Configuration options for creating a local (origin-side) RpcStream. */
 interface RpcStreamOptions<T> {
     ackPeriod?: number;
-    ackAdvance?: number;
+    bufferSize?: number;
     allowReconnect?: boolean;
     isRealTime?: boolean;
     canSkipTo?: (item: T) => boolean;
 }
 /**
- * Parses a stream reference string of the form "{hostId},{localId},{ackPeriod},{ackAdvance}".
+ * Parses a stream reference string of the form "{hostId},{localId},{ackPeriod},{bufferSize}".
  * Returns null if the value is not a valid stream reference.
  */
 declare function parseStreamRef(value: unknown): RpcStreamRef | null;
@@ -1047,7 +1047,7 @@ declare class RpcStream<T> implements AsyncIterable<T>, IRpcObject {
     readonly isRealTime: boolean;
     readonly canSkipTo: (item: T) => boolean;
     readonly ackPeriod: number;
-    readonly ackAdvance: number;
+    readonly bufferSize: number;
     readonly localSource?: RpcStreamSource<T>;
     readonly peer: RpcPeer;
     private _sender?;
@@ -1078,7 +1078,7 @@ declare class RpcStream<T> implements AsyncIterable<T>, IRpcObject {
      * stream reference.
      *
      * For binary peers the ref is a MessagePack-compatible object
-     * (`{ SerializedId, AckPeriod, AckAdvance, AllowReconnect }`);
+     * (`{ SerializedId, AckPeriod, BufferSize, AllowReconnect }`);
      * for text peers it is a comma-separated string.
      *
      * Can only be called once per stream.
@@ -1104,7 +1104,7 @@ declare class RpcStream<T> implements AsyncIterable<T>, IRpcObject {
  * Recursively walks a deserialized value and replaces any stream ref strings
  * with live RpcStream<unknown> instances registered on the given peer.
  * This handles nested stream refs inside complex return types (e.g. Table<T>
- * containing RpcStream<Row<T>> fields serialized as "{hostId},{localId},{ackPeriod},{ackAdvance}").
+ * containing RpcStream<Row<T>> fields serialized as "{hostId},{localId},{ackPeriod},{bufferSize}").
  */
 declare function resolveStreamRefs(value: unknown, peer: RpcPeer): unknown;
 
@@ -1123,13 +1123,12 @@ declare function resolveStreamRefs(value: unknown, peer: RpcPeer): unknown;
  * The pump is ACK-driven: the main loop blocks on `_whenAckReady` until a
  * client ACK is queued, processes it (updating `_lastAckedIndex`, rewinding
  * `_index` on mustReset, trimming the replay buffer), then sends items up
- * to `ack.nextIndex + ackAdvance`. While the peer is disconnected no ACKs
+ * to `ack.nextIndex + bufferSize`. While the peer is disconnected no ACKs
  * arrive, so the source is never pulled — the sender naturally pauses
  * instead of spinning.
  *
  * Direct port of .NET `RpcSharedStream<T>` at
- * src/ActualLab.Rpc/Infrastructure/RpcSharedStream.cs — including the
- * separate non-real-time / real-time pump variants.
+ * src/ActualLab.Rpc/Infrastructure/RpcSharedStream.cs.
  */
 declare class RpcStreamSender<T> implements IRpcObject {
     private static readonly _emptyGuid;
@@ -1140,7 +1139,7 @@ declare class RpcStreamSender<T> implements IRpcObject {
     readonly canSkipTo: (item: T) => boolean;
     readonly peer: RpcPeer;
     readonly ackPeriod: number;
-    readonly ackAdvance: number;
+    readonly bufferSize: number;
     /**
      * If true, the source was produced by a factory `(abortSignal) => AsyncIterable<T>`
      * and may honor the AbortSignal to exit gracefully. `disconnect()` first aborts
@@ -1161,7 +1160,7 @@ declare class RpcStreamSender<T> implements IRpcObject {
     private _iterator;
     private _acks;
     private _whenAckReady;
-    constructor(peer: RpcPeer, ackPeriod?: number, ackAdvance?: number, allowReconnect?: boolean, isRealTime?: boolean, canSkipTo?: (item: T) => boolean, sourceUsesAbortSignal?: boolean);
+    constructor(peer: RpcPeer, ackPeriod?: number, bufferSize?: number, allowReconnect?: boolean, isRealTime?: boolean, canSkipTo?: (item: T) => boolean, sourceUsesAbortSignal?: boolean);
     /** AbortSignal that is aborted when the sender is disconnected. */
     get abortSignal(): AbortSignal;
     /** Returns the stream reference string for the $sys.Ok response. */
@@ -1192,25 +1191,16 @@ declare class RpcStreamSender<T> implements IRpcObject {
     /**
      * Consume an AsyncIterable and send all items to the client.
      *
-     * Dispatches to the non-real-time or real-time pump, matching .NET
-     * `RpcSharedStream<T>.OnRun` at
-     * src/ActualLab.Rpc/Infrastructure/RpcSharedStream.cs:105-108.
+     * Matches .NET `RpcSharedStream<T>.OnRun` at
+     * src/ActualLab.Rpc/Infrastructure/RpcSharedStream.cs.
      */
     writeFrom(source: AsyncIterable<T>): Promise<void>;
     /**
-     * Non-real-time pump — back-pressure through buffered ACKs.
-     *
-     * Direct port of .NET `OnRunNonRealTime` at
-     * src/ActualLab.Rpc/Infrastructure/RpcSharedStream.cs:110-217.
-     */
-    private _runNonRealTime;
-    /**
-     * Real-time pump — drops stale items to stay close to the source's head.
-     *
-     * Direct port of .NET `OnRunRealTime` at
-     * src/ActualLab.Rpc/Infrastructure/RpcSharedStream.cs:219-420.
+     * ACK-driven pump. Non-real-time streams apply normal backpressure at
+     * `bufferSize`; real-time streams may compact the already-buffered unsent
+     * suffix to the latest buffered `canSkipTo` item after the consumer ACKs.
      */
-    private _runRealTime;
+    private _run;
     /** Drain all queued ACKs, returning the most recent one (or null if none). */
     private _tryProcessAcks;
     /** Wait for the ACK queue to have at least one entry (or `_ended`). */

package/dist/index.d.ts

@@ -995,7 +995,7 @@ interface RpcStreamRef {
     readonly hostId: string;
     readonly localId: number;
     readonly ackPeriod: number;
-    readonly ackAdvance: number;
+    readonly bufferSize: number;
     readonly allowReconnect: boolean;
     readonly isRealTime: boolean;
 }
@@ -1009,13 +1009,13 @@ type RpcStreamSource<T> = AsyncIterable<T> | ((abortSignal: AbortSignal) => Asyn
 /** Configuration options for creating a local (origin-side) RpcStream. */
 interface RpcStreamOptions<T> {
     ackPeriod?: number;
-    ackAdvance?: number;
+    bufferSize?: number;
     allowReconnect?: boolean;
     isRealTime?: boolean;
     canSkipTo?: (item: T) => boolean;
 }
 /**
- * Parses a stream reference string of the form "{hostId},{localId},{ackPeriod},{ackAdvance}".
+ * Parses a stream reference string of the form "{hostId},{localId},{ackPeriod},{bufferSize}".
  * Returns null if the value is not a valid stream reference.
  */
 declare function parseStreamRef(value: unknown): RpcStreamRef | null;
@@ -1047,7 +1047,7 @@ declare class RpcStream<T> implements AsyncIterable<T>, IRpcObject {
     readonly isRealTime: boolean;
     readonly canSkipTo: (item: T) => boolean;
     readonly ackPeriod: number;
-    readonly ackAdvance: number;
+    readonly bufferSize: number;
     readonly localSource?: RpcStreamSource<T>;
     readonly peer: RpcPeer;
     private _sender?;
@@ -1078,7 +1078,7 @@ declare class RpcStream<T> implements AsyncIterable<T>, IRpcObject {
      * stream reference.
      *
      * For binary peers the ref is a MessagePack-compatible object
-     * (`{ SerializedId, AckPeriod, AckAdvance, AllowReconnect }`);
+     * (`{ SerializedId, AckPeriod, BufferSize, AllowReconnect }`);
      * for text peers it is a comma-separated string.
      *
      * Can only be called once per stream.
@@ -1104,7 +1104,7 @@ declare class RpcStream<T> implements AsyncIterable<T>, IRpcObject {
  * Recursively walks a deserialized value and replaces any stream ref strings
  * with live RpcStream<unknown> instances registered on the given peer.
  * This handles nested stream refs inside complex return types (e.g. Table<T>
- * containing RpcStream<Row<T>> fields serialized as "{hostId},{localId},{ackPeriod},{ackAdvance}").
+ * containing RpcStream<Row<T>> fields serialized as "{hostId},{localId},{ackPeriod},{bufferSize}").
  */
 declare function resolveStreamRefs(value: unknown, peer: RpcPeer): unknown;
 
@@ -1123,13 +1123,12 @@ declare function resolveStreamRefs(value: unknown, peer: RpcPeer): unknown;
  * The pump is ACK-driven: the main loop blocks on `_whenAckReady` until a
  * client ACK is queued, processes it (updating `_lastAckedIndex`, rewinding
  * `_index` on mustReset, trimming the replay buffer), then sends items up
- * to `ack.nextIndex + ackAdvance`. While the peer is disconnected no ACKs
+ * to `ack.nextIndex + bufferSize`. While the peer is disconnected no ACKs
  * arrive, so the source is never pulled — the sender naturally pauses
  * instead of spinning.
  *
  * Direct port of .NET `RpcSharedStream<T>` at
- * src/ActualLab.Rpc/Infrastructure/RpcSharedStream.cs — including the
- * separate non-real-time / real-time pump variants.
+ * src/ActualLab.Rpc/Infrastructure/RpcSharedStream.cs.
  */
 declare class RpcStreamSender<T> implements IRpcObject {
     private static readonly _emptyGuid;
@@ -1140,7 +1139,7 @@ declare class RpcStreamSender<T> implements IRpcObject {
     readonly canSkipTo: (item: T) => boolean;
     readonly peer: RpcPeer;
     readonly ackPeriod: number;
-    readonly ackAdvance: number;
+    readonly bufferSize: number;
     /**
      * If true, the source was produced by a factory `(abortSignal) => AsyncIterable<T>`
      * and may honor the AbortSignal to exit gracefully. `disconnect()` first aborts
@@ -1161,7 +1160,7 @@ declare class RpcStreamSender<T> implements IRpcObject {
     private _iterator;
     private _acks;
     private _whenAckReady;
-    constructor(peer: RpcPeer, ackPeriod?: number, ackAdvance?: number, allowReconnect?: boolean, isRealTime?: boolean, canSkipTo?: (item: T) => boolean, sourceUsesAbortSignal?: boolean);
+    constructor(peer: RpcPeer, ackPeriod?: number, bufferSize?: number, allowReconnect?: boolean, isRealTime?: boolean, canSkipTo?: (item: T) => boolean, sourceUsesAbortSignal?: boolean);
     /** AbortSignal that is aborted when the sender is disconnected. */
     get abortSignal(): AbortSignal;
     /** Returns the stream reference string for the $sys.Ok response. */
@@ -1192,25 +1191,16 @@ declare class RpcStreamSender<T> implements IRpcObject {
     /**
      * Consume an AsyncIterable and send all items to the client.
      *
-     * Dispatches to the non-real-time or real-time pump, matching .NET
-     * `RpcSharedStream<T>.OnRun` at
-     * src/ActualLab.Rpc/Infrastructure/RpcSharedStream.cs:105-108.
+     * Matches .NET `RpcSharedStream<T>.OnRun` at
+     * src/ActualLab.Rpc/Infrastructure/RpcSharedStream.cs.
      */
     writeFrom(source: AsyncIterable<T>): Promise<void>;
     /**
-     * Non-real-time pump — back-pressure through buffered ACKs.
-     *
-     * Direct port of .NET `OnRunNonRealTime` at
-     * src/ActualLab.Rpc/Infrastructure/RpcSharedStream.cs:110-217.
-     */
-    private _runNonRealTime;
-    /**
-     * Real-time pump — drops stale items to stay close to the source's head.
-     *
-     * Direct port of .NET `OnRunRealTime` at
-     * src/ActualLab.Rpc/Infrastructure/RpcSharedStream.cs:219-420.
+     * ACK-driven pump. Non-real-time streams apply normal backpressure at
+     * `bufferSize`; real-time streams may compact the already-buffered unsent
+     * suffix to the latest buffered `canSkipTo` item after the consumer ACKs.
      */
-    private _runRealTime;
+    private _run;
     /** Drain all queued ACKs, returning the most recent one (or null if none). */
     private _tryProcessAcks;
     /** Wait for the ACK queue to have at least one entry (or `_ended`). */

package/dist/index.js

@@ -870,7 +870,7 @@ var RpcObjectKind = { Local: 0, Remote: 1 };
 import { PromiseSource as PromiseSource3, RingBuffer } from "@actuallab/core";
 var { warnLog: warnLog3 } = getLogs("RpcSharedStream");
 var DEFAULT_ACK_PERIOD = 256;
-var DEFAULT_ACK_ADVANCE = 128;
+var DEFAULT_BUFFER_SIZE = 128;
 var RpcStreamSender = class _RpcStreamSender {
   static _emptyGuid = "00000000-0000-0000-0000-000000000000";
   id;
@@ -880,7 +880,7 @@ var RpcStreamSender = class _RpcStreamSender {
   canSkipTo;
   peer;
   ackPeriod;
-  ackAdvance;
+  bufferSize;
   /**
    * If true, the source was produced by a factory `(abortSignal) => AsyncIterable<T>`
    * and may honor the AbortSignal to exit gracefully. `disconnect()` first aborts
@@ -903,7 +903,7 @@ var RpcStreamSender = class _RpcStreamSender {
   // -- ACK queue (analog of .NET's Channel<(long, bool)>) --
   _acks = [];
   _whenAckReady = null;
-  constructor(peer, ackPeriod = DEFAULT_ACK_PERIOD, ackAdvance = DEFAULT_ACK_ADVANCE, allowReconnect = true, isRealTime = false, canSkipTo = () => true, sourceUsesAbortSignal = false) {
+  constructor(peer, ackPeriod = DEFAULT_ACK_PERIOD, bufferSize = DEFAULT_BUFFER_SIZE, allowReconnect = true, isRealTime = false, canSkipTo = () => true, sourceUsesAbortSignal = false) {
     const localId = peer.sharedObjects.nextId();
     this.id = { hostId: peer.hub.hubId, localId };
     this.allowReconnect = allowReconnect;
@@ -911,7 +911,7 @@ var RpcStreamSender = class _RpcStreamSender {
     this.canSkipTo = canSkipTo;
     this.peer = peer;
     this.ackPeriod = ackPeriod;
-    this.ackAdvance = ackAdvance;
+    this.bufferSize = bufferSize;
     this.sourceUsesAbortSignal = sourceUsesAbortSignal;
   }
   /** AbortSignal that is aborted when the sender is disconnected. */
@@ -920,7 +920,7 @@ var RpcStreamSender = class _RpcStreamSender {
   }
   /** Returns the stream reference string for the $sys.Ok response. */
   toRef() {
-    return `${this.id.hostId},${this.id.localId},${this.ackPeriod},${this.ackAdvance},${this.allowReconnect ? "1" : "0"},${this.isRealTime ? "1" : "0"}`;
+    return `${this.id.hostId},${this.id.localId},${this.ackPeriod},${this.bufferSize},${this.allowReconnect ? "1" : "0"},${this.isRealTime ? "1" : "0"}`;
   }
   /**
    * Called by system call handler when $sys.Ack is received from the client.
@@ -997,9 +997,8 @@ var RpcStreamSender = class _RpcStreamSender {
   /**
    * Consume an AsyncIterable and send all items to the client.
    *
-   * Dispatches to the non-real-time or real-time pump, matching .NET
-   * `RpcSharedStream<T>.OnRun` at
-   * src/ActualLab.Rpc/Infrastructure/RpcSharedStream.cs:105-108.
+   * Matches .NET `RpcSharedStream<T>.OnRun` at
+   * src/ActualLab.Rpc/Infrastructure/RpcSharedStream.cs.
    */
   async writeFrom(source) {
     await this._started.promise;
@@ -1008,11 +1007,7 @@ var RpcStreamSender = class _RpcStreamSender {
     this._iterator = iterator;
     const state = { iteratorDone: false };
     try {
-      if (this.isRealTime) {
-        await this._runRealTime(iterator, state);
-      } else {
-        await this._runNonRealTime(iterator, state);
-      }
+      await this._run(iterator, state);
     } finally {
       if (state.iteratorDone && this._iterator === iterator) {
         this._iterator = null;
@@ -1020,90 +1015,59 @@ var RpcStreamSender = class _RpcStreamSender {
     }
   }
   /**
-   * Non-real-time pump — back-pressure through buffered ACKs.
-   *
-   * Direct port of .NET `OnRunNonRealTime` at
-   * src/ActualLab.Rpc/Infrastructure/RpcSharedStream.cs:110-217.
+   * ACK-driven pump. Non-real-time streams apply normal backpressure at
+   * `bufferSize`; real-time streams may compact the already-buffered unsent
+   * suffix to the latest buffered `canSkipTo` item after the consumer ACKs.
    */
   /* eslint-disable @typescript-eslint/no-unnecessary-condition -- _ended changes across awaits */
-  async _runNonRealTime(iterator, state) {
-    const buffer = new RingBuffer(this.ackAdvance + 1);
+  async _run(iterator, state) {
+    const buffer = new RingBuffer(this.bufferSize + 1);
+    const isRealTime = this.isRealTime;
     let bufferStart = 0;
     let isFullyBuffered = false;
-    while (true) {
-      let ack = this._tryProcessAcks();
-      if (!ack) {
-        await this._waitAckReady();
-        if (this._ended) return;
-        ack = this._tryProcessAcks();
-        if (!ack) {
-          warnLog3?.log("Something is off: couldn't read an acknowledgement");
-          return;
-        }
-      }
-      this._lastAckedIndex = ack.nextIndex;
-      const shift = _clamp(ack.nextIndex - bufferStart, 0, buffer.count);
-      if (shift > 0) {
-        buffer.moveHead(shift);
-        bufferStart += shift;
-      }
-      if (this._nextIndex < bufferStart) {
-        if (!this._ended)
-          this.sendEnd(new Error("Stream position unavailable."));
-        return;
-      }
-      let bufferIndex = this._nextIndex - bufferStart;
-      const maxIndex = ack.nextIndex + this.ackAdvance;
-      while (this._nextIndex < maxIndex) {
-        if (this._ended) return;
-        if (bufferIndex < buffer.count) {
-          const item = buffer.get(bufferIndex++);
-          if (item.kind === "value") {
-            this.sendItem(item.value);
-          } else if (item.kind === "end") {
-            if (!this._ended) this.sendEnd();
-            return;
-          } else {
-            if (!this._ended) this.sendEnd(item.error);
-            return;
-          }
-          continue;
-        }
-        if (isFullyBuffered) break;
-        if (!buffer.hasRemainingCapacity) break;
-        let pulled;
-        try {
-          const r = await iterator.next();
-          if (this._ended) return;
-          if (r.done) {
-            pulled = _endItem;
-            isFullyBuffered = true;
-            state.iteratorDone = true;
-          } else {
-            pulled = { kind: "value", value: r.value };
-          }
-        } catch (e) {
-          state.iteratorDone = true;
+    let whenMovedNext = null;
+    const pending = /* @__PURE__ */ Symbol("pending");
+    const readNext = async () => {
+      const next = whenMovedNext ?? iterator.next();
+      whenMovedNext = null;
+      return await next;
+    };
+    const tryReadReady = async () => {
+      whenMovedNext ??= iterator.next();
+      return await Promise.race([
+        whenMovedNext,
+        Promise.resolve(pending)
+      ]);
+    };
+    const bufferNext = async (onlyIfReady, prefetchNext) => {
+      let r;
+      try {
+        r = onlyIfReady ? await tryReadReady() : await readNext();
+        if (r === pending)
+          return false;
+        whenMovedNext = null;
+        if (this._ended) return false;
+        if (r.done) {
+          buffer.pushTail(_endItem);
           isFullyBuffered = true;
-          pulled = {
-            kind: "error",
-            error: e instanceof Error ? e : new Error(String(e))
-          };
+          state.iteratorDone = true;
+        } else {
+          buffer.pushTail({ kind: "value", value: r.value });
+          if (prefetchNext)
+            whenMovedNext = iterator.next();
         }
-        buffer.pushTail(pulled);
+        return true;
+      } catch (e) {
+        whenMovedNext = null;
+        state.iteratorDone = true;
+        isFullyBuffered = true;
+        buffer.pushTail({
+          kind: "error",
+          error: e instanceof Error ? e : new Error(String(e))
+        });
+        return true;
       }
-    }
-  }
-  /**
-   * Real-time pump — drops stale items to stay close to the source's head.
-   *
-   * Direct port of .NET `OnRunRealTime` at
-   * src/ActualLab.Rpc/Infrastructure/RpcSharedStream.cs:219-420.
-   */
-  async _runRealTime(iterator, state) {
-    const buffer = new RingBuffer(this.ackAdvance + 1);
-    let bufferStart = 0;
-    let isFullyBuffered = false;
+    };
     while (true) {
       let ack = this._tryProcessAcks();
       if (!ack) {
@@ -1116,7 +1080,7 @@ var RpcStreamSender = class _RpcStreamSender {
         }
       }
       this._lastAckedIndex = ack.nextIndex;
-      if (ack.mustReset && !isFullyBuffered) {
+      if (isRealTime && ack.mustReset && !isFullyBuffered) {
         buffer.clear();
         bufferStart = this._nextIndex;
         while (true) {
@@ -1124,7 +1088,7 @@ var RpcStreamSender = class _RpcStreamSender {
           let item;
           let accepted = false;
           try {
-            const r = await iterator.next();
+            const r = await readNext();
             if (this._ended) return;
             if (r.done) {
               item = _endItem;
@@ -1159,11 +1123,22 @@ var RpcStreamSender = class _RpcStreamSender {
         return;
       }
       let bufferIndex = this._nextIndex - bufferStart;
-      const maxIndex = ack.nextIndex + this.ackAdvance;
+      const maxIndex = ack.nextIndex + this.bufferSize;
       while (this._nextIndex < maxIndex) {
         if (this._ended) return;
-        if (this._acks.length > 0) break;
-        if (bufferIndex < buffer.count) {
+        if (isRealTime) {
+          while (buffer.hasRemainingCapacity && !isFullyBuffered && this._acks.length === 0) {
+            if (!await bufferNext(true, true))
+              break;
+          }
+          if (bufferIndex >= buffer.count && !isFullyBuffered && buffer.hasRemainingCapacity && this._acks.length === 0) {
+            await bufferNext(false, true);
+          }
+          if (ack.nextIndex > 0)
+            bufferIndex = _compactBufferedUnsentSuffix(buffer, bufferIndex, this.canSkipTo);
+          if (this._acks.length > 0) break;
+        }
+        while (this._nextIndex < maxIndex && bufferIndex < buffer.count) {
           const item = buffer.get(bufferIndex++);
           if (item.kind === "value") {
             this.sendItem(item.value);
@@ -1174,73 +1149,13 @@ var RpcStreamSender = class _RpcStreamSender {
             if (!this._ended) this.sendEnd(item.error);
             return;
           }
-          continue;
         }
+        if (this._nextIndex >= maxIndex)
+          break;
         if (isFullyBuffered) break;
         if (!buffer.hasRemainingCapacity) break;
-        let pulled;
-        try {
-          const r = await iterator.next();
-          if (this._ended) return;
-          if (r.done) {
-            pulled = _endItem;
-            isFullyBuffered = true;
-            state.iteratorDone = true;
-          } else {
-            pulled = { kind: "value", value: r.value };
-          }
-        } catch (e) {
-          state.iteratorDone = true;
-          isFullyBuffered = true;
-          pulled = {
-            kind: "error",
-            error: e instanceof Error ? e : new Error(String(e))
-          };
-        }
-        buffer.pushTail(pulled);
-      }
-      if (this._nextIndex >= maxIndex && !isFullyBuffered && !this._ended) {
-        let latestValue;
-        let haveLatest = false;
-        let exitReason = "ack";
-        let exitError = null;
-        drain: while (!this._ended) {
-          if (this._acks.length > 0) {
-            exitReason = "ack";
-            break drain;
-          }
-          let r;
-          try {
-            r = await iterator.next();
-          } catch (e) {
-            state.iteratorDone = true;
-            isFullyBuffered = true;
-            exitReason = "error";
-            exitError = e instanceof Error ? e : new Error(String(e));
-            break drain;
-          }
-          if (this._ended) return;
-          if (r.done) {
-            state.iteratorDone = true;
-            isFullyBuffered = true;
-            exitReason = "end";
-            break drain;
-          }
-          if (this.canSkipTo(r.value)) {
-            latestValue = r.value;
-            haveLatest = true;
-          }
-        }
-        if (exitReason === "end" || exitReason === "error") {
-          if (haveLatest && !this._ended) this.sendItem(latestValue);
-          if (!this._ended) this.sendEnd(exitError);
-          return;
-        }
-        if (haveLatest) {
-          const wasFull = buffer.isFull;
-          buffer.pushTailAndMoveHeadIfFull({ kind: "value", value: latestValue });
-          if (wasFull) bufferStart++;
-        }
+        if (!isRealTime)
+          await bufferNext(false, false);
       }
     }
   }
@@ -1307,11 +1222,28 @@ var _endItem = { kind: "end" };
 function _clamp(value, min, max) {
   return value < min ? min : value > max ? max : value;
 }
+function _compactBufferedUnsentSuffix(buffer, firstUnsentIndex, canSkipTo) {
+  let skipToIndex = -1;
+  for (let i = firstUnsentIndex; i < buffer.count; i++) {
+    const item = buffer.get(i);
+    if (item.kind === "value" && canSkipTo(item.value))
+      skipToIndex = i;
+  }
+  if (skipToIndex <= firstUnsentIndex)
+    return firstUnsentIndex;
+  const items = buffer.toArray();
+  buffer.clear();
+  for (let i = 0; i < firstUnsentIndex; i++)
+    buffer.pushTail(items[i]);
+  for (let i = skipToIndex; i < items.length; i++)
+    buffer.pushTail(items[i]);
+  return firstUnsentIndex;
+}
 
 // src/rpc-stream.ts
 var { warnLog: warnLog4 } = getLogs("RpcStream");
 var DEFAULT_ACK_PERIOD2 = 30;
-var DEFAULT_ACK_ADVANCE2 = 61;
+var DEFAULT_BUFFER_SIZE2 = 61;
 function parseStreamRef(value) {
   if (typeof value === "string") {
     const parts = value.split(",");
@@ -1319,12 +1251,12 @@ function parseStreamRef(value) {
     const hostId = parts[0];
     const localId = parseInt(parts[1], 10);
     const ackPeriod = parseInt(parts[2], 10);
-    const ackAdvance = parseInt(parts[3], 10);
-    if (isNaN(localId) || isNaN(ackPeriod) || isNaN(ackAdvance))
+    const bufferSize = parseInt(parts[3], 10);
+    if (isNaN(localId) || isNaN(ackPeriod) || isNaN(bufferSize))
       return null;
     const allowReconnect = parts.length < 5 || parts[4] !== "0";
     const isRealTime = parts.length >= 6 && parts[5] === "1";
-    return { hostId, localId, ackPeriod, ackAdvance, allowReconnect, isRealTime };
+    return { hostId, localId, ackPeriod, bufferSize, allowReconnect, isRealTime };
   }
   if (typeof value === "object" && value !== null) {
     const obj = value;
@@ -1335,10 +1267,10 @@ function parseStreamRef(value) {
     const hostId = String(rawHostId);
     const localId = Number(serializedId[1]);
     const ackPeriod = Number(obj.AckPeriod ?? 256);
-    const ackAdvance = Number(obj.AckAdvance ?? 128);
+    const bufferSize = Number(obj.BufferSize ?? 128);
     const allowReconnect = obj.AllowReconnect !== false;
     const isRealTime = obj.IsRealTime === true;
-    return { hostId, localId, ackPeriod, ackAdvance, allowReconnect, isRealTime };
+    return { hostId, localId, ackPeriod, bufferSize, allowReconnect, isRealTime };
   }
   return null;
 }
@@ -1358,7 +1290,7 @@ var RpcStream = class _RpcStream {
   isRealTime;
   canSkipTo;
   ackPeriod;
-  ackAdvance;
+  bufferSize;
   // Local (origin) mode
   localSource;
   // Remote (target) mode
@@ -1388,7 +1320,7 @@ var RpcStream = class _RpcStream {
       this.isRealTime = options.isRealTime ?? false;
       this.canSkipTo = options.canSkipTo ?? (() => true);
       this.ackPeriod = options.ackPeriod ?? DEFAULT_ACK_PERIOD2;
-      this.ackAdvance = options.ackAdvance ?? DEFAULT_ACK_ADVANCE2;
+      this.bufferSize = options.bufferSize ?? DEFAULT_BUFFER_SIZE2;
     } else {
       const ref = sourceOrRef;
       const peer = optionsOrPeer;
@@ -1399,7 +1331,7 @@ var RpcStream = class _RpcStream {
       this.isRealTime = ref.isRealTime;
       this.canSkipTo = () => true;
       this.ackPeriod = ref.ackPeriod;
-      this.ackAdvance = ref.ackAdvance;
+      this.bufferSize = ref.bufferSize;
     }
   }
   /**
@@ -1417,7 +1349,7 @@ var RpcStream = class _RpcStream {
    * stream reference.
    *
    * For binary peers the ref is a MessagePack-compatible object
-   * (`{ SerializedId, AckPeriod, AckAdvance, AllowReconnect }`);
+   * (`{ SerializedId, AckPeriod, BufferSize, AllowReconnect }`);
    * for text peers it is a comma-separated string.
    *
    * Can only be called once per stream.
@@ -1434,7 +1366,7 @@ var RpcStream = class _RpcStream {
     const sender = new RpcStreamSender(
       peer,
       this.ackPeriod,
-      this.ackAdvance,
+      this.bufferSize,
       this.allowReconnect,
       this.isRealTime,
       this.canSkipTo,
@@ -1447,7 +1379,7 @@ var RpcStream = class _RpcStream {
     this._toRefValue = peer.serializationFormat.isBinary ? {
       SerializedId: [sender.id.hostId, sender.id.localId],
       AckPeriod: sender.ackPeriod,
-      AckAdvance: sender.ackAdvance,
+      BufferSize: sender.bufferSize,
       AllowReconnect: sender.allowReconnect
     } : sender.toRef();
     return this._toRefValue;