@orpc/client 1.14.11 → 1.14.12

package/dist/adapters/message-port/index.d.ts

@@ -1,10 +1,9 @@
-import { C as ClientContext, a as ClientOptions } from '../../shared/client.BBZBQID8.js';
 import { Value, Promisable } from '@orpc/shared';
-import { StandardRequest, StandardLazyResponse } from '@standardserver/core';
-import { ClientPeer, EncodePeerMessageOptions, DecodePeerMessageOptions } from '@standardserver/peer';
-import { S as StandardLinkTransport, a as StandardLink, b as StandardLinkOptions } from '../../shared/client.BMKYqpdy.js';
-import { RPCLinkCodecOptions } from '../standard/index.js';
-import '../../shared/client.BdItY5DT.js';
+import { StandardRequest, StandardLazyResponse } from '@orpc/standard-server';
+import { DecodedRequestMessage } from '@orpc/standard-server-peer';
+import { b as ClientContext, c as ClientOptions } from '../../shared/client.i2uoJbEp.js';
+import { f as StandardLinkClient } from '../../shared/client.2jUAqzYU.js';
+import { f as StandardRPCLinkOptions, g as StandardRPCLink } from '../../shared/client.B3pNRBih.js';
 
 /**
  * The message port used by electron in main process
@@ -29,47 +28,53 @@ interface BrowserPortLike {
 }
 type SupportedMessagePort = Pick<MessagePort, 'addEventListener' | 'postMessage'> | MessagePortMainLike | BrowserPortLike;
 /**
- * Message port can support [The structured clone algorithm](https://developer.mozilla.org/en-US/docs/Web/API/Web_Workers_API/Structured_clone_algorithm)
+ *  Message port can support [The structured clone algorithm](https://developer.mozilla.org/en-US/docs/Web/API/Web_Workers_API/Structured_clone_algorithm)
  */
 type SupportedMessagePortData = any;
 declare function postMessagePortMessage(port: SupportedMessagePort, data: SupportedMessagePortData, transfer?: any[]): void;
 declare function onMessagePortMessage(port: SupportedMessagePort, callback: (data: SupportedMessagePortData) => void): void;
 declare function onMessagePortClose(port: SupportedMessagePort, callback: () => void): void;
 
-type DecodedRequestMessage = ConstructorParameters<typeof ClientPeer>[0] extends (message: infer TMessage) => unknown ? TMessage : never;
-interface MessagePortLinkTransportOptions<_T extends ClientContext> {
+interface LinkMessagePortClientOptions {
     port: SupportedMessagePort;
     /**
      * By default, oRPC serializes request/response messages to string/binary data before sending over message port.
-     * If needed, define this option to utilize full power of [MessagePort: postMessage() method](https://developer.mozilla.org/en-US/docs/Web/API/MessagePort/postMessage),
+     * If needed, you can define the this option to utilize full power of [MessagePort: postMessage() method](https://developer.mozilla.org/en-US/docs/Web/API/MessagePort/postMessage),
      * such as transferring ownership of objects to the other side or support unserializable objects like `OffscreenCanvas`.
      *
      * @remarks
      * - return null | undefined to disable this feature
      *
      * @warning Make sure your message port supports `transfer` before using this feature.
+     * @example
+     * ```ts
+     * experimental_transfer: (message, port) => {
+     *   const transfer = deepFindTransferableObjects(message) // implement your own logic
+     *   return transfer.length ? transfer : null // only enable when needed
+     * }
+     * ```
+     *
+     * @see {@link https://orpc.dev/docs/adapters/message-port#transfer Message Port Transfer Docs}
      */
     experimental_transfer?: Value<Promisable<object[] | null | undefined>, [message: DecodedRequestMessage, port: SupportedMessagePort]>;
-    /**
-     * Options for encoding peer messages. such as `prefix` for distinguishing messages on the same channel..
-     */
-    encodePeerMessage?: EncodePeerMessageOptions | undefined;
-    /**
-     * Options for decoding peer messages, such as `prefix` for distinguishing messages on the same channel.
-     */
-    decodePeerMessage?: DecodePeerMessageOptions | undefined;
 }
-declare class MessagePortLinkTransport<T extends ClientContext> implements StandardLinkTransport<T> {
+declare class LinkMessagePortClient<T extends ClientContext> implements StandardLinkClient<T> {
     private readonly peer;
-    constructor({ port, experimental_transfer, encodePeerMessage: encodePeerMessageOptions, decodePeerMessage: decodePeerMessageOptions }: MessagePortLinkTransportOptions<T>);
-    send(standardRequest: StandardRequest, _path: string[], _options: ClientOptions<T>): Promise<StandardLazyResponse>;
+    constructor(options: LinkMessagePortClientOptions);
+    call(request: StandardRequest, _options: ClientOptions<T>, _path: readonly string[], _input: unknown): Promise<StandardLazyResponse>;
 }
 
-interface RPCLinkOptions<T extends ClientContext> extends StandardLinkOptions<T>, MessagePortLinkTransportOptions<T>, RPCLinkCodecOptions<T> {
+interface RPCLinkOptions<T extends ClientContext> extends Omit<StandardRPCLinkOptions<T>, 'url' | 'method' | 'fallbackMethod' | 'maxUrlLength'>, LinkMessagePortClientOptions {
 }
-declare class RPCLink<T extends ClientContext> extends StandardLink<T> {
+/**
+ * The RPC Link for common message port implementations.
+ *
+ * @see {@link https://orpc.dev/docs/client/rpc-link RPC Link Docs}
+ * @see {@link https://orpc.dev/docs/adapters/message-port Message Port Adapter Docs}
+ */
+declare class RPCLink<T extends ClientContext> extends StandardRPCLink<T> {
     constructor(options: RPCLinkOptions<T>);
 }
 
-export { MessagePortLinkTransport, RPCLink, onMessagePortClose, onMessagePortMessage, postMessagePortMessage };
-export type { BrowserPortLike, MessagePortLinkTransportOptions, MessagePortMainLike, RPCLinkOptions, SupportedMessagePort, SupportedMessagePortData };
+export { LinkMessagePortClient, RPCLink, onMessagePortClose, onMessagePortMessage, postMessagePortMessage };
+export type { BrowserPortLike, LinkMessagePortClientOptions, MessagePortMainLike, RPCLinkOptions, SupportedMessagePort, SupportedMessagePortData };

package/dist/adapters/message-port/index.mjs

@@ -1,10 +1,10 @@
-import { value } from '@orpc/shared';
-import { ClientPeer, encodePeerMessage, decodePeerMessage, isServerPeerSendMessage, isPeerMessage } from '@standardserver/peer';
-import { S as StandardLink, R as RPCLinkCodec } from '../../shared/client.BRJnOJ0R.mjs';
-import '@standardserver/core';
-import '@standardserver/fetch';
-import '../../shared/client.Dnfj8jnT.mjs';
-import '../../shared/client.DqYwRDUO.mjs';
+import { value, isObject } from '@orpc/shared';
+import { experimental_ClientPeerWithoutCodec, serializeRequestMessage, encodeRequestMessage, deserializeResponseMessage, decodeResponseMessage } from '@orpc/standard-server-peer';
+import { c as StandardRPCLink } from '../../shared/client.C1VUaWTu.mjs';
+import '@orpc/standard-server';
+import '../../shared/client.DrCRv_sG.mjs';
+import '@orpc/standard-server-fetch';
+import '../../shared/client.BLtwTQUg.mjs';
 
 function postMessagePortMessage(port, data, transfer) {
   if (transfer) {
@@ -32,11 +32,11 @@ function onMessagePortMessage(port, callback) {
 }
 function onMessagePortClose(port, callback) {
   if ("addEventListener" in port) {
-    port.addEventListener("close", () => {
+    port.addEventListener("close", async () => {
       callback();
     });
   } else if ("on" in port) {
-    port.on("close", () => {
+    port.on("close", async () => {
       callback();
     });
   } else if ("onDisconnect" in port) {
@@ -48,49 +48,40 @@ function onMessagePortClose(port, callback) {
   }
 }
 
-class MessagePortLinkTransport {
+class LinkMessagePortClient {
   peer;
-  constructor({ port, experimental_transfer, encodePeerMessage: encodePeerMessageOptions, decodePeerMessage: decodePeerMessageOptions }) {
-    this.peer = new ClientPeer(async (message) => {
-      const transfer = await value(experimental_transfer, message, port);
+  constructor(options) {
+    this.peer = new experimental_ClientPeerWithoutCodec(async (message) => {
+      const [id, type, payload] = message;
+      const transfer = await value(options.experimental_transfer, message, options.port);
       if (transfer) {
-        postMessagePortMessage(port, message, transfer);
+        postMessagePortMessage(options.port, serializeRequestMessage(id, type, payload), transfer);
       } else {
-        postMessagePortMessage(port, await encodePeerMessage(message, encodePeerMessageOptions));
+        postMessagePortMessage(options.port, await encodeRequestMessage(id, type, payload));
       }
     });
-    onMessagePortMessage(port, async (data) => {
-      let peerMessage;
-      if (typeof data === "string" || data instanceof Uint8Array) {
-        const result = decodePeerMessage(data, decodePeerMessageOptions);
-        if (result.matched && isServerPeerSendMessage(result.message)) {
-          peerMessage = result.message;
-        }
-      } else if (isPeerMessage(data) && isServerPeerSendMessage(data)) {
-        peerMessage = data;
-      }
-      if (peerMessage === void 0) {
-        return { matched: false };
+    onMessagePortMessage(options.port, async (message) => {
+      if (isObject(message)) {
+        await this.peer.message(deserializeResponseMessage(message));
+      } else {
+        await this.peer.message(await decodeResponseMessage(message));
       }
-      await this.peer.message(peerMessage);
-      return { matched: true };
     });
-    onMessagePortClose(port, async () => {
-      await this.peer.close();
+    onMessagePortClose(options.port, () => {
+      this.peer.close();
     });
   }
-  async send(standardRequest, _path, _options) {
-    const standardResponse = await this.peer.request(standardRequest);
-    return standardResponse;
+  async call(request, _options, _path, _input) {
+    const response = await this.peer.request(request);
+    return { ...response, body: () => Promise.resolve(response.body) };
   }
 }
 
-class RPCLink extends StandardLink {
+class RPCLink extends StandardRPCLink {
   constructor(options) {
-    const codec = new RPCLinkCodec(options);
-    const transport = new MessagePortLinkTransport(options);
-    super(codec, transport, options);
+    const linkClient = new LinkMessagePortClient(options);
+    super(linkClient, { ...options, url: "http://orpc" });
   }
 }
 
-export { MessagePortLinkTransport, RPCLink, onMessagePortClose, onMessagePortMessage, postMessagePortMessage };
+export { LinkMessagePortClient, RPCLink, onMessagePortClose, onMessagePortMessage, postMessagePortMessage };

package/dist/adapters/standard/index.d.mts

@@ -1,61 +1,11 @@
-import { f as StandardLinkCodec, g as StandardLinkCodecDecodedResponse } from '../../shared/client.8f4DNmdE.mjs';
-export { C as CompositeStandardLinkPlugin, a as StandardLink, h as StandardLinkInterceptor, e as StandardLinkInterceptorOptions, b as StandardLinkOptions, c as StandardLinkPlugin, S as StandardLinkTransport, i as StandardLinkTransportInterceptor, d as StandardLinkTransportInterceptorOptions } from '../../shared/client.8f4DNmdE.mjs';
-import { Value, Promisable } from '@orpc/shared';
-import { StandardUrl, StandardHeaders, StandardRequest, StandardLazyResponse } from '@standardserver/core';
-export { StandardBody, StandardBodyHint, StandardHeaders, StandardLazyRequest, StandardLazyResponse, StandardMethod, StandardRequest, StandardResponse, StandardUrl } from '@standardserver/core';
-import { C as ClientContext, a as ClientOptions } from '../../shared/client.BBZBQID8.mjs';
-import { e as RPCSerializer } from '../../shared/client.BdItY5DT.mjs';
+export { C as CompositeStandardLinkPlugin, d as StandardLink, f as StandardLinkClient, S as StandardLinkClientInterceptorOptions, e as StandardLinkCodec, c as StandardLinkInterceptorOptions, b as StandardLinkOptions, a as StandardLinkPlugin } from '../../shared/client.CpCa3si8.mjs';
+export { S as STANDARD_RPC_JSON_SERIALIZER_BUILT_IN_TYPES, c as StandardRPCCustomJsonSerializer, b as StandardRPCJsonSerialized, a as StandardRPCJsonSerializedMetaItem, e as StandardRPCJsonSerializer, d as StandardRPCJsonSerializerOptions, g as StandardRPCLink, i as StandardRPCLinkCodec, h as StandardRPCLinkCodecOptions, f as StandardRPCLinkOptions, j as StandardRPCSerializer } from '../../shared/client.BFAVy68H.mjs';
+import { StandardHeaders } from '@orpc/standard-server';
+import { H as HTTPPath } from '../../shared/client.i2uoJbEp.mjs';
+import '@orpc/shared';
 
-interface RPCLinkCodecOptions<T extends ClientContext> {
-    /**
-     * Base url for all requests (without origin). Should match with handler's prefix.
-     *
-     * @example '/rpc?base=1'
-     *
-     * @default '/'
-     */
-    url?: Value<Promisable<StandardUrl>, [options: ClientOptions<T>, path: string[], input: unknown]>;
-    /**
-     * The maximum length of the URL.
-     *
-     * If the URL exceeds this length, the codec should use the `fallbackMethod` to send the request with the payload in the body instead of the URL.
-     *
-     * @default 2083
-     */
-    maxUrlLength?: Value<Promisable<number>, [options: ClientOptions<T>, path: string[], input: unknown]>;
-    /**
-     * The method used to make the request.
-     *
-     * @default 'POST'
-     */
-    method?: Value<Promisable<'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE'>, [options: ClientOptions<T>, path: string[], input: unknown]>;
-    /**
-     * The method to use when the payload cannot safely pass to the server with method return from method function.
-     * GET is not allowed, it's very dangerous.
-     *
-     * @default 'POST'
-     */
-    fallbackMethod?: 'POST' | 'PUT' | 'PATCH' | 'DELETE';
-    /**
-     * Inject headers to the request.
-     */
-    headers?: Value<Promisable<StandardHeaders | Headers>, [options: ClientOptions<T>, path: string[], input: unknown]>;
-    /**
-     * Override the default RPC serializer.
-     */
-    serializer?: Pick<RPCSerializer, keyof RPCSerializer>;
-}
-declare class RPCLinkCodec<T extends ClientContext> implements StandardLinkCodec<T> {
-    private readonly baseUrl;
-    private readonly maxUrlLength;
-    private readonly fallbackMethod;
-    private readonly expectedMethod;
-    private readonly headers;
-    private readonly serializer;
-    constructor(options: RPCLinkCodecOptions<T>);
-    encodeInput(input: unknown, path: string[], options: ClientOptions<T>): Promise<StandardRequest>;
-    decodeResponse(response: StandardLazyResponse): Promise<StandardLinkCodecDecodedResponse>;
-}
+declare function toHttpPath(path: readonly string[]): HTTPPath;
+declare function toStandardHeaders(headers: Headers | StandardHeaders): StandardHeaders;
+declare function getMalformedResponseErrorCode(status: number): string;
 
-export { RPCLinkCodec, StandardLinkCodec, StandardLinkCodecDecodedResponse };
-export type { RPCLinkCodecOptions };
+export { getMalformedResponseErrorCode, toHttpPath, toStandardHeaders };

package/dist/adapters/standard/index.d.ts

@@ -1,61 +1,11 @@
-import { f as StandardLinkCodec, g as StandardLinkCodecDecodedResponse } from '../../shared/client.BMKYqpdy.js';
-export { C as CompositeStandardLinkPlugin, a as StandardLink, h as StandardLinkInterceptor, e as StandardLinkInterceptorOptions, b as StandardLinkOptions, c as StandardLinkPlugin, S as StandardLinkTransport, i as StandardLinkTransportInterceptor, d as StandardLinkTransportInterceptorOptions } from '../../shared/client.BMKYqpdy.js';
-import { Value, Promisable } from '@orpc/shared';
-import { StandardUrl, StandardHeaders, StandardRequest, StandardLazyResponse } from '@standardserver/core';
-export { StandardBody, StandardBodyHint, StandardHeaders, StandardLazyRequest, StandardLazyResponse, StandardMethod, StandardRequest, StandardResponse, StandardUrl } from '@standardserver/core';
-import { C as ClientContext, a as ClientOptions } from '../../shared/client.BBZBQID8.js';
-import { e as RPCSerializer } from '../../shared/client.BdItY5DT.js';
+export { C as CompositeStandardLinkPlugin, d as StandardLink, f as StandardLinkClient, S as StandardLinkClientInterceptorOptions, e as StandardLinkCodec, c as StandardLinkInterceptorOptions, b as StandardLinkOptions, a as StandardLinkPlugin } from '../../shared/client.2jUAqzYU.js';
+export { S as STANDARD_RPC_JSON_SERIALIZER_BUILT_IN_TYPES, c as StandardRPCCustomJsonSerializer, b as StandardRPCJsonSerialized, a as StandardRPCJsonSerializedMetaItem, e as StandardRPCJsonSerializer, d as StandardRPCJsonSerializerOptions, g as StandardRPCLink, i as StandardRPCLinkCodec, h as StandardRPCLinkCodecOptions, f as StandardRPCLinkOptions, j as StandardRPCSerializer } from '../../shared/client.B3pNRBih.js';
+import { StandardHeaders } from '@orpc/standard-server';
+import { H as HTTPPath } from '../../shared/client.i2uoJbEp.js';
+import '@orpc/shared';
 
-interface RPCLinkCodecOptions<T extends ClientContext> {
-    /**
-     * Base url for all requests (without origin). Should match with handler's prefix.
-     *
-     * @example '/rpc?base=1'
-     *
-     * @default '/'
-     */
-    url?: Value<Promisable<StandardUrl>, [options: ClientOptions<T>, path: string[], input: unknown]>;
-    /**
-     * The maximum length of the URL.
-     *
-     * If the URL exceeds this length, the codec should use the `fallbackMethod` to send the request with the payload in the body instead of the URL.
-     *
-     * @default 2083
-     */
-    maxUrlLength?: Value<Promisable<number>, [options: ClientOptions<T>, path: string[], input: unknown]>;
-    /**
-     * The method used to make the request.
-     *
-     * @default 'POST'
-     */
-    method?: Value<Promisable<'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE'>, [options: ClientOptions<T>, path: string[], input: unknown]>;
-    /**
-     * The method to use when the payload cannot safely pass to the server with method return from method function.
-     * GET is not allowed, it's very dangerous.
-     *
-     * @default 'POST'
-     */
-    fallbackMethod?: 'POST' | 'PUT' | 'PATCH' | 'DELETE';
-    /**
-     * Inject headers to the request.
-     */
-    headers?: Value<Promisable<StandardHeaders | Headers>, [options: ClientOptions<T>, path: string[], input: unknown]>;
-    /**
-     * Override the default RPC serializer.
-     */
-    serializer?: Pick<RPCSerializer, keyof RPCSerializer>;
-}
-declare class RPCLinkCodec<T extends ClientContext> implements StandardLinkCodec<T> {
-    private readonly baseUrl;
-    private readonly maxUrlLength;
-    private readonly fallbackMethod;
-    private readonly expectedMethod;
-    private readonly headers;
-    private readonly serializer;
-    constructor(options: RPCLinkCodecOptions<T>);
-    encodeInput(input: unknown, path: string[], options: ClientOptions<T>): Promise<StandardRequest>;
-    decodeResponse(response: StandardLazyResponse): Promise<StandardLinkCodecDecodedResponse>;
-}
+declare function toHttpPath(path: readonly string[]): HTTPPath;
+declare function toStandardHeaders(headers: Headers | StandardHeaders): StandardHeaders;
+declare function getMalformedResponseErrorCode(status: number): string;
 
-export { RPCLinkCodec, StandardLinkCodec, StandardLinkCodecDecodedResponse };
-export type { RPCLinkCodecOptions };
+export { getMalformedResponseErrorCode, toHttpPath, toStandardHeaders };

package/dist/adapters/standard/index.mjs

@@ -1,6 +1,6 @@
-export { C as CompositeStandardLinkPlugin, R as RPCLinkCodec, S as StandardLink } from '../../shared/client.BRJnOJ0R.mjs';
+export { C as CompositeStandardLinkPlugin, a as STANDARD_RPC_JSON_SERIALIZER_BUILT_IN_TYPES, S as StandardLink, b as StandardRPCJsonSerializer, c as StandardRPCLink, d as StandardRPCLinkCodec, e as StandardRPCSerializer, g as getMalformedResponseErrorCode, t as toHttpPath, f as toStandardHeaders } from '../../shared/client.C1VUaWTu.mjs';
 import '@orpc/shared';
-import '@standardserver/core';
-import '@standardserver/fetch';
-import '../../shared/client.Dnfj8jnT.mjs';
-import '../../shared/client.DqYwRDUO.mjs';
+import '@orpc/standard-server';
+import '../../shared/client.DrCRv_sG.mjs';
+import '@orpc/standard-server-fetch';
+import '../../shared/client.BLtwTQUg.mjs';

package/dist/adapters/websocket/index.d.mts

@@ -1,121 +1,29 @@
-import { C as ClientContext, a as ClientOptions } from '../../shared/client.BBZBQID8.mjs';
-import { Promisable } from '@orpc/shared';
-import { StandardRequest, StandardLazyResponse } from '@standardserver/core';
-import { EncodePeerMessageOptions, DecodePeerMessageOptions } from '@standardserver/peer';
-import { S as StandardLinkTransport, a as StandardLink, b as StandardLinkOptions } from '../../shared/client.8f4DNmdE.mjs';
-import { RPCLinkCodecOptions } from '../standard/index.mjs';
-import '../../shared/client.BdItY5DT.mjs';
+import { StandardRequest, StandardLazyResponse } from '@orpc/standard-server';
+import { b as ClientContext, c as ClientOptions } from '../../shared/client.i2uoJbEp.mjs';
+import { f as StandardLinkClient } from '../../shared/client.CpCa3si8.mjs';
+import { f as StandardRPCLinkOptions, g as StandardRPCLink } from '../../shared/client.BFAVy68H.mjs';
+import '@orpc/shared';
 
-type WebSocketLike = Pick<WebSocket, 'addEventListener' | 'removeEventListener' | 'send' | 'readyState'>;
-interface WebSocketLinkTransportAttemptInfo {
-    /**
-     * Total number of connection attempts for this transport's lifetime.
-     * Starts at 1 on the first attempt, increments on every subsequent
-     * attempt, and never resets.
-     */
-    totalAttempt: number;
-    /**
-     * Attempt number within the current (re)connect cycle.
-     * Starts at 1, increments on each consecutive failure, and resets to 1
-     * once a connection succeeds. Use this for backoff calculations.
-     */
-    attempt: number;
+interface LinkWebsocketClientOptions {
+    websocket: Pick<WebSocket, 'addEventListener' | 'removeEventListener' | 'send' | 'readyState'>;
 }
-interface WebSocketLinkTransportReconnectOptions {
-    /**
-     * Whether to automatically reconnect when the connection is lost.
-     *
-     * @default false
-     */
-    enabled: boolean;
-    /**
-     * Delay before a (re)connect attempt, in milliseconds.
-     *
-     * @default info => info.attempt === 1 ? 0 : 2_000
-     */
-    delay?: undefined | ((info: WebSocketLinkTransportAttemptInfo) => number);
-    /**
-     * Maximum number of consecutive failed attempts before giving up.
-     * When exceeded, `getConnectedPeer` throws instead of retrying.
-     * Should greater than 1
-     *
-     * @default Infinity
-     */
-    maxAttempt?: undefined | number;
-    /**
-     * Whether to proactively reconnect right after the socket closes,
-     * rather than waiting for the next call to trigger reconnection.
-     * Reduces latency for the next request.
-     *
-     * @default { enabled: false }
-     */
-    onClose?: undefined | {
-        /**
-         * Whether to proactively reconnect right after the socket closes,
-         * rather than waiting for the next call to trigger reconnection.
-         * Reduces latency for the next request.
-         *
-         * @default false
-         */
-        enabled: boolean;
-        /**
-         * Delay before reconnecting after the socket closes, in milliseconds.
-         *
-         * @default 0
-         */
-        delay?: number;
-    };
-}
-interface WebSocketLinkTransportOptions<_T extends ClientContext> {
-    /**
-     * Returns a WebSocket instance for peer communication.
-     * Can be async for lazy resolution.
-     */
-    connect: (info: WebSocketLinkTransportAttemptInfo) => Promisable<WebSocketLike>;
-    /**
-     * Whether to connect immediately on initialization, instead of waiting
-     * for the first call. Reduces latency for the first request.
-     *
-     * @default false
-     */
-    connectOnInit?: undefined | boolean;
-    /**
-     * Reconnection behavior when the connection is lost.
-     *
-     * @default { enabled: false }
-     */
-    reconnect?: undefined | WebSocketLinkTransportReconnectOptions;
-    /**
-     * Options for encoding peer messages. such as `prefix` for distinguishing messages on the same channel..
-     */
-    encodePeerMessage?: EncodePeerMessageOptions | undefined;
-    /**
-     * Options for decoding peer messages. such as `prefix` for distinguishing messages on the same channel..
-     */
-    decodePeerMessage?: DecodePeerMessageOptions | undefined;
-}
-declare class WebSocketLinkTransport<T extends ClientContext> implements StandardLinkTransport<T> {
-    private readonly connect;
-    private readonly reconnectEnabled;
-    private readonly reconnectDelay;
-    private readonly reconnectMaxAttempt;
-    private readonly reconnectOnCloseEnabled;
-    private readonly reconnectOnCloseDelay;
-    private readonly encodePeerMessageOptions;
-    private readonly decodePeerMessageOptions;
-    constructor(options: WebSocketLinkTransportOptions<T>);
-    send(standardRequest: StandardRequest, _path: string[], _options: ClientOptions<T>): Promise<StandardLazyResponse>;
-    private totalAttempt;
-    private attempt;
-    private current;
-    private getConnectedPeer;
+declare class LinkWebsocketClient<T extends ClientContext> implements StandardLinkClient<T> {
+    private readonly peer;
+    constructor(options: LinkWebsocketClientOptions);
+    call(request: StandardRequest, _options: ClientOptions<T>, _path: readonly string[], _input: unknown): Promise<StandardLazyResponse>;
 }
 
-interface RPCLinkOptions<T extends ClientContext> extends StandardLinkOptions<T>, WebSocketLinkTransportOptions<T>, RPCLinkCodecOptions<T> {
+interface RPCLinkOptions<T extends ClientContext> extends Omit<StandardRPCLinkOptions<T>, 'url' | 'method' | 'fallbackMethod' | 'maxUrlLength'>, LinkWebsocketClientOptions {
 }
-declare class RPCLink<T extends ClientContext> extends StandardLink<T> {
+/**
+ * The RPC Link communicates with the server using the RPC protocol over WebSocket.
+ *
+ * @see {@link https://orpc.dev/docs/client/rpc-link RPC Link Docs}
+ * @see {@link https://orpc.dev/docs/adapters/websocket WebSocket Adapter Docs}
+ */
+declare class RPCLink<T extends ClientContext> extends StandardRPCLink<T> {
     constructor(options: RPCLinkOptions<T>);
 }
 
-export { RPCLink, WebSocketLinkTransport };
-export type { RPCLinkOptions, WebSocketLike, WebSocketLinkTransportAttemptInfo, WebSocketLinkTransportOptions, WebSocketLinkTransportReconnectOptions };
+export { LinkWebsocketClient, RPCLink };
+export type { LinkWebsocketClientOptions, RPCLinkOptions };

package/dist/adapters/websocket/index.d.ts

@@ -1,121 +1,29 @@
-import { C as ClientContext, a as ClientOptions } from '../../shared/client.BBZBQID8.js';
-import { Promisable } from '@orpc/shared';
-import { StandardRequest, StandardLazyResponse } from '@standardserver/core';
-import { EncodePeerMessageOptions, DecodePeerMessageOptions } from '@standardserver/peer';
-import { S as StandardLinkTransport, a as StandardLink, b as StandardLinkOptions } from '../../shared/client.BMKYqpdy.js';
-import { RPCLinkCodecOptions } from '../standard/index.js';
-import '../../shared/client.BdItY5DT.js';
+import { StandardRequest, StandardLazyResponse } from '@orpc/standard-server';
+import { b as ClientContext, c as ClientOptions } from '../../shared/client.i2uoJbEp.js';
+import { f as StandardLinkClient } from '../../shared/client.2jUAqzYU.js';
+import { f as StandardRPCLinkOptions, g as StandardRPCLink } from '../../shared/client.B3pNRBih.js';
+import '@orpc/shared';
 
-type WebSocketLike = Pick<WebSocket, 'addEventListener' | 'removeEventListener' | 'send' | 'readyState'>;
-interface WebSocketLinkTransportAttemptInfo {
-    /**
-     * Total number of connection attempts for this transport's lifetime.
-     * Starts at 1 on the first attempt, increments on every subsequent
-     * attempt, and never resets.
-     */
-    totalAttempt: number;
-    /**
-     * Attempt number within the current (re)connect cycle.
-     * Starts at 1, increments on each consecutive failure, and resets to 1
-     * once a connection succeeds. Use this for backoff calculations.
-     */
-    attempt: number;
+interface LinkWebsocketClientOptions {
+    websocket: Pick<WebSocket, 'addEventListener' | 'removeEventListener' | 'send' | 'readyState'>;
 }
-interface WebSocketLinkTransportReconnectOptions {
-    /**
-     * Whether to automatically reconnect when the connection is lost.
-     *
-     * @default false
-     */
-    enabled: boolean;
-    /**
-     * Delay before a (re)connect attempt, in milliseconds.
-     *
-     * @default info => info.attempt === 1 ? 0 : 2_000
-     */
-    delay?: undefined | ((info: WebSocketLinkTransportAttemptInfo) => number);
-    /**
-     * Maximum number of consecutive failed attempts before giving up.
-     * When exceeded, `getConnectedPeer` throws instead of retrying.
-     * Should greater than 1
-     *
-     * @default Infinity
-     */
-    maxAttempt?: undefined | number;
-    /**
-     * Whether to proactively reconnect right after the socket closes,
-     * rather than waiting for the next call to trigger reconnection.
-     * Reduces latency for the next request.
-     *
-     * @default { enabled: false }
-     */
-    onClose?: undefined | {
-        /**
-         * Whether to proactively reconnect right after the socket closes,
-         * rather than waiting for the next call to trigger reconnection.
-         * Reduces latency for the next request.
-         *
-         * @default false
-         */
-        enabled: boolean;
-        /**
-         * Delay before reconnecting after the socket closes, in milliseconds.
-         *
-         * @default 0
-         */
-        delay?: number;
-    };
-}
-interface WebSocketLinkTransportOptions<_T extends ClientContext> {
-    /**
-     * Returns a WebSocket instance for peer communication.
-     * Can be async for lazy resolution.
-     */
-    connect: (info: WebSocketLinkTransportAttemptInfo) => Promisable<WebSocketLike>;
-    /**
-     * Whether to connect immediately on initialization, instead of waiting
-     * for the first call. Reduces latency for the first request.
-     *
-     * @default false
-     */
-    connectOnInit?: undefined | boolean;
-    /**
-     * Reconnection behavior when the connection is lost.
-     *
-     * @default { enabled: false }
-     */
-    reconnect?: undefined | WebSocketLinkTransportReconnectOptions;
-    /**
-     * Options for encoding peer messages. such as `prefix` for distinguishing messages on the same channel..
-     */
-    encodePeerMessage?: EncodePeerMessageOptions | undefined;
-    /**
-     * Options for decoding peer messages. such as `prefix` for distinguishing messages on the same channel..
-     */
-    decodePeerMessage?: DecodePeerMessageOptions | undefined;
-}
-declare class WebSocketLinkTransport<T extends ClientContext> implements StandardLinkTransport<T> {
-    private readonly connect;
-    private readonly reconnectEnabled;
-    private readonly reconnectDelay;
-    private readonly reconnectMaxAttempt;
-    private readonly reconnectOnCloseEnabled;
-    private readonly reconnectOnCloseDelay;
-    private readonly encodePeerMessageOptions;
-    private readonly decodePeerMessageOptions;
-    constructor(options: WebSocketLinkTransportOptions<T>);
-    send(standardRequest: StandardRequest, _path: string[], _options: ClientOptions<T>): Promise<StandardLazyResponse>;
-    private totalAttempt;
-    private attempt;
-    private current;
-    private getConnectedPeer;
+declare class LinkWebsocketClient<T extends ClientContext> implements StandardLinkClient<T> {
+    private readonly peer;
+    constructor(options: LinkWebsocketClientOptions);
+    call(request: StandardRequest, _options: ClientOptions<T>, _path: readonly string[], _input: unknown): Promise<StandardLazyResponse>;
 }
 
-interface RPCLinkOptions<T extends ClientContext> extends StandardLinkOptions<T>, WebSocketLinkTransportOptions<T>, RPCLinkCodecOptions<T> {
+interface RPCLinkOptions<T extends ClientContext> extends Omit<StandardRPCLinkOptions<T>, 'url' | 'method' | 'fallbackMethod' | 'maxUrlLength'>, LinkWebsocketClientOptions {
 }
-declare class RPCLink<T extends ClientContext> extends StandardLink<T> {
+/**
+ * The RPC Link communicates with the server using the RPC protocol over WebSocket.
+ *
+ * @see {@link https://orpc.dev/docs/client/rpc-link RPC Link Docs}
+ * @see {@link https://orpc.dev/docs/adapters/websocket WebSocket Adapter Docs}
+ */
+declare class RPCLink<T extends ClientContext> extends StandardRPCLink<T> {
     constructor(options: RPCLinkOptions<T>);
 }
 
-export { RPCLink, WebSocketLinkTransport };
-export type { RPCLinkOptions, WebSocketLike, WebSocketLinkTransportAttemptInfo, WebSocketLinkTransportOptions, WebSocketLinkTransportReconnectOptions };
+export { LinkWebsocketClient, RPCLink };
+export type { LinkWebsocketClientOptions, RPCLinkOptions };