@orpc/server 0.0.0-next.8f101b9 → 0.0.0-next.905e81c

package/dist/hono.js

@@ -1,30 +1,34 @@
-import "./chunk-WUOGVGWG.js";
 import {
-  ORPCPayloadCodec,
-  ORPCProcedureMatcher,
-  RPCHandler,
-  super_json_exports
-} from "./chunk-ESTRJAOX.js";
-import "./chunk-KK4SDLC7.js";
+  RPCHandler
+} from "./chunk-47YYO5JS.js";
+import "./chunk-77FU7QSO.js";
+import "./chunk-MHVECKBC.js";
+import "./chunk-WQNNSBXW.js";
 
 // src/adapters/hono/middleware.ts
 import { value } from "@orpc/shared";
 function createMiddleware(handler, ...[options]) {
   return async (c, next) => {
+    const bodyProps = /* @__PURE__ */ new Set(["arrayBuffer", "blob", "formData", "json", "text"]);
+    const request = c.req.method === "GET" || c.req.method === "HEAD" ? c.req.raw : new Proxy(c.req.raw, {
+      // https://github.com/honojs/middleware/blob/main/packages/trpc-server/src/index.ts#L39
+      get(target, prop) {
+        if (bodyProps.has(prop)) {
+          return () => c.req[prop]();
+        }
+        return Reflect.get(target, prop, target);
+      }
+    });
     const context = await value(options?.context ?? {}, c);
-    const { matched, response } = await handler.handle(c.req.raw, { ...options, context });
+    const { matched, response } = await handler.handle(request, { ...options, context });
     if (matched) {
-      c.res = response;
-      return;
+      return c.newResponse(response.body, response);
     }
     await next();
   };
 }
 export {
-  ORPCPayloadCodec,
-  ORPCProcedureMatcher,
   RPCHandler,
-  super_json_exports as SuperJSON,
   createMiddleware
 };
 //# sourceMappingURL=hono.js.map

package/dist/index.js

@@ -3,10 +3,14 @@ import {
   Procedure,
   adaptRouter,
   addMiddleware,
+  convertPathToHttpPath,
   createAccessibleLazyRouter,
+  createContractedProcedure,
   createLazyProcedureFormAnyLazy,
   createProcedureClient,
   deepSetLazyRouterPrefix,
+  eachAllContractProcedure,
+  eachContractProcedure,
   flatLazy,
   getLazyRouterPrefix,
   getRouterChild,
@@ -17,7 +21,7 @@ import {
   middlewareOutputFn,
   setRouterContract,
   unlazy
-} from "./chunk-KK4SDLC7.js";
+} from "./chunk-MHVECKBC.js";
 
 // src/builder.ts
 import { mergeErrorMap as mergeErrorMap2, mergeMeta as mergeMeta2, mergePrefix, mergeRoute as mergeRoute2, mergeTags } from "@orpc/contract";
@@ -46,10 +50,14 @@ function decorateMiddleware(middleware) {
   decorated.concat = (concatMiddleware, mapInput) => {
     const mapped = mapInput ? decorateMiddleware(concatMiddleware).mapInput(mapInput) : concatMiddleware;
     const concatted = decorateMiddleware((options, input, output, ...rest) => {
-      const next = async (...[nextOptions]) => {
-        return mapped({ ...options, context: { ...nextOptions?.context, ...options.context } }, input, output, ...rest);
-      };
-      const merged = middleware({ ...options, next }, input, output, ...rest);
+      const merged = middleware({
+        ...options,
+        next: (...[nextOptions1]) => mapped({
+          ...options,
+          context: { ...options.context, ...nextOptions1?.context },
+          next: (...[nextOptions2]) => options.next({ context: { ...nextOptions1?.context, ...nextOptions2?.context } })
+        }, input, output, ...rest)
+      }, input, output, ...rest);
       return merged;
     });
     return concatted;
@@ -353,23 +361,33 @@ function createRouterClient(router, ...rest) {
 }
 
 // src/index.ts
-import { isDefinedError, ORPCError, safe, type } from "@orpc/contract";
+import { isDefinedError, ORPCError, safe } from "@orpc/client";
+import { eventIterator, type, ValidationError } from "@orpc/contract";
+import { getEventMeta, withEventMeta } from "@orpc/server-standard";
+import { onError, onFinish, onStart, onSuccess } from "@orpc/shared";
 export {
   Builder,
   DecoratedProcedure,
   LAZY_LOADER_SYMBOL,
   ORPCError,
   Procedure,
+  ValidationError,
   adaptRouter,
   call,
+  convertPathToHttpPath,
   createAccessibleLazyRouter,
+  createContractedProcedure,
   createLazyProcedureFormAnyLazy,
   createProcedureClient,
   createRouterClient,
   decorateMiddleware,
   deepSetLazyRouterPrefix,
+  eachAllContractProcedure,
+  eachContractProcedure,
+  eventIterator,
   fallbackConfig,
   flatLazy,
+  getEventMeta,
   getLazyRouterPrefix,
   getRouterChild,
   getRouterContract,
@@ -381,10 +399,15 @@ export {
   lazy,
   mergeContext,
   middlewareOutputFn,
+  onError,
+  onFinish,
+  onStart,
+  onSuccess,
   os,
   safe,
   setRouterContract,
   type,
-  unlazy
+  unlazy,
+  withEventMeta
 };
 //# sourceMappingURL=index.js.map

package/dist/next.js

@@ -1,11 +1,9 @@
-import "./chunk-WUOGVGWG.js";
 import {
-  ORPCPayloadCodec,
-  ORPCProcedureMatcher,
-  RPCHandler,
-  super_json_exports
-} from "./chunk-ESTRJAOX.js";
-import "./chunk-KK4SDLC7.js";
+  RPCHandler
+} from "./chunk-47YYO5JS.js";
+import "./chunk-77FU7QSO.js";
+import "./chunk-MHVECKBC.js";
+import "./chunk-WQNNSBXW.js";
 
 // src/adapters/next/serve.ts
 import { value } from "@orpc/shared";
@@ -27,10 +25,7 @@ function serve(handler, ...[options]) {
   };
 }
 export {
-  ORPCPayloadCodec,
-  ORPCProcedureMatcher,
   RPCHandler,
-  super_json_exports as SuperJSON,
   serve
 };
 //# sourceMappingURL=next.js.map

package/dist/node.js

@@ -1,87 +1,31 @@
 import {
-  RPCHandler
-} from "./chunk-ESTRJAOX.js";
-import "./chunk-KK4SDLC7.js";
+  RPCCodec,
+  RPCMatcher,
+  StandardHandler
+} from "./chunk-77FU7QSO.js";
+import "./chunk-MHVECKBC.js";
+import "./chunk-WQNNSBXW.js";
 
-// 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 = headers.get("Host") ?? "localhost";
-  const url = new URL(req.originalUrl ?? req.url ?? "/", `${protocol}//${host}`);
-  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();
-        });
-      }
-    });
-    init.duplex = "half";
-  }
-  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 headers;
-}
-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;
-    }
-  }
-  res.writeHead(response.status, headers);
-  if (response.body != null && res.req.method !== "HEAD") {
-    for await (const chunk of response.body) {
-      res.write(chunk);
-    }
-  }
-  res.end();
-}
-
-// src/adapters/node/orpc-handler.ts
-var RPCHandler2 = class {
-  orpcFetchHandler;
+// src/adapters/node/rpc-handler.ts
+import { sendStandardResponse, toStandardRequest } from "@orpc/server-standard-node";
+var RPCHandler = class {
+  standardHandler;
   constructor(router, options) {
-    this.orpcFetchHandler = new RPCHandler(router, options);
+    const codec = options?.codec ?? new RPCCodec();
+    const matcher = options?.matcher ?? new RPCMatcher();
+    this.standardHandler = new StandardHandler(router, matcher, codec, options);
   }
   async handle(req, res, ...rest) {
-    const request = createRequest(req, res);
-    const result = await this.orpcFetchHandler.handle(request, ...rest);
-    if (result.matched === false) {
+    const standardRequest = toStandardRequest(req, res);
+    const result = await this.standardHandler.handle(standardRequest, ...rest);
+    if (!result.matched) {
       return { matched: false };
     }
-    const context = rest[0]?.context ?? {};
-    await rest[0]?.beforeSend?.(result.response, context);
-    await sendResponse(res, result.response);
+    await sendStandardResponse(res, result.response);
     return { matched: true };
   }
 };
 export {
-  RPCHandler2 as RPCHandler,
-  createHeaders,
-  createRequest,
-  sendResponse
+  RPCHandler
 };
 //# sourceMappingURL=node.js.map

package/dist/plugins.js

@@ -0,0 +1,11 @@
+import {
+  CORSPlugin,
+  CompositePlugin,
+  ResponseHeadersPlugin
+} from "./chunk-WQNNSBXW.js";
+export {
+  CORSPlugin,
+  CompositePlugin,
+  ResponseHeadersPlugin
+};
+//# sourceMappingURL=plugins.js.map

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

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

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

@@ -0,0 +1,11 @@
+import type { MaybeOptionalOptions } from '@orpc/shared';
+import type { Context } from '../../context';
+import type { Router } from '../../router';
+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: MaybeOptionalOptions<StandardHandleOptions<T>>): Promise<FetchHandleResult>;
+}
+//# sourceMappingURL=rpc-handler.d.ts.map

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

@@ -1,13 +1,6 @@
-import type { HTTPPath } from '@orpc/contract';
+import type { MaybeOptionalOptions } from '@orpc/shared';
 import type { Context } from '../../context';
-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);
+import type { StandardHandleOptions } from '../standard';
 export type FetchHandleResult = {
     matched: true;
     response: Response;
@@ -16,6 +9,6 @@ export type FetchHandleResult = {
     response: undefined;
 };
 export interface FetchHandler<T extends Context> {
-    handle(request: Request, ...rest: FetchHandleRest<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,12 +1,12 @@
+import type { MaybeOptionalOptions, Value } from '@orpc/shared';
 import type { Context as HonoContext, MiddlewareHandler } from 'hono';
 import type { Context } from '../../context';
-import type { FetchHandleOptions, FetchHandler } from '../fetch';
-import { type Value } from '@orpc/shared';
-export type CreateMiddlewareOptions<T extends Context> = Omit<FetchHandleOptions<T>, 'context'> & (Record<never, never> extends T ? {
+import type { FetchHandler } from '../fetch';
+import type { StandardHandleOptions } from '../standard';
+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,13 +1,13 @@
+import type { MaybeOptionalOptions, Value } from '@orpc/shared';
 import type { NextRequest } from 'next/server';
 import type { Context } from '../../context';
-import type { FetchHandleOptions, FetchHandler } from '../fetch';
-import { type Value } from '@orpc/shared';
-export type ServeOptions<T extends Context> = Omit<FetchHandleOptions<T>, 'context'> & (Record<never, never> extends T ? {
+import type { FetchHandler } from '../fetch';
+import type { StandardHandleOptions } from '../standard';
+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>;
@@ -15,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,5 +1,3 @@
-export * from './orpc-handler';
-export * from './orpc-handler';
-export * from './request-listener';
+export * from './rpc-handler';
 export * from './types';
 //# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1,11 @@
+import type { MaybeOptionalOptions } from '@orpc/shared';
+import type { Context } from '../../context';
+import type { Router } from '../../router';
+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: MaybeOptionalOptions<StandardHandleOptions<T>>): Promise<NodeHttpHandleResult>;
+}
+//# sourceMappingURL=rpc-handler.d.ts.map

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

@@ -1,22 +1,22 @@
-import type { HTTPPath } from '@orpc/contract';
-import type { Promisable } from '@orpc/shared';
+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';
-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 = {
+import type { StandardHandleOptions } 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 = {
     matched: true;
 } | {
     matched: false;
 };
-export interface RequestHandler<T extends Context> {
-    handle(req: IncomingMessage, res: ServerResponse, ...rest: RequestHandleRest<T>): Promise<RequestHandleResult>;
+export interface NodeHttpHandler<T extends Context> {
+    handle(req: NodeHttpRequest, res: NodeHttpResponse, ...rest: MaybeOptionalOptions<StandardHandleOptions<T>>): Promise<NodeHttpHandleResult>;
 }
 //# sourceMappingURL=types.d.ts.map

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

@@ -0,0 +1,53 @@
+import type { ErrorFromErrorMap, HTTPPath, Meta, Schema, SchemaOutput } from '@orpc/contract';
+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 { ProcedureClientInterceptorOptions } from '../../procedure-client';
+import type { Router } from '../../router';
+import type { StandardCodec, StandardMatcher } from './types';
+export type StandardHandleOptions<T extends Context> = {
+    prefix?: HTTPPath;
+} & (Record<never, never> extends T ? {
+    context?: T;
+} : {
+    context: T;
+});
+export type WellStandardHandleOptions<T extends Context> = StandardHandleOptions<T> & {
+    context: T;
+};
+export type StandardHandleResult = {
+    matched: true;
+    response: StandardResponse;
+} | {
+    matched: false;
+    response: undefined;
+};
+export type StandardHandlerInterceptorOptions<TContext extends Context> = WellStandardHandleOptions<TContext> & {
+    request: StandardRequest;
+};
+export interface StandardHandlerOptions<TContext extends Context> {
+    plugins?: Plugin<TContext>[];
+    /**
+     * Interceptors at the request level, helpful when you want catch errors
+     */
+    interceptors?: Interceptor<StandardHandlerInterceptorOptions<TContext>, StandardHandleResult, unknown>[];
+    /**
+     * Interceptors at the root level, helpful when you want override the request/response
+     */
+    rootInterceptors?: Interceptor<StandardHandlerInterceptorOptions<TContext>, StandardHandleResult, unknown>[];
+    /**
+     *
+     * Interceptors for procedure client.
+     */
+    clientInterceptors?: Interceptor<ProcedureClientInterceptorOptions<TContext, Schema, Record<never, never>, Meta>, SchemaOutput<Schema, unknown>, ErrorFromErrorMap<Record<never, never>>>[];
+}
+export declare class StandardHandler<T extends Context> {
+    private readonly matcher;
+    private readonly codec;
+    private readonly options;
+    private readonly plugin;
+    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/index.d.ts

@@ -0,0 +1,6 @@
+export * from './handler';
+export * from './rpc-codec';
+export * from './rpc-handler';
+export * from './rpc-matcher';
+export * from './types';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1,16 @@
+import type { ORPCError } from '@orpc/client';
+import type { StandardRequest, StandardResponse } from '@orpc/server-standard';
+import type { AnyProcedure } from '../../procedure';
+import type { StandardCodec, StandardParams } from './types';
+import { RPCSerializer } from '@orpc/client/rpc';
+export interface StandardCodecOptions {
+    serializer?: RPCSerializer;
+}
+export declare class RPCCodec implements StandardCodec {
+    private readonly serializer;
+    constructor(options?: StandardCodecOptions);
+    decode(request: StandardRequest, _params: StandardParams | undefined, _procedure: AnyProcedure): Promise<unknown>;
+    encode(output: unknown, _procedure: AnyProcedure): StandardResponse;
+    encodeError(error: ORPCError<any, any>): StandardResponse;
+}
+//# sourceMappingURL=rpc-codec.d.ts.map

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

@@ -0,0 +1,8 @@
+import type { Context } from '../../context';
+import type { StandardHandlerOptions } from './handler';
+import type { StandardCodec, StandardMatcher } from './types';
+export interface RPCHandlerOptions<T extends Context> extends StandardHandlerOptions<T> {
+    matcher?: StandardMatcher;
+    codec?: StandardCodec;
+}
+//# sourceMappingURL=rpc-handler.d.ts.map

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

@@ -0,0 +1,10 @@
+import type { HTTPPath } from '@orpc/contract';
+import type { StandardMatcher, StandardMatchResult } from './types';
+import { type AnyRouter } from '../../router';
+export declare class RPCMatcher implements StandardMatcher {
+    private readonly tree;
+    private pendingRouters;
+    init(router: AnyRouter, path?: string[]): void;
+    match(_method: string, pathname: HTTPPath): Promise<StandardMatchResult>;
+}
+//# sourceMappingURL=rpc-matcher.d.ts.map

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

@@ -0,0 +1,21 @@
+import type { ORPCError } from '@orpc/client';
+import type { HTTPPath } from '@orpc/contract';
+import type { StandardRequest, StandardResponse } from '@orpc/server-standard';
+import type { AnyProcedure } from '../../procedure';
+import type { AnyRouter } from '../../router';
+export type StandardParams = Record<string, string>;
+export type StandardMatchResult = {
+    path: string[];
+    procedure: AnyProcedure;
+    params?: StandardParams;
+} | undefined;
+export interface StandardMatcher {
+    init(router: AnyRouter): void;
+    match(method: string, pathname: HTTPPath): Promise<StandardMatchResult>;
+}
+export interface StandardCodec {
+    encode(output: unknown, procedure: AnyProcedure): StandardResponse;
+    encodeError(error: ORPCError<any, any>): StandardResponse;
+    decode(request: StandardRequest, params: StandardParams | undefined, procedure: AnyProcedure): Promise<unknown>;
+}
+//# sourceMappingURL=types.d.ts.map

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

@@ -1,6 +1,7 @@
-import type { ContractRouter, ErrorMap, HTTPPath, MergedErrorMap, Meta, ORPCErrorConstructorMap, Route, Schema, SchemaInput, SchemaOutput } from '@orpc/contract';
+import type { ContractRouter, ErrorMap, HTTPPath, MergedErrorMap, Meta, Route, Schema, SchemaInput, SchemaOutput } from '@orpc/contract';
 import type { BuilderDef } from './builder';
 import type { ConflictContextGuard, Context, MergedContext } from './context';
+import type { ORPCErrorConstructorMap } from './error';
 import type { FlattenLazy } from './lazy-utils';
 import type { MapInputMiddleware, Middleware } from './middleware';
 import type { ProcedureHandler } from './procedure';

package/dist/src/builder.d.ts

@@ -1,6 +1,7 @@
-import type { ContractProcedureDef, ContractRouter, ErrorMap, HTTPPath, MergedErrorMap, Meta, ORPCErrorConstructorMap, Route, Schema, SchemaInput, SchemaOutput } from '@orpc/contract';
+import type { ContractProcedureDef, ContractRouter, ErrorMap, HTTPPath, MergedErrorMap, Meta, Route, Schema, SchemaInput, SchemaOutput } from '@orpc/contract';
 import type { BuilderWithMiddlewares, ProcedureBuilder, ProcedureBuilderWithInput, ProcedureBuilderWithOutput, RouterBuilder } from './builder-variants';
 import type { ConflictContextGuard, Context, MergedContext } from './context';
+import type { ORPCErrorConstructorMap } from './error';
 import type { FlattenLazy } from './lazy-utils';
 import type { AnyMiddleware, MapInputMiddleware, Middleware } from './middleware';
 import type { DecoratedMiddleware } from './middleware-decorated';

package/dist/src/context.d.ts

@@ -1,6 +1,5 @@
 import type { IsNever } from '@orpc/shared';
 export type Context = Record<string, any>;
-export type TypeInitialContext<T extends Context> = (type: T) => unknown;
 export type MergedContext<T extends Context, U extends Context> = T & U;
 export declare function mergeContext<T extends Context, U extends Context>(context: T, other: U): MergedContext<T, U>;
 export type ConflictContextGuard<T extends Context> = true extends IsNever<T> | {

package/dist/src/error.d.ts

@@ -0,0 +1,12 @@
+import type { ORPCErrorCode, ORPCErrorOptions } from '@orpc/client';
+import type { ErrorMap, ErrorMapItem, SchemaInput } from '@orpc/contract';
+import type { MaybeOptionalOptions } from '@orpc/shared';
+import { ORPCError } from '@orpc/client';
+export type ORPCErrorConstructorMapItemOptions<TData> = Omit<ORPCErrorOptions<TData>, 'defined' | 'status'>;
+export type ORPCErrorConstructorMapItem<TCode extends ORPCErrorCode, TInData> = (...rest: MaybeOptionalOptions<ORPCErrorConstructorMapItemOptions<TInData>>) => ORPCError<TCode, TInData>;
+export type ORPCErrorConstructorMap<T extends ErrorMap> = {
+    [K in keyof T]: K extends ORPCErrorCode ? T[K] extends ErrorMapItem<infer UInputSchema> ? ORPCErrorConstructorMapItem<K, SchemaInput<UInputSchema>> : never : never;
+};
+export declare function createORPCErrorConstructorMap<T extends ErrorMap>(errors: T): ORPCErrorConstructorMap<T>;
+export declare function validateORPCError(map: ErrorMap, error: ORPCError<any, any>): Promise<ORPCError<string, unknown>>;
+//# sourceMappingURL=error.d.ts.map

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

@@ -1,9 +1,12 @@
-import type { ClientRest, ErrorMap, Meta, ORPCErrorConstructorMap, Schema, SchemaInput, SchemaOutput } from '@orpc/contract';
+import type { ClientContext, ClientRest } from '@orpc/client';
+import type { ErrorMap, Meta, 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 { ORPCErrorConstructorMap } from './error';
 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 +16,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, TOutputSchema, THandlerOutput, 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, TOutputSchema, THandlerOutput, 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.