@orpc/server 0.0.0-next.68241f5 → 0.0.0-next.683f2ee

package/dist/shared/{server.DY7OKEoj.d.mts → server.BqadksTP.d.mts}

@@ -1,17 +1,17 @@
 import { HTTPPath, ORPCError } from '@orpc/client';
-import { Meta, InferSchemaOutput, AnySchema, ErrorFromErrorMap } from '@orpc/contract';
-import { Interceptor, ThrowableError } from '@orpc/shared';
+import { Meta } from '@orpc/contract';
+import { Interceptor } from '@orpc/shared';
 import { StandardResponse, StandardLazyRequest } from '@orpc/standard-server';
-import { C as Context, f as AnyRouter, h as AnyProcedure, F as ProcedureClientInterceptorOptions, R as Router } from './server.DPWk5pjW.mjs';
+import { C as Context, R as Router, b as AnyRouter, A as AnyProcedure, d as ProcedureClientInterceptorOptions } from './server.qKsRrdxW.mjs';
 
-interface StandardHandlerPlugin<TContext extends Context> {
+interface StandardHandlerPlugin<T extends Context> {
     order?: number;
-    init?(options: StandardHandlerOptions<TContext>): void;
+    init?(options: StandardHandlerOptions<T>, router: Router<any, T>): void;
 }
 declare class CompositeStandardHandlerPlugin<T extends Context, TPlugin extends StandardHandlerPlugin<T>> implements StandardHandlerPlugin<T> {
     protected readonly plugins: TPlugin[];
     constructor(plugins?: readonly TPlugin[]);
-    init(options: StandardHandlerOptions<T>): void;
+    init(options: StandardHandlerOptions<T>, router: Router<any, T>): void;
 }
 
 type StandardParams = Record<string, string>;
@@ -49,16 +49,16 @@ interface StandardHandlerOptions<TContext extends Context> {
     /**
      * Interceptors at the request level, helpful when you want catch errors
      */
-    interceptors?: Interceptor<StandardHandlerInterceptorOptions<TContext>, StandardHandleResult, ThrowableError>[];
+    interceptors?: Interceptor<StandardHandlerInterceptorOptions<TContext>, Promise<StandardHandleResult>>[];
     /**
      * Interceptors at the root level, helpful when you want override the request/response
      */
-    rootInterceptors?: Interceptor<StandardHandlerInterceptorOptions<TContext>, StandardHandleResult, ThrowableError>[];
+    rootInterceptors?: Interceptor<StandardHandlerInterceptorOptions<TContext>, Promise<StandardHandleResult>>[];
     /**
      *
      * Interceptors for procedure client.
      */
-    clientInterceptors?: Interceptor<ProcedureClientInterceptorOptions<TContext, Record<never, never>, Meta>, InferSchemaOutput<AnySchema>, ErrorFromErrorMap<Record<never, never>>>[];
+    clientInterceptors?: Interceptor<ProcedureClientInterceptorOptions<TContext, Record<never, never>, Meta>, Promise<unknown>>[];
 }
 declare class StandardHandler<T extends Context> {
     private readonly matcher;
@@ -70,5 +70,5 @@ declare class StandardHandler<T extends Context> {
     handle(request: StandardLazyRequest, options: StandardHandleOptions<T>): Promise<StandardHandleResult>;
 }
 
-export { CompositeStandardHandlerPlugin as C, StandardHandler as i };
-export type { StandardHandlerInterceptorOptions as S, StandardHandlerPlugin as a, StandardHandlerOptions as b, StandardCodec as c, StandardParams as d, StandardMatcher as e, StandardMatchResult as f, StandardHandleOptions as g, StandardHandleResult as h };
+export { CompositeStandardHandlerPlugin as C, StandardHandler as f };
+export type { StandardCodec as S, StandardParams as a, StandardHandleOptions as b, StandardHandleResult as c, StandardHandlerInterceptorOptions as d, StandardHandlerOptions as e, StandardHandlerPlugin as g, StandardMatchResult as h, StandardMatcher as i };

package/dist/shared/server.C8_sRzQB.d.mts

@@ -0,0 +1,42 @@
+import { ErrorMap, EnhanceRouteOptions, MergedErrorMap, AnyContractRouter, AnyContractProcedure } from '@orpc/contract';
+import { a as AnyMiddleware, L as Lazyable, b as AnyRouter, C as Context, c as Lazy, A as AnyProcedure, P as Procedure, M as MergedInitialContext } from './server.qKsRrdxW.mjs';
+
+declare function getRouter<T extends Lazyable<AnyRouter | undefined>>(router: T, path: readonly string[]): T extends Lazy<any> ? Lazy<AnyRouter | undefined> : Lazyable<AnyRouter | undefined>;
+type AccessibleLazyRouter<T extends Lazyable<AnyRouter | undefined>> = T extends Lazy<infer U extends AnyRouter | undefined | Lazy<AnyRouter | undefined>> ? AccessibleLazyRouter<U> : T extends AnyProcedure | undefined ? Lazy<T> : Lazy<T> & {
+    [K in keyof T]: T[K] extends Lazyable<AnyRouter> ? AccessibleLazyRouter<T[K]> : never;
+};
+declare function createAccessibleLazyRouter<T extends Lazy<AnyRouter | undefined>>(lazied: T): AccessibleLazyRouter<T>;
+type EnhancedRouter<T extends Lazyable<AnyRouter>, TInitialContext extends Context, TCurrentContext extends Context, TErrorMap extends ErrorMap> = T extends Lazy<infer U extends AnyRouter> ? AccessibleLazyRouter<EnhancedRouter<U, TInitialContext, TCurrentContext, TErrorMap>> : T extends Procedure<infer UInitialContext, infer UCurrentContext, infer UInputSchema, infer UOutputSchema, infer UErrorMap, infer UMeta> ? Procedure<MergedInitialContext<TInitialContext, UInitialContext, TCurrentContext>, UCurrentContext, UInputSchema, UOutputSchema, MergedErrorMap<TErrorMap, UErrorMap>, UMeta> : {
+    [K in keyof T]: T[K] extends Lazyable<AnyRouter> ? EnhancedRouter<T[K], TInitialContext, TCurrentContext, TErrorMap> : never;
+};
+interface EnhanceRouterOptions<TErrorMap extends ErrorMap> extends EnhanceRouteOptions {
+    middlewares: readonly AnyMiddleware[];
+    errorMap: TErrorMap;
+    dedupeLeadingMiddlewares: boolean;
+}
+declare function enhanceRouter<T extends Lazyable<AnyRouter>, TInitialContext extends Context, TCurrentContext extends Context, TErrorMap extends ErrorMap>(router: T, options: EnhanceRouterOptions<TErrorMap>): EnhancedRouter<T, TInitialContext, TCurrentContext, TErrorMap>;
+interface TraverseContractProceduresOptions {
+    router: AnyContractRouter | AnyRouter;
+    path: readonly string[];
+}
+interface TraverseContractProcedureCallbackOptions {
+    contract: AnyContractProcedure | AnyProcedure;
+    path: readonly string[];
+}
+/**
+ * @deprecated Use `TraverseContractProcedureCallbackOptions` instead.
+ */
+type ContractProcedureCallbackOptions = TraverseContractProcedureCallbackOptions;
+interface LazyTraverseContractProceduresOptions {
+    router: Lazy<AnyRouter>;
+    path: readonly string[];
+}
+declare function traverseContractProcedures(options: TraverseContractProceduresOptions, callback: (options: TraverseContractProcedureCallbackOptions) => void, lazyOptions?: LazyTraverseContractProceduresOptions[]): LazyTraverseContractProceduresOptions[];
+declare function resolveContractProcedures(options: TraverseContractProceduresOptions, callback: (options: TraverseContractProcedureCallbackOptions) => void): Promise<void>;
+type UnlaziedRouter<T extends AnyRouter> = T extends AnyProcedure ? T : {
+    [K in keyof T]: T[K] extends Lazyable<infer U extends AnyRouter> ? UnlaziedRouter<U> : never;
+};
+declare function unlazyRouter<T extends AnyRouter>(router: T): Promise<UnlaziedRouter<T>>;
+
+export { createAccessibleLazyRouter as c, enhanceRouter as e, getRouter as g, resolveContractProcedures as r, traverseContractProcedures as t, unlazyRouter as u };
+export type { AccessibleLazyRouter as A, ContractProcedureCallbackOptions as C, EnhanceRouterOptions as E, LazyTraverseContractProceduresOptions as L, TraverseContractProcedureCallbackOptions as T, UnlaziedRouter as U, EnhancedRouter as a, TraverseContractProceduresOptions as b };

package/dist/shared/server.ChUyt5-i.d.mts

@@ -0,0 +1,32 @@
+import { StandardRPCJsonSerializerOptions } from '@orpc/client/standard';
+import { b as AnyRouter, C as Context, R as Router } from './server.qKsRrdxW.mjs';
+import { i as StandardMatcher, h as StandardMatchResult, e as StandardHandlerOptions, f as StandardHandler } from './server.BqadksTP.mjs';
+import { HTTPPath } from '@orpc/client';
+import { Value } from '@orpc/shared';
+import { T as TraverseContractProcedureCallbackOptions } from './server.C8_sRzQB.mjs';
+
+interface StandardRPCMatcherOptions {
+    /**
+     * Filter procedures. Return `false` to exclude a procedure from matching.
+     *
+     * @default true
+     */
+    filter?: Value<boolean, [options: TraverseContractProcedureCallbackOptions]>;
+}
+declare class StandardRPCMatcher implements StandardMatcher {
+    private readonly filter;
+    private readonly tree;
+    private pendingRouters;
+    constructor(options?: StandardRPCMatcherOptions);
+    init(router: AnyRouter, path?: readonly string[]): void;
+    match(_method: string, pathname: HTTPPath): Promise<StandardMatchResult>;
+}
+
+interface StandardRPCHandlerOptions<T extends Context> extends StandardHandlerOptions<T>, StandardRPCJsonSerializerOptions, StandardRPCMatcherOptions {
+}
+declare class StandardRPCHandler<T extends Context> extends StandardHandler<T> {
+    constructor(router: Router<any, T>, options?: StandardRPCHandlerOptions<T>);
+}
+
+export { StandardRPCHandler as a, StandardRPCMatcher as c };
+export type { StandardRPCHandlerOptions as S, StandardRPCMatcherOptions as b };

package/dist/shared/server.ChyoA9XY.d.ts

@@ -0,0 +1,42 @@
+import { ErrorMap, EnhanceRouteOptions, MergedErrorMap, AnyContractRouter, AnyContractProcedure } from '@orpc/contract';
+import { a as AnyMiddleware, L as Lazyable, b as AnyRouter, C as Context, c as Lazy, A as AnyProcedure, P as Procedure, M as MergedInitialContext } from './server.qKsRrdxW.js';
+
+declare function getRouter<T extends Lazyable<AnyRouter | undefined>>(router: T, path: readonly string[]): T extends Lazy<any> ? Lazy<AnyRouter | undefined> : Lazyable<AnyRouter | undefined>;
+type AccessibleLazyRouter<T extends Lazyable<AnyRouter | undefined>> = T extends Lazy<infer U extends AnyRouter | undefined | Lazy<AnyRouter | undefined>> ? AccessibleLazyRouter<U> : T extends AnyProcedure | undefined ? Lazy<T> : Lazy<T> & {
+    [K in keyof T]: T[K] extends Lazyable<AnyRouter> ? AccessibleLazyRouter<T[K]> : never;
+};
+declare function createAccessibleLazyRouter<T extends Lazy<AnyRouter | undefined>>(lazied: T): AccessibleLazyRouter<T>;
+type EnhancedRouter<T extends Lazyable<AnyRouter>, TInitialContext extends Context, TCurrentContext extends Context, TErrorMap extends ErrorMap> = T extends Lazy<infer U extends AnyRouter> ? AccessibleLazyRouter<EnhancedRouter<U, TInitialContext, TCurrentContext, TErrorMap>> : T extends Procedure<infer UInitialContext, infer UCurrentContext, infer UInputSchema, infer UOutputSchema, infer UErrorMap, infer UMeta> ? Procedure<MergedInitialContext<TInitialContext, UInitialContext, TCurrentContext>, UCurrentContext, UInputSchema, UOutputSchema, MergedErrorMap<TErrorMap, UErrorMap>, UMeta> : {
+    [K in keyof T]: T[K] extends Lazyable<AnyRouter> ? EnhancedRouter<T[K], TInitialContext, TCurrentContext, TErrorMap> : never;
+};
+interface EnhanceRouterOptions<TErrorMap extends ErrorMap> extends EnhanceRouteOptions {
+    middlewares: readonly AnyMiddleware[];
+    errorMap: TErrorMap;
+    dedupeLeadingMiddlewares: boolean;
+}
+declare function enhanceRouter<T extends Lazyable<AnyRouter>, TInitialContext extends Context, TCurrentContext extends Context, TErrorMap extends ErrorMap>(router: T, options: EnhanceRouterOptions<TErrorMap>): EnhancedRouter<T, TInitialContext, TCurrentContext, TErrorMap>;
+interface TraverseContractProceduresOptions {
+    router: AnyContractRouter | AnyRouter;
+    path: readonly string[];
+}
+interface TraverseContractProcedureCallbackOptions {
+    contract: AnyContractProcedure | AnyProcedure;
+    path: readonly string[];
+}
+/**
+ * @deprecated Use `TraverseContractProcedureCallbackOptions` instead.
+ */
+type ContractProcedureCallbackOptions = TraverseContractProcedureCallbackOptions;
+interface LazyTraverseContractProceduresOptions {
+    router: Lazy<AnyRouter>;
+    path: readonly string[];
+}
+declare function traverseContractProcedures(options: TraverseContractProceduresOptions, callback: (options: TraverseContractProcedureCallbackOptions) => void, lazyOptions?: LazyTraverseContractProceduresOptions[]): LazyTraverseContractProceduresOptions[];
+declare function resolveContractProcedures(options: TraverseContractProceduresOptions, callback: (options: TraverseContractProcedureCallbackOptions) => void): Promise<void>;
+type UnlaziedRouter<T extends AnyRouter> = T extends AnyProcedure ? T : {
+    [K in keyof T]: T[K] extends Lazyable<infer U extends AnyRouter> ? UnlaziedRouter<U> : never;
+};
+declare function unlazyRouter<T extends AnyRouter>(router: T): Promise<UnlaziedRouter<T>>;
+
+export { createAccessibleLazyRouter as c, enhanceRouter as e, getRouter as g, resolveContractProcedures as r, traverseContractProcedures as t, unlazyRouter as u };
+export type { AccessibleLazyRouter as A, ContractProcedureCallbackOptions as C, EnhanceRouterOptions as E, LazyTraverseContractProceduresOptions as L, TraverseContractProcedureCallbackOptions as T, UnlaziedRouter as U, EnhancedRouter as a, TraverseContractProceduresOptions as b };

package/dist/shared/{server.BVwwTHyO.mjs → server.DZ5BIITo.mjs}

@@ -1,7 +1,7 @@
 function resolveFriendlyStandardHandleOptions(options) {
   return {
     ...options,
-    context: options?.context ?? {}
+    context: options.context ?? {}
     // Context only optional if all fields are optional
   };
 }

package/dist/shared/{server.qf03T-Xn.mjs → server.Dz5G6M6M.mjs}

@@ -1,18 +1,17 @@
 import { toHttpPath, StandardRPCJsonSerializer, StandardRPCSerializer } from '@orpc/client/standard';
-import { toArray, intercept, parseEmptyableJSON } from '@orpc/shared';
-import '@orpc/standard-server/batch';
 import { ORPCError, toORPCError } from '@orpc/client';
-import { S as StrictGetMethodPlugin } from './server.BW-nUGgA.mjs';
-import { c as createProcedureClient, t as traverseContractProcedures, i as isProcedure, u as unlazy, g as getRouter, a as createContractedProcedure } from './server.DG7Tamti.mjs';
+import { toArray, intercept, runWithSpan, ORPC_NAME, isAsyncIteratorObject, asyncIteratorWithSpan, setSpanError, parseEmptyableJSON, NullProtoObj, value } from '@orpc/shared';
+import { flattenHeader } from '@orpc/standard-server';
+import { c as createProcedureClient, t as traverseContractProcedures, i as isProcedure, u as unlazy, g as getRouter, a as createContractedProcedure } from './server.BOmqcs4W.mjs';
 
 class CompositeStandardHandlerPlugin {
   plugins;
   constructor(plugins = []) {
     this.plugins = [...plugins].sort((a, b) => (a.order ?? 0) - (b.order ?? 0));
   }
-  init(options) {
+  init(options, router) {
     for (const plugin of this.plugins) {
-      plugin.init?.(options);
+      plugin.init?.(options, router);
     }
   }
 }
@@ -22,7 +21,7 @@ class StandardHandler {
     this.matcher = matcher;
     this.codec = codec;
     const plugins = new CompositeStandardHandlerPlugin(options.plugins);
-    plugins.init(options);
+    plugins.init(options, router);
     this.interceptors = toArray(options.interceptors);
     this.clientInterceptors = toArray(options.clientInterceptors);
     this.rootInterceptors = toArray(options.rootInterceptors);
@@ -40,47 +39,74 @@ class StandardHandler {
       this.rootInterceptors,
       { ...options, request, prefix },
       async (interceptorOptions) => {
-        let isDecoding = false;
-        try {
-          return await intercept(
-            this.interceptors,
-            interceptorOptions,
-            async ({ request: request2, context, prefix: prefix2 }) => {
-              const method = request2.method;
-              const url = request2.url;
-              const pathname = prefix2 ? url.pathname.replace(prefix2, "") : url.pathname;
-              const match = await this.matcher.match(method, `/${pathname.replace(/^\/|\/$/g, "")}`);
-              if (!match) {
-                return { matched: false, response: void 0 };
+        return runWithSpan(
+          { name: `${request.method} ${request.url.pathname}` },
+          async (span) => {
+            let step;
+            try {
+              return await intercept(
+                this.interceptors,
+                interceptorOptions,
+                async ({ request: request2, context, prefix: prefix2 }) => {
+                  const method = request2.method;
+                  const url = request2.url;
+                  const pathname = prefix2 ? url.pathname.replace(prefix2, "") : url.pathname;
+                  const match = await runWithSpan(
+                    { name: "find_procedure" },
+                    () => this.matcher.match(method, `/${pathname.replace(/^\/|\/$/g, "")}`)
+                  );
+                  if (!match) {
+                    return { matched: false, response: void 0 };
+                  }
+                  span?.updateName(`${ORPC_NAME}.${match.path.join("/")}`);
+                  span?.setAttribute("rpc.system", ORPC_NAME);
+                  span?.setAttribute("rpc.method", match.path.join("."));
+                  step = "decode_input";
+                  let input = await runWithSpan(
+                    { name: "decode_input" },
+                    () => this.codec.decode(request2, match.params, match.procedure)
+                  );
+                  step = void 0;
+                  if (isAsyncIteratorObject(input)) {
+                    input = asyncIteratorWithSpan(
+                      { name: "consume_event_iterator_input", signal: request2.signal },
+                      input
+                    );
+                  }
+                  const client = createProcedureClient(match.procedure, {
+                    context,
+                    path: match.path,
+                    interceptors: this.clientInterceptors
+                  });
+                  step = "call_procedure";
+                  const output = await client(input, {
+                    signal: request2.signal,
+                    lastEventId: flattenHeader(request2.headers["last-event-id"])
+                  });
+                  step = void 0;
+                  const response = this.codec.encode(output, match.procedure);
+                  return {
+                    matched: true,
+                    response
+                  };
+                }
+              );
+            } catch (e) {
+              if (step !== "call_procedure") {
+                setSpanError(span, e);
               }
-              const client = createProcedureClient(match.procedure, {
-                context,
-                path: match.path,
-                interceptors: this.clientInterceptors
-              });
-              isDecoding = true;
-              const input = await this.codec.decode(request2, match.params, match.procedure);
-              isDecoding = false;
-              const lastEventId = Array.isArray(request2.headers["last-event-id"]) ? request2.headers["last-event-id"].at(-1) : request2.headers["last-event-id"];
-              const output = await client(input, { signal: request2.signal, lastEventId });
-              const response = this.codec.encode(output, match.procedure);
+              const error = step === "decode_input" && !(e instanceof ORPCError) ? new ORPCError("BAD_REQUEST", {
+                message: `Malformed request. Ensure the request body is properly formatted and the 'Content-Type' header is set correctly.`,
+                cause: e
+              }) : toORPCError(e);
+              const response = this.codec.encodeError(error);
               return {
                 matched: true,
                 response
               };
             }
-          );
-        } catch (e) {
-          const error = isDecoding && !(e instanceof ORPCError) ? new ORPCError("BAD_REQUEST", {
-            message: `Malformed request. Ensure the request body is properly formatted and the 'Content-Type' header is set correctly.`,
-            cause: e
-          }) : toORPCError(e);
-          const response = this.codec.encodeError(error);
-          return {
-            matched: true,
-            response
-          };
-        }
+          }
+        );
       }
     );
   }
@@ -95,6 +121,13 @@ class StandardRPCCodec {
     return this.serializer.deserialize(serialized);
   }
   encode(output, _procedure) {
+    if (output instanceof ReadableStream) {
+      return {
+        status: 200,
+        headers: {},
+        body: output
+      };
+    }
     return {
       status: 200,
       headers: {},
@@ -111,10 +144,18 @@ class StandardRPCCodec {
 }
 
 class StandardRPCMatcher {
-  tree = {};
+  filter;
+  tree = new NullProtoObj();
   pendingRouters = [];
+  constructor(options = {}) {
+    this.filter = options.filter ?? true;
+  }
   init(router, path = []) {
-    const laziedOptions = traverseContractProcedures({ router, path }, ({ path: path2, contract }) => {
+    const laziedOptions = traverseContractProcedures({ router, path }, (traverseOptions) => {
+      if (!value(this.filter, traverseOptions)) {
+        return;
+      }
+      const { path: path2, contract } = traverseOptions;
       const httpPath = toHttpPath(path2);
       if (isProcedure(contract)) {
         this.tree[httpPath] = {
@@ -173,15 +214,10 @@ class StandardRPCMatcher {
 }
 
 class StandardRPCHandler extends StandardHandler {
-  constructor(router, options) {
-    options.plugins ??= [];
-    const strictGetMethodPluginEnabled = options.strictGetMethodPluginEnabled ?? true;
-    if (strictGetMethodPluginEnabled) {
-      options.plugins.push(new StrictGetMethodPlugin());
-    }
+  constructor(router, options = {}) {
     const jsonSerializer = new StandardRPCJsonSerializer(options);
     const serializer = new StandardRPCSerializer(jsonSerializer);
-    const matcher = new StandardRPCMatcher();
+    const matcher = new StandardRPCMatcher(options);
     const codec = new StandardRPCCodec(serializer);
     super(router, matcher, codec, options);
   }

package/dist/shared/server.EfTOZ2Q7.d.ts

@@ -0,0 +1,12 @@
+import { C as Context } from './server.qKsRrdxW.js';
+import { b as StandardHandleOptions } from './server.7cEtMB30.js';
+
+type FriendlyStandardHandleOptions<T extends Context> = Omit<StandardHandleOptions<T>, 'context'> & (Record<never, never> extends T ? {
+    context?: T;
+} : {
+    context: T;
+});
+declare function resolveFriendlyStandardHandleOptions<T extends Context>(options: FriendlyStandardHandleOptions<T>): StandardHandleOptions<T>;
+
+export { resolveFriendlyStandardHandleOptions as r };
+export type { FriendlyStandardHandleOptions as F };

package/dist/shared/{server.BW-nUGgA.mjs → server.TEVCLCFC.mjs}

@@ -3,6 +3,9 @@ import { ORPCError, fallbackContractConfig } from '@orpc/contract';
 const STRICT_GET_METHOD_PLUGIN_IS_GET_METHOD_CONTEXT_SYMBOL = Symbol("STRICT_GET_METHOD_PLUGIN_IS_GET_METHOD_CONTEXT");
 class StrictGetMethodPlugin {
   error;
+  /**
+   * make sure execute before batch plugin to get real method
+   */
   order = 7e6;
   constructor(options = {}) {
     this.error = options.error ?? new ORPCError("METHOD_NOT_SUPPORTED");

package/dist/shared/{server.DPWk5pjW.d.mts → server.qKsRrdxW.d.mts}

@@ -1,6 +1,6 @@
 import { ORPCErrorCode, ORPCErrorOptions, ORPCError, HTTPPath, ClientContext, Client } from '@orpc/client';
 import { ErrorMap, ErrorMapItem, InferSchemaInput, AnySchema, Meta, ContractProcedureDef, InferSchemaOutput, ErrorFromErrorMap, AnyContractRouter, ContractProcedure } from '@orpc/contract';
-import { MaybeOptionalOptions, Promisable, Interceptor, Value } from '@orpc/shared';
+import { MaybeOptionalOptions, Promisable, Interceptor, PromiseWithError, Value } from '@orpc/shared';
 
 type Context = Record<PropertyKey, any>;
 type MergedInitialContext<TInitial extends Context, TAdditional extends Context, TCurrent extends Context> = TInitial & Omit<TAdditional, keyof TCurrent>;
@@ -13,7 +13,6 @@ type ORPCErrorConstructorMap<T extends ErrorMap> = {
     [K in keyof T]: K extends ORPCErrorCode ? T[K] extends ErrorMapItem<infer UInputSchema> ? ORPCErrorConstructorMapItem<K, InferSchemaInput<UInputSchema>> : never : never;
 };
 declare function createORPCErrorConstructorMap<T extends ErrorMap>(errors: T): ORPCErrorConstructorMap<T>;
-declare function validateORPCError(map: ErrorMap, error: ORPCError<any, any>): Promise<ORPCError<string, unknown>>;
 
 declare const LAZY_SYMBOL: unique symbol;
 interface LazyMeta {
@@ -29,7 +28,9 @@ interface Lazy<T> {
 }
 type Lazyable<T> = T | Lazy<T>;
 /**
- * Create a lazy thing.
+ * Creates a lazy-loaded item.
+ *
+ * @warning The `prefix` in `meta` only holds metadata and does not apply the prefix to the lazy router, use `os.prefix(...).lazy(...)` instead.
  */
 declare function lazy<T>(loader: () => Promise<{
     default: T;
@@ -62,7 +63,7 @@ interface ProcedureDef<TInitialContext extends Context, TCurrentContext extends
 /**
  * This class represents a procedure.
  *
- * @see {@link https://orpc.unnoq.com/docs/procedure Procedure Docs}
+ * @see {@link https://orpc.dev/docs/procedure Procedure Docs}
  */
 declare class Procedure<TInitialContext extends Context, TCurrentContext extends Context, TInputSchema extends AnySchema, TOutputSchema extends AnySchema, TErrorMap extends ErrorMap, TMeta extends Meta> {
     /**
@@ -101,7 +102,7 @@ interface MiddlewareOptions<TInContext extends Context, TOutput, TErrorConstruct
 /**
  * A function that represents a middleware.
  *
- * @see {@link https://orpc.unnoq.com/docs/middleware Middleware Docs}
+ * @see {@link https://orpc.dev/docs/middleware Middleware Docs}
  */
 interface Middleware<TInContext extends Context, TOutContext extends Context, TInput, TOutput, TErrorConstructorMap extends ORPCErrorConstructorMap<any>, TMeta extends Meta> {
     (options: MiddlewareOptions<TInContext, TOutput, TErrorConstructorMap, TMeta>, input: TInput, output: MiddlewareOutputFn<TOutput>): Promisable<MiddlewareResult<TOutContext, TOutput>>;
@@ -127,24 +128,24 @@ type CreateProcedureClientOptions<TInitialContext extends Context, TOutputSchema
      * This is helpful for logging and analytics.
      */
     path?: readonly string[];
-    interceptors?: Interceptor<ProcedureClientInterceptorOptions<TInitialContext, TErrorMap, TMeta>, InferSchemaOutput<TOutputSchema>, ErrorFromErrorMap<TErrorMap>>[];
+    interceptors?: Interceptor<ProcedureClientInterceptorOptions<TInitialContext, TErrorMap, TMeta>, PromiseWithError<InferSchemaOutput<TOutputSchema>, ErrorFromErrorMap<TErrorMap>>>[];
 } & (Record<never, never> extends TInitialContext ? {
-    context?: Value<TInitialContext, [clientContext: TClientContext]>;
+    context?: Value<Promisable<TInitialContext>, [clientContext: TClientContext]>;
 } : {
-    context: Value<TInitialContext, [clientContext: TClientContext]>;
+    context: Value<Promisable<TInitialContext>, [clientContext: TClientContext]>;
 });
 /**
  * Create Server-side client from a procedure.
  *
- * @see {@link https://orpc.unnoq.com/docs/client/server-side Server-side Client Docs}
+ * @see {@link https://orpc.dev/docs/client/server-side Server-side Client Docs}
  */
-declare function createProcedureClient<TInitialContext extends Context, TInputSchema extends AnySchema, TOutputSchema extends AnySchema, TErrorMap extends ErrorMap, TMeta extends Meta, TClientContext extends ClientContext>(lazyableProcedure: Lazyable<Procedure<TInitialContext, any, TInputSchema, TOutputSchema, TErrorMap, TMeta>>, ...[options]: MaybeOptionalOptions<CreateProcedureClientOptions<TInitialContext, TOutputSchema, TErrorMap, TMeta, TClientContext>>): ProcedureClient<TClientContext, TInputSchema, TOutputSchema, TErrorMap>;
+declare function createProcedureClient<TInitialContext extends Context, TInputSchema extends AnySchema, TOutputSchema extends AnySchema, TErrorMap extends ErrorMap, TMeta extends Meta, TClientContext extends ClientContext>(lazyableProcedure: Lazyable<Procedure<TInitialContext, any, TInputSchema, TOutputSchema, TErrorMap, TMeta>>, ...rest: MaybeOptionalOptions<CreateProcedureClientOptions<TInitialContext, TOutputSchema, TErrorMap, TMeta, TClientContext>>): ProcedureClient<TClientContext, TInputSchema, TOutputSchema, TErrorMap>;
 
 /**
  * Represents a router, which defines a hierarchical structure of procedures.
  *
  * @info A procedure is a router too.
- * @see {@link https://orpc.unnoq.com/docs/contract-first/define-contract#contract-router Contract Router Docs}
+ * @see {@link https://orpc.dev/docs/contract-first/define-contract#contract-router Contract Router Docs}
  */
 type Router<T extends AnyContractRouter, TInitialContext extends Context> = T extends ContractProcedure<infer UInputSchema, infer UOutputSchema, infer UErrorMap, infer UMeta> ? Procedure<TInitialContext, any, UInputSchema, UOutputSchema, UErrorMap, UMeta> : {
     [K in keyof T]: T[K] extends AnyContractRouter ? Lazyable<Router<T[K], TInitialContext>> : never;
@@ -155,7 +156,7 @@ type InferRouterInitialContext<T extends AnyRouter> = T extends Router<any, infe
  * Infer all initial context of the router.
  *
  * @info A procedure is a router too.
- * @see {@link https://orpc.unnoq.com/docs/router#utilities Router Utilities Docs}
+ * @see {@link https://orpc.dev/docs/router#utilities Router Utilities Docs}
  */
 type InferRouterInitialContexts<T extends AnyRouter> = T extends Procedure<infer UInitialContext, any, any, any, any, any> ? UInitialContext : {
     [K in keyof T]: T[K] extends Lazyable<infer U extends AnyRouter> ? InferRouterInitialContexts<U> : never;
@@ -164,7 +165,7 @@ type InferRouterInitialContexts<T extends AnyRouter> = T extends Procedure<infer
  * Infer all current context of the router.
  *
  * @info A procedure is a router too.
- * @see {@link https://orpc.unnoq.com/docs/router#utilities Router Utilities Docs}
+ * @see {@link https://orpc.dev/docs/router#utilities Router Utilities Docs}
  */
 type InferRouterCurrentContexts<T extends AnyRouter> = T extends Procedure<any, infer UCurrentContext, any, any, any, any> ? UCurrentContext : {
     [K in keyof T]: T[K] extends Lazyable<infer U extends AnyRouter> ? InferRouterCurrentContexts<U> : never;
@@ -173,7 +174,7 @@ type InferRouterCurrentContexts<T extends AnyRouter> = T extends Procedure<any,
  * Infer all router inputs
  *
  * @info A procedure is a router too.
- * @see {@link https://orpc.unnoq.com/docs/router#utilities Router Utilities Docs}
+ * @see {@link https://orpc.dev/docs/router#utilities Router Utilities Docs}
  */
 type InferRouterInputs<T extends AnyRouter> = T extends Procedure<any, any, infer UInputSchema, any, any, any> ? InferSchemaInput<UInputSchema> : {
     [K in keyof T]: T[K] extends Lazyable<infer U extends AnyRouter> ? InferRouterInputs<U> : never;
@@ -182,11 +183,11 @@ type InferRouterInputs<T extends AnyRouter> = T extends Procedure<any, any, infe
  * Infer all router outputs
  *
  * @info A procedure is a router too.
- * @see {@link https://orpc.unnoq.com/docs/router#utilities Router Utilities Docs}
+ * @see {@link https://orpc.dev/docs/router#utilities Router Utilities Docs}
  */
 type InferRouterOutputs<T extends AnyRouter> = T extends Procedure<any, any, any, infer UOutputSchema, any, any> ? InferSchemaOutput<UOutputSchema> : {
     [K in keyof T]: T[K] extends Lazyable<infer U extends AnyRouter> ? InferRouterOutputs<U> : never;
 };
 
-export { isProcedure as E, createProcedureClient as G, Procedure as P, createORPCErrorConstructorMap as l, mergeCurrentContext as m, LAZY_SYMBOL as n, lazy as p, isLazy as q, getLazyMeta as r, unlazy as u, validateORPCError as v, middlewareOutputFn as z };
-export type { AnyMiddleware as A, ProcedureHandlerOptions as B, Context as C, ProcedureDef as D, ProcedureClientInterceptorOptions as F, InferRouterInitialContexts as H, InferRouterInitialContext as I, InferRouterCurrentContexts as J, InferRouterInputs as K, Lazyable as L, Middleware as M, InferRouterOutputs as N, ORPCErrorConstructorMap as O, Router as R, MergedInitialContext as a, MergedCurrentContext as b, MapInputMiddleware as c, CreateProcedureClientOptions as d, ProcedureClient as e, AnyRouter as f, Lazy as g, AnyProcedure as h, ProcedureHandler as i, ORPCErrorConstructorMapItemOptions as j, ORPCErrorConstructorMapItem as k, LazyMeta as o, MiddlewareResult as s, MiddlewareNextFnOptions as t, MiddlewareNextFn as w, MiddlewareOutputFn as x, MiddlewareOptions as y };
+export { isProcedure as E, createProcedureClient as F, Procedure as P, mergeCurrentContext as m, createORPCErrorConstructorMap as n, LAZY_SYMBOL as o, lazy as q, isLazy as r, getLazyMeta as s, unlazy as u, middlewareOutputFn as z };
+export type { AnyProcedure as A, ProcedureHandlerOptions as B, Context as C, ProcedureDef as D, InferRouterInitialContexts as G, InferRouterCurrentContexts as H, InferRouterInitialContext as I, InferRouterInputs as J, InferRouterOutputs as K, Lazyable as L, MergedInitialContext as M, ORPCErrorConstructorMap as O, Router as R, AnyMiddleware as a, AnyRouter as b, Lazy as c, ProcedureClientInterceptorOptions as d, Middleware as e, MergedCurrentContext as f, MapInputMiddleware as g, CreateProcedureClientOptions as h, ProcedureClient as i, ProcedureHandler as j, ORPCErrorConstructorMapItemOptions as k, ORPCErrorConstructorMapItem as l, LazyMeta as p, MiddlewareResult as t, MiddlewareNextFnOptions as v, MiddlewareNextFn as w, MiddlewareOutputFn as x, MiddlewareOptions as y };