@actuallab/rpc 13.0.25 → 13.0.163

package/dist/index.d.cts

@@ -76,6 +76,22 @@ declare const defaultBinaryDecoder: Decoder<undefined>;
  *  with the same initial buffer size without needing to reach into
  *  this module's private constants. */
 declare function createBinaryEncoder(): Encoder;
+/**
+ * Parses a polymorphism marker (as written by .NET `ByteTypeSerializer`) at
+ * `offset`. The msgpack6 format prefixes every *polymorphic* argument/result
+ * with a 2-byte little-endian length:
+ *   - 0        → expected (non-polymorphic) type — the `\0\0` fast path
+ *   - 1        → NullValue (the value itself is absent)
+ *   - >= 2     → a derived type (2-byte length + 2-byte hash + UTF-8 name)
+ *
+ * Returns how many bytes the marker occupies and whether the value is a
+ * NullValue. Derived-type markers are unsupported by the TS client and throw a
+ * clear error instead of letting the marker bytes corrupt the msgpack frame.
+ */
+declare function readPolymorphismMarker(data: Uint8Array, offset: number): {
+    bytesRead: number;
+    isNull: boolean;
+};
 /**
  * Serializes an RpcMessage + args into V5 binary format (msgpack6np).
  *
@@ -202,9 +218,7 @@ declare abstract class RpcSerializationFormat {
     static NewtonsoftJsonV5: RpcSerializationFormat;
     static NewtonsoftJsonV5NP: RpcSerializationFormat;
     static MessagePackV6: RpcSerializationFormat;
-    static MemoryPackV6: RpcSerializationFormat;
     static MessagePackV6C: RpcSerializationFormat;
-    static MemoryPackV6C: RpcSerializationFormat;
     static All: readonly RpcSerializationFormat[];
     /** Convenience shortcut for RpcSerializationFormatResolver.Default.get(key). */
     static get(key: string): RpcSerializationFormat;
@@ -225,7 +239,7 @@ declare class RpcJsonSerializationFormat extends RpcSerializationFormat {
     serializeBinaryFrame(): Uint8Array;
 }
 /**
- * MessagePack binary format — "msgpack6" / "mempack6" (V5 wire format).
+ * MessagePack binary format — "msgpack6" (V5 wire format).
  */
 declare class RpcMessagePackSerializationFormat extends RpcSerializationFormat {
     readonly key: string;
@@ -240,7 +254,7 @@ declare class RpcMessagePackSerializationFormat extends RpcSerializationFormat {
     createDecoder(): Decoder;
 }
 /**
- * MessagePack compact binary format — "msgpack6c" / "mempack6c" (V5Compact).
+ * MessagePack compact binary format — "msgpack6c" (V5Compact).
  * Uses 4-byte method hash instead of full method name.
  * Registry is passed via parameters — format instance is immutable.
  */
@@ -385,6 +399,22 @@ declare function createMessageChannelPair(): [
     RpcMessageChannelConnection
 ];
 
+/**
+ * Connect/run timeouts for an outbound RPC call, enforced by the peer's
+ * maintenance loop. `Infinity` means "no timeout".
+ */
+declare class RpcCallTimeouts {
+    /** Both timeouts unbounded — the query default (.NET `RpcCallTimeouts.None`). */
+    static readonly None: RpcCallTimeouts;
+    /** Command default: 1.5 s connect / 10 s run (.NET `RpcCallTimeouts.Default.Command`). */
+    static readonly Command: RpcCallTimeouts;
+    /** Max time a call may wait for the connection before it is sent. */
+    readonly connectTimeoutMs: number;
+    /** Max time a sent call may stay unanswered before it is failed. */
+    readonly runTimeoutMs: number;
+    constructor(connectTimeoutMs?: number, runTimeoutMs?: number);
+}
+
 /** Controls outbound RPC call behavior regarding connection waiting, reconnection, and resending. */
 declare const RpcRemoteExecutionMode: {
     /** Wait for connection if disconnected when the call is made. */
@@ -408,6 +438,8 @@ interface RpcMethodDef {
     readonly stream: boolean;
     readonly noWait: boolean;
     readonly remoteExecutionMode: RpcRemoteExecutionMode;
+    /** Per-method connect/run timeouts (R12). `undefined` means unbounded. */
+    readonly timeouts?: RpcCallTimeouts;
 }
 /** Describes an RPC service — its name and method definitions. */
 interface RpcServiceDef {
@@ -422,6 +454,8 @@ interface RpcMethodDefInput {
     wireArgCount?: number;
     /** Override for remoteExecutionMode. Default: RpcRemoteExecutionMode.Default (7). NoWait methods always use 0. */
     remoteExecutionMode?: RpcRemoteExecutionMode;
+    /** Per-method connect/run timeouts (R12). Default: unbounded. */
+    timeouts?: RpcCallTimeouts;
 }
 declare const RpcType: {
     readonly object: symbol;
@@ -445,6 +479,14 @@ declare class RpcOutboundCall {
     readonly removeOnOk: boolean;
     /** The serialized wire data — stored for re-sending on reconnect. */
     serializedWireData: string | Uint8Array;
+    /** Per-call connect/run timeouts enforced by the peer's maintenance loop
+     *  (R12). `undefined` means unbounded (the query default). */
+    timeouts: RpcCallTimeouts | undefined;
+    /** `Date.now()` when this call was created (used for the connect timeout). */
+    readonly startedAt: number;
+    /** `Date.now()` when this call was last put on the wire, or 0 if it hasn't
+     *  been sent yet (used for the run timeout). */
+    sentAt: number;
     /**
      * Bitfield of {@link RpcCallStage} flags indicating how far this call
      * has progressed. Used by the `$sys.Reconnect` protocol to tell the
@@ -491,13 +533,31 @@ declare class RpcInboundCall {
     readonly callId: number;
     readonly method: string;
     readonly args: unknown[];
+    /** 0 = still processing, 1 = result computed and sent at least once. */
+    completedStage: number;
+    private _resend;
+    private readonly _abortController;
     constructor(callId: number, method: string, args: unknown[]);
+    /** Aborted when the remote peer cancels this call via `$sys.Cancel` (R17).
+     *  Threaded into the service handler so it can abort in-flight work. */
+    get signal(): AbortSignal;
+    /** True once the remote peer cancelled this call — the response is then
+     *  suppressed even though the call may still be registered (R9 dedup). */
+    get isCancelled(): boolean;
+    cancel(): void;
+    setResult(resend: () => void): void;
+    resendResult(): void;
 }
 /** Manages inbound calls by their RelatedId. */
 declare class RpcInboundCallTracker {
     private _calls;
+    private _completedIds;
+    /** Cap on retained completed calls — see `RpcLimits.completedInboundCallsLimit`. */
+    completedCallsLimit: number;
     get size(): number;
     register(call: RpcInboundCall): void;
+    getOrRegister(call: RpcInboundCall): RpcInboundCall;
+    markCompleted(call: RpcInboundCall): void;
     get(callId: number): RpcInboundCall | undefined;
     remove(callId: number): RpcInboundCall | undefined;
     clear(): void;
@@ -529,6 +589,12 @@ declare class RpcError extends Error {
     readonly typeName?: string;
     constructor(message: string, typeName?: string);
 }
+declare const REMOTE_EXCEPTION_TYPE_REF = "ActualLab.Serialization.RemoteException, ActualLab.Core";
+/** Wire shape of .NET `ExceptionInfo` for a JS error sent to a .NET peer. */
+declare function toExceptionInfo(error: unknown): {
+    TypeRef: string;
+    Message: string;
+};
 
 /**
  * Compresses and decompresses monotonically increasing sequences of
@@ -581,6 +647,12 @@ declare class RpcLimits {
     /** Process-wide default. Hubs read from this when they're constructed
      *  unless caller assigns a custom instance to `hub.limits`. */
     static Default: RpcLimits;
+    /** Dev preset with a relaxed keep-alive timeout (5 min), matching .NET's
+     *  debugger-attached `KeepAlivePeriod` (RpcLimits.cs:46-54). Activate
+     *  explicitly — e.g. `RpcLimits.Default = RpcLimits.Debug` or per-hub
+     *  `hub.limits = RpcLimits.Debug`. Never switched on automatically: the
+     *  TS side can't detect a debugger on the server (decision D4). */
+    static readonly Debug: RpcLimits;
     /** Max time to wait for the WebSocket to enter the OPEN state. On a
      *  hung connect (mobile after network change, half-open after sleep)
      *  the browser can take ~2 min to emit `onerror`/`onclose`; without
@@ -588,6 +660,22 @@ declare class RpcLimits {
     connectTimeoutMs: number;
     /** Max time to wait for the server's handshake response after WS opens. */
     handshakeTimeoutMs: number;
+    /** If a connection lived less than this before dropping, a graceful close
+     *  still counts as a failed attempt — the client keeps its growing
+     *  `_tryIndex` instead of resetting it, so a crash-looping server sees
+     *  increasing reconnect delays via `RetryDelaySeq`. Mirrors .NET
+     *  `RpcLimits.PrematureDisconnectTimeout` (RpcLimits.cs:18). */
+    prematureDisconnectTimeoutMs: number;
+    /** Max completed inbound calls retained for duplicate-frame dedup
+     *  (a resent call id re-sends the computed result instead of
+     *  re-executing the handler). Deviation from .NET, which unregisters a
+     *  call once its result is sent: TS clients blind-resend on reconnect,
+     *  so completed calls are retained — bounded by this limit (oldest
+     *  evicted first) to cap memory on long-lived connections. */
+    completedInboundCallsLimit: number;
+    /** How often each peer's maintenance loop scans outbound calls for
+     *  timeouts (R12). Mirrors .NET `RpcLimits.CallTimeoutCheckPeriod`. */
+    callTimeoutCheckPeriodMs: number;
     /** Outbound `$sys.KeepAlive` send period. */
     keepAlivePeriodMs: number;
     /** Reaper threshold — connection is force-closed (and the reconnect
@@ -597,6 +685,13 @@ declare class RpcLimits {
      *  `keepAlivePeriodMs + stall_duration`, so with these defaults the
      *  tolerated stall is ~15 s. */
     keepAliveTimeoutMs: number;
+    /** How long a server peer stays in `hub.peers` after its connection closes
+     *  before it's stopped and removed. A same-peer reconnect (`accept()`)
+     *  within this window cancels the pending removal, so brief drops don't
+     *  discard the peer's trackers. Mirrors .NET's server-peer shutdown timeout
+     *  (`RpcPeerOptions.ServerPeerShutdownTimeoutProvider`, 3-15 min); the TS
+     *  port uses a fixed floor-matching default. */
+    serverPeerCloseTimeoutMs: number;
     constructor(overrides?: Partial<RpcLimits>);
 }
 
@@ -605,16 +700,21 @@ declare class RpcClientPeerReconnectDelayer extends RetryDelayer {
 }
 
 type RpcServiceImpl = Record<string, ((...args: unknown[]) => unknown) | undefined>;
-/** Context passed to service dispatch — carries callId and connection for compute tracking. */
+/** Context passed to service dispatch — carries callId, the inbound CallType,
+ *  the connection, and the peer for compute-call invalidation tracking. */
 interface RpcDispatchContext {
     __rpcDispatch: true;
     callId: number;
+    callType: number;
     connection: RpcConnection;
+    /** Aborted when the inbound call is cancelled via `$sys.Cancel` (R17). */
+    signal?: AbortSignal;
+    peer: RpcPeer;
 }
 /** Dispatches inbound RPC calls to registered service implementations. */
 declare class RpcServiceHost {
     private _methods;
-    register(def: RpcServiceDef, impl: RpcServiceImpl): void;
+    register(def: RpcServiceDef, impl: RpcServiceImpl, receiver?: object): void;
     dispatch(wireMethod: string, args: unknown[], context?: RpcDispatchContext): Promise<unknown>;
     getMethodDef(wireMethod: string): RpcMethodDef | undefined;
 }
@@ -640,6 +740,7 @@ declare function rpcService(serviceName: string): <T extends AnyConstructor>(_ta
 declare function rpcMethod(options?: {
     returns?: symbol;
     remoteExecutionMode?: number;
+    argCount?: number;
 }): <This, Args extends unknown[], Return>(target: (this: This, ...args: Args) => Return, context: ClassMethodDecoratorContext<This, (this: This, ...args: Args) => Return>) => (this: This, ...args: Args) => Return;
 
 /**
@@ -671,12 +772,13 @@ declare class RpcSystemCallSender {
     private readonly _ackEndArgs;
     private static readonly NO_ERROR;
     registry?: RpcMethodRegistry;
-    private _send;
+    protected _send(conn: RpcConnection, format: RpcSerializationFormat, envelope: RpcMessage, args?: unknown[]): void;
     handshake(conn: RpcConnection, format: RpcSerializationFormat, peerId: string, hubId: string, index: number): void;
     ok(conn: RpcConnection, format: RpcSerializationFormat, relatedId: number, result: unknown): void;
     error(conn: RpcConnection, format: RpcSerializationFormat, relatedId: number, error: unknown): void;
     cancel(conn: RpcConnection, format: RpcSerializationFormat, relatedId: number): void;
     keepAlive(conn: RpcConnection, format: RpcSerializationFormat, activeCallIds: number[]): void;
+    disconnect(conn: RpcConnection, format: RpcSerializationFormat, localIds: number[]): void;
     item(conn: RpcConnection, format: RpcSerializationFormat, localId: number, index: number, item: unknown): void;
     batch(conn: RpcConnection, format: RpcSerializationFormat, localId: number, index: number, items: unknown[]): void;
     end(conn: RpcConnection, format: RpcSerializationFormat, localId: number, index: number, error?: {
@@ -705,6 +807,14 @@ declare class RpcHub {
     /** Shared reconnect delayer used by every client peer in this hub. Swap in
      *  a custom subclass (e.g. app-level signal-gated) before peers start. */
     reconnectDelayer: RpcClientPeerReconnectDelayer;
+    /** Cache of client proxies keyed by peer, then by service name — so
+     *  repeated {@link addClient} calls for the same service+peer return one
+     *  proxy. All consumers then share a single computed/call/invalidation
+     *  stream per logical value, matching .NET's singleton client proxies (F8).
+     *  A later def registered under the same name extends the existing proxy
+     *  with its extra methods (superset), so no consumer ever receives a proxy
+     *  missing methods the def declares. */
+    private readonly _clientProxies;
     /** Connection-lifecycle timing limits. Peers constructed against this hub
      *  read their initial `*Ms` field values from this instance; later
      *  mutations affect only peers built afterward (existing peers can be
@@ -742,9 +852,14 @@ declare class RpcHub {
     getServerPeer(ref: string, factory?: RpcPeerFactory): RpcServerPeer;
     /** Register a service with optional server method wrapping for custom call types. */
     addService(defOrContract: RpcServiceDef | (AnyConstructor), impl: RpcServiceImpl): void;
-    /** Create a typed client proxy for a service on a remote peer. */
+    /** Create a typed client proxy for a service on a remote peer. Repeated calls
+     *  for the same (peer, service name) return one shared proxy; a def carrying
+     *  extra methods extends it (F8). */
     addClient<T extends object>(peer: RpcPeer, defOrContract: RpcServiceDef | (AnyConstructor)): T;
     close(): void;
+    /** Create the hub's system-call sender. Override in FusionHub to add
+     *  Fusion-specific system calls (e.g. $sys-c.Invalidate). */
+    protected _createSystemCallSender(): RpcSystemCallSender;
     /** Build an RpcServiceDef from decorator metadata on a contract class. Override in FusionHub for compute support. */
     protected _buildServiceDef(cls: AnyConstructor): RpcServiceDef;
     /** Resolve a service def from either a plain RpcServiceDef or a contract class. */
@@ -753,6 +868,8 @@ declare class RpcHub {
     protected _wrapServerMethod(_methodDef: RpcMethodDef, fn: (...args: unknown[]) => unknown, _impl: object): (...args: unknown[]) => unknown;
     /** Create a client method for the given methodDef. Override in FusionHub for custom call types. */
     protected _createClientMethod(peer: RpcPeer, methodDef: RpcMethodDef): (...args: unknown[]) => unknown;
+    private _createClientProxy;
+    private _extendClientProxy;
 }
 
 interface RpcObjectId {
@@ -811,6 +928,8 @@ interface RpcCallOptions {
     signal?: AbortSignal;
     /** Bitfield of RpcRemoteExecutionMode flags (default: 7 = Default). */
     remoteExecutionMode?: number;
+    /** Per-call connect/run timeouts (R12). Default: unbounded. */
+    timeouts?: RpcCallTimeouts;
 }
 /** Data extracted from an inbound $sys.Handshake message. */
 interface RemoteHandshake {
@@ -835,6 +954,10 @@ declare abstract class RpcPeer {
      *  attempt (the reconnect delay is part of this phase); `Connected` is
      *  entered only after the handshake has succeeded. */
     readonly connectionStateChanged: EventHandlerSet<RpcConnectionState>;
+    /** Index of the handshake THIS peer most recently sent. Used to reject a
+     *  stale `$sys.Reconnect` that references an older connection generation
+     *  (C# `RpcSystemCalls.Reconnect`'s `ownHandshake.Index` check). */
+    protected _ownHandshakeIndex: number;
     protected _connection: RpcConnection | undefined;
     /** Mirror of `_connectionState === Connected`. True only after the
      *  handshake round-trip completes; outbound `call()` checks this to
@@ -846,6 +969,7 @@ declare abstract class RpcPeer {
     protected _connectionState: RpcConnectionState;
     private _keepAliveTimer;
     private _keepAliveWatchdog;
+    private _maintainTimer;
     /** Wall-clock time of the last inbound `$sys.KeepAlive`, or 0 if none yet
      *  for the current connection. Useful for diagnostics. */
     private _lastKeepAliveAt;
@@ -856,9 +980,16 @@ declare abstract class RpcPeer {
      *  at construction; set directly to override on a single peer. */
     keepAliveTimeoutMs: number;
     protected constructor(hub: RpcHub, ref: string);
+    /** Fail outbound calls whose per-call {@link RpcCallTimeouts} elapsed —
+     *  the connect timeout while a call still awaits the wire, the run timeout
+     *  once it has been sent. Mirrors .NET `RpcOutboundCallTracker.Maintain`
+     *  (RpcCallTrackers.cs:108-207). Calls without timeouts (queries) never
+     *  time out here. */
+    private _maintainOutboundCalls;
     get connection(): RpcConnection | undefined;
     get connectionState(): RpcConnectionState;
     get isConnected(): boolean;
+    get ownHandshakeIndex(): number;
     protected _setConnectionState(value: RpcConnectionState): void;
     /** Resolves on the next transition into `Connected` — or immediately if
      *  already in that state. */
@@ -914,15 +1045,17 @@ declare const enum RpcConnectionState {
 /** Client-side RPC peer — initiates WebSocket connection. ref = URL. */
 declare class RpcClientPeer extends RpcPeer {
     private _disposed;
+    /** Aborted when the peer is stopped/disposed — threaded into the reconnect
+     *  delay so a pending delay rejects promptly instead of parking. */
+    private readonly _stopController;
     private _tryIndex;
-    private _handshakeIndex;
     /** Index from the MOST RECENTLY RECEIVED server handshake — sent back
      *  to the server in `$sys.Reconnect:3` so the server can verify we're
      *  talking about the current connection. Mirrors .NET's
      *  `connectionState.Handshake.Index` path in
      *  `RpcOutboundCallTracker.TryReconnect`. */
     private _remoteHandshakeIndex;
-    private _lastRemoteHubId;
+    private _lastRemotePeerId;
     private _pendingHandshake;
     private _reconnectsAt;
     /** Base64url-encoded peer ID — matches .NET's RpcClientPeer.ClientId (Guid.ToBase64Url). */
@@ -943,6 +1076,10 @@ declare class RpcClientPeer extends RpcPeer {
      *  the connection attempt. Initialized from `hub.limits` at construction;
      *  set directly to override on a single peer. */
     handshakeTimeoutMs: number;
+    /** A connection that lived less than this before dropping does NOT reset
+     *  `_tryIndex`, so a crash-looping server sees growing reconnect delays.
+     *  Initialized from `hub.limits` at construction; override per peer. */
+    prematureDisconnectTimeoutMs: number;
     readonly peerChanged: EventHandlerSet<void>;
     /** Fired when the server rejects the connection due to an unsupported serialization format (close code 4010). */
     readonly unsupportedFormat: EventHandlerSet<{
@@ -1018,14 +1155,30 @@ declare class RpcClientPeer extends RpcPeer {
      *     default for `Dictionary<int, byte[]>`.
      */
     private _reconcileReconnect;
+    /** Detects a server-peer identity change by comparing the incoming
+     *  handshake's `RemotePeerId` with the last one — C#
+     *  `RpcHandshake.GetPeerChangeKind` keys off `RemotePeerId`, not
+     *  `RemoteHubId` (an idle server peer can be replaced while keeping the
+     *  same hub id). On a change it clears the inbound tracker and fires
+     *  `peerChanged`; the very first handshake is never a change. */
+    private _detectPeerChange;
     protected _onHandshakeReceived(handshake: RemoteHandshake): void;
     close(): void;
 }
 /** Server-side RPC peer — wraps an accepted connection. ref = "server://{uuid}". */
 declare class RpcServerPeer extends RpcPeer {
+    /** Grace period before an idle (disconnected) server peer is stopped and
+     *  removed from `hub.peers`; a re-`accept()` within it cancels removal.
+     *  Snapshotted from `hub.limits` at construction (F11). */
+    serverPeerCloseTimeoutMs: number;
+    private _closeTimer;
+    private _isClosed;
     constructor(hub: RpcHub, ref: string);
     /** Accept an incoming connection — sets up message handling and handshake response. */
     accept(conn: RpcConnection): void;
+    close(): void;
+    private _armCloseTimer;
+    private _clearCloseTimer;
     protected _onHandshakeReceived(_handshake: RemoteHandshake): void;
 }
 
@@ -1144,6 +1297,7 @@ declare class RpcStreamSender<T> implements IRpcObject {
      * src/ActualLab.Rpc/Infrastructure/RpcSharedStream.cs:68-101.
      */
     onAck(nextIndex: number, hostId: string): void;
+    private _sendDisconnect;
     /** Called by system call handler when $sys.AckEnd is received from the client. */
     onAckEnd(_hostId: string): void;
     /**
@@ -1307,6 +1461,8 @@ declare class RpcStream<T> implements AsyncIterable<T>, IRpcObject {
     disconnect(): void;
     [Symbol.asyncIterator](): AsyncIterator<T>;
     dispose(): void;
+    private _complete;
+    private _gapError;
     private _notifyConsumer;
     private _maybeSendAck;
     private static readonly _emptyGuid;
@@ -1396,4 +1552,4 @@ declare function xxh3_64str(input: string, seed?: bigint): bigint;
  */
 declare function computeMethodHash(methodName: string): number;
 
-export { ARG_DELIMITER, ENVELOPE_DELIMITER, FRAME_DELIMITER, type IRpcObject, IncreasingSeqCompressor, type MethodMeta, RPC_CLOSE_CODE_UNSUPPORTED_FORMAT, type RemoteHandshake, type RpcCallOptions, RpcCallStage, RpcCallTypeId, RpcClientPeer, RpcClientPeerReconnectDelayer, type RpcConnection, RpcConnectionState, type RpcConnectionUrlResolver, type RpcDeserializedMessage, type RpcDispatchContext, RpcError, RpcHub, RpcInboundCall, RpcInboundCallTracker, RpcJsonSerializationFormat, RpcLimits, type RpcLogScope, type RpcMessage, RpcMessageChannelConnection, RpcMessagePackCompactSerializationFormat, RpcMessagePackSerializationFormat, type RpcMethodDef, type RpcMethodDefInput, RpcMethodRegistry, type RpcObjectId, RpcObjectKind, RpcOutboundCall, RpcOutboundCallTracker, RpcPeer, type RpcPeerFactory, RpcPeerRefBuilder, type RpcPeerState, RpcPeerStateKind, RpcPeerStateMonitor, type RpcReceivedMessage, RpcRemoteExecutionMode, RpcRemoteObjectTracker, RpcSerializationFormat, RpcSerializationFormatResolver, RpcServerPeer, type RpcServiceDef, RpcServiceHost, type RpcServiceImpl, RpcSharedObjectTracker, RpcStream, type RpcStreamOptions, type RpcStreamRef, RpcStreamSender, type RpcStreamSource, RpcSystemCallHandler, RpcSystemCallSender, RpcSystemCalls, RpcType, RpcWebSocketConnection, type RpcWireData, type ServiceMeta, type WebSocketLike, type WebSocketServer, WebSocketState, computeMethodHash, createBinaryEncoder, createMessageChannelPair, createRpcClient, defaultBinaryDecoder, defaultBinaryEncoder, defaultConnectionUrlResolver, defineRpcService, deserializeBinaryMessage, deserializeCompactBinaryMessage, deserializeMessage, getLogs, getMethodsMeta, getServiceMeta, getStateDescription, isConnected, likelyConnected, parseStreamRef, resolveStreamRefs, rpcMethod, rpcService, serializeBinaryFrame, serializeBinaryMessage, serializeCompactBinaryMessage, serializeFrame, serializeMessage, splitBinaryFrame, splitCompactBinaryFrame, splitFrame, wireMethodName, xxh3_64, xxh3_64str };
+export { ARG_DELIMITER, ENVELOPE_DELIMITER, FRAME_DELIMITER, type IRpcObject, IncreasingSeqCompressor, type MethodMeta, REMOTE_EXCEPTION_TYPE_REF, RPC_CLOSE_CODE_UNSUPPORTED_FORMAT, type RemoteHandshake, type RpcCallOptions, RpcCallStage, RpcCallTimeouts, RpcCallTypeId, RpcClientPeer, RpcClientPeerReconnectDelayer, type RpcConnection, RpcConnectionState, type RpcConnectionUrlResolver, type RpcDeserializedMessage, type RpcDispatchContext, RpcError, RpcHub, RpcInboundCall, RpcInboundCallTracker, RpcJsonSerializationFormat, RpcLimits, type RpcLogScope, type RpcMessage, RpcMessageChannelConnection, RpcMessagePackCompactSerializationFormat, RpcMessagePackSerializationFormat, type RpcMethodDef, type RpcMethodDefInput, RpcMethodRegistry, type RpcObjectId, RpcObjectKind, RpcOutboundCall, RpcOutboundCallTracker, RpcPeer, type RpcPeerFactory, RpcPeerRefBuilder, type RpcPeerState, RpcPeerStateKind, RpcPeerStateMonitor, type RpcReceivedMessage, RpcRemoteExecutionMode, RpcRemoteObjectTracker, RpcSerializationFormat, RpcSerializationFormatResolver, RpcServerPeer, type RpcServiceDef, RpcServiceHost, type RpcServiceImpl, RpcSharedObjectTracker, RpcStream, type RpcStreamOptions, type RpcStreamRef, RpcStreamSender, type RpcStreamSource, RpcSystemCallHandler, RpcSystemCallSender, RpcSystemCalls, RpcType, RpcWebSocketConnection, type RpcWireData, type ServiceMeta, type WebSocketLike, type WebSocketServer, WebSocketState, computeMethodHash, createBinaryEncoder, createMessageChannelPair, createRpcClient, defaultBinaryDecoder, defaultBinaryEncoder, defaultConnectionUrlResolver, defineRpcService, deserializeBinaryMessage, deserializeCompactBinaryMessage, deserializeMessage, getLogs, getMethodsMeta, getServiceMeta, getStateDescription, isConnected, likelyConnected, parseStreamRef, readPolymorphismMarker, resolveStreamRefs, rpcMethod, rpcService, serializeBinaryFrame, serializeBinaryMessage, serializeCompactBinaryMessage, serializeFrame, serializeMessage, splitBinaryFrame, splitCompactBinaryFrame, splitFrame, toExceptionInfo, wireMethodName, xxh3_64, xxh3_64str };