@orpc/server 2.0.0-beta.46 → 2.0.0-beta.48

package/dist/shared/server.Chq5FpXf.mjs

@@ -1,353 +0,0 @@
-import { ORPCError, toORPCError, RPCSerializer, COMMON_ERROR_STATUS_MAP } from '@orpc/client';
-import { sortPlugins, toArray, matchesHttpPathPrefix, value, intercept, getTracer, runWithSpan, ORPC_NAME, isAsyncIteratorObject, override, traceAsyncIterator, traceReadableStream, recordSpanError, wrapAsyncIterator, toTracingException, wrapReadableStream, pathToHttpPath, normalizeHttpPath, parseEmptyableJSON, getOwn } from '@orpc/shared';
-import { flattenStandardHeader, parseStandardUrl, ErrorEvent } from '@standard-server/core';
-import { c as createProcedureClient, u as unlazy, P as Procedure } from './server.BB464y-6.mjs';
-import { w as walkProcedureContractsSync, r as resolveContractProcedure, D as DEFAULT_SUCCESS_STATUS, a as DEFAULT_ERROR_STATUS } from './server.CYbIpHbH.mjs';
-
-class CompositeStandardHandlerPlugin {
-  name = "~composite";
-  plugins;
-  constructor(plugins = []) {
-    this.plugins = sortPlugins(plugins);
-  }
-  init(options) {
-    for (const plugin of this.plugins) {
-      if (plugin.init) {
-        options = plugin.init(options);
-      }
-    }
-    return options;
-  }
-}
-
-class StandardHandler {
-  constructor(codec, options) {
-    this.codec = codec;
-    options = new CompositeStandardHandlerPlugin([
-      ...toArray(options.plugins),
-      new TracingHandlerPlugin()
-    ]).init(options);
-    this.routingInterceptors = options.routingInterceptors;
-    this.interceptors = options.interceptors;
-    this.clientInterceptors = options.clientInterceptors;
-  }
-  routingInterceptors;
-  interceptors;
-  clientInterceptors;
-  async handle(request, options) {
-    const { prefix } = options;
-    if (prefix && !matchesHttpPathPrefix(request.url, prefix)) {
-      return { matched: false, response: void 0 };
-    }
-    const context = await value(options.context, request);
-    return intercept(
-      this.routingInterceptors,
-      { context, prefix, request },
-      async ({ context: context2, prefix: prefix2, request: request2 }) => {
-        const span = getTracer()?.getActiveSpan();
-        let step;
-        const matchedOrNot = await runWithSpan("find_procedure", () => this.codec.resolveProcedure(request2, { context: context2, prefix: prefix2 }));
-        if (!matchedOrNot) {
-          span?.updateName(`${ORPC_NAME}_no_match`);
-          span?.setAttribute("http.request.method", request2.method);
-          span?.setAttribute("url.path", request2.url);
-          return { matched: false };
-        }
-        const { path, procedure, decodeInput } = matchedOrNot;
-        span?.updateName(`${ORPC_NAME}.${path.join("/")}`);
-        span?.setAttribute("rpc.system", ORPC_NAME);
-        span?.setAttribute("rpc.method", path.join("."));
-        try {
-          const response = await intercept(
-            this.interceptors,
-            { context: context2, prefix: prefix2, request: request2, path, procedure, decodeInput },
-            async ({ context: context3, prefix: prefix3, request: request3, path: path2, procedure: procedure2, decodeInput: decodeInput2 }) => {
-              step = "decode_input";
-              let input = await runWithSpan("decode_input", decodeInput2);
-              step = void 0;
-              if (getTracer() && isAsyncIteratorObject(input)) {
-                input = override(input, traceAsyncIterator("consume_async_iterator_object_input", input));
-              } else if (getTracer() && input instanceof ReadableStream) {
-                input = override(input, traceReadableStream("consume_octet_stream_input", input));
-              }
-              const client = createProcedureClient(procedure2, {
-                context: context3,
-                path: path2,
-                interceptors: this.clientInterceptors
-              });
-              step = "call_procedure";
-              const output = await client(input, {
-                signal: request3.signal,
-                lastEventId: flattenStandardHeader(request3.headers["last-event-id"])
-              });
-              step = void 0;
-              const response2 = await this.codec.encodeOutput(output, procedure2, path2, { context: context3, prefix: prefix3 });
-              return response2;
-            }
-          );
-          return { matched: true, response };
-        } catch (e) {
-          if (step !== "call_procedure") {
-            recordSpanError(span, e);
-          }
-          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 = await this.codec.encodeError(error, procedure, path, { context: context2, prefix: prefix2 });
-          return { matched: true, response };
-        }
-      }
-    );
-  }
-}
-class TracingHandlerPlugin {
-  name = "~tracing";
-  init(options) {
-    return {
-      ...options,
-      routingInterceptors: [
-        // Should be placed before user-provided interceptors to help them access the current active span.
-        async ({ next, request }) => {
-          const tracer = getTracer();
-          if (!tracer) {
-            return next();
-          }
-          const parent = tracer.extract?.(request.headers);
-          const [pathname] = parseStandardUrl(request.url);
-          return tracer.startActiveSpan(`${request.method} ${pathname}`, parent, async (span) => {
-            try {
-              const result = await next();
-              if (!result.matched) {
-                span.end();
-                return result;
-              }
-              const body = result.response.body;
-              if (isAsyncIteratorObject(body)) {
-                return {
-                  ...result,
-                  response: {
-                    ...result.response,
-                    /**
-                     * @remarks
-                     * **Warning**: Remember use `override` for remaining special properties
-                     */
-                    body: override(body, wrapAsyncIterator(body, {
-                      runWith: (fn) => tracer.withActiveSpan(span, fn),
-                      onError(error) {
-                        if (!(error instanceof ErrorEvent)) {
-                          span.recordException("error", toTracingException(error));
-                        }
-                      },
-                      onFinish() {
-                        span.end();
-                      }
-                    }))
-                  }
-                };
-              }
-              if (body instanceof ReadableStream) {
-                return {
-                  ...result,
-                  response: {
-                    ...result.response,
-                    /**
-                     * @remarks
-                     * **Warning**: Remember use `override` for remaining special properties
-                     */
-                    body: override(body, wrapReadableStream(body, {
-                      runWith: (fn) => tracer.withActiveSpan(span, fn),
-                      onError(error) {
-                        span.recordException("error", toTracingException(error));
-                      },
-                      onFinish() {
-                        span.end();
-                      }
-                    }))
-                  }
-                };
-              }
-              span.end();
-              return result;
-            } catch (e) {
-              span.recordException("error", toTracingException(e));
-              span.end();
-              throw e;
-            }
-          });
-        },
-        ...toArray(options.routingInterceptors)
-      ]
-    };
-  }
-}
-
-const RPC_DEFAULT_ALLOW_METHODS = ["POST", "PUT", "PATCH", "DELETE"];
-const NORMALIZABLE_PATHNAME_REGEX = /[^\w\-.!~*'()/]/;
-class RPCMatcher {
-  filter;
-  allowMethodsSet;
-  allowMethodsFn;
-  rootRouter;
-  tree = /* @__PURE__ */ new Map();
-  pendingLazyRouters = /* @__PURE__ */ new Map();
-  /** segment count of the deepest pending key, never lowered so it stays an upper bound */
-  maxPendingLazyRouterDepth = 0;
-  constructor(router, options = {}) {
-    this.filter = options.filter ?? true;
-    const allowMethods = options.allowMethods ?? RPC_DEFAULT_ALLOW_METHODS;
-    if (typeof allowMethods !== "function") {
-      this.allowMethodsSet = new Set(allowMethods);
-    } else {
-      this.allowMethodsFn = allowMethods;
-    }
-    this.rootRouter = router;
-    this.index(router);
-  }
-  index(router, path = []) {
-    const lazyResults = walkProcedureContractsSync(router, (procedure, procedurePath) => {
-      if (!value(this.filter, procedure, procedurePath)) {
-        return;
-      }
-      this.tree.set(pathToHttpPath(procedurePath), {
-        path: procedurePath,
-        contract: procedure,
-        // contract-first entries have no implementation yet, resolveProcedure fills it in on demand
-        procedure: procedure instanceof Procedure ? procedure : void 0
-      });
-    }, path);
-    for (const result of lazyResults) {
-      this.pendingLazyRouters.set(pathToHttpPath(result.path), result);
-      this.maxPendingLazyRouterDepth = Math.max(this.maxPendingLazyRouterDepth, result.path.length);
-    }
-  }
-  async match(method, pathname, prefix) {
-    if (this.allowMethodsSet && !this.allowMethodsSet.has(method)) {
-      return void 0;
-    }
-    if (prefix) {
-      if (!pathname.startsWith(prefix)) {
-        return void 0;
-      }
-      const charAfterPrefix = pathname[prefix.length];
-      if (charAfterPrefix === "/") {
-        pathname = pathname.slice(prefix.length);
-      } else if (charAfterPrefix === void 0) {
-        pathname = "/";
-      } else if (prefix[prefix.length - 1] === "/") {
-        pathname = pathname.slice(prefix.length - 1);
-      } else {
-        return void 0;
-      }
-    }
-    if (pathname.length > 1 && pathname.endsWith("/")) {
-      pathname = pathname.slice(0, -1);
-    }
-    const loading = this.resolvePendingLazyRouters(pathname);
-    if (loading !== void 0) {
-      await loading;
-    }
-    let entry = this.tree.get(pathname);
-    if (entry === void 0 && NORMALIZABLE_PATHNAME_REGEX.test(pathname)) {
-      const normalizedPathname = normalizeHttpPath(pathname);
-      const normalizedLoading = this.resolvePendingLazyRouters(normalizedPathname);
-      if (normalizedLoading !== void 0) {
-        await normalizedLoading;
-      }
-      entry = this.tree.get(normalizedPathname);
-    }
-    if (entry === void 0) {
-      return void 0;
-    }
-    const procedure = entry.procedure ?? await this.resolveProcedure(entry);
-    if (this.allowMethodsFn && !this.allowMethodsFn(method, procedure, entry.path)) {
-      return void 0;
-    }
-    return {
-      path: entry.path,
-      procedure
-    };
-  }
-  resolvePendingLazyRouters(pathname) {
-    if (this.pendingLazyRouters.size === 0) {
-      return;
-    }
-    let slashIndex = 0;
-    for (let depth = 1; slashIndex !== -1 && depth <= this.maxPendingLazyRouterDepth; depth++) {
-      const nextSlashIndex = pathname.indexOf("/", slashIndex + 1);
-      const httpPathPrefix = nextSlashIndex === -1 ? pathname : pathname.slice(0, nextSlashIndex);
-      const pending = this.pendingLazyRouters.get(httpPathPrefix);
-      if (pending !== void 0) {
-        return this.loadPendingLazyRouter(httpPathPrefix, pending).then(() => this.resolvePendingLazyRouters(pathname));
-      }
-      slashIndex = nextSlashIndex;
-    }
-  }
-  loadPendingLazyRouter(httpPathPrefix, pending) {
-    if (pending.loading === void 0) {
-      pending.loading = this.indexPendingLazyRouter(httpPathPrefix, pending).catch((error) => {
-        pending.loading = void 0;
-        throw error;
-      });
-    }
-    return pending.loading;
-  }
-  async indexPendingLazyRouter(httpPathPrefix, pending) {
-    const { default: router } = await unlazy(pending.router);
-    this.index(router, pending.path);
-    this.pendingLazyRouters.delete(httpPathPrefix);
-  }
-  async resolveProcedure(entry) {
-    entry.procedure = await resolveContractProcedure(this.rootRouter, entry.contract, entry.path);
-    return entry.procedure;
-  }
-}
-
-class RPCHandlerCodec {
-  matcher;
-  serializer;
-  errorStatusMap;
-  outputStatus;
-  constructor(router, options = {}) {
-    this.matcher = new RPCMatcher(router, options);
-    this.serializer = options.serializer ?? new RPCSerializer();
-    this.errorStatusMap = options.errorStatusMap ?? COMMON_ERROR_STATUS_MAP;
-    this.outputStatus = options.outputStatus;
-  }
-  async resolveProcedure(request, options) {
-    const [pathname, query] = parseStandardUrl(request.url);
-    const matched = await this.matcher.match(request.method, pathname, options.prefix);
-    if (!matched) {
-      return void 0;
-    }
-    return {
-      procedure: matched.procedure,
-      path: matched.path,
-      decodeInput: async () => {
-        if (request.method === "GET") {
-          const dataString = new URLSearchParams(query).getAll("data").at(-1);
-          return this.serializer.deserialize(parseEmptyableJSON(dataString));
-        }
-        const body = await request.resolveBody();
-        return this.serializer.deserialize(body);
-      }
-    };
-  }
-  encodeOutput(output, procedure, path, options) {
-    return {
-      headers: {},
-      status: value(this.outputStatus, output, procedure, path, options) ?? DEFAULT_SUCCESS_STATUS,
-      body: this.serializer.serialize(output)
-    };
-  }
-  encodeError(error, _procedure, _path, _options) {
-    const status = getOwn(this.errorStatusMap, error.code) ?? DEFAULT_ERROR_STATUS;
-    return {
-      headers: {},
-      status,
-      body: this.serializer.serialize(error.toJSON())
-    };
-  }
-}
-
-export { RPCHandlerCodec as R, StandardHandler as S, RPCMatcher as a, RPC_DEFAULT_ALLOW_METHODS as b };

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

@@ -1,166 +0,0 @@
-import { ClientContext, Client } from '@orpc/client';
-import { ErrorMap, AnyMetaPlugin, ORPCErrorConstructorMap, AnySchema, ProcedureContractDefinition, Meta, InferSchemaOutput, ORPCErrorFromErrorMap, InferSchemaInput } from '@orpc/contract';
-import { DistributiveOmit, MaybeOptionalOptions, Promisable, Interceptor, PromiseWithError, ThrowableError, Value } from '@orpc/shared';
-
-interface Context {
-    [key: PropertyKey]: any;
-}
-type MergedInitialContext<TInitial extends Context, TOutContext extends Context, TInContext extends Context> = TInContext extends any ? Exclude<keyof TInContext, keyof TInitial | keyof TOutContext> extends never ? TInitial : TInitial & DistributiveOmit<TInContext, keyof TInitial | keyof TOutContext> : never;
-type MergedContext<TCurrent extends Context, TOutContext extends Context> = keyof TOutContext extends never ? TCurrent : DistributiveOmit<TCurrent, keyof TOutContext> & TOutContext;
-
-type MiddlewareResult<TOutContext extends Context, TOutput> = Promisable<{
-    output: TOutput;
-    context: TOutContext;
-}>;
-type MiddlewareNextOptions<TOutContext extends Context> = (object extends TOutContext ? {
-    context?: TOutContext | undefined;
-} : {
-    context: TOutContext;
-}) & {
-    /** Overrides the signal for the rest of the chain. */
-    signal?: AbortSignal | undefined;
-};
-interface MiddlewareNext<TOutput> {
-    <T extends Context = object>(...rest: MaybeOptionalOptions<MiddlewareNextOptions<T>>): MiddlewareResult<T, TOutput>;
-}
-type MiddlewareDoneOptions<TOutContext, TOutput> = (object extends TOutContext ? {
-    context?: TOutContext | undefined;
-} : {
-    context: TOutContext;
-}) & {
-    output: TOutput;
-};
-interface MiddlewareDone<TOutput> {
-    /**
-     * Create a successful result and terminate the middleware chain early.
-     */
-    <TOutContext extends Context = object>(...rest: MaybeOptionalOptions<MiddlewareDoneOptions<TOutContext, TOutput>>): MiddlewareResult<TOutContext, TOutput>;
-}
-interface MiddlewareOptions<TInContext extends Context, TOutput, TErrorConstructorMap extends ORPCErrorConstructorMap<any>> {
-    context: TInContext;
-    path: string[];
-    procedure: AnyProcedure;
-    signal?: AbortSignal | undefined;
-    lastEventId: string | undefined;
-    /**
-     * Invoke to continue the middleware chain.
-     */
-    next: MiddlewareNext<TOutput>;
-    errors: TErrorConstructorMap;
-}
-interface MiddlewareDefinition<TErrorMap extends ErrorMap> {
-    errorMap?: TErrorMap | undefined;
-    metaPlugins?: AnyMetaPlugin[] | undefined;
-}
-interface Middleware<TInContext extends Context, TOutContext extends Context, TInput, TOutput, TErrorMap extends ErrorMap> {
-    /** this property should be optional to support inline middleware */
-    '~orpc'?: MiddlewareDefinition<TErrorMap> | undefined;
-    (opts: MiddlewareOptions<TInContext, TOutput, ORPCErrorConstructorMap<TErrorMap>>, input: TInput, done: MiddlewareDone<TOutput>): Promisable<MiddlewareResult<TOutContext, TOutput>>;
-}
-type AnyMiddleware = Middleware<any, any, any, any, any>;
-
-interface ProcedureHandlerOptions<TCurrentContext extends Context, TInput, TErrorConstructorMap extends ORPCErrorConstructorMap<any>> {
-    context: TCurrentContext;
-    input: TInput;
-    path: string[];
-    procedure: Procedure<Context, Context, AnySchema, AnySchema, ErrorMap>;
-    signal?: AbortSignal | undefined;
-    lastEventId?: string | undefined;
-    errors: TErrorConstructorMap;
-}
-interface ProcedureHandler<TCurrentContext extends Context, TInput, THandlerOutput, TErrorConstructorMap extends ORPCErrorConstructorMap<any>> {
-    (opts: ProcedureHandlerOptions<TCurrentContext, TInput, TErrorConstructorMap>, input: TInput): Promisable<THandlerOutput>;
-}
-interface OrderedMiddleware {
-    /**
-     * Snapshot of `inputSchemas.length`
-     * at the time this middleware was used.
-     *
-     * @default 0
-     */
-    inputSchemasLengthAtUse?: number | undefined;
-    /**
-     * Snapshot of `outputSchemas.length`
-     * at the time this middleware was used.
-     *
-     * @default 0
-     */
-    outputSchemasLengthAtUse?: number | undefined;
-    middleware: AnyMiddleware;
-}
-interface ProcedureConfig {
-    /**
-     * When enabled, input schemas are not validated at runtime.
-     * Schemas are still used for type inference and OpenAPI generation.
-     *
-     * @remarks
-     * **Warning**: Do not disable validation for schemas that transform values.
-     *
-     * @default false
-     */
-    disableInputValidation?: boolean | undefined;
-    /**
-     * When enabled, output schemas are not validated at runtime.
-     * Schemas are still used for type inference and OpenAPI generation.
-     *
-     * Useful when output schemas exist only for specification generation.
-     *
-     * @remarks
-     * **Warning**: Do not disable validation for schemas that transform values.
-     *
-     * @default false
-     */
-    disableOutputValidation?: boolean | undefined;
-}
-interface ProcedureDefinition<TInitialContext extends Context, TInjectedContext extends Context, TInputSchema extends AnySchema, TOutputSchema extends AnySchema, TErrorMap extends ErrorMap> extends ProcedureContractDefinition<TInputSchema, TOutputSchema, TErrorMap>, ProcedureConfig {
-    __TInitialContext?: (type: TInitialContext) => unknown;
-    __TInjectedContext?: (type: TInjectedContext) => unknown;
-    orderedMiddlewares: OrderedMiddleware[];
-    handler: ProcedureHandler<any, any, any, any>;
-}
-declare class Procedure<TInitialContext extends Context, TInjectedContext extends Context, TInputSchema extends AnySchema, TOutputSchema extends AnySchema, TErrorMap extends ErrorMap> {
-    '~orpc': ProcedureDefinition<TInitialContext, TInjectedContext, TInputSchema, TOutputSchema, TErrorMap>;
-    constructor(def: ProcedureDefinition<TInitialContext, TInjectedContext, TInputSchema, TOutputSchema, TErrorMap>);
-    /**
-     * Checks if the given instance satisfies the {@link Procedure} class/interface.
-     */
-    static [Symbol.hasInstance](instance: unknown): boolean;
-}
-type AnyProcedure = Procedure<any, any, any, any, any>;
-
-interface LazyDefinition<T> {
-    meta: Meta;
-    metaPlugins?: AnyMetaPlugin[] | undefined;
-    loader: () => Promise<{
-        default: T;
-    }>;
-}
-declare class Lazy<T> {
-    '~orpc': LazyDefinition<T>;
-    constructor(def: LazyDefinition<T>);
-    /**
-     * Checks if the given instance satisfies the {@link Lazy} class/interface.
-     */
-    static [Symbol.hasInstance](instance: unknown): boolean;
-}
-type Lazyable<T> = T | Lazy<T>;
-declare function unlazy<T extends Lazyable<any>>(maybeLazy: T): Promise<{
-    default: T extends Lazy<infer U> ? U : T;
-}>;
-
-type ProcedureClient<TClientContext extends ClientContext, TInputSchema extends AnySchema, TOutputSchema extends AnySchema, TErrorMap extends ErrorMap> = Client<TClientContext, InferSchemaInput<TInputSchema>, InferSchemaOutput<TOutputSchema>, ORPCErrorFromErrorMap<TErrorMap> | ThrowableError>;
-interface ProcedureClientInterceptorOptions<TInitialContext extends Context, TErrorMap extends ErrorMap> extends ProcedureHandlerOptions<TInitialContext, unknown, ORPCErrorConstructorMap<TErrorMap>> {
-}
-type ProcedureClientInterceptor<TInitialContext extends Context, TOutputSchema extends AnySchema, TErrorMap extends ErrorMap> = Interceptor<ProcedureClientInterceptorOptions<TInitialContext, TErrorMap>, PromiseWithError<InferSchemaOutput<TOutputSchema>, ORPCErrorFromErrorMap<TErrorMap> | ThrowableError>>;
-type ProcedureClientOptions<TInitialContext extends Context, TOutputSchema extends AnySchema, TErrorMap extends ErrorMap, TClientContext extends ClientContext> = {
-    path?: string[] | undefined;
-    interceptors?: ProcedureClientInterceptor<TInitialContext, TOutputSchema, TErrorMap>[] | undefined;
-} & (object extends TInitialContext ? {
-    context?: Value<Promisable<TInitialContext>, [clientContext: TClientContext]> | undefined;
-} : {
-    context: Value<Promisable<TInitialContext>, [clientContext: TClientContext]>;
-});
-declare function createProcedureClient<TInitialContext extends Context, TInputSchema extends AnySchema, TOutputSchema extends AnySchema, TErrorMap extends ErrorMap, TClientContext extends ClientContext = object>(lazyableProcedure: Lazyable<Procedure<TInitialContext, any, TInputSchema, TOutputSchema, TErrorMap>>, ...rest: MaybeOptionalOptions<ProcedureClientOptions<TInitialContext, TOutputSchema, TErrorMap, TClientContext>>): ProcedureClient<TClientContext, TInputSchema, TOutputSchema, TErrorMap>;
-
-export { Procedure as a, Lazy as f, createProcedureClient as u, unlazy as v };
-export type { AnyProcedure as A, Context as C, Lazyable as L, MergedContext as M, OrderedMiddleware as O, ProcedureClientOptions as P, ProcedureClient as b, ProcedureClientInterceptor as c, Middleware as d, MergedInitialContext as e, ProcedureHandler as g, ProcedureConfig as h, AnyMiddleware as i, LazyDefinition as j, MiddlewareDefinition as k, MiddlewareDone as l, MiddlewareDoneOptions as m, MiddlewareNext as n, MiddlewareNextOptions as o, MiddlewareOptions as p, MiddlewareResult as q, ProcedureClientInterceptorOptions as r, ProcedureDefinition as s, ProcedureHandlerOptions as t };

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

@@ -1,166 +0,0 @@
-import { ClientContext, Client } from '@orpc/client';
-import { ErrorMap, AnyMetaPlugin, ORPCErrorConstructorMap, AnySchema, ProcedureContractDefinition, Meta, InferSchemaOutput, ORPCErrorFromErrorMap, InferSchemaInput } from '@orpc/contract';
-import { DistributiveOmit, MaybeOptionalOptions, Promisable, Interceptor, PromiseWithError, ThrowableError, Value } from '@orpc/shared';
-
-interface Context {
-    [key: PropertyKey]: any;
-}
-type MergedInitialContext<TInitial extends Context, TOutContext extends Context, TInContext extends Context> = TInContext extends any ? Exclude<keyof TInContext, keyof TInitial | keyof TOutContext> extends never ? TInitial : TInitial & DistributiveOmit<TInContext, keyof TInitial | keyof TOutContext> : never;
-type MergedContext<TCurrent extends Context, TOutContext extends Context> = keyof TOutContext extends never ? TCurrent : DistributiveOmit<TCurrent, keyof TOutContext> & TOutContext;
-
-type MiddlewareResult<TOutContext extends Context, TOutput> = Promisable<{
-    output: TOutput;
-    context: TOutContext;
-}>;
-type MiddlewareNextOptions<TOutContext extends Context> = (object extends TOutContext ? {
-    context?: TOutContext | undefined;
-} : {
-    context: TOutContext;
-}) & {
-    /** Overrides the signal for the rest of the chain. */
-    signal?: AbortSignal | undefined;
-};
-interface MiddlewareNext<TOutput> {
-    <T extends Context = object>(...rest: MaybeOptionalOptions<MiddlewareNextOptions<T>>): MiddlewareResult<T, TOutput>;
-}
-type MiddlewareDoneOptions<TOutContext, TOutput> = (object extends TOutContext ? {
-    context?: TOutContext | undefined;
-} : {
-    context: TOutContext;
-}) & {
-    output: TOutput;
-};
-interface MiddlewareDone<TOutput> {
-    /**
-     * Create a successful result and terminate the middleware chain early.
-     */
-    <TOutContext extends Context = object>(...rest: MaybeOptionalOptions<MiddlewareDoneOptions<TOutContext, TOutput>>): MiddlewareResult<TOutContext, TOutput>;
-}
-interface MiddlewareOptions<TInContext extends Context, TOutput, TErrorConstructorMap extends ORPCErrorConstructorMap<any>> {
-    context: TInContext;
-    path: string[];
-    procedure: AnyProcedure;
-    signal?: AbortSignal | undefined;
-    lastEventId: string | undefined;
-    /**
-     * Invoke to continue the middleware chain.
-     */
-    next: MiddlewareNext<TOutput>;
-    errors: TErrorConstructorMap;
-}
-interface MiddlewareDefinition<TErrorMap extends ErrorMap> {
-    errorMap?: TErrorMap | undefined;
-    metaPlugins?: AnyMetaPlugin[] | undefined;
-}
-interface Middleware<TInContext extends Context, TOutContext extends Context, TInput, TOutput, TErrorMap extends ErrorMap> {
-    /** this property should be optional to support inline middleware */
-    '~orpc'?: MiddlewareDefinition<TErrorMap> | undefined;
-    (opts: MiddlewareOptions<TInContext, TOutput, ORPCErrorConstructorMap<TErrorMap>>, input: TInput, done: MiddlewareDone<TOutput>): Promisable<MiddlewareResult<TOutContext, TOutput>>;
-}
-type AnyMiddleware = Middleware<any, any, any, any, any>;
-
-interface ProcedureHandlerOptions<TCurrentContext extends Context, TInput, TErrorConstructorMap extends ORPCErrorConstructorMap<any>> {
-    context: TCurrentContext;
-    input: TInput;
-    path: string[];
-    procedure: Procedure<Context, Context, AnySchema, AnySchema, ErrorMap>;
-    signal?: AbortSignal | undefined;
-    lastEventId?: string | undefined;
-    errors: TErrorConstructorMap;
-}
-interface ProcedureHandler<TCurrentContext extends Context, TInput, THandlerOutput, TErrorConstructorMap extends ORPCErrorConstructorMap<any>> {
-    (opts: ProcedureHandlerOptions<TCurrentContext, TInput, TErrorConstructorMap>, input: TInput): Promisable<THandlerOutput>;
-}
-interface OrderedMiddleware {
-    /**
-     * Snapshot of `inputSchemas.length`
-     * at the time this middleware was used.
-     *
-     * @default 0
-     */
-    inputSchemasLengthAtUse?: number | undefined;
-    /**
-     * Snapshot of `outputSchemas.length`
-     * at the time this middleware was used.
-     *
-     * @default 0
-     */
-    outputSchemasLengthAtUse?: number | undefined;
-    middleware: AnyMiddleware;
-}
-interface ProcedureConfig {
-    /**
-     * When enabled, input schemas are not validated at runtime.
-     * Schemas are still used for type inference and OpenAPI generation.
-     *
-     * @remarks
-     * **Warning**: Do not disable validation for schemas that transform values.
-     *
-     * @default false
-     */
-    disableInputValidation?: boolean | undefined;
-    /**
-     * When enabled, output schemas are not validated at runtime.
-     * Schemas are still used for type inference and OpenAPI generation.
-     *
-     * Useful when output schemas exist only for specification generation.
-     *
-     * @remarks
-     * **Warning**: Do not disable validation for schemas that transform values.
-     *
-     * @default false
-     */
-    disableOutputValidation?: boolean | undefined;
-}
-interface ProcedureDefinition<TInitialContext extends Context, TInjectedContext extends Context, TInputSchema extends AnySchema, TOutputSchema extends AnySchema, TErrorMap extends ErrorMap> extends ProcedureContractDefinition<TInputSchema, TOutputSchema, TErrorMap>, ProcedureConfig {
-    __TInitialContext?: (type: TInitialContext) => unknown;
-    __TInjectedContext?: (type: TInjectedContext) => unknown;
-    orderedMiddlewares: OrderedMiddleware[];
-    handler: ProcedureHandler<any, any, any, any>;
-}
-declare class Procedure<TInitialContext extends Context, TInjectedContext extends Context, TInputSchema extends AnySchema, TOutputSchema extends AnySchema, TErrorMap extends ErrorMap> {
-    '~orpc': ProcedureDefinition<TInitialContext, TInjectedContext, TInputSchema, TOutputSchema, TErrorMap>;
-    constructor(def: ProcedureDefinition<TInitialContext, TInjectedContext, TInputSchema, TOutputSchema, TErrorMap>);
-    /**
-     * Checks if the given instance satisfies the {@link Procedure} class/interface.
-     */
-    static [Symbol.hasInstance](instance: unknown): boolean;
-}
-type AnyProcedure = Procedure<any, any, any, any, any>;
-
-interface LazyDefinition<T> {
-    meta: Meta;
-    metaPlugins?: AnyMetaPlugin[] | undefined;
-    loader: () => Promise<{
-        default: T;
-    }>;
-}
-declare class Lazy<T> {
-    '~orpc': LazyDefinition<T>;
-    constructor(def: LazyDefinition<T>);
-    /**
-     * Checks if the given instance satisfies the {@link Lazy} class/interface.
-     */
-    static [Symbol.hasInstance](instance: unknown): boolean;
-}
-type Lazyable<T> = T | Lazy<T>;
-declare function unlazy<T extends Lazyable<any>>(maybeLazy: T): Promise<{
-    default: T extends Lazy<infer U> ? U : T;
-}>;
-
-type ProcedureClient<TClientContext extends ClientContext, TInputSchema extends AnySchema, TOutputSchema extends AnySchema, TErrorMap extends ErrorMap> = Client<TClientContext, InferSchemaInput<TInputSchema>, InferSchemaOutput<TOutputSchema>, ORPCErrorFromErrorMap<TErrorMap> | ThrowableError>;
-interface ProcedureClientInterceptorOptions<TInitialContext extends Context, TErrorMap extends ErrorMap> extends ProcedureHandlerOptions<TInitialContext, unknown, ORPCErrorConstructorMap<TErrorMap>> {
-}
-type ProcedureClientInterceptor<TInitialContext extends Context, TOutputSchema extends AnySchema, TErrorMap extends ErrorMap> = Interceptor<ProcedureClientInterceptorOptions<TInitialContext, TErrorMap>, PromiseWithError<InferSchemaOutput<TOutputSchema>, ORPCErrorFromErrorMap<TErrorMap> | ThrowableError>>;
-type ProcedureClientOptions<TInitialContext extends Context, TOutputSchema extends AnySchema, TErrorMap extends ErrorMap, TClientContext extends ClientContext> = {
-    path?: string[] | undefined;
-    interceptors?: ProcedureClientInterceptor<TInitialContext, TOutputSchema, TErrorMap>[] | undefined;
-} & (object extends TInitialContext ? {
-    context?: Value<Promisable<TInitialContext>, [clientContext: TClientContext]> | undefined;
-} : {
-    context: Value<Promisable<TInitialContext>, [clientContext: TClientContext]>;
-});
-declare function createProcedureClient<TInitialContext extends Context, TInputSchema extends AnySchema, TOutputSchema extends AnySchema, TErrorMap extends ErrorMap, TClientContext extends ClientContext = object>(lazyableProcedure: Lazyable<Procedure<TInitialContext, any, TInputSchema, TOutputSchema, TErrorMap>>, ...rest: MaybeOptionalOptions<ProcedureClientOptions<TInitialContext, TOutputSchema, TErrorMap, TClientContext>>): ProcedureClient<TClientContext, TInputSchema, TOutputSchema, TErrorMap>;
-
-export { Procedure as a, Lazy as f, createProcedureClient as u, unlazy as v };
-export type { AnyProcedure as A, Context as C, Lazyable as L, MergedContext as M, OrderedMiddleware as O, ProcedureClientOptions as P, ProcedureClient as b, ProcedureClientInterceptor as c, Middleware as d, MergedInitialContext as e, ProcedureHandler as g, ProcedureConfig as h, AnyMiddleware as i, LazyDefinition as j, MiddlewareDefinition as k, MiddlewareDone as l, MiddlewareDoneOptions as m, MiddlewareNext as n, MiddlewareNextOptions as o, MiddlewareOptions as p, MiddlewareResult as q, ProcedureClientInterceptorOptions as r, ProcedureDefinition as s, ProcedureHandlerOptions as t };