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

package/dist/implementer-router.js

@@ -0,0 +1,98 @@
+import { ProcedureImplementer } from "./implementer-procedure.js";
+import { Lazy } from "./lazy.js";
+import { decorateMiddleware } from "./middleware-decorated.js";
+import { Procedure } from "./procedure.js";
+import { withHiddenRouterContract } from "./router-hidden.js";
+import { augmentImplementedRouter } from "./router-utils.js";
+import { ProcedureContract } from "@orpc/contract";
+import { bindMethods, omit, setOwn } from "@orpc/shared";
+// src/implementer-router.ts
+var SharedRouterImplementer = class SharedRouterImplementer {
+	contract;
+	config;
+	middlewares;
+	constructor(contract, config, middlewares) {
+		this.contract = contract;
+		this.config = config;
+		this.middlewares = middlewares;
+	}
+	static create(contract, config, middlewares = []) {
+		return new SharedRouterImplementer(contract, config, middlewares);
+	}
+	use(middleware) {
+		return createRouterImplementerInternal(this.contract, this.config, [...this.middlewares, middleware]);
+	}
+	middleware(middleware) {
+		const allMiddlewares = [...this.middlewares, middleware];
+		let current = decorateMiddleware(allMiddlewares.shift());
+		for (const mid of allMiddlewares) current = current.use(mid);
+		return current;
+	}
+	router(router) {
+		if (this.middlewares.length) router = augmentImplementedRouter(router, {
+			...this.config,
+			middlewares: this.middlewares
+		});
+		return withHiddenRouterContract(router, this.contract);
+	}
+	lazy(loader) {
+		return new Lazy({
+			loader: async () => {
+				const { default: router } = await loader();
+				return { default: this.router(router) };
+			},
+			meta: {}
+		});
+	}
+};
+function createRouterImplementer(contract, config) {
+	return createRouterImplementerInternal(toPlainRouterContract(contract), config, []);
+}
+/**
+* A normal router can be used as a contract (e.g. for mocking), but its procedures carry a handler,
+* middlewares and config. Kept as is, unimplemented procedures would pass as procedures, their config
+* would override the config passed to `implement`, and handlers serving the hidden contract would run
+* the contract's procedures instead of the actual implementation.
+*
+* Rebuilds the contract with every procedure turned into a plain {@link ProcedureContract}
+* (without `handler`, `orderedMiddlewares` and procedure config), copying only the routers that contain one,
+* so contract-first contracts are returned as is.
+*/
+function toPlainRouterContract(contract) {
+	if (contract instanceof ProcedureContract) {
+		if (!(contract instanceof Procedure)) return contract;
+		return new ProcedureContract(omit(contract["~orpc"], [
+			"handler",
+			"orderedMiddlewares",
+			"disableInputValidation",
+			"disableOutputValidation"
+		]));
+	}
+	let copied;
+	for (const [key, child] of Object.entries(contract)) {
+		const plainChild = toPlainRouterContract(child);
+		if (plainChild !== child) {
+			copied ??= { ...contract };
+			copied[key] = plainChild;
+		}
+	}
+	return copied ?? contract;
+}
+function createRouterImplementerInternal(contract, config, middlewares) {
+	if (contract instanceof ProcedureContract) return new ProcedureImplementer({
+		...config,
+		...contract["~orpc"],
+		orderedMiddlewares: middlewares.map((middleware) => ({ middleware }))
+	});
+	const implementer = {};
+	for (const [key, child] of Object.entries(contract)) setOwn(implementer, key, createRouterImplementerInternal(child, config, middlewares));
+	const shared = bindMethods(SharedRouterImplementer.create(contract, config, middlewares));
+	for (const [key, method] of Object.entries(shared)) if (Object.hasOwn(implementer, key)) {
+		const child = implementer[key];
+		implementer[key] = new Proxy(method, { get(_, p) {
+			return Reflect.get(child, p);
+		} });
+	} else implementer[key] = method;
+	return implementer;
+}
+export { SharedRouterImplementer, createRouterImplementer };

package/dist/implementer.d.ts

@@ -0,0 +1,16 @@
+import { DefaultInitialContext } from "./builder.js";
+import { Context } from "./context.js";
+import { RouterImplementer } from "./implementer-router.js";
+import { ProcedureConfig } from "./procedure.js";
+import { RouterContract } from "@orpc/contract";
+export type Implementer<TContract extends RouterContract, TInitialContext extends Context> = {
+  $context<T extends Context = DefaultInitialContext>(): Implementer<TContract, T & object>;
+  $config(config: ProcedureConfig): Implementer<TContract, TInitialContext>;
+} & RouterImplementer<TContract, TInitialContext>;
+/**
+ * Turns a contract into an implementer, used to implement the contract's
+ * procedures, routers, and middleware with full type safety.
+ *
+ * @see {@link https://orpc.dev/docs/contract/implementation#implementer | Contract Implementation - Implementer}
+ */
+export declare function implement<TContract extends RouterContract, TInitialContext extends Context = DefaultInitialContext>(contract: TContract, config?: ProcedureConfig): Implementer<TContract, TInitialContext & object>;

package/dist/implementer.js

@@ -0,0 +1,30 @@
+import { createRouterImplementer } from "./implementer-router.js";
+import { isNonPrimitive } from "@orpc/shared";
+// src/implementer.ts
+/**
+* Turns a contract into an implementer, used to implement the contract's
+* procedures, routers, and middleware with full type safety.
+*
+* @see {@link https://orpc.dev/docs/contract/implementation#implementer | Contract Implementation - Implementer}
+*/
+function implement(contract, config = {}) {
+	const routerImplementer = createRouterImplementer(contract, config);
+	const implementer = new Proxy(routerImplementer, { get(_, p) {
+		let method;
+		if (p === "$context") method = () => implementer;
+		else if (p === "$config") method = (incoming) => implement(contract, {
+			...config,
+			...incoming
+		});
+		const value = Reflect.get(routerImplementer, p);
+		if (method) {
+			if (!isNonPrimitive(value)) return method;
+			return new Proxy(method, { get(_, p) {
+				return Reflect.get(value, p);
+			} });
+		}
+		return value;
+	} });
+	return implementer;
+}
+export { implement };

package/dist/index.d.ts

@@ -1,196 +1,22 @@
-import { AnyORPCError, ClientOptions, ClientContext } from '@orpc/client';
-export { AnyORPCError, AnyORPCErrorJSON, COMMON_ERROR_STATUS_MAP, Client, ClientContext, ClientOptions, ClientRest, FriendlyClientOptions, ORPCError, ORPCErrorCode, ORPCErrorJSON, ORPCErrorOptions, RPCJsonSerialization, RPCJsonSerializationMeta, RPCJsonSerializer, RPCJsonSerializerHandler, RPCJsonSerializerOptions, RPCSerializer, RPCSerializerOptions, RPCSerializerSerializeOptions, SafeResult, cloneORPCError, isDefinedError, isInferableError, safe, toORPCError } from '@orpc/client';
-import { ErrorMap, MergedErrorMap, AnySchema, MetaPlugin, InferSchemaOutput, InferSchemaInput, AugmentContractRouterOptions, RouterContract, AnyProcedureContract, InitialInputSchema, InitialOutputSchema, MergedSchema, Schema, ProcedureContractDefinition, ProcedureContract, InferRouterContractErrorMap, ORPCErrorFromErrorMap } from '@orpc/contract';
-export { AnyMetaPlugin, AnySchema, ErrorMap, ErrorMapItem, InferSchemaInput, InferSchemaOutput, MergedErrorMap, Meta, MetaPlugin, MetaPluginDefinition, ORPCErrorFromErrorMap, ProcedureContract, ProcedureContractDefinition, RouterContract, Schema, ValidationError, defineMeta, eventIterator, reconcileORPCError, type } from '@orpc/contract';
-import { IntersectPick, Promisable, Public, PromiseWithError, ThrowableError, MaybeOptionalOptions } from '@orpc/shared';
-export { AsyncCleanupFn, AsyncIteratorClass, AsyncIteratorClassNextFn, MaybeOptionalOptions, PromiseWithError, Registry, ThrowableError, asyncIteratorToStream as eventIteratorToStream, asyncIteratorToUnproxiedDataStream as eventIteratorToUnproxiedDataStream, onError, onFinish, onStart, onSuccess, streamToAsyncIteratorClass as streamToEventIterator } from '@orpc/shared';
-import { C as Context, d as Middleware, M as MergedContext, e as MergedInitialContext, a as Procedure, f as AnyMiddleware, g as Lazy, A as AnyProcedure, L as Lazyable, h as ProcedureHandler, O as ORPCErrorConstructorMap, i as OrderedMiddleware, P as ProcedureClientOptions, b as ProcedureClient } from './shared/server.BL22TloH.js';
-export { j as LazyDefinition, k as MiddlewareDefinition, l as MiddlewareDone, m as MiddlewareDoneOptions, n as MiddlewareNext, o as MiddlewareNextOptions, p as MiddlewareOptions, q as MiddlewareResult, r as ORPCErrorConstructorMapItem, s as ORPCErrorConstructorMapItemOptions, c as ProcedureClientInterceptor, t as ProcedureClientInterceptorOptions, u as ProcedureDefinition, v as ProcedureHandlerOptions, w as createORPCErrorConstructorMap, x as createProcedureClient, y as unlazy } from './shared/server.BL22TloH.js';
-import { A as AnyRouter, R as Router, C as ContractedRouter, I as InferRouterInitialContext } from './shared/server.Pa0F03f_.js';
-export { a as InferRouterError, b as InferRouterErrors, c as InferRouterFinalContexts, d as InferRouterInitialContexts, e as InferRouterInputs, f as InferRouterOutputs } from './shared/server.Pa0F03f_.js';
-export { ErrorEvent, EventMeta, getEventMeta, unwrapEvent, withEventMeta } from '@standardserver/core';
-
-interface DecoratedMiddleware<TInContext extends Context, TOutContext extends Context, TInput, TOutput, TErrorMap extends ErrorMap> extends Middleware<TInContext, TOutContext, TInput, TOutput, TErrorMap> {
-    adaptInput<T>(adapt: (input: T) => TInput): DecoratedMiddleware<TInContext, TOutContext, T, TOutput, TErrorMap>;
-    errors<T extends ErrorMap>(errors: T): DecoratedMiddleware<TInContext, TOutContext, TInput, TOutput, MergedErrorMap<TErrorMap, T>>;
-    use<$OutContext extends IntersectPick<MergedContext<TInContext, TOutContext>, $OutContext>, $Input extends TInput, $InContext extends Context = MergedContext<TInContext, TOutContext>, $ErrorMap extends ErrorMap = TErrorMap>(middleware: Middleware<$InContext | MergedContext<TInContext, TOutContext>, $OutContext, $Input, TOutput, $ErrorMap>): DecoratedMiddleware<MergedInitialContext<TInContext, TOutContext, $InContext>, MergedContext<TOutContext, $OutContext>, $Input, TOutput, MergedErrorMap<$ErrorMap, TErrorMap>>;
-}
-declare function decorateMiddleware<TInContext extends Context, TOutContext extends Context, TInput, TOutput, TErrorMap extends ErrorMap>(middleware: Middleware<TInContext, TOutContext, TInput, TOutput, TErrorMap>): DecoratedMiddleware<TInContext, TOutContext, TInput, TOutput, TErrorMap>;
-
-declare class DecoratedProcedure<TInitialContext extends Context, TInjectedContext extends Context, TInputSchema extends AnySchema, TOutputSchema extends AnySchema, TErrorMap extends ErrorMap, TReturnedError extends AnyORPCError> extends Procedure<TInitialContext, TInjectedContext, TInputSchema, TOutputSchema, TErrorMap, TReturnedError> {
-    meta(...plugins: MetaPlugin<TInputSchema, TOutputSchema, TErrorMap>[]): DecoratedProcedure<TInitialContext, TInjectedContext, TInputSchema, TOutputSchema, TErrorMap, TReturnedError>;
-    errors<T extends ErrorMap>(errors: T): DecoratedProcedure<TInitialContext, TInjectedContext, TInputSchema, TOutputSchema, MergedErrorMap<TErrorMap, T>, TReturnedError>;
-    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>): DecoratedProcedure<MergedInitialContext<TInitialContext, TInjectedContext, $InContext>, MergedContext<TInjectedContext, $OutContext>, TInputSchema, TOutputSchema, MergedErrorMap<$ErrorMap, TErrorMap>, TReturnedError>;
-}
-
-type AugmentedRouter<T extends AnyRouter, TErrorMap extends ErrorMap> = T extends Procedure<infer $InitialContext, infer $CurrentContext, infer $InputSchema, infer $OutputSchema, infer $ErrorMap, infer $ReturnedORPCError> ? Procedure<$InitialContext, $CurrentContext, $InputSchema, $OutputSchema, MergedErrorMap<TErrorMap, $ErrorMap>, $ReturnedORPCError> : {
-    [K in keyof T]: T[K] extends Lazy<infer $ extends AnyRouter> ? Lazy<AugmentedRouter<$, TErrorMap>> : T[K] extends AnyRouter ? AugmentedRouter<T[K], TErrorMap> : never;
-};
-type AugmentedRouterWithMiddlewares<T extends AnyRouter, TInitialContext extends Context, TInjectedContext extends Context, TErrorMap extends ErrorMap> = T extends Procedure<infer $InitialContext, infer $CurrentContext, infer $InputSchema, infer $OutputSchema, infer $ErrorMap, infer $ReturnedORPCError> ? Procedure<MergedInitialContext<TInitialContext, TInjectedContext, $InitialContext>, $CurrentContext, $InputSchema, $OutputSchema, MergedErrorMap<TErrorMap, $ErrorMap>, $ReturnedORPCError> : {
-    [K in keyof T]: T[K] extends Lazy<infer $ extends AnyRouter> ? Lazy<AugmentedRouterWithMiddlewares<$, TInitialContext, TInjectedContext, TErrorMap>> : T[K] extends AnyRouter ? AugmentedRouterWithMiddlewares<T[K], TInitialContext, TInjectedContext, TErrorMap> : never;
-};
-interface AugmentRouterOptions<TErrorMap extends ErrorMap> extends AugmentContractRouterOptions<TErrorMap> {
-    middlewares: AnyMiddleware[];
-}
-declare function augmentRouter<T extends AnyRouter, TInitialContext extends Context, TCurrentContext extends Context, TErrorMap extends ErrorMap>(router: T, options: AugmentRouterOptions<TErrorMap>): AugmentedRouter<T, TErrorMap> | AugmentedRouterWithMiddlewares<T, TInitialContext, TCurrentContext, TErrorMap>;
-interface AugmentImplementedRouterOptions {
-    middlewares: AnyMiddleware[];
-}
-declare function augmentImplementedRouter<T extends AnyRouter, TInitialContext extends Context, TCurrentContext extends Context>(router: T, options: AugmentImplementedRouterOptions): AugmentedRouter<T, object> | AugmentedRouterWithMiddlewares<T, TInitialContext, TCurrentContext, object>;
-declare function getRouter<T extends Lazyable<AnyRouter | undefined>>(router: T, path: readonly string[]): T extends Lazy<any> ? Lazy<AnyRouter | undefined> : Lazyable<AnyRouter | undefined>;
-interface WalkProcedureContractsLazyResult {
-    router: Lazy<AnyRouter>;
-    path: string[];
-}
-declare function walkProcedureContractsSync(router: RouterContract | AnyRouter, callback: (contract: AnyProcedureContract | AnyProcedure, path: string[]) => void, path?: string[]): WalkProcedureContractsLazyResult[];
-declare function walkProcedureContractsAsync(router: RouterContract | AnyRouter, callback: (contract: AnyProcedureContract | AnyProcedure, path: string[]) => Promisable<void>, path?: string[]): Promise<void>;
-type UnlaziedRouter<T extends AnyRouter> = T extends AnyProcedure ? T : {
-    [K in keyof T]: T[K] extends Lazyable<infer U extends AnyRouter> ? UnlaziedRouter<U> : never;
-};
-declare function unlazyRouter<T extends AnyRouter>(router: T): Promise<UnlaziedRouter<T>>;
-
-interface BuilderWithMiddlewares<TInitialContext extends Context, TInjectedContext extends Context, TErrorMap extends ErrorMap> {
-    '~orpc': BuilderDefinition<InitialInputSchema, InitialOutputSchema, TErrorMap>;
-    'meta'(...plugins: MetaPlugin<InitialInputSchema, InitialOutputSchema, TErrorMap>[]): BuilderWithMiddlewares<TInitialContext, TInjectedContext, TErrorMap>;
-    'errors'<T extends ErrorMap>(errors: T): BuilderWithMiddlewares<TInitialContext, TInjectedContext, MergedErrorMap<TErrorMap, T>>;
-    '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>>;
-    '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>;
-    'input'<T extends AnySchema>(schema: T): BuilderWithInput<TInitialContext, TInjectedContext, T, TErrorMap>;
-    'output'<T extends AnySchema>(schema: T): BuilderWithOutput<TInitialContext, TInjectedContext, T, TErrorMap>;
-    'handler'<T>(handler: ProcedureHandler<MergedContext<TInitialContext, TInjectedContext>, InferSchemaOutput<InitialInputSchema>, T, ORPCErrorConstructorMap<TErrorMap>>): DecoratedProcedure<TInitialContext, TInjectedContext, InitialInputSchema, Schema<Exclude<T, AnyORPCError>>, TErrorMap, Extract<T, AnyORPCError>>;
-    'router'<T extends Router<MergedContext<TInitialContext, TInjectedContext>>>(router: T): AugmentedRouterWithMiddlewares<T, TInitialContext, TInjectedContext, TErrorMap>;
-    'lazy'<T extends Router<MergedContext<TInitialContext, TInjectedContext>>>(loader: () => Promise<{
-        default: T;
-    }>): Lazy<AugmentedRouterWithMiddlewares<T, TInitialContext, TInjectedContext, TErrorMap>>;
-}
-interface BuilderWithInput<TInitialContext extends Context, TInjectedContext extends Context, TInputSchema extends AnySchema, TErrorMap extends ErrorMap> {
-    '~orpc': BuilderDefinition<TInputSchema, InitialOutputSchema, TErrorMap>;
-    'meta'(...plugins: MetaPlugin<TInputSchema, InitialOutputSchema, TErrorMap>[]): BuilderWithInput<TInitialContext, TInjectedContext, TInputSchema, TErrorMap>;
-    'errors'<T extends ErrorMap>(errors: T): BuilderWithInput<TInitialContext, TInjectedContext, TInputSchema, MergedErrorMap<TErrorMap, T>>;
-    '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>>;
-    'input'<T extends AnySchema>(schema: T): BuilderWithInput<TInitialContext, TInjectedContext, MergedSchema<T, TInputSchema>, TErrorMap>;
-    'output'<T extends AnySchema>(schema: T): BuilderWithInputOutput<TInitialContext, TInjectedContext, TInputSchema, T, TErrorMap>;
-    'handler'<T>(handler: ProcedureHandler<MergedContext<TInitialContext, TInjectedContext>, InferSchemaOutput<TInputSchema>, T, ORPCErrorConstructorMap<TErrorMap>>): DecoratedProcedure<TInitialContext, TInjectedContext, TInputSchema, Schema<Exclude<T, AnyORPCError>>, TErrorMap, Extract<T, AnyORPCError>>;
-}
-interface BuilderWithOutput<TInitialContext extends Context, TInjectedContext extends Context, TOutputSchema extends AnySchema, TErrorMap extends ErrorMap> {
-    '~orpc': BuilderDefinition<InitialInputSchema, TOutputSchema, TErrorMap>;
-    'meta'(...plugins: MetaPlugin<InitialInputSchema, TOutputSchema, TErrorMap>[]): BuilderWithOutput<TInitialContext, TInjectedContext, TOutputSchema, TErrorMap>;
-    'errors'<T extends ErrorMap>(errors: T): BuilderWithOutput<TInitialContext, TInjectedContext, TOutputSchema, MergedErrorMap<TErrorMap, T>>;
-    '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>>;
-    'input'<T extends AnySchema>(schema: T): BuilderWithInputOutput<TInitialContext, TInjectedContext, T, TOutputSchema, TErrorMap>;
-    'output'<T extends AnySchema>(schema: T): BuilderWithOutput<TInitialContext, TInjectedContext, MergedSchema<T, TOutputSchema>, TErrorMap>;
-    'handler'<T extends InferSchemaInput<TOutputSchema> | AnyORPCError>(handler: ProcedureHandler<MergedContext<TInitialContext, TInjectedContext>, InferSchemaOutput<InitialInputSchema>, T, ORPCErrorConstructorMap<TErrorMap>>): DecoratedProcedure<TInitialContext, TInjectedContext, InitialInputSchema, TOutputSchema, TErrorMap, Extract<T, AnyORPCError>>;
-}
-interface BuilderWithInputOutput<TInitialContext extends Context, TInjectedContext extends Context, TInputSchema extends AnySchema, TOutputSchema extends AnySchema, TErrorMap extends ErrorMap> {
-    '~orpc': BuilderDefinition<TInputSchema, TOutputSchema, TErrorMap>;
-    'meta'(...plugins: MetaPlugin<TInputSchema, TOutputSchema, TErrorMap>[]): BuilderWithInputOutput<TInitialContext, TInjectedContext, TInputSchema, TOutputSchema, TErrorMap>;
-    'errors'<T extends ErrorMap>(errors: T): BuilderWithInputOutput<TInitialContext, TInjectedContext, TInputSchema, TOutputSchema, MergedErrorMap<TErrorMap, T>>;
-    '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>>;
-    'input'<T extends AnySchema>(schema: T): BuilderWithInputOutput<TInitialContext, TInjectedContext, MergedSchema<T, TInputSchema>, TOutputSchema, TErrorMap>;
-    'output'<T extends AnySchema>(schema: T): BuilderWithInputOutput<TInitialContext, TInjectedContext, TInputSchema, MergedSchema<T, TOutputSchema>, TErrorMap>;
-    'handler'<T extends InferSchemaInput<TOutputSchema> | AnyORPCError>(handler: ProcedureHandler<MergedContext<TInitialContext, TInjectedContext>, InferSchemaOutput<TInputSchema>, T, ORPCErrorConstructorMap<TErrorMap>>): DecoratedProcedure<TInitialContext, TInjectedContext, TInputSchema, TOutputSchema, TErrorMap, Extract<T, AnyORPCError>>;
-}
-
-interface DefaultInitialContext {
-}
-interface BuilderDefinition<TInputSchema extends AnySchema, TInjectedContext extends AnySchema, TErrorMap extends ErrorMap> extends ProcedureContractDefinition<TInputSchema, TInjectedContext, TErrorMap> {
-    orderedMiddlewares: OrderedMiddleware[];
-}
-declare class Builder<TInitialContext extends Context, TErrorMap extends ErrorMap> {
-    '~orpc': BuilderDefinition<InitialInputSchema, InitialOutputSchema, TErrorMap>;
-    private constructor();
-    static create<T extends Context = DefaultInitialContext>(): Builder<T & object, Record<never, never>>;
-    $context<T extends Context = DefaultInitialContext>(): Builder<T & object, TErrorMap>;
-    meta(...plugins: MetaPlugin<InitialInputSchema, InitialOutputSchema, TErrorMap>[]): Builder<TInitialContext, TErrorMap>;
-    errors<U extends ErrorMap>(errors: U): Builder<TInitialContext, MergedErrorMap<TErrorMap, U>>;
-    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>>;
-    middleware<$OutContext extends IntersectPick<TInitialContext, $OutContext>, $Input, $Output = any>(middleware: Middleware<TInitialContext, $OutContext, $Input, $Output, TErrorMap>): DecoratedMiddleware<TInitialContext, $OutContext, $Input, $Output, TErrorMap>;
-    input<$ extends AnySchema>(schema: $): BuilderWithInput<TInitialContext, object, $, TErrorMap>;
-    output<$ extends AnySchema>(schema: $): BuilderWithOutput<TInitialContext, object, $, TErrorMap>;
-    handler<T>(handler: ProcedureHandler<TInitialContext, InferSchemaOutput<InitialInputSchema>, T, ORPCErrorConstructorMap<TErrorMap>>): DecoratedProcedure<TInitialContext, object, InitialInputSchema, Schema<Exclude<T, AnyORPCError>>, TErrorMap, Extract<T, AnyORPCError>>;
-    router<T extends AnyRouter>(router: T): AugmentedRouter<T, TErrorMap>;
-    lazy<T extends AnyRouter>(loader: () => Promise<{
-        default: T;
-    }>): Lazy<AugmentedRouter<T, TErrorMap>>;
-}
-declare const os: Builder<DefaultInitialContext & object, Record<never, never>>;
-
-declare const DEFAULT_SUCCESS_STATUS = 200;
-declare const DEFAULT_ERROR_STATUS = 500;
-
-declare class ProcedureImplementer<TInitialContext extends Context, TInjectedContext extends Context, TInputSchema extends AnySchema, TOutputSchema extends AnySchema, TErrorMap extends ErrorMap> {
-    '~orpc': BuilderDefinition<TInputSchema, TOutputSchema, TErrorMap>;
-    constructor(definition: BuilderDefinition<TInputSchema, TOutputSchema, TErrorMap>);
-    '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>): ProcedureImplementer<MergedInitialContext<TInitialContext, TInjectedContext, $InContext>, MergedContext<TInjectedContext, $OutContext>, TInputSchema, TOutputSchema, TErrorMap>;
-    'handler'(handler: ProcedureHandler<MergedContext<TInitialContext, TInjectedContext>, InferSchemaOutput<TInputSchema>, AnyORPCError | InferSchemaInput<TOutputSchema>, ORPCErrorConstructorMap<TErrorMap>>): ImplementedProcedure<TInitialContext, TInjectedContext, TInputSchema, TOutputSchema, TErrorMap>;
-}
-declare class ImplementedProcedure<TInitialContext extends Context, TInjectedContext extends Context, TInputSchema extends AnySchema, TOutputSchema extends AnySchema, TErrorMap extends ErrorMap> extends Procedure<TInitialContext, TInjectedContext, TInputSchema, TOutputSchema, TErrorMap, never> {
-    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>): ImplementedProcedure<MergedInitialContext<TInitialContext, TInjectedContext, $InContext>, MergedContext<TInjectedContext, $OutContext>, TInputSchema, TOutputSchema, TErrorMap>;
-}
-
-declare class SharedRouterImplementer<TContract extends RouterContract, TInitialContext extends Context> {
-    private readonly contract;
-    private readonly middlewares;
-    private constructor();
-    static create<TContract extends RouterContract, TInitialContext extends Context>(contract: TContract): SharedRouterImplementer<TContract, TInitialContext>;
-    static create<TContract extends RouterContract, TInitialContext extends Context, TInjectedContext extends Context>(contract: TContract, middlewares: AnyMiddleware[]): SharedRouterImplementerWithMiddlewares<TContract, TInitialContext, TInjectedContext>;
-    use<$OutContext extends IntersectPick<TInitialContext, $OutContext>, $InContext extends Context = TInitialContext, $ErrorMap extends ErrorMap = InferRouterContractErrorMap<TContract>>(middleware: Middleware<$InContext | TInitialContext, $OutContext, unknown, unknown, $ErrorMap>): RouterImplementerWithMiddlewares<TContract, MergedInitialContext<TInitialContext, object, $InContext>, $OutContext>;
-    middleware<$OutContext extends IntersectPick<TInitialContext, $OutContext>, $Input, $InContext extends Context = TInitialContext, $Output = any>(middleware: Middleware<$InContext | TInitialContext, $OutContext, $Input, $Output, InferRouterContractErrorMap<TContract>>): DecoratedMiddleware<MergedInitialContext<TInitialContext, object, $InContext>, $OutContext, $Input, $Output, object>;
-    router<T extends ContractedRouter<TContract, any>>(router: T): T;
-    lazy<T extends ContractedRouter<TContract, any>>(loader: () => Promise<{
-        default: T;
-    }>): Lazy<T>;
-}
-interface SharedRouterImplementerWithMiddlewares<TContract extends RouterContract, TInitialContext extends Context, TInjectedContext extends Context> {
-    use<$OutContext extends IntersectPick<MergedContext<TInitialContext, TInjectedContext>, $OutContext>, $InContext extends Context = MergedContext<TInitialContext, TInjectedContext>, $ErrorMap extends ErrorMap = InferRouterContractErrorMap<TContract>>(middleware: Middleware<$InContext | MergedContext<TInitialContext, TInjectedContext>, $OutContext, unknown, unknown, $ErrorMap>): RouterImplementerWithMiddlewares<TContract, MergedInitialContext<TInitialContext, TInjectedContext, $InContext>, MergedContext<TInjectedContext, $OutContext>>;
-    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, InferRouterContractErrorMap<TContract>>): DecoratedMiddleware<MergedInitialContext<TInitialContext, TInjectedContext, $InContext>, MergedContext<TInjectedContext, $OutContext>, $Input, $Output, object>;
-    router<T extends ContractedRouter<TContract, MergedContext<TInitialContext, TInjectedContext>>>(router: T): AugmentedRouterWithMiddlewares<T, TInitialContext, TInjectedContext, object>;
-    lazy<T extends ContractedRouter<TContract, any>>(loader: () => Promise<{
-        default: T;
-    }>): Lazy<AugmentedRouterWithMiddlewares<T, TInitialContext, TInjectedContext, object>>;
-}
-type RouterImplementer<TContract extends RouterContract, TInitialContext extends Context> = TContract extends ProcedureContract<infer $InputSchema, infer $OutputSchema, infer $ErrorMap> ? ProcedureImplementer<TInitialContext, object, $InputSchema, $OutputSchema, $ErrorMap> : Public<SharedRouterImplementer<TContract, TInitialContext>> & {
-    [K in keyof TContract]: TContract[K] extends RouterContract ? RouterImplementer<TContract[K], TInitialContext> : never;
-};
-type RouterImplementerWithMiddlewares<TContract extends RouterContract, TInitialContext extends Context, TInjectedContext extends Context> = TContract extends ProcedureContract<infer $InputSchema, infer $OutputSchema, infer $ErrorMap> ? ProcedureImplementer<TInitialContext, TInjectedContext, $InputSchema, $OutputSchema, $ErrorMap> : SharedRouterImplementerWithMiddlewares<TContract, TInitialContext, TInjectedContext> & {
-    [K in keyof TContract]: TContract[K] extends RouterContract ? RouterImplementerWithMiddlewares<TContract[K], TInitialContext, TInjectedContext> : never;
-};
-declare function createRouterImplementer<TContract extends RouterContract, TInitialContext extends Context>(contract: TContract): RouterImplementer<TContract, TInitialContext>;
-
-type Implementer<TContract extends RouterContract, TInitialContext extends Context> = {
-    $context<T extends Context = DefaultInitialContext>(): Implementer<TContract, T & object>;
-} & RouterImplementer<TContract, TInitialContext>;
-declare function implement<TContract extends RouterContract, TInitialContext extends Context = DefaultInitialContext>(contract: TContract): Implementer<TContract, TInitialContext & object>;
-
-declare function createGuardedProcedureLazy(lazy: Lazy<unknown>): Lazy<AnyProcedure>;
-/**
- * Create a new procedure that ensure the contract is applied to the procedure.
- *
- * .input/.output/.handler mismatches are already caught by the `implementer.router`,
- * but .errors (in case implemented procedure error map is more than enough) and .meta cannot be
- * validated that way - so they must be overridden here to ensure the client always sees what the contract defines.
- */
-declare function createContractProcedure<TInitialContext extends Context, TInjectedContext extends Context, TInputSchema extends AnySchema, TOutputSchema extends AnySchema, TErrorMap extends ErrorMap>(procedure: Procedure<TInitialContext, TInjectedContext, TInputSchema, TOutputSchema, any, any>, contract: ProcedureContract<any, any, TErrorMap>): Procedure<TInitialContext, TInjectedContext, TInputSchema, TOutputSchema, TErrorMap, never>;
-type CallOptions<TInitialContext extends Context, TOutputSchema extends AnySchema, TErrorMap extends ErrorMap, TReturnedError extends AnyORPCError> = ProcedureClientOptions<TInitialContext, TOutputSchema, TErrorMap, TReturnedError, object> & Omit<ClientOptions<object>, 'context'>;
-type CallRest<TInitialContext extends Context, TInputSchema extends AnySchema, TOutputSchema extends AnySchema, TErrorMap extends ErrorMap, TReturnedError extends AnyORPCError> = object extends CallOptions<TInitialContext, TOutputSchema, TErrorMap, TReturnedError> ? undefined extends InferSchemaInput<TInputSchema> ? [input?: InferSchemaInput<TInputSchema>, options?: CallOptions<TInitialContext, TOutputSchema, TErrorMap, TReturnedError>] : [input: InferSchemaInput<TInputSchema>, options?: CallOptions<TInitialContext, TOutputSchema, TErrorMap, TReturnedError>] : [input: InferSchemaInput<TInputSchema>, options: CallOptions<TInitialContext, TOutputSchema, TErrorMap, TReturnedError>];
-/**
- * Quickly call a procedure without creating a client.
- *
- * @example
- * ```ts
- * const output = await call(getting, 'input')
- * const output = await call(getting, 'input', { context: { db: 'postgres' } })
- * ```
- */
-declare function call<TInitialContext extends Context, TInputSchema extends AnySchema, TOutputSchema extends AnySchema, TErrorMap extends ErrorMap, TReturnedError extends AnyORPCError>(lazyableProcedure: Lazyable<Procedure<TInitialContext, any, TInputSchema, TOutputSchema, TErrorMap, TReturnedError>>, ...[input, options,]: CallRest<TInitialContext, TInputSchema, TOutputSchema, TErrorMap, TReturnedError>): PromiseWithError<InferSchemaOutput<TOutputSchema>, ORPCErrorFromErrorMap<TErrorMap> | TReturnedError | ThrowableError>;
-
-type RouterClient<TRouter extends AnyRouter, TClientContext extends ClientContext = object> = TRouter extends Procedure<any, any, infer $InputSchema, infer $OutputSchema, infer $ErrorMap, infer $ReturnedError> ? ProcedureClient<TClientContext, $InputSchema, $OutputSchema, $ErrorMap, $ReturnedError> : {
-    [K in keyof TRouter]: TRouter[K] extends Lazyable<infer U extends AnyRouter> ? RouterClient<U, TClientContext> : never;
-};
-declare function createRouterClient<T extends AnyRouter, TClientContext extends ClientContext = object>(router: Lazyable<T | undefined>, ...rest: MaybeOptionalOptions<ProcedureClientOptions<InferRouterInitialContext<T>, Schema<unknown>, ErrorMap, any, TClientContext>>): RouterClient<T, TClientContext>;
-
-declare function withHiddenRouterContract<T extends Lazyable<AnyRouter>>(router: T, contract: RouterContract): T;
-declare function getHiddenRouterContract(router: Lazyable<AnyRouter | RouterContract>): RouterContract | undefined;
-
-export { AnyMiddleware, AnyProcedure, AnyRouter, Builder, Context, ContractedRouter, DEFAULT_ERROR_STATUS, DEFAULT_SUCCESS_STATUS, DecoratedProcedure, ImplementedProcedure, InferRouterInitialContext, Lazy, Lazyable, MergedContext, MergedInitialContext, Middleware, ORPCErrorConstructorMap, OrderedMiddleware, Procedure, ProcedureClient, ProcedureClientOptions, ProcedureHandler, ProcedureImplementer, Router, SharedRouterImplementer, augmentImplementedRouter, augmentRouter, call, createContractProcedure, createGuardedProcedureLazy, createRouterClient, createRouterImplementer, decorateMiddleware, getHiddenRouterContract, getRouter, implement, os, unlazyRouter, walkProcedureContractsAsync, walkProcedureContractsSync, withHiddenRouterContract };
-export type { AugmentImplementedRouterOptions, AugmentRouterOptions, AugmentedRouter, AugmentedRouterWithMiddlewares, BuilderDefinition, BuilderWithInput, BuilderWithInputOutput, BuilderWithMiddlewares, BuilderWithOutput, CallOptions, CallRest, DecoratedMiddleware, DefaultInitialContext, Implementer, RouterClient, RouterImplementer, RouterImplementerWithMiddlewares, SharedRouterImplementerWithMiddlewares, UnlaziedRouter, WalkProcedureContractsLazyResult };
+import { Builder, BuilderDefinition, DefaultInitialContext, os } from "./builder.js";
+import { BuilderWithInput, BuilderWithInputOutput, BuilderWithMiddlewares, BuilderWithOutput } from "./builder-variants.js";
+import { DEFAULT_ERROR_STATUS, DEFAULT_SUCCESS_STATUS } from "./constants.js";
+import { Context, MergedContext, MergedInitialContext } from "./context.js";
+import { Implementer, implement } from "./implementer.js";
+import { ImplementedProcedure, ProcedureImplementer } from "./implementer-procedure.js";
+import { RouterImplementer, RouterImplementerWithMiddlewares, SharedRouterImplementer, SharedRouterImplementerWithMiddlewares } from "./implementer-router.js";
+import { Lazy, LazyDefinition, Lazyable, unlazy } from "./lazy.js";
+import { AnyMiddleware, Middleware, MiddlewareDefinition, MiddlewareDone, MiddlewareDoneOptions, MiddlewareNext, MiddlewareNextOptions, MiddlewareOptions, MiddlewareResult } from "./middleware.js";
+import { DecoratedMiddleware } from "./middleware-decorated.js";
+import { AnyProcedure, OrderedMiddleware, Procedure, ProcedureConfig, ProcedureDefinition, ProcedureHandler, ProcedureHandlerOptions } from "./procedure.js";
+import { ProcedureClient, ProcedureClientInterceptor, ProcedureClientInterceptorOptions, ProcedureClientOptions, createProcedureClient } from "./procedure-client.js";
+import { DecoratedProcedure } from "./procedure-decorated.js";
+import { CallOptions, CallRest, call } from "./procedure-utils.js";
+import { AnyRouter, ContractedRouter, InferRouterError, InferRouterErrors, InferRouterFinalContexts, InferRouterInitialContext, InferRouterInitialContexts, InferRouterInputs, InferRouterOutputs, Router } from "./router.js";
+import { RouterClient, createRouterClient } from "./router-client.js";
+import { AugmentedRouter, AugmentedRouterWithMiddlewares, UnlaziedRouter, WalkProcedureContractsLazyResult, getRouter, resolveContractProcedure, unlazyRouter, walkProcedureContractsAsync, walkProcedureContractsSync } from "./router-utils.js";
+import { AnyMetaPlugin, AnySchema, ErrorMap, ErrorMapItem, InferSchemaInput, InferSchemaOutput, InitialInputSchema, InitialOutputSchema, MergedErrorMap, MergedSchema, Meta, MetaPlugin, MetaPluginDefinition, ORPCErrorConstructorMap, ORPCErrorConstructorMapItem, ORPCErrorConstructorMapItemOptions, ORPCErrorFactory, ORPCErrorFactoryOptions, ORPCErrorFromErrorMap, ProcedureContract, ProcedureContractDefinition, RouterContract, Schema, ValidationError, asyncIteratorObject, defineMeta, error, eventIterator, type } from "@orpc/contract";
+import { AsyncCleanupFn, AsyncIteratorClass, AsyncIteratorClassNextFn, DistributiveOmit, IntersectPick, MaybeOptionalOptions, PromiseWithError, Public, Registry, ThrowableError, asyncIteratorToStream, asyncIteratorToStream as eventIteratorToStream, asyncIteratorToUnproxiedDataStream, asyncIteratorToUnproxiedDataStream as eventIteratorToUnproxiedDataStream, onAsyncIteratorObjectError, onError, onFinish, onReadableStreamError, onStart, onSuccess, streamToAsyncIteratorObject, streamToAsyncIteratorObject as streamToEventIterator } from "@orpc/shared";
+import { AnyORPCError, AnyORPCErrorJSON, COMMON_ERROR_STATUS_MAP, Client, ClientContext, ClientOptions, ClientRest, FriendlyClientOptions, ORPCError, ORPCErrorCode, ORPCErrorJSON, ORPCErrorOptions, RPCJsonSerialization, RPCJsonSerializationMeta, RPCJsonSerializer, RPCJsonSerializerHandler, RPCJsonSerializerOptions, RPCSerializer, RPCSerializerOptions, RPCSerializerSerializeOptions, SafeResult, isDefinedError, safe, toORPCError } from "@orpc/client";
+import { EventMeta, EventStreamErrorEvent, EventStreamErrorEvent as ErrorEvent, StandardBody, StandardBodyHint, StandardHeaders, StandardLazyRequest, StandardLazyResponse, StandardMethod, StandardRequest, StandardResponse, StandardUrl, getEventMeta, unwrapEvent, withEventMeta } from "@standard-server/core";
+export { type AnyMetaPlugin, AnyMiddleware, type AnyORPCError, type AnyORPCErrorJSON, AnyProcedure, AnyRouter, type AnySchema, type AsyncCleanupFn, AsyncIteratorClass, type AsyncIteratorClassNextFn, type AugmentedRouter, type AugmentedRouterWithMiddlewares, Builder, BuilderDefinition, BuilderWithInput, BuilderWithInputOutput, BuilderWithMiddlewares, BuilderWithOutput, COMMON_ERROR_STATUS_MAP, type CallOptions, type CallRest, type Client, type ClientContext, type ClientOptions, type ClientRest, Context, ContractedRouter, DEFAULT_ERROR_STATUS, DEFAULT_SUCCESS_STATUS, type DecoratedMiddleware, DecoratedProcedure, DefaultInitialContext, type DistributiveOmit, ErrorEvent, type ErrorMap, type ErrorMapItem, type EventMeta, EventStreamErrorEvent, type FriendlyClientOptions, ImplementedProcedure, Implementer, type InferRouterFinalContexts as InferRouterCurrentContexts, InferRouterError, InferRouterErrors, InferRouterFinalContexts, InferRouterInitialContext, InferRouterInitialContexts, InferRouterInputs, InferRouterOutputs, type InferSchemaInput, type InferSchemaOutput, type InitialInputSchema, type InitialOutputSchema, type IntersectPick, Lazy, LazyDefinition, Lazyable, type MaybeOptionalOptions, MergedContext, type MergedErrorMap, MergedInitialContext, type MergedSchema, type Meta, type MetaPlugin, type MetaPluginDefinition, Middleware, MiddlewareDefinition, MiddlewareDone, MiddlewareDoneOptions, MiddlewareNext, MiddlewareNextOptions, MiddlewareOptions, MiddlewareResult, ORPCError, type ORPCErrorCode, type ORPCErrorConstructorMap, type ORPCErrorConstructorMapItem, type ORPCErrorConstructorMapItemOptions, type ORPCErrorFactory, type ORPCErrorFactoryOptions, type ORPCErrorFromErrorMap, type ORPCErrorJSON, type ORPCErrorOptions, OrderedMiddleware, Procedure, ProcedureClient, ProcedureClientInterceptor, ProcedureClientInterceptorOptions, ProcedureClientOptions, ProcedureConfig, type ProcedureContract, type ProcedureContractDefinition, ProcedureDefinition, ProcedureHandler, ProcedureHandlerOptions, ProcedureImplementer, type PromiseWithError, type Public, type RPCJsonSerialization, type RPCJsonSerializationMeta, RPCJsonSerializer, type RPCJsonSerializerHandler, type RPCJsonSerializerOptions, RPCSerializer, type RPCSerializerOptions, type RPCSerializerSerializeOptions, type Registry, Router, RouterClient, type RouterContract, type RouterImplementer, type RouterImplementerWithMiddlewares, type SafeResult, type Schema, SharedRouterImplementer, type SharedRouterImplementerWithMiddlewares, type StandardBody, type StandardBodyHint, type StandardHeaders, type StandardLazyRequest, type StandardLazyResponse, type StandardMethod, type StandardRequest, type StandardResponse, type StandardUrl, type ThrowableError, type UnlaziedRouter, ValidationError, type WalkProcedureContractsLazyResult, asyncIteratorObject, asyncIteratorToStream, asyncIteratorToUnproxiedDataStream, call, createProcedureClient, createRouterClient, defineMeta, error, eventIterator, eventIteratorToStream, eventIteratorToUnproxiedDataStream, getEventMeta, getRouter, implement, isDefinedError, onAsyncIteratorObjectError, onError, onFinish, onReadableStreamError, onStart, onSuccess, os, resolveContractProcedure, safe, streamToAsyncIteratorObject, streamToEventIterator, toORPCError, type, unlazy, unlazyRouter, unwrapEvent, walkProcedureContractsAsync, walkProcedureContractsSync, withEventMeta };

package/dist/index.js

@@ -0,0 +1,16 @@
+export { Builder, os } from "./builder.js";
+export { DEFAULT_ERROR_STATUS, DEFAULT_SUCCESS_STATUS } from "./constants.js";
+export { implement } from "./implementer.js";
+export { ImplementedProcedure, ProcedureImplementer } from "./implementer-procedure.js";
+export { SharedRouterImplementer } from "./implementer-router.js";
+export { Lazy, unlazy } from "./lazy.js";
+export { Procedure } from "./procedure.js";
+export { createProcedureClient } from "./procedure-client.js";
+export { DecoratedProcedure } from "./procedure-decorated.js";
+export { call } from "./procedure-utils.js";
+export { createRouterClient } from "./router-client.js";
+export { getRouter, resolveContractProcedure, unlazyRouter, walkProcedureContractsAsync, walkProcedureContractsSync } from "./router-utils.js";
+export { ValidationError, asyncIteratorObject, defineMeta, error, eventIterator, type } from "@orpc/contract";
+export { AsyncIteratorClass, asyncIteratorToStream, asyncIteratorToStream as eventIteratorToStream, asyncIteratorToUnproxiedDataStream, asyncIteratorToUnproxiedDataStream as eventIteratorToUnproxiedDataStream, onAsyncIteratorObjectError, onError, onFinish, onReadableStreamError, onStart, onSuccess, streamToAsyncIteratorObject, streamToAsyncIteratorObject as streamToEventIterator } from "@orpc/shared";
+export { COMMON_ERROR_STATUS_MAP, ORPCError, RPCJsonSerializer, RPCSerializer, isDefinedError, safe, toORPCError } from "@orpc/client";
+export { EventStreamErrorEvent, EventStreamErrorEvent as ErrorEvent, getEventMeta, unwrapEvent, withEventMeta } from "@standard-server/core";

package/dist/lazy.d.ts

@@ -0,0 +1,20 @@
+import { AnyMetaPlugin, Meta } from "@orpc/contract";
+export interface LazyDefinition<T> {
+  meta: Meta;
+  metaPlugins?: AnyMetaPlugin[] | undefined;
+  loader: () => Promise<{
+    default: T;
+  }>;
+}
+export declare class Lazy<T> {
+  "~orpc": LazyDefinition<T>;
+  "constructor"(def: LazyDefinition<T>);
+  /**
+   * Checks if the given instance satisfies the {@link Lazy} class/interface.
+   */
+  static [Symbol.hasInstance](instance: unknown): boolean;
+}
+export type Lazyable<T> = T | Lazy<T>;
+export declare function unlazy<T extends Lazyable<any>>(maybeLazy: T): Promise<{
+  default: T extends Lazy<infer U> ? U : T;
+}>;

package/dist/lazy.js

@@ -0,0 +1,20 @@
+import { getConstructor, isNonPrimitive } from "@orpc/shared";
+// src/lazy.ts
+var Lazy = class Lazy {
+	"~orpc";
+	"constructor"(def) {
+		this["~orpc"] = def;
+	}
+	/**
+	* Checks if the given instance satisfies the {@link Lazy} class/interface.
+	*/
+	static [Symbol.hasInstance](instance) {
+		if (this !== Lazy) return Function.prototype[Symbol.hasInstance].call(this, instance);
+		if (getConstructor(instance) === Lazy) return true;
+		return isNonPrimitive(instance) && isNonPrimitive(instance["~orpc"]) && isNonPrimitive(instance["~orpc"].meta) && (instance["~orpc"].metaPlugins === void 0 || Array.isArray(instance["~orpc"].metaPlugins)) && typeof instance["~orpc"].loader === "function";
+	}
+};
+function unlazy(maybeLazy) {
+	return maybeLazy instanceof Lazy ? maybeLazy["~orpc"].loader() : Promise.resolve({ default: maybeLazy });
+}
+export { Lazy, unlazy };

package/dist/middleware-decorated.d.ts

@@ -0,0 +1,9 @@
+import { Context, MergedContext, MergedInitialContext } from "./context.js";
+import { Middleware } from "./middleware.js";
+import { ErrorMap, MergedErrorMap } from "@orpc/contract";
+import { IntersectPick } from "@orpc/shared";
+export interface DecoratedMiddleware<TInContext extends Context, TOutContext extends Context, TInput, TOutput, TErrorMap extends ErrorMap> extends Middleware<TInContext, TOutContext, TInput, TOutput, TErrorMap> {
+  adaptInput<T>(adapt: (input: T) => TInput): DecoratedMiddleware<TInContext, TOutContext, T, TOutput, TErrorMap>;
+  errors<T extends ErrorMap>(errors: T): DecoratedMiddleware<TInContext, TOutContext, TInput, TOutput, MergedErrorMap<TErrorMap, T>>;
+  use<$OutContext extends IntersectPick<MergedContext<TInContext, TOutContext>, $OutContext>, $Input extends TInput, $InContext extends Context = MergedContext<TInContext, TOutContext>, $ErrorMap extends ErrorMap = TErrorMap>(middleware: Middleware<$InContext | MergedContext<TInContext, TOutContext>, $OutContext, $Input, TOutput, $ErrorMap>): DecoratedMiddleware<MergedInitialContext<TInContext, TOutContext, $InContext>, MergedContext<TOutContext, $OutContext>, $Input, TOutput, MergedErrorMap<$ErrorMap, TErrorMap>>;
+}

package/dist/middleware-decorated.js

@@ -0,0 +1,67 @@
+import { mergeErrorMap } from "@orpc/contract";
+import { toArray } from "@orpc/shared";
+// src/middleware-decorated.ts
+function decorateMiddleware(middleware) {
+	const decorated = ((...args) => middleware(...args));
+	decorated["~orpc"] = middleware["~orpc"];
+	Object.defineProperty(decorated, "name", { value: middleware.name });
+	decorated.adaptInput = (adapt) => {
+		const mapped = decorateMiddleware((opts, input, ...args) => {
+			return middleware(opts, adapt(input), ...args);
+		});
+		mapped["~orpc"] = decorated["~orpc"];
+		Object.defineProperty(mapped, "name", { value: decorated.name });
+		return mapped;
+	};
+	decorated.errors = (errors) => {
+		const newMiddleware = decorateMiddleware(decorated);
+		newMiddleware["~orpc"] = {
+			...decorated["~orpc"],
+			errorMap: mergeErrorMap(decorated["~orpc"]?.errorMap, errors)
+		};
+		return newMiddleware;
+	};
+	decorated.use = (usedMiddleware) => {
+		const merged = decorateMiddleware((opts, ...args) => {
+			return middleware({
+				...opts,
+				async next(nextOpts1) {
+					const signal = nextOpts1?.signal ?? opts.signal;
+					const result = await usedMiddleware({
+						...opts,
+						context: {
+							...opts.context,
+							...nextOpts1?.context
+						},
+						signal,
+						next(nextOpts2, ...args) {
+							return opts.next({
+								context: {
+									...nextOpts1?.context,
+									...nextOpts2?.context
+								},
+								signal: nextOpts2?.signal ?? signal
+							}, ...args);
+						}
+					}, ...args);
+					return {
+						...result,
+						context: {
+							...nextOpts1?.context,
+							...result.context
+						}
+					};
+				}
+			}, ...args);
+		});
+		merged["~orpc"] = {
+			...decorated["~orpc"],
+			errorMap: mergeErrorMap(usedMiddleware["~orpc"]?.errorMap, decorated["~orpc"]?.errorMap),
+			metaPlugins: [...toArray(decorated["~orpc"]?.metaPlugins), ...toArray(usedMiddleware["~orpc"]?.metaPlugins)]
+		};
+		Object.defineProperty(merged, "name", { value: `${decorated.name} + ${usedMiddleware.name}` });
+		return merged;
+	};
+	return decorated;
+}
+export { decorateMiddleware };

package/dist/middleware.d.ts

@@ -0,0 +1,54 @@
+import { Context } from "./context.js";
+import { AnyProcedure } from "./procedure.js";
+import { AnyMetaPlugin, ErrorMap, ORPCErrorConstructorMap } from "@orpc/contract";
+import { MaybeOptionalOptions, Promisable } from "@orpc/shared";
+export type MiddlewareResult<TOutContext extends Context, TOutput> = Promisable<{
+  output: TOutput;
+  context: TOutContext;
+}>;
+export type MiddlewareNextOptions<TOutContext extends Context> = (object extends TOutContext ? {
+  context?: TOutContext | undefined;
+} : {
+  context: TOutContext;
+}) & {
+  /** Overrides the signal for the rest of the chain. */
+  signal?: AbortSignal | undefined;
+};
+export interface MiddlewareNext<TOutput> {
+  <T extends Context = object>(...rest: MaybeOptionalOptions<MiddlewareNextOptions<T>>): MiddlewareResult<T, TOutput>;
+}
+export type MiddlewareDoneOptions<TOutContext, TOutput> = (object extends TOutContext ? {
+  context?: TOutContext | undefined;
+} : {
+  context: TOutContext;
+}) & {
+  output: TOutput;
+};
+export interface MiddlewareDone<TOutput> {
+  /**
+   * Create a successful result and terminate the middleware chain early.
+   */
+  <TOutContext extends Context = object>(...rest: MaybeOptionalOptions<MiddlewareDoneOptions<TOutContext, TOutput>>): MiddlewareResult<TOutContext, TOutput>;
+}
+export interface MiddlewareOptions<TInContext extends Context, TOutput, TErrorConstructorMap extends ORPCErrorConstructorMap<any>> {
+  context: TInContext;
+  path: string[];
+  procedure: AnyProcedure;
+  signal?: AbortSignal | undefined;
+  lastEventId: string | undefined;
+  /**
+   * Invoke to continue the middleware chain.
+   */
+  next: MiddlewareNext<TOutput>;
+  errors: TErrorConstructorMap;
+}
+export interface MiddlewareDefinition<TErrorMap extends ErrorMap> {
+  errorMap?: TErrorMap | undefined;
+  metaPlugins?: AnyMetaPlugin[] | undefined;
+}
+export interface Middleware<TInContext extends Context, TOutContext extends Context, TInput, TOutput, TErrorMap extends ErrorMap> {
+  /** this property should be optional to support inline middleware */
+  "~orpc"?: MiddlewareDefinition<TErrorMap> | undefined;
+  (opts: MiddlewareOptions<TInContext, TOutput, ORPCErrorConstructorMap<TErrorMap>>, input: TInput, done: MiddlewareDone<TOutput>): Promisable<MiddlewareResult<TOutContext, TOutput>>;
+}
+export type AnyMiddleware = Middleware<any, any, any, any, any>;