@actuallab/rpc 12.3.29 → 12.3.33

package/dist/index.cjs

@@ -80,6 +80,7 @@ __export(index_exports, {
   deserializeBinaryMessage: () => deserializeBinaryMessage,
   deserializeCompactBinaryMessage: () => deserializeCompactBinaryMessage,
   deserializeMessage: () => deserializeMessage,
+  getLogs: () => getLogs,
   getMethodsMeta: () => getMethodsMeta,
   getServiceMeta: () => getServiceMeta,
   getStateDescription: () => getStateDescription,
@@ -103,6 +104,33 @@ __export(index_exports, {
 });
 module.exports = __toCommonJS(index_exports);
 
+// src/logging.ts
+var import_core = require("@actuallab/core");
+var scopeDefaults = {
+  RpcCallTracker: import_core.LogLevel.Warn,
+  RpcClient: import_core.LogLevel.Warn,
+  RpcClientPeerReconnectDelayer: import_core.LogLevel.Warn,
+  RpcConnection: import_core.LogLevel.Warn,
+  RpcHub: import_core.LogLevel.Warn,
+  RpcInterceptor: import_core.LogLevel.Warn,
+  RpcMessageChannelConnection: import_core.LogLevel.Warn,
+  RpcMethodRegistry: import_core.LogLevel.Warn,
+  RpcOutboundCall: import_core.LogLevel.Warn,
+  RpcPeer: import_core.LogLevel.Info,
+  RpcPeerStateMonitor: import_core.LogLevel.Warn,
+  RpcRemoteObjectTracker: import_core.LogLevel.Warn,
+  RpcSerialization: import_core.LogLevel.Warn,
+  RpcServiceHost: import_core.LogLevel.Warn,
+  RpcSharedObjectTracker: import_core.LogLevel.Warn,
+  RpcSharedStream: import_core.LogLevel.Warn,
+  RpcStream: import_core.LogLevel.Warn,
+  RpcStreamSender: import_core.LogLevel.Warn,
+  RpcSystemCallHandler: import_core.LogLevel.Warn,
+  RpcSystemCallSender: import_core.LogLevel.Warn,
+  RpcWebSocketClient: import_core.LogLevel.Warn
+};
+var getLogs = (0, import_core.createLogProvider)("rpc.", scopeDefaults);
+
 // src/rpc-message.ts
 var RpcCallTypeId = /* @__PURE__ */ ((RpcCallTypeId2) => {
   RpcCallTypeId2[RpcCallTypeId2["Regular"] = 0] = "Regular";
@@ -164,6 +192,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) {
@@ -193,9 +222,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;
     }
   });
@@ -450,7 +477,8 @@ function splitCompactBinaryFrame(frame, registry, decoder = defaultBinaryDecoder
 
 // src/rpc-connection.ts
 var import_msgpack3 = require("@msgpack/msgpack");
-var import_core = require("@actuallab/core");
+var import_core2 = require("@actuallab/core");
+var { warnLog: warnLog2 } = getLogs("RpcConnection");
 var WebSocketState = {
   CONNECTING: 0,
   OPEN: 1,
@@ -460,7 +488,7 @@ var WebSocketState = {
 var RpcWebSocketConnection = class {
   _ws;
   _sendBuffer = [];
-  _connected = new import_core.PromiseSource();
+  _connected = new import_core2.PromiseSource();
   /** Per-connection msgpack encoder — reused across outbound messages to
    *  amortise construction cost and to keep the internal write buffer at
    *  its largest observed size (avoids repeated `resizeBuffer` growth on
@@ -481,9 +509,9 @@ var RpcWebSocketConnection = class {
   _format;
   _methodRegistry;
   binaryMode;
-  messageReceived = new import_core.EventHandlerSet();
-  closed = new import_core.EventHandlerSet();
-  error = new import_core.EventHandlerSet();
+  messageReceived = new import_core2.EventHandlerSet();
+  closed = new import_core2.EventHandlerSet();
+  error = new import_core2.EventHandlerSet();
   constructor(ws, binaryMode = false, format, methodRegistry) {
     this._ws = ws;
     this.binaryMode = binaryMode;
@@ -512,6 +540,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) {
@@ -527,6 +556,7 @@ var RpcWebSocketConnection = class {
               });
             }
           } catch (e) {
+            warnLog2?.log("Failed to split binary blob frame:", e);
             this.error.trigger(e);
           }
         });
@@ -602,13 +632,13 @@ var RpcWebSocketConnection = class {
 };
 
 // src/rpc-message-channel-connection.ts
-var import_core2 = require("@actuallab/core");
+var import_core3 = require("@actuallab/core");
 var RpcMessageChannelConnection = class {
   _port;
   _open = true;
   binaryMode = false;
-  messageReceived = new import_core2.EventHandlerSet();
-  closed = new import_core2.EventHandlerSet();
+  messageReceived = new import_core3.EventHandlerSet();
+  closed = new import_core3.EventHandlerSet();
   whenConnected = Promise.resolve();
   // immediately connected
   constructor(port) {
@@ -697,7 +727,7 @@ function defineRpcService(name, methods) {
 }
 
 // src/rpc-call-tracker.ts
-var import_core3 = require("@actuallab/core");
+var import_core4 = require("@actuallab/core");
 
 // src/rpc-call-stage.ts
 var RpcCallStage = {
@@ -716,7 +746,7 @@ var RpcCallStage = {
 var RpcOutboundCall = class {
   callId;
   method;
-  result = new import_core3.PromiseSource();
+  result = new import_core4.PromiseSource();
   /** Bitfield of RpcRemoteExecutionMode flags controlling reconnect/resend behavior. */
   remoteExecutionMode;
   /** Whether to remove this call from the tracker on $sys.Ok. Default: true.
@@ -933,13 +963,14 @@ function _readVarUint(data, offset) {
 
 // src/rpc-stream.ts
 var import_denque = __toESM(require("denque"), 1);
-var import_core5 = require("@actuallab/core");
+var import_core6 = require("@actuallab/core");
 
 // src/rpc-object.ts
 var RpcObjectKind = { Local: 0, Remote: 1 };
 
 // src/rpc-stream-sender.ts
-var import_core4 = require("@actuallab/core");
+var import_core5 = require("@actuallab/core");
+var { warnLog: warnLog3 } = getLogs("RpcSharedStream");
 var DEFAULT_ACK_PERIOD = 256;
 var DEFAULT_ACK_ADVANCE = 128;
 var RpcStreamSender = class _RpcStreamSender {
@@ -966,7 +997,7 @@ var RpcStreamSender = class _RpcStreamSender {
   /** Next stream index that will be sent (matches .NET's `index`). */
   _nextIndex = 0;
   _ended = false;
-  _started = new import_core4.PromiseSource();
+  _started = new import_core5.PromiseSource();
   /** Highest `nextIndex` observed in an ACK so far (matches .NET's `lastAckNextIndex` idiom). */
   _lastAckedIndex = 0;
   _abortController = new AbortController();
@@ -1098,7 +1129,7 @@ var RpcStreamSender = class _RpcStreamSender {
    */
   /* eslint-disable @typescript-eslint/no-unnecessary-condition -- _ended changes across awaits */
   async _runNonRealTime(iterator, state) {
-    const buffer = new import_core4.RingBuffer(this.ackAdvance + 1);
+    const buffer = new import_core5.RingBuffer(this.ackAdvance + 1);
     let bufferStart = 0;
     let isFullyBuffered = false;
     while (true) {
@@ -1108,6 +1139,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;
         }
       }
@@ -1171,7 +1203,7 @@ var RpcStreamSender = class _RpcStreamSender {
    * src/ActualLab.Rpc/Infrastructure/RpcSharedStream.cs:219-420.
    */
   async _runRealTime(iterator, state) {
-    const buffer = new import_core4.RingBuffer(this.ackAdvance + 1);
+    const buffer = new import_core5.RingBuffer(this.ackAdvance + 1);
     let bufferStart = 0;
     let isFullyBuffered = false;
     while (true) {
@@ -1180,7 +1212,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) {
@@ -1328,7 +1363,7 @@ var RpcStreamSender = class _RpcStreamSender {
   /** Wait for the ACK queue to have at least one entry (or `_ended`). */
   async _waitAckReady() {
     if (this._acks.length > 0 || this._ended) return;
-    this._whenAckReady = new import_core4.PromiseSource();
+    this._whenAckReady = new import_core5.PromiseSource();
     await this._whenAckReady.promise;
     this._whenAckReady = null;
   }
@@ -1376,6 +1411,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) {
@@ -1521,9 +1557,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(
@@ -1548,9 +1582,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(
@@ -1621,7 +1653,7 @@ var RpcStream = class _RpcStream {
             if (this._completionError) throw this._completionError;
             return { value: void 0, done: true };
           }
-          this._consumerWaiting = new import_core5.PromiseSource();
+          this._consumerWaiting = new import_core6.PromiseSource();
           await this._consumerWaiting.promise;
         }
       },
@@ -1737,10 +1769,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);
@@ -1762,6 +1796,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;
@@ -1775,25 +1815,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);
@@ -1804,9 +1839,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;
@@ -1895,6 +1928,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 = {
@@ -1951,12 +1985,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);
@@ -2068,14 +2107,14 @@ var RpcSharedObjectTracker = class {
 };
 
 // src/rpc-peer.ts
-var import_core7 = require("@actuallab/core");
+var import_core8 = require("@actuallab/core");
 
 // src/rpc-client-peer-reconnect-delayer.ts
-var import_core6 = require("@actuallab/core");
-var RpcClientPeerReconnectDelayer = class extends import_core6.RetryDelayer {
+var import_core7 = require("@actuallab/core");
+var RpcClientPeerReconnectDelayer = class extends import_core7.RetryDelayer {
   constructor() {
     super();
-    this.delays = import_core6.RetryDelaySeq.exp(1e3, 6e4);
+    this.delays = import_core7.RetryDelaySeq.exp(1e3, 6e4);
   }
 };
 
@@ -2238,6 +2277,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}`;
@@ -2253,8 +2293,8 @@ var RpcPeer = class {
   inbound = new RpcInboundCallTracker();
   remoteObjects = new RpcRemoteObjectTracker();
   sharedObjects = new RpcSharedObjectTracker();
-  connected = new import_core7.EventHandlerSet();
-  disconnected = new import_core7.EventHandlerSet();
+  connected = new import_core8.EventHandlerSet();
+  disconnected = new import_core8.EventHandlerSet();
   _pendingSends = [];
   _keepAliveTimer;
   constructor(ref, hub) {
@@ -2276,9 +2316,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();
     });
@@ -2353,6 +2398,7 @@ var RpcPeer = class {
     this._sendWireData(wireData);
   }
   close() {
+    infoLog?.log(`'${this.ref}': Stopping`);
     this._stopKeepAlive();
     this.remoteObjects.disconnectAll();
     this.sharedObjects.disconnectAll();
@@ -2366,6 +2412,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() {
@@ -2392,15 +2439,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) {
@@ -2467,6 +2520,7 @@ var RpcPeer = class {
             e
           );
         }
+        debugLog2?.log(`'${this.ref}': Inbound call failed: ${method}#${relatedId}`, e);
       } finally {
         if (!isNoWait) {
           this.inbound.remove(relatedId);
@@ -2520,11 +2574,11 @@ var RpcClientPeer = class extends RpcPeer {
   serializationFormat;
   /** Builds the WebSocket URL for this peer. Replace to customize URL construction. */
   connectionUrlResolver = defaultConnectionUrlResolver;
-  peerChanged = new import_core7.EventHandlerSet();
+  peerChanged = new import_core8.EventHandlerSet();
   /** Fired when the server rejects the connection due to an unsupported serialization format (close code 4010). */
-  unsupportedFormat = new import_core7.EventHandlerSet();
+  unsupportedFormat = new import_core8.EventHandlerSet();
   reconnectDelayer = new RpcClientPeerReconnectDelayer();
-  reconnectsAtChanged = new import_core7.EventHandlerSet();
+  reconnectsAtChanged = new import_core8.EventHandlerSet();
   get reconnectsAt() {
     return this._reconnectsAt;
   }
@@ -2555,10 +2609,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,
@@ -2571,7 +2627,7 @@ var RpcClientPeer = class extends RpcPeer {
           lastCloseCode = ev.code;
           lastCloseReason = ev.reason;
         });
-        this._pendingHandshake = new import_core7.PromiseSource();
+        this._pendingHandshake = new import_core8.PromiseSource();
         this.setupConnection(conn);
         this._connection = void 0;
         const closedRejection = new Promise(
@@ -2582,13 +2638,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
@@ -2601,20 +2662,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;
@@ -2622,6 +2687,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;
       }
@@ -2816,6 +2882,7 @@ function _toBytes2(value) {
 }
 
 // src/rpc-service-host.ts
+var { warnLog: warnLog7 } = getLogs("RpcServiceHost");
 var RpcServiceHost = class {
   _methods = /* @__PURE__ */ new Map();
   register(def, impl) {
@@ -2830,8 +2897,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);
     }
@@ -3361,6 +3430,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();
@@ -3370,9 +3440,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);
@@ -3405,6 +3473,7 @@ var RpcMethodRegistry = class {
 };
 
 // src/rpc-hub.ts
+var { warnLog: warnLog9 } = getLogs("RpcHub");
 var RpcHub = class {
   hubId;
   peers = /* @__PURE__ */ new Map();
@@ -3430,6 +3499,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. */
@@ -3661,13 +3731,14 @@ function getStateDescription(state, useLastError = false) {
 }
 
 // src/rpc-peer-state-monitor.ts
-var import_core8 = require("@actuallab/core");
+var import_core9 = require("@actuallab/core");
+var { infoLog: infoLog2 } = getLogs("RpcPeerStateMonitor");
 var JustConnectedPeriodMs = 1500;
 var JustDisconnectedPeriodMs = 3e3;
 var MinReconnectsInMs = 1e3;
 var RpcPeerStateMonitor = class {
   peer;
-  stateChanged = new import_core8.EventHandlerSet();
+  stateChanged = new import_core9.EventHandlerSet();
   _rawConnected;
   _connectedAt = 0;
   _disconnectedAt = 0;
@@ -3723,6 +3794,7 @@ var RpcPeerStateMonitor = class {
     this._scheduleRecompute(
       this._rawConnected ? JustConnectedPeriodMs : JustDisconnectedPeriodMs
     );
+    infoLog2?.log(`'${peer.ref}': monitor started`);
   }
   get state() {
     return this._state;
@@ -3738,6 +3810,7 @@ var RpcPeerStateMonitor = class {
     this.peer.reconnectDelayer.cancelDelaysChanged.remove(
       this._onCancelDelaysChanged
     );
+    infoLog2?.log(`'${this.peer.ref}': monitor stopped`);
   }
   _recompute() {
     if (this._timer !== void 0) {
@@ -3864,6 +3937,7 @@ var RpcPeerStateMonitor = class {
   deserializeBinaryMessage,
   deserializeCompactBinaryMessage,
   deserializeMessage,
+  getLogs,
   getMethodsMeta,
   getServiceMeta,
   getStateDescription,