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

package/dist/builder-variants.d.mts

@@ -0,0 +1,267 @@
+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.mjs";
+import type { Context, MergedContext, MergedInitialContext } from "./context.mjs";
+import type { Lazy } from "./lazy.mjs";
+import type { Middleware } from "./middleware.mjs";
+import type { DecoratedMiddleware } from "./middleware-decorated.mjs";
+import type { ProcedureHandler } from "./procedure.mjs";
+import type { DecoratedProcedure } from "./procedure-decorated.mjs";
+import type { Router } from "./router.mjs";
+import type { AugmentedRouterWithMiddlewares } from "./router-utils.mjs";
+/**
+* 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>;
+}

package/dist/builder-variants.mjs

@@ -0,0 +1 @@
+export {};

package/dist/builder.d.mts

@@ -0,0 +1,141 @@
+import type { AnySchema, ErrorMap, InferSchemaInput, InferSchemaOutput, InitialInputSchema, InitialOutputSchema, MergedErrorMap, MetaPlugin, ORPCErrorConstructorMap, ProcedureContractDefinition, Schema } from "@orpc/contract";
+import type { IntersectPick } from "@orpc/shared";
+import type { BuilderWithInput, BuilderWithMiddlewares, BuilderWithOutput } from "./builder-variants.mjs";
+import type { Context, MergedInitialContext } from "./context.mjs";
+import type { Middleware } from "./middleware.mjs";
+import type { DecoratedMiddleware } from "./middleware-decorated.mjs";
+import type { OrderedMiddleware, ProcedureConfig, ProcedureHandler } from "./procedure.mjs";
+import type { AnyRouter } from "./router.mjs";
+import type { AugmentedRouter } from "./router-utils.mjs";
+import { Lazy } from "./lazy.mjs";
+import { DecoratedProcedure } from "./procedure-decorated.mjs";
+/**
+* The initial context type used when `.$context` is not called.
+* Augment this interface with `declare module '@orpc/server'` to define
+* a default initial context type globally.
+*
+* @see {@link https://orpc.dev/docs/context#default-initial-context | Context - Default Initial Context}
+*/
+export interface DefaultInitialContext {}
+export interface BuilderDefinition<
+	TInputSchema extends AnySchema,
+	TInjectedContext extends AnySchema,
+	TErrorMap extends ErrorMap
+> extends ProcedureContractDefinition<TInputSchema, TInjectedContext, TErrorMap>, ProcedureConfig {
+	orderedMiddlewares: OrderedMiddleware[];
+}
+/**
+* The procedure builder behind `os`. Chain its methods to gradually define
+* context, middleware, errors, schemas, and finally a handler or router.
+*
+* @see {@link https://orpc.dev/docs/procedure | Procedure}
+*/
+export declare class Builder<
+	TInitialContext extends Context,
+	TErrorMap extends ErrorMap
+> {
+	"~orpc": BuilderDefinition<InitialInputSchema, InitialOutputSchema, TErrorMap>;
+	/**
+	* Private constructor to prevent direct instantiation.
+	* Use the static `create` method to initialize a new instance with a safe initial definition.
+	*/
+	private constructor();
+	/**
+	* Creates a fresh builder with an empty definition.
+	* Prefer the exported `os` instance over calling this directly.
+	*
+	* @see {@link https://orpc.dev/docs/procedure | Procedure}
+	*/
+	static create<T extends Context = DefaultInitialContext>(): Builder<T & object, Record<never, never>>;
+	/**
+	* Declares the initial context type that must be provided when executing
+	* procedures built from this builder.
+	*
+	* @see {@link https://orpc.dev/docs/context#initial-context | Context - Initial Context}
+	*/
+	$context<T extends Context = DefaultInitialContext>(): Builder<T & object, TErrorMap>;
+	/**
+	* Overrides the procedure configuration, such as disabling runtime
+	* input/output validation.
+	*
+	* @see {@link https://orpc.dev/docs/recipes/validation-customization | Validation Customization}
+	*/
+	$config(config: ProcedureConfig): Builder<TInitialContext, TErrorMap>;
+	/**
+	* Applies metadata plugins to procedures built from this builder.
+	*
+	* @see {@link https://orpc.dev/docs/metadata | Metadata}
+	*/
+	meta(...plugins: MetaPlugin<InitialInputSchema, InitialOutputSchema, TErrorMap>[]): Builder<TInitialContext, 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<U extends ErrorMap>(errors: U): Builder<TInitialContext, MergedErrorMap<TErrorMap, U>>;
+	/**
+	* 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<TInitialContext, $OutContext>,
+		$InContext extends Context = TInitialContext,
+		$ErrorMap extends ErrorMap = TErrorMap
+	>(middleware: Middleware<$InContext | TInitialContext, $OutContext, InferSchemaOutput<InitialInputSchema>, InferSchemaInput<InitialOutputSchema>, $ErrorMap>): BuilderWithMiddlewares<MergedInitialContext<TInitialContext, object, $InContext>, $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<TInitialContext, $OutContext>,
+		$Input,
+		$Output = any
+	>(middleware: Middleware<TInitialContext, $OutContext, $Input, $Output, TErrorMap>): DecoratedMiddleware<TInitialContext, $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<$ extends AnySchema>(schema: $): BuilderWithInput<TInitialContext, object, $, 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<$ extends AnySchema>(schema: $): BuilderWithOutput<TInitialContext, object, $, 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<TInitialContext, InferSchemaOutput<InitialInputSchema>, T, ORPCErrorConstructorMap<TErrorMap>>): DecoratedProcedure<TInitialContext, object, 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 AnyRouter>(router: T): AugmentedRouter<T, 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 AnyRouter>(loader: () => Promise<{
+		default: T;
+	}>): Lazy<AugmentedRouter<T, TErrorMap>>;
+}
+/**
+* The oRPC procedure builder. Chain methods like `.input`, `.use`, and `.handler`
+* to define procedures, then compose them into routers.
+*
+* @see {@link https://orpc.dev/docs/procedure | Procedure}
+*/
+export declare const os: Builder<DefaultInitialContext & object, Record<never, never>>;

package/dist/builder.mjs

@@ -0,0 +1,145 @@
+import { getHiddenMetaPlugins, mergeErrorMap, resolveMetaPlugins } from "@orpc/contract";
+import { toArray } from "@orpc/shared";
+import { Lazy } from "./lazy.mjs";
+import { decorateMiddleware } from "./middleware-decorated.mjs";
+import { DecoratedProcedure } from "./procedure-decorated.mjs";
+import { augmentRouter } from "./router-utils.mjs";
+
+export class Builder {
+	"~orpc";
+	
+	constructor(definition) {
+		this["~orpc"] = definition;
+	}
+	
+	static create() {
+		
+		
+		return new Builder({
+			errorMap: {},
+			meta: {},
+			orderedMiddlewares: []
+		});
+	}
+	
+	$context() {
+		
+		
+		
+		return this;
+	}
+	
+	$config(config) {
+		return new Builder({
+			...this["~orpc"],
+			...config
+		});
+	}
+	
+	meta(...plugins) {
+		const [meta, metaPlugins] = resolveMetaPlugins(this["~orpc"].meta, this["~orpc"].metaPlugins, plugins);
+		return new Builder({
+			...this["~orpc"],
+			meta,
+			metaPlugins
+		});
+	}
+	
+	errors(errors) {
+		let builder = new Builder({
+			...this["~orpc"],
+			errorMap: mergeErrorMap(this["~orpc"].errorMap, errors)
+		});
+		const plugins = getHiddenMetaPlugins(errors);
+		if (plugins) {
+			builder = builder.meta(...plugins);
+		}
+		return builder;
+	}
+	
+	use(middleware) {
+		let builder = new Builder({
+			...this["~orpc"],
+			errorMap: mergeErrorMap(middleware["~orpc"]?.errorMap ?? {}, this["~orpc"].errorMap),
+			orderedMiddlewares: [...this["~orpc"].orderedMiddlewares, {
+				middleware,
+				inputSchemasLengthAtUse: this["~orpc"].inputSchemas?.length,
+				outputSchemasLengthAtUse: this["~orpc"].outputSchemas?.length
+			}]
+		});
+		if (middleware["~orpc"]?.metaPlugins) {
+			builder = builder.meta(...middleware["~orpc"]?.metaPlugins);
+		}
+		return builder;
+	}
+	
+	middleware(middleware) {
+		const allMiddlewares = [...this["~orpc"].orderedMiddlewares.map(({ middleware }) => middleware), middleware];
+		let current = decorateMiddleware(allMiddlewares.shift());
+		for (const mid of allMiddlewares) {
+			current = current.use(mid);
+		}
+		current["~orpc"] = {
+			...current["~orpc"],
+			errorMap: this["~orpc"].errorMap,
+			metaPlugins: [...toArray(this["~orpc"].metaPlugins), ...toArray(middleware["~orpc"]?.metaPlugins)]
+		};
+		return current;
+	}
+	
+	input(schema) {
+		let builder = new Builder({
+			...this["~orpc"],
+			inputSchemas: [...toArray(this["~orpc"].inputSchemas), schema]
+		});
+		const plugins = getHiddenMetaPlugins(schema);
+		if (plugins) {
+			builder = builder.meta(...plugins);
+		}
+		return builder;
+	}
+	
+	output(schema) {
+		let builder = new Builder({
+			...this["~orpc"],
+			outputSchemas: [...toArray(this["~orpc"].outputSchemas), schema]
+		});
+		const plugins = getHiddenMetaPlugins(schema);
+		if (plugins) {
+			builder = builder.meta(...plugins);
+		}
+		return builder;
+	}
+	
+	handler(handler) {
+		let procedure = new DecoratedProcedure({
+			...this["~orpc"],
+			handler
+		});
+		const plugins = getHiddenMetaPlugins(handler);
+		if (plugins) {
+			procedure = procedure.meta(...plugins);
+		}
+		return procedure;
+	}
+	
+	router(router) {
+		return augmentRouter(router, {
+			...this["~orpc"],
+			middlewares: this["~orpc"].orderedMiddlewares.map(({ middleware }) => middleware)
+		});
+	}
+	
+	lazy(loader) {
+		return new Lazy({
+			loader: async () => {
+				const { default: router } = await loader();
+				return { default: this.router(router) };
+			},
+			meta: this["~orpc"].meta,
+			metaPlugins: this["~orpc"].metaPlugins
+		});
+	}
+}
+
+export const os = /* @__PURE__ */ Builder.create();

package/dist/constants.d.mts

@@ -0,0 +1,2 @@
+export declare const DEFAULT_SUCCESS_STATUS = 200;
+export declare const DEFAULT_ERROR_STATUS = 400;

package/dist/constants.mjs

@@ -0,0 +1,2 @@
+export const DEFAULT_SUCCESS_STATUS = 200;
+export const DEFAULT_ERROR_STATUS = 400;

package/dist/context.d.mts

@@ -0,0 +1,13 @@
+import type { DistributiveOmit } from "@orpc/shared";
+export interface Context {
+	[key: PropertyKey]: any;
+}
+export 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;
+export type MergedContext<
+	TCurrent extends Context,
+	TOutContext extends Context
+> = keyof TOutContext extends never ? TCurrent : DistributiveOmit<TCurrent, keyof TOutContext> & TOutContext;

package/dist/context.mjs

@@ -0,0 +1 @@
+export {};

package/dist/extensions/callable.d.mts

@@ -1,10 +1,17 @@
-import { ClientContext } from '@orpc/client';
-import { AnySchema, ErrorMap } from '@orpc/contract';
-import { MaybeOptionalOptions } from '@orpc/shared';
-import { Context, ProcedureClientOptions, Procedure, ProcedureClient } from '../index.mjs';
-
-declare module '@orpc/server' {
-    interface DecoratedProcedure<TInitialContext extends Context, TInjectedContext extends Context, TInputSchema extends AnySchema, TOutputSchema extends AnySchema, TErrorMap extends ErrorMap> {
-        callable<TClientContext extends ClientContext>(...rest: MaybeOptionalOptions<ProcedureClientOptions<TInitialContext, TOutputSchema, TErrorMap, TClientContext>>): Procedure<TInitialContext, TInjectedContext, TInputSchema, TOutputSchema, TErrorMap> & ProcedureClient<TClientContext, TInputSchema, TOutputSchema, TErrorMap>;
-    }
+import type { ClientContext } from "@orpc/client";
+import type { AnySchema, ErrorMap } from "@orpc/contract";
+import type { MaybeOptionalOptions } from "@orpc/shared";
+import type { Context } from "../context.mjs";
+import type { Procedure } from "../procedure.mjs";
+import type { ProcedureClient, ProcedureClientOptions } from "../procedure-client.mjs";
+declare module "@orpc/server" {
+	interface DecoratedProcedure<
+		TInitialContext extends Context,
+		TInjectedContext extends Context,
+		TInputSchema extends AnySchema,
+		TOutputSchema extends AnySchema,
+		TErrorMap extends ErrorMap
+	> {
+		callable<TClientContext extends ClientContext>(...rest: MaybeOptionalOptions<ProcedureClientOptions<TInitialContext, TOutputSchema, TErrorMap, TClientContext>>): Procedure<TInitialContext, TInjectedContext, TInputSchema, TOutputSchema, TErrorMap> & ProcedureClient<TClientContext, TInputSchema, TOutputSchema, TErrorMap>;
+	}
 }

package/dist/extensions/callable.mjs

@@ -1,11 +1,7 @@
-import { c as createProcedureClient } from '../shared/server.BB464y-6.mjs';
-import { D as DecoratedProcedure } from '../shared/server.sBQSgqK3.mjs';
-import '@orpc/client';
-import '@orpc/contract';
-import '@orpc/shared';
-
+import { createProcedureClient } from "../procedure-client.mjs";
+import { DecoratedProcedure } from "../procedure-decorated.mjs";
 DecoratedProcedure.prototype.callable = function callable(...rest) {
-  const callable2 = createProcedureClient(this, ...rest);
-  callable2["~orpc"] = this["~orpc"];
-  return callable2;
+	const callable = createProcedureClient(this, ...rest);
+	callable["~orpc"] = this["~orpc"];
+	return callable;
 };

package/dist/helpers/base64url.d.mts

@@ -0,0 +1,31 @@
+/**
+* Encodes a Uint8Array to base64url format
+* Base64url is URL-safe and doesn't use padding
+*
+* @example
+* ```ts
+* const text = "Hello World"
+* const encoded = encodeBase64url(new TextEncoder().encode(text))
+* const decoded = decodeBase64url(encoded)
+* expect(new TextDecoder().decode(decoded)).toEqual(text)
+* ```
+*
+* @see {@link https://orpc.dev/docs/helpers/base64url | Base64Url Helpers}
+*/
+export declare function encodeBase64url(data: Uint8Array): string;
+/**
+* Decodes a base64url string to Uint8Array
+* Only accepts canonical, unpadded base64url (the form produced by `encodeBase64url`),
+* returns undefined for anything else, including padded or standard base64 input
+*
+* @example
+* ```ts
+* const text = "Hello World"
+* const encoded = encodeBase64url(new TextEncoder().encode(text))
+* const decoded = decodeBase64url(encoded)
+* expect(new TextDecoder().decode(decoded)).toEqual(text)
+* ```
+*
+* @see {@link https://orpc.dev/docs/helpers/base64url | Base64Url Helpers}
+*/
+export declare function decodeBase64url(base64url: string | undefined | null): Uint8Array<ArrayBuffer> | undefined;