@orpc/server 0.0.0-next.31590a1 → 0.0.0-next.32cb70c

package/dist/node.js

@@ -1,175 +1,87 @@
 import {
-  RPCCodec,
-  RPCMatcher,
-  StandardHandler
-} from "./chunk-CVIWJKJC.js";
-import "./chunk-NOA3GBJQ.js";
-import "./chunk-OXB4YX67.js";
+  RPCHandler
+} from "./chunk-ESTRJAOX.js";
+import "./chunk-KK4SDLC7.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) {
+// src/adapters/node/request-listener.ts
+function createRequest(req, res) {
+  const controller = new AbortController();
+  res.on("close", () => {
+    controller.abort();
+  });
   const method = req.method ?? "GET";
+  const headers = createHeaders(req);
   const protocol = "encrypted" in req.socket && req.socket.encrypted ? "https:" : "http:";
-  const host = req.headers.host ?? "localhost";
+  const host = headers.get("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");
+  const init = { method, headers, signal: controller.signal };
+  if (method !== "GET" && method !== "HEAD") {
+    init.body = new ReadableStream({
+      start(controller2) {
+        req.on("data", (chunk) => {
+          controller2.enqueue(new Uint8Array(chunk.buffer, chunk.byteOffset, chunk.byteLength));
+        });
+        req.on("end", () => {
+          controller2.close();
+        });
       }
-      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");
+    init.duplex = "half";
   }
-  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 new Request(url, init);
+}
+function createHeaders(req) {
+  const headers = new Headers();
+  const rawHeaders = req.rawHeaders;
+  for (let i = 0; i < rawHeaders.length; i += 2) {
+    headers.append(rawHeaders[i], rawHeaders[i + 1]);
   }
-  return streamToFile(req, "blob", contentType);
+  return headers;
 }
-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
+async function sendResponse(res, response) {
+  const headers = {};
+  for (const [key, value] of response.headers) {
+    if (key in headers) {
+      if (Array.isArray(headers[key])) {
+        headers[key].push(value);
+      } else {
+        headers[key] = [headers[key], value];
+      }
+    } else {
+      headers[key] = value;
     }
-  });
-  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);
+  res.writeHead(response.status, headers);
+  if (response.body != null && res.req.method !== "HEAD") {
+    for await (const chunk of response.body) {
+      res.write(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;
+  res.end();
 }
 
-// src/adapters/node/rpc-handler.ts
-var RPCHandler = class {
-  standardHandler;
+// src/adapters/node/orpc-handler.ts
+var RPCHandler2 = class {
+  orpcFetchHandler;
   constructor(router, options) {
-    const codec = options?.codec ?? new RPCCodec();
-    const matcher = options?.matcher ?? new RPCMatcher();
-    this.standardHandler = new StandardHandler(router, matcher, codec, options);
+    this.orpcFetchHandler = new RPCHandler(router, options);
   }
   async handle(req, res, ...rest) {
-    const standardRequest = nodeHttpToStandardRequest(req, res);
-    const result = await this.standardHandler.handle(standardRequest, ...rest);
-    if (!result.matched) {
+    const request = createRequest(req, res);
+    const result = await this.orpcFetchHandler.handle(request, ...rest);
+    if (result.matched === false) {
       return { matched: false };
     }
-    await nodeHttpResponseSendStandardResponse(res, result.response);
+    const context = rest[0]?.context ?? {};
+    await rest[0]?.beforeSend?.(result.response, context);
+    await sendResponse(res, result.response);
     return { matched: true };
   }
 };
 export {
-  RPCHandler,
-  nodeHttpResponseSendStandardResponse,
-  nodeHttpToStandardRequest
+  RPCHandler2 as RPCHandler,
+  createHeaders,
+  createRequest,
+  sendResponse
 };
 //# sourceMappingURL=node.js.map

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

@@ -1,4 +1,6 @@
-export * from './rpc-handler';
+export * from './orpc-handler';
+export * from './orpc-payload-codec';
+export * from './orpc-procedure-matcher';
+export * as SuperJSON from './super-json';
 export * from './types';
-export * from './utils';
 //# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1,20 @@
+import type { Hooks } from '@orpc/shared';
+import type { Context } from '../../context';
+import type { Router } from '../../router';
+import type { FetchHandler, FetchHandleRest, FetchHandleResult } from './types';
+import { type PublicORPCPayloadCodec } from './orpc-payload-codec';
+import { type PublicORPCProcedureMatcher } from './orpc-procedure-matcher';
+export type RPCHandlerOptions<T extends Context> = Hooks<Request, FetchHandleResult, T, {
+    signal?: AbortSignal;
+}> & {
+    procedureMatcher?: PublicORPCProcedureMatcher;
+    payloadCodec?: PublicORPCPayloadCodec;
+};
+export declare class RPCHandler<T extends Context> implements FetchHandler<T> {
+    private readonly options?;
+    private readonly procedureMatcher;
+    private readonly payloadCodec;
+    constructor(router: Router<T, any>, options?: NoInfer<RPCHandlerOptions<T>> | undefined);
+    handle(request: Request, ...[options]: FetchHandleRest<T>): Promise<FetchHandleResult>;
+}
+//# sourceMappingURL=orpc-handler.d.ts.map

package/dist/src/adapters/fetch/orpc-payload-codec.d.ts

@@ -0,0 +1,16 @@
+import { type HTTPMethod } from '@orpc/contract';
+export declare class ORPCPayloadCodec {
+    /**
+     * If method is GET, the payload will be encoded as query string.
+     * If method is GET and payload contain file, the method will be fallback to fallbackMethod. (fallbackMethod = GET will force to use GET method)
+     */
+    encode(payload: unknown, method?: HTTPMethod, fallbackMethod?: HTTPMethod): {
+        query?: URLSearchParams;
+        body?: FormData | string;
+        headers?: Headers;
+        method: HTTPMethod;
+    };
+    decode(re: Request | Response): Promise<unknown>;
+}
+export type PublicORPCPayloadCodec = Pick<ORPCPayloadCodec, keyof ORPCPayloadCodec>;
+//# sourceMappingURL=orpc-payload-codec.d.ts.map

package/dist/src/adapters/fetch/orpc-procedure-matcher.d.ts

@@ -0,0 +1,12 @@
+import type { AnyProcedure } from '../../procedure';
+import type { AnyRouter } from '../../router';
+export declare class ORPCProcedureMatcher {
+    private readonly router;
+    constructor(router: AnyRouter);
+    match(pathname: string): Promise<{
+        path: string[];
+        procedure: AnyProcedure;
+    } | undefined>;
+}
+export type PublicORPCProcedureMatcher = Pick<ORPCProcedureMatcher, keyof ORPCProcedureMatcher>;
+//# sourceMappingURL=orpc-procedure-matcher.d.ts.map

package/dist/src/adapters/fetch/super-json.d.ts

@@ -0,0 +1,12 @@
+import type { Segment } from '@orpc/shared';
+export type JSONExtraType = 'bigint' | 'date' | 'nan' | 'undefined' | 'set' | 'map' | 'regexp' | 'url';
+export type JSONMeta = [JSONExtraType, Segment[]][];
+export declare function serialize(value: unknown, segments?: Segment[], meta?: JSONMeta): {
+    data: unknown;
+    meta: JSONMeta;
+};
+export declare function deserialize({ data, meta, }: {
+    data: unknown;
+    meta: JSONMeta;
+}): unknown;
+//# sourceMappingURL=super-json.d.ts.map

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

@@ -1,5 +1,13 @@
+import type { HTTPPath } from '@orpc/contract';
 import type { Context } from '../../context';
-import type { StandardHandleRest } from '../standard';
+export type FetchHandleOptions<T extends Context> = {
+    prefix?: HTTPPath;
+} & (Record<never, never> extends T ? {
+    context?: T;
+} : {
+    context: T;
+});
+export type FetchHandleRest<T extends Context> = [options: FetchHandleOptions<T>] | (Record<never, never> extends T ? [] : never);
 export type FetchHandleResult = {
     matched: true;
     response: Response;
@@ -8,6 +16,6 @@ export type FetchHandleResult = {
     response: undefined;
 };
 export interface FetchHandler<T extends Context> {
-    handle(request: Request, ...rest: StandardHandleRest<T>): Promise<FetchHandleResult>;
+    handle(request: Request, ...rest: FetchHandleRest<T>): Promise<FetchHandleResult>;
 }
 //# sourceMappingURL=types.d.ts.map

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

@@ -1,9 +1,8 @@
 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 { FetchHandleOptions, FetchHandler } from '../fetch';
 import { type Value } from '@orpc/shared';
-export type CreateMiddlewareOptions<T extends Context> = Omit<StandardHandleOptions<T>, 'context'> & (Record<never, never> extends T ? {
+export type CreateMiddlewareOptions<T extends Context> = Omit<FetchHandleOptions<T>, 'context'> & (Record<never, never> extends T ? {
     context?: Value<T, [HonoContext]>;
 } : {
     context: Value<T, [HonoContext]>;

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

@@ -1,9 +1,8 @@
 import type { NextRequest } from 'next/server';
 import type { Context } from '../../context';
-import type { FetchHandler } from '../fetch';
-import type { StandardHandleOptions } from '../standard';
+import type { FetchHandleOptions, FetchHandler } from '../fetch';
 import { type Value } from '@orpc/shared';
-export type ServeOptions<T extends Context> = Omit<StandardHandleOptions<T>, 'context'> & (Record<never, never> extends T ? {
+export type ServeOptions<T extends Context> = Omit<FetchHandleOptions<T>, 'context'> & (Record<never, never> extends T ? {
     context?: Value<T, [NextRequest]>;
 } : {
     context: Value<T, [NextRequest]>;

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

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

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

@@ -0,0 +1,12 @@
+import type { ServerResponse } from 'node:http';
+import type { Context } from '../../context';
+import type { Router } from '../../router';
+import type { RPCHandlerOptions } from '../fetch/orpc-handler';
+import type { RequestHandler, RequestHandleRest, RequestHandleResult } from './types';
+import { type ExpressableIncomingMessage } from './request-listener';
+export declare class RPCHandler<T extends Context> implements RequestHandler<T> {
+    private readonly orpcFetchHandler;
+    constructor(router: Router<T, any>, options?: NoInfer<RPCHandlerOptions<T>>);
+    handle(req: ExpressableIncomingMessage, res: ServerResponse, ...rest: RequestHandleRest<T>): Promise<RequestHandleResult>;
+}
+//# sourceMappingURL=orpc-handler.d.ts.map

package/dist/src/adapters/node/request-listener.d.ts

@@ -0,0 +1,28 @@
+import type { IncomingMessage, ServerResponse } from 'node:http';
+export interface ExpressableIncomingMessage extends IncomingMessage {
+    originalUrl?: string;
+}
+/**
+ * Creates a [`Request`](https://developer.mozilla.org/en-US/docs/Web/API/Request) object from a Node.js
+ * [`IncomingMessage`](https://nodejs.org/api/http.html#class-httpincomingmessage) and
+ * [`http.ServerResponse`](https://nodejs.org/api/http.html#class-httpserverresponse) pair.
+ *
+ */
+export declare function createRequest(req: ExpressableIncomingMessage, res: ServerResponse): Request;
+/**
+ * Creates a [`Headers`](https://developer.mozilla.org/en-US/docs/Web/API/Headers) object from the headers
+ * in a Node.js [`IncomingMessage`](https://nodejs.org/api/http.html#class-httpincomingmessage).
+ *
+ * @param req The incoming request object.
+ * @returns A headers object.
+ */
+export declare function createHeaders(req: IncomingMessage): Headers;
+/**
+ * Sends a [`Response`](https://developer.mozilla.org/en-US/docs/Web/API/Response) to the client using the
+ * Node.js [`http.ServerResponse`](https://nodejs.org/api/http.html#class-httpserverresponse) object.
+ *
+ * @param res The server response object.
+ * @param response The response to send.
+ */
+export declare function sendResponse(res: ServerResponse, response: Response): Promise<void>;
+//# sourceMappingURL=request-listener.d.ts.map

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

@@ -1,21 +1,22 @@
+import type { HTTPPath } from '@orpc/contract';
+import type { Promisable } 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';
-export type NodeHttpRequest = (IncomingMessage | Http2ServerRequest) & {
-    /**
-     * Replace `req.url` with `req.originalUrl` when `req.originalUrl` is available.
-     * This is useful for `express.js` middleware.
-     */
-    originalUrl?: string;
-};
-export type NodeHttpResponse = ServerResponse | Http2ServerResponse;
-export type NodeHttpHandleResult = {
+export type RequestHandleOptions<T extends Context> = {
+    prefix?: HTTPPath;
+    beforeSend?(response: Response, context: T): Promisable<void>;
+} & (Record<never, never> extends T ? {
+    context?: T;
+} : {
+    context: T;
+});
+export type RequestHandleRest<T extends Context> = [options: RequestHandleOptions<T>] | (Record<never, never> extends T ? [] : never);
+export type RequestHandleResult = {
     matched: true;
 } | {
     matched: false;
 };
-export interface NodeHttpHandler<T extends Context> {
-    handle(req: NodeHttpRequest, res: NodeHttpResponse, ...rest: StandardHandleRest<T>): Promise<NodeHttpHandleResult>;
+export interface RequestHandler<T extends Context> {
+    handle(req: IncomingMessage, res: ServerResponse, ...rest: RequestHandleRest<T>): Promise<RequestHandleResult>;
 }
 //# sourceMappingURL=types.d.ts.map

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

@@ -1,17 +1,16 @@
-import type { AnyContractRouter, ContractProcedure, ContractRouterToErrorMap, ContractRouterToMeta, ORPCErrorConstructorMap } from '@orpc/contract';
+import type { AnyContractRouter, ContractProcedure, ContractRouter, ContractRouterToErrorMap, ORPCErrorConstructorMap } from '@orpc/contract';
 import type { ConflictContextGuard, Context, MergedContext } from './context';
 import type { ProcedureImplementer } from './implementer-procedure';
 import type { FlattenLazy } from './lazy-utils';
 import type { Middleware } from './middleware';
 import type { AdaptedRouter, Router } from './router';
-export interface RouterImplementerWithMiddlewares<TContract extends AnyContractRouter, TInitialContext extends Context, TCurrentContext extends Context> {
-    use<U extends Context>(middleware: Middleware<TCurrentContext, U, unknown, unknown, ORPCErrorConstructorMap<ContractRouterToErrorMap<TContract>>, ContractRouterToMeta<TContract>>): ConflictContextGuard<MergedContext<TCurrentContext, U>> & ImplementerInternalWithMiddlewares<TContract, TInitialContext, MergedContext<TCurrentContext, U>>;
+export type ImplementerInternalWithMiddlewares<TContract extends AnyContractRouter, TInitialContext extends Context, TCurrentContext extends Context> = (TContract extends ContractProcedure<infer UInputSchema, infer UOutputSchema, infer UErrorMap, infer UMeta> ? ProcedureImplementer<TInitialContext, TCurrentContext, UInputSchema, UOutputSchema, UErrorMap, UMeta> : TContract extends ContractRouter<infer UMeta> ? {
+    use<U extends Context>(middleware: Middleware<TCurrentContext, U, unknown, unknown, ORPCErrorConstructorMap<ContractRouterToErrorMap<TContract>>, UMeta>): ConflictContextGuard<MergedContext<TCurrentContext, U>> & ImplementerInternalWithMiddlewares<TContract, TInitialContext, MergedContext<TCurrentContext, U>>;
     router<U extends Router<TCurrentContext, TContract>>(router: U): AdaptedRouter<U, TInitialContext, Record<never, never>>;
     lazy<U extends Router<TInitialContext, TContract>>(loader: () => Promise<{
         default: U;
     }>): AdaptedRouter<FlattenLazy<U>, TInitialContext, Record<never, never>>;
-}
-export type ImplementerInternalWithMiddlewares<TContract extends AnyContractRouter, TInitialContext extends Context, TCurrentContext extends Context> = (TContract extends ContractProcedure<infer UInputSchema, infer UOutputSchema, infer UErrorMap, infer UMeta> ? ProcedureImplementer<TInitialContext, TCurrentContext, UInputSchema, UOutputSchema, UErrorMap, UMeta> : RouterImplementerWithMiddlewares<TContract, TInitialContext, TCurrentContext> & {
+} & {
     [K in keyof TContract]: TContract[K] extends AnyContractRouter ? ImplementerInternalWithMiddlewares<TContract[K], TInitialContext, TCurrentContext> : never;
-});
+} : never);
 //# sourceMappingURL=implementer-variants.d.ts.map

package/dist/src/implementer.d.ts

@@ -1,4 +1,4 @@
-import type { AnyContractRouter, ContractProcedure, ContractRouterToErrorMap, ContractRouterToMeta, ORPCErrorConstructorMap } from '@orpc/contract';
+import type { AnyContractRouter, ContractProcedure, ContractRouter, ContractRouterToErrorMap, ContractRouterToMeta, ORPCErrorConstructorMap } from '@orpc/contract';
 import type { ConflictContextGuard, Context, MergedContext } from './context';
 import type { ProcedureImplementer } from './implementer-procedure';
 import type { ImplementerInternalWithMiddlewares } from './implementer-variants';
@@ -7,18 +7,17 @@ import { type BuilderConfig } from './builder';
 import { type FlattenLazy } from './lazy-utils';
 import { type DecoratedMiddleware } from './middleware-decorated';
 import { type AdaptedRouter, type Router } from './router';
-export interface RouterImplementer<TContract extends AnyContractRouter, TInitialContext extends Context, TCurrentContext extends Context> {
+export type ImplementerInternal<TContract extends AnyContractRouter, TInitialContext extends Context, TCurrentContext extends Context> = (TContract extends ContractProcedure<infer UInputSchema, infer UOutputSchema, infer UErrorMap, infer UMeta> ? ProcedureImplementer<TInitialContext, TCurrentContext, UInputSchema, UOutputSchema, UErrorMap, UMeta> : TContract extends ContractRouter<infer UMeta> ? {
     middleware<UOutContext extends Context, TInput, TOutput = any>(// = any here is important to make middleware can be used in any output by default
-    middleware: Middleware<TCurrentContext, UOutContext, TInput, TOutput, ORPCErrorConstructorMap<ContractRouterToErrorMap<TContract>>, ContractRouterToMeta<TContract>>): DecoratedMiddleware<TCurrentContext, UOutContext, TInput, TOutput, ORPCErrorConstructorMap<any>, ContractRouterToMeta<TContract>>;
-    use<U extends Context>(middleware: Middleware<TCurrentContext, U, unknown, unknown, ORPCErrorConstructorMap<ContractRouterToErrorMap<TContract>>, ContractRouterToMeta<TContract>>): ConflictContextGuard<MergedContext<TCurrentContext, U>> & ImplementerInternalWithMiddlewares<TContract, TInitialContext, MergedContext<TCurrentContext, U>>;
+    middleware: Middleware<TCurrentContext, UOutContext, TInput, TOutput, ORPCErrorConstructorMap<ContractRouterToErrorMap<TContract>>, ContractRouterToMeta<TContract>>): DecoratedMiddleware<TCurrentContext, UOutContext, TInput, TOutput, ORPCErrorConstructorMap<any>, UMeta>;
+    use<U extends Context>(middleware: Middleware<TCurrentContext, U, unknown, unknown, ORPCErrorConstructorMap<ContractRouterToErrorMap<TContract>>, UMeta>): ConflictContextGuard<MergedContext<TCurrentContext, U>> & ImplementerInternalWithMiddlewares<TContract, TInitialContext, MergedContext<TCurrentContext, U>>;
     router<U extends Router<TCurrentContext, TContract>>(router: U): AdaptedRouter<U, TInitialContext, Record<never, never>>;
     lazy<U extends Router<TCurrentContext, TContract>>(loader: () => Promise<{
         default: U;
     }>): AdaptedRouter<FlattenLazy<U>, TInitialContext, Record<never, never>>;
-}
-export type ImplementerInternal<TContract extends AnyContractRouter, TInitialContext extends Context, TCurrentContext extends Context> = (TContract extends ContractProcedure<infer UInputSchema, infer UOutputSchema, infer UErrorMap, infer UMeta> ? ProcedureImplementer<TInitialContext, TCurrentContext, UInputSchema, UOutputSchema, UErrorMap, UMeta> : RouterImplementer<TContract, TInitialContext, TCurrentContext> & {
+} & {
     [K in keyof TContract]: TContract[K] extends AnyContractRouter ? ImplementerInternal<TContract[K], TInitialContext, TCurrentContext> : never;
-});
+} : never);
 export declare function implementerInternal<TContract extends AnyContractRouter, TInitialContext extends Context, TCurrentContext extends Context>(contract: TContract, config: BuilderConfig, middlewares: AnyMiddleware[]): ImplementerInternal<TContract, TInitialContext, TCurrentContext>;
 export type Implementer<TContract extends AnyContractRouter, TInitialContext extends Context, TCurrentContext extends Context> = {
     $context<U extends Context>(): Implementer<TContract, U, U>;

package/dist/src/index.d.ts

@@ -17,7 +17,5 @@ export * from './procedure-utils';
 export * from './router';
 export * from './router-accessible-lazy';
 export * from './router-client';
-export * from './utils';
-export { isDefinedError, ORPCError, safe, type, ValidationError } from '@orpc/contract';
-export { onError, onFinish, onStart, onSuccess } from '@orpc/shared';
+export { isDefinedError, ORPCError, safe, type } from '@orpc/contract';
 //# sourceMappingURL=index.d.ts.map

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@orpc/server",
   "type": "module",
-  "version": "0.0.0-next.31590a1",
+  "version": "0.0.0-next.32cb70c",
   "license": "MIT",
   "homepage": "https://orpc.unnoq.com",
   "repository": {
@@ -19,16 +19,6 @@
       "import": "./dist/index.js",
       "default": "./dist/index.js"
     },
-    "./plugins": {
-      "types": "./dist/src/plugins/index.d.ts",
-      "import": "./dist/plugins.js",
-      "default": "./dist/plugins.js"
-    },
-    "./standard": {
-      "types": "./dist/src/adapters/standard/index.d.ts",
-      "import": "./dist/standard.js",
-      "default": "./dist/standard.js"
-    },
     "./fetch": {
       "types": "./dist/src/adapters/fetch/index.d.ts",
       "import": "./dist/fetch.js",
@@ -63,12 +53,8 @@
     "next": ">=14.0.0"
   },
   "dependencies": {
-    "content-disposition": "^0.5.4",
-    "@orpc/contract": "0.0.0-next.31590a1",
-    "@orpc/shared": "0.0.0-next.31590a1"
-  },
-  "devDependencies": {
-    "light-my-request": "^6.5.1"
+    "@orpc/contract": "0.0.0-next.32cb70c",
+    "@orpc/shared": "0.0.0-next.32cb70c"
   },
   "scripts": {
     "build": "tsup --onSuccess='tsc -b --noCheck'",