@orpc/server 1.14.6 → 2.0.0-beta.10

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

@@ -1,21 +1,19 @@
-import { S as StandardCodec, a as StandardParams } from '../../shared/server.BqadksTP.mjs';
-export { C as CompositeStandardHandlerPlugin, b as StandardHandleOptions, c as StandardHandleResult, f as StandardHandler, d as StandardHandlerInterceptorOptions, e as StandardHandlerOptions, g as StandardHandlerPlugin, h as StandardMatchResult, i as StandardMatcher } from '../../shared/server.BqadksTP.mjs';
-import { ORPCError } from '@orpc/client';
-import { StandardRPCSerializer } from '@orpc/client/standard';
-import { StandardLazyRequest, StandardResponse } from '@orpc/standard-server';
-import { A as AnyProcedure } from '../../shared/server.qKsRrdxW.mjs';
-export { a as StandardRPCHandler, S as StandardRPCHandlerOptions, c as StandardRPCMatcher, b as StandardRPCMatcherOptions } from '../../shared/server.ChUyt5-i.mjs';
-export { F as FriendlyStandardHandleOptions, r as resolveFriendlyStandardHandleOptions } from '../../shared/server.B8gYOD5g.mjs';
-import '@orpc/contract';
+import { b as StandardHandlerHandleOptions } from '../../shared/server.DJIkub_t.mjs';
+export { C as CompositeStandardHandlerPlugin, O as OtelHandlerPlugin, S as StandardHandler, c as StandardHandlerCodec, d as StandardHandlerCodecResolvedProcedure, h as StandardHandlerHandleResult, i as StandardHandlerInterceptor, g as StandardHandlerInterceptorOptions, a as StandardHandlerOptions, e as StandardHandlerPlugin, j as StandardHandlerRoutingInterceptor, f as StandardHandlerRoutingInterceptorOptions } from '../../shared/server.DJIkub_t.mjs';
+export { a as RPCHandlerCodec, R as RPCHandlerCodecOptions, b as RPCMatcher, c as RPCMatcherOptions } from '../../shared/server.Cj5lgPuG.mjs';
+import { C as Context } from '../../shared/server.BL22TloH.mjs';
+export { StandardBody, StandardBodyHint, StandardHeaders, StandardLazyRequest, StandardLazyResponse, StandardMethod, StandardRequest, StandardResponse, StandardUrl } from '@standardserver/core';
+import '@orpc/client';
 import '@orpc/shared';
-import '../../shared/server.C8_sRzQB.mjs';
+import '@orpc/contract';
+import '../../shared/server.BsNNjG5J.mjs';
 
-declare class StandardRPCCodec implements StandardCodec {
-    private readonly serializer;
-    constructor(serializer: StandardRPCSerializer);
-    decode(request: StandardLazyRequest, _params: StandardParams | undefined, _procedure: AnyProcedure): Promise<unknown>;
-    encode(output: unknown, _procedure: AnyProcedure): StandardResponse;
-    encodeError(error: ORPCError<any, any>): StandardResponse;
-}
+type FriendlyStandardHandlerHandleOptions<T extends Context> = Omit<StandardHandlerHandleOptions<T>, 'context'> & (object extends T ? {
+    context?: T;
+} : {
+    context: T;
+});
+declare function resolveFriendlyStandardHandlerHandleOptions<T extends Context>(options: FriendlyStandardHandlerHandleOptions<T>): StandardHandlerHandleOptions<T>;
 
-export { StandardCodec, StandardParams, StandardRPCCodec };
+export { StandardHandlerHandleOptions, resolveFriendlyStandardHandlerHandleOptions };
+export type { FriendlyStandardHandlerHandleOptions };

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

@@ -1,21 +1,19 @@
-import { S as StandardCodec, a as StandardParams } from '../../shared/server.7cEtMB30.js';
-export { C as CompositeStandardHandlerPlugin, b as StandardHandleOptions, c as StandardHandleResult, f as StandardHandler, d as StandardHandlerInterceptorOptions, e as StandardHandlerOptions, g as StandardHandlerPlugin, h as StandardMatchResult, i as StandardMatcher } from '../../shared/server.7cEtMB30.js';
-import { ORPCError } from '@orpc/client';
-import { StandardRPCSerializer } from '@orpc/client/standard';
-import { StandardLazyRequest, StandardResponse } from '@orpc/standard-server';
-import { A as AnyProcedure } from '../../shared/server.qKsRrdxW.js';
-export { a as StandardRPCHandler, S as StandardRPCHandlerOptions, c as StandardRPCMatcher, b as StandardRPCMatcherOptions } from '../../shared/server.yoEB3Fx4.js';
-export { F as FriendlyStandardHandleOptions, r as resolveFriendlyStandardHandleOptions } from '../../shared/server.EfTOZ2Q7.js';
-import '@orpc/contract';
+import { b as StandardHandlerHandleOptions } from '../../shared/server.DBANIheG.js';
+export { C as CompositeStandardHandlerPlugin, O as OtelHandlerPlugin, S as StandardHandler, c as StandardHandlerCodec, d as StandardHandlerCodecResolvedProcedure, h as StandardHandlerHandleResult, i as StandardHandlerInterceptor, g as StandardHandlerInterceptorOptions, a as StandardHandlerOptions, e as StandardHandlerPlugin, j as StandardHandlerRoutingInterceptor, f as StandardHandlerRoutingInterceptorOptions } from '../../shared/server.DBANIheG.js';
+export { a as RPCHandlerCodec, R as RPCHandlerCodecOptions, b as RPCMatcher, c as RPCMatcherOptions } from '../../shared/server.d_2NS3g5.js';
+import { C as Context } from '../../shared/server.BL22TloH.js';
+export { StandardBody, StandardBodyHint, StandardHeaders, StandardLazyRequest, StandardLazyResponse, StandardMethod, StandardRequest, StandardResponse, StandardUrl } from '@standardserver/core';
+import '@orpc/client';
 import '@orpc/shared';
-import '../../shared/server.ChyoA9XY.js';
+import '@orpc/contract';
+import '../../shared/server.Pa0F03f_.js';
 
-declare class StandardRPCCodec implements StandardCodec {
-    private readonly serializer;
-    constructor(serializer: StandardRPCSerializer);
-    decode(request: StandardLazyRequest, _params: StandardParams | undefined, _procedure: AnyProcedure): Promise<unknown>;
-    encode(output: unknown, _procedure: AnyProcedure): StandardResponse;
-    encodeError(error: ORPCError<any, any>): StandardResponse;
-}
+type FriendlyStandardHandlerHandleOptions<T extends Context> = Omit<StandardHandlerHandleOptions<T>, 'context'> & (object extends T ? {
+    context?: T;
+} : {
+    context: T;
+});
+declare function resolveFriendlyStandardHandlerHandleOptions<T extends Context>(options: FriendlyStandardHandlerHandleOptions<T>): StandardHandlerHandleOptions<T>;
 
-export { StandardCodec, StandardParams, StandardRPCCodec };
+export { StandardHandlerHandleOptions, resolveFriendlyStandardHandlerHandleOptions };
+export type { FriendlyStandardHandlerHandleOptions };

package/dist/adapters/standard/index.mjs

@@ -1,8 +1,8 @@
-export { C as CompositeStandardHandlerPlugin, S as StandardHandler, a as StandardRPCCodec, b as StandardRPCHandler, c as StandardRPCMatcher } from '../../shared/server.ZxHCEN1h.mjs';
-export { r as resolveFriendlyStandardHandleOptions } from '../../shared/server.DZ5BIITo.mjs';
-import '@orpc/client/standard';
+export { C as CompositeStandardHandlerPlugin, O as OtelHandlerPlugin, R as RPCHandlerCodec, a as RPCMatcher, S as StandardHandler } from '../../shared/server.GDpX6Df8.mjs';
+export { r as resolveFriendlyStandardHandlerHandleOptions } from '../../shared/server.W91HSRkE.mjs';
 import '@orpc/client';
 import '@orpc/shared';
-import '@orpc/standard-server';
-import '../../shared/server.DEBcqOjg.mjs';
+import '@standardserver/core';
+import '../../shared/server.CrlKQucM.mjs';
 import '@orpc/contract';
+import '../../shared/server.BwHnWUuN.mjs';

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

@@ -1,18 +1,16 @@
-import { ServerPeer, EncodedMessage, ServerPeerHandleRequestFn } from '@orpc/standard-server-peer';
-import { C as Context } from '../../shared/server.qKsRrdxW.mjs';
-import { F as FriendlyStandardHandleOptions } from '../../shared/server.B8gYOD5g.mjs';
-import { f as StandardHandler } from '../../shared/server.BqadksTP.mjs';
+import { Value, Promisable } from '@orpc/shared';
+import { StandardLazyRequest, StandardResponse } from '@standardserver/core';
+import { C as Context } from '../../shared/server.BL22TloH.mjs';
+import { b as StandardHandlerHandleOptions, S as StandardHandler } from '../../shared/server.DJIkub_t.mjs';
 import '@orpc/client';
 import '@orpc/contract';
-import '@orpc/shared';
-import '@orpc/standard-server';
 
-type HandleStandardServerPeerMessageOptions<T extends Context> = Omit<FriendlyStandardHandleOptions<T>, 'prefix'>;
-/**
- * @deprecated Use `createServerPeerRequestHandleFn` instead.
- */
-declare function handleStandardServerPeerMessage<T extends Context>(handler: StandardHandler<T>, peer: ServerPeer, message: EncodedMessage, options: HandleStandardServerPeerMessageOptions<T>): Promise<void>;
-declare function createServerPeerHandleRequestFn<T extends Context>(handler: StandardHandler<T>, options: HandleStandardServerPeerMessageOptions<T>): ServerPeerHandleRequestFn;
+type StandardPeerRequestHandlerOptions<T extends Context> = Omit<StandardHandlerHandleOptions<T>, 'context'> & (Record<never, never> extends T ? {
+    context?: Value<Promisable<T>, [request: StandardLazyRequest]>;
+} : {
+    context: Value<Promisable<T>, [request: StandardLazyRequest]>;
+});
+declare function createStandardPeerRequestHandler<T extends Context>(handler: StandardHandler<T>, options: StandardPeerRequestHandlerOptions<T>): (request: StandardLazyRequest) => Promise<StandardResponse>;
 
-export { createServerPeerHandleRequestFn, handleStandardServerPeerMessage };
-export type { HandleStandardServerPeerMessageOptions };
+export { createStandardPeerRequestHandler };
+export type { StandardPeerRequestHandlerOptions };

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

@@ -1,18 +1,16 @@
-import { ServerPeer, EncodedMessage, ServerPeerHandleRequestFn } from '@orpc/standard-server-peer';
-import { C as Context } from '../../shared/server.qKsRrdxW.js';
-import { F as FriendlyStandardHandleOptions } from '../../shared/server.EfTOZ2Q7.js';
-import { f as StandardHandler } from '../../shared/server.7cEtMB30.js';
+import { Value, Promisable } from '@orpc/shared';
+import { StandardLazyRequest, StandardResponse } from '@standardserver/core';
+import { C as Context } from '../../shared/server.BL22TloH.js';
+import { b as StandardHandlerHandleOptions, S as StandardHandler } from '../../shared/server.DBANIheG.js';
 import '@orpc/client';
 import '@orpc/contract';
-import '@orpc/shared';
-import '@orpc/standard-server';
 
-type HandleStandardServerPeerMessageOptions<T extends Context> = Omit<FriendlyStandardHandleOptions<T>, 'prefix'>;
-/**
- * @deprecated Use `createServerPeerRequestHandleFn` instead.
- */
-declare function handleStandardServerPeerMessage<T extends Context>(handler: StandardHandler<T>, peer: ServerPeer, message: EncodedMessage, options: HandleStandardServerPeerMessageOptions<T>): Promise<void>;
-declare function createServerPeerHandleRequestFn<T extends Context>(handler: StandardHandler<T>, options: HandleStandardServerPeerMessageOptions<T>): ServerPeerHandleRequestFn;
+type StandardPeerRequestHandlerOptions<T extends Context> = Omit<StandardHandlerHandleOptions<T>, 'context'> & (Record<never, never> extends T ? {
+    context?: Value<Promisable<T>, [request: StandardLazyRequest]>;
+} : {
+    context: Value<Promisable<T>, [request: StandardLazyRequest]>;
+});
+declare function createStandardPeerRequestHandler<T extends Context>(handler: StandardHandler<T>, options: StandardPeerRequestHandlerOptions<T>): (request: StandardLazyRequest) => Promise<StandardResponse>;
 
-export { createServerPeerHandleRequestFn, handleStandardServerPeerMessage };
-export type { HandleStandardServerPeerMessageOptions };
+export { createStandardPeerRequestHandler };
+export type { StandardPeerRequestHandlerOptions };

package/dist/adapters/standard-peer/index.mjs

@@ -1,21 +1,2 @@
-import { r as resolveFriendlyStandardHandleOptions } from '../../shared/server.DZ5BIITo.mjs';
-
-async function handleStandardServerPeerMessage(handler, peer, message, options) {
-  const [id, request] = await peer.message(message);
-  if (!request) {
-    return;
-  }
-  const handle = createServerPeerHandleRequestFn(handler, options);
-  await peer.response(id, await handle(request));
-}
-function createServerPeerHandleRequestFn(handler, options) {
-  return async (request) => {
-    const { response } = await handler.handle(
-      { ...request, body: () => Promise.resolve(request.body) },
-      resolveFriendlyStandardHandleOptions(options)
-    );
-    return response ?? { status: 404, headers: {}, body: "No procedure matched" };
-  };
-}
-
-export { createServerPeerHandleRequestFn, handleStandardServerPeerMessage };
+export { c as createStandardPeerRequestHandler } from '../../shared/server.CX4vUnDk.mjs';
+import '@orpc/shared';

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

@@ -1,56 +1,70 @@
 import { MaybeOptionalOptions } from '@orpc/shared';
-import { C as Context, R as Router } from '../../shared/server.qKsRrdxW.mjs';
-import { HandleStandardServerPeerMessageOptions } from '../standard-peer/index.mjs';
-import { f as StandardHandler } from '../../shared/server.BqadksTP.mjs';
-import { S as StandardRPCHandlerOptions } from '../../shared/server.ChUyt5-i.mjs';
+import { EncodePeerMessageOptions, DecodePeerMessageOptions } from '@standardserver/peer';
+import { C as Context } from '../../shared/server.BL22TloH.mjs';
+import { S as StandardHandler, a as StandardHandlerOptions } from '../../shared/server.DJIkub_t.mjs';
+import { StandardPeerRequestHandlerOptions } from '../standard-peer/index.mjs';
+import { R as Router } from '../../shared/server.BsNNjG5J.mjs';
+import { R as RPCHandlerCodecOptions } from '../../shared/server.Cj5lgPuG.mjs';
 import '@orpc/client';
 import '@orpc/contract';
-import '@orpc/standard-server-peer';
-import '../../shared/server.B8gYOD5g.mjs';
-import '@orpc/standard-server';
-import '@orpc/client/standard';
-import '../../shared/server.C8_sRzQB.mjs';
+import '@standardserver/core';
 
-type MinimalWebsocket = Pick<WebSocket, 'addEventListener' | 'send'>;
-declare class WebsocketHandler<T extends Context> {
-    #private;
-    constructor(standardHandler: StandardHandler<T>);
+/**
+ * Supports standard WebSocket instances, Bun ServerWebSocket, "ws" ServerWebSocket,
+ * Cloudflare WebSocket Hibernation, and similar implementations.
+ */
+type WebSocketLike = {
+    send: (data: string | Uint8Array<ArrayBuffer>) => unknown;
+};
+interface WebSocketHandlerOptions<_T extends Context> {
+    /**
+     * Options for encoding peer messages. such as `prefix` for distinguishing messages on the same channel..
+     */
+    encodePeerMessage?: EncodePeerMessageOptions | undefined;
     /**
-     * Upgrades a WebSocket to enable handling
+     * Options for decoding peer messages. such as `prefix` for distinguishing messages on the same channel..
+     */
+    decodePeerMessage?: DecodePeerMessageOptions | undefined;
+}
+declare class WebSocketHandler<T extends Context> {
+    private readonly handler;
+    private readonly peers;
+    private readonly encodePeerMessageOptions;
+    private readonly decodePeerMessageOptions;
+    constructor(handler: StandardHandler<T>, options?: NoInfer<WebSocketHandlerOptions<T>>);
+    /**
+     * Handles a single message received from a WebSocket.
      *
-     * This attaches the necessary 'message' and 'close' listeners to the WebSocket
+     * @warning AVOID calling this method, if `.upgrade()` is used, as `.upgrade()` already sets up necessary event listeners to call this method for incoming messages and manage peer lifecycle.
      *
-     * @warning Do not use this method if you're using `.message()` or `.close()`
+     * @param ws The WebSocket instance, require consistent instance across messages for proper peer management
+     * @param data The message data received from the WebSocket, can be string, ArrayBuffer, Blob, ...
      */
-    upgrade(ws: MinimalWebsocket, ...rest: MaybeOptionalOptions<HandleStandardServerPeerMessageOptions<T>>): void;
+    message(ws: WebSocketLike, data: string | ArrayBuffer | Blob | Exclude<ConstructorParameters<typeof Blob>[0], undefined>[0][] | Pick<Uint8Array<ArrayBuffer>, 'buffer' | 'byteOffset' | 'byteLength'>, ...rest: MaybeOptionalOptions<StandardPeerRequestHandlerOptions<T>>): Promise<{
+        matched: boolean;
+    }>;
     /**
-     * Handles a single message received from a WebSocket.
+     * Called when a websocket is closed, to clean up any associated peer state.
      *
-     * @warning Avoid calling this directly if `.upgrade()` is used.
+     * @warning AVOID calling this method, if `.upgrade()` is used, as `.upgrade()` already sets up necessary event listeners to call this method for incoming messages and manage peer lifecycle.
      *
-     * @param ws The WebSocket instance
-     * @param data The message payload, usually place in `event.data`
+     * @param ws The WebSocket instance to clean up, must be the same instance used in `.message()` calls to properly clean up
      */
-    message(ws: MinimalWebsocket, data: string | ArrayBuffer | Blob, ...rest: MaybeOptionalOptions<HandleStandardServerPeerMessageOptions<T>>): Promise<void>;
+    close(ws: WebSocketLike): Promise<void>;
     /**
-     * Closes the WebSocket peer and cleans up.
+     * Attaches websocket event listeners for message and close handling.
      *
-     * @warning Avoid calling this directly if `.upgrade()` is used.
+     * Use this instead of calling `.message()` and `.close()` manually.
+     * Requires a websocket-like object that supports `addEventListener` and `removeEventListener`.
      */
-    close(ws: MinimalWebsocket): void;
+    upgrade(ws: Pick<WebSocket, 'send' | 'addEventListener' | 'removeEventListener'>, ...rest: MaybeOptionalOptions<StandardPeerRequestHandlerOptions<T>>): void;
 }
 
-interface RPCHandlerOptions<T extends Context> extends StandardRPCHandlerOptions<T> {
+interface RPCHandlerOptions<T extends Context> extends StandardHandlerOptions<T>, RPCHandlerCodecOptions<T>, WebSocketHandlerOptions<T> {
 }
-/**
- * RPC Handler for Websocket adapter
- *
- * @see {@link https://orpc.dev/docs/rpc-handler RPC Handler Docs}
- * @see {@link https://orpc.dev/docs/adapters/websocket Websocket Adapter Docs}
- */
-declare class RPCHandler<T extends Context> extends WebsocketHandler<T> {
-    constructor(router: Router<any, T>, options?: NoInfer<RPCHandlerOptions<T>>);
+declare class RPCHandler<T extends Context> extends WebSocketHandler<T> {
+    constructor(router: Router<T>, options?: NoInfer<RPCHandlerOptions<T>>);
 }
 
-export { RPCHandler, WebsocketHandler };
-export type { MinimalWebsocket, RPCHandlerOptions };
+export { RPCHandler, WebSocketHandler };
+export type { RPCHandlerOptions, WebSocketHandlerOptions, WebSocketLike };

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

@@ -1,56 +1,70 @@
 import { MaybeOptionalOptions } from '@orpc/shared';
-import { C as Context, R as Router } from '../../shared/server.qKsRrdxW.js';
-import { HandleStandardServerPeerMessageOptions } from '../standard-peer/index.js';
-import { f as StandardHandler } from '../../shared/server.7cEtMB30.js';
-import { S as StandardRPCHandlerOptions } from '../../shared/server.yoEB3Fx4.js';
+import { EncodePeerMessageOptions, DecodePeerMessageOptions } from '@standardserver/peer';
+import { C as Context } from '../../shared/server.BL22TloH.js';
+import { S as StandardHandler, a as StandardHandlerOptions } from '../../shared/server.DBANIheG.js';
+import { StandardPeerRequestHandlerOptions } from '../standard-peer/index.js';
+import { R as Router } from '../../shared/server.Pa0F03f_.js';
+import { R as RPCHandlerCodecOptions } from '../../shared/server.d_2NS3g5.js';
 import '@orpc/client';
 import '@orpc/contract';
-import '@orpc/standard-server-peer';
-import '../../shared/server.EfTOZ2Q7.js';
-import '@orpc/standard-server';
-import '@orpc/client/standard';
-import '../../shared/server.ChyoA9XY.js';
+import '@standardserver/core';
 
-type MinimalWebsocket = Pick<WebSocket, 'addEventListener' | 'send'>;
-declare class WebsocketHandler<T extends Context> {
-    #private;
-    constructor(standardHandler: StandardHandler<T>);
+/**
+ * Supports standard WebSocket instances, Bun ServerWebSocket, "ws" ServerWebSocket,
+ * Cloudflare WebSocket Hibernation, and similar implementations.
+ */
+type WebSocketLike = {
+    send: (data: string | Uint8Array<ArrayBuffer>) => unknown;
+};
+interface WebSocketHandlerOptions<_T extends Context> {
+    /**
+     * Options for encoding peer messages. such as `prefix` for distinguishing messages on the same channel..
+     */
+    encodePeerMessage?: EncodePeerMessageOptions | undefined;
     /**
-     * Upgrades a WebSocket to enable handling
+     * Options for decoding peer messages. such as `prefix` for distinguishing messages on the same channel..
+     */
+    decodePeerMessage?: DecodePeerMessageOptions | undefined;
+}
+declare class WebSocketHandler<T extends Context> {
+    private readonly handler;
+    private readonly peers;
+    private readonly encodePeerMessageOptions;
+    private readonly decodePeerMessageOptions;
+    constructor(handler: StandardHandler<T>, options?: NoInfer<WebSocketHandlerOptions<T>>);
+    /**
+     * Handles a single message received from a WebSocket.
      *
-     * This attaches the necessary 'message' and 'close' listeners to the WebSocket
+     * @warning AVOID calling this method, if `.upgrade()` is used, as `.upgrade()` already sets up necessary event listeners to call this method for incoming messages and manage peer lifecycle.
      *
-     * @warning Do not use this method if you're using `.message()` or `.close()`
+     * @param ws The WebSocket instance, require consistent instance across messages for proper peer management
+     * @param data The message data received from the WebSocket, can be string, ArrayBuffer, Blob, ...
      */
-    upgrade(ws: MinimalWebsocket, ...rest: MaybeOptionalOptions<HandleStandardServerPeerMessageOptions<T>>): void;
+    message(ws: WebSocketLike, data: string | ArrayBuffer | Blob | Exclude<ConstructorParameters<typeof Blob>[0], undefined>[0][] | Pick<Uint8Array<ArrayBuffer>, 'buffer' | 'byteOffset' | 'byteLength'>, ...rest: MaybeOptionalOptions<StandardPeerRequestHandlerOptions<T>>): Promise<{
+        matched: boolean;
+    }>;
     /**
-     * Handles a single message received from a WebSocket.
+     * Called when a websocket is closed, to clean up any associated peer state.
      *
-     * @warning Avoid calling this directly if `.upgrade()` is used.
+     * @warning AVOID calling this method, if `.upgrade()` is used, as `.upgrade()` already sets up necessary event listeners to call this method for incoming messages and manage peer lifecycle.
      *
-     * @param ws The WebSocket instance
-     * @param data The message payload, usually place in `event.data`
+     * @param ws The WebSocket instance to clean up, must be the same instance used in `.message()` calls to properly clean up
      */
-    message(ws: MinimalWebsocket, data: string | ArrayBuffer | Blob, ...rest: MaybeOptionalOptions<HandleStandardServerPeerMessageOptions<T>>): Promise<void>;
+    close(ws: WebSocketLike): Promise<void>;
     /**
-     * Closes the WebSocket peer and cleans up.
+     * Attaches websocket event listeners for message and close handling.
      *
-     * @warning Avoid calling this directly if `.upgrade()` is used.
+     * Use this instead of calling `.message()` and `.close()` manually.
+     * Requires a websocket-like object that supports `addEventListener` and `removeEventListener`.
      */
-    close(ws: MinimalWebsocket): void;
+    upgrade(ws: Pick<WebSocket, 'send' | 'addEventListener' | 'removeEventListener'>, ...rest: MaybeOptionalOptions<StandardPeerRequestHandlerOptions<T>>): void;
 }
 
-interface RPCHandlerOptions<T extends Context> extends StandardRPCHandlerOptions<T> {
+interface RPCHandlerOptions<T extends Context> extends StandardHandlerOptions<T>, RPCHandlerCodecOptions<T>, WebSocketHandlerOptions<T> {
 }
-/**
- * RPC Handler for Websocket adapter
- *
- * @see {@link https://orpc.dev/docs/rpc-handler RPC Handler Docs}
- * @see {@link https://orpc.dev/docs/adapters/websocket Websocket Adapter Docs}
- */
-declare class RPCHandler<T extends Context> extends WebsocketHandler<T> {
-    constructor(router: Router<any, T>, options?: NoInfer<RPCHandlerOptions<T>>);
+declare class RPCHandler<T extends Context> extends WebSocketHandler<T> {
+    constructor(router: Router<T>, options?: NoInfer<RPCHandlerOptions<T>>);
 }
 
-export { RPCHandler, WebsocketHandler };
-export type { MinimalWebsocket, RPCHandlerOptions };
+export { RPCHandler, WebSocketHandler };
+export type { RPCHandlerOptions, WebSocketHandlerOptions, WebSocketLike };

package/dist/adapters/websocket/index.mjs

@@ -1,67 +1,80 @@
-import { readAsBuffer, resolveMaybeOptionalOptions } from '@orpc/shared';
-import { ServerPeer } from '@orpc/standard-server-peer';
-import { createServerPeerHandleRequestFn } from '../standard-peer/index.mjs';
-import { b as StandardRPCHandler } from '../../shared/server.ZxHCEN1h.mjs';
-import '../../shared/server.DZ5BIITo.mjs';
-import '@orpc/client/standard';
+import { toStringOrBytes, resolveMaybeOptionalOptions } from '@orpc/shared';
+import { ServerPeer, encodePeerMessage, decodePeerMessage, isClientPeerSendMessage } from '@standardserver/peer';
+import { c as createStandardPeerRequestHandler } from '../../shared/server.CX4vUnDk.mjs';
+import { R as RPCHandlerCodec, S as StandardHandler } from '../../shared/server.GDpX6Df8.mjs';
 import '@orpc/client';
-import '@orpc/standard-server';
-import '../../shared/server.DEBcqOjg.mjs';
+import '@standardserver/core';
+import '../../shared/server.CrlKQucM.mjs';
 import '@orpc/contract';
+import '../../shared/server.BwHnWUuN.mjs';
 
-class WebsocketHandler {
-  #peers = /* @__PURE__ */ new WeakMap();
-  #handler;
-  constructor(standardHandler) {
-    this.#handler = standardHandler;
-  }
-  /**
-   * Upgrades a WebSocket to enable handling
-   *
-   * This attaches the necessary 'message' and 'close' listeners to the WebSocket
-   *
-   * @warning Do not use this method if you're using `.message()` or `.close()`
-   */
-  upgrade(ws, ...rest) {
-    ws.addEventListener("message", (event) => this.message(ws, event.data, ...rest));
-    ws.addEventListener("close", () => this.close(ws));
+class WebSocketHandler {
+  constructor(handler, options = {}) {
+    this.handler = handler;
+    this.encodePeerMessageOptions = options.encodePeerMessage;
+    this.decodePeerMessageOptions = options.decodePeerMessage;
   }
+  peers = /* @__PURE__ */ new WeakMap();
+  encodePeerMessageOptions;
+  decodePeerMessageOptions;
   /**
    * Handles a single message received from a WebSocket.
    *
-   * @warning Avoid calling this directly if `.upgrade()` is used.
+   * @warning AVOID calling this method, if `.upgrade()` is used, as `.upgrade()` already sets up necessary event listeners to call this method for incoming messages and manage peer lifecycle.
    *
-   * @param ws The WebSocket instance
-   * @param data The message payload, usually place in `event.data`
+   * @param ws The WebSocket instance, require consistent instance across messages for proper peer management
+   * @param data The message data received from the WebSocket, can be string, ArrayBuffer, Blob, ...
    */
   async message(ws, data, ...rest) {
-    let peer = this.#peers.get(ws);
+    let peer = this.peers.get(ws);
     if (!peer) {
-      this.#peers.set(ws, peer = new ServerPeer(ws.send.bind(ws)));
+      this.peers.set(ws, peer = new ServerPeer(async (message) => {
+        const encoded2 = await encodePeerMessage(message, this.encodePeerMessageOptions);
+        await ws.send(encoded2);
+      }));
+    }
+    const encoded = await toStringOrBytes(data);
+    const result = decodePeerMessage(encoded, this.decodePeerMessageOptions);
+    if (result.matched && isClientPeerSendMessage(result.message)) {
+      await peer.message(
+        result.message,
+        createStandardPeerRequestHandler(this.handler, resolveMaybeOptionalOptions(rest))
+      );
     }
-    const message = data instanceof Blob ? await readAsBuffer(data) : data;
-    await peer.message(
-      message,
-      createServerPeerHandleRequestFn(this.#handler, resolveMaybeOptionalOptions(rest))
-    );
+    return result;
   }
   /**
-   * Closes the WebSocket peer and cleans up.
+   * Called when a websocket is closed, to clean up any associated peer state.
    *
-   * @warning Avoid calling this directly if `.upgrade()` is used.
+   * @warning AVOID calling this method, if `.upgrade()` is used, as `.upgrade()` already sets up necessary event listeners to call this method for incoming messages and manage peer lifecycle.
+   *
+   * @param ws The WebSocket instance to clean up, must be the same instance used in `.message()` calls to properly clean up
    */
-  close(ws) {
-    const peer = this.#peers.get(ws);
+  async close(ws) {
+    const peer = this.peers.get(ws);
     if (peer) {
-      peer.close();
+      await peer.close();
+      this.peers.delete(ws);
     }
   }
+  /**
+   * Attaches websocket event listeners for message and close handling.
+   *
+   * Use this instead of calling `.message()` and `.close()` manually.
+   * Requires a websocket-like object that supports `addEventListener` and `removeEventListener`.
+   */
+  upgrade(ws, ...rest) {
+    ws.addEventListener("message", (event) => this.message(ws, event.data, ...rest));
+    ws.addEventListener("close", () => this.close(ws));
+  }
 }
 
-class RPCHandler extends WebsocketHandler {
+class RPCHandler extends WebSocketHandler {
   constructor(router, options = {}) {
-    super(new StandardRPCHandler(router, options));
+    const codec = new RPCHandlerCodec(router, options);
+    const handler = new StandardHandler(codec, options);
+    super(handler, options);
   }
 }
 
-export { RPCHandler, WebsocketHandler };
+export { RPCHandler, WebSocketHandler };

package/dist/extensions/callable.d.mts

@@ -0,0 +1,10 @@
+import { AnyORPCError, ClientContext } from '@orpc/client';
+import { AnySchema, ErrorMap } from '@orpc/contract';
+import { MaybeOptionalOptions } from '@orpc/shared';
+import { C as Context, P as ProcedureClientOptions, a as Procedure, b as ProcedureClient } from '../shared/server.BL22TloH.mjs';
+
+declare module "../index" {
+    interface DecoratedProcedure<TInitialContext extends Context, TInjectedContext extends Context, TInputSchema extends AnySchema, TOutputSchema extends AnySchema, TErrorMap extends ErrorMap, TReturnedError extends AnyORPCError> {
+        callable<TClientContext extends ClientContext>(...rest: MaybeOptionalOptions<ProcedureClientOptions<TInitialContext, TOutputSchema, TErrorMap, TReturnedError, TClientContext>>): Procedure<TInitialContext, TInjectedContext, TInputSchema, TOutputSchema, TErrorMap, TReturnedError> & ProcedureClient<TClientContext, TInputSchema, TOutputSchema, TErrorMap, TReturnedError>;
+    }
+}

package/dist/extensions/callable.d.ts

@@ -0,0 +1,10 @@
+import { AnyORPCError, ClientContext } from '@orpc/client';
+import { AnySchema, ErrorMap } from '@orpc/contract';
+import { MaybeOptionalOptions } from '@orpc/shared';
+import { C as Context, P as ProcedureClientOptions, a as Procedure, b as ProcedureClient } from '../shared/server.BL22TloH.js';
+
+declare module "../index" {
+    interface DecoratedProcedure<TInitialContext extends Context, TInjectedContext extends Context, TInputSchema extends AnySchema, TOutputSchema extends AnySchema, TErrorMap extends ErrorMap, TReturnedError extends AnyORPCError> {
+        callable<TClientContext extends ClientContext>(...rest: MaybeOptionalOptions<ProcedureClientOptions<TInitialContext, TOutputSchema, TErrorMap, TReturnedError, TClientContext>>): Procedure<TInitialContext, TInjectedContext, TInputSchema, TOutputSchema, TErrorMap, TReturnedError> & ProcedureClient<TClientContext, TInputSchema, TOutputSchema, TErrorMap, TReturnedError>;
+    }
+}

package/dist/extensions/callable.mjs

@@ -0,0 +1,11 @@
+import { c as createProcedureClient } from '../shared/server.CrlKQucM.mjs';
+import { D as DecoratedProcedure } from '../shared/server.CjOb6ItT.mjs';
+import '@orpc/client';
+import '@orpc/contract';
+import '@orpc/shared';
+
+DecoratedProcedure.prototype.callable = function callable(...rest) {
+  const callable2 = createProcedureClient(this, ...rest);
+  callable2["~orpc"] = this["~orpc"];
+  return callable2;
+};

package/dist/helpers/index.d.mts

@@ -1,4 +1,4 @@
-import { SerializeOptions, ParseOptions } from 'cookie';
+import { ParseOptions, SerializeOptions } from 'cookie';
 
 /**
  * Encodes a Uint8Array to base64url format
@@ -25,7 +25,7 @@ declare function encodeBase64url(data: Uint8Array): string;
  * expect(new TextDecoder().decode(decoded)).toEqual(text)
  * ```
  */
-declare function decodeBase64url(base64url: string | undefined | null): Uint8Array | undefined;
+declare function decodeBase64url(base64url: string | undefined | null): Uint8Array<ArrayBuffer> | undefined;
 
 interface SetCookieOptions extends SerializeOptions {
     /**

package/dist/helpers/index.d.ts

@@ -1,4 +1,4 @@
-import { SerializeOptions, ParseOptions } from 'cookie';
+import { ParseOptions, SerializeOptions } from 'cookie';
 
 /**
  * Encodes a Uint8Array to base64url format
@@ -25,7 +25,7 @@ declare function encodeBase64url(data: Uint8Array): string;
  * expect(new TextDecoder().decode(decoded)).toEqual(text)
  * ```
  */
-declare function decodeBase64url(base64url: string | undefined | null): Uint8Array | undefined;
+declare function decodeBase64url(base64url: string | undefined | null): Uint8Array<ArrayBuffer> | undefined;
 
 interface SetCookieOptions extends SerializeOptions {
     /**

package/dist/helpers/index.mjs

@@ -1,4 +1,4 @@
-import { serialize, parse } from 'cookie';
+import { parse, serialize } from 'cookie';
 
 function encodeBase64url(data) {
   const chunkSize = 8192;