@actuallab/rpc 12.1.100 → 12.2.21

package/dist/index.cjs

@@ -1,7 +1,9 @@
 "use strict";
+var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __export = (target, all) => {
   for (var name in all)
@@ -15,6 +17,14 @@ var __copyProps = (to, from, except, desc) => {
   }
   return to;
 };
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
 // src/index.ts
@@ -24,13 +34,18 @@ __export(index_exports, {
   DEFAULT_SERIALIZATION_FORMAT: () => DEFAULT_SERIALIZATION_FORMAT,
   ENVELOPE_DELIMITER: () => ENVELOPE_DELIMITER,
   FRAME_DELIMITER: () => FRAME_DELIMITER,
+  RPC_CLOSE_CODE_UNSUPPORTED_FORMAT: () => RPC_CLOSE_CODE_UNSUPPORTED_FORMAT,
   RpcCallTypeId: () => RpcCallTypeId,
   RpcClientPeer: () => RpcClientPeer,
   RpcClientPeerReconnectDelayer: () => RpcClientPeerReconnectDelayer,
   RpcHub: () => RpcHub,
   RpcInboundCall: () => RpcInboundCall,
   RpcInboundCallTracker: () => RpcInboundCallTracker,
+  RpcJsonSerializationFormat: () => RpcJsonSerializationFormat,
   RpcMessageChannelConnection: () => RpcMessageChannelConnection,
+  RpcMessagePackCompactSerializationFormat: () => RpcMessagePackCompactSerializationFormat,
+  RpcMessagePackSerializationFormat: () => RpcMessagePackSerializationFormat,
+  RpcMethodRegistry: () => RpcMethodRegistry,
   RpcObjectKind: () => RpcObjectKind,
   RpcOutboundCall: () => RpcOutboundCall,
   RpcOutboundCallTracker: () => RpcOutboundCallTracker,
@@ -39,6 +54,7 @@ __export(index_exports, {
   RpcPeerStateKind: () => RpcPeerStateKind,
   RpcPeerStateMonitor: () => RpcPeerStateMonitor,
   RpcRemoteObjectTracker: () => RpcRemoteObjectTracker,
+  RpcSerializationFormat: () => RpcSerializationFormat,
   RpcServerPeer: () => RpcServerPeer,
   RpcServiceHost: () => RpcServiceHost,
   RpcSharedObjectTracker: () => RpcSharedObjectTracker,
@@ -50,10 +66,16 @@ __export(index_exports, {
   RpcType: () => RpcType,
   RpcWebSocketConnection: () => RpcWebSocketConnection,
   WebSocketState: () => WebSocketState,
+  computeMethodHash: () => computeMethodHash,
+  createBinaryEncoder: () => createBinaryEncoder,
   createMessageChannelPair: () => createMessageChannelPair,
   createRpcClient: () => createRpcClient,
+  defaultBinaryDecoder: () => defaultBinaryDecoder,
+  defaultBinaryEncoder: () => defaultBinaryEncoder,
   defaultConnectionUrlResolver: () => defaultConnectionUrlResolver,
   defineRpcService: () => defineRpcService,
+  deserializeBinaryMessage: () => deserializeBinaryMessage,
+  deserializeCompactBinaryMessage: () => deserializeCompactBinaryMessage,
   deserializeMessage: () => deserializeMessage,
   getMethodsMeta: () => getMethodsMeta,
   getServiceMeta: () => getServiceMeta,
@@ -64,10 +86,17 @@ __export(index_exports, {
   resolveStreamRefs: () => resolveStreamRefs,
   rpcMethod: () => rpcMethod,
   rpcService: () => rpcService,
+  serializeBinaryFrame: () => serializeBinaryFrame,
+  serializeBinaryMessage: () => serializeBinaryMessage,
+  serializeCompactBinaryMessage: () => serializeCompactBinaryMessage,
   serializeFrame: () => serializeFrame,
   serializeMessage: () => serializeMessage,
+  splitBinaryFrame: () => splitBinaryFrame,
+  splitCompactBinaryFrame: () => splitCompactBinaryFrame,
   splitFrame: () => splitFrame,
-  wireMethodName: () => wireMethodName
+  wireMethodName: () => wireMethodName,
+  xxh3_64: () => xxh3_64,
+  xxh3_64str: () => xxh3_64str
 });
 module.exports = __toCommonJS(index_exports);
 
@@ -95,6 +124,7 @@ var ARG_DELIMITER = "";
 var FRAME_DELIMITER = "\n";
 
 // src/rpc-serialization.ts
+var import_msgpack = require("@msgpack/msgpack");
 function serializeMessage(message, args) {
   const envelope = JSON.stringify(message);
   if (args === void 0 || args.length === 0) {
@@ -124,13 +154,263 @@ function deserializeMessage(raw) {
     try {
       return JSON.parse(s);
     } catch {
+      console.warn(
+        `[RpcSerialization] failed to parse arg as JSON: ${s.substring(0, 100)}`
+      );
       return s;
     }
   });
   return { message, args };
 }
+var textEncoder = new TextEncoder();
+var textDecoder = new TextDecoder();
+var INITIAL_ENCODER_BUFFER_SIZE = 32 * 1024;
+var defaultBinaryEncoder = new import_msgpack.Encoder(
+  void 0,
+  void 0,
+  void 0,
+  INITIAL_ENCODER_BUFFER_SIZE
+);
+var defaultBinaryDecoder = new import_msgpack.Decoder();
+function createBinaryEncoder() {
+  return new import_msgpack.Encoder(
+    void 0,
+    void 0,
+    void 0,
+    INITIAL_ENCODER_BUFFER_SIZE
+  );
+}
+function varUintByteLen(value) {
+  if (value < 0) value = 0;
+  let n = 0;
+  do {
+    n++;
+    value >>>= 7;
+  } while (value > 0);
+  return n;
+}
+function writeVarUintInto(out, pos, value) {
+  if (value < 0) value = 0;
+  do {
+    let byte = value & 127;
+    value >>>= 7;
+    if (value > 0) byte |= 128;
+    out[pos++] = byte;
+  } while (value > 0);
+  return pos;
+}
+function readVarUint(data, offset) {
+  let value = 0, shift = 0, bytesRead = 0;
+  do {
+    if (offset + bytesRead >= data.length) break;
+    const byte = data[offset + bytesRead];
+    value |= (byte & 127) << shift;
+    bytesRead++;
+    if ((byte & 128) === 0) break;
+    shift += 7;
+  } while (shift < 35);
+  return { value: value >>> 0, bytesRead };
+}
+function concatUint8Arrays(arrays) {
+  let totalLength = 0;
+  for (const arr of arrays) totalLength += arr.length;
+  const result = new Uint8Array(totalLength);
+  let offset = 0;
+  for (const arr of arrays) {
+    result.set(arr, offset);
+    offset += arr.length;
+  }
+  return result;
+}
+function serializeBinaryMessage(message, args, encoder = defaultBinaryEncoder) {
+  let argsDataLen = 0;
+  let argBufs = null;
+  if (args && args.length > 0) {
+    argBufs = new Array(args.length);
+    for (let i = 0; i < args.length; i++) {
+      const buf = encoder.encode(args[i]);
+      argBufs[i] = buf;
+      argsDataLen += buf.length;
+    }
+  }
+  const callType = message.CallType ?? 0;
+  const relatedId = message.RelatedId ?? 0;
+  const methodBytes = textEncoder.encode(message.Method ?? "");
+  const relatedIdLen = varUintByteLen(relatedId);
+  const methodLenVarintLen = varUintByteLen(methodBytes.length);
+  const headerSize = 1 + relatedIdLen + methodLenVarintLen + methodBytes.length;
+  const totalSize = headerSize + 4 + argsDataLen;
+  const out = new Uint8Array(totalSize);
+  let pos = 0;
+  out[pos++] = callType << 5 & 224;
+  pos = writeVarUintInto(out, pos, relatedId);
+  pos = writeVarUintInto(out, pos, methodBytes.length);
+  out.set(methodBytes, pos);
+  pos += methodBytes.length;
+  out[pos++] = argsDataLen & 255;
+  out[pos++] = argsDataLen >>> 8 & 255;
+  out[pos++] = argsDataLen >>> 16 & 255;
+  out[pos++] = argsDataLen >>> 24 & 255;
+  if (argBufs !== null) {
+    for (const buf of argBufs) {
+      out.set(buf, pos);
+      pos += buf.length;
+    }
+  }
+  return out;
+}
+function deserializeBinaryMessage(data, offset, decoder = defaultBinaryDecoder) {
+  const view = new DataView(data.buffer, data.byteOffset, data.byteLength);
+  let pos = offset;
+  const byte0 = data[pos++];
+  const callTypeId = byte0 >> 5 & 7;
+  const headerCount = byte0 & 31;
+  const relId = readVarUint(data, pos);
+  pos += relId.bytesRead;
+  const methodLen = readVarUint(data, pos);
+  pos += methodLen.bytesRead;
+  const methodBytes = data.subarray(pos, pos + methodLen.value);
+  const method = textDecoder.decode(methodBytes);
+  pos += methodLen.value;
+  const argDataLen = view.getInt32(pos, true);
+  pos += 4;
+  if (headerCount > 0) {
+    for (let h = 0; h < headerCount; h++) {
+      const keyLen = data[pos++];
+      pos += keyLen;
+      const valLen = readVarUint(data, pos);
+      pos += valLen.bytesRead + valLen.value;
+    }
+  }
+  const args = [];
+  const argEnd = pos + argDataLen;
+  if (argDataLen > 0) {
+    const argSlice = data.subarray(pos, argEnd);
+    for (const decoded of decoder.decodeMulti(argSlice)) {
+      args.push(decoded);
+    }
+    pos = argEnd;
+  }
+  const message = {
+    Method: method,
+    RelatedId: relId.value,
+    CallType: callTypeId
+  };
+  return { message, args, bytesRead: pos - offset };
+}
+function splitBinaryFrame(frame, decoder = defaultBinaryDecoder) {
+  const results = [];
+  let offset = 0;
+  while (offset < frame.length) {
+    const { message, args, bytesRead } = deserializeBinaryMessage(
+      frame,
+      offset,
+      decoder
+    );
+    if (bytesRead <= 0) break;
+    results.push({ message, args });
+    offset += bytesRead;
+  }
+  return results;
+}
+function serializeBinaryFrame(messages) {
+  return concatUint8Arrays(messages);
+}
+function serializeCompactBinaryMessage(message, args, registry, encoder = defaultBinaryEncoder) {
+  let argsDataLen = 0;
+  let argBufs = null;
+  if (args && args.length > 0) {
+    argBufs = new Array(args.length);
+    for (let i = 0; i < args.length; i++) {
+      const buf = encoder.encode(args[i]);
+      argBufs[i] = buf;
+      argsDataLen += buf.length;
+    }
+  }
+  const methodName = message.Method ?? "";
+  const methodHash = registry?.requireHash(methodName) ?? 0;
+  const callType = message.CallType ?? 0;
+  const relatedId = message.RelatedId ?? 0;
+  const relatedIdLen = varUintByteLen(relatedId);
+  const headerSize = 1 + relatedIdLen + 4;
+  const totalSize = headerSize + 4 + argsDataLen;
+  const out = new Uint8Array(totalSize);
+  let pos = 0;
+  out[pos++] = callType << 5 & 224;
+  pos = writeVarUintInto(out, pos, relatedId);
+  const hashU32 = methodHash >>> 0;
+  out[pos++] = hashU32 & 255;
+  out[pos++] = hashU32 >>> 8 & 255;
+  out[pos++] = hashU32 >>> 16 & 255;
+  out[pos++] = hashU32 >>> 24 & 255;
+  out[pos++] = argsDataLen & 255;
+  out[pos++] = argsDataLen >>> 8 & 255;
+  out[pos++] = argsDataLen >>> 16 & 255;
+  out[pos++] = argsDataLen >>> 24 & 255;
+  if (argBufs !== null) {
+    for (const buf of argBufs) {
+      out.set(buf, pos);
+      pos += buf.length;
+    }
+  }
+  return out;
+}
+function deserializeCompactBinaryMessage(data, offset, registry, decoder = defaultBinaryDecoder) {
+  const view = new DataView(data.buffer, data.byteOffset, data.byteLength);
+  let pos = offset;
+  const byte0 = data[pos++];
+  const callTypeId = byte0 >> 5 & 7;
+  const headerCount = byte0 & 31;
+  const relId = readVarUint(data, pos);
+  pos += relId.bytesRead;
+  const methodHash = view.getUint32(pos, true);
+  pos += 4;
+  const method = registry?.getName(methodHash | 0) ?? `<hash:0x${methodHash.toString(16).padStart(8, "0")}>`;
+  const argDataLen = view.getInt32(pos, true);
+  pos += 4;
+  if (headerCount > 0) {
+    for (let h = 0; h < headerCount; h++) {
+      const keyLen = data[pos++];
+      pos += keyLen;
+      const valLen = readVarUint(data, pos);
+      pos += valLen.bytesRead + valLen.value;
+    }
+  }
+  const args = [];
+  const argEnd = pos + argDataLen;
+  if (argDataLen > 0) {
+    const argSlice = data.subarray(pos, argEnd);
+    for (const decoded of decoder.decodeMulti(argSlice)) {
+      args.push(decoded);
+    }
+    pos = argEnd;
+  }
+  const message = {
+    Method: method,
+    RelatedId: relId.value,
+    CallType: callTypeId
+  };
+  return { message, args, bytesRead: pos - offset };
+}
+function splitCompactBinaryFrame(frame, registry, decoder = defaultBinaryDecoder) {
+  const results = [];
+  let offset = 0;
+  while (offset < frame.length) {
+    const { message, args, bytesRead } = deserializeCompactBinaryMessage(
+      frame,
+      offset,
+      registry,
+      decoder
+    );
+    if (bytesRead <= 0) break;
+    results.push({ message, args });
+    offset += bytesRead;
+  }
+  return results;
+}
 
 // src/rpc-connection.ts
+var import_msgpack2 = require("@msgpack/msgpack");
 var import_core = require("@actuallab/core");
 var WebSocketState = {
   CONNECTING: 0,
@@ -142,11 +422,36 @@ var RpcWebSocketConnection = class {
   _ws;
   _sendBuffer = [];
   _connected = new import_core.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
+   *  large video frames). See serializeBinaryMessage() for details. */
+  _encoder = createBinaryEncoder();
+  /** Per-connection msgpack decoder — reused across inbound messages
+   *  rather than reconstructing one for every `decodeMulti` call. */
+  _decoder = new import_msgpack2.Decoder();
+  /** Exposed for callers who need to encode outbound binary messages
+   *  through this connection (e.g. `serializeBinaryMessage`). Safe to
+   *  pass to synchronous encode calls on the same event-loop turn. */
+  get encoder() {
+    return this._encoder;
+  }
+  get decoder() {
+    return this._decoder;
+  }
+  _format;
+  _methodRegistry;
+  binaryMode;
   messageReceived = new import_core.EventHandlerSet();
   closed = new import_core.EventHandlerSet();
   error = new import_core.EventHandlerSet();
-  constructor(ws) {
+  constructor(ws, binaryMode = false, format, methodRegistry) {
     this._ws = ws;
+    this.binaryMode = binaryMode;
+    this._format = format;
+    this._methodRegistry = methodRegistry;
+    if (binaryMode && ws.binaryType !== void 0)
+      ws.binaryType = "arraybuffer";
     if (ws.readyState === WebSocketState.OPEN) {
       this._connected.resolve();
       this._flush();
@@ -156,10 +461,46 @@ var RpcWebSocketConnection = class {
       this._flush();
     };
     ws.onmessage = (ev) => {
-      const data = typeof ev.data === "string" ? ev.data : String(ev.data);
-      const messages = splitFrame(data);
-      for (const msg of messages) {
-        if (msg.length > 0) this.messageReceived.trigger(msg);
+      if (ev.data instanceof Uint8Array || ev.data instanceof ArrayBuffer) {
+        const frame = ev.data instanceof Uint8Array ? ev.data : new Uint8Array(ev.data);
+        try {
+          const messages = this._splitBinary(frame);
+          for (const { message, args } of messages) {
+            this.messageReceived.trigger({
+              kind: "binary",
+              message,
+              args
+            });
+          }
+        } catch (e) {
+          this.error.trigger(e);
+        }
+      } else if (typeof Blob !== "undefined" && ev.data instanceof Blob && this.binaryMode) {
+        void ev.data.arrayBuffer().then((ab) => {
+          const frame = new Uint8Array(ab);
+          try {
+            const messages = this._splitBinary(frame);
+            for (const { message, args } of messages) {
+              this.messageReceived.trigger({
+                kind: "binary",
+                message,
+                args
+              });
+            }
+          } catch (e) {
+            this.error.trigger(e);
+          }
+        });
+      } else {
+        const data = typeof ev.data === "string" ? ev.data : String(ev.data);
+        const messages = splitFrame(data);
+        for (const msg of messages) {
+          if (msg.length > 0)
+            this.messageReceived.trigger({
+              kind: "text",
+              raw: msg
+            });
+        }
       }
     };
     ws.onclose = (ev) => {
@@ -176,27 +517,46 @@ var RpcWebSocketConnection = class {
     return this._connected.promise;
   }
   send(serializedMessage) {
-    try {
-      if (this._ws.readyState === WebSocketState.OPEN)
-        this._ws.send(serializedMessage);
-      else if (this._ws.readyState === WebSocketState.CONNECTING)
-        this._sendBuffer.push(serializedMessage);
-    } catch {
-    }
+    this._sendRaw(serializedMessage);
+  }
+  sendBinary(data) {
+    this._sendRaw(data);
+  }
+  sendTextBatch(messages) {
+    this._sendRaw(serializeFrame(messages));
+  }
+  sendBinaryBatch(messages) {
+    this._sendRaw(serializeBinaryFrame(messages));
   }
-  sendBatch(messages) {
-    const frame = serializeFrame(messages);
-    this.send(frame);
+  /** Split a binary frame using the format (compact-aware) or default splitter. */
+  _splitBinary(frame) {
+    if (this._format) {
+      return this._format.splitBinaryFrame(
+        frame,
+        this._decoder,
+        this._methodRegistry
+      );
+    }
+    return splitBinaryFrame(frame, this._decoder);
   }
   close(code, reason) {
     this._ws.close(code, reason);
   }
+  _sendRaw(data) {
+    try {
+      if (this._ws.readyState === WebSocketState.OPEN) {
+        this._ws.send(data);
+      } else if (this._ws.readyState === WebSocketState.CONNECTING)
+        this._sendBuffer.push(data);
+    } catch {
+    }
+  }
   _flush() {
     if (this._sendBuffer.length === 0) return;
-    const frame = serializeFrame(this._sendBuffer);
+    const buffer = this._sendBuffer;
     this._sendBuffer = [];
     try {
-      this._ws.send(frame);
+      for (const item of buffer) this._ws.send(item);
     } catch {
     }
   }
@@ -207,6 +567,7 @@ var import_core2 = require("@actuallab/core");
 var RpcMessageChannelConnection = class {
   _port;
   _open = true;
+  binaryMode = false;
   messageReceived = new import_core2.EventHandlerSet();
   closed = new import_core2.EventHandlerSet();
   whenConnected = Promise.resolve();
@@ -216,7 +577,8 @@ var RpcMessageChannelConnection = class {
     port.onmessage = (ev) => {
       const data = typeof ev.data === "string" ? ev.data : String(ev.data);
       for (const msg of splitFrame(data))
-        if (msg.length > 0) this.messageReceived.trigger(msg);
+        if (msg.length > 0)
+          this.messageReceived.trigger({ kind: "text", raw: msg });
     };
   }
   get isOpen() {
@@ -229,6 +591,13 @@ var RpcMessageChannelConnection = class {
     } catch {
     }
   }
+  sendBinary(data) {
+    if (!this._open) return;
+    try {
+      this._port.postMessage(data, [data.buffer]);
+    } catch {
+    }
+  }
   close(code, reason) {
     if (!this._open) return;
     this._open = false;
@@ -283,8 +652,8 @@ var RpcOutboundCall = class {
   /** Whether to remove this call from the tracker on $sys.Ok. Default: true.
    *  Subclasses (e.g. compute calls) override to false to stay in tracker for invalidation. */
   removeOnOk = true;
-  /** The serialized wire message — stored for re-sending on reconnect. */
-  serializedMessage = "";
+  /** The serialized wire data — stored for re-sending on reconnect. */
+  serializedWireData = "";
   constructor(callId, method) {
     this.callId = callId;
     this.method = method;
@@ -374,6 +743,7 @@ var RpcInboundCallTracker = class {
 };
 
 // src/rpc-stream.ts
+var import_denque = __toESM(require("denque"), 1);
 var import_core4 = require("@actuallab/core");
 
 // src/rpc-object.ts
@@ -381,25 +751,49 @@ var RpcObjectKind = { Local: 0, Remote: 1 };
 
 // src/rpc-stream.ts
 function parseStreamRef(value) {
-  if (typeof value !== "string") return null;
-  const parts = value.split(",");
-  if (parts.length < 4 || parts.length > 5) return null;
-  const hostId = parts[0];
-  const localId = parseInt(parts[1], 10);
-  const ackPeriod = parseInt(parts[2], 10);
-  const ackAdvance = parseInt(parts[3], 10);
-  if (isNaN(localId) || isNaN(ackPeriod) || isNaN(ackAdvance)) return null;
-  const allowReconnect = parts.length < 5 || parts[4] !== "0";
-  return { hostId, localId, ackPeriod, ackAdvance, allowReconnect };
+  if (typeof value === "string") {
+    const parts = value.split(",");
+    if (parts.length < 4 || parts.length > 6) return null;
+    const hostId = parts[0];
+    const localId = parseInt(parts[1], 10);
+    const ackPeriod = parseInt(parts[2], 10);
+    const ackAdvance = parseInt(parts[3], 10);
+    if (isNaN(localId) || isNaN(ackPeriod) || isNaN(ackAdvance))
+      return null;
+    const allowReconnect = parts.length < 5 || parts[4] !== "0";
+    const isRealTime = parts.length >= 6 && parts[5] === "1";
+    return { hostId, localId, ackPeriod, ackAdvance, allowReconnect, isRealTime };
+  }
+  if (typeof value === "object" && value !== null) {
+    const obj = value;
+    const serializedId = obj.SerializedId;
+    if (!Array.isArray(serializedId) || serializedId.length < 2)
+      return null;
+    const rawHostId = serializedId[0];
+    const hostId = String(rawHostId);
+    const localId = Number(serializedId[1]);
+    const ackPeriod = Number(obj.AckPeriod ?? 256);
+    const ackAdvance = Number(obj.AckAdvance ?? 128);
+    const allowReconnect = obj.AllowReconnect !== false;
+    const isRealTime = obj.IsRealTime === true;
+    return { hostId, localId, ackPeriod, ackAdvance, allowReconnect, isRealTime };
+  }
+  return null;
 }
-var RpcStream = class {
+var RpcStream = class _RpcStream {
   id;
   kind = RpcObjectKind.Remote;
   allowReconnect;
   peer;
   ackPeriod;
   ackAdvance;
-  _buffer = [];
+  // Double-ended queue so consumption via `shift()` is O(1) and the
+  // backing store frees memory as items are drained. The previous
+  // `T[]` buffer kept every item for the life of the stream because
+  // the iterator tracked a read index instead of shifting — fine for
+  // short runs but a slow leak in the browser where a video call can
+  // last an hour.
+  _buffer = new import_denque.default();
   _nextExpectedIndex = 0;
   _consumerWaiting = null;
   _completed = false;
@@ -419,6 +813,17 @@ var RpcStream = class {
   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}`
+      );
+      if (!this.allowReconnect) {
+        this._completed = true;
+        this._completionError = new Error(
+          `Stream gap at index ${index} (expected ${this._nextExpectedIndex}); reconnect not allowed`
+        );
+        this._notifyConsumer();
+        return;
+      }
       this._sendAck(this._nextExpectedIndex, true);
       return;
     }
@@ -435,6 +840,17 @@ var RpcStream = class {
   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}`
+      );
+      if (!this.allowReconnect) {
+        this._completed = true;
+        this._completionError = new Error(
+          `Stream gap at index ${index} (expected ${this._nextExpectedIndex}); reconnect not allowed`
+        );
+        this._notifyConsumer();
+        return;
+      }
       this._sendAck(this._nextExpectedIndex, true);
       return;
     }
@@ -470,10 +886,9 @@ var RpcStream = class {
   }
   // -- AsyncIterable --
   [Symbol.asyncIterator]() {
-    if (this._iterating) throw new Error("RpcStream can only be iterated once.");
+    if (this._iterating)
+      throw new Error("RpcStream can only be iterated once.");
     this._iterating = true;
-    let bufferIndex = 0;
-    let consumedIndex = 0;
     const self = this;
     return {
       async next() {
@@ -482,10 +897,8 @@ var RpcStream = class {
           self._sendAck(0, true);
         }
         while (true) {
-          if (bufferIndex < self._buffer.length) {
-            const value = self._buffer[bufferIndex];
-            bufferIndex++;
-            consumedIndex++;
+          if (!self._buffer.isEmpty()) {
+            const value = self._buffer.shift();
             return { value, done: false };
           }
           if (self._completed) {
@@ -524,17 +937,30 @@ var RpcStream = class {
       this._sendAck(nextIndex, false);
     }
   }
-  _sendAck(nextIndex, _mustReset) {
+  static _emptyGuid = "00000000-0000-0000-0000-000000000000";
+  _sendAck(nextIndex, mustReset) {
     this._ackSentUpTo = nextIndex;
     const conn = this.peer.connection;
     if (conn) {
-      this.peer.hub.systemCallSender.ack(conn, this.id.localId, nextIndex, this.id.hostId);
+      const hostId = mustReset ? this.id.hostId : _RpcStream._emptyGuid;
+      this.peer.hub.systemCallSender.ack(
+        conn,
+        this.peer.format,
+        this.id.localId,
+        nextIndex,
+        hostId
+      );
     }
   }
   _sendAckEnd() {
     const conn = this.peer.connection;
     if (conn) {
-      this.peer.hub.systemCallSender.ackEnd(conn, this.id.localId, this.id.hostId);
+      this.peer.hub.systemCallSender.ackEnd(
+        conn,
+        this.peer.format,
+        this.id.localId,
+        this.id.hostId
+      );
     }
   }
 };
@@ -556,6 +982,8 @@ function resolveStreamRefs(value, peer) {
     return value;
   }
   if (typeof value === "object") {
+    if (ArrayBuffer.isView(value) || value instanceof ArrayBuffer)
+      return value;
     for (const key of Object.keys(value)) {
       value[key] = resolveStreamRefs(
         value[key],
@@ -601,21 +1029,39 @@ var RpcSystemCallHandler = class {
       }
       case RpcSystemCalls.item: {
         const stream = peer.remoteObjects.get(relatedId);
-        if (stream) stream.onItem(args[0], resolveStreamRefs(args[1], peer));
+        if (!stream) {
+          console.warn(
+            `[RpcSysHandler] $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) {
+        if (!stream) {
+          console.warn(
+            `[RpcSysHandler] $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);
+          for (let i = 0; i < items.length; i++)
+            items[i] = resolveStreamRefs(items[i], peer);
           stream.onBatch(args[0], items);
         }
         break;
       }
       case RpcSystemCalls.end: {
         const stream = peer.remoteObjects.get(relatedId);
-        if (stream) {
+        if (!stream) {
+          console.warn(
+            `[RpcSysHandler] $sys.End: no stream for relatedId=${relatedId}`
+          );
+        } else {
           const errorInfo = args[1];
           const msg = errorInfo?.Message ?? errorInfo?.message;
           const error = msg ? new Error(msg) : null;
@@ -633,76 +1079,142 @@ var RpcSystemCallHandler = class {
         sender?.onAckEnd(args[0]);
         break;
       }
+      default: {
+        if (method === "$sys.Disconnect" || method?.startsWith("$sys.Disconnect")) {
+          const ids = args[0];
+          if (Array.isArray(ids)) {
+            for (const id of ids) {
+              const remoteObj = peer.remoteObjects.get(id);
+              if (remoteObj && typeof remoteObj.disconnect === "function") {
+                remoteObj.disconnect();
+              }
+              const sharedObj = peer.sharedObjects.get(id);
+              if (sharedObj && typeof sharedObj.disconnect === "function") {
+                sharedObj.disconnect();
+              }
+            }
+          }
+        }
+        break;
+      }
     }
   }
 };
 
 // src/rpc-system-call-sender.ts
-var RpcSystemCallSender = class {
-  handshake(conn, peerId, hubId, index) {
-    const msg = serializeMessage({ Method: RpcSystemCalls.handshake }, [{
+var RpcSystemCallSender = class _RpcSystemCallSender {
+  // Reusable envelopes — one per hot-path method.
+  _itemEnv = {
+    Method: RpcSystemCalls.item,
+    RelatedId: 0
+  };
+  _batchEnv = {
+    Method: RpcSystemCalls.batch,
+    RelatedId: 0
+  };
+  _endEnv = {
+    Method: RpcSystemCalls.end,
+    RelatedId: 0
+  };
+  _ackEnv = {
+    Method: RpcSystemCalls.ack,
+    RelatedId: 0
+  };
+  _ackEndEnv = {
+    Method: RpcSystemCalls.ackEnd,
+    RelatedId: 0
+  };
+  // Reusable arg arrays.
+  _itemArgs = [0, null];
+  _batchArgs = [0, null];
+  _endArgs = [0, { TypeRef: "", Message: "" }];
+  _ackArgs = [0, ""];
+  _ackEndArgs = [""];
+  static NO_ERROR = Object.freeze({ TypeRef: "", Message: "" });
+  registry;
+  _send(conn, format, envelope, args) {
+    const wireData = format.serializeMessage(
+      envelope,
+      args,
+      conn.encoder,
+      this.registry
+    );
+    if (typeof wireData === "string") {
+      conn.send(wireData);
+    } else {
+      conn.sendBinary(wireData);
+    }
+  }
+  handshake(conn, format, peerId, hubId, index) {
+    const handshakeArg = format.isBinary ? [peerId, null, hubId, 2, index] : {
       RemotePeerId: peerId,
       RemoteApiVersionSet: null,
       RemoteHubId: hubId,
       ProtocolVersion: 2,
       Index: index
-    }]);
-    conn.send(msg);
-  }
-  ok(conn, relatedId, result) {
-    const msg = serializeMessage({ Method: RpcSystemCalls.ok, RelatedId: relatedId }, [result]);
-    conn.send(msg);
+    };
+    this._send(conn, format, { Method: RpcSystemCalls.handshake }, [
+      handshakeArg
+    ]);
+  }
+  ok(conn, format, relatedId, result) {
+    this._send(
+      conn,
+      format,
+      { Method: RpcSystemCalls.ok, RelatedId: relatedId },
+      [result]
+    );
   }
-  error(conn, relatedId, error) {
+  error(conn, format, relatedId, error) {
     const message = error instanceof Error ? error.message : String(error);
-    const msg = serializeMessage(
+    this._send(
+      conn,
+      format,
       { Method: RpcSystemCalls.error, RelatedId: relatedId },
       [{ Message: message }]
     );
-    conn.send(msg);
-  }
-  cancel(conn, relatedId) {
-    const msg = serializeMessage({ Method: RpcSystemCalls.cancel, RelatedId: relatedId });
-    conn.send(msg);
-  }
-  keepAlive(conn, activeCallIds) {
-    const msg = serializeMessage({ Method: RpcSystemCalls.keepAlive }, [activeCallIds]);
-    conn.send(msg);
-  }
-  item(conn, localId, index, item) {
-    const msg = serializeMessage(
-      { Method: RpcSystemCalls.item, RelatedId: localId },
-      [index, item]
-    );
-    conn.send(msg);
-  }
-  batch(conn, localId, index, items) {
-    const msg = serializeMessage(
-      { Method: RpcSystemCalls.batch, RelatedId: localId },
-      [index, items]
-    );
-    conn.send(msg);
-  }
-  end(conn, localId, index, error = null) {
-    const msg = serializeMessage(
-      { Method: RpcSystemCalls.end, RelatedId: localId },
-      [index, error]
-    );
-    conn.send(msg);
   }
-  ack(conn, localId, nextIndex, hostId) {
-    const msg = serializeMessage(
-      { Method: RpcSystemCalls.ack, RelatedId: localId },
-      [nextIndex, hostId]
-    );
-    conn.send(msg);
+  cancel(conn, format, relatedId) {
+    this._send(conn, format, {
+      Method: RpcSystemCalls.cancel,
+      RelatedId: relatedId
+    });
   }
-  ackEnd(conn, localId, hostId) {
-    const msg = serializeMessage(
-      { Method: RpcSystemCalls.ackEnd, RelatedId: localId },
-      [hostId]
-    );
-    conn.send(msg);
+  keepAlive(conn, format, activeCallIds) {
+    this._send(conn, format, { Method: RpcSystemCalls.keepAlive }, [
+      activeCallIds
+    ]);
+  }
+  item(conn, format, localId, index, item) {
+    this._itemEnv.RelatedId = localId;
+    this._itemArgs[0] = index;
+    this._itemArgs[1] = item;
+    this._send(conn, format, this._itemEnv, this._itemArgs);
+    this._itemArgs[1] = null;
+  }
+  batch(conn, format, localId, index, items) {
+    this._batchEnv.RelatedId = localId;
+    this._batchArgs[0] = index;
+    this._batchArgs[1] = items;
+    this._send(conn, format, this._batchEnv, this._batchArgs);
+    this._batchArgs[1] = null;
+  }
+  end(conn, format, localId, index, error = _RpcSystemCallSender.NO_ERROR) {
+    this._endEnv.RelatedId = localId;
+    this._endArgs[0] = index;
+    this._endArgs[1] = error;
+    this._send(conn, format, this._endEnv, this._endArgs);
+  }
+  ack(conn, format, localId, nextIndex, hostId) {
+    this._ackEnv.RelatedId = localId;
+    this._ackArgs[0] = nextIndex;
+    this._ackArgs[1] = hostId;
+    this._send(conn, format, this._ackEnv, this._ackArgs);
+  }
+  ackEnd(conn, format, localId, hostId) {
+    this._ackEndEnv.RelatedId = localId;
+    this._ackEndArgs[0] = hostId;
+    this._send(conn, format, this._ackEndEnv, this._ackEndArgs);
   }
 };
 
@@ -714,29 +1226,42 @@ var RpcStreamSender = class {
   id;
   kind = RpcObjectKind.Local;
   allowReconnect;
+  isRealTime;
+  canSkipTo;
   peer;
   ackPeriod;
   ackAdvance;
   _nextIndex = 0;
   _ended = false;
   _started = new import_core5.PromiseSource();
-  constructor(peer, ackPeriod = DEFAULT_ACK_PERIOD, ackAdvance = DEFAULT_ACK_ADVANCE, allowReconnect = true) {
+  _lastAckedIndex = 0;
+  _ackWaiting = null;
+  constructor(peer, ackPeriod = DEFAULT_ACK_PERIOD, ackAdvance = DEFAULT_ACK_ADVANCE, allowReconnect = true, isRealTime = false, canSkipTo = () => true) {
     const localId = peer.sharedObjects.nextId();
     this.id = { hostId: peer.hub.hubId, localId };
     this.allowReconnect = allowReconnect;
+    this.isRealTime = isRealTime;
+    this.canSkipTo = canSkipTo;
     this.peer = peer;
     this.ackPeriod = ackPeriod;
     this.ackAdvance = ackAdvance;
   }
   /** Returns the stream reference string for the $sys.Ok response. */
   toRef() {
-    return `${this.id.hostId},${this.id.localId},${this.ackPeriod},${this.ackAdvance},${this.allowReconnect ? "1" : "0"}`;
+    return `${this.id.hostId},${this.id.localId},${this.ackPeriod},${this.ackAdvance},${this.allowReconnect ? "1" : "0"},${this.isRealTime ? "1" : "0"}`;
   }
   /** Called by system call handler when $sys.Ack is received from the client. */
-  onAck(_nextIndex, _hostId) {
+  onAck(nextIndex, _hostId) {
     if (!this._started.isCompleted) {
       this._started.resolve();
     }
+    if (nextIndex > this._lastAckedIndex) {
+      this._lastAckedIndex = nextIndex;
+    }
+    if (this._ackWaiting) {
+      this._ackWaiting.resolve();
+      this._ackWaiting = null;
+    }
   }
   /** Called by system call handler when $sys.AckEnd is received from the client. */
   onAckEnd(_hostId) {
@@ -748,7 +1273,13 @@ var RpcStreamSender = class {
     if (this._ended) return;
     const conn = this.peer.connection;
     if (!conn) return;
-    this.peer.hub.systemCallSender.item(conn, this.id.localId, this._nextIndex, item);
+    this.peer.hub.systemCallSender.item(
+      conn,
+      this.peer.format,
+      this.id.localId,
+      this._nextIndex,
+      item
+    );
     this._nextIndex++;
   }
   /** Send a batch of items to the client. */
@@ -756,7 +1287,13 @@ var RpcStreamSender = class {
     if (this._ended || items.length === 0) return;
     const conn = this.peer.connection;
     if (!conn) return;
-    this.peer.hub.systemCallSender.batch(conn, this.id.localId, this._nextIndex, items);
+    this.peer.hub.systemCallSender.batch(
+      conn,
+      this.peer.format,
+      this.id.localId,
+      this._nextIndex,
+      items
+    );
     this._nextIndex += items.length;
   }
   /** Signal stream completion to the client. */
@@ -765,19 +1302,63 @@ var RpcStreamSender = class {
     this._ended = true;
     const conn = this.peer.connection;
     if (!conn) return;
-    const errorInfo = error ? { Message: error.message } : null;
-    this.peer.hub.systemCallSender.end(conn, this.id.localId, this._nextIndex, errorInfo);
+    const errorInfo = error ? { TypeRef: "System.Exception", Message: error.message } : { TypeRef: "", Message: "" };
+    this.peer.hub.systemCallSender.end(
+      conn,
+      this.peer.format,
+      this.id.localId,
+      this._nextIndex,
+      errorInfo
+    );
   }
   /**
    * Consume an AsyncIterable and send all items to the client.
    * Waits for the client's initial Ack before starting to pump items.
+   *
+   * When `isRealTime` is true, applies flow control based on `ackAdvance`:
+   * if the sender is `ackAdvance` items ahead of the last ACK, it enters
+   * skip mode — draining the source and discarding items until it finds
+   * one where `canSkipTo` returns true.
    */
   async writeFrom(source) {
     await this._started.promise;
+    const iterator = source[Symbol.asyncIterator]();
     try {
-      for await (const item of source) {
+      while (true) {
+        const next = await iterator.next();
+        if (next.done || this._ended) break;
+        const item = next.value;
+        if (this._nextIndex < this._lastAckedIndex + this.ackAdvance) {
+          this.sendItem(item);
+          continue;
+        }
+        if (!this.isRealTime) {
+          await this._waitForAckBudget();
+          if (this._ended) return;
+          this.sendItem(item);
+          continue;
+        }
+        let latestSkipTarget = this.canSkipTo(item) ? item : void 0;
+        let sourceExhausted = false;
+        while (this._nextIndex >= this._lastAckedIndex + this.ackAdvance) {
+          if (this._ended) return;
+          const n = await iterator.next();
+          if (n.done) {
+            sourceExhausted = true;
+            break;
+          }
+          if (this.canSkipTo(n.value)) {
+            latestSkipTarget = n.value;
+          }
+        }
         if (this._ended) return;
-        this.sendItem(item);
+        if (latestSkipTarget !== void 0) {
+          this.sendItem(latestSkipTarget);
+        }
+        if (sourceExhausted) {
+          if (!this._ended) this.sendEnd();
+          return;
+        }
       }
       if (!this._ended) {
         this.sendEnd();
@@ -788,6 +1369,14 @@ var RpcStreamSender = class {
       }
     }
   }
+  /** Wait until _nextIndex < _lastAckedIndex + ackAdvance. */
+  async _waitForAckBudget() {
+    while (this._nextIndex >= this._lastAckedIndex + this.ackAdvance) {
+      if (this._ended) return;
+      this._ackWaiting = new import_core5.PromiseSource();
+      await this._ackWaiting.promise;
+    }
+  }
   // -- IRpcObject --
   reconnect() {
   }
@@ -809,6 +1398,9 @@ var RpcRemoteObjectTracker = class {
   get(localId) {
     return this._objects.get(localId);
   }
+  keys() {
+    return this._objects.keys();
+  }
   unregister(obj) {
     this._objects.delete(obj.id.localId);
   }
@@ -820,10 +1412,8 @@ var RpcRemoteObjectTracker = class {
   }
   reconnectAll() {
     for (const obj of this._objects.values()) {
-      if (obj.allowReconnect)
-        obj.reconnect();
-      else
-        obj.disconnect();
+      if (obj.allowReconnect) obj.reconnect();
+      else obj.disconnect();
     }
   }
 };
@@ -841,6 +1431,9 @@ var RpcSharedObjectTracker = class {
   get(localId) {
     return this._objects.get(localId);
   }
+  keys() {
+    return this._objects.keys();
+  }
   unregister(obj) {
     this._objects.delete(obj.id.localId);
   }
@@ -864,8 +1457,132 @@ var RpcClientPeerReconnectDelayer = class extends import_core6.RetryDelayer {
   }
 };
 
+// src/rpc-serialization-format.ts
+var import_msgpack3 = require("@msgpack/msgpack");
+var RpcSerializationFormat = class _RpcSerializationFormat {
+  /** Create a reusable binary encoder for this format. Returns undefined for text formats. */
+  createEncoder() {
+    return void 0;
+  }
+  /** Create a reusable binary decoder for this format. Returns undefined for text formats. */
+  createDecoder() {
+    return void 0;
+  }
+  // --- Static registry ---
+  static _all = /* @__PURE__ */ new Map();
+  static register(format) {
+    _RpcSerializationFormat._all.set(format.key, format);
+  }
+  static get(key) {
+    const format = _RpcSerializationFormat._all.get(key);
+    if (!format)
+      throw new Error(`Unknown RPC serialization format: "${key}"`);
+    return format;
+  }
+  static tryGet(key) {
+    return _RpcSerializationFormat._all.get(key);
+  }
+};
+var RpcJsonSerializationFormat = class extends RpcSerializationFormat {
+  key;
+  isBinary = false;
+  isCompact = false;
+  constructor(key) {
+    super();
+    this.key = key;
+  }
+  serializeMessage(message, args) {
+    return serializeMessage(message, args);
+  }
+  deserializeTextMessage(raw) {
+    return deserializeMessage(raw);
+  }
+  splitBinaryFrame() {
+    throw new Error("Text format does not support binary frames");
+  }
+  serializeBinaryFrame() {
+    throw new Error("Text format does not support binary frames");
+  }
+};
+var RpcMessagePackSerializationFormat = class extends RpcSerializationFormat {
+  key;
+  isBinary = true;
+  isCompact = false;
+  constructor(key) {
+    super();
+    this.key = key;
+  }
+  serializeMessage(message, args, encoder) {
+    return serializeBinaryMessage(message, args, encoder);
+  }
+  deserializeTextMessage(raw) {
+    return deserializeMessage(raw);
+  }
+  splitBinaryFrame(frame, decoder) {
+    return splitBinaryFrame(frame, decoder);
+  }
+  serializeBinaryFrame(messages) {
+    return serializeBinaryFrame(messages);
+  }
+  createEncoder() {
+    return createBinaryEncoder();
+  }
+  createDecoder() {
+    return new import_msgpack3.Decoder();
+  }
+};
+var RpcMessagePackCompactSerializationFormat = class extends RpcSerializationFormat {
+  key;
+  isBinary = true;
+  isCompact = true;
+  constructor(key) {
+    super();
+    this.key = key;
+  }
+  serializeMessage(message, args, encoder, registry) {
+    return serializeCompactBinaryMessage(
+      message,
+      args,
+      registry,
+      encoder
+    );
+  }
+  deserializeTextMessage(raw) {
+    return deserializeMessage(raw);
+  }
+  splitBinaryFrame(frame, decoder, registry) {
+    return splitCompactBinaryFrame(frame, registry, decoder);
+  }
+  serializeBinaryFrame(messages) {
+    return serializeBinaryFrame(messages);
+  }
+  createEncoder() {
+    return createBinaryEncoder();
+  }
+  createDecoder() {
+    return new import_msgpack3.Decoder();
+  }
+};
+RpcSerializationFormat.register(new RpcJsonSerializationFormat("json5"));
+RpcSerializationFormat.register(new RpcJsonSerializationFormat("json5np"));
+RpcSerializationFormat.register(new RpcJsonSerializationFormat("njson5"));
+RpcSerializationFormat.register(new RpcJsonSerializationFormat("njson5np"));
+RpcSerializationFormat.register(
+  new RpcMessagePackSerializationFormat("msgpack6")
+);
+RpcSerializationFormat.register(
+  new RpcMessagePackSerializationFormat("mempack6")
+);
+RpcSerializationFormat.register(
+  new RpcMessagePackCompactSerializationFormat("msgpack6c")
+);
+RpcSerializationFormat.register(
+  new RpcMessagePackCompactSerializationFormat("mempack6c")
+);
+
 // src/rpc-peer.ts
 var DEFAULT_SERIALIZATION_FORMAT = "json5np";
+var RPC_CLOSE_CODE_UNSUPPORTED_FORMAT = 4001;
 var defaultConnectionUrlResolver = (peer) => {
   const sep = peer.ref.includes("?") ? "&" : "?";
   return peer.ref + sep + `clientId=${peer.clientId}&f=${peer.serializationFormat}`;
@@ -911,17 +1628,27 @@ var RpcPeer = class {
       this._startKeepAlive();
     });
   }
+  /** The serialization format used by this peer. Override in subclasses. */
+  get format() {
+    return RpcSerializationFormat.get("json5np");
+  }
   call(method, args, options) {
     const callId = this.outbound.nextId();
     const outboundCall = options?.outboundCallFactory ? options.outboundCallFactory(callId, method) : new RpcOutboundCall(callId, method);
-    const msg = serializeMessage(
-      { Method: method, RelatedId: callId, CallType: options?.callTypeId ?? 0 },
-      args
+    const envelope = {
+      Method: method,
+      RelatedId: callId,
+      CallType: options?.callTypeId ?? 0
+    };
+    outboundCall.serializedWireData = this.format.serializeMessage(
+      envelope,
+      args,
+      this._connection?.encoder,
+      this._hub.registry
     );
-    outboundCall.serializedMessage = msg;
     if (this._connection !== void 0) {
       this.outbound.register(outboundCall);
-      this._connection.send(msg);
+      this._sendWireData(outboundCall.serializedWireData);
     } else {
       this._pendingSends.push(outboundCall);
     }
@@ -935,12 +1662,16 @@ var RpcPeer = class {
           outboundCall.result.reject(new Error("Call cancelled."));
           outboundCall.onDisconnect();
           if (peer._connection !== void 0)
-            hub.systemCallSender.cancel(peer._connection, callId);
+            hub.systemCallSender.cancel(peer._connection, peer.format, callId);
         } else {
-          const idx = peer._pendingSends.findIndex((c) => c.callId === callId);
+          const idx = peer._pendingSends.findIndex(
+            (c) => c.callId === callId
+          );
           if (idx !== -1) {
             peer._pendingSends.splice(idx, 1);
-            outboundCall.result.reject(new Error("Call cancelled."));
+            outboundCall.result.reject(
+              new Error("Call cancelled.")
+            );
             outboundCall.onDisconnect();
           }
         }
@@ -952,8 +1683,14 @@ var RpcPeer = class {
   }
   callNoWait(method, args) {
     if (this._connection === void 0) return;
-    const msg = serializeMessage({ Method: method, RelatedId: 0 }, args);
-    this._connection.send(msg);
+    const envelope = { Method: method, RelatedId: 0 };
+    const wireData = this.format.serializeMessage(
+      envelope,
+      args,
+      this._connection.encoder,
+      this._hub.registry
+    );
+    this._sendWireData(wireData);
   }
   close() {
     this._stopKeepAlive();
@@ -972,23 +1709,41 @@ var RpcPeer = class {
   }
   /** Send any messages buffered while disconnected. Call after connection + handshake are ready. */
   _flushPendingSends() {
-    if (this._pendingSends.length === 0 || this._connection === void 0) return;
+    if (this._pendingSends.length === 0 || this._connection === void 0)
+      return;
     for (const call of this._pendingSends) {
       this.outbound.register(call);
-      this._connection.send(call.serializedMessage);
+      this._sendWireData(call.serializedWireData);
     }
     this._pendingSends.length = 0;
   }
+  /** Send pre-serialized wire data through the current connection. */
+  _sendWireData(data) {
+    if (this._connection === void 0) return;
+    if (typeof data === "string") {
+      this._connection.send(data);
+    } else {
+      this._connection.sendBinary(data);
+    }
+  }
   /** Override in subclasses to handle the remote peer's handshake response. */
   _onHandshakeReceived(_handshake) {
   }
-  _handleMessage(raw) {
-    const { message, args } = deserializeMessage(raw);
+  _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;
+    }
     const method = message.Method ?? "";
     if (method === RpcSystemCalls.handshake) {
       const handshake = args[0];
-      if (handshake !== void 0)
-        this._onHandshakeReceived(handshake);
+      if (handshake !== void 0) this._onHandshakeReceived(handshake);
       return;
     }
     if (method.startsWith("$sys")) {
@@ -1010,19 +1765,42 @@ var RpcPeer = class {
     if (serviceHost !== void 0) {
       void (async () => {
         try {
-          const context = this._connection !== void 0 ? { __rpcDispatch: true, callId: relatedId, connection: this._connection } : void 0;
-          const result = await serviceHost.dispatch(method, args, context);
+          const context = this._connection !== void 0 ? {
+            __rpcDispatch: true,
+            callId: relatedId,
+            connection: this._connection
+          } : void 0;
+          const result = await serviceHost.dispatch(
+            method,
+            args,
+            context
+          );
           if (methodDef?.stream === true && this._connection !== void 0) {
             const sender = new RpcStreamSender(this);
             this.sharedObjects.register(sender);
-            this._hub.systemCallSender.ok(this._connection, relatedId, sender.toRef());
+            this._hub.systemCallSender.ok(
+              this._connection,
+              this.format,
+              relatedId,
+              sender.toRef()
+            );
             void sender.writeFrom(result);
           } else if (!isNoWait && this._connection !== void 0) {
-            this._hub.systemCallSender.ok(this._connection, relatedId, result);
+            this._hub.systemCallSender.ok(
+              this._connection,
+              this.format,
+              relatedId,
+              result
+            );
           }
         } catch (e) {
           if (!isNoWait && this._connection !== void 0) {
-            this._hub.systemCallSender.error(this._connection, relatedId, e);
+            this._hub.systemCallSender.error(
+              this._connection,
+              this.format,
+              relatedId,
+              e
+            );
           }
         } finally {
           if (!isNoWait) {
@@ -1035,7 +1813,9 @@ var RpcPeer = class {
   _startKeepAlive() {
     this._keepAliveTimer = setInterval(() => {
       if (this._connection !== void 0) {
-        this._hub.systemCallSender.keepAlive(this._connection, this.outbound.activeCallIds());
+        this._hub.systemCallSender.keepAlive(this._connection, this.format, [
+          ...this.remoteObjects.keys()
+        ]);
       }
     }, 15e3);
   }
@@ -1071,6 +1851,8 @@ var RpcClientPeer = class extends RpcPeer {
   /** Builds the WebSocket URL for this peer. Replace to customize URL construction. */
   connectionUrlResolver = defaultConnectionUrlResolver;
   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();
   reconnectDelayer = new RpcClientPeerReconnectDelayer();
   reconnectsAtChanged = new import_core7.EventHandlerSet();
   get reconnectsAt() {
@@ -1081,10 +1863,15 @@ var RpcClientPeer = class extends RpcPeer {
     this._reconnectsAt = value;
     this.reconnectsAtChanged.trigger();
   }
+  _format;
   constructor(hub, url, serializationFormat) {
     super(url, hub);
     this.clientId = guidToBase64Url(this.id);
     this.serializationFormat = serializationFormat ?? DEFAULT_SERIALIZATION_FORMAT;
+    this._format = RpcSerializationFormat.get(this.serializationFormat);
+  }
+  get format() {
+    return this._format;
   }
   get connectionKind() {
     return this._connectionKind;
@@ -1098,18 +1885,39 @@ var RpcClientPeer = class extends RpcPeer {
   async run(wsFactory) {
     const connUrl = this.connectionUrlResolver(this);
     while (!this._disposed) {
+      let lastCloseCode = 0;
+      let lastCloseReason = "";
       try {
         const ws = wsFactory?.(connUrl) ?? new WebSocket(connUrl);
-        const conn = new RpcWebSocketConnection(ws);
+        const conn = new RpcWebSocketConnection(
+          ws,
+          this.format.isBinary,
+          this.format,
+          this._hub.registry
+        );
         this._connectionKind = 1 /* Connecting */;
+        conn.closed.add((ev) => {
+          lastCloseCode = ev.code;
+          lastCloseReason = ev.reason;
+        });
         this._pendingHandshake = new import_core7.PromiseSource();
         this.setupConnection(conn);
         this._connection = void 0;
-        const closedRejection = new Promise((_, reject) => conn.closed.add(() => reject(new Error("Connection failed"))));
+        const closedRejection = new Promise(
+          (_, reject) => conn.closed.add(
+            () => reject(new Error("Connection failed"))
+          )
+        );
         closedRejection.catch(() => {
         });
         await Promise.race([conn.whenConnected, closedRejection]);
-        this._hub.systemCallSender.handshake(conn, this.id, this._hub.hubId, ++this._handshakeIndex);
+        this._hub.systemCallSender.handshake(
+          conn,
+          this.format,
+          this.id,
+          this._hub.hubId,
+          ++this._handshakeIndex
+        );
         const remoteHandshake = await Promise.race([
           this._pendingHandshake.promise,
           closedRejection
@@ -1134,6 +1942,11 @@ var RpcClientPeer = class extends RpcPeer {
       }
       this._connectionKind = 0 /* Disconnected */;
       if (this._disposed) break;
+      if (lastCloseCode === RPC_CLOSE_CODE_UNSUPPORTED_FORMAT) {
+        this.unsupportedFormat.trigger({ reason: lastCloseReason });
+        this._disposed = true;
+        break;
+      }
       this._tryIndex++;
       const delay = this.reconnectDelayer.getDelay(this._tryIndex);
       if (delay.isLimitExceeded) {
@@ -1157,7 +1970,6 @@ var RpcClientPeer = class extends RpcPeer {
    *  Regular in-flight calls are re-sent transparently. */
   _reconnect(_isPeerChanged) {
     if (this._connection === void 0) return;
-    const conn = this._connection;
     if (_isPeerChanged) {
       this.remoteObjects.disconnectAll();
     } else {
@@ -1169,7 +1981,7 @@ var RpcClientPeer = class extends RpcPeer {
         call.onDisconnect();
         this.outbound.remove(call.callId);
       } else {
-        conn.send(call.serializedMessage);
+        this._sendWireData(call.serializedWireData);
       }
     }
     this._flushPendingSends();
@@ -1192,7 +2004,13 @@ var RpcServerPeer = class extends RpcPeer {
   }
   _onHandshakeReceived(_handshake) {
     if (this._connection !== void 0) {
-      this._hub.systemCallSender.handshake(this._connection, this.id, this._hub.hubId, 0);
+      this._hub.systemCallSender.handshake(
+        this._connection,
+        this.format,
+        this.id,
+        this._hub.hubId,
+        0
+      );
     }
   }
 };
@@ -1220,12 +2038,16 @@ var RpcServiceHost = class {
     for (const methodDef of def.methods.values()) {
       const fn = impl[methodDef.name];
       if (!fn) continue;
-      this._methods.set(wireMethodName(methodDef), { def: methodDef, fn });
+      this._methods.set(wireMethodName(methodDef), {
+        def: methodDef,
+        fn
+      });
     }
   }
   async dispatch(wireMethod, args, context) {
     const entry = this._methods.get(wireMethod);
-    if (entry === void 0) throw new Error(`Method not found: ${wireMethod}`);
+    if (entry === void 0)
+      throw new Error(`Method not found: ${wireMethod}`);
     if (context !== void 0 && entry.def.callTypeId !== 0) {
       return await entry.fn(...args, context);
     }
@@ -1264,6 +2086,539 @@ function rpcMethod(options) {
   };
 }
 
+// src/rpc-xxhash3.ts
+var U64_MASK = 0xffffffffffffffffn;
+var U32_MASK = 0xffffffffn;
+var PRIME32_1 = 2654435761;
+var PRIME32_2 = 2246822519;
+var PRIME32_3 = 3266489917;
+var PRIME64_1 = 0x9e3779b185ebca87n;
+var PRIME64_2 = 0xc2b2ae3d27d4eb4fn;
+var PRIME64_3 = 0x165667b19e3779f9n;
+var PRIME64_4 = 0x85ebca77c2b2ae63n;
+var PRIME64_5 = 0x27d4eb2f165667c5n;
+var XXH3_SECRET_SIZE_MIN = 136;
+var XXH_SECRET_DEFAULT_SIZE = 192;
+var STRIPE_LEN = 64;
+var XXH_SECRET_CONSUME_RATE = 8;
+var ACC_NB = STRIPE_LEN / 8;
+var XXH3_MIDSIZE_MAX = 240;
+var XXH3_MIDSIZE_STARTOFFSET = 3;
+var XXH3_MIDSIZE_LASTOFFSET = 17;
+var XXH_SECRET_LASTACC_START = 7;
+var XXH_SECRET_MERGEACCS_START = 11;
+var RRMXMX = 0x9fb21c651e98df25n;
+var DEFAULT_SECRET = new Uint8Array([
+  184,
+  254,
+  108,
+  57,
+  35,
+  164,
+  75,
+  190,
+  124,
+  1,
+  129,
+  44,
+  247,
+  33,
+  173,
+  28,
+  222,
+  212,
+  109,
+  233,
+  131,
+  144,
+  151,
+  219,
+  114,
+  64,
+  164,
+  164,
+  183,
+  179,
+  103,
+  31,
+  203,
+  121,
+  230,
+  78,
+  204,
+  192,
+  229,
+  120,
+  130,
+  90,
+  208,
+  125,
+  204,
+  255,
+  114,
+  33,
+  184,
+  8,
+  70,
+  116,
+  247,
+  67,
+  36,
+  142,
+  224,
+  53,
+  144,
+  230,
+  129,
+  58,
+  38,
+  76,
+  60,
+  40,
+  82,
+  187,
+  145,
+  195,
+  0,
+  203,
+  136,
+  208,
+  101,
+  139,
+  27,
+  83,
+  46,
+  163,
+  113,
+  100,
+  72,
+  151,
+  162,
+  13,
+  249,
+  78,
+  56,
+  25,
+  239,
+  70,
+  169,
+  222,
+  172,
+  216,
+  168,
+  250,
+  118,
+  63,
+  227,
+  156,
+  52,
+  63,
+  249,
+  220,
+  187,
+  199,
+  199,
+  11,
+  79,
+  29,
+  138,
+  81,
+  224,
+  75,
+  205,
+  180,
+  89,
+  49,
+  200,
+  159,
+  126,
+  201,
+  217,
+  120,
+  115,
+  100,
+  234,
+  197,
+  172,
+  131,
+  52,
+  211,
+  235,
+  195,
+  197,
+  129,
+  160,
+  255,
+  250,
+  19,
+  99,
+  235,
+  23,
+  13,
+  221,
+  81,
+  183,
+  240,
+  218,
+  73,
+  211,
+  22,
+  85,
+  38,
+  41,
+  212,
+  104,
+  158,
+  43,
+  22,
+  190,
+  88,
+  125,
+  71,
+  161,
+  252,
+  143,
+  248,
+  184,
+  209,
+  122,
+  208,
+  49,
+  206,
+  69,
+  203,
+  58,
+  143,
+  149,
+  22,
+  4,
+  40,
+  175,
+  215,
+  251,
+  202,
+  187,
+  75,
+  64,
+  126
+]);
+function u64(x) {
+  return x & U64_MASK;
+}
+function read32LE(buf, off) {
+  return (buf[off] | buf[off + 1] << 8 | buf[off + 2] << 16 | buf[off + 3] << 24) >>> 0;
+}
+function read64LE(buf, off) {
+  return BigInt(buf[off]) | BigInt(buf[off + 1]) << 8n | BigInt(buf[off + 2]) << 16n | BigInt(buf[off + 3]) << 24n | BigInt(buf[off + 4]) << 32n | BigInt(buf[off + 5]) << 40n | BigInt(buf[off + 6]) << 48n | BigInt(buf[off + 7]) << 56n;
+}
+function write64LE(buf, off, value) {
+  let x = u64(value);
+  for (let i = 0; i < 8; i++) {
+    buf[off + i] = Number(x & 0xffn);
+    x >>= 8n;
+  }
+}
+function swap32(x) {
+  return (x << 24 & 4278190080 | x << 8 & 16711680 | x >>> 8 & 65280 | x >>> 24 & 255) >>> 0;
+}
+function swap64(x) {
+  x = u64(x);
+  return x << 56n & 0xff00000000000000n | x << 40n & 0x00ff000000000000n | x << 24n & 0x0000ff0000000000n | x << 8n & 0x000000ff00000000n | x >> 8n & 0x00000000ff000000n | x >> 24n & 0x0000000000ff0000n | x >> 40n & 0x000000000000ff00n | x >> 56n & 0x00000000000000ffn;
+}
+function rotl64(x, amount) {
+  const r = BigInt(amount & 63);
+  return u64(x << r | x >> 64n - r);
+}
+function mul128Fold64(lhs, rhs) {
+  const product = u64(lhs) * u64(rhs);
+  return u64(product) ^ u64(product >> 64n);
+}
+function xxh64Avalanche(hash) {
+  let h = u64(hash);
+  h ^= h >> 33n;
+  h = u64(h * PRIME64_2);
+  h ^= h >> 29n;
+  h = u64(h * PRIME64_3);
+  h ^= h >> 32n;
+  return u64(h);
+}
+function xxh3Avalanche(hash) {
+  let h = u64(hash);
+  h ^= h >> 37n;
+  h = u64(h * 0x165667919e3779f9n);
+  h ^= h >> 32n;
+  return u64(h);
+}
+function len0(secret, seed) {
+  const acc = u64(seed ^ read64LE(secret, 56) ^ read64LE(secret, 64));
+  return xxh64Avalanche(acc);
+}
+function len1to3(input, length, secret, seed) {
+  const byte1 = input[0];
+  const byte2 = length > 1 ? input[1] : input[0];
+  const byte3 = input[length - 1];
+  const combined = (byte1 << 16 | byte2 << 24 | byte3 | length << 8) >>> 0;
+  const bitflip = u64(
+    BigInt((read32LE(secret, 0) ^ read32LE(secret, 4)) >>> 0) + seed
+  );
+  const value64 = u64(BigInt(combined) ^ bitflip);
+  return xxh64Avalanche(value64);
+}
+function len4to8(input, length, secret, seed) {
+  const inputHi = read32LE(input, 0);
+  const inputLo = read32LE(input, length - 4);
+  const input64 = BigInt(inputLo) | BigInt(inputHi) << 32n;
+  let acc = read64LE(secret, 8) ^ read64LE(secret, 16);
+  seed ^= BigInt(swap32(Number(seed & U32_MASK))) << 32n;
+  acc = u64(acc - seed);
+  acc ^= input64;
+  acc ^= rotl64(acc, 49) ^ rotl64(acc, 24);
+  acc = u64(acc * RRMXMX);
+  acc ^= (acc >> 35n) + BigInt(length);
+  acc = u64(acc * RRMXMX);
+  acc ^= acc >> 28n;
+  return u64(acc);
+}
+function len9to16(input, length, secret, seed) {
+  let inputLo = read64LE(secret, 24) ^ read64LE(secret, 32);
+  let inputHi = read64LE(secret, 40) ^ read64LE(secret, 48);
+  let acc = BigInt(length);
+  inputLo = u64(inputLo + seed);
+  inputHi = u64(inputHi - seed);
+  inputLo ^= read64LE(input, 0);
+  inputHi ^= read64LE(input, length - 8);
+  acc = u64(acc + swap64(inputLo));
+  acc = u64(acc + inputHi);
+  acc = u64(acc + mul128Fold64(inputLo, inputHi));
+  return xxh3Avalanche(acc);
+}
+function mix16B(input, inputOff, secret, secretOff, seed) {
+  let lhs = seed;
+  let rhs = u64(0n - seed);
+  lhs = u64(lhs + read64LE(secret, secretOff));
+  rhs = u64(rhs + read64LE(secret, secretOff + 8));
+  lhs ^= read64LE(input, inputOff);
+  rhs ^= read64LE(input, inputOff + 8);
+  return mul128Fold64(lhs, rhs);
+}
+function len17to128(input, length, secret, seed) {
+  let i = Math.floor((length - 1) / 32);
+  let acc = u64(BigInt(length) * PRIME64_1);
+  for (; i >= 0; i--) {
+    acc = u64(acc + mix16B(input, 16 * i, secret, 32 * i, seed));
+    acc = u64(
+      acc + mix16B(
+        input,
+        length - 16 * (i + 1),
+        secret,
+        32 * i + 16,
+        seed
+      )
+    );
+  }
+  return xxh3Avalanche(acc);
+}
+function len129to240(input, length, secret, seed) {
+  let acc = u64(BigInt(length) * PRIME64_1);
+  const nbRounds = Math.floor(length / 16);
+  for (let i = 0; i < 8; i++) {
+    acc = u64(acc + mix16B(input, 16 * i, secret, 16 * i, seed));
+  }
+  acc = xxh3Avalanche(acc);
+  for (let i = 8; i < nbRounds; i++) {
+    acc = u64(
+      acc + mix16B(
+        input,
+        16 * i,
+        secret,
+        16 * (i - 8) + XXH3_MIDSIZE_STARTOFFSET,
+        seed
+      )
+    );
+  }
+  acc = u64(
+    acc + mix16B(
+      input,
+      length - 16,
+      secret,
+      XXH3_SECRET_SIZE_MIN - XXH3_MIDSIZE_LASTOFFSET,
+      seed
+    )
+  );
+  return xxh3Avalanche(acc);
+}
+function hashShort(input, length, secret, seed) {
+  if (length <= 16) {
+    if (length > 8) return len9to16(input, length, secret, seed);
+    if (length >= 4) return len4to8(input, length, secret, seed);
+    if (length !== 0) return len1to3(input, length, secret, seed);
+    return len0(secret, seed);
+  }
+  if (length <= 128) return len17to128(input, length, secret, seed);
+  return len129to240(input, length, secret, seed);
+}
+function accumulate512(acc, input, inputOff, secret, secretOff) {
+  for (let i = 0; i < ACC_NB; i++) {
+    const dataVal = read64LE(input, inputOff + 8 * i);
+    const dataKey = dataVal ^ read64LE(secret, secretOff + 8 * i);
+    acc[i ^ 1] = u64(acc[i ^ 1] + dataVal);
+    const low32 = dataKey & U32_MASK;
+    const high32 = dataKey >> 32n;
+    acc[i] = u64(acc[i] + low32 * high32);
+  }
+}
+function scrambleAcc(acc, secret, secretOff) {
+  for (let i = 0; i < ACC_NB; i++) {
+    let x = acc[i];
+    x ^= x >> 47n;
+    x ^= read64LE(secret, secretOff + 8 * i);
+    x = u64(x * BigInt(PRIME32_1));
+    acc[i] = x;
+  }
+}
+function accumulateLoop(acc, input, inputOff, secret, secretOff, nbStripes) {
+  for (let n = 0; n < nbStripes; n++) {
+    accumulate512(
+      acc,
+      input,
+      inputOff + n * STRIPE_LEN,
+      secret,
+      secretOff + 8 * n
+    );
+  }
+}
+function mix2Accs(acc, accOff, secret, secretOff) {
+  return mul128Fold64(
+    acc[accOff] ^ read64LE(secret, secretOff),
+    acc[accOff + 1] ^ read64LE(secret, secretOff + 8)
+  );
+}
+function mergeAccs(acc, key, keyOff, start) {
+  let result = start;
+  for (let i = 0; i < 4; i++) {
+    result = u64(result + mix2Accs(acc, 2 * i, key, keyOff + 16 * i));
+  }
+  return xxh3Avalanche(result);
+}
+function hashLong(input, length, secret, secretSize) {
+  const nbRounds = Math.floor(
+    (secretSize - STRIPE_LEN) / XXH_SECRET_CONSUME_RATE
+  );
+  const blockLen = STRIPE_LEN * nbRounds;
+  const nbBlocks = Math.floor((length - 1) / blockLen);
+  const nbStripes = Math.floor(
+    (length - 1 - blockLen * nbBlocks) / STRIPE_LEN
+  );
+  const acc = [
+    BigInt(PRIME32_3),
+    PRIME64_1,
+    PRIME64_2,
+    PRIME64_3,
+    PRIME64_4,
+    BigInt(PRIME32_2),
+    PRIME64_5,
+    BigInt(PRIME32_1)
+  ];
+  for (let n = 0; n < nbBlocks; n++) {
+    accumulateLoop(acc, input, n * blockLen, secret, 0, nbRounds);
+    scrambleAcc(acc, secret, secretSize - STRIPE_LEN);
+  }
+  accumulateLoop(acc, input, nbBlocks * blockLen, secret, 0, nbStripes);
+  accumulate512(
+    acc,
+    input,
+    length - STRIPE_LEN,
+    secret,
+    secretSize - STRIPE_LEN - XXH_SECRET_LASTACC_START
+  );
+  return mergeAccs(
+    acc,
+    secret,
+    XXH_SECRET_MERGEACCS_START,
+    u64(BigInt(length) * PRIME64_1)
+  );
+}
+function hashLongWithSeed(input, length, seed) {
+  const secret = new Uint8Array(XXH_SECRET_DEFAULT_SIZE);
+  for (let i = 0; i < XXH_SECRET_DEFAULT_SIZE / 16; i++) {
+    const off = 16 * i;
+    write64LE(secret, off, u64(read64LE(DEFAULT_SECRET, off) + seed));
+    write64LE(
+      secret,
+      off + 8,
+      u64(read64LE(DEFAULT_SECRET, off + 8) - seed)
+    );
+  }
+  return hashLong(input, length, secret, secret.length);
+}
+var textEncoder2 = new TextEncoder();
+function xxh3_64(input, seed = 0n) {
+  const len = input.length;
+  if (len <= XXH3_MIDSIZE_MAX) {
+    return hashShort(input, len, DEFAULT_SECRET, u64(seed));
+  }
+  return hashLongWithSeed(input, len, u64(seed));
+}
+function xxh3_64str(input, seed = 0n) {
+  return xxh3_64(textEncoder2.encode(input), seed);
+}
+function computeMethodHash(methodName) {
+  const utf8 = textEncoder2.encode(methodName);
+  const prefixValue = Math.imul(67211, utf8.length) >>> 0;
+  const prefixed = new Uint8Array(4 + utf8.length);
+  prefixed[0] = prefixValue & 255;
+  prefixed[1] = prefixValue >>> 8 & 255;
+  prefixed[2] = prefixValue >>> 16 & 255;
+  prefixed[3] = prefixValue >>> 24 & 255;
+  prefixed.set(utf8, 4);
+  const hash64 = xxh3_64(prefixed);
+  return Number(hash64 & 0xffffffffn) | 0;
+}
+
+// src/rpc-method-registry.ts
+var RpcMethodRegistry = class {
+  _nameToHash = /* @__PURE__ */ new Map();
+  _hashToName = /* @__PURE__ */ new Map();
+  /** Register a method name and compute its hash. */
+  register(methodName) {
+    if (this._nameToHash.has(methodName)) return;
+    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}`
+      );
+      return;
+    }
+    this._nameToHash.set(methodName, hash);
+    this._hashToName.set(hash, methodName);
+  }
+  /** Register all wire method names from a service definition. */
+  registerService(serviceName, methods) {
+    for (const [, def] of methods) {
+      const wireName = `${serviceName}.${def.name}:${def.wireArgCount}`;
+      this.register(wireName);
+    }
+  }
+  /** Get the hash for a method name. Computes on demand if not registered. */
+  getHash(methodName) {
+    let hash = this._nameToHash.get(methodName);
+    if (hash === void 0) {
+      this.register(methodName);
+      hash = this._nameToHash.get(methodName);
+    }
+    return hash;
+  }
+  /** Get the method name for a hash. Returns undefined if not registered. */
+  getName(hash) {
+    return this._hashToName.get(hash);
+  }
+  /** Get the hash for a method name, throwing if not registered. */
+  requireHash(methodName) {
+    return this.getHash(methodName);
+  }
+};
+
 // src/rpc-hub.ts
 var RpcHub = class {
   hubId;
@@ -1271,9 +2626,16 @@ var RpcHub = class {
   serviceHost;
   systemCallSender = new RpcSystemCallSender();
   systemCallHandler = new RpcSystemCallHandler();
+  /** Method registry for compact format hash ↔ name resolution.
+   *  Created lazily, populated by addService/addClient. */
+  registry = new RpcMethodRegistry();
   constructor(hubId) {
     this.hubId = hubId ?? crypto.randomUUID();
     this.serviceHost = new RpcServiceHost();
+    this.systemCallSender.registry = this.registry;
+    for (const methodName of Object.values(RpcSystemCalls)) {
+      this.registry.register(methodName);
+    }
   }
   addPeer(peer) {
     this.peers.set(peer.ref, peer);
@@ -1311,10 +2673,12 @@ var RpcHub = class {
       wrappedImpl[methodDef.name] = methodDef.callTypeId !== 0 ? this._wrapServerMethod(methodDef, fn, impl) : fn;
     }
     this.serviceHost.register(def, wrappedImpl);
+    this.registry.registerService(def.name, def.methods);
   }
   /** Create a typed client proxy for a service on a remote peer. */
   addClient(peer, defOrContract) {
     const def = this._resolveServiceDef(defOrContract);
+    this.registry.registerService(def.name, def.methods);
     const overloads = /* @__PURE__ */ new Map();
     for (const methodDef of def.methods.values()) {
       let byArgCount = overloads.get(methodDef.name);
@@ -1322,7 +2686,10 @@ var RpcHub = class {
         byArgCount = /* @__PURE__ */ new Map();
         overloads.set(methodDef.name, byArgCount);
       }
-      byArgCount.set(methodDef.argCount, this._createClientMethod(peer, methodDef));
+      byArgCount.set(
+        methodDef.argCount,
+        this._createClientMethod(peer, methodDef)
+      );
     }
     const methods = /* @__PURE__ */ new Map();
     for (const [name, byArgCount] of overloads) {
@@ -1331,7 +2698,10 @@ var RpcHub = class {
       } else {
         methods.set(name, (...args) => {
           const fn = byArgCount.get(args.length);
-          if (!fn) throw new Error(`No overload of ${name} accepts ${args.length} arguments`);
+          if (!fn)
+            throw new Error(
+              `No overload of ${name} accepts ${args.length} arguments`
+            );
           return fn(...args);
         });
       }
@@ -1347,7 +2717,8 @@ var RpcHub = class {
   /** Build an RpcServiceDef from decorator metadata on a contract class. Override in FusionHub for compute support. */
   _buildServiceDef(cls) {
     const svcMeta = getServiceMeta(cls);
-    if (svcMeta === void 0) throw new Error("Contract class missing @rpcService metadata");
+    if (svcMeta === void 0)
+      throw new Error("Contract class missing @rpcService metadata");
     const methodsMeta = getMethodsMeta(cls) ?? {};
     const methods = /* @__PURE__ */ new Map();
     for (const [name, meta] of Object.entries(methodsMeta)) {
@@ -1390,7 +2761,10 @@ var RpcHub = class {
         const outboundCall = peer.call(wireName, callArgs);
         const result = await outboundCall.result.promise;
         const ref = parseStreamRef(result);
-        if (!ref) throw new Error(`Expected stream reference, got: ${JSON.stringify(result)}`);
+        if (!ref)
+          throw new Error(
+            `Expected stream reference, got: ${JSON.stringify(result)}`
+          );
         const stream = new RpcStream(ref, peer);
         peer.remoteObjects.register(stream);
         return stream;
@@ -1429,7 +2803,10 @@ function createRpcClient(peer, serviceDef) {
       }
       methods.set(name, (...args) => {
         const fn = fns.get(args.length);
-        if (!fn) throw new Error(`No overload of ${name} accepts ${args.length} arguments`);
+        if (!fn)
+          throw new Error(
+            `No overload of ${name} accepts ${args.length} arguments`
+          );
         return fn(...args);
       });
     }
@@ -1474,12 +2851,10 @@ function getStateDescription(state, useLastError = false) {
     case 1 /* JustDisconnected */:
       return "Just disconnected, reconnecting...";
     case 2 /* Disconnected */:
-      if (state.reconnectsIn > 0)
-        break;
+      if (state.reconnectsIn > 0) break;
       return "Reconnecting...";
   }
-  if (state.lastError == null || !useLastError)
-    return "Disconnected.";
+  if (state.lastError == null || !useLastError) return "Disconnected.";
   let message = state.lastError.message.trim();
   if (!(message.endsWith(".") || message.endsWith("!") || message.endsWith("?")))
     message += ".";
@@ -1510,7 +2885,9 @@ var RpcPeerStateMonitor = class {
   _onDisconnected = (ev) => {
     const wasConnected = this._rawConnected;
     this._rawConnected = false;
-    this._lastError = new Error(`Connection closed: ${ev.reason} (code ${ev.code})`);
+    this._lastError = new Error(
+      `Connection closed: ${ev.reason} (code ${ev.code})`
+    );
     if (wasConnected) {
       this._disconnectedAt = Date.now();
     }
@@ -1527,16 +2904,26 @@ var RpcPeerStateMonitor = class {
     this._rawConnected = peer.isConnected;
     if (this._rawConnected) {
       this._connectedAt = Date.now();
-      this._state = { kind: 3 /* JustConnected */, reconnectsIn: 0 };
+      this._state = {
+        kind: 3 /* JustConnected */,
+        reconnectsIn: 0
+      };
     } else {
       this._disconnectedAt = Date.now();
-      this._state = { kind: 1 /* JustDisconnected */, reconnectsIn: 0 };
+      this._state = {
+        kind: 1 /* JustDisconnected */,
+        reconnectsIn: 0
+      };
     }
     peer.connected.add(this._onConnected);
     peer.disconnected.add(this._onDisconnected);
     peer.reconnectsAtChanged.add(this._onReconnectsAtChanged);
-    peer.reconnectDelayer.cancelDelaysChanged.add(this._onCancelDelaysChanged);
-    this._scheduleRecompute(this._rawConnected ? JustConnectedPeriodMs : JustDisconnectedPeriodMs);
+    peer.reconnectDelayer.cancelDelaysChanged.add(
+      this._onCancelDelaysChanged
+    );
+    this._scheduleRecompute(
+      this._rawConnected ? JustConnectedPeriodMs : JustDisconnectedPeriodMs
+    );
   }
   get state() {
     return this._state;
@@ -1549,7 +2936,9 @@ var RpcPeerStateMonitor = class {
     this.peer.connected.remove(this._onConnected);
     this.peer.disconnected.remove(this._onDisconnected);
     this.peer.reconnectsAtChanged.remove(this._onReconnectsAtChanged);
-    this.peer.reconnectDelayer.cancelDelaysChanged.remove(this._onCancelDelaysChanged);
+    this.peer.reconnectDelayer.cancelDelaysChanged.remove(
+      this._onCancelDelaysChanged
+    );
   }
   _recompute() {
     if (this._timer !== void 0) {
@@ -1561,24 +2950,46 @@ var RpcPeerStateMonitor = class {
     if (this._rawConnected) {
       const connectedFor = now - this._connectedAt;
       if (connectedFor < JustConnectedPeriodMs) {
-        newState = { kind: 3 /* JustConnected */, reconnectsIn: 0 };
+        newState = {
+          kind: 3 /* JustConnected */,
+          reconnectsIn: 0
+        };
         this._scheduleRecompute(JustConnectedPeriodMs - connectedFor);
       } else {
-        newState = { kind: 0 /* Connected */, reconnectsIn: 0 };
+        newState = {
+          kind: 0 /* Connected */,
+          reconnectsIn: 0
+        };
       }
     } else {
       const disconnectedFor = now - this._disconnectedAt;
       if (disconnectedFor < JustDisconnectedPeriodMs) {
-        newState = { kind: 1 /* JustDisconnected */, lastError: this._lastError, reconnectsIn: 0 };
-        this._scheduleRecompute(JustDisconnectedPeriodMs - disconnectedFor);
+        newState = {
+          kind: 1 /* JustDisconnected */,
+          lastError: this._lastError,
+          reconnectsIn: 0
+        };
+        this._scheduleRecompute(
+          JustDisconnectedPeriodMs - disconnectedFor
+        );
       } else {
         const reconnectsAt = this.peer.reconnectsAt;
         const reconnectsIn = reconnectsAt > 0 ? Math.max(0, reconnectsAt - now) : 0;
         if (reconnectsIn < MinReconnectsInMs) {
-          newState = { kind: 2 /* Disconnected */, lastError: this._lastError, reconnectsIn: 0 };
+          newState = {
+            kind: 2 /* Disconnected */,
+            lastError: this._lastError,
+            reconnectsIn: 0
+          };
         } else {
-          newState = { kind: 2 /* Disconnected */, lastError: this._lastError, reconnectsIn };
-          this._scheduleRecompute(Math.min(1e3, reconnectsIn - MinReconnectsInMs));
+          newState = {
+            kind: 2 /* Disconnected */,
+            lastError: this._lastError,
+            reconnectsIn
+          };
+          this._scheduleRecompute(
+            Math.min(1e3, reconnectsIn - MinReconnectsInMs)
+          );
         }
       }
     }
@@ -1593,10 +3004,13 @@ var RpcPeerStateMonitor = class {
   }
   _scheduleRecompute(delayMs) {
     if (this._timer !== void 0) clearTimeout(this._timer);
-    this._timer = setTimeout(() => {
-      this._timer = void 0;
-      this._recompute();
-    }, Math.max(0, delayMs));
+    this._timer = setTimeout(
+      () => {
+        this._timer = void 0;
+        this._recompute();
+      },
+      Math.max(0, delayMs)
+    );
   }
 };
 // Annotate the CommonJS export names for ESM import in node:
@@ -1605,13 +3019,18 @@ var RpcPeerStateMonitor = class {
   DEFAULT_SERIALIZATION_FORMAT,
   ENVELOPE_DELIMITER,
   FRAME_DELIMITER,
+  RPC_CLOSE_CODE_UNSUPPORTED_FORMAT,
   RpcCallTypeId,
   RpcClientPeer,
   RpcClientPeerReconnectDelayer,
   RpcHub,
   RpcInboundCall,
   RpcInboundCallTracker,
+  RpcJsonSerializationFormat,
   RpcMessageChannelConnection,
+  RpcMessagePackCompactSerializationFormat,
+  RpcMessagePackSerializationFormat,
+  RpcMethodRegistry,
   RpcObjectKind,
   RpcOutboundCall,
   RpcOutboundCallTracker,
@@ -1620,6 +3039,7 @@ var RpcPeerStateMonitor = class {
   RpcPeerStateKind,
   RpcPeerStateMonitor,
   RpcRemoteObjectTracker,
+  RpcSerializationFormat,
   RpcServerPeer,
   RpcServiceHost,
   RpcSharedObjectTracker,
@@ -1631,10 +3051,16 @@ var RpcPeerStateMonitor = class {
   RpcType,
   RpcWebSocketConnection,
   WebSocketState,
+  computeMethodHash,
+  createBinaryEncoder,
   createMessageChannelPair,
   createRpcClient,
+  defaultBinaryDecoder,
+  defaultBinaryEncoder,
   defaultConnectionUrlResolver,
   defineRpcService,
+  deserializeBinaryMessage,
+  deserializeCompactBinaryMessage,
   deserializeMessage,
   getMethodsMeta,
   getServiceMeta,
@@ -1645,9 +3071,16 @@ var RpcPeerStateMonitor = class {
   resolveStreamRefs,
   rpcMethod,
   rpcService,
+  serializeBinaryFrame,
+  serializeBinaryMessage,
+  serializeCompactBinaryMessage,
   serializeFrame,
   serializeMessage,
+  splitBinaryFrame,
+  splitCompactBinaryFrame,
   splitFrame,
-  wireMethodName
+  wireMethodName,
+  xxh3_64,
+  xxh3_64str
 });
 //# sourceMappingURL=index.cjs.map