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

package/dist/adapters/standard/rpc-matcher.js

@@ -0,0 +1,152 @@
+import { normalizeHttpPath, pathToHttpPath, value } from '@orpc/shared';
+import { unlazy } from '../../lazy.js';
+import { Procedure } from '../../procedure.js';
+import { resolveContractProcedure, walkProcedureContractsSync } from '../../router-utils.js';
+/**
+ * Methods that can invoke procedures by default. Browsers cannot trigger them
+ * cross-site without a CORS preflight or an HTML form, unlike `GET`, which a plain
+ * `<a>` click or redirect can trigger with `SameSite=Lax` cookies attached. Other
+ * methods (`HEAD`, `OPTIONS`, `QUERY`, ...) have safe semantics that should not
+ * invoke a procedure that can modify data.
+ *
+ * @see {@link https://orpc.dev/docs/rpc/handler#supported-http-methods | RPC Handler - Supported HTTP Methods}
+ */
+export const RPC_DEFAULT_ALLOW_METHODS = [
+    'POST',
+    'PUT',
+    'PATCH',
+    'DELETE',
+];
+// `%` or a char `encodeURIComponent` encodes, meaning normalization may change the pathname
+const NORMALIZABLE_PATHNAME_REGEX = /[^\w\-.!~*'()/]/;
+export class RPCMatcher {
+    filter;
+    allowMethodsSet;
+    allowMethodsFn;
+    rootRouter;
+    tree = new Map();
+    pendingLazyRouters = 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 : undefined,
+            });
+        }, 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 undefined;
+        }
+        if (prefix) {
+            if (!pathname.startsWith(prefix)) {
+                return undefined;
+            }
+            const charAfterPrefix = pathname[prefix.length];
+            if (charAfterPrefix === '/') {
+                pathname = pathname.slice(prefix.length);
+            }
+            else if (charAfterPrefix === undefined) {
+                pathname = '/';
+            }
+            else if (prefix[prefix.length - 1] === '/') {
+                pathname = pathname.slice(prefix.length - 1);
+            }
+            else {
+                return undefined;
+            }
+        }
+        if (pathname.length > 1 && pathname.endsWith('/')) {
+            pathname = pathname.slice(0, -1);
+        }
+        // most requests `await undefined` so conditionally await it to save a microtask turn
+        const loading = this.resolvePendingLazyRouters(pathname);
+        if (loading !== undefined) {
+            await loading;
+        }
+        let entry = this.tree.get(pathname);
+        if (entry === undefined && NORMALIZABLE_PATHNAME_REGEX.test(pathname)) {
+            // Retry with a normalized path: users may percent-encode characters that we store
+            // unencoded ("a%62c" vs "abc"), or leave raw characters that we store encoded
+            // ("a^b" vs "a%5Eb"), so normalization handles both without duplicate entries.
+            const normalizedPathname = normalizeHttpPath(pathname);
+            // most requests `await undefined` so conditionally await it to save a microtask turn
+            const normalizedLoading = this.resolvePendingLazyRouters(normalizedPathname);
+            if (normalizedLoading !== undefined) {
+                await normalizedLoading;
+            }
+            entry = this.tree.get(normalizedPathname);
+        }
+        if (entry === undefined) {
+            return undefined;
+        }
+        const procedure = entry.procedure ?? (await this.resolveProcedure(entry));
+        if (this.allowMethodsFn && !this.allowMethodsFn(method, procedure, entry.path)) {
+            return undefined;
+        }
+        return {
+            path: entry.path,
+            procedure,
+        };
+    }
+    resolvePendingLazyRouters(pathname) {
+        if (this.pendingLazyRouters.size === 0) {
+            return;
+        }
+        let slashIndex = 0;
+        // a pending key has as many segments as its path, so deeper prefixes can never match,
+        // and scanning them would cost quadratic time on slash-heavy pathnames
+        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 !== undefined) {
+                return this.loadPendingLazyRouter(httpPathPrefix, pending).then(() => this.resolvePendingLazyRouters(pathname));
+            }
+            slashIndex = nextSlashIndex;
+        }
+    }
+    loadPendingLazyRouter(httpPathPrefix, pending) {
+        if (pending.loading === undefined) {
+            pending.loading = this.indexPendingLazyRouter(httpPathPrefix, pending).catch((error) => {
+                pending.loading = undefined;
+                throw error;
+            });
+        }
+        return pending.loading;
+    }
+    async indexPendingLazyRouter(httpPathPrefix, pending) {
+        const { default: router } = await unlazy(pending.router);
+        this.index(router, pending.path);
+        // removed only once indexed, so a concurrent match never observes this router as
+        // neither pending nor indexed
+        this.pendingLazyRouters.delete(httpPathPrefix);
+    }
+    async resolveProcedure(entry) {
+        entry.procedure = await resolveContractProcedure(this.rootRouter, entry.contract, entry.path);
+        return entry.procedure;
+    }
+}

package/dist/adapters/standard/utils.d.ts

@@ -0,0 +1,10 @@
+import type { Promisable, Value } from '@orpc/shared';
+import type { StandardLazyRequest } from '@standard-server/core';
+import type { Context } from '../../context.ts';
+import type { StandardHandlerHandleOptions } from './handler.ts';
+export type FriendlyStandardHandlerHandleOptions<T extends Context> = Omit<StandardHandlerHandleOptions<T>, 'context'> & (object extends T ? {
+    context?: Value<Promisable<T>, [request: StandardLazyRequest]> | undefined;
+} : {
+    context: Value<Promisable<T>, [request: StandardLazyRequest]>;
+});
+export declare function resolveFriendlyStandardHandlerHandleOptions<T extends Context>(options: FriendlyStandardHandlerHandleOptions<T>): StandardHandlerHandleOptions<T>;

package/dist/adapters/standard/utils.js

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

package/dist/adapters/standard-peer/index.d.ts

@@ -0,0 +1 @@
+export * from './utils.ts';

package/dist/adapters/standard-peer/index.js

@@ -0,0 +1 @@
+export * from './utils.js';

package/dist/adapters/standard-peer/{utils.d.mts → utils.d.ts}

@@ -1,4 +1,4 @@
-import type { StandardLazyRequest, StandardResponse } from "@standard-server/core";
-import type { Context } from "../../context.mjs";
-import type { FriendlyStandardHandlerHandleOptions, StandardHandler } from "../standard/index.mjs";
+import type { StandardLazyRequest, StandardResponse } from '@standard-server/core';
+import type { Context } from '../../context.ts';
+import type { FriendlyStandardHandlerHandleOptions, StandardHandler } from '../standard/index.ts';
 export declare function createStandardPeerRequestHandler<T extends Context>(handler: StandardHandler<T>, options: FriendlyStandardHandlerHandleOptions<T>): (request: StandardLazyRequest) => Promise<StandardResponse>;

package/dist/adapters/standard-peer/utils.js

@@ -0,0 +1,7 @@
+import { resolveFriendlyStandardHandlerHandleOptions } from '../standard/index.js';
+export function createStandardPeerRequestHandler(handler, options) {
+    return async (request) => {
+        const { response } = await handler.handle(request, resolveFriendlyStandardHandlerHandleOptions(options));
+        return response ?? { status: 404, headers: {}, body: 'No procedure matched' };
+    };
+}

package/dist/adapters/websocket/handler.d.ts

@@ -0,0 +1,59 @@
+import type { Arrayable, MaybeOptionalOptions } from '@orpc/shared';
+import type { DecodePeerMessageOptions, EncodePeerMessageOptions } from '@standard-server/peer';
+import type { Context } from '../../context.ts';
+import type { FriendlyStandardHandlerHandleOptions, StandardHandler } from '../standard/index.ts';
+/**
+ * Supports standard WebSocket instances, Bun ServerWebSocket, "ws" ServerWebSocket,
+ * Cloudflare WebSocket Hibernation, and similar implementations.
+ */
+export type WebSocketLike = {
+    send: (data: string | Uint8Array<ArrayBuffer>) => unknown;
+};
+export interface WebSocketHandlerOptions<_T extends Context> {
+    /**
+     * Options for encoding peer messages. such as `prefix` for distinguishing messages on the same channel..
+     */
+    encodePeerMessage?: EncodePeerMessageOptions | undefined;
+    /**
+     * Options for decoding peer messages. such as `prefix` for distinguishing messages on the same channel..
+     */
+    decodePeerMessage?: DecodePeerMessageOptions | undefined;
+}
+export declare class WebSocketHandler<T extends Context> {
+    private readonly handler;
+    /**
+     * `null` marks a closed socket, so late messages never create a new peer.
+     */
+    private readonly peers;
+    private readonly encodePeerMessageOptions;
+    private readonly decodePeerMessageOptions;
+    constructor(handler: StandardHandler<T>, options?: NoInfer<WebSocketHandlerOptions<T>>);
+    /**
+     * Handles a single WebSocket message.
+     *
+     * Message order matters. Call this immediately after receiving a message,
+     * before any other async work, to preserve ordering.
+     *
+     * To avoid async Blob reads, configure `ws.binaryType` to return binary data
+     * directly (for example, `arraybuffer`).
+     *
+     * @param ws The WebSocket instance. Use the same instance for all messages.
+     * @param data The received message. Binary data should already be loaded (not a `Blob`).
+     */
+    message(ws: WebSocketLike, data: Arrayable<string | ArrayBuffer | Pick<Uint8Array<ArrayBuffer>, 'buffer' | 'byteOffset' | 'byteLength'>>, ...rest: MaybeOptionalOptions<FriendlyStandardHandlerHandleOptions<T>>): Promise<{
+        matched: boolean;
+    }>;
+    /**
+     * Cleans up peer state for a closed WebSocket.
+     * Messages passed to `.message()` for this WebSocket afterwards are ignored.
+     *
+     * @param ws The same WebSocket instance passed to `.message()`.
+     */
+    close(ws: WebSocketLike): Promise<void>;
+    /**
+     * Attaches message, close, and error event listeners to a WebSocket.
+     *
+     * Prefer this over calling `.message()` and `.close()` manually.
+     */
+    upgrade(ws: Pick<WebSocket, 'send' | 'addEventListener' | 'removeEventListener'>, ...rest: MaybeOptionalOptions<FriendlyStandardHandlerHandleOptions<T>>): void;
+}

package/dist/adapters/websocket/handler.js

@@ -0,0 +1,85 @@
+import { loadBytes, resolveMaybeOptionalOptions, sequential, toStringOrBytes } from '@orpc/shared';
+import { decodePeerMessage, encodePeerMessage, isClientPeerSendMessage, ServerPeer, } from '@standard-server/peer';
+import { createStandardPeerRequestHandler } from '../standard-peer/index.js';
+export class WebSocketHandler {
+    handler;
+    /**
+     * `null` marks a closed socket, so late messages never create a new peer.
+     */
+    peers = new WeakMap();
+    encodePeerMessageOptions;
+    decodePeerMessageOptions;
+    constructor(handler, options = {}) {
+        this.handler = handler;
+        this.encodePeerMessageOptions = options.encodePeerMessage;
+        this.decodePeerMessageOptions = options.decodePeerMessage;
+    }
+    /**
+     * Handles a single WebSocket message.
+     *
+     * Message order matters. Call this immediately after receiving a message,
+     * before any other async work, to preserve ordering.
+     *
+     * To avoid async Blob reads, configure `ws.binaryType` to return binary data
+     * directly (for example, `arraybuffer`).
+     *
+     * @param ws The WebSocket instance. Use the same instance for all messages.
+     * @param data The received message. Binary data should already be loaded (not a `Blob`).
+     */
+    async message(ws, data, ...rest) {
+        /**
+         * Message order is important: loading -> decode -> .message.
+         * This flow must stay synchronous, or we need to use `sequential` helper
+         */
+        const encoded = toStringOrBytes(data);
+        const result = decodePeerMessage(encoded, this.decodePeerMessageOptions);
+        let peer = this.peers.get(ws);
+        // Closed (e.g. a Blob finished loading after close): a new peer here would leak and never be aborted.
+        if (peer === null) {
+            return result;
+        }
+        if (!peer) {
+            this.peers.set(ws, (peer = new ServerPeer(async (message) => {
+                const encoded = await encodePeerMessage(message, this.encodePeerMessageOptions);
+                await ws.send(encoded);
+            })));
+        }
+        if (result.matched && isClientPeerSendMessage(result.message)) {
+            await peer.message(result.message, createStandardPeerRequestHandler(this.handler, resolveMaybeOptionalOptions(rest)));
+        }
+        return result;
+    }
+    /**
+     * Cleans up peer state for a closed WebSocket.
+     * Messages passed to `.message()` for this WebSocket afterwards are ignored.
+     *
+     * @param ws The same WebSocket instance passed to `.message()`.
+     */
+    async close(ws) {
+        const peer = this.peers.get(ws);
+        this.peers.set(ws, null);
+        await peer?.close();
+    }
+    /**
+     * Attaches message, close, and error event listeners to a WebSocket.
+     *
+     * Prefer this over calling `.message()` and `.close()` manually.
+     */
+    upgrade(ws, ...rest) {
+        /**
+         * Message order is important: loading -> decode -> .message.
+         * This flow must stay synchronous, or we need to use `sequential` helper
+         */
+        ws.addEventListener('message', sequential(async (event) => {
+            // For better compatibility avoid control or depend on websocket.binaryType
+            const data = event.data instanceof Blob ? await loadBytes(event.data) : event.data;
+            // Not awaited: `this.message` runs business logic that may be slow,
+            // and awaiting it would block decoding of subsequent messages.
+            void this.message(ws, data, ...rest);
+        }));
+        ws.addEventListener('close', () => this.close(ws));
+        // EventEmitter-based implementations like `ws` throw an unhandled `error` event,
+        // so a single malformed frame would crash the process. `close` always follows and handles cleanup.
+        ws.addEventListener('error', () => { });
+    }
+}

package/dist/adapters/websocket/index.d.ts

@@ -0,0 +1,2 @@
+export * from './handler.ts';
+export * from './rpc-handler.ts';

package/dist/adapters/websocket/index.js

@@ -0,0 +1,2 @@
+export * from './handler.js';
+export * from './rpc-handler.js';

package/dist/adapters/websocket/rpc-handler.d.ts

@@ -0,0 +1,16 @@
+import type { Context } from '../../context.ts';
+import type { Router } from '../../router.ts';
+import type { RPCHandlerCodecOptions, StandardHandlerOptions } from '../standard/index.ts';
+import type { WebSocketHandlerOptions } from './handler.ts';
+import { WebSocketHandler } from './handler.ts';
+export interface RPCHandlerOptions<T extends Context> extends StandardHandlerOptions<T>, RPCHandlerCodecOptions<T>, WebSocketHandlerOptions<T> {
+}
+/**
+ * Serves an oRPC router over the RPC protocol on a standard WebSocket
+ * connection (Deno, Bun, Cloudflare Durable Objects, and more).
+ *
+ * @see {@link https://orpc.dev/docs/adapters/websocket | WebSocket Adapters}
+ */
+export declare class RPCHandler<T extends Context> extends WebSocketHandler<T> {
+    constructor(router: Router<T>, options?: NoInfer<RPCHandlerOptions<T>>);
+}

package/dist/adapters/websocket/rpc-handler.js

@@ -0,0 +1,15 @@
+import { RPCHandlerCodec, StandardHandler } from '../standard/index.js';
+import { WebSocketHandler } from './handler.js';
+/**
+ * Serves an oRPC router over the RPC protocol on a standard WebSocket
+ * connection (Deno, Bun, Cloudflare Durable Objects, and more).
+ *
+ * @see {@link https://orpc.dev/docs/adapters/websocket | WebSocket Adapters}
+ */
+export class RPCHandler extends WebSocketHandler {
+    constructor(router, options = {}) {
+        const codec = new RPCHandlerCodec(router, options);
+        const handler = new StandardHandler(codec, options);
+        super(handler, options);
+    }
+}

package/dist/builder-variants.d.ts

@@ -0,0 +1,226 @@
+import type { AnySchema, ErrorMap, InferSchemaInput, InferSchemaOutput, InitialInputSchema, InitialOutputSchema, MergedErrorMap, MergedSchema, MetaPlugin, ORPCErrorConstructorMap, Schema } from '@orpc/contract';
+import type { IntersectPick } from '@orpc/shared';
+import type { BuilderDefinition } from './builder.ts';
+import type { Context, MergedContext, MergedInitialContext } from './context.ts';
+import type { Lazy } from './lazy.ts';
+import type { DecoratedMiddleware } from './middleware-decorated.ts';
+import type { Middleware } from './middleware.ts';
+import type { DecoratedProcedure } from './procedure-decorated.ts';
+import type { ProcedureHandler } from './procedure.ts';
+import type { AugmentedRouterWithMiddlewares } from './router-utils.ts';
+import type { Router } from './router.ts';
+/**
+ * The builder variant returned after `.use` is called.
+ * `.$context` and `.$config` are no longer available once middleware is applied.
+ *
+ * @see {@link https://orpc.dev/docs/procedure | Procedure}
+ */
+export interface BuilderWithMiddlewares<TInitialContext extends Context, TInjectedContext extends Context, TErrorMap extends ErrorMap> {
+    '~orpc': BuilderDefinition<InitialInputSchema, InitialOutputSchema, TErrorMap>;
+    /**
+     * Applies metadata plugins to procedures built from this builder.
+     *
+     * @see {@link https://orpc.dev/docs/metadata | Metadata}
+     */
+    'meta'(...plugins: MetaPlugin<InitialInputSchema, InitialOutputSchema, TErrorMap>[]): BuilderWithMiddlewares<TInitialContext, TInjectedContext, TErrorMap>;
+    /**
+     * Defines typesafe errors that procedures built from this builder can throw
+     * via the `errors` utility in handlers and middleware.
+     *
+     * @see {@link https://orpc.dev/docs/error-handling#typesafe-errors | Error Handling - Typesafe Errors}
+     */
+    'errors'<T extends ErrorMap>(errors: T): BuilderWithMiddlewares<TInitialContext, TInjectedContext, MergedErrorMap<TErrorMap, T>>;
+    /**
+     * Applies a middleware that runs before the handler of every procedure
+     * built from this builder.
+     *
+     * @see {@link https://orpc.dev/docs/middleware | Middleware}
+     */
+    'use'<$OutContext extends IntersectPick<MergedContext<TInitialContext, TInjectedContext>, $OutContext>, $InContext extends Context = MergedContext<TInitialContext, TInjectedContext>, $ErrorMap extends ErrorMap = TErrorMap>(middleware: Middleware<$InContext | MergedContext<TInitialContext, TInjectedContext>, $OutContext, InferSchemaOutput<InitialInputSchema>, InferSchemaInput<InitialOutputSchema>, $ErrorMap>): BuilderWithMiddlewares<MergedInitialContext<TInitialContext, TInjectedContext, $InContext>, MergedContext<TInjectedContext, $OutContext>, MergedErrorMap<$ErrorMap, TErrorMap>>;
+    /**
+     * Creates a standalone middleware that can be composed and applied to any
+     * compatible builder or procedure with `.use`.
+     *
+     * @see {@link https://orpc.dev/docs/middleware | Middleware}
+     */
+    'middleware'<$OutContext extends IntersectPick<MergedContext<TInitialContext, TInjectedContext>, $OutContext>, $Input, $InContext extends Context = MergedContext<TInitialContext, TInjectedContext>, $Output = any>(middleware: Middleware<$InContext | MergedContext<TInitialContext, TInjectedContext>, $OutContext, $Input, $Output, TErrorMap>): DecoratedMiddleware<MergedInitialContext<TInitialContext, TInjectedContext, $InContext>, MergedContext<TInjectedContext, $OutContext>, $Input, $Output, TErrorMap>;
+    /**
+     * Defines the input schema used to validate and type the procedure input.
+     *
+     * @see {@link https://orpc.dev/docs/procedure#inputoutput-validation | Procedure - Input/Output Validation}
+     */
+    'input'<T extends AnySchema>(schema: T): BuilderWithInput<TInitialContext, TInjectedContext, T, TErrorMap>;
+    /**
+     * Defines the output schema used to validate and type the procedure output.
+     *
+     * @see {@link https://orpc.dev/docs/procedure#inputoutput-validation | Procedure - Input/Output Validation}
+     */
+    'output'<T extends AnySchema>(schema: T): BuilderWithOutput<TInitialContext, TInjectedContext, T, TErrorMap>;
+    /**
+     * Defines the function that implements the procedure and completes the
+     * chain, returning a callable procedure.
+     *
+     * @see {@link https://orpc.dev/docs/procedure | Procedure}
+     */
+    'handler'<T>(handler: ProcedureHandler<MergedContext<TInitialContext, TInjectedContext>, InferSchemaOutput<InitialInputSchema>, T, ORPCErrorConstructorMap<TErrorMap>>): DecoratedProcedure<TInitialContext, TInjectedContext, InitialInputSchema, Schema<T>, TErrorMap>;
+    /**
+     * Applies the builder's middleware, errors, and metadata to every procedure
+     * in the given router.
+     *
+     * @see {@link https://orpc.dev/docs/router#extending-router | Router - Extending Router}
+     */
+    'router'<T extends Router<MergedContext<TInitialContext, TInjectedContext>>>(router: T): AugmentedRouterWithMiddlewares<T, TInitialContext, TInjectedContext, TErrorMap>;
+    /**
+     * Like `.router`, but loads the router lazily on first access, which helps
+     * reduce startup time for large applications.
+     *
+     * @see {@link https://orpc.dev/docs/router#lazy-router | Router - Lazy Router}
+     */
+    'lazy'<T extends Router<MergedContext<TInitialContext, TInjectedContext>>>(loader: () => Promise<{
+        default: T;
+    }>): Lazy<AugmentedRouterWithMiddlewares<T, TInitialContext, TInjectedContext, TErrorMap>>;
+}
+/**
+ * The builder variant returned after `.input` is called.
+ * Only procedure-level methods remain available once an input schema is defined.
+ *
+ * @see {@link https://orpc.dev/docs/procedure | Procedure}
+ */
+export interface BuilderWithInput<TInitialContext extends Context, TInjectedContext extends Context, TInputSchema extends AnySchema, TErrorMap extends ErrorMap> {
+    '~orpc': BuilderDefinition<TInputSchema, InitialOutputSchema, TErrorMap>;
+    /**
+     * Applies metadata plugins to procedures built from this builder.
+     *
+     * @see {@link https://orpc.dev/docs/metadata | Metadata}
+     */
+    'meta'(...plugins: MetaPlugin<TInputSchema, InitialOutputSchema, TErrorMap>[]): BuilderWithInput<TInitialContext, TInjectedContext, TInputSchema, TErrorMap>;
+    /**
+     * Defines typesafe errors that procedures built from this builder can throw
+     * via the `errors` utility in handlers and middleware.
+     *
+     * @see {@link https://orpc.dev/docs/error-handling#typesafe-errors | Error Handling - Typesafe Errors}
+     */
+    'errors'<T extends ErrorMap>(errors: T): BuilderWithInput<TInitialContext, TInjectedContext, TInputSchema, MergedErrorMap<TErrorMap, T>>;
+    /**
+     * Applies a middleware that runs before the handler and can access the
+     * validated input.
+     *
+     * @see {@link https://orpc.dev/docs/middleware | Middleware}
+     */
+    'use'<$OutContext extends IntersectPick<MergedContext<TInitialContext, TInjectedContext>, $OutContext>, $InContext extends Context = MergedContext<TInitialContext, TInjectedContext>, $ErrorMap extends ErrorMap = TErrorMap>(middleware: Middleware<$InContext | MergedContext<TInitialContext, TInjectedContext>, $OutContext, InferSchemaOutput<TInputSchema>, InferSchemaInput<InitialOutputSchema>, $ErrorMap>): BuilderWithInput<MergedInitialContext<TInitialContext, TInjectedContext, $InContext>, MergedContext<TInjectedContext, $OutContext>, TInputSchema, MergedErrorMap<$ErrorMap, TErrorMap>>;
+    /**
+     * Adds an additional input schema, merged with the previously defined one.
+     *
+     * @see {@link https://orpc.dev/docs/procedure#multiple-schemas | Procedure - Multiple Schemas}
+     */
+    'input'<T extends AnySchema>(schema: T): BuilderWithInput<TInitialContext, TInjectedContext, MergedSchema<T, TInputSchema>, TErrorMap>;
+    /**
+     * Defines the output schema used to validate and type the procedure output.
+     *
+     * @see {@link https://orpc.dev/docs/procedure#inputoutput-validation | Procedure - Input/Output Validation}
+     */
+    'output'<T extends AnySchema>(schema: T): BuilderWithInputOutput<TInitialContext, TInjectedContext, TInputSchema, T, TErrorMap>;
+    /**
+     * Defines the function that implements the procedure and completes the
+     * chain, returning a callable procedure.
+     *
+     * @see {@link https://orpc.dev/docs/procedure | Procedure}
+     */
+    'handler'<T>(handler: ProcedureHandler<MergedContext<TInitialContext, TInjectedContext>, InferSchemaOutput<TInputSchema>, T, ORPCErrorConstructorMap<TErrorMap>>): DecoratedProcedure<TInitialContext, TInjectedContext, TInputSchema, Schema<T>, TErrorMap>;
+}
+/**
+ * The builder variant returned after `.output` is called.
+ * Only procedure-level methods remain available once an output schema is defined.
+ *
+ * @see {@link https://orpc.dev/docs/procedure | Procedure}
+ */
+export interface BuilderWithOutput<TInitialContext extends Context, TInjectedContext extends Context, TOutputSchema extends AnySchema, TErrorMap extends ErrorMap> {
+    '~orpc': BuilderDefinition<InitialInputSchema, TOutputSchema, TErrorMap>;
+    /**
+     * Applies metadata plugins to procedures built from this builder.
+     *
+     * @see {@link https://orpc.dev/docs/metadata | Metadata}
+     */
+    'meta'(...plugins: MetaPlugin<InitialInputSchema, TOutputSchema, TErrorMap>[]): BuilderWithOutput<TInitialContext, TInjectedContext, TOutputSchema, TErrorMap>;
+    /**
+     * Defines typesafe errors that procedures built from this builder can throw
+     * via the `errors` utility in handlers and middleware.
+     *
+     * @see {@link https://orpc.dev/docs/error-handling#typesafe-errors | Error Handling - Typesafe Errors}
+     */
+    'errors'<T extends ErrorMap>(errors: T): BuilderWithOutput<TInitialContext, TInjectedContext, TOutputSchema, MergedErrorMap<TErrorMap, T>>;
+    /**
+     * Applies a middleware that runs before the handler and can access the
+     * typed output.
+     *
+     * @see {@link https://orpc.dev/docs/middleware | Middleware}
+     */
+    'use'<$OutContext extends IntersectPick<MergedContext<TInitialContext, TInjectedContext>, $OutContext>, $InContext extends Context = MergedContext<TInitialContext, TInjectedContext>, $ErrorMap extends ErrorMap = TErrorMap>(middleware: Middleware<$InContext | MergedContext<TInitialContext, TInjectedContext>, $OutContext, InferSchemaOutput<InitialInputSchema>, InferSchemaInput<TOutputSchema>, $ErrorMap>): BuilderWithOutput<MergedInitialContext<TInitialContext, TInjectedContext, $InContext>, MergedContext<TInjectedContext, $OutContext>, TOutputSchema, MergedErrorMap<$ErrorMap, TErrorMap>>;
+    /**
+     * Defines the input schema used to validate and type the procedure input.
+     *
+     * @see {@link https://orpc.dev/docs/procedure#inputoutput-validation | Procedure - Input/Output Validation}
+     */
+    'input'<T extends AnySchema>(schema: T): BuilderWithInputOutput<TInitialContext, TInjectedContext, T, TOutputSchema, TErrorMap>;
+    /**
+     * Adds an additional output schema, merged with the previously defined one.
+     *
+     * @see {@link https://orpc.dev/docs/procedure#multiple-schemas | Procedure - Multiple Schemas}
+     */
+    'output'<T extends AnySchema>(schema: T): BuilderWithOutput<TInitialContext, TInjectedContext, MergedSchema<T, TOutputSchema>, TErrorMap>;
+    /**
+     * Defines the function that implements the procedure and completes the
+     * chain, returning a callable procedure.
+     *
+     * @see {@link https://orpc.dev/docs/procedure | Procedure}
+     */
+    'handler'<T extends InferSchemaInput<TOutputSchema>>(handler: ProcedureHandler<MergedContext<TInitialContext, TInjectedContext>, InferSchemaOutput<InitialInputSchema>, T, ORPCErrorConstructorMap<TErrorMap>>): DecoratedProcedure<TInitialContext, TInjectedContext, InitialInputSchema, TOutputSchema, TErrorMap>;
+}
+/**
+ * The builder variant returned after both `.input` and `.output` are called.
+ * Only procedure-level methods remain available.
+ *
+ * @see {@link https://orpc.dev/docs/procedure | Procedure}
+ */
+export interface BuilderWithInputOutput<TInitialContext extends Context, TInjectedContext extends Context, TInputSchema extends AnySchema, TOutputSchema extends AnySchema, TErrorMap extends ErrorMap> {
+    '~orpc': BuilderDefinition<TInputSchema, TOutputSchema, TErrorMap>;
+    /**
+     * Applies metadata plugins to procedures built from this builder.
+     *
+     * @see {@link https://orpc.dev/docs/metadata | Metadata}
+     */
+    'meta'(...plugins: MetaPlugin<TInputSchema, TOutputSchema, TErrorMap>[]): BuilderWithInputOutput<TInitialContext, TInjectedContext, TInputSchema, TOutputSchema, TErrorMap>;
+    /**
+     * Defines typesafe errors that procedures built from this builder can throw
+     * via the `errors` utility in handlers and middleware.
+     *
+     * @see {@link https://orpc.dev/docs/error-handling#typesafe-errors | Error Handling - Typesafe Errors}
+     */
+    'errors'<T extends ErrorMap>(errors: T): BuilderWithInputOutput<TInitialContext, TInjectedContext, TInputSchema, TOutputSchema, MergedErrorMap<TErrorMap, T>>;
+    /**
+     * Applies a middleware that runs before the handler and can access the
+     * validated input and typed output.
+     *
+     * @see {@link https://orpc.dev/docs/middleware | Middleware}
+     */
+    'use'<$OutContext extends IntersectPick<MergedContext<TInitialContext, TInjectedContext>, $OutContext>, $InContext extends Context = MergedContext<TInitialContext, TInjectedContext>, $ErrorMap extends ErrorMap = TErrorMap>(middleware: Middleware<$InContext | MergedContext<TInitialContext, TInjectedContext>, $OutContext, InferSchemaOutput<TInputSchema>, InferSchemaInput<TOutputSchema>, $ErrorMap>): BuilderWithInputOutput<MergedInitialContext<TInitialContext, TInjectedContext, $InContext>, MergedContext<TInjectedContext, $OutContext>, TInputSchema, TOutputSchema, MergedErrorMap<$ErrorMap, TErrorMap>>;
+    /**
+     * Adds an additional input schema, merged with the previously defined one.
+     *
+     * @see {@link https://orpc.dev/docs/procedure#multiple-schemas | Procedure - Multiple Schemas}
+     */
+    'input'<T extends AnySchema>(schema: T): BuilderWithInputOutput<TInitialContext, TInjectedContext, MergedSchema<T, TInputSchema>, TOutputSchema, TErrorMap>;
+    /**
+     * Adds an additional output schema, merged with the previously defined one.
+     *
+     * @see {@link https://orpc.dev/docs/procedure#multiple-schemas | Procedure - Multiple Schemas}
+     */
+    'output'<T extends AnySchema>(schema: T): BuilderWithInputOutput<TInitialContext, TInjectedContext, TInputSchema, MergedSchema<T, TOutputSchema>, TErrorMap>;
+    /**
+     * Defines the function that implements the procedure and completes the
+     * chain, returning a callable procedure.
+     *
+     * @see {@link https://orpc.dev/docs/procedure | Procedure}
+     */
+    'handler'<T extends InferSchemaInput<TOutputSchema>>(handler: ProcedureHandler<MergedContext<TInitialContext, TInjectedContext>, InferSchemaOutput<TInputSchema>, T, ORPCErrorConstructorMap<TErrorMap>>): DecoratedProcedure<TInitialContext, TInjectedContext, TInputSchema, TOutputSchema, TErrorMap>;
+}