@orpc/server 0.0.0-next.ccd4e42 → 0.0.0-next.d0e429d

package/dist/index.js

@@ -21,7 +21,7 @@ import {
   middlewareOutputFn,
   setRouterContract,
   unlazy
-} from "./chunk-NOA3GBJQ.js";
+} from "./chunk-MHVECKBC.js";
 
 // src/builder.ts
 import { mergeErrorMap as mergeErrorMap2, mergeMeta as mergeMeta2, mergePrefix, mergeRoute as mergeRoute2, mergeTags } from "@orpc/contract";
@@ -50,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;
@@ -357,8 +361,10 @@ function createRouterClient(router, ...rest) {
 }
 
 // src/index.ts
-import { isDefinedError, ORPCError, safe, type, ValidationError } from "@orpc/contract";
+import { isDefinedError, ORPCError, safe } from "@orpc/client";
+import { eventIterator, type, ValidationError } from "@orpc/contract";
 import { onError, onFinish, onStart, onSuccess } from "@orpc/shared";
+import { getEventMeta, withEventMeta } from "@orpc/standard-server";
 export {
   Builder,
   DecoratedProcedure,
@@ -378,8 +384,10 @@ export {
   deepSetLazyRouterPrefix,
   eachAllContractProcedure,
   eachContractProcedure,
+  eventIterator,
   fallbackConfig,
   flatLazy,
+  getEventMeta,
   getLazyRouterPrefix,
   getRouterChild,
   getRouterContract,
@@ -399,6 +407,7 @@ export {
   safe,
   setRouterContract,
   type,
-  unlazy
+  unlazy,
+  withEventMeta
 };
 //# sourceMappingURL=index.js.map

package/dist/next.js

@@ -1,12 +1,9 @@
 import {
-  RPCHandler,
-  fetchReToStandardBody,
-  fetchRequestToStandardRequest,
-  standardBodyToFetchBody,
-  standardResponseToFetchResponse
-} from "./chunk-6RSW63UJ.js";
-import "./chunk-JHLUGXCM.js";
-import "./chunk-NOA3GBJQ.js";
+  RPCHandler
+} from "./chunk-AJXRPY6I.js";
+import "./chunk-NTHCS5CK.js";
+import "./chunk-MHVECKBC.js";
+import "./chunk-TXHKQO7N.js";
 
 // src/adapters/next/serve.ts
 import { value } from "@orpc/shared";
@@ -29,10 +26,6 @@ function serve(handler, ...[options]) {
 }
 export {
   RPCHandler,
-  fetchReToStandardBody,
-  fetchRequestToStandardRequest,
-  serve,
-  standardBodyToFetchBody,
-  standardResponseToFetchResponse
+  serve
 };
 //# sourceMappingURL=next.js.map

package/dist/node.js

@@ -2,152 +2,12 @@ import {
   RPCCodec,
   RPCMatcher,
   StandardHandler
-} from "./chunk-JHLUGXCM.js";
-import "./chunk-NOA3GBJQ.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();
-    }
-    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-NTHCS5CK.js";
+import "./chunk-MHVECKBC.js";
+import "./chunk-TXHKQO7N.js";
 
 // src/adapters/node/rpc-handler.ts
+import { sendStandardResponse, toStandardRequest } from "@orpc/standard-server-node";
 var RPCHandler = class {
   standardHandler;
   constructor(router, options) {
@@ -155,19 +15,17 @@ var RPCHandler = class {
     const matcher = options?.matcher ?? new RPCMatcher();
     this.standardHandler = new StandardHandler(router, matcher, codec, options);
   }
-  async handle(req, res, ...rest) {
-    const standardRequest = nodeHttpToStandardRequest(req, res);
-    const result = await this.standardHandler.handle(standardRequest, ...rest);
+  async handle(req, res, ...[options]) {
+    const standardRequest = toStandardRequest(req, res);
+    const result = await this.standardHandler.handle(standardRequest, options);
     if (!result.matched) {
       return { matched: false };
     }
-    await nodeHttpResponseSendStandardResponse(res, result.response);
+    await sendStandardResponse(res, result.response, options);
     return { matched: true };
   }
 };
 export {
-  RPCHandler,
-  nodeHttpResponseSendStandardResponse,
-  nodeHttpToStandardRequest
+  RPCHandler
 };
 //# sourceMappingURL=node.js.map

package/dist/plugins.js

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

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,12 @@
+import type { MaybeOptionalOptions } from '@orpc/shared';
+import type { ToFetchResponseOptions } from '@orpc/standard-server-fetch';
 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, ...[options]: MaybeOptionalOptions<StandardHandleOptions<T> & ToFetchResponseOptions>): Promise<FetchHandleResult>;
 }
 //# sourceMappingURL=rpc-handler.d.ts.map

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

@@ -1,5 +1,7 @@
+import type { MaybeOptionalOptions } from '@orpc/shared';
+import type { ToFetchResponseOptions } from '@orpc/standard-server-fetch';
 import type { Context } from '../../context';
-import type { StandardHandleRest } from '../standard';
+import type { StandardHandleOptions } from '../standard';
 export type FetchHandleResult = {
     matched: true;
     response: Response;
@@ -8,6 +10,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> & ToFetchResponseOptions>): 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,12 @@
+import type { MaybeOptionalOptions } from '@orpc/shared';
+import type { SendStandardResponseOptions } from '@orpc/standard-server-node';
 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, ...[options]: MaybeOptionalOptions<StandardHandleOptions<T> & SendStandardResponseOptions>): Promise<NodeHttpHandleResult>;
 }
 //# sourceMappingURL=rpc-handler.d.ts.map

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

@@ -1,7 +1,9 @@
+import type { MaybeOptionalOptions } from '@orpc/shared';
+import type { SendStandardResponseOptions } from '@orpc/standard-server-node';
 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 +18,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> & SendStandardResponseOptions>): Promise<NodeHttpHandleResult>;
 }
 //# sourceMappingURL=types.d.ts.map

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

@@ -1,8 +1,11 @@
-import type { HTTPPath } from '@orpc/contract';
-import type { Interceptable } from '@orpc/shared';
+import type { ErrorFromErrorMap, HTTPPath, Meta, Schema, SchemaOutput } from '@orpc/contract';
+import type { Interceptor, MaybeOptionalOptions } from '@orpc/shared';
+import type { StandardRequest, StandardResponse } from '@orpc/standard-server';
 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, StandardRequest, StandardResponse } from './types';
+import type { StandardCodec, StandardMatcher } from './types';
 export type StandardHandleOptions<T extends Context> = {
     prefix?: HTTPPath;
 } & (Record<never, never> extends T ? {
@@ -10,7 +13,9 @@ export type StandardHandleOptions<T extends Context> = {
 } : {
     context: T;
 });
-export type StandardHandleRest<T extends Context> = [options: StandardHandleOptions<T>] | (Record<never, never> extends T ? [] : never);
+export type WellStandardHandleOptions<T extends Context> = StandardHandleOptions<T> & {
+    context: T;
+};
 export type StandardHandleResult = {
     matched: true;
     response: StandardResponse;
@@ -18,16 +23,31 @@ export type StandardHandleResult = {
     matched: false;
     response: undefined;
 };
-export interface StandardHandlerOptions<TContext extends Context> extends Interceptable<{
-    context: TContext;
+export type StandardHandlerInterceptorOptions<TContext extends Context> = WellStandardHandleOptions<TContext> & {
     request: StandardRequest;
-}, StandardHandleResult, unknown> {
+};
+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<TContext extends Context> {
+export declare class StandardHandler<T extends Context> {
     private readonly matcher;
     private readonly codec;
     private readonly options;
-    constructor(router: Router<TContext, any>, matcher: StandardMatcher, codec: StandardCodec, options?: NoInfer<StandardHandlerOptions<TContext>>);
-    handle(request: StandardRequest, ...[options]: StandardHandleRest<TContext>): Promise<StandardHandleResult>;
+    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

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

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

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

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

@@ -1,31 +1,8 @@
-import type { AbortSignal, HTTPPath, ORPCError } from '@orpc/contract';
-import type { JsonValue } from '@orpc/shared';
+import type { ORPCError } from '@orpc/client';
+import type { HTTPPath } from '@orpc/contract';
+import type { StandardRequest, StandardResponse } from '@orpc/standard-server';
 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/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.

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

@@ -1,5 +1,6 @@
-import type { AnyContractRouter, ContractProcedure, ContractRouterToErrorMap, ContractRouterToMeta, ORPCErrorConstructorMap } from '@orpc/contract';
+import type { AnyContractRouter, ContractProcedure, ContractRouterToErrorMap, ContractRouterToMeta } from '@orpc/contract';
 import type { ConflictContextGuard, Context, MergedContext } from './context';
+import type { ORPCErrorConstructorMap } from './error';
 import type { ProcedureImplementer } from './implementer-procedure';
 import type { FlattenLazy } from './lazy-utils';
 import type { Middleware } from './middleware';

package/dist/src/implementer.d.ts

@@ -1,5 +1,6 @@
-import type { AnyContractRouter, ContractProcedure, ContractRouterToErrorMap, ContractRouterToMeta, ORPCErrorConstructorMap } from '@orpc/contract';
+import type { AnyContractRouter, ContractProcedure, ContractRouterToErrorMap, ContractRouterToMeta } from '@orpc/contract';
 import type { ConflictContextGuard, Context, MergedContext } from './context';
+import type { ORPCErrorConstructorMap } from './error';
 import type { ProcedureImplementer } from './implementer-procedure';
 import type { ImplementerInternalWithMiddlewares } from './implementer-variants';
 import type { AnyMiddleware, Middleware } from './middleware';

package/dist/src/index.d.ts

@@ -18,6 +18,8 @@ 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 { isDefinedError, ORPCError, safe } from '@orpc/client';
+export { eventIterator, type, ValidationError } from '@orpc/contract';
 export { onError, onFinish, onStart, onSuccess } from '@orpc/shared';
+export { getEventMeta, withEventMeta } from '@orpc/standard-server';
 //# sourceMappingURL=index.d.ts.map

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

@@ -1,5 +1,6 @@
-import type { Meta, ORPCErrorConstructorMap } from '@orpc/contract';
+import type { Meta } from '@orpc/contract';
 import type { Context, MergedContext } from './context';
+import type { ORPCErrorConstructorMap } from './error';
 import type { MapInputMiddleware, Middleware } from './middleware';
 export interface DecoratedMiddleware<TInContext extends Context, TOutContext extends Context, TInput, TOutput, TErrorConstructorMap extends ORPCErrorConstructorMap<any>, TMeta extends Meta> extends Middleware<TInContext, TOutContext, TInput, TOutput, TErrorConstructorMap, TMeta> {
     concat<UOutContext extends Context, UInput>(middleware: Middleware<TInContext & TOutContext, UOutContext, UInput & TInput, TOutput, TErrorConstructorMap, TMeta>): DecoratedMiddleware<TInContext, MergedContext<TOutContext, UOutContext>, UInput & TInput, TOutput, TErrorConstructorMap, TMeta>;