@actuallab/rpc 14.3.34 → 14.4.3

package/dist/index.d.cts

@@ -409,7 +409,8 @@ declare class RpcCallTimeouts {
     static readonly None: RpcCallTimeouts;
     /** Command default: 1.5 s connect / 10 s run (.NET `RpcCallTimeouts.Default.Command`). */
     static readonly Command: RpcCallTimeouts;
-    /** 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. */
     readonly connectTimeoutMs: number;
     /** Max time a sent call may stay unanswered before it is failed. */
     readonly runTimeoutMs: number;
@@ -1003,6 +1004,8 @@ declare abstract class RpcPeer {
     /** Wall-clock time of the last inbound `$sys.KeepAlive`, or 0 if none yet
      *  for the current connection. Useful for diagnostics. */
     private _lastKeepAliveAt;
+    /** When the current outage began; 0 until the peer has been connected at least once. */
+    private _disconnectedAt;
     /** Outbound keep-alive send period. Initialized from `hub.limits` at
      *  construction; set directly to override on a single peer. */
     keepAlivePeriodMs: number;
@@ -1012,9 +1015,10 @@ declare abstract class RpcPeer {
     protected constructor(hub: RpcHub, ref: string);
     /** 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. */
     private _maintainOutboundCalls;
     get connection(): RpcConnection | undefined;
     get connectionState(): RpcConnectionState;

package/dist/index.d.ts

@@ -409,7 +409,8 @@ declare class RpcCallTimeouts {
     static readonly None: RpcCallTimeouts;
     /** Command default: 1.5 s connect / 10 s run (.NET `RpcCallTimeouts.Default.Command`). */
     static readonly Command: RpcCallTimeouts;
-    /** 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. */
     readonly connectTimeoutMs: number;
     /** Max time a sent call may stay unanswered before it is failed. */
     readonly runTimeoutMs: number;
@@ -1003,6 +1004,8 @@ declare abstract class RpcPeer {
     /** Wall-clock time of the last inbound `$sys.KeepAlive`, or 0 if none yet
      *  for the current connection. Useful for diagnostics. */
     private _lastKeepAliveAt;
+    /** When the current outage began; 0 until the peer has been connected at least once. */
+    private _disconnectedAt;
     /** Outbound keep-alive send period. Initialized from `hub.limits` at
      *  construction; set directly to override on a single peer. */
     keepAlivePeriodMs: number;
@@ -1012,9 +1015,10 @@ declare abstract class RpcPeer {
     protected constructor(hub: RpcHub, ref: string);
     /** 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. */
     private _maintainOutboundCalls;
     get connection(): RpcConnection | undefined;
     get connectionState(): RpcConnectionState;

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;
@@ -2673,6 +2674,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 +2696,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 +2708,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)
@@ -2747,10 +2755,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 */)
+      if (previousState === 3 /* Connected */) {
         this._isConnected = false;
+        this._disconnectedAt = Date.now();
+      }
       this._disarmKeepAliveWatchdog();
     }
     this.connectionStateChanged.trigger(value);
@@ -2775,6 +2786,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})`);