@orpc/server 0.0.0-next.9723092 → 0.0.0-next.989a435

package/dist/{chunk-F75AQ6KO.js → chunk-DAUWED3D.js}

@@ -6,10 +6,10 @@ import {
   getRouterChild,
   isProcedure,
   unlazy
-} from "./chunk-SV6DBVXJ.js";
+} from "./chunk-XP6YRLY2.js";
 import {
   CompositePlugin
-} from "./chunk-XFBAK67J.js";
+} from "./chunk-XI6WGCB3.js";
 
 // src/adapters/standard/handler.ts
 import { toORPCError } from "@orpc/contract";
@@ -75,9 +75,12 @@ var StandardHandler = class {
 };
 
 // src/adapters/standard/rpc-serializer.ts
-import { findDeepMatches, isPlainObject, set } from "@orpc/shared";
+import { findDeepMatches, isObject, set } from "@orpc/shared";
 var RPCSerializer = class {
   serialize(data) {
+    if (data === void 0) {
+      return void 0;
+    }
     if (data instanceof Blob) {
       return data;
     }
@@ -95,6 +98,9 @@ var RPCSerializer = class {
     return form;
   }
   deserialize(serialized) {
+    if (serialized === void 0) {
+      return void 0;
+    }
     if (serialized instanceof Blob) {
       return serialized;
     }
@@ -131,7 +137,7 @@ function serializeRPCJson(value, segments = [], meta = []) {
     meta.push(["url", segments]);
     return { json: value.toString(), meta };
   }
-  if (isPlainObject(value)) {
+  if (isObject(value)) {
     const json = {};
     for (const k in value) {
       json[k] = serializeRPCJson(value[k], [...segments, k], meta).json;
@@ -310,4 +316,4 @@ export {
   RPCCodec,
   RPCMatcher
 };
-//# sourceMappingURL=chunk-F75AQ6KO.js.map
+//# sourceMappingURL=chunk-DAUWED3D.js.map

package/dist/chunk-N2FJGXSJ.js

@@ -0,0 +1,32 @@
+import {
+  RPCCodec,
+  RPCMatcher,
+  StandardHandler
+} from "./chunk-DAUWED3D.js";
+
+// src/adapters/fetch/rpc-handler.ts
+import { toFetchResponse, toStandardRequest } from "@orpc/server-standard-fetch";
+var RPCHandler = class {
+  standardHandler;
+  constructor(router, options) {
+    const matcher = options?.matcher ?? new RPCMatcher();
+    const codec = options?.codec ?? new RPCCodec();
+    this.standardHandler = new StandardHandler(router, matcher, codec, options);
+  }
+  async handle(request, ...rest) {
+    const standardRequest = toStandardRequest(request);
+    const result = await this.standardHandler.handle(standardRequest, ...rest);
+    if (!result.matched) {
+      return result;
+    }
+    return {
+      matched: true,
+      response: toFetchResponse(result.response)
+    };
+  }
+};
+
+export {
+  RPCHandler
+};
+//# sourceMappingURL=chunk-N2FJGXSJ.js.map

package/dist/{chunk-XFBAK67J.js → chunk-XI6WGCB3.js}

@@ -21,12 +21,9 @@ var CORSPlugin = class {
   options;
   constructor(options) {
     const defaults = {
-      origin: "*",
+      origin: (origin) => origin,
       allowMethods: ["GET", "HEAD", "PUT", "POST", "DELETE", "PATCH"]
     };
-    if (options?.credentials) {
-      defaults.origin = (origin) => origin;
-    }
     this.options = {
       ...defaults,
       ...options
@@ -125,4 +122,4 @@ export {
   CORSPlugin,
   ResponseHeadersPlugin
 };
-//# sourceMappingURL=chunk-XFBAK67J.js.map
+//# sourceMappingURL=chunk-XI6WGCB3.js.map

package/dist/{chunk-SV6DBVXJ.js → chunk-XP6YRLY2.js}

@@ -68,7 +68,8 @@ function createProcedureClient(lazyableProcedure, ...[options]) {
   return async (...[input, callerOptions]) => {
     const path = options?.path ?? [];
     const { default: procedure } = await unlazy(lazyableProcedure);
-    const context = await value(options?.context ?? {}, callerOptions?.context);
+    const clientContext = callerOptions?.context ?? {};
+    const context = await value(options?.context ?? {}, clientContext);
     const errors = createORPCErrorConstructorMap(procedure["~orpc"].errorMap);
     try {
       return await intercept(
@@ -374,4 +375,4 @@ export {
   convertPathToHttpPath,
   createContractedProcedure
 };
-//# sourceMappingURL=chunk-SV6DBVXJ.js.map
+//# sourceMappingURL=chunk-XP6YRLY2.js.map

package/dist/fetch.js

@@ -1,18 +1,10 @@
 import {
-  RPCHandler,
-  fetchReToStandardBody,
-  fetchRequestToStandardRequest,
-  standardBodyToFetchBody,
-  standardResponseToFetchResponse
-} from "./chunk-LBBHJSG5.js";
-import "./chunk-F75AQ6KO.js";
-import "./chunk-SV6DBVXJ.js";
-import "./chunk-XFBAK67J.js";
+  RPCHandler
+} from "./chunk-N2FJGXSJ.js";
+import "./chunk-DAUWED3D.js";
+import "./chunk-XP6YRLY2.js";
+import "./chunk-XI6WGCB3.js";
 export {
-  RPCHandler,
-  fetchReToStandardBody,
-  fetchRequestToStandardRequest,
-  standardBodyToFetchBody,
-  standardResponseToFetchResponse
+  RPCHandler
 };
 //# sourceMappingURL=fetch.js.map

package/dist/hono.js

@@ -1,13 +1,9 @@
 import {
-  RPCHandler,
-  fetchReToStandardBody,
-  fetchRequestToStandardRequest,
-  standardBodyToFetchBody,
-  standardResponseToFetchResponse
-} from "./chunk-LBBHJSG5.js";
-import "./chunk-F75AQ6KO.js";
-import "./chunk-SV6DBVXJ.js";
-import "./chunk-XFBAK67J.js";
+  RPCHandler
+} from "./chunk-N2FJGXSJ.js";
+import "./chunk-DAUWED3D.js";
+import "./chunk-XP6YRLY2.js";
+import "./chunk-XI6WGCB3.js";
 
 // src/adapters/hono/middleware.ts
 import { value } from "@orpc/shared";
@@ -26,17 +22,13 @@ function createMiddleware(handler, ...[options]) {
     const context = await value(options?.context ?? {}, c);
     const { matched, response } = await handler.handle(request, { ...options, context });
     if (matched) {
-      return c.body(response.body, response);
+      return c.newResponse(response.body, response);
     }
     await next();
   };
 }
 export {
   RPCHandler,
-  createMiddleware,
-  fetchReToStandardBody,
-  fetchRequestToStandardRequest,
-  standardBodyToFetchBody,
-  standardResponseToFetchResponse
+  createMiddleware
 };
 //# sourceMappingURL=hono.js.map

package/dist/index.js

@@ -21,7 +21,7 @@ import {
   middlewareOutputFn,
   setRouterContract,
   unlazy
-} from "./chunk-SV6DBVXJ.js";
+} from "./chunk-XP6YRLY2.js";
 
 // src/builder.ts
 import { mergeErrorMap as mergeErrorMap2, mergeMeta as mergeMeta2, mergePrefix, mergeRoute as mergeRoute2, mergeTags } from "@orpc/contract";

package/dist/next.js

@@ -1,13 +1,9 @@
 import {
-  RPCHandler,
-  fetchReToStandardBody,
-  fetchRequestToStandardRequest,
-  standardBodyToFetchBody,
-  standardResponseToFetchResponse
-} from "./chunk-LBBHJSG5.js";
-import "./chunk-F75AQ6KO.js";
-import "./chunk-SV6DBVXJ.js";
-import "./chunk-XFBAK67J.js";
+  RPCHandler
+} from "./chunk-N2FJGXSJ.js";
+import "./chunk-DAUWED3D.js";
+import "./chunk-XP6YRLY2.js";
+import "./chunk-XI6WGCB3.js";
 
 // src/adapters/next/serve.ts
 import { value } from "@orpc/shared";
@@ -30,10 +26,6 @@ function serve(handler, ...[options]) {
 }
 export {
   RPCHandler,
-  fetchReToStandardBody,
-  fetchRequestToStandardRequest,
-  serve,
-  standardBodyToFetchBody,
-  standardResponseToFetchResponse
+  serve
 };
 //# sourceMappingURL=next.js.map

package/dist/node.js

@@ -2,154 +2,12 @@ import {
   RPCCodec,
   RPCMatcher,
   StandardHandler
-} from "./chunk-F75AQ6KO.js";
-import "./chunk-SV6DBVXJ.js";
-import "./chunk-XFBAK67J.js";
-
-// src/adapters/node/utils.ts
-import { Buffer, File } from "node:buffer";
-import { Readable } from "node:stream";
-import { once } from "@orpc/shared";
-import cd from "content-disposition";
-function nodeHttpToStandardRequest(req, res) {
-  const method = req.method ?? "GET";
-  const protocol = "encrypted" in req.socket && req.socket.encrypted ? "https:" : "http:";
-  const host = req.headers.host ?? "localhost";
-  const url = new URL(req.originalUrl ?? req.url ?? "/", `${protocol}//${host}`);
-  return {
-    raw: { request: req, response: res },
-    method,
-    url,
-    headers: req.headers,
-    body: once(() => {
-      return nodeHttpRequestToStandardBody(req);
-    }),
-    get signal() {
-      const signal = nodeHttpResponseToAbortSignal(res);
-      Object.defineProperty(this, "signal", { value: signal, writable: true });
-      return signal;
-    },
-    set signal(value) {
-      Object.defineProperty(this, "signal", { value, writable: true });
-    }
-  };
-}
-function nodeHttpResponseSendStandardResponse(res, standardResponse) {
-  return new Promise((resolve, reject) => {
-    res.on("error", reject);
-    res.on("finish", resolve);
-    if (standardResponse.body === void 0) {
-      res.writeHead(standardResponse.status, standardResponse.headers);
-      res.end();
-      return;
-    }
-    if (standardResponse.body instanceof Blob) {
-      const resHeaders = {
-        ...standardResponse.headers,
-        "content-type": standardResponse.body.type,
-        "content-length": standardResponse.body.size.toString()
-      };
-      if (!standardResponse.headers["content-disposition"] && standardResponse.body instanceof Blob) {
-        resHeaders["content-disposition"] = cd(standardResponse.body instanceof File ? standardResponse.body.name : "blob");
-      }
-      res.writeHead(standardResponse.status, resHeaders);
-      Readable.fromWeb(
-        standardResponse.body.stream()
-        // Conflict between types=node and lib=dom so we need to cast it
-      ).pipe(res);
-      return;
-    }
-    if (standardResponse.body instanceof FormData) {
-      const response = new Response(standardResponse.body);
-      res.writeHead(standardResponse.status, {
-        ...standardResponse.headers,
-        "content-type": response.headers.get("content-type")
-      });
-      Readable.fromWeb(
-        response.body
-        // Conflict between types=node and lib=dom so we need to cast it
-      ).pipe(res);
-      return;
-    }
-    if (standardResponse.body instanceof URLSearchParams) {
-      res.writeHead(standardResponse.status, {
-        ...standardResponse.headers,
-        "content-type": "application/x-www-form-urlencoded"
-      });
-      const string2 = standardResponse.body.toString();
-      res.end(string2);
-      return;
-    }
-    res.writeHead(standardResponse.status, {
-      ...standardResponse.headers,
-      "content-type": "application/json"
-    });
-    const string = JSON.stringify(standardResponse.body);
-    res.end(string);
-  });
-}
-async function nodeHttpRequestToStandardBody(req) {
-  const method = req.method ?? "GET";
-  if (method === "GET" || method === "HEAD") {
-    return void 0;
-  }
-  const contentDisposition = req.headers["content-disposition"];
-  const fileName = contentDisposition ? cd.parse(contentDisposition).parameters.filename : void 0;
-  const contentType = req.headers["content-type"];
-  if (fileName) {
-    return await streamToFile(req, fileName, contentType || "application/octet-stream");
-  }
-  if (!contentType || contentType.startsWith("application/json")) {
-    const text = await streamToString(req);
-    if (!text) {
-      return void 0;
-    }
-    return JSON.parse(text);
-  }
-  if (contentType.startsWith("multipart/form-data")) {
-    return await streamToFormData(req, contentType);
-  }
-  if (contentType.startsWith("application/x-www-form-urlencoded")) {
-    const text = await streamToString(req);
-    return new URLSearchParams(text);
-  }
-  if (contentType.startsWith("text/")) {
-    return await streamToString(req);
-  }
-  return streamToFile(req, "blob", contentType);
-}
-function streamToFormData(stream, contentType) {
-  const response = new Response(stream, {
-    // Conflict between types=node and lib=dom so we need to cast it
-    headers: {
-      "content-type": contentType
-    }
-  });
-  return response.formData();
-}
-async function streamToString(stream) {
-  let string = "";
-  for await (const chunk of stream) {
-    string += chunk.toString();
-  }
-  return string;
-}
-async function streamToFile(stream, fileName, contentType) {
-  const chunks = [];
-  for await (const chunk of stream) {
-    chunks.push(chunk);
-  }
-  return new File([Buffer.concat(chunks)], fileName, { type: contentType });
-}
-function nodeHttpResponseToAbortSignal(res) {
-  const controller = new AbortController();
-  res.on("close", () => {
-    controller.abort();
-  });
-  return controller.signal;
-}
+} from "./chunk-DAUWED3D.js";
+import "./chunk-XP6YRLY2.js";
+import "./chunk-XI6WGCB3.js";
 
 // src/adapters/node/rpc-handler.ts
+import { sendStandardResponse, toStandardRequest } from "@orpc/server-standard-node";
 var RPCHandler = class {
   standardHandler;
   constructor(router, options) {
@@ -158,18 +16,16 @@ var RPCHandler = class {
     this.standardHandler = new StandardHandler(router, matcher, codec, options);
   }
   async handle(req, res, ...rest) {
-    const standardRequest = nodeHttpToStandardRequest(req, res);
+    const standardRequest = toStandardRequest(req, res);
     const result = await this.standardHandler.handle(standardRequest, ...rest);
     if (!result.matched) {
       return { matched: false };
     }
-    await nodeHttpResponseSendStandardResponse(res, result.response);
+    await sendStandardResponse(res, result.response);
     return { matched: true };
   }
 };
 export {
-  RPCHandler,
-  nodeHttpResponseSendStandardResponse,
-  nodeHttpToStandardRequest
+  RPCHandler
 };
 //# sourceMappingURL=node.js.map

package/dist/plugins.js

@@ -2,7 +2,7 @@ import {
   CORSPlugin,
   CompositePlugin,
   ResponseHeadersPlugin
-} from "./chunk-XFBAK67J.js";
+} from "./chunk-XI6WGCB3.js";
 export {
   CORSPlugin,
   CompositePlugin,

package/dist/src/adapters/fetch/index.d.ts

@@ -1,4 +1,3 @@
 export * from './rpc-handler';
 export * from './types';
-export * from './utils';
 //# sourceMappingURL=index.d.ts.map

package/dist/src/adapters/fetch/rpc-handler.d.ts

@@ -1,10 +1,11 @@
+import type { MaybeOptionalOptions } from '@orpc/shared';
 import type { Context } from '../../context';
 import type { Router } from '../../router';
-import type { RPCHandlerOptions, StandardHandleRest } from '../standard';
+import type { RPCHandlerOptions, StandardHandleOptions } from '../standard';
 import type { FetchHandler, FetchHandleResult } from './types';
 export declare class RPCHandler<T extends Context> implements FetchHandler<T> {
     private readonly standardHandler;
     constructor(router: Router<T, any>, options?: NoInfer<RPCHandlerOptions<T>>);
-    handle(request: Request, ...rest: StandardHandleRest<T>): Promise<FetchHandleResult>;
+    handle(request: Request, ...rest: MaybeOptionalOptions<StandardHandleOptions<T>>): Promise<FetchHandleResult>;
 }
 //# sourceMappingURL=rpc-handler.d.ts.map

package/dist/src/adapters/fetch/types.d.ts

@@ -1,5 +1,6 @@
+import type { MaybeOptionalOptions } from '@orpc/shared';
 import type { Context } from '../../context';
-import type { StandardHandleRest } from '../standard';
+import type { StandardHandleOptions } from '../standard';
 export type FetchHandleResult = {
     matched: true;
     response: Response;
@@ -8,6 +9,6 @@ export type FetchHandleResult = {
     response: undefined;
 };
 export interface FetchHandler<T extends Context> {
-    handle(request: Request, ...rest: StandardHandleRest<T>): Promise<FetchHandleResult>;
+    handle(request: Request, ...rest: MaybeOptionalOptions<StandardHandleOptions<T>>): Promise<FetchHandleResult>;
 }
 //# sourceMappingURL=types.d.ts.map

package/dist/src/adapters/hono/middleware.d.ts

@@ -1,13 +1,12 @@
+import type { MaybeOptionalOptions, Value } from '@orpc/shared';
 import type { Context as HonoContext, MiddlewareHandler } from 'hono';
 import type { Context } from '../../context';
 import type { FetchHandler } from '../fetch';
 import type { StandardHandleOptions } from '../standard';
-import { type Value } from '@orpc/shared';
 export type CreateMiddlewareOptions<T extends Context> = Omit<StandardHandleOptions<T>, 'context'> & (Record<never, never> extends T ? {
     context?: Value<T, [HonoContext]>;
 } : {
     context: Value<T, [HonoContext]>;
 });
-export type CreateMiddlewareRest<T extends Context> = [options: CreateMiddlewareOptions<T>] | (Record<never, never> extends T ? [] : never);
-export declare function createMiddleware<T extends Context>(handler: FetchHandler<T>, ...[options]: CreateMiddlewareRest<T>): MiddlewareHandler;
+export declare function createMiddleware<T extends Context>(handler: FetchHandler<T>, ...[options]: MaybeOptionalOptions<CreateMiddlewareOptions<T>>): MiddlewareHandler;
 //# sourceMappingURL=middleware.d.ts.map

package/dist/src/adapters/next/serve.d.ts

@@ -1,14 +1,13 @@
+import type { MaybeOptionalOptions, Value } from '@orpc/shared';
 import type { NextRequest } from 'next/server';
 import type { Context } from '../../context';
 import type { FetchHandler } from '../fetch';
 import type { StandardHandleOptions } from '../standard';
-import { type Value } from '@orpc/shared';
 export type ServeOptions<T extends Context> = Omit<StandardHandleOptions<T>, 'context'> & (Record<never, never> extends T ? {
     context?: Value<T, [NextRequest]>;
 } : {
     context: Value<T, [NextRequest]>;
 });
-export type ServeRest<T extends Context> = [options: ServeOptions<T>] | (Record<never, never> extends T ? [] : never);
 export interface ServeResult {
     GET(req: NextRequest): Promise<Response>;
     POST(req: NextRequest): Promise<Response>;
@@ -16,5 +15,5 @@ export interface ServeResult {
     PATCH(req: NextRequest): Promise<Response>;
     DELETE(req: NextRequest): Promise<Response>;
 }
-export declare function serve<T extends Context>(handler: FetchHandler<T>, ...[options]: ServeRest<T>): ServeResult;
+export declare function serve<T extends Context>(handler: FetchHandler<T>, ...[options]: MaybeOptionalOptions<ServeOptions<T>>): ServeResult;
 //# sourceMappingURL=serve.d.ts.map

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

@@ -1,4 +1,3 @@
 export * from './rpc-handler';
 export * from './types';
-export * from './utils';
 //# sourceMappingURL=index.d.ts.map

package/dist/src/adapters/node/rpc-handler.d.ts

@@ -1,10 +1,11 @@
+import type { MaybeOptionalOptions } from '@orpc/shared';
 import type { Context } from '../../context';
 import type { Router } from '../../router';
-import type { RPCHandlerOptions, StandardHandleRest } from '../standard';
+import type { RPCHandlerOptions, StandardHandleOptions } from '../standard';
 import type { NodeHttpHandler, NodeHttpHandleResult, NodeHttpRequest, NodeHttpResponse } from './types';
 export declare class RPCHandler<T extends Context> implements NodeHttpHandler<T> {
     private readonly standardHandler;
     constructor(router: Router<T, any>, options?: NoInfer<RPCHandlerOptions<T>>);
-    handle(req: NodeHttpRequest, res: NodeHttpResponse, ...rest: StandardHandleRest<T>): Promise<NodeHttpHandleResult>;
+    handle(req: NodeHttpRequest, res: NodeHttpResponse, ...rest: MaybeOptionalOptions<StandardHandleOptions<T>>): Promise<NodeHttpHandleResult>;
 }
 //# sourceMappingURL=rpc-handler.d.ts.map

package/dist/src/adapters/node/types.d.ts

@@ -1,7 +1,8 @@
+import type { MaybeOptionalOptions } from '@orpc/shared';
 import type { IncomingMessage, ServerResponse } from 'node:http';
 import type { Http2ServerRequest, Http2ServerResponse } from 'node:http2';
 import type { Context } from '../../context';
-import type { StandardHandleRest } from '../standard';
+import type { StandardHandleOptions } from '../standard';
 export type NodeHttpRequest = (IncomingMessage | Http2ServerRequest) & {
     /**
      * Replace `req.url` with `req.originalUrl` when `req.originalUrl` is available.
@@ -16,6 +17,6 @@ export type NodeHttpHandleResult = {
     matched: false;
 };
 export interface NodeHttpHandler<T extends Context> {
-    handle(req: NodeHttpRequest, res: NodeHttpResponse, ...rest: StandardHandleRest<T>): Promise<NodeHttpHandleResult>;
+    handle(req: NodeHttpRequest, res: NodeHttpResponse, ...rest: MaybeOptionalOptions<StandardHandleOptions<T>>): Promise<NodeHttpHandleResult>;
 }
 //# sourceMappingURL=types.d.ts.map

package/dist/src/adapters/standard/handler.d.ts

@@ -1,10 +1,11 @@
 import type { ErrorMap, HTTPPath, Meta, Schema } from '@orpc/contract';
-import type { Interceptor } from '@orpc/shared';
+import type { StandardRequest, StandardResponse } from '@orpc/server-standard';
+import type { Interceptor, MaybeOptionalOptions } from '@orpc/shared';
 import type { Context } from '../../context';
 import type { Plugin } from '../../plugins';
 import type { CreateProcedureClientOptions } from '../../procedure-client';
 import type { Router } from '../../router';
-import type { StandardCodec, StandardMatcher, StandardRequest, StandardResponse } from './types';
+import type { StandardCodec, StandardMatcher } from './types';
 export type StandardHandleOptions<T extends Context> = {
     prefix?: HTTPPath;
 } & (Record<never, never> extends T ? {
@@ -15,7 +16,6 @@ export type StandardHandleOptions<T extends Context> = {
 export type WellStandardHandleOptions<T extends Context> = StandardHandleOptions<T> & {
     context: T;
 };
-export type StandardHandleRest<T extends Context> = [options: StandardHandleOptions<T>] | (Record<never, never> extends T ? [] : never);
 export type StandardHandleResult = {
     matched: true;
     response: StandardResponse;
@@ -26,7 +26,7 @@ export type StandardHandleResult = {
 export type StandardHandlerInterceptorOptions<TContext extends Context> = WellStandardHandleOptions<TContext> & {
     request: StandardRequest;
 };
-export type WellCreateProcedureClientOptions<TContext extends Context> = CreateProcedureClientOptions<TContext, Schema, Schema, unknown, ErrorMap, Meta, unknown> & {
+export type WellCreateProcedureClientOptions<TContext extends Context> = CreateProcedureClientOptions<TContext, Schema, Schema, unknown, ErrorMap, Meta, Record<never, never>> & {
     context: TContext;
 };
 export interface StandardHandlerOptions<TContext extends Context> {
@@ -40,12 +40,12 @@ export interface StandardHandlerOptions<TContext extends Context> {
      */
     interceptorsRoot?: Interceptor<StandardHandlerInterceptorOptions<TContext>, StandardHandleResult, unknown>[];
 }
-export declare class StandardHandler<TContext extends Context> {
+export declare class StandardHandler<T extends Context> {
     private readonly matcher;
     private readonly codec;
     private readonly options;
     private readonly plugin;
-    constructor(router: Router<TContext, any>, matcher: StandardMatcher, codec: StandardCodec, options?: NoInfer<StandardHandlerOptions<TContext>>);
-    handle(request: StandardRequest, ...[options]: StandardHandleRest<TContext>): Promise<StandardHandleResult>;
+    constructor(router: Router<T, any>, matcher: StandardMatcher, codec: StandardCodec, options?: NoInfer<StandardHandlerOptions<T>>);
+    handle(request: StandardRequest, ...[options]: MaybeOptionalOptions<StandardHandleOptions<T>>): Promise<StandardHandleResult>;
 }
 //# sourceMappingURL=handler.d.ts.map

package/dist/src/adapters/standard/rpc-codec.d.ts

@@ -1,6 +1,7 @@
 import type { ORPCError } from '@orpc/contract';
+import type { StandardRequest, StandardResponse } from '@orpc/server-standard';
 import type { AnyProcedure } from '../../procedure';
-import type { StandardCodec, StandardParams, StandardRequest, StandardResponse } from './types';
+import type { StandardCodec, StandardParams } from './types';
 import { RPCSerializer } from './rpc-serializer';
 export interface StandardCodecOptions {
     serializer?: RPCSerializer;

package/dist/src/adapters/standard/rpc-serializer.d.ts

@@ -3,7 +3,7 @@ export type RPCSerializedJsonMeta = ['bigint' | 'date' | 'nan' | 'undefined' | '
 export type RPCSerialized = {
     json: unknown;
     meta: RPCSerializedJsonMeta;
-} | FormData | Blob;
+} | FormData | Blob | undefined;
 export type RPCSerializedFormDataMaps = Segment[][];
 export declare class RPCSerializer {
     serialize(data: unknown): RPCSerialized;

package/dist/src/adapters/standard/types.d.ts

@@ -1,31 +1,7 @@
-import type { AbortSignal, HTTPPath, ORPCError } from '@orpc/contract';
-import type { JsonValue } from '@orpc/shared';
+import type { HTTPPath, ORPCError } from '@orpc/contract';
+import type { StandardRequest, StandardResponse } from '@orpc/server-standard';
 import type { AnyProcedure } from '../../procedure';
 import type { AnyRouter } from '../../router';
-export interface StandardHeaders {
-    [key: string]: string | string[] | undefined;
-}
-export type StandardBody = undefined | JsonValue | Blob | URLSearchParams | FormData;
-export interface StandardRequest {
-    /**
-     * Can be { request: Request } or { request: IncomingMessage, response: ServerResponse } based on the adapter.
-     */
-    raw: Record<string, unknown>;
-    method: string;
-    url: URL;
-    headers: StandardHeaders;
-    /**
-     * The body has been parsed base on the content-type header.
-     * This method can safely call multiple times (cached).
-     */
-    body(): Promise<StandardBody>;
-    signal?: AbortSignal;
-}
-export interface StandardResponse {
-    status: number;
-    headers: StandardHeaders;
-    body: StandardBody;
-}
 export type StandardParams = Record<string, string>;
 export type StandardMatchResult = {
     path: string[];

package/dist/src/implementer-procedure.d.ts

@@ -1,9 +1,10 @@
-import type { ClientRest, ErrorMap, Meta, ORPCErrorConstructorMap, Schema, SchemaInput, SchemaOutput } from '@orpc/contract';
+import type { ClientContext, ClientRest, ErrorMap, Meta, ORPCErrorConstructorMap, Schema, SchemaInput, SchemaOutput } from '@orpc/contract';
+import type { MaybeOptionalOptions } from '@orpc/shared';
 import type { BuilderDef } from './builder';
 import type { ConflictContextGuard, Context, MergedContext } from './context';
 import type { MapInputMiddleware, Middleware } from './middleware';
 import type { Procedure, ProcedureHandler } from './procedure';
-import type { CreateProcedureClientRest, ProcedureClient } from './procedure-client';
+import type { CreateProcedureClientOptions, ProcedureClient } from './procedure-client';
 import type { DecoratedProcedure } from './procedure-decorated';
 /**
  * Like `DecoratedProcedure`, but removed all method that can change the contract.
@@ -13,11 +14,11 @@ export interface ImplementedProcedure<TInitialContext extends Context, TCurrentC
     /**
      * Make this procedure callable (works like a function while still being a procedure).
      */
-    callable<TClientContext>(...rest: CreateProcedureClientRest<TInitialContext, TInputSchema, TOutputSchema, THandlerOutput, TErrorMap, TMeta, TClientContext>): Procedure<TInitialContext, TCurrentContext, TInputSchema, TOutputSchema, THandlerOutput, TErrorMap, TMeta> & ProcedureClient<TClientContext, TInputSchema, TOutputSchema, THandlerOutput, TErrorMap>;
+    callable<TClientContext extends ClientContext>(...rest: MaybeOptionalOptions<CreateProcedureClientOptions<TInitialContext, TInputSchema, TOutputSchema, THandlerOutput, TErrorMap, TMeta, TClientContext>>): Procedure<TInitialContext, TCurrentContext, TInputSchema, TOutputSchema, THandlerOutput, TErrorMap, TMeta> & ProcedureClient<TClientContext, TInputSchema, TOutputSchema, THandlerOutput, TErrorMap>;
     /**
      * Make this procedure compatible with server action (the same as .callable, but the type is compatible with server action).
      */
-    actionable<TClientContext>(...rest: CreateProcedureClientRest<TInitialContext, TInputSchema, TOutputSchema, THandlerOutput, TErrorMap, TMeta, TClientContext>): Procedure<TInitialContext, TCurrentContext, TInputSchema, TOutputSchema, THandlerOutput, TErrorMap, TMeta> & ((...rest: ClientRest<TClientContext, SchemaInput<TInputSchema>>) => Promise<SchemaOutput<TOutputSchema, THandlerOutput>>);
+    actionable<TClientContext extends ClientContext>(...rest: MaybeOptionalOptions<CreateProcedureClientOptions<TInitialContext, TInputSchema, TOutputSchema, THandlerOutput, TErrorMap, TMeta, TClientContext>>): Procedure<TInitialContext, TCurrentContext, TInputSchema, TOutputSchema, THandlerOutput, TErrorMap, TMeta> & ((...rest: ClientRest<TClientContext, SchemaInput<TInputSchema>>) => Promise<SchemaOutput<TOutputSchema, THandlerOutput>>);
 }
 /**
  * Like `ProcedureBuilderWithoutHandler`, but removed all method that can change the contract.

package/dist/src/middleware.d.ts

@@ -1,5 +1,5 @@
-import type { AbortSignal, ErrorMap, Meta, ORPCErrorConstructorMap, Schema } from '@orpc/contract';
-import type { Promisable } from '@orpc/shared';
+import type { ErrorMap, Meta, ORPCErrorConstructorMap, Schema } from '@orpc/contract';
+import type { MaybeOptionalOptions, Promisable } from '@orpc/shared';
 import type { Context } from './context';
 import type { Procedure } from './procedure';
 export type MiddlewareResult<TOutContext extends Context, TOutput> = Promisable<{
@@ -11,9 +11,8 @@ export type MiddlewareNextFnOptions<TOutContext extends Context> = Record<never,
 } : {
     context: TOutContext;
 };
-export type MiddlewareNextFnRest<TOutContext extends Context> = [options: MiddlewareNextFnOptions<TOutContext>] | (Record<never, never> extends TOutContext ? [] : never);
 export interface MiddlewareNextFn<TInContext extends Context, TOutput> {
-    <U extends Context & Partial<TInContext> = Record<never, never>>(...rest: MiddlewareNextFnRest<U>): MiddlewareResult<U, TOutput>;
+    <U extends Context & Partial<TInContext> = Record<never, never>>(...rest: MaybeOptionalOptions<MiddlewareNextFnOptions<U>>): MiddlewareResult<U, TOutput>;
 }
 export interface MiddlewareOutputFn<TOutput> {
     (output: TOutput): MiddlewareResult<Record<never, never>, TOutput>;

package/dist/src/procedure-client.d.ts

@@ -1,9 +1,9 @@
-import type { Client, ErrorFromErrorMap, ErrorMap, Meta, ORPCErrorConstructorMap, Schema, SchemaInput, SchemaOutput } from '@orpc/contract';
-import type { Interceptor, Value } from '@orpc/shared';
+import type { Client, ClientContext, ErrorFromErrorMap, ErrorMap, Meta, ORPCErrorConstructorMap, Schema, SchemaInput, SchemaOutput } from '@orpc/contract';
+import type { Interceptor, MaybeOptionalOptions, Value } from '@orpc/shared';
 import type { Context } from './context';
 import type { Lazyable } from './lazy';
 import type { Procedure } from './procedure';
-export type ProcedureClient<TClientContext, TInputSchema extends Schema, TOutputSchema extends Schema, THandlerOutput extends SchemaInput<TOutputSchema>, TErrorMap extends ErrorMap> = Client<TClientContext, SchemaInput<TInputSchema>, SchemaOutput<TOutputSchema, THandlerOutput>, ErrorFromErrorMap<TErrorMap>>;
+export type ProcedureClient<TClientContext extends ClientContext, TInputSchema extends Schema, TOutputSchema extends Schema, THandlerOutput extends SchemaInput<TOutputSchema>, TErrorMap extends ErrorMap> = Client<TClientContext, SchemaInput<TInputSchema>, SchemaOutput<TOutputSchema, THandlerOutput>, ErrorFromErrorMap<TErrorMap>>;
 export interface ProcedureClientInterceptorOptions<TInitialContext extends Context, TInputSchema extends Schema, TErrorMap extends ErrorMap, TMeta extends Meta> {
     context: TInitialContext;
     input: SchemaInput<TInputSchema>;
@@ -15,7 +15,7 @@ export interface ProcedureClientInterceptorOptions<TInitialContext extends Conte
 /**
  * Options for creating a procedure caller with comprehensive type safety
  */
-export type CreateProcedureClientOptions<TInitialContext extends Context, TInputSchema extends Schema, TOutputSchema extends Schema, THandlerOutput extends SchemaInput<TOutputSchema>, TErrorMap extends ErrorMap, TMeta extends Meta, TClientContext> = {
+export type CreateProcedureClientOptions<TInitialContext extends Context, TInputSchema extends Schema, TOutputSchema extends Schema, THandlerOutput extends SchemaInput<TOutputSchema>, TErrorMap extends ErrorMap, TMeta extends Meta, TClientContext extends ClientContext> = {
     /**
      * This is helpful for logging and analytics.
      */
@@ -26,6 +26,5 @@ export type CreateProcedureClientOptions<TInitialContext extends Context, TInput
 } : {
     context: Value<TInitialContext, [clientContext: TClientContext]>;
 });
-export type CreateProcedureClientRest<TInitialContext extends Context, TInputSchema extends Schema, TOutputSchema extends Schema, THandlerOutput extends SchemaInput<TOutputSchema>, TErrorMap extends ErrorMap, TMeta extends Meta, TClientContext> = [options: CreateProcedureClientOptions<TInitialContext, TInputSchema, TOutputSchema, THandlerOutput, TErrorMap, TMeta, TClientContext>] | (Record<never, never> extends TInitialContext ? [] : never);
-export declare function createProcedureClient<TInitialContext extends Context, TInputSchema extends Schema, TOutputSchema extends Schema, THandlerOutput extends SchemaInput<TOutputSchema>, TErrorMap extends ErrorMap, TMeta extends Meta, TClientContext>(lazyableProcedure: Lazyable<Procedure<TInitialContext, any, TInputSchema, TOutputSchema, THandlerOutput, TErrorMap, TMeta>>, ...[options]: CreateProcedureClientRest<TInitialContext, TInputSchema, TOutputSchema, THandlerOutput, TErrorMap, TMeta, TClientContext>): ProcedureClient<TClientContext, TInputSchema, TOutputSchema, THandlerOutput, TErrorMap>;
+export declare function createProcedureClient<TInitialContext extends Context, TInputSchema extends Schema, TOutputSchema extends Schema, THandlerOutput extends SchemaInput<TOutputSchema>, TErrorMap extends ErrorMap, TMeta extends Meta, TClientContext extends ClientContext>(lazyableProcedure: Lazyable<Procedure<TInitialContext, any, TInputSchema, TOutputSchema, THandlerOutput, TErrorMap, TMeta>>, ...[options]: MaybeOptionalOptions<CreateProcedureClientOptions<TInitialContext, TInputSchema, TOutputSchema, THandlerOutput, TErrorMap, TMeta, TClientContext>>): ProcedureClient<TClientContext, TInputSchema, TOutputSchema, THandlerOutput, TErrorMap>;
 //# sourceMappingURL=procedure-client.d.ts.map

package/dist/src/procedure-decorated.d.ts

@@ -1,7 +1,8 @@
-import type { ClientRest, ErrorMap, MergedErrorMap, Meta, ORPCErrorConstructorMap, Route, Schema, SchemaInput, SchemaOutput } from '@orpc/contract';
+import type { ClientContext, ClientRest, ErrorMap, MergedErrorMap, Meta, ORPCErrorConstructorMap, Route, Schema, SchemaInput, SchemaOutput } from '@orpc/contract';
+import type { MaybeOptionalOptions } from '@orpc/shared';
 import type { ConflictContextGuard, Context, MergedContext } from './context';
 import type { MapInputMiddleware, Middleware } from './middleware';
-import type { CreateProcedureClientRest, ProcedureClient } from './procedure-client';
+import type { CreateProcedureClientOptions, ProcedureClient } from './procedure-client';
 import { Procedure } from './procedure';
 export declare class DecoratedProcedure<TInitialContext extends Context, TCurrentContext extends Context, TInputSchema extends Schema, TOutputSchema extends Schema, THandlerOutput extends SchemaInput<TOutputSchema>, TErrorMap extends ErrorMap, TMeta extends Meta> extends Procedure<TInitialContext, TCurrentContext, TInputSchema, TOutputSchema, THandlerOutput, TErrorMap, TMeta> {
     errors<U extends ErrorMap>(errors: U): DecoratedProcedure<TInitialContext, TCurrentContext, TInputSchema, TOutputSchema, THandlerOutput, MergedErrorMap<TErrorMap, U>, TMeta>;
@@ -12,10 +13,10 @@ export declare class DecoratedProcedure<TInitialContext extends Context, TCurren
     /**
      * Make this procedure callable (works like a function while still being a procedure).
      */
-    callable<TClientContext>(...rest: CreateProcedureClientRest<TInitialContext, TInputSchema, TOutputSchema, THandlerOutput, TErrorMap, TMeta, TClientContext>): Procedure<TInitialContext, TCurrentContext, TInputSchema, TOutputSchema, THandlerOutput, TErrorMap, TMeta> & ProcedureClient<TClientContext, TInputSchema, TOutputSchema, THandlerOutput, TErrorMap>;
+    callable<TClientContext extends ClientContext>(...rest: MaybeOptionalOptions<CreateProcedureClientOptions<TInitialContext, TInputSchema, TOutputSchema, THandlerOutput, TErrorMap, TMeta, TClientContext>>): Procedure<TInitialContext, TCurrentContext, TInputSchema, TOutputSchema, THandlerOutput, TErrorMap, TMeta> & ProcedureClient<TClientContext, TInputSchema, TOutputSchema, THandlerOutput, TErrorMap>;
     /**
      * Make this procedure compatible with server action (the same as .callable, but the type is compatible with server action).
      */
-    actionable<TClientContext>(...rest: CreateProcedureClientRest<TInitialContext, TInputSchema, TOutputSchema, THandlerOutput, TErrorMap, TMeta, TClientContext>): Procedure<TInitialContext, TCurrentContext, TInputSchema, TOutputSchema, THandlerOutput, TErrorMap, TMeta> & ((...rest: ClientRest<TClientContext, SchemaInput<TInputSchema>>) => Promise<SchemaOutput<TOutputSchema, THandlerOutput>>);
+    actionable<TClientContext extends ClientContext>(...rest: MaybeOptionalOptions<CreateProcedureClientOptions<TInitialContext, TInputSchema, TOutputSchema, THandlerOutput, TErrorMap, TMeta, TClientContext>>): Procedure<TInitialContext, TCurrentContext, TInputSchema, TOutputSchema, THandlerOutput, TErrorMap, TMeta> & ((...rest: ClientRest<TClientContext, SchemaInput<TInputSchema>>) => Promise<SchemaOutput<TOutputSchema, THandlerOutput>>);
 }
 //# sourceMappingURL=procedure-decorated.d.ts.map

package/dist/src/procedure-utils.d.ts

@@ -1,8 +1,9 @@
 import type { ClientPromiseResult, ErrorFromErrorMap, ErrorMap, Meta, Schema, SchemaInput, SchemaOutput } from '@orpc/contract';
+import type { MaybeOptionalOptions } from '@orpc/shared';
 import type { Context } from './context';
 import type { Lazyable } from './lazy';
 import type { Procedure } from './procedure';
-import { type CreateProcedureClientRest } from './procedure-client';
+import type { CreateProcedureClientOptions } from './procedure-client';
 /**
  * Directly call a procedure without creating a client.
  *
@@ -13,5 +14,5 @@ import { type CreateProcedureClientRest } from './procedure-client';
  * ```
  *
  */
-export declare function call<TInitialContext extends Context, TInputSchema extends Schema, TOutputSchema extends Schema, THandlerOutput extends SchemaInput<TOutputSchema>, TErrorMap extends ErrorMap, TMeta extends Meta>(procedure: Lazyable<Procedure<TInitialContext, any, TInputSchema, TOutputSchema, THandlerOutput, TErrorMap, TMeta>>, input: SchemaInput<TInputSchema>, ...rest: CreateProcedureClientRest<TInitialContext, TInputSchema, TOutputSchema, THandlerOutput, TErrorMap, TMeta, unknown>): ClientPromiseResult<SchemaOutput<TOutputSchema, THandlerOutput>, ErrorFromErrorMap<TErrorMap>>;
+export declare function call<TInitialContext extends Context, TInputSchema extends Schema, TOutputSchema extends Schema, THandlerOutput extends SchemaInput<TOutputSchema>, TErrorMap extends ErrorMap, TMeta extends Meta>(procedure: Lazyable<Procedure<TInitialContext, any, TInputSchema, TOutputSchema, THandlerOutput, TErrorMap, TMeta>>, input: SchemaInput<TInputSchema>, ...rest: MaybeOptionalOptions<CreateProcedureClientOptions<TInitialContext, TInputSchema, TOutputSchema, THandlerOutput, TErrorMap, TMeta, Record<never, never>>>): ClientPromiseResult<SchemaOutput<TOutputSchema, THandlerOutput>, ErrorFromErrorMap<TErrorMap>>;
 //# sourceMappingURL=procedure-utils.d.ts.map

package/dist/src/procedure.d.ts

@@ -1,4 +1,4 @@
-import type { AbortSignal, ContractProcedureDef, ErrorMap, Meta, ORPCErrorConstructorMap, Schema, SchemaInput, SchemaOutput } from '@orpc/contract';
+import type { ContractProcedureDef, ErrorMap, Meta, ORPCErrorConstructorMap, Schema, SchemaInput, SchemaOutput } from '@orpc/contract';
 import type { Promisable } from '@orpc/shared';
 import type { Context, TypeInitialContext } from './context';
 import type { AnyMiddleware } from './middleware';

package/dist/src/router-client.d.ts

@@ -1,11 +1,11 @@
-import type { ErrorMap, Meta } from '@orpc/contract';
+import type { ClientContext, ErrorMap, Meta } from '@orpc/contract';
+import type { MaybeOptionalOptions } from '@orpc/shared';
 import type { Lazy } from './lazy';
 import type { Procedure } from './procedure';
-import type { CreateProcedureClientRest, ProcedureClient } from './procedure-client';
-import type { AnyRouter, Router } from './router';
-export type RouterClient<TRouter extends AnyRouter, TClientContext> = TRouter extends Lazy<infer U extends AnyRouter> ? RouterClient<U, TClientContext> : TRouter extends Procedure<any, any, infer UInputSchema, infer UOutputSchema, infer UFuncOutput, infer UErrorMap, any> ? ProcedureClient<TClientContext, UInputSchema, UOutputSchema, UFuncOutput, UErrorMap> : {
+import type { CreateProcedureClientOptions, ProcedureClient } from './procedure-client';
+import type { AnyRouter, InferRouterInitialContext } from './router';
+export type RouterClient<TRouter extends AnyRouter, TClientContext extends ClientContext> = TRouter extends Lazy<infer U extends AnyRouter> ? RouterClient<U, TClientContext> : TRouter extends Procedure<any, any, infer UInputSchema, infer UOutputSchema, infer UFuncOutput, infer UErrorMap, any> ? ProcedureClient<TClientContext, UInputSchema, UOutputSchema, UFuncOutput, UErrorMap> : {
     [K in keyof TRouter]: TRouter[K] extends AnyRouter ? RouterClient<TRouter[K], TClientContext> : never;
 };
-export type CreateRouterClientRest<TRouter extends AnyRouter, TClientContext> = CreateProcedureClientRest<TRouter extends Router<infer UContext, any> ? UContext : never, undefined, undefined, unknown, ErrorMap, Meta, TClientContext>;
-export declare function createRouterClient<TRouter extends AnyRouter, TClientContext>(router: TRouter | Lazy<undefined>, ...rest: CreateRouterClientRest<TRouter, TClientContext>): RouterClient<TRouter, TClientContext>;
+export declare function createRouterClient<TRouter extends AnyRouter, TClientContext extends ClientContext>(router: TRouter | Lazy<undefined>, ...rest: MaybeOptionalOptions<CreateProcedureClientOptions<InferRouterInitialContext<TRouter>, undefined, undefined, unknown, ErrorMap, Meta, TClientContext>>): RouterClient<TRouter, TClientContext>;
 //# sourceMappingURL=router-client.d.ts.map

package/dist/src/router.d.ts

@@ -9,6 +9,7 @@ export type Router<TInitialContext extends Context, TContract extends AnyContrac
     [K in keyof TContract]: TContract[K] extends AnyContractRouter ? Router<TInitialContext, TContract[K]> : never;
 }>;
 export type AnyRouter = Router<any, any>;
+export type InferRouterInitialContext<T extends AnyRouter> = T extends Router<infer UInitialContext, any> ? UInitialContext : never;
 export type InferRouterInputs<T extends AnyRouter> = T extends Lazy<infer U extends AnyRouter> ? InferRouterInputs<U> : T extends Procedure<any, any, infer UInputSchema, any, any, any, any> ? SchemaInput<UInputSchema> : {
     [K in keyof T]: T[K] extends AnyRouter ? InferRouterInputs<T[K]> : never;
 };

package/dist/standard.js

@@ -4,9 +4,9 @@ import {
   RPCSerializer,
   StandardHandler,
   serializeRPCJson
-} from "./chunk-F75AQ6KO.js";
-import "./chunk-SV6DBVXJ.js";
-import "./chunk-XFBAK67J.js";
+} from "./chunk-DAUWED3D.js";
+import "./chunk-XP6YRLY2.js";
+import "./chunk-XI6WGCB3.js";
 export {
   RPCCodec,
   RPCMatcher,

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@orpc/server",
   "type": "module",
-  "version": "0.0.0-next.9723092",
+  "version": "0.0.0-next.989a435",
   "license": "MIT",
   "homepage": "https://orpc.unnoq.com",
   "repository": {
@@ -63,9 +63,11 @@
     "next": ">=14.0.0"
   },
   "dependencies": {
-    "content-disposition": "^0.5.4",
-    "@orpc/contract": "0.0.0-next.9723092",
-    "@orpc/shared": "0.0.0-next.9723092"
+    "@orpc/server-standard": "^0.0.0",
+    "@orpc/server-standard-fetch": "^0.0.0",
+    "@orpc/server-standard-node": "^0.0.0",
+    "@orpc/contract": "0.0.0-next.989a435",
+    "@orpc/shared": "0.0.0-next.989a435"
   },
   "devDependencies": {
     "light-my-request": "^6.5.1"

package/dist/chunk-LBBHJSG5.js

@@ -1,136 +0,0 @@
-import {
-  RPCCodec,
-  RPCMatcher,
-  StandardHandler
-} from "./chunk-F75AQ6KO.js";
-
-// src/adapters/fetch/utils.ts
-import { once } from "@orpc/shared";
-import cd from "content-disposition";
-function fetchHeadersToStandardHeaders(headers) {
-  const standardHeaders = {};
-  for (const [key, value] of headers) {
-    if (Array.isArray(standardHeaders[key])) {
-      standardHeaders[key].push(value);
-    } else if (standardHeaders[key] !== void 0) {
-      standardHeaders[key] = [standardHeaders[key], value];
-    } else {
-      standardHeaders[key] = value;
-    }
-  }
-  return standardHeaders;
-}
-async function fetchReToStandardBody(re) {
-  if (!re.body) {
-    return void 0;
-  }
-  const contentDisposition = re.headers.get("content-disposition");
-  const fileName = contentDisposition ? cd.parse(contentDisposition).parameters.filename : void 0;
-  if (fileName) {
-    const blob2 = await re.blob();
-    return new File([blob2], fileName, {
-      type: blob2.type
-    });
-  }
-  const contentType = re.headers.get("content-type");
-  if (!contentType || contentType.startsWith("application/json")) {
-    const text = await re.text();
-    if (!text) {
-      return void 0;
-    }
-    return JSON.parse(text);
-  }
-  if (contentType.startsWith("multipart/form-data")) {
-    return await re.formData();
-  }
-  if (contentType.startsWith("application/x-www-form-urlencoded")) {
-    return new URLSearchParams(await re.text());
-  }
-  if (contentType.startsWith("text/")) {
-    return await re.text();
-  }
-  const blob = await re.blob();
-  return new File([blob], "blob", {
-    type: blob.type
-  });
-}
-function fetchRequestToStandardRequest(request) {
-  const url = new URL(request.url);
-  return {
-    raw: { request },
-    url,
-    signal: request.signal,
-    method: request.method,
-    body: once(() => {
-      return fetchReToStandardBody(request);
-    }),
-    get headers() {
-      const headers = fetchHeadersToStandardHeaders(request.headers);
-      Object.defineProperty(this, "headers", { value: headers, writable: true });
-      return headers;
-    },
-    set headers(value) {
-      Object.defineProperty(this, "headers", { value, writable: true });
-    }
-  };
-}
-function standardResponseToFetchHeaders(response) {
-  const fetchHeaders = new Headers();
-  for (const [key, value] of Object.entries(response.headers)) {
-    if (Array.isArray(value)) {
-      for (const v of value) {
-        fetchHeaders.append(key, v);
-      }
-    } else if (value !== void 0) {
-      fetchHeaders.append(key, value);
-    }
-  }
-  if (response.body instanceof Blob && !fetchHeaders.has("content-disposition")) {
-    fetchHeaders.set("content-disposition", cd(response.body instanceof File ? response.body.name : "blob"));
-  } else if (!(response.body instanceof Blob) && !(response.body instanceof URLSearchParams) && !(response.body instanceof FormData) && response.body !== void 0 && !fetchHeaders.has("content-type")) {
-    fetchHeaders.set("content-type", "application/json");
-  }
-  return fetchHeaders;
-}
-function standardBodyToFetchBody(body) {
-  if (body instanceof Blob || body instanceof FormData || body instanceof URLSearchParams) {
-    return body;
-  }
-  return JSON.stringify(body);
-}
-function standardResponseToFetchResponse(response) {
-  return new Response(standardBodyToFetchBody(response.body), {
-    headers: standardResponseToFetchHeaders(response),
-    status: response.status
-  });
-}
-
-// src/adapters/fetch/rpc-handler.ts
-var RPCHandler = class {
-  standardHandler;
-  constructor(router, options) {
-    const matcher = options?.matcher ?? new RPCMatcher();
-    const codec = options?.codec ?? new RPCCodec();
-    this.standardHandler = new StandardHandler(router, matcher, codec, options);
-  }
-  async handle(request, ...rest) {
-    const standardRequest = fetchRequestToStandardRequest(request);
-    const result = await this.standardHandler.handle(standardRequest, ...rest);
-    if (!result.matched) {
-      return result;
-    }
-    return {
-      matched: true,
-      response: standardResponseToFetchResponse(result.response)
-    };
-  }
-};
-
-export {
-  fetchReToStandardBody,
-  fetchRequestToStandardRequest,
-  standardBodyToFetchBody,
-  standardResponseToFetchResponse,
-  RPCHandler
-};
-//# sourceMappingURL=chunk-LBBHJSG5.js.map

package/dist/src/adapters/fetch/utils.d.ts

@@ -1,6 +0,0 @@
-import type { StandardBody, StandardRequest, StandardResponse } from '../standard';
-export declare function fetchReToStandardBody(re: Request | Response): Promise<StandardBody>;
-export declare function fetchRequestToStandardRequest(request: Request): StandardRequest;
-export declare function standardBodyToFetchBody(body: StandardBody): Blob | FormData | URLSearchParams | string | undefined;
-export declare function standardResponseToFetchResponse(response: StandardResponse): Response;
-//# sourceMappingURL=utils.d.ts.map

package/dist/src/adapters/node/utils.d.ts

@@ -1,5 +0,0 @@
-import type { StandardRequest, StandardResponse } from '../standard';
-import type { NodeHttpRequest, NodeHttpResponse } from './types';
-export declare function nodeHttpToStandardRequest(req: NodeHttpRequest, res: NodeHttpResponse): StandardRequest;
-export declare function nodeHttpResponseSendStandardResponse(res: NodeHttpResponse, standardResponse: StandardResponse): Promise<void>;
-//# sourceMappingURL=utils.d.ts.map