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

package/dist/implementer-router.d.ts

@@ -1,40 +1,34 @@
-import type { ErrorMap, InferRouterContractErrorMap, RouterContract } from '@orpc/contract';
-import { ProcedureContract } from '@orpc/contract';
-import type { IntersectPick, Public } from '@orpc/shared';
-import type { Context, MergedContext, MergedInitialContext } from './context.ts';
-import { ProcedureImplementer } from './implementer-procedure.ts';
-import { Lazy } from './lazy.ts';
-import type { DecoratedMiddleware } from './middleware-decorated.ts';
-import type { AnyMiddleware, Middleware } from './middleware.ts';
-import type { ProcedureConfig } from './procedure.ts';
-import type { AugmentedRouterWithMiddlewares } from './router-utils.ts';
-import type { ContractedRouter } from './router.ts';
+import { Context, MergedContext, MergedInitialContext } from "./context.js";
+import { ProcedureImplementer } from "./implementer-procedure.js";
+import { Lazy } from "./lazy.js";
+import { AnyMiddleware, Middleware } from "./middleware.js";
+import { DecoratedMiddleware } from "./middleware-decorated.js";
+import { ProcedureConfig } from "./procedure.js";
+import { ContractedRouter } from "./router.js";
+import { AugmentedRouterWithMiddlewares } from "./router-utils.js";
+import { ErrorMap, InferRouterContractErrorMap, ProcedureContract, RouterContract } from "@orpc/contract";
+import { IntersectPick, Public } from "@orpc/shared";
 export declare class SharedRouterImplementer<TContract extends RouterContract, TInitialContext extends Context> {
-    private readonly contract;
-    private readonly config;
-    private readonly middlewares;
-    private constructor();
-    static create<TContract extends RouterContract, TInitialContext extends Context>(contract: TContract, config: ProcedureConfig): SharedRouterImplementer<TContract, TInitialContext>;
-    static create<TContract extends RouterContract, TInitialContext extends Context, TInjectedContext extends Context>(contract: TContract, config: ProcedureConfig, 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>;
+  private readonly contract;
+  private readonly config;
+  private readonly middlewares;
+  private constructor();
+  static create<TContract extends RouterContract, TInitialContext extends Context>(contract: TContract, config: ProcedureConfig): SharedRouterImplementer<TContract, TInitialContext>;
+  static create<TContract extends RouterContract, TInitialContext extends Context, TInjectedContext extends Context>(contract: TContract, config: ProcedureConfig, 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>;
 }
 export 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>>;
+  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>>;
 }
-export 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;
-};
-export 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;
-};
-export declare function createRouterImplementer<TContract extends RouterContract, TInitialContext extends Context>(contract: TContract, config: ProcedureConfig): RouterImplementer<TContract, TInitialContext>;
+export 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; };
+export 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; };

package/dist/implementer-router.js

@@ -1,117 +1,98 @@
-import { ProcedureContract } from '@orpc/contract';
-import { bindMethods, omit, setOwn } from '@orpc/shared';
-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';
-export 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: {},
-        });
-    }
-}
-export function createRouterImplementer(contract, config) {
-    return createRouterImplementerInternal(toPlainRouterContract(contract), config, []);
+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.
- */
+* 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;
-        }
-        // handler & orderedMiddlewares are what make a definition a procedure (see Procedure[Symbol.hasInstance])
-        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);
+	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;
+	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

@@ -1,11 +1,11 @@
-import type { RouterContract } from '@orpc/contract';
-import type { DefaultInitialContext } from './builder.ts';
-import type { Context } from './context.ts';
-import type { RouterImplementer } from './implementer-router.ts';
-import type { ProcedureConfig } from './procedure.ts';
+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>;
+  $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
@@ -13,4 +13,4 @@ export type Implementer<TContract extends RouterContract, TInitialContext extend
  *
  * @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>;
+export declare function implement<TContract extends RouterContract, TInitialContext extends Context = DefaultInitialContext>(contract: TContract, config?: ProcedureConfig): Implementer<TContract, TInitialContext & object>;

package/dist/implementer.js

@@ -1,37 +1,30 @@
-import { isNonPrimitive } from '@orpc/shared';
-import { createRouterImplementer } from './implementer-router.js';
+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}
- */
-export function implement(contract, config = {}) {
-    // Using `& object` avoids "has no properties in common with type" errors
-    // when combining procedures or routers with compatible but non-overlapping contexts.
-    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;
+* 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,61 +1,22 @@
-export * from './builder.ts';
-export * from './builder-variants.ts';
-export * from './constants.ts';
-export * from './context.ts';
-export * from './implementer.ts';
-export * from './implementer-procedure.ts';
-export { SharedRouterImplementer } from './implementer-router.ts';
-export type { RouterImplementer, RouterImplementerWithMiddlewares, SharedRouterImplementerWithMiddlewares, } from './implementer-router.ts';
-export * from './lazy.ts';
-export * from './middleware.ts';
-export type { DecoratedMiddleware } from './middleware-decorated.ts';
-export * from './procedure.ts';
-export * from './procedure-client.ts';
-export * from './procedure-decorated.ts';
-export { call } from './procedure-utils.ts';
-export type { CallOptions, CallRest } from './procedure-utils.ts';
-export * from './router.ts';
-export type { 
-/**
- * @deprecated Use `InferRouterFinalContexts` instead.
- */
-InferRouterFinalContexts as InferRouterCurrentContexts, } from './router.ts';
-export * from './router-client.ts';
-export { getRouter, resolveContractProcedure, unlazyRouter, walkProcedureContractsAsync, walkProcedureContractsSync, } from './router-utils.ts';
-export type { AugmentedRouter, AugmentedRouterWithMiddlewares, UnlaziedRouter, WalkProcedureContractsLazyResult, } from './router-utils.ts';
-export type { AnyORPCError, AnyORPCErrorJSON, Client, ClientContext, ClientOptions, ClientRest, FriendlyClientOptions, ORPCErrorCode, ORPCErrorJSON, ORPCErrorOptions, RPCJsonSerialization, RPCJsonSerializationMeta, RPCJsonSerializerHandler, RPCJsonSerializerOptions, RPCSerializerOptions, RPCSerializerSerializeOptions, SafeResult, } from '@orpc/client';
-export { COMMON_ERROR_STATUS_MAP, isDefinedError, ORPCError, RPCJsonSerializer, RPCSerializer, safe, toORPCError, } from '@orpc/client';
-export type { AnyMetaPlugin, AnySchema, ErrorMap, ErrorMapItem, InferSchemaInput, InferSchemaOutput, InitialInputSchema, InitialOutputSchema, MergedErrorMap, MergedSchema, Meta, MetaPlugin, MetaPluginDefinition, ORPCErrorConstructorMap, ORPCErrorConstructorMapItem, ORPCErrorConstructorMapItemOptions, ORPCErrorFactory, ORPCErrorFactoryOptions, ORPCErrorFromErrorMap, ProcedureContract, ProcedureContractDefinition, RouterContract, Schema, } from '@orpc/contract';
-export { asyncIteratorObject, defineMeta, error, eventIterator, type, ValidationError, } from '@orpc/contract';
-export type { AsyncCleanupFn, AsyncIteratorClassNextFn, DistributiveOmit, IntersectPick, MaybeOptionalOptions, PromiseWithError, Public, Registry, ThrowableError, } from '@orpc/shared';
-export { AsyncIteratorClass, asyncIteratorToStream, asyncIteratorToUnproxiedDataStream, 
-/**
- * @deprecated Use `asyncIteratorToStream` instead.
- */
-asyncIteratorToStream as eventIteratorToStream, 
-/**
- * @deprecated Use `asyncIteratorToUnproxiedDataStream` instead.
- */
-asyncIteratorToUnproxiedDataStream as eventIteratorToUnproxiedDataStream, onAsyncIteratorObjectError, onError, onFinish, onReadableStreamError, onStart, onSuccess, streamToAsyncIteratorObject, 
-/**
- * @deprecated Use `streamToAsyncIteratorObject` instead.
- */
-streamToAsyncIteratorObject as streamToEventIterator, } from '@orpc/shared';
-export type { EventMeta, StandardBody, StandardBodyHint, StandardHeaders, StandardLazyRequest, StandardLazyResponse, StandardMethod, StandardRequest, StandardResponse, StandardUrl, } from '@standard-server/core';
-export { 
-/**
- * @deprecated Use `EventStreamErrorEvent` instead.
- */
-EventStreamErrorEvent as ErrorEvent, EventStreamErrorEvent, 
-/**
- * Retrieves metadata attached to a single iterator event value.
- *
- * @see {@link https://orpc.dev/docs/helpers/publisher | Publisher Helpers}
- */
-getEventMeta, unwrapEvent, 
-/**
- * Returns a new iterator event value with attached, validated metadata.
- *
- * @see {@link https://orpc.dev/docs/async-iterator-object#last-event-id--event-metadata | AsyncIteratorObject (SSE) - Last Event ID & Event Metadata}
- */
-withEventMeta, } from '@standard-server/core';
+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

@@ -1,48 +1,16 @@
-export * from './builder.js';
-export * from './builder-variants.js';
-export * from './constants.js';
-export * from './context.js';
-export * from './implementer.js';
-export * from './implementer-procedure.js';
-export { SharedRouterImplementer } from './implementer-router.js';
-export * from './lazy.js';
-export * from './middleware.js';
-export * from './procedure.js';
-export * from './procedure-client.js';
-export * from './procedure-decorated.js';
-export { call } from './procedure-utils.js';
-export * from './router.js';
-export * from './router-client.js';
-export { getRouter, resolveContractProcedure, unlazyRouter, walkProcedureContractsAsync, walkProcedureContractsSync, } from './router-utils.js';
-export { COMMON_ERROR_STATUS_MAP, isDefinedError, ORPCError, RPCJsonSerializer, RPCSerializer, safe, toORPCError, } from '@orpc/client';
-export { asyncIteratorObject, defineMeta, error, eventIterator, type, ValidationError, } from '@orpc/contract';
-export { AsyncIteratorClass, asyncIteratorToStream, asyncIteratorToUnproxiedDataStream, 
-/**
- * @deprecated Use `asyncIteratorToStream` instead.
- */
-asyncIteratorToStream as eventIteratorToStream, 
-/**
- * @deprecated Use `asyncIteratorToUnproxiedDataStream` instead.
- */
-asyncIteratorToUnproxiedDataStream as eventIteratorToUnproxiedDataStream, onAsyncIteratorObjectError, onError, onFinish, onReadableStreamError, onStart, onSuccess, streamToAsyncIteratorObject, 
-/**
- * @deprecated Use `streamToAsyncIteratorObject` instead.
- */
-streamToAsyncIteratorObject as streamToEventIterator, } from '@orpc/shared';
-export { 
-/**
- * @deprecated Use `EventStreamErrorEvent` instead.
- */
-EventStreamErrorEvent as ErrorEvent, EventStreamErrorEvent, 
-/**
- * Retrieves metadata attached to a single iterator event value.
- *
- * @see {@link https://orpc.dev/docs/helpers/publisher | Publisher Helpers}
- */
-getEventMeta, unwrapEvent, 
-/**
- * Returns a new iterator event value with attached, validated metadata.
- *
- * @see {@link https://orpc.dev/docs/async-iterator-object#last-event-id--event-metadata | AsyncIteratorObject (SSE) - Last Event ID & Event Metadata}
- */
-withEventMeta, } from '@standard-server/core';
+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

@@ -1,20 +1,20 @@
-import type { AnyMetaPlugin, Meta } from '@orpc/contract';
+import { AnyMetaPlugin, Meta } from "@orpc/contract";
 export interface LazyDefinition<T> {
-    meta: Meta;
-    metaPlugins?: AnyMetaPlugin[] | undefined;
-    loader: () => Promise<{
-        default: 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;
+  "~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;
-}>;
+  default: T extends Lazy<infer U> ? U : T;
+}>;