@actuallab/rpc 12.5.2 → 13.0.12

package/dist/index.cjs

@@ -33,7 +33,6 @@ __export(index_exports, {
   ARG_DELIMITER: () => ARG_DELIMITER,
   ENVELOPE_DELIMITER: () => ENVELOPE_DELIMITER,
   FRAME_DELIMITER: () => FRAME_DELIMITER,
-  HANDSHAKE_TIMEOUT_MS: () => HANDSHAKE_TIMEOUT_MS,
   IncreasingSeqCompressor: () => IncreasingSeqCompressor,
   RPC_CLOSE_CODE_UNSUPPORTED_FORMAT: () => RPC_CLOSE_CODE_UNSUPPORTED_FORMAT,
   RpcCallStage: () => RpcCallStage,
@@ -46,6 +45,7 @@ __export(index_exports, {
   RpcInboundCall: () => RpcInboundCall,
   RpcInboundCallTracker: () => RpcInboundCallTracker,
   RpcJsonSerializationFormat: () => RpcJsonSerializationFormat,
+  RpcLimits: () => RpcLimits,
   RpcMessageChannelConnection: () => RpcMessageChannelConnection,
   RpcMessagePackCompactSerializationFormat: () => RpcMessagePackCompactSerializationFormat,
   RpcMessagePackSerializationFormat: () => RpcMessagePackSerializationFormat,
@@ -2290,9 +2290,6 @@ function yieldToEventLoop() {
   return new Promise((resolve) => setTimeout(resolve, 0));
 }
 var RPC_CLOSE_CODE_UNSUPPORTED_FORMAT = 4001;
-var HANDSHAKE_TIMEOUT_MS = 1e4;
-var KEEP_ALIVE_PERIOD_MS = 15e3;
-var KEEP_ALIVE_TIMEOUT_MS = 55e3;
 var { debugLog: debugLog2, infoLog, warnLog: warnLog6, errorLog: errorLog2 } = getLogs("RpcPeer");
 var defaultConnectionUrlResolver = (peer) => {
   const formatKey = peer.serializationFormat.key;
@@ -2354,13 +2351,17 @@ 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;
-  /** Outbound keep-alive send period (per-peer override for tests). */
-  keepAlivePeriodMs = KEEP_ALIVE_PERIOD_MS;
-  /** Inbound keep-alive silence tolerance (per-peer override for tests). */
-  keepAliveTimeoutMs = KEEP_ALIVE_TIMEOUT_MS;
+  /** Outbound keep-alive send period. Initialized from `hub.limits` at
+   *  construction; set directly to override on a single peer. */
+  keepAlivePeriodMs;
+  /** Inbound keep-alive silence tolerance. Initialized from `hub.limits`
+   *  at construction; set directly to override on a single peer. */
+  keepAliveTimeoutMs;
   constructor(hub, ref) {
     this.hub = hub;
     this.ref = ref;
+    this.keepAlivePeriodMs = hub.limits.keepAlivePeriodMs;
+    this.keepAliveTimeoutMs = hub.limits.keepAliveTimeoutMs;
   }
   get connection() {
     return this._connection;
@@ -2679,9 +2680,14 @@ var RpcClientPeer = class extends RpcPeer {
    *  `Cookie` headers to the WS upgrade, which the browser `WebSocket`
    *  constructor can't do). Must be set before `start()`. */
   webSocketFactory;
+  /** Max time to wait for the WebSocket to reach OPEN before aborting the
+   *  connection attempt. Initialized from `hub.limits` at construction;
+   *  set directly to override on a single peer. */
+  connectTimeoutMs;
   /** Max time to wait for the server's handshake response before aborting
-   *  the connection attempt. Mirrors .NET's `Hub.Limits.HandshakeTimeout`. */
-  handshakeTimeoutMs = HANDSHAKE_TIMEOUT_MS;
+   *  the connection attempt. Initialized from `hub.limits` at construction;
+   *  set directly to override on a single peer. */
+  handshakeTimeoutMs;
   peerChanged = new import_core7.EventHandlerSet();
   /** Fired when the server rejects the connection due to an unsupported serialization format (close code 4010). */
   unsupportedFormat = new import_core7.EventHandlerSet();
@@ -2712,6 +2718,8 @@ var RpcClientPeer = class extends RpcPeer {
    */
   constructor(hub, url, mustStart = true) {
     super(hub, url);
+    this.connectTimeoutMs = hub.limits.connectTimeoutMs;
+    this.handshakeTimeoutMs = hub.limits.handshakeTimeoutMs;
     this.clientId = guidToBase64Url(this.id);
     const resolver = RpcSerializationFormatResolver.Default;
     this.serializationFormat = resolver.get(parseFormatFromUrl(url) ?? resolver.defaultFormatKey);
@@ -2788,7 +2796,20 @@ var RpcClientPeer = class extends RpcPeer {
           });
           this._pendingHandshake = new import_core7.PromiseSource();
           this.setupConnection(conn);
-          await Promise.race([conn.whenConnected, closedRejection]);
+          const connectTimeoutMs = this.connectTimeoutMs;
+          try {
+            await (0, import_core7.withTimeout)(
+              Promise.race([conn.whenConnected, closedRejection]),
+              connectTimeoutMs,
+              "Connect timeout"
+            );
+          } catch (e) {
+            if (e instanceof import_core7.TimeoutError) {
+              warnLog6?.log(`'${this.ref}': Connect timed out after ${connectTimeoutMs}ms`);
+              conn.close();
+            }
+            throw e;
+          }
           this._setConnectionState(2 /* Handshaking */);
           try {
             this.hub.systemCallSender.handshake(
@@ -2803,29 +2824,20 @@ var RpcClientPeer = class extends RpcPeer {
             throw e;
           }
           const handshakeTimeoutMs = this.handshakeTimeoutMs;
-          let handshakeTimer;
-          const handshakeTimeout = new Promise((_, reject) => {
-            handshakeTimer = setTimeout(() => {
-              reject(new Error("Handshake timeout"));
-            }, handshakeTimeoutMs);
-          });
-          handshakeTimeout.catch(() => {
-          });
           let remoteHandshake;
           try {
-            remoteHandshake = await Promise.race([
-              this._pendingHandshake.promise,
-              closedRejection,
-              handshakeTimeout
-            ]);
+            remoteHandshake = await (0, import_core7.withTimeout)(
+              Promise.race([this._pendingHandshake.promise, closedRejection]),
+              handshakeTimeoutMs,
+              "Handshake timeout"
+            );
           } catch (e) {
-            if (e instanceof Error && e.message === "Handshake timeout") {
+            if (e instanceof import_core7.TimeoutError) {
               warnLog6?.log(`'${this.ref}': Handshake timed out after ${handshakeTimeoutMs}ms`);
               conn.close();
             }
             throw e;
           } finally {
-            if (handshakeTimer !== void 0) clearTimeout(handshakeTimer);
             this._pendingHandshake = void 0;
           }
           this._remoteHandshakeIndex = remoteHandshake.Index ?? 0;
@@ -3057,6 +3069,32 @@ function _toBytes2(value) {
   return null;
 }
 
+// src/rpc-limits.ts
+var RpcLimits = class _RpcLimits {
+  /** Process-wide default. Hubs read from this when they're constructed
+   *  unless caller assigns a custom instance to `hub.limits`. */
+  static Default = new _RpcLimits();
+  /** Max time to wait for the WebSocket to enter the OPEN state. On a
+   *  hung connect (mobile after network change, half-open after sleep)
+   *  the browser can take ~2 min to emit `onerror`/`onclose`; without
+   *  this cap the reconnect loop blocks for that whole window. */
+  connectTimeoutMs = 1e4;
+  /** Max time to wait for the server's handshake response after WS opens. */
+  handshakeTimeoutMs = 1e4;
+  /** Outbound `$sys.KeepAlive` send period. */
+  keepAlivePeriodMs = 1e4;
+  /** Reaper threshold — connection is force-closed (and the reconnect
+   *  loop takes over) if no inbound `$sys.KeepAlive` has been seen for
+   *  this long. Sized to tolerate a complete server stall plus most of
+   *  one keepalive cycle: the worst-case age of `_lastKeepAliveAt` is
+   *  `keepAlivePeriodMs + stall_duration`, so with these defaults the
+   *  tolerated stall is ~15 s. */
+  keepAliveTimeoutMs = 25e3;
+  constructor(overrides) {
+    if (overrides) Object.assign(this, overrides);
+  }
+};
+
 // src/rpc-client-peer-reconnect-delayer.ts
 var import_core8 = require("@actuallab/core");
 var RpcClientPeerReconnectDelayer = class extends import_core8.RetryDelayer {
@@ -3671,6 +3709,13 @@ var RpcHub = class {
   /** Shared reconnect delayer used by every client peer in this hub. Swap in
    *  a custom subclass (e.g. app-level signal-gated) before peers start. */
   reconnectDelayer = new RpcClientPeerReconnectDelayer();
+  /** Connection-lifecycle timing limits. Peers constructed against this hub
+   *  read their initial `*Ms` field values from this instance; later
+   *  mutations affect only peers built afterward (existing peers can be
+   *  retuned by setting their `*Ms` fields directly). Defaults to the
+   *  process-wide {@link RpcLimits.Default} so a single global override
+   *  propagates to every hub that hasn't replaced this. */
+  limits = RpcLimits.Default;
   /** URL used by {@link defaultPeer} to resolve / create the default client
    *  peer. Must be set before the first {@link defaultPeer} access. */
   defaultPeerUrl;
@@ -4119,7 +4164,6 @@ var RpcPeerStateMonitor = class {
   ARG_DELIMITER,
   ENVELOPE_DELIMITER,
   FRAME_DELIMITER,
-  HANDSHAKE_TIMEOUT_MS,
   IncreasingSeqCompressor,
   RPC_CLOSE_CODE_UNSUPPORTED_FORMAT,
   RpcCallStage,
@@ -4132,6 +4176,7 @@ var RpcPeerStateMonitor = class {
   RpcInboundCall,
   RpcInboundCallTracker,
   RpcJsonSerializationFormat,
+  RpcLimits,
   RpcMessageChannelConnection,
   RpcMessagePackCompactSerializationFormat,
   RpcMessagePackSerializationFormat,