@actuallab/rpc 14.3.34 → 14.4.11

package/dist/index.js

@@ -879,7 +879,8 @@ var RpcCallTimeouts = class _RpcCallTimeouts {
   static None = new _RpcCallTimeouts(Infinity, Infinity);
   /** Command default: 1.5 s connect / 10 s run (.NET `RpcCallTimeouts.Default.Command`). */
   static Command = new _RpcCallTimeouts(1500, 1e4);
-  /** Max time a call may wait for the connection before it is sent. */
+  /** Max time a call may wait for a connection - before it is sent, and again for the
+   *  duration of any outage it is still pending through. */
   connectTimeoutMs;
   /** Max time a sent call may stay unanswered before it is failed. */
   runTimeoutMs;
@@ -1078,13 +1079,17 @@ var RpcSystemCallHandler = class {
       case RpcSystemCalls.keepAlive: {
         peer.notifyKeepAliveReceived();
         const keepAliveIds = args[0];
-        if (Array.isArray(keepAliveIds) && keepAliveIds.length > 0 && peer.connection !== void 0) {
+        if (Array.isArray(keepAliveIds) && keepAliveIds.length > 0 && peer.wireConnection !== void 0) {
           const unknownIds = [];
           for (const id of keepAliveIds)
             if (peer.sharedObjects.get(id) === void 0)
               unknownIds.push(id);
           if (unknownIds.length > 0)
-            peer.hub.systemCallSender.disconnect(peer.connection, peer.serializationFormat, unknownIds);
+            peer.hub.systemCallSender.disconnect(
+              peer.wireConnection,
+              peer.serializationFormat,
+              unknownIds
+            );
         }
         break;
       }
@@ -1130,16 +1135,24 @@ var RpcSystemCallHandler = class {
         const sender = peer.sharedObjects.get(relatedId);
         if (sender)
           sender.onAck(args[0], args[1]);
-        else if (peer.connection !== void 0)
-          peer.hub.systemCallSender.disconnect(peer.connection, peer.serializationFormat, [relatedId]);
+        else if (peer.wireConnection !== void 0)
+          peer.hub.systemCallSender.disconnect(
+            peer.wireConnection,
+            peer.serializationFormat,
+            [relatedId]
+          );
         break;
       }
       case RpcSystemCalls.ackEnd: {
         const sender = peer.sharedObjects.get(relatedId);
         if (sender)
           sender.onAckEnd(args[0]);
-        else if (peer.connection !== void 0)
-          peer.hub.systemCallSender.disconnect(peer.connection, peer.serializationFormat, [relatedId]);
+        else if (peer.wireConnection !== void 0)
+          peer.hub.systemCallSender.disconnect(
+            peer.wireConnection,
+            peer.serializationFormat,
+            [relatedId]
+          );
         break;
       }
       case RpcSystemCalls.disconnect: {
@@ -1168,12 +1181,13 @@ var RpcSystemCallHandler = class {
    *                  with the same `RelatedId`.
    */
   _handleReconnect(relatedId, args, peer) {
-    if (peer.connection === void 0) return;
+    const conn = peer.wireConnection;
+    if (conn === void 0) return;
     const handshakeIndex = args[0];
     if (typeof handshakeIndex !== "number" || handshakeIndex !== peer.ownHandshakeIndex) {
       const got = typeof handshakeIndex === "number" ? handshakeIndex : `<${typeof handshakeIndex}>`;
       peer.hub.systemCallSender.error(
-        peer.connection,
+        conn,
         peer.serializationFormat,
         relatedId,
         new Error(
@@ -1184,7 +1198,7 @@ var RpcSystemCallHandler = class {
     }
     if (!peer.tryClaimReconnect()) {
       peer.hub.systemCallSender.error(
-        peer.connection,
+        conn,
         peer.serializationFormat,
         relatedId,
         new Error("TooLateToReconnect: this connection was already reconnected")
@@ -1215,7 +1229,7 @@ var RpcSystemCallHandler = class {
     }
     const responseBytes = IncreasingSeqCompressor.serialize(unknownIds);
     const responseValue = peer.serializationFormat.isBinary ? responseBytes : base64Encode(responseBytes);
-    peer.hub.systemCallSender.ok(peer.connection, peer.serializationFormat, relatedId, responseValue);
+    peer.hub.systemCallSender.ok(conn, peer.serializationFormat, relatedId, responseValue);
   }
 };
 function polymorphicPayloadError(method, got, expected) {
@@ -1398,6 +1412,8 @@ import { PromiseSource as PromiseSource4 } from "@actuallab/core";
 // src/rpc-stream-sender.ts
 import { PromiseSource as PromiseSource3, RingBuffer } from "@actuallab/core";
 var { warnLog: warnLog5 } = getLogs("RpcSharedStream");
+function _ignore() {
+}
 var DEFAULT_ACK_PERIOD = 256;
 var DEFAULT_ACK_ADVANCE = 128;
 var RTT_WINDOW_MS = 2e4;
@@ -1437,7 +1453,11 @@ var RpcStreamSender = class _RpcStreamSender {
   // -- Pump state --
   /** Next stream index that will be sent (matches .NET's `index`). */
   _nextIndex = 0;
-  _ended = false;
+  /** Torn down — `disconnect()` ran. .NET's counterpart is disposal; note it
+   *  does NOT mean "an End was sent", which .NET does not track at all. */
+  _isDisposed = false;
+  /** The pump has returned. .NET's `WhenRunning.IsCompleted`. */
+  _isCompleted = false;
   _started = new PromiseSource3();
   /** Highest `nextIndex` observed in an ACK so far (matches .NET's `lastAckNextIndex` idiom). */
   _lastAckedIndex = 0;
@@ -1544,7 +1564,7 @@ var RpcStreamSender = class _RpcStreamSender {
         this._sendDisconnect();
         return;
       }
-    } else if (this._ended) {
+    } else if (this._isCompleted) {
       this._sendDisconnect();
       return;
     } else if (mustReset && !this.allowReconnect) {
@@ -1565,7 +1585,7 @@ var RpcStreamSender = class _RpcStreamSender {
   // Tells the consumer this shared stream is gone, then disposes it —
   // mirrors RpcSharedStream.SendDisconnect (RpcSharedStream.cs:284-289).
   _sendDisconnect() {
-    const conn = this.peer.connection;
+    const conn = this.peer.wireConnection;
     if (conn)
       this.peer.hub.systemCallSender.disconnect(conn, this.peer.serializationFormat, [this.id.localId]);
     this.disconnect();
@@ -1579,13 +1599,13 @@ var RpcStreamSender = class _RpcStreamSender {
    *
    * Advances `_nextIndex` unconditionally — even if the peer is disconnected
    * the item is considered "sent" from the pump's perspective so the replay
-   * buffer indexing stays consistent. If a connection is absent, the wire
+   * buffer indexing stays consistent. If the peer isn't connected, the wire
    * message is dropped; the item will be resent from the replay buffer
    * after a reconnect (client sends `Ack(N, mustReset=true)`).
    */
   sendItem(item) {
-    if (this._ended) return;
-    const conn = this.peer.connection;
+    if (this._isDisposed) return;
+    const conn = this.peer.wireConnection;
     if (conn) {
       this.peer.hub.systemCallSender.item(
         conn,
@@ -1602,8 +1622,8 @@ var RpcStreamSender = class _RpcStreamSender {
   }
   /** Send a batch of items to the client. See {@link sendItem} for disconnect semantics. */
   sendBatch(items) {
-    if (this._ended || items.length === 0) return;
-    const conn = this.peer.connection;
+    if (this._isDisposed || items.length === 0) return;
+    const conn = this.peer.wireConnection;
     if (conn) {
       this.peer.hub.systemCallSender.batch(
         conn,
@@ -1615,18 +1635,21 @@ var RpcStreamSender = class _RpcStreamSender {
     }
     this._nextIndex += items.length;
   }
-  /** Signal stream completion to the client. */
+  /** Signal stream completion to the client. Re-sendable on purpose: if the
+   *  peer was not connected the frame is dropped, and the End stays in the
+   *  replay buffer for the next reset ack — .NET has no "already ended" latch
+   *  (the End is an ordinary buffer entry, RpcSharedStream.cs:185/239). */
   sendEnd(error) {
-    if (this._ended) return;
-    this._ended = true;
-    const conn = this.peer.connection;
+    if (this._isDisposed) return;
+    const index = this._nextIndex++;
+    const conn = this.peer.wireConnection;
     if (!conn) return;
     const errorInfo = error ? toExceptionInfo(error) : { TypeRef: "", Message: "" };
     this.peer.hub.systemCallSender.end(
       conn,
       this.peer.serializationFormat,
       this.id.localId,
-      this._nextIndex,
+      index,
       errorInfo
     );
   }
@@ -1638,13 +1661,14 @@ var RpcStreamSender = class _RpcStreamSender {
    */
   async writeFrom(source) {
     await this._started;
-    if (this._ended) return;
+    if (this._isDisposed) return;
     const iterator = source[Symbol.asyncIterator]();
     this._iterator = iterator;
     const state = { iteratorDone: false };
     try {
       await this._run(iterator, state);
     } finally {
+      this._isCompleted = true;
       if (state.iteratorDone && this._iterator === iterator) {
         this._iterator = null;
       }
@@ -1657,7 +1681,7 @@ var RpcStreamSender = class _RpcStreamSender {
    * With `bufferSize > ackAdvance` the local ring buffer holds more than the
    * in-flight window — real-time mode uses the extra space to pre-buffer.
    */
-  /* eslint-disable @typescript-eslint/no-unnecessary-condition -- _ended changes across awaits */
+  /* eslint-disable @typescript-eslint/no-unnecessary-condition -- _isDisposed changes across awaits */
   async _run(iterator, state) {
     const buffer = new RingBuffer(this.bufferSize + 1);
     const isRealTime = this.isRealTime;
@@ -1690,7 +1714,7 @@ var RpcStreamSender = class _RpcStreamSender {
         if (r === pending)
           return false;
         whenMovedNext = null;
-        if (this._ended) return false;
+        if (this._isDisposed) return false;
         if (r.done) {
           buffer.pushTail(_endItem);
           isFullyBuffered = true;
@@ -1714,105 +1738,107 @@ var RpcStreamSender = class _RpcStreamSender {
         return true;
       }
     };
-    while (true) {
-      let ack = this._tryProcessAcks();
-      if (!ack) {
-        await this._waitAckReady();
-        if (this._ended) return;
-        ack = this._tryProcessAcks();
+    nextAck:
+      while (true) {
+        let ack = this._tryProcessAcks();
         if (!ack) {
-          warnLog5?.log("Something is off: couldn't read an acknowledgement");
-          return;
+          await this._waitAckReady();
+          if (this._isDisposed) return;
+          ack = this._tryProcessAcks();
+          if (!ack) {
+            warnLog5?.log("Something is off: couldn't read an acknowledgement");
+            return;
+          }
         }
-      }
-      this._lastAckedIndex = ack.nextIndex;
-      if (isRealTime && ack.mustReset && !isFullyBuffered) {
-        buffer.clear();
-        bufferStart = this._nextIndex;
-        while (true) {
-          if (this._ended) return;
-          let item;
-          let accepted = false;
-          try {
-            const r = await readNext();
-            if (this._ended) return;
-            if (r.done) {
-              item = _endItem;
-              isFullyBuffered = true;
+        this._lastAckedIndex = ack.nextIndex;
+        if (isRealTime && ack.mustReset && !isFullyBuffered) {
+          buffer.clear();
+          bufferStart = this._nextIndex;
+          while (true) {
+            if (this._isDisposed) return;
+            let item;
+            let accepted = false;
+            try {
+              const r = await readNext();
+              if (this._isDisposed) return;
+              if (r.done) {
+                item = _endItem;
+                isFullyBuffered = true;
+                state.iteratorDone = true;
+              } else if (this.canSkipTo(r.value)) {
+                item = { kind: "value", value: r.value };
+                accepted = true;
+              } else {
+                continue;
+              }
+            } catch (e) {
               state.iteratorDone = true;
-            } else if (this.canSkipTo(r.value)) {
-              item = { kind: "value", value: r.value };
-              accepted = true;
-            } else {
-              continue;
+              isFullyBuffered = true;
+              item = {
+                kind: "error",
+                error: e instanceof Error ? e : new Error(String(e))
+              };
             }
-          } catch (e) {
-            state.iteratorDone = true;
-            isFullyBuffered = true;
-            item = {
-              kind: "error",
-              error: e instanceof Error ? e : new Error(String(e))
-            };
+            buffer.pushTail(item);
+            fireBuffered();
+            if (accepted || isFullyBuffered) break;
           }
-          buffer.pushTail(item);
-          fireBuffered();
-          if (accepted || isFullyBuffered) break;
         }
-      }
-      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 (isRealTime) {
-          while (buffer.hasRemainingCapacity && !isFullyBuffered && !this._hasPendingAck) {
-            if (!await bufferNext(true, true))
-              break;
-          }
-          if (bufferIndex >= buffer.count && !isFullyBuffered && buffer.hasRemainingCapacity && !this._hasPendingAck) {
-            await bufferNext(false, true);
-          }
-          if (ack.nextIndex > 0) {
-            const result = _compactBufferedUnsentSuffix(
-              buffer,
-              bufferIndex,
-              this.canSkipTo
-            );
-            bufferIndex = result.newIndex;
-            if (result.skipped > 0)
-              this._skipCount += result.skipped;
-          }
-          if (this._hasPendingAck) break;
+        const shift = _clamp(ack.nextIndex - bufferStart, 0, buffer.count);
+        if (shift > 0) {
+          buffer.moveHead(shift);
+          bufferStart += shift;
         }
-        while (this._nextIndex < maxIndex && 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;
+        if (this._nextIndex < bufferStart) {
+          if (!this._isDisposed)
+            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._isDisposed) return;
+          if (isRealTime) {
+            while (buffer.hasRemainingCapacity && !isFullyBuffered && !this._hasPendingAck) {
+              if (!await bufferNext(true, true))
+                break;
+            }
+            if (bufferIndex >= buffer.count && !isFullyBuffered && buffer.hasRemainingCapacity && !this._hasPendingAck) {
+              whenMovedNext ??= iterator.next();
+              const whenAckReady = this._whenAckReady ??= new PromiseSource3();
+              await Promise.race([whenMovedNext.then(_ignore, _ignore), whenAckReady]);
+              if (!this._hasPendingAck)
+                await bufferNext(false, true);
+            }
+            if (ack.nextIndex > 0) {
+              const result = _compactBufferedUnsentSuffix(
+                buffer,
+                bufferIndex,
+                this.canSkipTo
+              );
+              bufferIndex = result.newIndex;
+              if (result.skipped > 0)
+                this._skipCount += result.skipped;
+            }
+            if (this._hasPendingAck) break;
           }
+          while (this._nextIndex < maxIndex && bufferIndex < buffer.count) {
+            const item = buffer.get(bufferIndex++);
+            if (item.kind === "value") {
+              this.sendItem(item.value);
+            } else {
+              this.sendEnd(item.kind === "error" ? item.error : void 0);
+              continue nextAck;
+            }
+          }
+          if (this._nextIndex >= maxIndex)
+            break;
+          if (isFullyBuffered) break;
+          if (!buffer.hasRemainingCapacity) break;
+          if (!isRealTime)
+            await bufferNext(false, false);
         }
-        if (this._nextIndex >= maxIndex)
-          break;
-        if (isFullyBuffered) break;
-        if (!buffer.hasRemainingCapacity) break;
-        if (!isRealTime)
-          await bufferNext(false, false);
       }
-    }
   }
   /* eslint-enable @typescript-eslint/no-unnecessary-condition */
   get _hasPendingAck() {
@@ -1837,13 +1863,14 @@ var RpcStreamSender = class _RpcStreamSender {
     }
     return { nextIndex, mustReset };
   }
-  /** Wait until an ACK is pending (or `_ended`). */
+  /** Wait until an ACK is pending (or the sender is torn down). */
   async _waitAckReady() {
-    if (this._hasPendingAck || this._ended)
+    if (this._hasPendingAck || this._isDisposed)
       return;
-    this._whenAckReady = new PromiseSource3();
-    await this._whenAckReady;
-    this._whenAckReady = null;
+    const whenAckReady = this._whenAckReady ??= new PromiseSource3();
+    await whenAckReady;
+    if (this._whenAckReady === 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).
@@ -1869,8 +1896,8 @@ var RpcStreamSender = class _RpcStreamSender {
   reconnect() {
   }
   disconnect() {
-    if (this._ended) return;
-    this._ended = true;
+    if (this._isDisposed) return;
+    this._isDisposed = true;
     this._abortController.abort();
     if (!this._started.isCompleted) {
       this._started.resolve();
@@ -2029,8 +2056,11 @@ var RpcStream = class _RpcStream {
     }
   }
   /**
-   * For local streams: resolves when the sender finishes pumping (after `toRef()` was called).
-   * Rejects if the source throws. Throws if `toRef()` hasn't been called yet.
+   * For local streams: resolves once the consumer acknowledges the end
+   * ($sys.AckEnd) or the sender is disconnected — NOT when the source drains,
+   * since the sender keeps serving acks after End so a reconnect can replay it.
+   * A source error reaches the consumer as $sys.End(error) instead of rejecting
+   * this. Throws if `toRef()` hasn't been called yet.
    */
   get whenSent() {
     if (!this._whenSent)
@@ -2296,7 +2326,7 @@ var RpcStream = class _RpcStream {
   static _emptyGuid = "00000000-0000-0000-0000-000000000000";
   _sendAck(nextIndex, mustReset) {
     this._ackSentUpTo = nextIndex;
-    const conn = this.peer.isConnected ? this.peer.connection : void 0;
+    const conn = this.peer.wireConnection;
     if (conn) {
       const hostId = mustReset ? this.id.hostId : _RpcStream._emptyGuid;
       this.peer.hub.systemCallSender.ack(
@@ -2309,7 +2339,7 @@ var RpcStream = class _RpcStream {
     }
   }
   _sendAckEnd() {
-    const conn = this.peer.isConnected ? this.peer.connection : void 0;
+    const conn = this.peer.wireConnection;
     if (conn) {
       this.peer.hub.systemCallSender.ackEnd(
         conn,
@@ -2673,6 +2703,8 @@ var RpcPeer = class {
   /** Wall-clock time of the last inbound `$sys.KeepAlive`, or 0 if none yet
    *  for the current connection. Useful for diagnostics. */
   _lastKeepAliveAt = 0;
+  /** When the current outage began; 0 until the peer has been connected at least once. */
+  _disconnectedAt = 0;
   /** Outbound keep-alive send period. Initialized from `hub.limits` at
    *  construction; set directly to override on a single peer. */
   keepAlivePeriodMs;
@@ -2693,9 +2725,10 @@ var RpcPeer = class {
   }
   /** Fail outbound calls whose per-call {@link RpcCallTimeouts} elapsed —
    *  the connect timeout while a call still awaits the wire, the run timeout
-   *  once it has been sent. Mirrors .NET `RpcOutboundCallTracker.Maintain`
-   *  (RpcCallTrackers.cs:108-207). Calls without timeouts (queries) never
-   *  time out here. */
+   *  once it has been sent, and the connect timeout again for any pending call while the
+   *  peer is away. Mirrors .NET `RpcOutboundCallTracker.HandleDisconnect` (ConnectTimeout,
+   *  per outage) plus `Maintain` (RunTimeout, per connection). Calls without timeouts
+   *  (queries) never time out here. */
   _maintainOutboundCalls() {
     const now = Date.now();
     const canRunTimeout = this._isConnected && (this._lastKeepAliveAt === 0 || now - this._lastKeepAliveAt <= this.keepAliveTimeoutMs);
@@ -2704,7 +2737,11 @@ var RpcPeer = class {
       if (timeouts === void 0 || call.result.isCompleted)
         continue;
       let timedOut;
-      if (call.sentAt === 0) {
+      if (!this._isConnected) {
+        const since = Math.max(this._disconnectedAt, call.startedAt);
+        if (now - since >= timeouts.connectTimeoutMs)
+          timedOut = `connect timeout (${timeouts.connectTimeoutMs}ms)`;
+      } else if (call.sentAt === 0) {
         if (now - call.startedAt >= timeouts.connectTimeoutMs)
           timedOut = `connect timeout (${timeouts.connectTimeoutMs}ms)`;
       } else if (canRunTimeout && now - call.sentAt >= timeouts.runTimeoutMs)
@@ -2719,6 +2756,18 @@ var RpcPeer = class {
   get connection() {
     return this._connection;
   }
+  // The connection you may send a non-handshake message on, or `undefined`.
+  // `_connection` is set before the socket even opens and stays set through
+  // the handshake, and `RpcConnection` buffers pre-OPEN sends and flushes them
+  // from `onopen` — so writing through it during Connecting or Handshaking puts
+  // the frame on the wire ahead of $sys.Handshake and corrupts the remote's
+  // handshake. `_isConnected` is the only flag false across both phases.
+  // Port of C#'s `RpcPeer.Transport` (RpcPeer.cs:29-52), which hides the
+  // transport for exactly this reason. $sys.Handshake itself must use
+  // `connection` — it is the frame this gate exists to let through first.
+  get wireConnection() {
+    return this._isConnected ? this._connection : void 0;
+  }
   get connectionState() {
     return this._connectionState;
   }
@@ -2747,10 +2796,13 @@ var RpcPeer = class {
     this._connectionState = value;
     if (value === 3 /* Connected */) {
       this._isConnected = true;
+      this._disconnectedAt = 0;
       this._armKeepAliveWatchdog();
-    } else if (value === 0 /* Disconnected */) {
-      if (previousState === 3 /* Connected */)
+    } else {
+      if (previousState === 3 /* Connected */) {
         this._isConnected = false;
+        this._disconnectedAt = Date.now();
+      }
       this._disarmKeepAliveWatchdog();
     }
     this.connectionStateChanged.trigger(value);
@@ -2775,6 +2827,8 @@ var RpcPeer = class {
     conn.closed.add((ev) => {
       if (this._connection !== conn) return;
       this._connection = void 0;
+      if (this._isConnected)
+        this._disconnectedAt = Date.now();
       this._isConnected = false;
       if (ev.reason)
         infoLog?.log(`'${this.ref}': Disconnected: ${ev.reason} (code=${ev.code})`);
@@ -2834,8 +2888,9 @@ var RpcPeer = class {
         if (this.outboundCalls.remove(callId) !== void 0) {
           outboundCall.result.reject(cancellationError("Call cancelled."));
           outboundCall.onDisconnect();
-          if (this._isConnected && this._connection !== void 0)
-            this.hub.systemCallSender.cancel(this._connection, this.serializationFormat, callId);
+          const conn = this.wireConnection;
+          if (conn !== void 0)
+            this.hub.systemCallSender.cancel(conn, this.serializationFormat, callId);
         }
       };
       signal.addEventListener("abort", onAbort, { once: true });
@@ -2878,9 +2933,11 @@ var RpcPeer = class {
     this._setConnectionState(0 /* Disconnected */);
     infoLog?.log(`'${this.ref}': Stopped`);
   }
-  /** Send pre-serialized wire data through the current connection. */
+  /** Send pre-serialized wire data through the current connection. Callers are
+   *  already gated on `_isConnected`; the check is repeated here so the next one
+   *  cannot reintroduce a pre-handshake write. $sys.Handshake does not use this. */
   _sendWireData(data) {
-    if (this._connection === void 0) return;
+    if (!this._isConnected || this._connection === void 0) return;
     if (typeof data === "string") {
       this._connection.send(data);
     } else {
@@ -2963,9 +3020,10 @@ var RpcPeer = class {
             const ref = stream.toRef(this);
             const send = () => {
               if (call2?.isCancelled === true) return;
-              if (this._connection !== void 0)
+              const conn = this.wireConnection;
+              if (conn !== void 0)
                 this.hub.systemCallSender.ok(
-                  this._connection,
+                  conn,
                   this.serializationFormat,
                   relatedId,
                   ref
@@ -2980,9 +3038,10 @@ var RpcPeer = class {
         } else if (call2 !== void 0) {
           const send = () => {
             if (call2.isCancelled) return;
-            if (this._connection !== void 0)
+            const conn = this.wireConnection;
+            if (conn !== void 0)
               this.hub.systemCallSender.ok(
-                this._connection,
+                conn,
                 this.serializationFormat,
                 relatedId,
                 result
@@ -2996,9 +3055,10 @@ var RpcPeer = class {
         if (call2 !== void 0) {
           const send = () => {
             if (call2.isCancelled) return;
-            if (this._connection !== void 0)
+            const conn = this.wireConnection;
+            if (conn !== void 0)
               this.hub.systemCallSender.error(
-                this._connection,
+                conn,
                 this.serializationFormat,
                 relatedId,
                 e
@@ -3031,8 +3091,9 @@ var RpcPeer = class {
    *  Mirrors .NET `RpcObjectTrackers.Maintain`'s `KeepAliveTimeout` branch. */
   _armKeepAliveWatchdog() {
     this._keepAliveTimer ??= setInterval(() => {
-      if (this._connection !== void 0) {
-        this.hub.systemCallSender.keepAlive(this._connection, this.serializationFormat, [
+      const conn = this.wireConnection;
+      if (conn !== void 0) {
+        this.hub.systemCallSender.keepAlive(conn, this.serializationFormat, [
           ...this.remoteObjects.keys()
         ]);
       }
@@ -3180,9 +3241,26 @@ var RpcClientPeer = class extends RpcPeer {
   connectWith(conn, isPeerChanged = true) {
     const sentCalls = this.outboundCalls.getSentCalls();
     this.setupConnection(conn);
+    const whenHandshake = isPeerChanged ? void 0 : this._pendingHandshake = new PromiseSource5();
+    this.hub.systemCallSender.handshake(
+      conn,
+      this.serializationFormat,
+      this.id,
+      this.hub.hubId,
+      this.nextOwnHandshakeIndex()
+    );
     this._isConnected = true;
     this.connectionStateChanged.trigger(3 /* Connected */);
-    void this._reconnect(sentCalls, isPeerChanged);
+    if (whenHandshake === void 0) {
+      void this._reconnect(sentCalls, true);
+      return;
+    }
+    const whenClosed = new PromiseSource5();
+    conn.closed.add(() => whenClosed.resolve());
+    void Promise.race([whenHandshake, whenClosed]).then(() => {
+      this._pendingHandshake = void 0;
+      return this._reconnect(sentCalls, false);
+    });
   }
   /** Kick off the reconnect loop. Idempotent — subsequent calls are
    *  no-ops; await `peer.whenRunning` if you need the loop's completion
@@ -3500,6 +3578,7 @@ var RpcClientPeer = class extends RpcPeer {
     return 2 /* Changed */;
   }
   _onHandshakeReceived(handshake) {
+    this._remoteHandshakeIndex = handshake.Index ?? 0;
     this._pendingHandshake?.resolve(handshake);
   }
   close() {