@actuallab/rpc 12.4.1 → 12.4.7

package/dist/index.cjs

@@ -1006,6 +1006,23 @@ var RpcStreamSender = class _RpcStreamSender {
   _lastAckedIndex = 0;
   _abortController = new AbortController();
   _iterator = null;
+  // -- Recorder-controller metrics (Step 9.1) --
+  /** Total items skipped via real-time `canSkipTo` compaction. */
+  _skipCount = 0;
+  /** Fires after a $sys.Ack has been processed (post-compaction). The
+   *  recorder's quality controller uses this to bump a "last ACK at"
+   *  watchdog so it can distinguish "stuck" (no ACK > N s) from
+   *  "throttled" (ACKs flowing). */
+  onAckProcessed;
+  get nextIndex() {
+    return this._nextIndex;
+  }
+  get lastAckIndex() {
+    return this._lastAckedIndex;
+  }
+  get skipCount() {
+    return this._skipCount;
+  }
   // -- ACK queue (analog of .NET's Channel<(long, bool)>) --
   _acks = [];
   _whenAckReady = null;
@@ -1240,8 +1257,16 @@ var RpcStreamSender = class _RpcStreamSender {
           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 (ack.nextIndex > 0) {
+            const result = _compactBufferedUnsentSuffix(
+              buffer,
+              bufferIndex,
+              this.canSkipTo
+            );
+            bufferIndex = result.newIndex;
+            if (result.skipped > 0)
+              this._skipCount += result.skipped;
+          }
           if (this._acks.length > 0) break;
         }
         while (this._nextIndex < maxIndex && bufferIndex < buffer.count) {
@@ -1277,6 +1302,10 @@ var RpcStreamSender = class _RpcStreamSender {
         this._nextIndex = a.nextIndex;
       }
     }
+    try {
+      this.onAckProcessed?.();
+    } catch {
+    }
     return last;
   }
   /** Wait for the ACK queue to have at least one entry (or `_ended`). */
@@ -1336,14 +1365,16 @@ function _compactBufferedUnsentSuffix(buffer, firstUnsentIndex, canSkipTo) {
       skipToIndex = i;
   }
   if (skipToIndex <= firstUnsentIndex)
-    return firstUnsentIndex;
+    return { newIndex: firstUnsentIndex, skipped: 0 };
+  const cutFrom = firstUnsentIndex;
+  const cutTo = skipToIndex;
   const items = buffer.toArray();
   buffer.clear();
-  for (let i = 0; i < firstUnsentIndex; i++)
+  for (let i = 0; i < cutFrom; i++)
     buffer.pushTail(items[i]);
-  for (let i = skipToIndex; i < items.length; i++)
+  for (let i = cutTo; i < items.length; i++)
     buffer.pushTail(items[i]);
-  return firstUnsentIndex;
+  return { newIndex: firstUnsentIndex, skipped: skipToIndex - firstUnsentIndex };
 }
 
 // src/rpc-stream.ts
@@ -1449,6 +1480,11 @@ var RpcStream = class _RpcStream {
       throw new Error("toRef() must be called before awaiting whenSent.");
     return this._whenSent;
   }
+  /** Local sender backing this stream after `toRef()` has been called.
+   *  `undefined` for remote streams or before `toRef()`. */
+  get sender() {
+    return this._sender;
+  }
   /**
    * For local streams: bind to a peer, create and register an `RpcStreamSender`,
    * start pumping items from the local source in the background, and return the