@actuallab/rpc 12.3.29 → 12.3.33

package/dist/index.d.cts

@@ -1,5 +1,9 @@
-import { Encoder, Decoder } from '@msgpack/msgpack';
+import * as _actuallab_core from '@actuallab/core';
 import { EventHandlerSet, PromiseSource, RetryDelayer } from '@actuallab/core';
+import { Encoder, Decoder } from '@msgpack/msgpack';
+
+type RpcLogScope = 'RpcCallTracker' | 'RpcClient' | 'RpcClientPeerReconnectDelayer' | 'RpcConnection' | 'RpcHub' | 'RpcInterceptor' | 'RpcMessageChannelConnection' | 'RpcMethodRegistry' | 'RpcOutboundCall' | 'RpcPeer' | 'RpcPeerStateMonitor' | 'RpcRemoteObjectTracker' | 'RpcSerialization' | 'RpcServiceHost' | 'RpcSharedObjectTracker' | 'RpcSharedStream' | 'RpcStream' | 'RpcStreamSender' | 'RpcSystemCallHandler' | 'RpcSystemCallSender' | 'RpcWebSocketClient';
+declare const getLogs: (scope: RpcLogScope) => _actuallab_core.LogScopeFns;
 
 /** Identifies the type of an RPC call on the wire. */
 declare const enum RpcCallTypeId {
@@ -1182,4 +1186,4 @@ declare function xxh3_64str(input: string, seed?: bigint): bigint;
  */
 declare function computeMethodHash(methodName: string): number;
 
-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, type RpcConnectionUrlResolver, type RpcDeserializedMessage, type RpcDispatchContext, RpcHub, RpcInboundCall, RpcInboundCallTracker, RpcJsonSerializationFormat, type RpcMessage, RpcMessageChannelConnection, RpcMessagePackCompactSerializationFormat, RpcMessagePackSerializationFormat, type RpcMethodDef, type RpcMethodDefInput, RpcMethodRegistry, type RpcObjectId, RpcObjectKind, RpcOutboundCall, RpcOutboundCallTracker, RpcPeer, RpcPeerConnectionKind, 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, 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, type RpcConnectionUrlResolver, type RpcDeserializedMessage, type RpcDispatchContext, RpcHub, RpcInboundCall, RpcInboundCallTracker, RpcJsonSerializationFormat, type RpcLogScope, type RpcMessage, RpcMessageChannelConnection, RpcMessagePackCompactSerializationFormat, RpcMessagePackSerializationFormat, type RpcMethodDef, type RpcMethodDefInput, RpcMethodRegistry, type RpcObjectId, RpcObjectKind, RpcOutboundCall, RpcOutboundCallTracker, RpcPeer, RpcPeerConnectionKind, 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

@@ -1,5 +1,9 @@
-import { Encoder, Decoder } from '@msgpack/msgpack';
+import * as _actuallab_core from '@actuallab/core';
 import { EventHandlerSet, PromiseSource, RetryDelayer } from '@actuallab/core';
+import { Encoder, Decoder } from '@msgpack/msgpack';
+
+type RpcLogScope = 'RpcCallTracker' | 'RpcClient' | 'RpcClientPeerReconnectDelayer' | 'RpcConnection' | 'RpcHub' | 'RpcInterceptor' | 'RpcMessageChannelConnection' | 'RpcMethodRegistry' | 'RpcOutboundCall' | 'RpcPeer' | 'RpcPeerStateMonitor' | 'RpcRemoteObjectTracker' | 'RpcSerialization' | 'RpcServiceHost' | 'RpcSharedObjectTracker' | 'RpcSharedStream' | 'RpcStream' | 'RpcStreamSender' | 'RpcSystemCallHandler' | 'RpcSystemCallSender' | 'RpcWebSocketClient';
+declare const getLogs: (scope: RpcLogScope) => _actuallab_core.LogScopeFns;
 
 /** Identifies the type of an RPC call on the wire. */
 declare const enum RpcCallTypeId {
@@ -1182,4 +1186,4 @@ declare function xxh3_64str(input: string, seed?: bigint): bigint;
  */
 declare function computeMethodHash(methodName: string): number;
 
-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, type RpcConnectionUrlResolver, type RpcDeserializedMessage, type RpcDispatchContext, RpcHub, RpcInboundCall, RpcInboundCallTracker, RpcJsonSerializationFormat, type RpcMessage, RpcMessageChannelConnection, RpcMessagePackCompactSerializationFormat, RpcMessagePackSerializationFormat, type RpcMethodDef, type RpcMethodDefInput, RpcMethodRegistry, type RpcObjectId, RpcObjectKind, RpcOutboundCall, RpcOutboundCallTracker, RpcPeer, RpcPeerConnectionKind, 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, 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, type RpcConnectionUrlResolver, type RpcDeserializedMessage, type RpcDispatchContext, RpcHub, RpcInboundCall, RpcInboundCallTracker, RpcJsonSerializationFormat, type RpcLogScope, type RpcMessage, RpcMessageChannelConnection, RpcMessagePackCompactSerializationFormat, RpcMessagePackSerializationFormat, type RpcMethodDef, type RpcMethodDefInput, RpcMethodRegistry, type RpcObjectId, RpcObjectKind, RpcOutboundCall, RpcOutboundCallTracker, RpcPeer, RpcPeerConnectionKind, 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

@@ -1,3 +1,30 @@
+// src/logging.ts
+import { createLogProvider, LogLevel } from "@actuallab/core";
+var scopeDefaults = {
+  RpcCallTracker: LogLevel.Warn,
+  RpcClient: LogLevel.Warn,
+  RpcClientPeerReconnectDelayer: LogLevel.Warn,
+  RpcConnection: LogLevel.Warn,
+  RpcHub: LogLevel.Warn,
+  RpcInterceptor: LogLevel.Warn,
+  RpcMessageChannelConnection: LogLevel.Warn,
+  RpcMethodRegistry: LogLevel.Warn,
+  RpcOutboundCall: LogLevel.Warn,
+  RpcPeer: LogLevel.Info,
+  RpcPeerStateMonitor: LogLevel.Warn,
+  RpcRemoteObjectTracker: LogLevel.Warn,
+  RpcSerialization: LogLevel.Warn,
+  RpcServiceHost: LogLevel.Warn,
+  RpcSharedObjectTracker: LogLevel.Warn,
+  RpcSharedStream: LogLevel.Warn,
+  RpcStream: LogLevel.Warn,
+  RpcStreamSender: LogLevel.Warn,
+  RpcSystemCallHandler: LogLevel.Warn,
+  RpcSystemCallSender: LogLevel.Warn,
+  RpcWebSocketClient: LogLevel.Warn
+};
+var getLogs = createLogProvider("rpc.", scopeDefaults);
+
 // src/rpc-message.ts
 var RpcCallTypeId = /* @__PURE__ */ ((RpcCallTypeId2) => {
   RpcCallTypeId2[RpcCallTypeId2["Regular"] = 0] = "Regular";
@@ -62,6 +89,7 @@ function patchMsgpackEncoderForMaps() {
 patchMsgpackEncoderForMaps();
 
 // src/rpc-serialization.ts
+var { warnLog } = getLogs("RpcSerialization");
 function serializeMessage(message, args) {
   const envelope = JSON.stringify(message);
   if (args === void 0 || args.length === 0) {
@@ -91,9 +119,7 @@ function deserializeMessage(raw) {
     try {
       return JSON.parse(s);
     } catch {
-      console.warn(
-        `[RpcSerialization] failed to parse arg as JSON: ${s.substring(0, 100)}`
-      );
+      warnLog?.log(`failed to parse arg as JSON: ${s.substring(0, 100)}`);
       return s;
     }
   });
@@ -349,6 +375,7 @@ function splitCompactBinaryFrame(frame, registry, decoder = defaultBinaryDecoder
 // src/rpc-connection.ts
 import { Decoder as Decoder2 } from "@msgpack/msgpack";
 import { PromiseSource, EventHandlerSet } from "@actuallab/core";
+var { warnLog: warnLog2 } = getLogs("RpcConnection");
 var WebSocketState = {
   CONNECTING: 0,
   OPEN: 1,
@@ -410,6 +437,7 @@ var RpcWebSocketConnection = class {
             });
           }
         } catch (e) {
+          warnLog2?.log("Failed to split binary frame:", e);
           this.error.trigger(e);
         }
       } else if (typeof Blob !== "undefined" && ev.data instanceof Blob && this.binaryMode) {
@@ -425,6 +453,7 @@ var RpcWebSocketConnection = class {
               });
             }
           } catch (e) {
+            warnLog2?.log("Failed to split binary blob frame:", e);
             this.error.trigger(e);
           }
         });
@@ -838,6 +867,7 @@ var RpcObjectKind = { Local: 0, Remote: 1 };
 
 // src/rpc-stream-sender.ts
 import { PromiseSource as PromiseSource3, RingBuffer } from "@actuallab/core";
+var { warnLog: warnLog3 } = getLogs("RpcSharedStream");
 var DEFAULT_ACK_PERIOD = 256;
 var DEFAULT_ACK_ADVANCE = 128;
 var RpcStreamSender = class _RpcStreamSender {
@@ -1006,6 +1036,7 @@ var RpcStreamSender = class _RpcStreamSender {
         if (this._ended) return;
         ack = this._tryProcessAcks();
         if (!ack) {
+          warnLog3?.log("Something is off: couldn't read an acknowledgement");
           return;
         }
       }
@@ -1078,7 +1109,10 @@ var RpcStreamSender = class _RpcStreamSender {
         await this._waitAckReady();
         if (this._ended) return;
         ack = this._tryProcessAcks();
-        if (!ack) return;
+        if (!ack) {
+          warnLog3?.log("Something is off: couldn't read an acknowledgement");
+          return;
+        }
       }
       this._lastAckedIndex = ack.nextIndex;
       if (ack.mustReset && !isFullyBuffered) {
@@ -1274,6 +1308,7 @@ function _clamp(value, min, max) {
 }
 
 // src/rpc-stream.ts
+var { warnLog: warnLog4 } = getLogs("RpcStream");
 var DEFAULT_ACK_PERIOD2 = 30;
 var DEFAULT_ACK_ADVANCE2 = 61;
 function parseStreamRef(value) {
@@ -1419,9 +1454,7 @@ var RpcStream = class _RpcStream {
   onItem(index, item) {
     if (this._disposed || this._completed) return;
     if (index > this._nextExpectedIndex) {
-      console.warn(
-        `[RpcStream] item index gap: localId=${this.id.localId}, expected=${this._nextExpectedIndex}, received=${index}`
-      );
+      warnLog4?.log(`item index gap: localId=${this.id.localId}, expected=${this._nextExpectedIndex}, received=${index}`);
       if (!this.allowReconnect) {
         this._completed = true;
         this._completionError = new Error(
@@ -1446,9 +1479,7 @@ var RpcStream = class _RpcStream {
   onBatch(index, items) {
     if (this._disposed || this._completed) return;
     if (index > this._nextExpectedIndex) {
-      console.warn(
-        `[RpcStream] batch index gap: localId=${this.id.localId}, expected=${this._nextExpectedIndex}, received=${index}`
-      );
+      warnLog4?.log(`batch index gap: localId=${this.id.localId}, expected=${this._nextExpectedIndex}, received=${index}`);
       if (!this.allowReconnect) {
         this._completed = true;
         this._completionError = new Error(
@@ -1635,10 +1666,12 @@ function base64Decode(encoded) {
 }
 
 // src/rpc-system-call-handler.ts
+var { debugLog, warnLog: warnLog5 } = getLogs("RpcSystemCallHandler");
 var RpcSystemCallHandler = class {
   handle(message, args, peer) {
     const method = message.Method;
     const relatedId = message.RelatedId ?? 0;
+    debugLog?.log(`'${peer.ref}': handle ${method}#${relatedId}`);
     switch (method) {
       case RpcSystemCalls.ok: {
         const call = peer.outbound.get(relatedId);
@@ -1660,6 +1693,12 @@ var RpcSystemCallHandler = class {
         if (call !== void 0) {
           const errorInfo = args[0];
           const msg = errorInfo?.Message ?? errorInfo?.message ?? "RPC error";
+          const errorType = errorInfo?.TypeRef ?? errorInfo?.typeRef;
+          if (errorType !== null && typeof errorType === "object") {
+            const t = errorType;
+            if (t.TypeName === "RpcRerouteException" || t.typeName === "RpcRerouteException")
+              warnLog5?.log("Got RpcRerouteException from remote peer:", msg);
+          }
           call.result.reject(new Error(msg));
         }
         break;
@@ -1673,25 +1712,20 @@ var RpcSystemCallHandler = class {
       }
       case RpcSystemCalls.item: {
         const stream = peer.remoteObjects.get(relatedId);
-        if (!stream) {
-          console.warn(
-            `[RpcSysHandler] $sys.I: no stream for relatedId=${relatedId}`
-          );
-        } else {
+        if (!stream)
+          debugLog?.log(`$sys.I: no stream for relatedId=${relatedId}`);
+        else
           stream.onItem(
             args[0],
             resolveStreamRefs(args[1], peer)
           );
-        }
         break;
       }
       case RpcSystemCalls.batch: {
         const stream = peer.remoteObjects.get(relatedId);
-        if (!stream) {
-          console.warn(
-            `[RpcSysHandler] $sys.B: no stream for relatedId=${relatedId}`
-          );
-        } else if (Array.isArray(args[1])) {
+        if (!stream)
+          debugLog?.log(`$sys.B: no stream for relatedId=${relatedId}`);
+        else if (Array.isArray(args[1])) {
           const items = args[1];
           for (let i = 0; i < items.length; i++)
             items[i] = resolveStreamRefs(items[i], peer);
@@ -1702,9 +1736,7 @@ var RpcSystemCallHandler = class {
       case RpcSystemCalls.end: {
         const stream = peer.remoteObjects.get(relatedId);
         if (!stream) {
-          console.warn(
-            `[RpcSysHandler] $sys.End: no stream for relatedId=${relatedId}`
-          );
+          debugLog?.log(`$sys.End: no stream for relatedId=${relatedId}`);
         } else {
           const errorInfo = args[1];
           const msg = errorInfo?.Message ?? errorInfo?.message;
@@ -1793,6 +1825,7 @@ function _toBytes(value) {
 }
 
 // src/rpc-system-call-sender.ts
+var { errorLog } = getLogs("RpcSystemCallSender");
 var RpcSystemCallSender = class _RpcSystemCallSender {
   // Reusable envelopes — one per hot-path method.
   _itemEnv = {
@@ -1849,12 +1882,17 @@ var RpcSystemCallSender = class _RpcSystemCallSender {
     ]);
   }
   ok(conn, format, relatedId, result) {
-    this._send(
-      conn,
-      format,
-      { Method: RpcSystemCalls.ok, RelatedId: relatedId },
-      [result]
-    );
+    try {
+      this._send(
+        conn,
+        format,
+        { Method: RpcSystemCalls.ok, RelatedId: relatedId },
+        [result]
+      );
+    } catch (e) {
+      errorLog?.log(`Failed to send Ok response for call #${relatedId}`, e);
+      this.error(conn, format, relatedId, e);
+    }
   }
   error(conn, format, relatedId, error) {
     const message = error instanceof Error ? error.message : String(error);
@@ -2136,6 +2174,7 @@ var RpcSerializationFormatResolver = class _RpcSerializationFormatResolver {
 
 // src/rpc-peer.ts
 var RPC_CLOSE_CODE_UNSUPPORTED_FORMAT = 4001;
+var { debugLog: debugLog2, infoLog, warnLog: warnLog6, errorLog: errorLog2 } = getLogs("RpcPeer");
 var defaultConnectionUrlResolver = (peer) => {
   const sep = peer.ref.includes("?") ? "&" : "?";
   return peer.ref + sep + `clientId=${peer.clientId}&f=${peer.serializationFormat}`;
@@ -2174,9 +2213,14 @@ var RpcPeer = class {
     conn.closed.add((ev) => {
       this._connection = void 0;
       this._stopKeepAlive();
+      if (ev.reason)
+        infoLog?.log(`'${this.ref}': Disconnected: ${ev.reason} (code=${ev.code})`);
+      else
+        infoLog?.log(`'${this.ref}': Disconnected`);
       this.disconnected.trigger(ev);
     });
     void conn.whenConnected.then(() => {
+      infoLog?.log(`'${this.ref}': Connected`);
       this.connected.trigger();
       this._startKeepAlive();
     });
@@ -2251,6 +2295,7 @@ var RpcPeer = class {
     this._sendWireData(wireData);
   }
   close() {
+    infoLog?.log(`'${this.ref}': Stopping`);
     this._stopKeepAlive();
     this.remoteObjects.disconnectAll();
     this.sharedObjects.disconnectAll();
@@ -2264,6 +2309,7 @@ var RpcPeer = class {
     this.outbound.invalidateAll();
     this._connection?.close();
     this._hub.peers.delete(this.ref);
+    infoLog?.log(`'${this.ref}': Stopped`);
   }
   /** Send any messages buffered while disconnected. Call after connection + handshake are ready. */
   _flushPendingSends() {
@@ -2290,15 +2336,21 @@ var RpcPeer = class {
   _handleMessage(received) {
     let message;
     let args;
-    if (received.kind === "binary") {
-      message = received.message;
-      args = received.args;
-    } else {
-      const parsed = deserializeMessage(received.raw);
-      message = parsed.message;
-      args = parsed.args;
+    try {
+      if (received.kind === "binary") {
+        message = received.message;
+        args = received.args;
+      } else {
+        const parsed = deserializeMessage(received.raw);
+        message = parsed.message;
+        args = parsed.args;
+      }
+    } catch (e) {
+      errorLog2?.log(`'${this.ref}': Failed to process inbound message:`, received, e);
+      return;
     }
     const method = message.Method ?? "";
+    debugLog2?.log(`'${this.ref}': <- ${method}#${message.RelatedId ?? 0}`);
     if (method === RpcSystemCalls.handshake) {
       const raw = args[0];
       if (raw !== void 0) {
@@ -2365,6 +2417,7 @@ var RpcPeer = class {
             e
           );
         }
+        debugLog2?.log(`'${this.ref}': Inbound call failed: ${method}#${relatedId}`, e);
       } finally {
         if (!isNoWait) {
           this.inbound.remove(relatedId);
@@ -2453,10 +2506,12 @@ var RpcClientPeer = class extends RpcPeer {
   /** Start the reconnection loop — runs until disposed. */
   async run(wsFactory) {
     const connUrl = this.connectionUrlResolver(this);
+    infoLog?.log(`'${this.ref}': Started (Client)`);
     while (!this._disposed) {
       let lastCloseCode = 0;
       let lastCloseReason = "";
       try {
+        infoLog?.log(`'${this.ref}': Connecting to ${connUrl}`);
         const ws = wsFactory?.(connUrl) ?? new WebSocket(connUrl);
         const conn = new RpcWebSocketConnection(
           ws,
@@ -2480,13 +2535,18 @@ var RpcClientPeer = class extends RpcPeer {
         closedRejection.catch(() => {
         });
         await Promise.race([conn.whenConnected, closedRejection]);
-        this._hub.systemCallSender.handshake(
-          conn,
-          this.format,
-          this.id,
-          this._hub.hubId,
-          ++this._handshakeIndex
-        );
+        try {
+          this._hub.systemCallSender.handshake(
+            conn,
+            this.format,
+            this.id,
+            this._hub.hubId,
+            ++this._handshakeIndex
+          );
+        } catch (e) {
+          warnLog6?.log(`'${this.ref}': Failed to send handshake`, e);
+          throw e;
+        }
         const remoteHandshake = await Promise.race([
           this._pendingHandshake.promise,
           closedRejection
@@ -2499,20 +2559,24 @@ var RpcClientPeer = class extends RpcPeer {
           isPeerChanged = this._lastRemoteHubId !== void 0 && this._lastRemoteHubId !== remoteHubId;
           if (isPeerChanged) {
             this.inbound.clear();
+            infoLog?.log(`'${this.ref}': Peer changed`);
             this.peerChanged.trigger();
           }
           this._lastRemoteHubId = remoteHubId;
         }
+        infoLog?.log(`'${this.ref}': Handshake succeeded, peerChanged=${isPeerChanged}`);
         this._connection = conn;
         this._connectionKind = 2 /* Connected */;
         this._tryIndex = 0;
         await this._reconnect(isPeerChanged);
         await new Promise((r) => conn.closed.add(() => r()));
-      } catch {
+      } catch (e) {
+        debugLog2?.log(`'${this.ref}': run() iteration failed:`, e);
       }
       this._connectionKind = 0 /* Disconnected */;
       if (this._disposed) break;
       if (lastCloseCode === RPC_CLOSE_CODE_UNSUPPORTED_FORMAT) {
+        warnLog6?.log(`'${this.ref}': Unsupported serialization format - shutting down`);
         this.unsupportedFormat.trigger({ reason: lastCloseReason });
         this._disposed = true;
         break;
@@ -2520,6 +2584,7 @@ var RpcClientPeer = class extends RpcPeer {
       this._tryIndex++;
       const delay = this.reconnectDelayer.getDelay(this._tryIndex);
       if (delay.isLimitExceeded) {
+        warnLog6?.log(`'${this.ref}': Reconnect limit exceeded - shutting down`);
         this._disposed = true;
         break;
       }
@@ -2714,6 +2779,7 @@ function _toBytes2(value) {
 }
 
 // src/rpc-service-host.ts
+var { warnLog: warnLog7 } = getLogs("RpcServiceHost");
 var RpcServiceHost = class {
   _methods = /* @__PURE__ */ new Map();
   register(def, impl) {
@@ -2728,8 +2794,10 @@ var RpcServiceHost = class {
   }
   async dispatch(wireMethod, args, context) {
     const entry = this._methods.get(wireMethod);
-    if (entry === void 0)
+    if (entry === void 0) {
+      warnLog7?.log(`Method not found: ${wireMethod}`);
       throw new Error(`Method not found: ${wireMethod}`);
+    }
     if (context !== void 0 && entry.def.callTypeId !== 0) {
       return await entry.fn(...args, context);
     }
@@ -3259,6 +3327,7 @@ function computeMethodHash(methodName) {
 }
 
 // src/rpc-method-registry.ts
+var { warnLog: warnLog8 } = getLogs("RpcMethodRegistry");
 var RpcMethodRegistry = class {
   _nameToHash = /* @__PURE__ */ new Map();
   _hashToName = /* @__PURE__ */ new Map();
@@ -3268,9 +3337,7 @@ var RpcMethodRegistry = class {
     const hash = computeMethodHash(methodName);
     const existing = this._hashToName.get(hash);
     if (existing !== void 0 && existing !== methodName) {
-      console.warn(
-        `[RpcMethodRegistry] hash collision: "${methodName}" and "${existing}" both hash to ${hash}`
-      );
+      warnLog8?.log(`hash collision: "${methodName}" and "${existing}" both hash to ${hash}`);
       return;
     }
     this._nameToHash.set(methodName, hash);
@@ -3303,6 +3370,7 @@ var RpcMethodRegistry = class {
 };
 
 // src/rpc-hub.ts
+var { warnLog: warnLog9 } = getLogs("RpcHub");
 var RpcHub = class {
   hubId;
   peers = /* @__PURE__ */ new Map();
@@ -3328,6 +3396,7 @@ var RpcHub = class {
     if (peer !== void 0) {
       peer.close();
       this.peers.delete(ref);
+      warnLog9?.log(`'${ref}': peer is removed from RpcHub`);
     }
   }
   /** Get or create a peer by ref. Server peers have "server://" prefix, everything else is a client peer. */
@@ -3560,6 +3629,7 @@ function getStateDescription(state, useLastError = false) {
 
 // src/rpc-peer-state-monitor.ts
 import { EventHandlerSet as EventHandlerSet4 } from "@actuallab/core";
+var { infoLog: infoLog2 } = getLogs("RpcPeerStateMonitor");
 var JustConnectedPeriodMs = 1500;
 var JustDisconnectedPeriodMs = 3e3;
 var MinReconnectsInMs = 1e3;
@@ -3621,6 +3691,7 @@ var RpcPeerStateMonitor = class {
     this._scheduleRecompute(
       this._rawConnected ? JustConnectedPeriodMs : JustDisconnectedPeriodMs
     );
+    infoLog2?.log(`'${peer.ref}': monitor started`);
   }
   get state() {
     return this._state;
@@ -3636,6 +3707,7 @@ var RpcPeerStateMonitor = class {
     this.peer.reconnectDelayer.cancelDelaysChanged.remove(
       this._onCancelDelaysChanged
     );
+    infoLog2?.log(`'${this.peer.ref}': monitor stopped`);
   }
   _recompute() {
     if (this._timer !== void 0) {
@@ -3761,6 +3833,7 @@ export {
   deserializeBinaryMessage,
   deserializeCompactBinaryMessage,
   deserializeMessage,
+  getLogs,
   getMethodsMeta,
   getServiceMeta,
   getStateDescription,