@actuallab/rpc 12.5.2 → 13.0.12

package/dist/index.d.cts

@@ -558,6 +558,48 @@ declare const IncreasingSeqCompressor: {
     readonly deserialize: (data: Uint8Array) => number[];
 };
 
+/**
+ * Configurable timing limits for RPC connection lifecycle. Mirrors .NET's
+ * `RpcLimits` (src/ActualLab.Rpc/Configuration/RpcLimits.cs).
+ *
+ * Override paths, from broadest to narrowest:
+ *  - **Process-wide**: mutate fields on {@link RpcLimits.Default} (affects
+ *    every hub that hasn't been given its own instance — hubs default to
+ *    using the shared `Default`, so mutations propagate live), or replace
+ *    `RpcLimits.Default = new RpcLimits({ … })` (affects hubs constructed
+ *    *after* the replacement).
+ *  - **Per-hub**: assign `hub.limits = new RpcLimits({ … })` before peers
+ *    are created from that hub.
+ *  - **Per-peer**: set the matching `*Ms` field on the peer directly
+ *    (e.g. `peer.keepAliveTimeoutMs = 60_000`) before `start()`.
+ *
+ * Peers snapshot the relevant values from `hub.limits` at construction —
+ * later mutations to `hub.limits` don't retroactively affect already-built
+ * peers; that's by design and matches the .NET semantics.
+ */
+declare class RpcLimits {
+    /** Process-wide default. Hubs read from this when they're constructed
+     *  unless caller assigns a custom instance to `hub.limits`. */
+    static Default: 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: number;
+    /** Max time to wait for the server's handshake response after WS opens. */
+    handshakeTimeoutMs: number;
+    /** Outbound `$sys.KeepAlive` send period. */
+    keepAlivePeriodMs: number;
+    /** 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: number;
+    constructor(overrides?: Partial<RpcLimits>);
+}
+
 declare class RpcClientPeerReconnectDelayer extends RetryDelayer {
     constructor();
 }
@@ -663,6 +705,13 @@ declare class RpcHub {
     /** 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: 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;
     /** URL used by {@link defaultPeer} to resolve / create the default client
      *  peer. Must be set before the first {@link defaultPeer} access. */
     defaultPeerUrl: string | undefined;
@@ -746,8 +795,6 @@ declare class RpcSharedObjectTracker {
 
 /** WebSocket close code sent by the server when the client's serialization format is unsupported. */
 declare const RPC_CLOSE_CODE_UNSUPPORTED_FORMAT = 4001;
-/** Maximum time to wait for the server's handshake response after opening the socket. */
-declare const HANDSHAKE_TIMEOUT_MS = 10000;
 /** Builds the WebSocket connection URL for an RpcClientPeer. */
 type RpcConnectionUrlResolver = (peer: RpcClientPeer) => string | Promise<string>;
 /** Default connection URL provider — sets `clientId` and `f` query parameters,
@@ -802,9 +849,11 @@ 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;
-    /** Outbound keep-alive send period (per-peer override for tests). */
+    /** Outbound keep-alive send period. Initialized from `hub.limits` at
+     *  construction; set directly to override on a single peer. */
     keepAlivePeriodMs: number;
-    /** Inbound keep-alive silence tolerance (per-peer override for tests). */
+    /** Inbound keep-alive silence tolerance. Initialized from `hub.limits`
+     *  at construction; set directly to override on a single peer. */
     keepAliveTimeoutMs: number;
     protected constructor(hub: RpcHub, ref: string);
     get connection(): RpcConnection | undefined;
@@ -886,8 +935,13 @@ declare class RpcClientPeer extends RpcPeer {
      *  `Cookie` headers to the WS upgrade, which the browser `WebSocket`
      *  constructor can't do). Must be set before `start()`. */
     webSocketFactory: ((url: string) => WebSocketLike) | undefined;
+    /** 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: number;
     /** Max time to wait for the server's handshake response before aborting
-     *  the connection attempt. Mirrors .NET's `Hub.Limits.HandshakeTimeout`. */
+     *  the connection attempt. Initialized from `hub.limits` at construction;
+     *  set directly to override on a single peer. */
     handshakeTimeoutMs: number;
     readonly peerChanged: EventHandlerSet<void>;
     /** Fired when the server rejects the connection due to an unsupported serialization format (close code 4010). */
@@ -1342,4 +1396,4 @@ declare function xxh3_64str(input: string, seed?: bigint): bigint;
  */
 declare function computeMethodHash(methodName: string): number;
 
-export { ARG_DELIMITER, ENVELOPE_DELIMITER, FRAME_DELIMITER, HANDSHAKE_TIMEOUT_MS, type IRpcObject, IncreasingSeqCompressor, type MethodMeta, RPC_CLOSE_CODE_UNSUPPORTED_FORMAT, type RemoteHandshake, type RpcCallOptions, RpcCallStage, RpcCallTypeId, RpcClientPeer, RpcClientPeerReconnectDelayer, type RpcConnection, RpcConnectionState, type RpcConnectionUrlResolver, type RpcDeserializedMessage, type RpcDispatchContext, RpcError, RpcHub, RpcInboundCall, RpcInboundCallTracker, RpcJsonSerializationFormat, type RpcLogScope, type RpcMessage, RpcMessageChannelConnection, RpcMessagePackCompactSerializationFormat, RpcMessagePackSerializationFormat, type RpcMethodDef, type RpcMethodDefInput, RpcMethodRegistry, type RpcObjectId, RpcObjectKind, RpcOutboundCall, RpcOutboundCallTracker, RpcPeer, type RpcPeerFactory, RpcPeerRefBuilder, type RpcPeerState, RpcPeerStateKind, RpcPeerStateMonitor, type RpcReceivedMessage, RpcRemoteExecutionMode, RpcRemoteObjectTracker, RpcSerializationFormat, RpcSerializationFormatResolver, RpcServerPeer, type RpcServiceDef, RpcServiceHost, type RpcServiceImpl, RpcSharedObjectTracker, RpcStream, type RpcStreamOptions, type RpcStreamRef, RpcStreamSender, type RpcStreamSource, RpcSystemCallHandler, RpcSystemCallSender, RpcSystemCalls, RpcType, RpcWebSocketConnection, type RpcWireData, type ServiceMeta, type WebSocketLike, type WebSocketServer, WebSocketState, computeMethodHash, createBinaryEncoder, createMessageChannelPair, createRpcClient, defaultBinaryDecoder, defaultBinaryEncoder, defaultConnectionUrlResolver, defineRpcService, deserializeBinaryMessage, deserializeCompactBinaryMessage, deserializeMessage, getLogs, getMethodsMeta, getServiceMeta, getStateDescription, isConnected, likelyConnected, parseStreamRef, resolveStreamRefs, rpcMethod, rpcService, serializeBinaryFrame, serializeBinaryMessage, serializeCompactBinaryMessage, serializeFrame, serializeMessage, splitBinaryFrame, splitCompactBinaryFrame, splitFrame, wireMethodName, xxh3_64, xxh3_64str };
+export { ARG_DELIMITER, ENVELOPE_DELIMITER, FRAME_DELIMITER, type IRpcObject, IncreasingSeqCompressor, type MethodMeta, RPC_CLOSE_CODE_UNSUPPORTED_FORMAT, type RemoteHandshake, type RpcCallOptions, RpcCallStage, RpcCallTypeId, RpcClientPeer, RpcClientPeerReconnectDelayer, type RpcConnection, RpcConnectionState, type RpcConnectionUrlResolver, type RpcDeserializedMessage, type RpcDispatchContext, RpcError, RpcHub, RpcInboundCall, RpcInboundCallTracker, RpcJsonSerializationFormat, RpcLimits, type RpcLogScope, type RpcMessage, RpcMessageChannelConnection, RpcMessagePackCompactSerializationFormat, RpcMessagePackSerializationFormat, type RpcMethodDef, type RpcMethodDefInput, RpcMethodRegistry, type RpcObjectId, RpcObjectKind, RpcOutboundCall, RpcOutboundCallTracker, RpcPeer, type RpcPeerFactory, RpcPeerRefBuilder, type RpcPeerState, RpcPeerStateKind, RpcPeerStateMonitor, type RpcReceivedMessage, RpcRemoteExecutionMode, RpcRemoteObjectTracker, RpcSerializationFormat, RpcSerializationFormatResolver, RpcServerPeer, type RpcServiceDef, RpcServiceHost, type RpcServiceImpl, RpcSharedObjectTracker, RpcStream, type RpcStreamOptions, type RpcStreamRef, RpcStreamSender, type RpcStreamSource, RpcSystemCallHandler, RpcSystemCallSender, RpcSystemCalls, RpcType, RpcWebSocketConnection, type RpcWireData, type ServiceMeta, type WebSocketLike, type WebSocketServer, WebSocketState, computeMethodHash, createBinaryEncoder, createMessageChannelPair, createRpcClient, defaultBinaryDecoder, defaultBinaryEncoder, defaultConnectionUrlResolver, defineRpcService, deserializeBinaryMessage, deserializeCompactBinaryMessage, deserializeMessage, getLogs, getMethodsMeta, getServiceMeta, getStateDescription, isConnected, likelyConnected, parseStreamRef, resolveStreamRefs, rpcMethod, rpcService, serializeBinaryFrame, serializeBinaryMessage, serializeCompactBinaryMessage, serializeFrame, serializeMessage, splitBinaryFrame, splitCompactBinaryFrame, splitFrame, wireMethodName, xxh3_64, xxh3_64str };

package/dist/index.d.ts

@@ -558,6 +558,48 @@ declare const IncreasingSeqCompressor: {
     readonly deserialize: (data: Uint8Array) => number[];
 };
 
+/**
+ * Configurable timing limits for RPC connection lifecycle. Mirrors .NET's
+ * `RpcLimits` (src/ActualLab.Rpc/Configuration/RpcLimits.cs).
+ *
+ * Override paths, from broadest to narrowest:
+ *  - **Process-wide**: mutate fields on {@link RpcLimits.Default} (affects
+ *    every hub that hasn't been given its own instance — hubs default to
+ *    using the shared `Default`, so mutations propagate live), or replace
+ *    `RpcLimits.Default = new RpcLimits({ … })` (affects hubs constructed
+ *    *after* the replacement).
+ *  - **Per-hub**: assign `hub.limits = new RpcLimits({ … })` before peers
+ *    are created from that hub.
+ *  - **Per-peer**: set the matching `*Ms` field on the peer directly
+ *    (e.g. `peer.keepAliveTimeoutMs = 60_000`) before `start()`.
+ *
+ * Peers snapshot the relevant values from `hub.limits` at construction —
+ * later mutations to `hub.limits` don't retroactively affect already-built
+ * peers; that's by design and matches the .NET semantics.
+ */
+declare class RpcLimits {
+    /** Process-wide default. Hubs read from this when they're constructed
+     *  unless caller assigns a custom instance to `hub.limits`. */
+    static Default: 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: number;
+    /** Max time to wait for the server's handshake response after WS opens. */
+    handshakeTimeoutMs: number;
+    /** Outbound `$sys.KeepAlive` send period. */
+    keepAlivePeriodMs: number;
+    /** 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: number;
+    constructor(overrides?: Partial<RpcLimits>);
+}
+
 declare class RpcClientPeerReconnectDelayer extends RetryDelayer {
     constructor();
 }
@@ -663,6 +705,13 @@ declare class RpcHub {
     /** 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: 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;
     /** URL used by {@link defaultPeer} to resolve / create the default client
      *  peer. Must be set before the first {@link defaultPeer} access. */
     defaultPeerUrl: string | undefined;
@@ -746,8 +795,6 @@ declare class RpcSharedObjectTracker {
 
 /** WebSocket close code sent by the server when the client's serialization format is unsupported. */
 declare const RPC_CLOSE_CODE_UNSUPPORTED_FORMAT = 4001;
-/** Maximum time to wait for the server's handshake response after opening the socket. */
-declare const HANDSHAKE_TIMEOUT_MS = 10000;
 /** Builds the WebSocket connection URL for an RpcClientPeer. */
 type RpcConnectionUrlResolver = (peer: RpcClientPeer) => string | Promise<string>;
 /** Default connection URL provider — sets `clientId` and `f` query parameters,
@@ -802,9 +849,11 @@ 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;
-    /** Outbound keep-alive send period (per-peer override for tests). */
+    /** Outbound keep-alive send period. Initialized from `hub.limits` at
+     *  construction; set directly to override on a single peer. */
     keepAlivePeriodMs: number;
-    /** Inbound keep-alive silence tolerance (per-peer override for tests). */
+    /** Inbound keep-alive silence tolerance. Initialized from `hub.limits`
+     *  at construction; set directly to override on a single peer. */
     keepAliveTimeoutMs: number;
     protected constructor(hub: RpcHub, ref: string);
     get connection(): RpcConnection | undefined;
@@ -886,8 +935,13 @@ declare class RpcClientPeer extends RpcPeer {
      *  `Cookie` headers to the WS upgrade, which the browser `WebSocket`
      *  constructor can't do). Must be set before `start()`. */
     webSocketFactory: ((url: string) => WebSocketLike) | undefined;
+    /** 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: number;
     /** Max time to wait for the server's handshake response before aborting
-     *  the connection attempt. Mirrors .NET's `Hub.Limits.HandshakeTimeout`. */
+     *  the connection attempt. Initialized from `hub.limits` at construction;
+     *  set directly to override on a single peer. */
     handshakeTimeoutMs: number;
     readonly peerChanged: EventHandlerSet<void>;
     /** Fired when the server rejects the connection due to an unsupported serialization format (close code 4010). */
@@ -1342,4 +1396,4 @@ declare function xxh3_64str(input: string, seed?: bigint): bigint;
  */
 declare function computeMethodHash(methodName: string): number;
 
-export { ARG_DELIMITER, ENVELOPE_DELIMITER, FRAME_DELIMITER, HANDSHAKE_TIMEOUT_MS, type IRpcObject, IncreasingSeqCompressor, type MethodMeta, RPC_CLOSE_CODE_UNSUPPORTED_FORMAT, type RemoteHandshake, type RpcCallOptions, RpcCallStage, RpcCallTypeId, RpcClientPeer, RpcClientPeerReconnectDelayer, type RpcConnection, RpcConnectionState, type RpcConnectionUrlResolver, type RpcDeserializedMessage, type RpcDispatchContext, RpcError, RpcHub, RpcInboundCall, RpcInboundCallTracker, RpcJsonSerializationFormat, type RpcLogScope, type RpcMessage, RpcMessageChannelConnection, RpcMessagePackCompactSerializationFormat, RpcMessagePackSerializationFormat, type RpcMethodDef, type RpcMethodDefInput, RpcMethodRegistry, type RpcObjectId, RpcObjectKind, RpcOutboundCall, RpcOutboundCallTracker, RpcPeer, type RpcPeerFactory, RpcPeerRefBuilder, type RpcPeerState, RpcPeerStateKind, RpcPeerStateMonitor, type RpcReceivedMessage, RpcRemoteExecutionMode, RpcRemoteObjectTracker, RpcSerializationFormat, RpcSerializationFormatResolver, RpcServerPeer, type RpcServiceDef, RpcServiceHost, type RpcServiceImpl, RpcSharedObjectTracker, RpcStream, type RpcStreamOptions, type RpcStreamRef, RpcStreamSender, type RpcStreamSource, RpcSystemCallHandler, RpcSystemCallSender, RpcSystemCalls, RpcType, RpcWebSocketConnection, type RpcWireData, type ServiceMeta, type WebSocketLike, type WebSocketServer, WebSocketState, computeMethodHash, createBinaryEncoder, createMessageChannelPair, createRpcClient, defaultBinaryDecoder, defaultBinaryEncoder, defaultConnectionUrlResolver, defineRpcService, deserializeBinaryMessage, deserializeCompactBinaryMessage, deserializeMessage, getLogs, getMethodsMeta, getServiceMeta, getStateDescription, isConnected, likelyConnected, parseStreamRef, resolveStreamRefs, rpcMethod, rpcService, serializeBinaryFrame, serializeBinaryMessage, serializeCompactBinaryMessage, serializeFrame, serializeMessage, splitBinaryFrame, splitCompactBinaryFrame, splitFrame, wireMethodName, xxh3_64, xxh3_64str };
+export { ARG_DELIMITER, ENVELOPE_DELIMITER, FRAME_DELIMITER, type IRpcObject, IncreasingSeqCompressor, type MethodMeta, RPC_CLOSE_CODE_UNSUPPORTED_FORMAT, type RemoteHandshake, type RpcCallOptions, RpcCallStage, RpcCallTypeId, RpcClientPeer, RpcClientPeerReconnectDelayer, type RpcConnection, RpcConnectionState, type RpcConnectionUrlResolver, type RpcDeserializedMessage, type RpcDispatchContext, RpcError, RpcHub, RpcInboundCall, RpcInboundCallTracker, RpcJsonSerializationFormat, RpcLimits, type RpcLogScope, type RpcMessage, RpcMessageChannelConnection, RpcMessagePackCompactSerializationFormat, RpcMessagePackSerializationFormat, type RpcMethodDef, type RpcMethodDefInput, RpcMethodRegistry, type RpcObjectId, RpcObjectKind, RpcOutboundCall, RpcOutboundCallTracker, RpcPeer, type RpcPeerFactory, RpcPeerRefBuilder, type RpcPeerState, RpcPeerStateKind, RpcPeerStateMonitor, type RpcReceivedMessage, RpcRemoteExecutionMode, RpcRemoteObjectTracker, RpcSerializationFormat, RpcSerializationFormatResolver, RpcServerPeer, type RpcServiceDef, RpcServiceHost, type RpcServiceImpl, RpcSharedObjectTracker, RpcStream, type RpcStreamOptions, type RpcStreamRef, RpcStreamSender, type RpcStreamSource, RpcSystemCallHandler, RpcSystemCallSender, RpcSystemCalls, RpcType, RpcWebSocketConnection, type RpcWireData, type ServiceMeta, type WebSocketLike, type WebSocketServer, WebSocketState, computeMethodHash, createBinaryEncoder, createMessageChannelPair, createRpcClient, defaultBinaryDecoder, defaultBinaryEncoder, defaultConnectionUrlResolver, defineRpcService, deserializeBinaryMessage, deserializeCompactBinaryMessage, deserializeMessage, getLogs, getMethodsMeta, getServiceMeta, getStateDescription, isConnected, likelyConnected, parseStreamRef, resolveStreamRefs, rpcMethod, rpcService, serializeBinaryFrame, serializeBinaryMessage, serializeCompactBinaryMessage, serializeFrame, serializeMessage, splitBinaryFrame, splitCompactBinaryFrame, splitFrame, wireMethodName, xxh3_64, xxh3_64str };

package/dist/index.js

@@ -2020,7 +2020,7 @@ var RpcSharedObjectTracker = class {
 };
 
 // src/rpc-peer.ts
-import { EventHandlerSet as EventHandlerSet3, PromiseSource as PromiseSource5 } from "@actuallab/core";
+import { EventHandlerSet as EventHandlerSet3, PromiseSource as PromiseSource5, TimeoutError, withTimeout } from "@actuallab/core";
 
 // src/rpc-serialization-format.ts
 import { Decoder as Decoder3 } from "@msgpack/msgpack";
@@ -2184,9 +2184,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;
@@ -2248,13 +2245,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;
@@ -2573,9 +2574,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 EventHandlerSet3();
   /** Fired when the server rejects the connection due to an unsupported serialization format (close code 4010). */
   unsupportedFormat = new EventHandlerSet3();
@@ -2606,6 +2612,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);
@@ -2682,7 +2690,20 @@ var RpcClientPeer = class extends RpcPeer {
           });
           this._pendingHandshake = new PromiseSource5();
           this.setupConnection(conn);
-          await Promise.race([conn.whenConnected, closedRejection]);
+          const connectTimeoutMs = this.connectTimeoutMs;
+          try {
+            await withTimeout(
+              Promise.race([conn.whenConnected, closedRejection]),
+              connectTimeoutMs,
+              "Connect timeout"
+            );
+          } catch (e) {
+            if (e instanceof TimeoutError) {
+              warnLog6?.log(`'${this.ref}': Connect timed out after ${connectTimeoutMs}ms`);
+              conn.close();
+            }
+            throw e;
+          }
           this._setConnectionState(2 /* Handshaking */);
           try {
             this.hub.systemCallSender.handshake(
@@ -2697,29 +2718,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 withTimeout(
+              Promise.race([this._pendingHandshake.promise, closedRejection]),
+              handshakeTimeoutMs,
+              "Handshake timeout"
+            );
           } catch (e) {
-            if (e instanceof Error && e.message === "Handshake timeout") {
+            if (e instanceof 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;
@@ -2951,6 +2963,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
 import { RetryDelaySeq, RetryDelayer } from "@actuallab/core";
 var RpcClientPeerReconnectDelayer = class extends RetryDelayer {
@@ -3565,6 +3603,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;
@@ -4012,7 +4057,6 @@ export {
   ARG_DELIMITER,
   ENVELOPE_DELIMITER,
   FRAME_DELIMITER,
-  HANDSHAKE_TIMEOUT_MS,
   IncreasingSeqCompressor,
   RPC_CLOSE_CODE_UNSUPPORTED_FORMAT,
   RpcCallStage,
@@ -4025,6 +4069,7 @@ export {
   RpcInboundCall,
   RpcInboundCallTracker,
   RpcJsonSerializationFormat,
+  RpcLimits,
   RpcMessageChannelConnection,
   RpcMessagePackCompactSerializationFormat,
   RpcMessagePackSerializationFormat,