@actuallab/rpc 12.1.62

package/dist/index.js

@@ -0,0 +1,1133 @@
+// src/rpc-message.ts
+var RpcCallTypeId = /* @__PURE__ */ ((RpcCallTypeId2) => {
+  RpcCallTypeId2[RpcCallTypeId2["Regular"] = 0] = "Regular";
+  RpcCallTypeId2[RpcCallTypeId2["Reliable"] = 1] = "Reliable";
+  return RpcCallTypeId2;
+})(RpcCallTypeId || {});
+var RpcSystemCalls = {
+  handshake: "$sys.Handshake:1",
+  ok: "$sys.Ok:1",
+  error: "$sys.Error:1",
+  cancel: "$sys.Cancel:0",
+  keepAlive: "$sys.KeepAlive:1",
+  reconnect: "$sys.Reconnect:3"
+};
+var ENVELOPE_DELIMITER = "\n";
+var ARG_DELIMITER = "";
+var FRAME_DELIMITER = "\n";
+
+// src/rpc-serialization.ts
+function serializeMessage(message, args) {
+  const envelope = JSON.stringify(message);
+  if (args === void 0 || args.length === 0) {
+    return envelope + ENVELOPE_DELIMITER;
+  }
+  const argsStr = args.map((a) => JSON.stringify(a)).join(ARG_DELIMITER);
+  return envelope + ENVELOPE_DELIMITER + argsStr;
+}
+function serializeFrame(messages) {
+  return messages.join(FRAME_DELIMITER);
+}
+function splitFrame(frame) {
+  return frame.split(FRAME_DELIMITER);
+}
+function deserializeMessage(raw) {
+  const nlIndex = raw.indexOf(ENVELOPE_DELIMITER);
+  if (nlIndex === -1) {
+    return { message: JSON.parse(raw), args: [] };
+  }
+  const envelopeStr = raw.substring(0, nlIndex);
+  const argsStr = raw.substring(nlIndex + 1);
+  const message = JSON.parse(envelopeStr);
+  if (argsStr.length === 0) {
+    return { message, args: [] };
+  }
+  const args = argsStr.split(ARG_DELIMITER).map((s) => {
+    try {
+      return JSON.parse(s);
+    } catch {
+      return s;
+    }
+  });
+  return { message, args };
+}
+
+// src/rpc-connection.ts
+import { PromiseSource, EventHandlerSet } from "@actuallab/core";
+var WebSocketState = {
+  CONNECTING: 0,
+  OPEN: 1,
+  CLOSING: 2,
+  CLOSED: 3
+};
+var RpcWebSocketConnection = class {
+  _ws;
+  _sendBuffer = [];
+  _connected = new PromiseSource();
+  messageReceived = new EventHandlerSet();
+  closed = new EventHandlerSet();
+  error = new EventHandlerSet();
+  constructor(ws) {
+    this._ws = ws;
+    if (ws.readyState === WebSocketState.OPEN) {
+      this._connected.resolve();
+      this._flush();
+    }
+    ws.onopen = () => {
+      this._connected.resolve();
+      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);
+      }
+    };
+    ws.onclose = (ev) => {
+      this.closed.trigger({ code: ev.code, reason: ev.reason });
+    };
+    ws.onerror = (ev) => {
+      this.error.trigger(ev);
+    };
+  }
+  get isOpen() {
+    return this._ws.readyState === WebSocketState.OPEN;
+  }
+  get whenConnected() {
+    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 {
+    }
+  }
+  sendBatch(messages) {
+    const frame = serializeFrame(messages);
+    this.send(frame);
+  }
+  close(code, reason) {
+    this._ws.close(code, reason);
+  }
+  _flush() {
+    if (this._sendBuffer.length === 0) return;
+    const frame = serializeFrame(this._sendBuffer);
+    this._sendBuffer = [];
+    try {
+      this._ws.send(frame);
+    } catch {
+    }
+  }
+};
+
+// src/rpc-message-channel-connection.ts
+import { EventHandlerSet as EventHandlerSet2 } from "@actuallab/core";
+var RpcMessageChannelConnection = class {
+  _port;
+  _open = true;
+  messageReceived = new EventHandlerSet2();
+  closed = new EventHandlerSet2();
+  whenConnected = Promise.resolve();
+  // immediately connected
+  constructor(port) {
+    this._port = port;
+    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);
+    };
+  }
+  get isOpen() {
+    return this._open;
+  }
+  send(serializedMessage) {
+    if (!this._open) return;
+    try {
+      this._port.postMessage(serializedMessage);
+    } catch {
+    }
+  }
+  close(code, reason) {
+    if (!this._open) return;
+    this._open = false;
+    this._port.close();
+    this.closed.trigger({ code: code ?? 1e3, reason: reason ?? "" });
+  }
+};
+function createMessageChannelPair() {
+  const channel = new MessageChannel();
+  return [
+    new RpcMessageChannelConnection(channel.port1),
+    new RpcMessageChannelConnection(channel.port2)
+  ];
+}
+
+// src/rpc-service-def.ts
+var RpcType = {
+  object: /* @__PURE__ */ Symbol("object"),
+  stream: /* @__PURE__ */ Symbol("stream"),
+  void: /* @__PURE__ */ Symbol("void")
+};
+function wireMethodName(def) {
+  return `${def.serviceName}.${def.name}:${def.wireArgCount}`;
+}
+function defineRpcService(name, methods, options) {
+  const ctOffset = options?.ctOffset ?? 0;
+  const map = /* @__PURE__ */ new Map();
+  for (const [key, input] of Object.entries(methods)) {
+    const colonIndex = key.indexOf(":");
+    const cleanName = colonIndex >= 0 ? key.substring(0, colonIndex) : key;
+    const wireArgCount = input.args.length + ctOffset;
+    const mapKey = `${cleanName}:${wireArgCount}`;
+    map.set(mapKey, {
+      name: cleanName,
+      serviceName: name,
+      argCount: input.args.length,
+      wireArgCount,
+      callTypeId: input.callTypeId ?? 0,
+      stream: input.stream ?? input.returns === RpcType.stream,
+      noWait: input.noWait ?? false
+    });
+  }
+  return { name, methods: map };
+}
+
+// src/rpc-call-tracker.ts
+import { PromiseSource as PromiseSource2 } from "@actuallab/core";
+var RpcOutboundCall = class {
+  callId;
+  method;
+  result = new PromiseSource2();
+  /** 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 = "";
+  constructor(callId, method) {
+    this.callId = callId;
+    this.method = method;
+  }
+  /** Called when the connection is lost. Subclasses can override to resolve invalidation promises. */
+  onDisconnect() {
+  }
+};
+var RpcOutboundCallTracker = class {
+  _calls = /* @__PURE__ */ new Map();
+  _nextId = 1;
+  get size() {
+    return this._calls.size;
+  }
+  nextId() {
+    return this._nextId++;
+  }
+  register(call) {
+    this._calls.set(call.callId, call);
+  }
+  get(callId) {
+    return this._calls.get(callId);
+  }
+  remove(callId) {
+    const call = this._calls.get(callId);
+    if (call !== void 0) this._calls.delete(callId);
+    return call;
+  }
+  values() {
+    return this._calls.values();
+  }
+  activeCallIds() {
+    return [...this._calls.keys()];
+  }
+  /** Reject all pending calls with the given error.
+   *  Stage-3 compute calls (result resolved, awaiting invalidation) are kept in the tracker. */
+  rejectAll(error) {
+    for (const [id, call] of this._calls) {
+      if (!call.removeOnOk && call.result.isCompleted) {
+        continue;
+      }
+      call.result.reject(error);
+      call.onDisconnect();
+      this._calls.delete(id);
+    }
+  }
+  /** Invalidate all remaining stage-3 calls (on reconnect or peer stop). */
+  invalidateAll() {
+    for (const call of this._calls.values()) {
+      call.onDisconnect();
+    }
+    this._calls.clear();
+  }
+  clear() {
+    this._calls.clear();
+  }
+};
+var RpcInboundCall = class {
+  callId;
+  method;
+  args;
+  constructor(callId, method, args) {
+    this.callId = callId;
+    this.method = method;
+    this.args = args;
+  }
+};
+var RpcInboundCallTracker = class {
+  _calls = /* @__PURE__ */ new Map();
+  get size() {
+    return this._calls.size;
+  }
+  register(call) {
+    this._calls.set(call.callId, call);
+  }
+  get(callId) {
+    return this._calls.get(callId);
+  }
+  remove(callId) {
+    const call = this._calls.get(callId);
+    if (call !== void 0) this._calls.delete(callId);
+    return call;
+  }
+  clear() {
+    this._calls.clear();
+  }
+};
+
+// src/rpc-system-call-handler.ts
+function handleSystemCall(message, args, outboundTracker, inboundTracker) {
+  const method = message.Method;
+  const relatedId = message.RelatedId ?? 0;
+  switch (method) {
+    case RpcSystemCalls.ok: {
+      const call = outboundTracker.get(relatedId);
+      if (call !== void 0) {
+        if (call.removeOnOk) {
+          outboundTracker.remove(relatedId);
+        }
+        call.result.resolve(args[0]);
+      }
+      break;
+    }
+    case RpcSystemCalls.error: {
+      const call = outboundTracker.remove(relatedId);
+      if (call !== void 0) {
+        const errorInfo = args[0];
+        const msg = errorInfo?.Message ?? errorInfo?.message ?? "RPC error";
+        call.result.reject(new Error(msg));
+      }
+      break;
+    }
+    case RpcSystemCalls.cancel: {
+      inboundTracker.remove(relatedId);
+      break;
+    }
+    case RpcSystemCalls.keepAlive: {
+      break;
+    }
+  }
+}
+
+// src/rpc-system-call-sender.ts
+var RpcSystemCallSender = class {
+  handshake(conn, peerId, hubId, index) {
+    const msg = serializeMessage({ Method: RpcSystemCalls.handshake }, [{
+      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);
+  }
+  error(conn, relatedId, error) {
+    const message = error instanceof Error ? error.message : String(error);
+    const msg = serializeMessage(
+      { 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);
+  }
+};
+
+// src/rpc-peer.ts
+import { EventHandlerSet as EventHandlerSet3, PromiseSource as PromiseSource3 } from "@actuallab/core";
+
+// src/rpc-client-peer-reconnect-delayer.ts
+import { RetryDelaySeq, RetryDelayer } from "@actuallab/core";
+var RpcClientPeerReconnectDelayer = class extends RetryDelayer {
+  constructor() {
+    super();
+    this.delays = RetryDelaySeq.exp(1e3, 6e4);
+  }
+};
+
+// src/rpc-peer.ts
+var DEFAULT_SERIALIZATION_FORMAT = "json5np";
+var defaultConnectionUrlResolver = (peer) => {
+  const sep = peer.ref.includes("?") ? "&" : "?";
+  return peer.ref + sep + `clientId=${peer.clientId}&f=${peer.serializationFormat}`;
+};
+var RpcPeer = class {
+  /** Routing/addressing key — used as key in hub.peers (URL for clients, "server://{uuid}" for servers). */
+  ref;
+  /** Auto-generated GUID — used in handshakes only. */
+  id = crypto.randomUUID();
+  _hub;
+  _connection;
+  outbound = new RpcOutboundCallTracker();
+  inbound = new RpcInboundCallTracker();
+  connected = new EventHandlerSet3();
+  disconnected = new EventHandlerSet3();
+  _pendingSends = [];
+  _keepAliveTimer;
+  constructor(ref, hub) {
+    this.ref = ref;
+    this._hub = hub;
+  }
+  get connection() {
+    return this._connection;
+  }
+  get isConnected() {
+    return this._connection?.isOpen ?? false;
+  }
+  setupConnection(conn) {
+    this._connection = conn;
+    conn.messageReceived.add((raw) => this._handleMessage(raw));
+    conn.closed.add((ev) => {
+      this._connection = void 0;
+      this._stopKeepAlive();
+      this.disconnected.trigger(ev);
+    });
+    void conn.whenConnected.then(() => {
+      this.connected.trigger();
+      this._startKeepAlive();
+    });
+  }
+  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
+    );
+    outboundCall.serializedMessage = msg;
+    if (this._connection !== void 0) {
+      this.outbound.register(outboundCall);
+      this._connection.send(msg);
+    } else {
+      this._pendingSends.push(outboundCall);
+    }
+    const signal = options?.signal;
+    if (signal !== void 0) {
+      const peer = this;
+      const hub = this._hub;
+      const tracker = this.outbound;
+      const onAbort = () => {
+        if (tracker.remove(callId) !== void 0) {
+          outboundCall.result.reject(new Error("Call cancelled."));
+          outboundCall.onDisconnect();
+          if (peer._connection !== void 0)
+            hub.systemCallSender.cancel(peer._connection, callId);
+        } else {
+          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.onDisconnect();
+          }
+        }
+      };
+      signal.addEventListener("abort", onAbort, { once: true });
+      outboundCall.result.promise.then(() => signal.removeEventListener("abort", onAbort)).catch(() => signal.removeEventListener("abort", onAbort));
+    }
+    return outboundCall;
+  }
+  callNoWait(method, args) {
+    if (this._connection === void 0) return;
+    const msg = serializeMessage({ Method: method, RelatedId: 0 }, args);
+    this._connection.send(msg);
+  }
+  close() {
+    this._stopKeepAlive();
+    for (const call of this._pendingSends) {
+      if (!call.result.isCompleted)
+        call.result.reject(new Error("Peer closed."));
+      call.onDisconnect();
+    }
+    this._pendingSends.length = 0;
+    this.outbound.rejectAll(new Error("Peer closed."));
+    this.outbound.invalidateAll();
+    this._connection?.close();
+    this._hub.peers.delete(this.ref);
+  }
+  /** Send any messages buffered while disconnected. Call after connection + handshake are ready. */
+  _flushPendingSends() {
+    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._pendingSends.length = 0;
+  }
+  /** Override in subclasses to handle the remote peer's handshake response. */
+  _onHandshakeReceived(_handshake) {
+  }
+  _handleMessage(raw) {
+    const { message, args } = deserializeMessage(raw);
+    const method = message.Method ?? "";
+    if (method === RpcSystemCalls.handshake) {
+      const handshake = args[0];
+      if (handshake !== void 0)
+        this._onHandshakeReceived(handshake);
+      return;
+    }
+    if (method.startsWith("$sys")) {
+      this._hub.handleSystemCall(message, args, this.outbound, this.inbound);
+      return;
+    }
+    this._handleInbound(message, args);
+  }
+  _handleInbound(message, args) {
+    const method = message.Method ?? "";
+    const relatedId = message.RelatedId ?? 0;
+    const call = new RpcInboundCall(relatedId, method, args);
+    const methodDef = this._hub.serviceHost.getMethodDef(method);
+    const isNoWait = methodDef?.noWait === true;
+    if (!isNoWait) {
+      this.inbound.register(call);
+    }
+    const serviceHost = this._hub.serviceHost;
+    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);
+          if (!isNoWait && this._connection !== void 0) {
+            this._hub.systemCallSender.ok(this._connection, relatedId, result);
+          }
+        } catch (e) {
+          if (!isNoWait && this._connection !== void 0) {
+            this._hub.systemCallSender.error(this._connection, relatedId, e);
+          }
+        } finally {
+          if (!isNoWait) {
+            this.inbound.remove(relatedId);
+          }
+        }
+      })();
+    }
+  }
+  _startKeepAlive() {
+    this._keepAliveTimer = setInterval(() => {
+      if (this._connection !== void 0) {
+        this._hub.systemCallSender.keepAlive(this._connection, this.outbound.activeCallIds());
+      }
+    }, 15e3);
+  }
+  _stopKeepAlive() {
+    if (this._keepAliveTimer !== void 0) {
+      clearInterval(this._keepAliveTimer);
+      this._keepAliveTimer = void 0;
+    }
+  }
+};
+var RpcPeerConnectionKind = /* @__PURE__ */ ((RpcPeerConnectionKind2) => {
+  RpcPeerConnectionKind2[RpcPeerConnectionKind2["Disconnected"] = 0] = "Disconnected";
+  RpcPeerConnectionKind2[RpcPeerConnectionKind2["Connecting"] = 1] = "Connecting";
+  RpcPeerConnectionKind2[RpcPeerConnectionKind2["Connected"] = 2] = "Connected";
+  return RpcPeerConnectionKind2;
+})(RpcPeerConnectionKind || {});
+var RpcClientPeer = class extends RpcPeer {
+  _disposed = false;
+  _connectionKind = 0 /* Disconnected */;
+  _tryIndex = 0;
+  _handshakeIndex = 0;
+  _lastRemoteHubId;
+  _pendingHandshake;
+  _reconnectsAt = 0;
+  /** Base64url-encoded peer ID — matches .NET's RpcClientPeer.ClientId (Guid.ToBase64Url). */
+  clientId;
+  /**
+   * Serialization format key sent to the server via `f=` query parameter.
+   * TS uses plain JSON.stringify (no polymorphic type wrapping), so `json5np`
+   * (no-polymorphism) is the correct default.
+   */
+  serializationFormat;
+  /** Builds the WebSocket URL for this peer. Replace to customize URL construction. */
+  connectionUrlResolver = defaultConnectionUrlResolver;
+  peerChanged = new EventHandlerSet3();
+  reconnectDelayer = new RpcClientPeerReconnectDelayer();
+  reconnectsAtChanged = new EventHandlerSet3();
+  get reconnectsAt() {
+    return this._reconnectsAt;
+  }
+  _setReconnectsAt(value) {
+    if (this._reconnectsAt === value) return;
+    this._reconnectsAt = value;
+    this.reconnectsAtChanged.trigger();
+  }
+  constructor(hub, url, serializationFormat) {
+    super(url, hub);
+    this.clientId = guidToBase64Url(this.id);
+    this.serializationFormat = serializationFormat ?? DEFAULT_SERIALIZATION_FORMAT;
+  }
+  get connectionKind() {
+    return this._connectionKind;
+  }
+  /** One-shot connection for tests — no reconnection loop, no handshake. */
+  connectWith(conn) {
+    this.setupConnection(conn);
+    this._reconnect(true);
+  }
+  /** Start the reconnection loop — runs until disposed. */
+  async run(wsFactory) {
+    const connUrl = this.connectionUrlResolver(this);
+    while (!this._disposed) {
+      try {
+        const ws = wsFactory?.(connUrl) ?? new WebSocket(connUrl);
+        const conn = new RpcWebSocketConnection(ws);
+        this._connectionKind = 1 /* Connecting */;
+        this._pendingHandshake = new PromiseSource3();
+        this.setupConnection(conn);
+        this._connection = void 0;
+        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);
+        const remoteHandshake = await Promise.race([
+          this._pendingHandshake.promise,
+          closedRejection
+        ]);
+        this._pendingHandshake = void 0;
+        const remoteHubId = remoteHandshake.RemoteHubId;
+        let isPeerChanged = false;
+        if (remoteHubId !== void 0) {
+          isPeerChanged = this._lastRemoteHubId !== void 0 && this._lastRemoteHubId !== remoteHubId;
+          if (isPeerChanged) {
+            this.inbound.clear();
+            this.peerChanged.trigger();
+          }
+          this._lastRemoteHubId = remoteHubId;
+        }
+        this._connection = conn;
+        this._connectionKind = 2 /* Connected */;
+        this._tryIndex = 0;
+        this._reconnect(isPeerChanged);
+        await new Promise((r) => conn.closed.add(() => r()));
+      } catch {
+      }
+      this._connectionKind = 0 /* Disconnected */;
+      if (this._disposed) break;
+      this._tryIndex++;
+      const delay = this.reconnectDelayer.getDelay(this._tryIndex);
+      if (delay.isLimitExceeded) {
+        this._disposed = true;
+        break;
+      }
+      this._setReconnectsAt(delay.endsAt);
+      try {
+        await delay.promise;
+      } finally {
+        this._setReconnectsAt(0);
+      }
+    }
+  }
+  /** Re-send outbound calls after reconnection + flush pending sends.
+   *  Stage-3 compute calls are always self-invalidated: without $sys.Reconnect
+   *  protocol, the server's invalidation tracking is lost on disconnect, and
+   *  re-sending would get a duplicate $sys.Ok that is ignored (PromiseSource
+   *  already resolved). Self-invalidation forces a fresh recompute that
+   *  establishes new invalidation tracking on the new connection.
+   *  Regular in-flight calls are re-sent transparently. */
+  _reconnect(_isPeerChanged) {
+    if (this._connection === void 0) return;
+    const conn = this._connection;
+    const trackerCalls = [...this.outbound.values()];
+    for (const call of trackerCalls) {
+      if (!call.removeOnOk && call.result.isCompleted) {
+        call.onDisconnect();
+        this.outbound.remove(call.callId);
+      } else {
+        conn.send(call.serializedMessage);
+      }
+    }
+    this._flushPendingSends();
+  }
+  _onHandshakeReceived(handshake) {
+    this._pendingHandshake?.resolve(handshake);
+  }
+  close() {
+    this._disposed = true;
+    super.close();
+  }
+};
+var RpcServerPeer = class extends RpcPeer {
+  constructor(hub, ref) {
+    super(ref, hub);
+  }
+  /** Accept an incoming connection — sets up message handling and handshake response. */
+  accept(conn) {
+    this.setupConnection(conn);
+  }
+  _onHandshakeReceived(_handshake) {
+    if (this._connection !== void 0) {
+      this._hub.systemCallSender.handshake(this._connection, this.id, this._hub.hubId, 0);
+    }
+  }
+};
+function guidToBase64Url(uuid) {
+  const hex = uuid.replace(/-/g, "");
+  const bytes = new Uint8Array(16);
+  bytes[0] = parseInt(hex.slice(6, 8), 16);
+  bytes[1] = parseInt(hex.slice(4, 6), 16);
+  bytes[2] = parseInt(hex.slice(2, 4), 16);
+  bytes[3] = parseInt(hex.slice(0, 2), 16);
+  bytes[4] = parseInt(hex.slice(10, 12), 16);
+  bytes[5] = parseInt(hex.slice(8, 10), 16);
+  bytes[6] = parseInt(hex.slice(14, 16), 16);
+  bytes[7] = parseInt(hex.slice(12, 14), 16);
+  for (let i = 8; i < 16; i++)
+    bytes[i] = parseInt(hex.slice(i * 2, i * 2 + 2), 16);
+  const binary = String.fromCharCode(...bytes);
+  return btoa(binary).replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
+}
+
+// src/rpc-service-host.ts
+var RpcServiceHost = class {
+  _methods = /* @__PURE__ */ new Map();
+  register(def, impl) {
+    for (const methodDef of def.methods.values()) {
+      const fn = impl[methodDef.name];
+      if (!fn) continue;
+      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 (context !== void 0 && entry.def.callTypeId !== 0) {
+      return await entry.fn(...args, context);
+    }
+    return await entry.fn(...args);
+  }
+  getMethodDef(wireMethod) {
+    return this._methods.get(wireMethod)?.def;
+  }
+};
+
+// src/rpc-decorators.ts
+var METHODS_META = /* @__PURE__ */ Symbol.for("actuallab.methods");
+var SERVICE_META = /* @__PURE__ */ Symbol.for("actuallab.service");
+function getMethodsMeta(cls) {
+  return cls[Symbol.metadata]?.[METHODS_META];
+}
+function getServiceMeta(cls) {
+  return cls[Symbol.metadata]?.[SERVICE_META];
+}
+function rpcService(serviceName, options) {
+  return function(_target, context) {
+    const meta = context.metadata[SERVICE_META] ??= {};
+    meta.name = serviceName;
+    if (options?.ctOffset !== void 0)
+      meta.ctOffset = options.ctOffset;
+  };
+}
+function rpcMethod(options) {
+  return function(target, context) {
+    const methodName = String(context.name);
+    const methods = context.metadata[METHODS_META] ??= {};
+    methods[methodName] = {
+      ...methods[methodName],
+      argCount: target.length,
+      stream: options?.stream ?? false,
+      noWait: options?.noWait ?? false
+    };
+    return target;
+  };
+}
+
+// src/rpc-hub.ts
+var RpcHub = class {
+  hubId;
+  peers = /* @__PURE__ */ new Map();
+  serviceHost;
+  systemCallSender = new RpcSystemCallSender();
+  constructor(hubId) {
+    this.hubId = hubId ?? crypto.randomUUID();
+    this.serviceHost = new RpcServiceHost();
+  }
+  addPeer(peer) {
+    this.peers.set(peer.ref, peer);
+  }
+  removePeer(ref) {
+    const peer = this.peers.get(ref);
+    if (peer !== void 0) {
+      peer.close();
+      this.peers.delete(ref);
+    }
+  }
+  /** Get or create a peer by ref. Server peers have "server://" prefix, everything else is a client peer. */
+  getPeer(ref) {
+    let peer = this.peers.get(ref);
+    if (peer) return peer;
+    peer = ref.startsWith("server://") ? new RpcServerPeer(this, ref) : new RpcClientPeer(this, ref);
+    this.addPeer(peer);
+    return peer;
+  }
+  /** Get or create a client peer for the given URL. */
+  getClientPeer(ref) {
+    return this.getPeer(ref);
+  }
+  /** Get or create a server peer for the given ref. */
+  getServerPeer(ref) {
+    return this.getPeer(ref);
+  }
+  /** Register a service with optional server method wrapping for custom call types. */
+  addService(defOrContract, impl) {
+    const def = this._resolveServiceDef(defOrContract);
+    const wrappedImpl = {};
+    for (const methodDef of def.methods.values()) {
+      const fn = impl[methodDef.name];
+      if (!fn) continue;
+      wrappedImpl[methodDef.name] = methodDef.callTypeId !== 0 ? this._wrapServerMethod(methodDef, fn, impl) : fn;
+    }
+    this.serviceHost.register(def, wrappedImpl);
+  }
+  /** Create a typed client proxy for a service on a remote peer. */
+  addClient(peer, defOrContract) {
+    const def = this._resolveServiceDef(defOrContract);
+    const overloads = /* @__PURE__ */ new Map();
+    for (const methodDef of def.methods.values()) {
+      let byArgCount = overloads.get(methodDef.name);
+      if (!byArgCount) {
+        byArgCount = /* @__PURE__ */ new Map();
+        overloads.set(methodDef.name, byArgCount);
+      }
+      byArgCount.set(methodDef.argCount, this._createClientMethod(peer, methodDef));
+    }
+    const methods = /* @__PURE__ */ new Map();
+    for (const [name, byArgCount] of overloads) {
+      if (byArgCount.size === 1) {
+        methods.set(name, byArgCount.values().next().value);
+      } else {
+        methods.set(name, (...args) => {
+          const fn = byArgCount.get(args.length);
+          if (!fn) throw new Error(`No overload of ${name} accepts ${args.length} arguments`);
+          return fn(...args);
+        });
+      }
+    }
+    return new Proxy({}, {
+      get: (_target, prop) => typeof prop === "string" ? methods.get(prop) : void 0
+    });
+  }
+  close() {
+    for (const peer of this.peers.values()) peer.close();
+    this.peers.clear();
+  }
+  /** Dispatch an inbound system call. Override in FusionHub to handle compute-specific system calls. */
+  handleSystemCall(message, args, outbound, inbound) {
+    handleSystemCall(message, args, outbound, inbound);
+  }
+  /** 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");
+    const methodsMeta = getMethodsMeta(cls) ?? {};
+    const ctOffset = svcMeta.ctOffset ?? 0;
+    const methods = /* @__PURE__ */ new Map();
+    for (const [name, meta] of Object.entries(methodsMeta)) {
+      const wireArgCount = meta.argCount + ctOffset;
+      const mapKey = `${name}:${wireArgCount}`;
+      methods.set(mapKey, {
+        name,
+        serviceName: svcMeta.name,
+        argCount: meta.argCount,
+        wireArgCount,
+        callTypeId: 0,
+        stream: meta.stream ?? false,
+        noWait: meta.noWait ?? false
+      });
+    }
+    return { name: svcMeta.name, methods };
+  }
+  /** Resolve a service def from either a plain RpcServiceDef or a contract class. */
+  _resolveServiceDef(defOrContract) {
+    if (typeof defOrContract === "function")
+      return this._buildServiceDef(defOrContract);
+    return defOrContract;
+  }
+  /** Override in FusionHub — default is pass-through (for methods with callTypeId !== 0). */
+  _wrapServerMethod(_methodDef, fn, _impl) {
+    return fn;
+  }
+  /** Create a client method for the given methodDef. Override in FusionHub for custom call types. */
+  _createClientMethod(peer, methodDef) {
+    const wireName = wireMethodName(methodDef);
+    if (methodDef.noWait) {
+      return (...args) => {
+        const callArgs = args.slice(0, methodDef.argCount);
+        peer.callNoWait(wireName, callArgs);
+      };
+    }
+    const callOptions = methodDef.callTypeId !== 0 ? { callTypeId: methodDef.callTypeId } : void 0;
+    return async (...args) => {
+      const callArgs = args.slice(0, methodDef.argCount);
+      const outboundCall = peer.call(wireName, callArgs, callOptions);
+      return outboundCall.result.promise;
+    };
+  }
+};
+
+// src/rpc-client.ts
+function createRpcClient(peer, serviceDef) {
+  const overloads = /* @__PURE__ */ new Map();
+  for (const methodDef of serviceDef.methods.values()) {
+    let byArgCount = overloads.get(methodDef.name);
+    if (!byArgCount) {
+      byArgCount = /* @__PURE__ */ new Map();
+      overloads.set(methodDef.name, byArgCount);
+    }
+    byArgCount.set(methodDef.argCount, methodDef);
+  }
+  const methods = /* @__PURE__ */ new Map();
+  for (const [name, byArgCount] of overloads) {
+    if (byArgCount.size === 1) {
+      const methodDef = byArgCount.values().next().value;
+      methods.set(name, createMethod(peer, methodDef));
+    } else {
+      const fns = /* @__PURE__ */ new Map();
+      for (const [argCount, methodDef] of byArgCount) {
+        fns.set(argCount, createMethod(peer, methodDef));
+      }
+      methods.set(name, (...args) => {
+        const fn = fns.get(args.length);
+        if (!fn) throw new Error(`No overload of ${name} accepts ${args.length} arguments`);
+        return fn(...args);
+      });
+    }
+  }
+  return new Proxy({}, {
+    get(_target, prop) {
+      if (typeof prop !== "string") return void 0;
+      return methods.get(prop);
+    }
+  });
+}
+function createMethod(peer, methodDef) {
+  return async (...args) => {
+    const callArgs = args.slice(0, methodDef.argCount);
+    const wireName = wireMethodName(methodDef);
+    const options = methodDef.callTypeId !== 0 ? { callTypeId: methodDef.callTypeId } : void 0;
+    const outboundCall = peer.call(wireName, callArgs, options);
+    return outboundCall.result.promise;
+  };
+}
+
+// src/rpc-peer-state.ts
+var RpcPeerStateKind = /* @__PURE__ */ ((RpcPeerStateKind2) => {
+  RpcPeerStateKind2[RpcPeerStateKind2["Connected"] = 0] = "Connected";
+  RpcPeerStateKind2[RpcPeerStateKind2["JustDisconnected"] = 1] = "JustDisconnected";
+  RpcPeerStateKind2[RpcPeerStateKind2["Disconnected"] = 2] = "Disconnected";
+  RpcPeerStateKind2[RpcPeerStateKind2["JustConnected"] = 3] = "JustConnected";
+  return RpcPeerStateKind2;
+})(RpcPeerStateKind || {});
+function isConnected(state) {
+  return state.kind === 0 /* Connected */ || state.kind === 3 /* JustConnected */;
+}
+function likelyConnected(state) {
+  return state.kind !== 2 /* Disconnected */;
+}
+function getStateDescription(state, useLastError = false) {
+  switch (state.kind) {
+    case 3 /* JustConnected */:
+      return "Just connected.";
+    case 0 /* Connected */:
+      return "Connected.";
+    case 1 /* JustDisconnected */:
+      return "Just disconnected, reconnecting...";
+    case 2 /* Disconnected */:
+      if (state.reconnectsIn > 0)
+        break;
+      return "Reconnecting...";
+  }
+  if (state.lastError == null || !useLastError)
+    return "Disconnected.";
+  let message = state.lastError.message.trim();
+  if (!(message.endsWith(".") || message.endsWith("!") || message.endsWith("?")))
+    message += ".";
+  return "Disconnected: " + message;
+}
+
+// src/rpc-peer-state-monitor.ts
+import { EventHandlerSet as EventHandlerSet4 } from "@actuallab/core";
+var JustConnectedPeriodMs = 1500;
+var JustDisconnectedPeriodMs = 3e3;
+var MinReconnectsInMs = 1e3;
+var RpcPeerStateMonitor = class {
+  peer;
+  stateChanged = new EventHandlerSet4();
+  _rawConnected;
+  _connectedAt = 0;
+  _disconnectedAt = 0;
+  _lastError;
+  _state;
+  _timer;
+  // Arrow functions to preserve `this` when used as event handlers
+  _onConnected = () => {
+    this._rawConnected = true;
+    this._connectedAt = Date.now();
+    this._lastError = void 0;
+    this._recompute();
+  };
+  _onDisconnected = (ev) => {
+    const wasConnected = this._rawConnected;
+    this._rawConnected = false;
+    this._lastError = new Error(`Connection closed: ${ev.reason} (code ${ev.code})`);
+    if (wasConnected) {
+      this._disconnectedAt = Date.now();
+    }
+    this._recompute();
+  };
+  _onReconnectsAtChanged = () => {
+    this._recompute();
+  };
+  _onCancelDelaysChanged = () => {
+    this._recompute();
+  };
+  constructor(peer) {
+    this.peer = peer;
+    this._rawConnected = peer.isConnected;
+    if (this._rawConnected) {
+      this._connectedAt = Date.now();
+      this._state = { kind: 3 /* JustConnected */, reconnectsIn: 0 };
+    } else {
+      this._disconnectedAt = Date.now();
+      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);
+  }
+  get state() {
+    return this._state;
+  }
+  dispose() {
+    if (this._timer !== void 0) {
+      clearTimeout(this._timer);
+      this._timer = void 0;
+    }
+    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);
+  }
+  _recompute() {
+    if (this._timer !== void 0) {
+      clearTimeout(this._timer);
+      this._timer = void 0;
+    }
+    const now = Date.now();
+    let newState;
+    if (this._rawConnected) {
+      const connectedFor = now - this._connectedAt;
+      if (connectedFor < JustConnectedPeriodMs) {
+        newState = { kind: 3 /* JustConnected */, reconnectsIn: 0 };
+        this._scheduleRecompute(JustConnectedPeriodMs - connectedFor);
+      } else {
+        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);
+      } 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 };
+        } else {
+          newState = { kind: 2 /* Disconnected */, lastError: this._lastError, reconnectsIn };
+          this._scheduleRecompute(Math.min(1e3, reconnectsIn - MinReconnectsInMs));
+        }
+      }
+    }
+    this._setState(newState);
+  }
+  _setState(newState) {
+    const old = this._state;
+    if (old.kind === newState.kind && old.lastError === newState.lastError && old.reconnectsIn === newState.reconnectsIn)
+      return;
+    this._state = newState;
+    this.stateChanged.trigger(newState);
+  }
+  _scheduleRecompute(delayMs) {
+    if (this._timer !== void 0) clearTimeout(this._timer);
+    this._timer = setTimeout(() => {
+      this._timer = void 0;
+      this._recompute();
+    }, Math.max(0, delayMs));
+  }
+};
+export {
+  ARG_DELIMITER,
+  DEFAULT_SERIALIZATION_FORMAT,
+  ENVELOPE_DELIMITER,
+  FRAME_DELIMITER,
+  RpcCallTypeId,
+  RpcClientPeer,
+  RpcClientPeerReconnectDelayer,
+  RpcHub,
+  RpcInboundCall,
+  RpcInboundCallTracker,
+  RpcMessageChannelConnection,
+  RpcOutboundCall,
+  RpcOutboundCallTracker,
+  RpcPeer,
+  RpcPeerConnectionKind,
+  RpcPeerStateKind,
+  RpcPeerStateMonitor,
+  RpcServerPeer,
+  RpcServiceHost,
+  RpcSystemCallSender,
+  RpcSystemCalls,
+  RpcType,
+  RpcWebSocketConnection,
+  WebSocketState,
+  createMessageChannelPair,
+  createRpcClient,
+  defaultConnectionUrlResolver,
+  defineRpcService,
+  deserializeMessage,
+  getMethodsMeta,
+  getServiceMeta,
+  getStateDescription,
+  handleSystemCall,
+  isConnected,
+  likelyConnected,
+  rpcMethod,
+  rpcService,
+  serializeFrame,
+  serializeMessage,
+  splitFrame,
+  wireMethodName
+};
+//# sourceMappingURL=index.js.map