@actuallab/rpc 13.0.163 → 14.0.17

package/dist/index.cjs

@@ -1077,6 +1077,7 @@ var import_core5 = require("@actuallab/core");
 var { warnLog: warnLog3 } = getLogs("RpcSharedStream");
 var DEFAULT_ACK_PERIOD = 256;
 var DEFAULT_ACK_ADVANCE = 128;
+var RTT_WINDOW_MS = 2e4;
 var RpcStreamSender = class _RpcStreamSender {
   static _emptyGuid = "00000000-0000-0000-0000-000000000000";
   id;
@@ -1118,6 +1119,9 @@ var RpcStreamSender = class _RpcStreamSender {
   _lastAckedIndex = 0;
   _abortController = new AbortController();
   _iterator = null;
+  // -- RTT sampling (send → matching ack round trips, windowed minimum) --
+  _pendingSendTimes = [];
+  _rttSamples = [];
   // -- Recorder-controller metrics (Step 9.1) --
   /** Total items skipped via real-time `canSkipTo` compaction. */
   _skipCount = 0;
@@ -1142,6 +1146,21 @@ var RpcStreamSender = class _RpcStreamSender {
   get skipCount() {
     return this._skipCount;
   }
+  // Windowed-MIN ack round trip (ms, -1 until sampled): converges on propagation
+  // RTT — unlike a mean/EMA it is not inflated by self-induced queuing.
+  get minRttMs() {
+    const cutoffMs = Date.now() - RTT_WINDOW_MS;
+    while (this._rttSamples.length > 0 && this._rttSamples[0].atMs < cutoffMs)
+      this._rttSamples.shift();
+    if (this._rttSamples.length === 0)
+      return -1;
+    let min = this._rttSamples[0].rttMs;
+    for (const s of this._rttSamples) {
+      if (s.rttMs < min)
+        min = s.rttMs;
+    }
+    return min;
+  }
   // -- ACK queue (analog of .NET's Channel<(long, bool)>) --
   _acks = [];
   _whenAckReady = null;
@@ -1195,6 +1214,7 @@ var RpcStreamSender = class _RpcStreamSender {
       this._sendDisconnect();
       return;
     }
+    this._sampleRtt(nextIndex, mustReset);
     this._acks.push({ nextIndex, mustReset });
     if (this._whenAckReady) {
       this._whenAckReady.resolve();
@@ -1233,6 +1253,7 @@ var RpcStreamSender = class _RpcStreamSender {
         this._nextIndex,
         item
       );
+      this._pendingSendTimes.push({ index: this._nextIndex, sentAtMs: Date.now() });
     }
     this._nextIndex++;
   }
@@ -1451,13 +1472,18 @@ var RpcStreamSender = class _RpcStreamSender {
     }
   }
   /* eslint-enable @typescript-eslint/no-unnecessary-condition */
-  /** Drain all queued ACKs, returning the most recent one (or null if none). */
+  /** Drain all queued ACKs, returning the most recent one (or null if none).
+   *  A reconnect's reset ACK may be drained in one batch with regular
+   *  consumption ACKs the client sends right after it, so `mustReset` is
+   *  OR-ed over the whole batch — the last ACK alone can't represent it. */
   _tryProcessAcks() {
     if (this._acks.length === 0) return null;
-    let last = null;
+    let nextIndex = 0;
+    let mustReset = false;
     while (this._acks.length > 0) {
       const a = this._acks.shift();
-      last = a;
+      nextIndex = a.nextIndex;
+      mustReset ||= a.mustReset;
       if (a.mustReset || this._nextIndex < a.nextIndex) {
         this._nextIndex = a.nextIndex;
       }
@@ -1466,7 +1492,7 @@ var RpcStreamSender = class _RpcStreamSender {
       this.onAckProcessed?.();
     } catch {
     }
-    return last;
+    return { nextIndex, mustReset };
   }
   /** Wait for the ACK queue to have at least one entry (or `_ended`). */
   async _waitAckReady() {
@@ -1475,6 +1501,26 @@ var RpcStreamSender = class _RpcStreamSender {
     await this._whenAckReady;
     this._whenAckReady = null;
   }
+  // One RTT sample per ack: time from sending the newest acked item to the
+  // ack's arrival (a slight upper bound — includes the server's ack cadence).
+  _sampleRtt(ackNextIndex, mustReset) {
+    if (mustReset) {
+      this._pendingSendTimes.length = 0;
+      return;
+    }
+    let sentAtMs = -1;
+    while (this._pendingSendTimes.length > 0 && this._pendingSendTimes[0].index < ackNextIndex) {
+      sentAtMs = this._pendingSendTimes[0].sentAtMs;
+      this._pendingSendTimes.shift();
+    }
+    if (sentAtMs < 0)
+      return;
+    const nowMs = Date.now();
+    const cutoffMs = nowMs - RTT_WINDOW_MS;
+    while (this._rttSamples.length > 0 && this._rttSamples[0].atMs < cutoffMs)
+      this._rttSamples.shift();
+    this._rttSamples.push({ atMs: nowMs, rttMs: nowMs - sentAtMs });
+  }
   // -- IRpcObject --
   reconnect() {
   }