@actuallab/rpc 13.0.163 → 14.0.17

package/dist/index.d.cts

@@ -1266,6 +1266,8 @@ declare class RpcStreamSender<T> implements IRpcObject {
     private _lastAckedIndex;
     private _abortController;
     private _iterator;
+    private _pendingSendTimes;
+    private _rttSamples;
     /** Total items skipped via real-time `canSkipTo` compaction. */
     private _skipCount;
     /** Fires after a $sys.Ack has been processed (post-compaction). The
@@ -1283,6 +1285,7 @@ declare class RpcStreamSender<T> implements IRpcObject {
     get nextIndex(): number;
     get lastAckIndex(): number;
     get skipCount(): number;
+    get minRttMs(): number;
     private _acks;
     private _whenAckReady;
     constructor(peer: RpcPeer, ackPeriod?: number, ackAdvance?: number, allowReconnect?: boolean, isRealTime?: boolean, canSkipTo?: (item: T) => boolean, sourceUsesAbortSignal?: boolean, bufferSize?: number);
@@ -1329,10 +1332,14 @@ declare class RpcStreamSender<T> implements IRpcObject {
      * in-flight window — real-time mode uses the extra space to pre-buffer.
      */
     private _run;
-    /** 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. */
     private _tryProcessAcks;
     /** Wait for the ACK queue to have at least one entry (or `_ended`). */
     private _waitAckReady;
+    private _sampleRtt;
     reconnect(): void;
     disconnect(): void;
     private _forceCloseIterator;

package/dist/index.d.ts

@@ -1266,6 +1266,8 @@ declare class RpcStreamSender<T> implements IRpcObject {
     private _lastAckedIndex;
     private _abortController;
     private _iterator;
+    private _pendingSendTimes;
+    private _rttSamples;
     /** Total items skipped via real-time `canSkipTo` compaction. */
     private _skipCount;
     /** Fires after a $sys.Ack has been processed (post-compaction). The
@@ -1283,6 +1285,7 @@ declare class RpcStreamSender<T> implements IRpcObject {
     get nextIndex(): number;
     get lastAckIndex(): number;
     get skipCount(): number;
+    get minRttMs(): number;
     private _acks;
     private _whenAckReady;
     constructor(peer: RpcPeer, ackPeriod?: number, ackAdvance?: number, allowReconnect?: boolean, isRealTime?: boolean, canSkipTo?: (item: T) => boolean, sourceUsesAbortSignal?: boolean, bufferSize?: number);
@@ -1329,10 +1332,14 @@ declare class RpcStreamSender<T> implements IRpcObject {
      * in-flight window — real-time mode uses the extra space to pre-buffer.
      */
     private _run;
-    /** 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. */
     private _tryProcessAcks;
     /** Wait for the ACK queue to have at least one entry (or `_ended`). */
     private _waitAckReady;
+    private _sampleRtt;
     reconnect(): void;
     disconnect(): void;
     private _forceCloseIterator;

package/dist/index.js

@@ -967,6 +967,7 @@ import { PromiseSource as PromiseSource3, RingBuffer } from "@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;
@@ -1008,6 +1009,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;
@@ -1032,6 +1036,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;
@@ -1085,6 +1104,7 @@ var RpcStreamSender = class _RpcStreamSender {
       this._sendDisconnect();
       return;
     }
+    this._sampleRtt(nextIndex, mustReset);
     this._acks.push({ nextIndex, mustReset });
     if (this._whenAckReady) {
       this._whenAckReady.resolve();
@@ -1123,6 +1143,7 @@ var RpcStreamSender = class _RpcStreamSender {
         this._nextIndex,
         item
       );
+      this._pendingSendTimes.push({ index: this._nextIndex, sentAtMs: Date.now() });
     }
     this._nextIndex++;
   }
@@ -1341,13 +1362,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;
       }
@@ -1356,7 +1382,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() {
@@ -1365,6 +1391,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() {
   }