@orpc/server 2.0.0-beta.5 → 2.0.0-beta.50

package/dist/builder-variants.d.ts

@@ -0,0 +1,226 @@
+import { BuilderDefinition } from "./builder.js";
+import { Context, MergedContext, MergedInitialContext } from "./context.js";
+import { Lazy } from "./lazy.js";
+import { Middleware } from "./middleware.js";
+import { DecoratedMiddleware } from "./middleware-decorated.js";
+import { ProcedureHandler } from "./procedure.js";
+import { DecoratedProcedure } from "./procedure-decorated.js";
+import { Router } from "./router.js";
+import { AugmentedRouterWithMiddlewares } from "./router-utils.js";
+import { AnySchema, ErrorMap, InferSchemaInput, InferSchemaOutput, InitialInputSchema, InitialOutputSchema, MergedErrorMap, MergedSchema, MetaPlugin, ORPCErrorConstructorMap, Schema } from "@orpc/contract";
+import { IntersectPick } from "@orpc/shared";
+/**
+ * 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.d.ts

@@ -0,0 +1,126 @@
+import { BuilderWithInput, BuilderWithMiddlewares, BuilderWithOutput } from "./builder-variants.js";
+import { Context, MergedInitialContext } from "./context.js";
+import { Lazy } from "./lazy.js";
+import { Middleware } from "./middleware.js";
+import { DecoratedMiddleware } from "./middleware-decorated.js";
+import { OrderedMiddleware, ProcedureConfig, ProcedureHandler } from "./procedure.js";
+import { DecoratedProcedure } from "./procedure-decorated.js";
+import { AnyRouter } from "./router.js";
+import { AugmentedRouter } from "./router-utils.js";
+import { AnySchema, ErrorMap, InferSchemaInput, InferSchemaOutput, InitialInputSchema, InitialOutputSchema, MergedErrorMap, MetaPlugin, ORPCErrorConstructorMap, ProcedureContractDefinition, Schema } from "@orpc/contract";
+import { IntersectPick } from "@orpc/shared";
+/**
+ * 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.js

@@ -0,0 +1,200 @@
+import { Lazy } from "./lazy.js";
+import { decorateMiddleware } from "./middleware-decorated.js";
+import { DecoratedProcedure } from "./procedure-decorated.js";
+import { augmentRouter } from "./router-utils.js";
+import { getHiddenMetaPlugins, mergeErrorMap, resolveMetaPlugins } from "@orpc/contract";
+import { toArray } from "@orpc/shared";
+// src/builder.ts
+/**
+* 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}
+*/
+var Builder = class Builder {
+	"~orpc";
+	/**
+	* Private constructor to prevent direct instantiation.
+	* Use the static `create` method to initialize a new instance with a safe initial definition.
+	*/
+	"constructor"(definition) {
+		this["~orpc"] = definition;
+	}
+	/**
+	* 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"() {
+		return new Builder({
+			errorMap: {},
+			meta: {},
+			orderedMiddlewares: []
+		});
+	}
+	/**
+	* 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"() {
+		return this;
+	}
+	/**
+	* Overrides the procedure configuration, such as disabling runtime
+	* input/output validation.
+	*
+	* @see {@link https://orpc.dev/docs/recipes/validation-customization | Validation Customization}
+	*/
+	"$config"(config) {
+		return new Builder({
+			...this["~orpc"],
+			...config
+		});
+	}
+	/**
+	* Applies metadata plugins to procedures built from this builder.
+	*
+	* @see {@link https://orpc.dev/docs/metadata | Metadata}
+	*/
+	"meta"(...plugins) {
+		const [meta, metaPlugins] = resolveMetaPlugins(this["~orpc"].meta, this["~orpc"].metaPlugins, plugins);
+		return new Builder({
+			...this["~orpc"],
+			meta,
+			metaPlugins
+		});
+	}
+	/**
+	* 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"(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;
+	}
+	/**
+	* Applies a middleware that runs before the handler of every procedure
+	* built from this builder.
+	*
+	* @see {@link https://orpc.dev/docs/middleware | Middleware}
+	*/
+	"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;
+	}
+	/**
+	* 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"(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;
+	}
+	/**
+	* 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"(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;
+	}
+	/**
+	* 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"(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;
+	}
+	/**
+	* Defines the function that implements the procedure and completes the
+	* chain, returning a callable procedure.
+	*
+	* @see {@link https://orpc.dev/docs/procedure | Procedure}
+	*/
+	"handler"(handler) {
+		let procedure = new DecoratedProcedure({
+			...this["~orpc"],
+			handler
+		});
+		const plugins = getHiddenMetaPlugins(handler);
+		if (plugins) procedure = procedure.meta(...plugins);
+		return procedure;
+	}
+	/**
+	* 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"(router) {
+		return augmentRouter(router, {
+			...this["~orpc"],
+			middlewares: this["~orpc"].orderedMiddlewares.map(({ middleware }) => middleware)
+		});
+	}
+	/**
+	* 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"(loader) {
+		return new Lazy({
+			loader: async () => {
+				const { default: router } = await loader();
+				return { default: this.router(router) };
+			},
+			meta: this["~orpc"].meta,
+			metaPlugins: this["~orpc"].metaPlugins
+		});
+	}
+};
+/**
+* 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}
+*/
+const os = /* @__PURE__ */ Builder.create();
+export { Builder, os };

package/dist/constants.d.ts

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

package/dist/constants.js

@@ -0,0 +1,4 @@
+// src/constants.ts
+const DEFAULT_SUCCESS_STATUS = 200;
+const DEFAULT_ERROR_STATUS = 400;
+export { DEFAULT_ERROR_STATUS, DEFAULT_SUCCESS_STATUS };

package/dist/context.d.ts

@@ -0,0 +1,6 @@
+import { 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/extensions/callable.d.ts

@@ -1,10 +1,11 @@
-import { AnyORPCError, ClientContext } from '@orpc/client';
-import { AnySchema, ErrorMap } from '@orpc/contract';
-import { MaybeOptionalOptions } from '@orpc/shared';
-import { C as Context, P as ProcedureClientOptions, a as Procedure, b as ProcedureClient } from '../shared/server.BL22TloH.js';
-
-declare module "../index" {
-    interface DecoratedProcedure<TInitialContext extends Context, TInjectedContext extends Context, TInputSchema extends AnySchema, TOutputSchema extends AnySchema, TErrorMap extends ErrorMap, TReturnedError extends AnyORPCError> {
-        callable<TClientContext extends ClientContext>(...rest: MaybeOptionalOptions<ProcedureClientOptions<TInitialContext, TOutputSchema, TErrorMap, TReturnedError, TClientContext>>): Procedure<TInitialContext, TInjectedContext, TInputSchema, TOutputSchema, TErrorMap, TReturnedError> & ProcedureClient<TClientContext, TInputSchema, TOutputSchema, TErrorMap, TReturnedError>;
-    }
-}
+import { Context } from "../context.js";
+import { Procedure } from "../procedure.js";
+import { ProcedureClient, ProcedureClientOptions } from "../procedure-client.js";
+import { AnySchema, ErrorMap } from "@orpc/contract";
+import { MaybeOptionalOptions } from "@orpc/shared";
+import { ClientContext } from "@orpc/client";
+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.js

@@ -0,0 +1,8 @@
+import { createProcedureClient } from "../procedure-client.js";
+import { DecoratedProcedure } from "../procedure-decorated.js";
+// src/extensions/callable.ts
+DecoratedProcedure.prototype.callable = function callable(...rest) {
+	const callable = createProcedureClient(this, ...rest);
+	callable["~orpc"] = this["~orpc"];
+	return callable;
+};

package/dist/helpers/base64url.d.ts

@@ -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;