@orpc/server 0.0.0-next.93e7a4c → 0.0.0-next.93fa264

package/dist/adapters/fetch/index.mjs

@@ -0,0 +1,110 @@
+import { ORPCError } from '@orpc/client';
+import { toArray, intercept, resolveMaybeOptionalOptions } from '@orpc/shared';
+import { toStandardLazyRequest, toFetchResponse } from '@orpc/standard-server-fetch';
+import { r as resolveFriendlyStandardHandleOptions } from '../../shared/server.DZ5BIITo.mjs';
+import '@orpc/standard-server';
+import '@orpc/contract';
+import { C as CompositeStandardHandlerPlugin, b as StandardRPCHandler } from '../../shared/server.CHvOkcM3.mjs';
+import '@orpc/client/standard';
+import '@orpc/standard-server/batch';
+import { S as StrictGetMethodPlugin } from '../../shared/server.BW-nUGgA.mjs';
+import '../../shared/server.DG7Tamti.mjs';
+
+class BodyLimitPlugin {
+  maxBodySize;
+  constructor(options) {
+    this.maxBodySize = options.maxBodySize;
+  }
+  initRuntimeAdapter(options) {
+    options.adapterInterceptors ??= [];
+    options.adapterInterceptors.push(async (options2) => {
+      if (!options2.request.body) {
+        return options2.next();
+      }
+      let currentBodySize = 0;
+      const rawReader = options2.request.body.getReader();
+      const reader = new ReadableStream({
+        start: async (controller) => {
+          try {
+            if (Number(options2.request.headers.get("content-length")) > this.maxBodySize) {
+              controller.error(new ORPCError("PAYLOAD_TOO_LARGE"));
+              return;
+            }
+            while (true) {
+              const { done, value } = await rawReader.read();
+              if (done) {
+                break;
+              }
+              currentBodySize += value.length;
+              if (currentBodySize > this.maxBodySize) {
+                controller.error(new ORPCError("PAYLOAD_TOO_LARGE"));
+                break;
+              }
+              controller.enqueue(value);
+            }
+          } finally {
+            controller.close();
+          }
+        }
+      });
+      const requestInit = { body: reader, duplex: "half" };
+      return options2.next({
+        ...options2,
+        request: new Request(options2.request, requestInit)
+      });
+    });
+  }
+}
+
+class CompositeFetchHandlerPlugin extends CompositeStandardHandlerPlugin {
+  initRuntimeAdapter(options) {
+    for (const plugin of this.plugins) {
+      plugin.initRuntimeAdapter?.(options);
+    }
+  }
+}
+
+class FetchHandler {
+  constructor(standardHandler, options = {}) {
+    this.standardHandler = standardHandler;
+    const plugin = new CompositeFetchHandlerPlugin(options.plugins);
+    plugin.initRuntimeAdapter(options);
+    this.adapterInterceptors = toArray(options.adapterInterceptors);
+    this.toFetchResponseOptions = options;
+  }
+  toFetchResponseOptions;
+  adapterInterceptors;
+  async handle(request, ...rest) {
+    return intercept(
+      this.adapterInterceptors,
+      {
+        ...resolveFriendlyStandardHandleOptions(resolveMaybeOptionalOptions(rest)),
+        request,
+        toFetchResponseOptions: this.toFetchResponseOptions
+      },
+      async ({ request: request2, toFetchResponseOptions, ...options }) => {
+        const standardRequest = toStandardLazyRequest(request2);
+        const result = await this.standardHandler.handle(standardRequest, options);
+        if (!result.matched) {
+          return result;
+        }
+        return {
+          matched: true,
+          response: toFetchResponse(result.response, toFetchResponseOptions)
+        };
+      }
+    );
+  }
+}
+
+class RPCHandler extends FetchHandler {
+  constructor(router, options = {}) {
+    if (options.strictGetMethodPluginEnabled ?? true) {
+      options.plugins ??= [];
+      options.plugins.push(new StrictGetMethodPlugin());
+    }
+    super(new StandardRPCHandler(router, options), options);
+  }
+}
+
+export { BodyLimitPlugin, CompositeFetchHandlerPlugin, FetchHandler, RPCHandler };

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

@@ -0,0 +1,28 @@
+import { SupportedMessagePort } from '@orpc/client/message-port';
+import { MaybeOptionalOptions } from '@orpc/shared';
+import { C as Context, R as Router } from '../../shared/server.DD2C4ujN.mjs';
+import { i as StandardHandler } from '../../shared/server.Dq8xr7PQ.mjs';
+import { F as FriendlyStandardHandleOptions } from '../../shared/server.BliFSTnG.mjs';
+import { S as StandardRPCHandlerOptions } from '../../shared/server.Bd52nNaH.mjs';
+import '@orpc/client';
+import '@orpc/contract';
+import '@orpc/standard-server';
+import '@orpc/client/standard';
+
+declare class experimental_MessagePortHandler<T extends Context> {
+    private readonly standardHandler;
+    constructor(standardHandler: StandardHandler<T>);
+    upgrade(port: SupportedMessagePort, ...rest: MaybeOptionalOptions<Omit<FriendlyStandardHandleOptions<T>, 'prefix'>>): void;
+}
+
+/**
+ * RPC Handler for common message port implementations.
+ *
+ * @see {@link https://orpc.unnoq.com/docs/rpc-handler RPC Handler Docs}
+ * @see {@link https://orpc.unnoq.com/docs/adapters/message-port Message Port Adapter Docs}
+ */
+declare class experimental_RPCHandler<T extends Context> extends experimental_MessagePortHandler<T> {
+    constructor(router: Router<any, T>, options?: NoInfer<StandardRPCHandlerOptions<T>>);
+}
+
+export { experimental_MessagePortHandler, experimental_RPCHandler };

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

@@ -0,0 +1,28 @@
+import { SupportedMessagePort } from '@orpc/client/message-port';
+import { MaybeOptionalOptions } from '@orpc/shared';
+import { C as Context, R as Router } from '../../shared/server.DD2C4ujN.js';
+import { i as StandardHandler } from '../../shared/server.-ACo36I0.js';
+import { F as FriendlyStandardHandleOptions } from '../../shared/server.IG2MjhrD.js';
+import { S as StandardRPCHandlerOptions } from '../../shared/server.BPAWobQg.js';
+import '@orpc/client';
+import '@orpc/contract';
+import '@orpc/standard-server';
+import '@orpc/client/standard';
+
+declare class experimental_MessagePortHandler<T extends Context> {
+    private readonly standardHandler;
+    constructor(standardHandler: StandardHandler<T>);
+    upgrade(port: SupportedMessagePort, ...rest: MaybeOptionalOptions<Omit<FriendlyStandardHandleOptions<T>, 'prefix'>>): void;
+}
+
+/**
+ * RPC Handler for common message port implementations.
+ *
+ * @see {@link https://orpc.unnoq.com/docs/rpc-handler RPC Handler Docs}
+ * @see {@link https://orpc.unnoq.com/docs/adapters/message-port Message Port Adapter Docs}
+ */
+declare class experimental_RPCHandler<T extends Context> extends experimental_MessagePortHandler<T> {
+    constructor(router: Router<any, T>, options?: NoInfer<StandardRPCHandlerOptions<T>>);
+}
+
+export { experimental_MessagePortHandler, experimental_RPCHandler };

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

@@ -0,0 +1,41 @@
+import { postMessagePortMessage, onMessagePortMessage, onMessagePortClose } from '@orpc/client/message-port';
+import { resolveMaybeOptionalOptions } from '@orpc/shared';
+import { ServerPeer } from '@orpc/standard-server-peer';
+import { r as resolveFriendlyStandardHandleOptions } from '../../shared/server.DZ5BIITo.mjs';
+import '@orpc/client';
+import '@orpc/standard-server';
+import '@orpc/contract';
+import { b as StandardRPCHandler } from '../../shared/server.CHvOkcM3.mjs';
+import '@orpc/client/standard';
+import '../../shared/server.DG7Tamti.mjs';
+
+class experimental_MessagePortHandler {
+  constructor(standardHandler) {
+    this.standardHandler = standardHandler;
+  }
+  upgrade(port, ...rest) {
+    const peer = new ServerPeer((message) => {
+      return postMessagePortMessage(port, message);
+    });
+    onMessagePortMessage(port, async (message) => {
+      const [id, request] = await peer.message(message);
+      if (!request) {
+        return;
+      }
+      const options = resolveFriendlyStandardHandleOptions(resolveMaybeOptionalOptions(rest));
+      const { response } = await this.standardHandler.handle({ ...request, body: () => Promise.resolve(request.body) }, options);
+      await peer.response(id, response ?? { status: 404, headers: {}, body: "No procedure matched" });
+    });
+    onMessagePortClose(port, () => {
+      peer.close();
+    });
+  }
+}
+
+class experimental_RPCHandler extends experimental_MessagePortHandler {
+  constructor(router, options = {}) {
+    super(new StandardRPCHandler(router, options));
+  }
+}
+
+export { experimental_MessagePortHandler, experimental_RPCHandler };

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

@@ -0,0 +1,77 @@
+import { C as Context, R as Router } from '../../shared/server.DD2C4ujN.mjs';
+import { Interceptor, MaybeOptionalOptions } from '@orpc/shared';
+import { SendStandardResponseOptions, NodeHttpRequest, NodeHttpResponse } from '@orpc/standard-server-node';
+import { a as StandardHandlerPlugin, C as CompositeStandardHandlerPlugin, g as StandardHandleOptions, i as StandardHandler } from '../../shared/server.Dq8xr7PQ.mjs';
+import { F as FriendlyStandardHandleOptions } from '../../shared/server.BliFSTnG.mjs';
+import { S as StandardRPCHandlerOptions } from '../../shared/server.Bd52nNaH.mjs';
+import '@orpc/client';
+import '@orpc/contract';
+import '@orpc/standard-server';
+import '@orpc/client/standard';
+
+interface NodeHttpHandlerPlugin<T extends Context> extends StandardHandlerPlugin<T> {
+    initRuntimeAdapter?(options: NodeHttpHandlerOptions<T>): void;
+}
+declare class CompositeNodeHttpHandlerPlugin<T extends Context, TPlugin extends NodeHttpHandlerPlugin<T>> extends CompositeStandardHandlerPlugin<T, TPlugin> implements NodeHttpHandlerPlugin<T> {
+    initRuntimeAdapter(options: NodeHttpHandlerOptions<T>): void;
+}
+
+type NodeHttpHandleResult = {
+    matched: true;
+} | {
+    matched: false;
+};
+interface NodeHttpHandlerInterceptorOptions<T extends Context> extends StandardHandleOptions<T> {
+    request: NodeHttpRequest;
+    response: NodeHttpResponse;
+    sendStandardResponseOptions: SendStandardResponseOptions;
+}
+interface NodeHttpHandlerOptions<T extends Context> extends SendStandardResponseOptions {
+    adapterInterceptors?: Interceptor<NodeHttpHandlerInterceptorOptions<T>, Promise<NodeHttpHandleResult>>[];
+    plugins?: NodeHttpHandlerPlugin<T>[];
+}
+declare class NodeHttpHandler<T extends Context> implements NodeHttpHandler<T> {
+    private readonly standardHandler;
+    private readonly sendStandardResponseOptions;
+    private readonly adapterInterceptors;
+    constructor(standardHandler: StandardHandler<T>, options?: NoInfer<NodeHttpHandlerOptions<T>>);
+    handle(request: NodeHttpRequest, response: NodeHttpResponse, ...rest: MaybeOptionalOptions<FriendlyStandardHandleOptions<T>>): Promise<NodeHttpHandleResult>;
+}
+
+interface BodyLimitPluginOptions {
+    /**
+     * The maximum size of the body in bytes.
+     */
+    maxBodySize: number;
+}
+/**
+ * The Body Limit Plugin restricts the size of the request body for the Node.js HTTP Server.
+ *
+ * @see {@link https://orpc.unnoq.com/docs/plugins/body-limit Body Limit Plugin Docs}
+ */
+declare class BodyLimitPlugin<T extends Context> implements NodeHttpHandlerPlugin<T> {
+    private readonly maxBodySize;
+    constructor(options: BodyLimitPluginOptions);
+    initRuntimeAdapter(options: NodeHttpHandlerOptions<T>): void;
+}
+
+type RPCHandlerOptions<T extends Context> = NodeHttpHandlerOptions<T> & StandardRPCHandlerOptions<T> & {
+    /**
+     * Enables or disables the StrictGetMethodPlugin.
+     *
+     * @default true
+     */
+    strictGetMethodPluginEnabled?: boolean;
+};
+/**
+ * RPC Handler for Node.js HTTP Server
+ *
+ * @see {@link https://orpc.unnoq.com/docs/rpc-handler RPC Handler Docs}
+ * @see {@link https://orpc.unnoq.com/docs/adapters/http HTTP Adapter Docs}
+ */
+declare class RPCHandler<T extends Context> extends NodeHttpHandler<T> {
+    constructor(router: Router<any, T>, options?: NoInfer<RPCHandlerOptions<T>>);
+}
+
+export { BodyLimitPlugin, CompositeNodeHttpHandlerPlugin, NodeHttpHandler, RPCHandler };
+export type { BodyLimitPluginOptions, NodeHttpHandleResult, NodeHttpHandlerInterceptorOptions, NodeHttpHandlerOptions, NodeHttpHandlerPlugin, RPCHandlerOptions };

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

@@ -0,0 +1,77 @@
+import { C as Context, R as Router } from '../../shared/server.DD2C4ujN.js';
+import { Interceptor, MaybeOptionalOptions } from '@orpc/shared';
+import { SendStandardResponseOptions, NodeHttpRequest, NodeHttpResponse } from '@orpc/standard-server-node';
+import { a as StandardHandlerPlugin, C as CompositeStandardHandlerPlugin, g as StandardHandleOptions, i as StandardHandler } from '../../shared/server.-ACo36I0.js';
+import { F as FriendlyStandardHandleOptions } from '../../shared/server.IG2MjhrD.js';
+import { S as StandardRPCHandlerOptions } from '../../shared/server.BPAWobQg.js';
+import '@orpc/client';
+import '@orpc/contract';
+import '@orpc/standard-server';
+import '@orpc/client/standard';
+
+interface NodeHttpHandlerPlugin<T extends Context> extends StandardHandlerPlugin<T> {
+    initRuntimeAdapter?(options: NodeHttpHandlerOptions<T>): void;
+}
+declare class CompositeNodeHttpHandlerPlugin<T extends Context, TPlugin extends NodeHttpHandlerPlugin<T>> extends CompositeStandardHandlerPlugin<T, TPlugin> implements NodeHttpHandlerPlugin<T> {
+    initRuntimeAdapter(options: NodeHttpHandlerOptions<T>): void;
+}
+
+type NodeHttpHandleResult = {
+    matched: true;
+} | {
+    matched: false;
+};
+interface NodeHttpHandlerInterceptorOptions<T extends Context> extends StandardHandleOptions<T> {
+    request: NodeHttpRequest;
+    response: NodeHttpResponse;
+    sendStandardResponseOptions: SendStandardResponseOptions;
+}
+interface NodeHttpHandlerOptions<T extends Context> extends SendStandardResponseOptions {
+    adapterInterceptors?: Interceptor<NodeHttpHandlerInterceptorOptions<T>, Promise<NodeHttpHandleResult>>[];
+    plugins?: NodeHttpHandlerPlugin<T>[];
+}
+declare class NodeHttpHandler<T extends Context> implements NodeHttpHandler<T> {
+    private readonly standardHandler;
+    private readonly sendStandardResponseOptions;
+    private readonly adapterInterceptors;
+    constructor(standardHandler: StandardHandler<T>, options?: NoInfer<NodeHttpHandlerOptions<T>>);
+    handle(request: NodeHttpRequest, response: NodeHttpResponse, ...rest: MaybeOptionalOptions<FriendlyStandardHandleOptions<T>>): Promise<NodeHttpHandleResult>;
+}
+
+interface BodyLimitPluginOptions {
+    /**
+     * The maximum size of the body in bytes.
+     */
+    maxBodySize: number;
+}
+/**
+ * The Body Limit Plugin restricts the size of the request body for the Node.js HTTP Server.
+ *
+ * @see {@link https://orpc.unnoq.com/docs/plugins/body-limit Body Limit Plugin Docs}
+ */
+declare class BodyLimitPlugin<T extends Context> implements NodeHttpHandlerPlugin<T> {
+    private readonly maxBodySize;
+    constructor(options: BodyLimitPluginOptions);
+    initRuntimeAdapter(options: NodeHttpHandlerOptions<T>): void;
+}
+
+type RPCHandlerOptions<T extends Context> = NodeHttpHandlerOptions<T> & StandardRPCHandlerOptions<T> & {
+    /**
+     * Enables or disables the StrictGetMethodPlugin.
+     *
+     * @default true
+     */
+    strictGetMethodPluginEnabled?: boolean;
+};
+/**
+ * RPC Handler for Node.js HTTP Server
+ *
+ * @see {@link https://orpc.unnoq.com/docs/rpc-handler RPC Handler Docs}
+ * @see {@link https://orpc.unnoq.com/docs/adapters/http HTTP Adapter Docs}
+ */
+declare class RPCHandler<T extends Context> extends NodeHttpHandler<T> {
+    constructor(router: Router<any, T>, options?: NoInfer<RPCHandlerOptions<T>>);
+}
+
+export { BodyLimitPlugin, CompositeNodeHttpHandlerPlugin, NodeHttpHandler, RPCHandler };
+export type { BodyLimitPluginOptions, NodeHttpHandleResult, NodeHttpHandlerInterceptorOptions, NodeHttpHandlerOptions, NodeHttpHandlerPlugin, RPCHandlerOptions };

package/dist/adapters/node/index.mjs

@@ -0,0 +1,95 @@
+import { ORPCError } from '@orpc/client';
+import { toArray, intercept, resolveMaybeOptionalOptions } from '@orpc/shared';
+import { toStandardLazyRequest, sendStandardResponse } from '@orpc/standard-server-node';
+import { r as resolveFriendlyStandardHandleOptions } from '../../shared/server.DZ5BIITo.mjs';
+import '@orpc/standard-server';
+import '@orpc/contract';
+import { C as CompositeStandardHandlerPlugin, b as StandardRPCHandler } from '../../shared/server.CHvOkcM3.mjs';
+import '@orpc/client/standard';
+import '@orpc/standard-server/batch';
+import { S as StrictGetMethodPlugin } from '../../shared/server.BW-nUGgA.mjs';
+import '../../shared/server.DG7Tamti.mjs';
+
+class BodyLimitPlugin {
+  maxBodySize;
+  constructor(options) {
+    this.maxBodySize = options.maxBodySize;
+  }
+  initRuntimeAdapter(options) {
+    options.adapterInterceptors ??= [];
+    options.adapterInterceptors.push(async (options2) => {
+      let isHeaderChecked = false;
+      const checkHeader = () => {
+        if (!isHeaderChecked && Number(options2.request.headers["content-length"]) > this.maxBodySize) {
+          throw new ORPCError("PAYLOAD_TOO_LARGE");
+        }
+        isHeaderChecked = true;
+      };
+      const originalEmit = options2.request.emit.bind(options2.request);
+      let currentBodySize = 0;
+      options2.request.emit = (event, ...args) => {
+        if (event === "data") {
+          checkHeader();
+          currentBodySize += args[0].length;
+          if (currentBodySize > this.maxBodySize) {
+            throw new ORPCError("PAYLOAD_TOO_LARGE");
+          }
+        }
+        return originalEmit(event, ...args);
+      };
+      return options2.next();
+    });
+  }
+}
+
+class CompositeNodeHttpHandlerPlugin extends CompositeStandardHandlerPlugin {
+  initRuntimeAdapter(options) {
+    for (const plugin of this.plugins) {
+      plugin.initRuntimeAdapter?.(options);
+    }
+  }
+}
+
+class NodeHttpHandler {
+  constructor(standardHandler, options = {}) {
+    this.standardHandler = standardHandler;
+    const plugin = new CompositeNodeHttpHandlerPlugin(options.plugins);
+    plugin.initRuntimeAdapter(options);
+    this.adapterInterceptors = toArray(options.adapterInterceptors);
+    this.sendStandardResponseOptions = options;
+  }
+  sendStandardResponseOptions;
+  adapterInterceptors;
+  async handle(request, response, ...rest) {
+    return intercept(
+      this.adapterInterceptors,
+      {
+        ...resolveFriendlyStandardHandleOptions(resolveMaybeOptionalOptions(rest)),
+        request,
+        response,
+        sendStandardResponseOptions: this.sendStandardResponseOptions
+      },
+      async ({ request: request2, response: response2, sendStandardResponseOptions, ...options }) => {
+        const standardRequest = toStandardLazyRequest(request2, response2);
+        const result = await this.standardHandler.handle(standardRequest, options);
+        if (!result.matched) {
+          return { matched: false };
+        }
+        await sendStandardResponse(response2, result.response, sendStandardResponseOptions);
+        return { matched: true };
+      }
+    );
+  }
+}
+
+class RPCHandler extends NodeHttpHandler {
+  constructor(router, options = {}) {
+    if (options.strictGetMethodPluginEnabled ?? true) {
+      options.plugins ??= [];
+      options.plugins.push(new StrictGetMethodPlugin());
+    }
+    super(new StandardRPCHandler(router, options), options);
+  }
+}
+
+export { BodyLimitPlugin, CompositeNodeHttpHandlerPlugin, NodeHttpHandler, RPCHandler };

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

@@ -0,0 +1,26 @@
+import { c as StandardCodec, d as StandardParams, e as StandardMatcher, f as StandardMatchResult } from '../../shared/server.Dq8xr7PQ.mjs';
+export { C as CompositeStandardHandlerPlugin, g as StandardHandleOptions, h as StandardHandleResult, i as StandardHandler, S as StandardHandlerInterceptorOptions, b as StandardHandlerOptions, a as StandardHandlerPlugin } from '../../shared/server.Dq8xr7PQ.mjs';
+import { ORPCError, HTTPPath } from '@orpc/client';
+import { StandardRPCSerializer } from '@orpc/client/standard';
+import { StandardLazyRequest, StandardResponse } from '@orpc/standard-server';
+import { h as AnyProcedure, f as AnyRouter } from '../../shared/server.DD2C4ujN.mjs';
+export { a as StandardRPCHandler, S as StandardRPCHandlerOptions } from '../../shared/server.Bd52nNaH.mjs';
+import '@orpc/contract';
+import '@orpc/shared';
+
+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;
+}
+
+declare class StandardRPCMatcher implements StandardMatcher {
+    private readonly tree;
+    private pendingRouters;
+    init(router: AnyRouter, path?: readonly string[]): void;
+    match(_method: string, pathname: HTTPPath): Promise<StandardMatchResult>;
+}
+
+export { StandardCodec, StandardMatchResult, StandardMatcher, StandardParams, StandardRPCCodec, StandardRPCMatcher };

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

@@ -0,0 +1,26 @@
+import { c as StandardCodec, d as StandardParams, e as StandardMatcher, f as StandardMatchResult } from '../../shared/server.-ACo36I0.js';
+export { C as CompositeStandardHandlerPlugin, g as StandardHandleOptions, h as StandardHandleResult, i as StandardHandler, S as StandardHandlerInterceptorOptions, b as StandardHandlerOptions, a as StandardHandlerPlugin } from '../../shared/server.-ACo36I0.js';
+import { ORPCError, HTTPPath } from '@orpc/client';
+import { StandardRPCSerializer } from '@orpc/client/standard';
+import { StandardLazyRequest, StandardResponse } from '@orpc/standard-server';
+import { h as AnyProcedure, f as AnyRouter } from '../../shared/server.DD2C4ujN.js';
+export { a as StandardRPCHandler, S as StandardRPCHandlerOptions } from '../../shared/server.BPAWobQg.js';
+import '@orpc/contract';
+import '@orpc/shared';
+
+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;
+}
+
+declare class StandardRPCMatcher implements StandardMatcher {
+    private readonly tree;
+    private pendingRouters;
+    init(router: AnyRouter, path?: readonly string[]): void;
+    match(_method: string, pathname: HTTPPath): Promise<StandardMatchResult>;
+}
+
+export { StandardCodec, StandardMatchResult, StandardMatcher, StandardParams, StandardRPCCodec, StandardRPCMatcher };

package/dist/adapters/standard/index.mjs

@@ -0,0 +1,7 @@
+export { C as CompositeStandardHandlerPlugin, S as StandardHandler, a as StandardRPCCodec, b as StandardRPCHandler, c as StandardRPCMatcher } from '../../shared/server.CHvOkcM3.mjs';
+import '@orpc/client/standard';
+import '@orpc/client';
+import '@orpc/shared';
+import '@orpc/standard-server';
+import '../../shared/server.DG7Tamti.mjs';
+import '@orpc/contract';

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

@@ -0,0 +1,51 @@
+import { MaybeOptionalOptions } from '@orpc/shared';
+import { C as Context, R as Router } from '../../shared/server.DD2C4ujN.mjs';
+import { i as StandardHandler } from '../../shared/server.Dq8xr7PQ.mjs';
+import { F as FriendlyStandardHandleOptions } from '../../shared/server.BliFSTnG.mjs';
+import { S as StandardRPCHandlerOptions } from '../../shared/server.Bd52nNaH.mjs';
+import '@orpc/client';
+import '@orpc/contract';
+import '@orpc/standard-server';
+import '@orpc/client/standard';
+
+type experimental_MinimalWebsocket = Pick<WebSocket, 'addEventListener' | 'send'>;
+declare class experimental_WebsocketHandler<T extends Context> {
+    #private;
+    constructor(standardHandler: StandardHandler<T>);
+    /**
+     * 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: experimental_MinimalWebsocket, ...rest: MaybeOptionalOptions<Omit<FriendlyStandardHandleOptions<T>, 'prefix'>>): void;
+    /**
+     * Handles a single message received from a WebSocket.
+     *
+     * @warning Avoid calling this directly if `.upgrade()` is used.
+     *
+     * @param ws The WebSocket instance
+     * @param data The message payload, usually place in `event.data`
+     */
+    message(ws: experimental_MinimalWebsocket, data: string | ArrayBuffer | Blob, ...rest: MaybeOptionalOptions<Omit<FriendlyStandardHandleOptions<T>, 'prefix'>>): Promise<void>;
+    /**
+     * Closes the WebSocket peer and cleans up.
+     *
+     * @warning Avoid calling this directly if `.upgrade()` is used.
+     */
+    close(ws: experimental_MinimalWebsocket): void;
+}
+
+/**
+ * RPC Handler for Websocket adapter
+ *
+ * @see {@link https://orpc.unnoq.com/docs/rpc-handler RPC Handler Docs}
+ * @see {@link https://orpc.unnoq.com/docs/adapters/websocket Websocket Adapter Docs}
+ */
+declare class experimental_RPCHandler<T extends Context> extends experimental_WebsocketHandler<T> {
+    constructor(router: Router<any, T>, options?: NoInfer<StandardRPCHandlerOptions<T>>);
+}
+
+export { experimental_RPCHandler, experimental_WebsocketHandler };
+export type { experimental_MinimalWebsocket };

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

@@ -0,0 +1,51 @@
+import { MaybeOptionalOptions } from '@orpc/shared';
+import { C as Context, R as Router } from '../../shared/server.DD2C4ujN.js';
+import { i as StandardHandler } from '../../shared/server.-ACo36I0.js';
+import { F as FriendlyStandardHandleOptions } from '../../shared/server.IG2MjhrD.js';
+import { S as StandardRPCHandlerOptions } from '../../shared/server.BPAWobQg.js';
+import '@orpc/client';
+import '@orpc/contract';
+import '@orpc/standard-server';
+import '@orpc/client/standard';
+
+type experimental_MinimalWebsocket = Pick<WebSocket, 'addEventListener' | 'send'>;
+declare class experimental_WebsocketHandler<T extends Context> {
+    #private;
+    constructor(standardHandler: StandardHandler<T>);
+    /**
+     * 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: experimental_MinimalWebsocket, ...rest: MaybeOptionalOptions<Omit<FriendlyStandardHandleOptions<T>, 'prefix'>>): void;
+    /**
+     * Handles a single message received from a WebSocket.
+     *
+     * @warning Avoid calling this directly if `.upgrade()` is used.
+     *
+     * @param ws The WebSocket instance
+     * @param data The message payload, usually place in `event.data`
+     */
+    message(ws: experimental_MinimalWebsocket, data: string | ArrayBuffer | Blob, ...rest: MaybeOptionalOptions<Omit<FriendlyStandardHandleOptions<T>, 'prefix'>>): Promise<void>;
+    /**
+     * Closes the WebSocket peer and cleans up.
+     *
+     * @warning Avoid calling this directly if `.upgrade()` is used.
+     */
+    close(ws: experimental_MinimalWebsocket): void;
+}
+
+/**
+ * RPC Handler for Websocket adapter
+ *
+ * @see {@link https://orpc.unnoq.com/docs/rpc-handler RPC Handler Docs}
+ * @see {@link https://orpc.unnoq.com/docs/adapters/websocket Websocket Adapter Docs}
+ */
+declare class experimental_RPCHandler<T extends Context> extends experimental_WebsocketHandler<T> {
+    constructor(router: Router<any, T>, options?: NoInfer<StandardRPCHandlerOptions<T>>);
+}
+
+export { experimental_RPCHandler, experimental_WebsocketHandler };
+export type { experimental_MinimalWebsocket };