@actuallab/rpc 12.3.83 → 12.4.1

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;
@@ -2188,6 +2120,17 @@ var defaultConnectionUrlResolver = (peer) => {
     return peer.ref + sep + `clientId=${peer.clientId}&f=${formatKey}`;
   }
 };
+var sanitizeUrl = (url) => {
+  try {
+    const parsed = new URL(url);
+    if (!parsed.searchParams.has("session"))
+      return url;
+    parsed.searchParams.set("session", "<redacted>");
+    return parsed.toString();
+  } catch {
+    return url.replace(/([?&]session=)[^&]*/i, "$1<redacted>");
+  }
+};
 function parseFormatFromUrl(url) {
   try {
     const f = new URL(url).searchParams.get("f");
@@ -2635,7 +2578,6 @@ var RpcClientPeer = class extends RpcPeer {
   }
   async _runImpl() {
     if (this._disposed) return;
-    const connUrl = this.connectionUrlResolver(this);
     infoLog?.log(`'${this.ref}': Started (Client)`);
     try {
       while (!this._disposed) {
@@ -2656,7 +2598,8 @@ var RpcClientPeer = class extends RpcPeer {
         let lastCloseCode = 0;
         let lastCloseReason = "";
         try {
-          infoLog?.log(`'${this.ref}': Connecting to ${connUrl}`);
+          const connUrl = await this.connectionUrlResolver(this);
+          infoLog?.log(`'${this.ref}': Connecting to ${sanitizeUrl(connUrl)}`);
           const ws = this.webSocketFactory?.(connUrl) ?? new WebSocket(connUrl);
           const conn = new RpcWebSocketConnection(
             ws,