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

package/dist/plugins/signal-sync.d.mts

@@ -0,0 +1,13 @@
+import type { StandardHandlerOptions, StandardHandlerPlugin } from "../adapters/standard/index.mjs";
+import type { Context } from "../context.mjs";
+/**
+* Keeps the request signal and a streaming output (async iterator object or readable stream) in sync:
+* cancelling the output aborts the signal with an `AbortError`,
+* and aborting the signal ends the output with the abort reason and cancels it.
+*
+* @see {@link https://orpc.dev/docs/plugins/signal-sync | Signal Sync Plugin}
+*/
+export declare class SignalSyncHandlerPlugin<T extends Context> implements StandardHandlerPlugin<T> {
+	name: string;
+	init(options: StandardHandlerOptions<T>): StandardHandlerOptions<T>;
+}

package/dist/plugins/signal-sync.mjs

@@ -0,0 +1,84 @@
+import { AbortError, anyAbortSignal, AsyncIteratorClass, isAsyncIteratorObject, override, runWithSignal, toArray } from "@orpc/shared";
+
+export class SignalSyncHandlerPlugin {
+	name = "~signal-sync";
+	init(options) {
+		const clientInterceptor = async (interceptorOptions) => {
+			const controller = new AbortController();
+			const signal = anyAbortSignal([interceptorOptions.signal, controller.signal]);
+			const cancel = () => controller.abort(new AbortError("The response body was cancelled"));
+			const output = await interceptorOptions.next({
+				...interceptorOptions,
+				signal
+			});
+			if (isAsyncIteratorObject(output)) {
+				return override(output, syncAsyncIterator(output, signal, cancel));
+			}
+			if (output instanceof ReadableStream) {
+				return override(output, syncReadableStream(output, signal, cancel));
+			}
+			return output;
+		};
+		return {
+			...options,
+			clientInterceptors: [clientInterceptor, ...toArray(options.clientInterceptors)]
+		};
+	}
+}
+function listenAbort(signal, onAbort) {
+	if (signal.aborted) {
+		onAbort();
+	} else {
+		signal.addEventListener("abort", onAbort, { once: true });
+	}
+	return () => signal.removeEventListener("abort", onAbort);
+}
+function syncAsyncIterator(iterator, signal, cancel) {
+	let cancelling;
+	const unlisten = listenAbort(signal, () => {
+		cancelling = (async () => iterator.return?.())();
+		cancelling.catch(() => {});
+	});
+	return new AsyncIteratorClass(() => runWithSignal(signal, () => iterator.next()), async ({ kind }) => {
+		if (kind === "cancelled") {
+			cancel();
+			await cancelling;
+		}
+		unlisten();
+	});
+}
+function syncReadableStream(stream, signal, cancel) {
+	const reader = stream.getReader();
+	let cancelling;
+	let unlisten;
+	return new ReadableStream({
+		start(controller) {
+			unlisten = listenAbort(signal, () => {
+				controller.error(signal.reason);
+				cancelling = reader.cancel(signal.reason);
+				cancelling.catch(() => {});
+			});
+		},
+		async pull(controller) {
+			try {
+				const { done, value } = await reader.read();
+				if (signal.aborted) {
+					return;
+				}
+				if (done) {
+					unlisten();
+					controller.close();
+				} else {
+					controller.enqueue(value);
+				}
+			} catch (error) {
+				unlisten();
+				throw error;
+			}
+		},
+		async cancel() {
+			cancel();
+			await cancelling;
+		}
+	}, { highWaterMark: 0 });
+}

package/dist/plugins/timeout.d.mts

@@ -0,0 +1,37 @@
+import type { Value } from "@orpc/shared";
+import type { StandardHandlerInterceptorOptions, StandardHandlerOptions, StandardHandlerPlugin } from "../adapters/standard/index.mjs";
+import type { Context } from "../context.mjs";
+export interface TimeoutHandlerPluginOptions<T extends Context> {
+	/**
+	* Timeout in milliseconds before the request signal is aborted.
+	* This only covers producing the response, use `streamingTimeout`
+	* to limit streaming response bodies.
+	* Use `null` or `undefined` to disable the timeout.
+	*/
+	timeout: Value<number | null | undefined, [options: StandardHandlerInterceptorOptions<T>]>;
+	/**
+	* Timeout in milliseconds for the full duration of a streaming response body
+	* (async iterator object or readable stream), measured from when the response is produced.
+	* When exceeded, the request signal is aborted and the body ends
+	* once its producer honors the signal.
+	* Usually higher than `timeout`.
+	* Use `null` or `undefined` to disable the timeout.
+	*
+	* @default undefined (streaming responses run without limit)
+	*/
+	streamingTimeout?: Value<number | null | undefined, [options: StandardHandlerInterceptorOptions<T>]> | undefined;
+}
+/**
+* The Timeout Handler Plugin aborts the request signal with an `AbortError`
+* when handling exceeds a configured timeout. It only aborts the signal,
+* the procedure must honor it to stop early and produce the response.
+*
+* @see {@link https://orpc.dev/docs/plugins/timeout | Timeout Plugin}
+*/
+export declare class TimeoutHandlerPlugin<T extends Context> implements StandardHandlerPlugin<T> {
+	private readonly timeout;
+	private readonly streamingTimeout;
+	name: string;
+	constructor(options: NoInfer<TimeoutHandlerPluginOptions<T>>);
+	init(options: StandardHandlerOptions<T>): StandardHandlerOptions<T>;
+}

package/dist/plugins/timeout.mjs

@@ -0,0 +1,56 @@
+import { AbortError, anyAbortSignal, isAsyncIteratorObject, override, toArray, value, wrapAsyncIterator, wrapReadableStream } from "@orpc/shared";
+
+export class TimeoutHandlerPlugin {
+	timeout;
+	streamingTimeout;
+	name = "~timeout";
+	constructor(options) {
+		this.timeout = options.timeout;
+		this.streamingTimeout = options.streamingTimeout;
+	}
+	init(options) {
+		const interceptor = async (interceptorOptions) => {
+			const timeoutMs = value(this.timeout, interceptorOptions);
+			const streamingTimeoutMs = value(this.streamingTimeout, interceptorOptions);
+			const hasTimeout = timeoutMs !== null && timeoutMs !== undefined;
+			const hasStreamingTimeout = streamingTimeoutMs !== null && streamingTimeoutMs !== undefined;
+			if (!hasTimeout && !hasStreamingTimeout) {
+				return interceptorOptions.next();
+			}
+			const controller = new AbortController();
+			const abortWithTimeout = (ms) => {
+				controller.abort(new AbortError(`Request timed out after ${ms}ms`));
+			};
+			const timeoutId = hasTimeout ? setTimeout(abortWithTimeout, timeoutMs, timeoutMs) : undefined;
+			const signal = anyAbortSignal([interceptorOptions.request.signal, controller.signal]);
+			try {
+				const response = await interceptorOptions.next({
+					...interceptorOptions,
+					request: {
+						...interceptorOptions.request,
+						signal
+					}
+				});
+				if (hasStreamingTimeout) {
+					const body = response.body;
+					const isIterator = isAsyncIteratorObject(body);
+					if (isIterator || body instanceof ReadableStream) {
+						const streamingTimeoutId = setTimeout(abortWithTimeout, streamingTimeoutMs, streamingTimeoutMs);
+						const onFinish = () => clearTimeout(streamingTimeoutId);
+						return {
+							...response,
+							body: isIterator ? override(body, wrapAsyncIterator(body, { onFinish })) : override(body, wrapReadableStream(body, { onFinish }))
+						};
+					}
+				}
+				return response;
+			} finally {
+				clearTimeout(timeoutId);
+			}
+		};
+		return {
+			...options,
+			interceptors: [interceptor, ...toArray(options.interceptors)]
+		};
+	}
+}

package/dist/procedure-client.d.mts

@@ -0,0 +1,41 @@
+import type { Client, ClientContext } from "@orpc/client";
+import type { AnySchema, ErrorMap, InferSchemaInput, InferSchemaOutput, ORPCErrorConstructorMap, ORPCErrorFromErrorMap } from "@orpc/contract";
+import type { Interceptor, MaybeOptionalOptions, Promisable, PromiseWithError, ThrowableError, Value } from "@orpc/shared";
+import type { Context } from "./context.mjs";
+import type { Lazyable } from "./lazy.mjs";
+import type { Procedure, ProcedureHandlerOptions } from "./procedure.mjs";
+export type ProcedureClient<
+	TClientContext extends ClientContext,
+	TInputSchema extends AnySchema,
+	TOutputSchema extends AnySchema,
+	TErrorMap extends ErrorMap
+> = Client<TClientContext, InferSchemaInput<TInputSchema>, InferSchemaOutput<TOutputSchema>, ORPCErrorFromErrorMap<TErrorMap> | ThrowableError>;
+export interface ProcedureClientInterceptorOptions<
+	TInitialContext extends Context,
+	TErrorMap extends ErrorMap
+> extends ProcedureHandlerOptions<TInitialContext, unknown, ORPCErrorConstructorMap<TErrorMap>> {}
+export type ProcedureClientInterceptor<
+	TInitialContext extends Context,
+	TOutputSchema extends AnySchema,
+	TErrorMap extends ErrorMap
+> = Interceptor<ProcedureClientInterceptorOptions<TInitialContext, TErrorMap>, PromiseWithError<InferSchemaOutput<TOutputSchema>, ORPCErrorFromErrorMap<TErrorMap> | ThrowableError>>;
+export type ProcedureClientOptions<
+	TInitialContext extends Context,
+	TOutputSchema extends AnySchema,
+	TErrorMap extends ErrorMap,
+	TClientContext extends ClientContext
+> = {
+	path?: string[] | undefined;
+	interceptors?: ProcedureClientInterceptor<TInitialContext, TOutputSchema, TErrorMap>[] | undefined;
+} & (object extends TInitialContext ? {
+	context?: Value<Promisable<TInitialContext>, [clientContext: TClientContext]> | undefined;
+} : {
+	context: Value<Promisable<TInitialContext>, [clientContext: TClientContext]>;
+});
+export declare function createProcedureClient<
+	TInitialContext extends Context,
+	TInputSchema extends AnySchema,
+	TOutputSchema extends AnySchema,
+	TErrorMap extends ErrorMap,
+	TClientContext extends ClientContext = object
+>(lazyableProcedure: Lazyable<Procedure<TInitialContext, any, TInputSchema, TOutputSchema, TErrorMap>>, ...rest: MaybeOptionalOptions<ProcedureClientOptions<TInitialContext, TOutputSchema, TErrorMap, TClientContext>>): ProcedureClient<TClientContext, TInputSchema, TOutputSchema, TErrorMap>;

package/dist/procedure-client.mjs

@@ -0,0 +1,157 @@
+import { ORPCError, wrapAsyncIteratorPreservingEventMeta } from "@orpc/client";
+import { createORPCErrorConstructorMap, reconcileORPCError, ValidationError } from "@orpc/contract";
+import { getTracer, intercept, isAsyncIteratorObject, mergeTwoLevels, override, resolveMaybeOptionalOptions, runWithSpan, toArray, traceAsyncIterator, traceReadableStream, value } from "@orpc/shared";
+import { unlazy } from "./lazy.mjs";
+export function createProcedureClient(lazyableProcedure, ...rest) {
+	const options = resolveMaybeOptionalOptions(rest);
+	return async (...[input, callerOptions]) => {
+		const path = toArray(options.path);
+		const { default: procedure } = await unlazy(lazyableProcedure);
+		
+		const clientContext = callerOptions?.context ?? {};
+		
+		const context = await value(options.context, clientContext) ?? {};
+		const errors = createORPCErrorConstructorMap(procedure["~orpc"].errorMap);
+		const reconcileError = async (e) => {
+			if (e instanceof ORPCError) {
+				return await reconcileORPCError(procedure["~orpc"].errorMap, e);
+			}
+			return e;
+		};
+		try {
+			const output = await runWithSpan("call_procedure", (span) => {
+				span?.setAttribute("procedure.path", path);
+				return intercept(options.interceptors, {
+					context,
+					
+					input,
+					errors,
+					path,
+					procedure,
+					signal: callerOptions?.signal,
+					lastEventId: callerOptions?.lastEventId
+				}, (interceptorOptions) => executeProcedureInternal(interceptorOptions.procedure, interceptorOptions));
+			});
+			if (isAsyncIteratorObject(output)) {
+				
+				return override(output, wrapAsyncIteratorPreservingEventMeta(getTracer() ? traceAsyncIterator("consume_async_iterator_object_output", output) : output, { mapError: reconcileError }));
+			} else if (getTracer() && output instanceof ReadableStream) {
+				
+				return override(output, traceReadableStream("consume_octet_stream_output", output));
+			}
+			return output;
+		} catch (e) {
+			throw await reconcileError(e);
+		}
+	};
+}
+async function validateInput(i, schema, input) {
+	return runWithSpan(`validate_input.${i}`, async (span) => {
+		span?.setAttribute("input_schema.index", i);
+		const result = await schema["~standard"].validate(input);
+		if (result.issues) {
+			throw new ORPCError("BAD_REQUEST", {
+				message: "Input validation failed",
+				data: { issues: result.issues },
+				cause: new ValidationError({
+					message: "Input validation failed",
+					issues: result.issues,
+					invalidData: input
+				})
+			});
+		}
+		return result.value;
+	});
+}
+async function validateOutput(i, schema, output) {
+	return runWithSpan(`validate_output.${i}`, async (span) => {
+		span?.setAttribute("output_schema.index", i);
+		const result = await schema["~standard"].validate(output);
+		if (result.issues) {
+			throw new ORPCError("INTERNAL_SERVER_ERROR", {
+				message: "Output validation failed",
+				cause: new ValidationError({
+					message: "Output validation failed",
+					issues: result.issues,
+					invalidData: output
+				})
+			});
+		}
+		return result.value;
+	});
+}
+const middlewareDone = (...rest) => {
+	const options = resolveMaybeOptionalOptions(rest);
+	return {
+		output: options.output,
+		
+		context: options.context ?? {}
+	};
+};
+async function executeProcedureInternal(procedure, options) {
+	const inputSchemas = toArray(procedure["~orpc"].inputSchemas);
+	const outputSchemas = toArray(procedure["~orpc"].outputSchemas);
+	const orderedMiddlewares = procedure["~orpc"].orderedMiddlewares;
+	const next = async (midIndex, context, input, signal) => {
+		let currentInput = input;
+		let middlewareInput = input;
+		const startInputIndex = midIndex === 0 ? 0 : orderedMiddlewares[midIndex - 1].inputSchemasLengthAtUse ?? 0;
+		const endInputIndex = midIndex === orderedMiddlewares.length ? inputSchemas.length : orderedMiddlewares[midIndex].inputSchemasLengthAtUse ?? 0;
+		
+		if (!procedure["~orpc"].disableInputValidation) {
+			for (let i = startInputIndex; i < endInputIndex; i++) {
+				const validated = await validateInput(i, inputSchemas[i], i !== 0 ? mergeTwoLevels(options.input, currentInput) : currentInput);
+				currentInput = i !== 0 ? mergeTwoLevels(currentInput, validated) : validated;
+			}
+			middlewareInput = endInputIndex > 0 && endInputIndex < inputSchemas.length ? mergeTwoLevels(options.input, currentInput) : currentInput;
+		}
+		let currentOutput;
+		let currentContext = context;
+		if (midIndex < orderedMiddlewares.length) {
+			const { middleware } = orderedMiddlewares[midIndex];
+			const result = await runWithSpan(`middleware.${middleware.name}`, async (span) => {
+				span?.setAttribute("middleware.index", midIndex);
+				return await middleware({
+					...options,
+					context,
+					signal,
+					next: (...rest) => {
+						const nextOptions = resolveMaybeOptionalOptions(rest);
+						
+						const nextContext = nextOptions.context ?? {};
+						return next(midIndex + 1, {
+							...context,
+							...nextContext
+						}, currentInput, nextOptions.signal ?? signal);
+					},
+					lastEventId: options.lastEventId
+				}, middlewareInput, middlewareDone);
+			});
+			currentOutput = result.output;
+			currentContext = {
+				...context,
+				...result.context
+			};
+		} else {
+			currentOutput = await runWithSpan("handler", () => procedure["~orpc"].handler({
+				...options,
+				context,
+				input: currentInput,
+				signal
+			}, currentInput));
+		}
+		const startOutputIndex = midIndex === 0 ? 0 : orderedMiddlewares[midIndex - 1].outputSchemasLengthAtUse ?? 0;
+		const endOutputIndex = midIndex === orderedMiddlewares.length ? outputSchemas.length : orderedMiddlewares[midIndex].outputSchemasLengthAtUse ?? 0;
+		if (!procedure["~orpc"].disableOutputValidation) {
+			for (let i = endOutputIndex - 1; i >= startOutputIndex; i--) {
+				currentOutput = await validateOutput(i, outputSchemas[i], currentOutput);
+			}
+		}
+		return {
+			output: currentOutput,
+			context: currentContext
+		};
+	};
+	const { output } = await next(0, options.context, options.input, options.signal);
+	return output;
+}

package/dist/procedure-decorated.d.mts

@@ -0,0 +1,20 @@
+import type { AnySchema, ErrorMap, InferSchemaInput, InferSchemaOutput, MergedErrorMap, MetaPlugin } from "@orpc/contract";
+import type { IntersectPick } from "@orpc/shared";
+import type { Context, MergedContext, MergedInitialContext } from "./context.mjs";
+import type { Middleware } from "./middleware.mjs";
+import { Procedure } from "./procedure.mjs";
+export declare class DecoratedProcedure<
+	TInitialContext extends Context,
+	TInjectedContext extends Context,
+	TInputSchema extends AnySchema,
+	TOutputSchema extends AnySchema,
+	TErrorMap extends ErrorMap
+> extends Procedure<TInitialContext, TInjectedContext, TInputSchema, TOutputSchema, TErrorMap> {
+	meta(...plugins: MetaPlugin<TInputSchema, TOutputSchema, TErrorMap>[]): DecoratedProcedure<TInitialContext, TInjectedContext, TInputSchema, TOutputSchema, TErrorMap>;
+	errors<T extends ErrorMap>(errors: T): DecoratedProcedure<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>): DecoratedProcedure<MergedInitialContext<TInitialContext, TInjectedContext, $InContext>, MergedContext<TInjectedContext, $OutContext>, TInputSchema, TOutputSchema, MergedErrorMap<$ErrorMap, TErrorMap>>;
+}

package/dist/procedure-decorated.mjs

@@ -0,0 +1,41 @@
+import { getHiddenMetaPlugins, mergeErrorMap, resolveMetaPlugins } from "@orpc/contract";
+import { Procedure } from "./procedure.mjs";
+export class DecoratedProcedure extends Procedure {
+	meta(...plugins) {
+		const [meta, metaPlugins] = resolveMetaPlugins(this["~orpc"].meta, this["~orpc"].metaPlugins, plugins);
+		return new DecoratedProcedure({
+			...this["~orpc"],
+			meta,
+			metaPlugins
+		});
+	}
+	errors(errors) {
+		let procedure = new DecoratedProcedure({
+			...this["~orpc"],
+			errorMap: mergeErrorMap(this["~orpc"].errorMap, errors)
+		});
+		const plugins = getHiddenMetaPlugins(errors);
+		if (plugins) {
+			procedure = procedure.meta(...plugins);
+		}
+		return procedure;
+	}
+	use(middleware) {
+		
+		
+		
+		let procedure = new DecoratedProcedure({
+			...this["~orpc"],
+			errorMap: mergeErrorMap(middleware["~orpc"]?.errorMap, this["~orpc"].errorMap),
+			orderedMiddlewares: [...this["~orpc"].orderedMiddlewares, {
+				middleware,
+				inputSchemasLengthAtUse: this["~orpc"].inputSchemas?.length,
+				outputSchemasLengthAtUse: this["~orpc"].outputSchemas?.length
+			}]
+		});
+		if (middleware["~orpc"]?.metaPlugins) {
+			procedure = procedure.meta(...middleware["~orpc"]?.metaPlugins);
+		}
+		return procedure;
+	}
+}

package/dist/procedure-utils.d.mts

@@ -0,0 +1,52 @@
+import type { ClientOptions } from "@orpc/client";
+import type { AnySchema, ErrorMap, InferSchemaInput, InferSchemaOutput, ORPCErrorFromErrorMap, ProcedureContract } from "@orpc/contract";
+import type { PromiseWithError, ThrowableError } from "@orpc/shared";
+import type { Context } from "./context.mjs";
+import type { Lazyable } from "./lazy.mjs";
+import type { AnyProcedure } from "./procedure.mjs";
+import type { ProcedureClientOptions } from "./procedure-client.mjs";
+import { Lazy } from "./lazy.mjs";
+import { Procedure } from "./procedure.mjs";
+export 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.
+*/
+export 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>, contract: ProcedureContract<any, any, TErrorMap>): Procedure<TInitialContext, TInjectedContext, TInputSchema, TOutputSchema, TErrorMap>;
+export type CallOptions<
+	TInitialContext extends Context,
+	TOutputSchema extends AnySchema,
+	TErrorMap extends ErrorMap
+> = ProcedureClientOptions<TInitialContext, TOutputSchema, TErrorMap, object> & Omit<ClientOptions<object>, "context">;
+export type CallRest<
+	TInitialContext extends Context,
+	TInputSchema extends AnySchema,
+	TOutputSchema extends AnySchema,
+	TErrorMap extends ErrorMap
+> = object extends CallOptions<TInitialContext, TOutputSchema, TErrorMap> ? undefined extends InferSchemaInput<TInputSchema> ? [input?: InferSchemaInput<TInputSchema>, options?: CallOptions<TInitialContext, TOutputSchema, TErrorMap>] : [input: InferSchemaInput<TInputSchema>, options?: CallOptions<TInitialContext, TOutputSchema, TErrorMap>] : [input: InferSchemaInput<TInputSchema>, options: CallOptions<TInitialContext, TOutputSchema, TErrorMap>];
+/**
+* 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' } })
+* ```
+*
+* @see {@link https://orpc.dev/docs/client/server-side#one-off-calls | Server-Side Clients - One-Off Calls}
+*/
+export declare function call<
+	TInitialContext extends Context,
+	TInputSchema extends AnySchema,
+	TOutputSchema extends AnySchema,
+	TErrorMap extends ErrorMap
+>(lazyableProcedure: Lazyable<Procedure<TInitialContext, any, TInputSchema, TOutputSchema, TErrorMap>>, ...[input, options]: CallRest<TInitialContext, TInputSchema, TOutputSchema, TErrorMap>): PromiseWithError<InferSchemaOutput<TOutputSchema>, ORPCErrorFromErrorMap<TErrorMap> | ThrowableError>;

package/dist/procedure-utils.mjs

@@ -0,0 +1,33 @@
+import { Lazy, unlazy } from "./lazy.mjs";
+import { Procedure } from "./procedure.mjs";
+import { createProcedureClient } from "./procedure-client.mjs";
+export function createGuardedProcedureLazy(lazy) {
+	const guarded = new Lazy({
+		...lazy["~orpc"],
+		async loader() {
+			const { default: maybeProcedure } = await unlazy(lazy);
+			if (!(maybeProcedure instanceof Procedure)) {
+				throw new TypeError(`
+          Expected a lazy<procedure> but got lazy<unknown>.
+          This should be caught by TypeScript compilation.
+          Please report this issue if you think this is a bug.
+        `);
+			}
+			return { default: maybeProcedure };
+		}
+	});
+	return guarded;
+}
+
+export function createContractProcedure(procedure, contract) {
+	return new Procedure({
+		...procedure["~orpc"],
+		errorMap: contract["~orpc"].errorMap,
+		meta: contract["~orpc"].meta,
+		metaPlugins: contract["~orpc"].metaPlugins
+	});
+}
+
+export function call(lazyableProcedure, ...[input = undefined, options = {}]) {
+	return createProcedureClient(lazyableProcedure, options)(input, options);
+}

package/dist/procedure.d.mts

@@ -0,0 +1,93 @@
+import type { AnySchema, ErrorMap, ORPCErrorConstructorMap, ProcedureContractDefinition } from "@orpc/contract";
+import type { Promisable } from "@orpc/shared";
+import type { Context } from "./context.mjs";
+import type { AnyMiddleware } from "./middleware.mjs";
+export interface ProcedureHandlerOptions<
+	TCurrentContext extends Context,
+	TInput,
+	TErrorConstructorMap extends ORPCErrorConstructorMap<any>
+> {
+	context: TCurrentContext;
+	input: TInput;
+	path: string[];
+	procedure: Procedure<Context, Context, AnySchema, AnySchema, ErrorMap>;
+	signal?: AbortSignal | undefined;
+	lastEventId?: string | undefined;
+	errors: TErrorConstructorMap;
+}
+export interface ProcedureHandler<
+	TCurrentContext extends Context,
+	TInput,
+	THandlerOutput,
+	TErrorConstructorMap extends ORPCErrorConstructorMap<any>
+> {
+	(opts: ProcedureHandlerOptions<TCurrentContext, TInput, TErrorConstructorMap>, input: TInput): Promisable<THandlerOutput>;
+}
+export interface OrderedMiddleware {
+	/**
+	* Snapshot of `inputSchemas.length`
+	* at the time this middleware was used.
+	*
+	* @default 0
+	*/
+	inputSchemasLengthAtUse?: number | undefined;
+	/**
+	* Snapshot of `outputSchemas.length`
+	* at the time this middleware was used.
+	*
+	* @default 0
+	*/
+	outputSchemasLengthAtUse?: number | undefined;
+	middleware: AnyMiddleware;
+}
+export interface ProcedureConfig {
+	/**
+	* When enabled, input schemas are not validated at runtime.
+	* Schemas are still used for type inference and OpenAPI generation.
+	*
+	* @remarks
+	* **Warning**: Do not disable validation for schemas that transform values.
+	*
+	* @default false
+	*/
+	disableInputValidation?: boolean | undefined;
+	/**
+	* When enabled, output schemas are not validated at runtime.
+	* Schemas are still used for type inference and OpenAPI generation.
+	*
+	* Useful when output schemas exist only for specification generation.
+	*
+	* @remarks
+	* **Warning**: Do not disable validation for schemas that transform values.
+	*
+	* @default false
+	*/
+	disableOutputValidation?: boolean | undefined;
+}
+export interface ProcedureDefinition<
+	TInitialContext extends Context,
+	TInjectedContext extends Context,
+	TInputSchema extends AnySchema,
+	TOutputSchema extends AnySchema,
+	TErrorMap extends ErrorMap
+> extends ProcedureContractDefinition<TInputSchema, TOutputSchema, TErrorMap>, ProcedureConfig {
+	__TInitialContext?: (type: TInitialContext) => unknown;
+	__TInjectedContext?: (type: TInjectedContext) => unknown;
+	orderedMiddlewares: OrderedMiddleware[];
+	handler: ProcedureHandler<any, any, any, any>;
+}
+export declare class Procedure<
+	TInitialContext extends Context,
+	TInjectedContext extends Context,
+	TInputSchema extends AnySchema,
+	TOutputSchema extends AnySchema,
+	TErrorMap extends ErrorMap
+> {
+	"~orpc": ProcedureDefinition<TInitialContext, TInjectedContext, TInputSchema, TOutputSchema, TErrorMap>;
+	constructor(def: ProcedureDefinition<TInitialContext, TInjectedContext, TInputSchema, TOutputSchema, TErrorMap>);
+	/**
+	* Checks if the given instance satisfies the {@link Procedure} class/interface.
+	*/
+	static [Symbol.hasInstance](instance: unknown): boolean;
+}
+export type AnyProcedure = Procedure<any, any, any, any, any>;

package/dist/procedure.mjs

@@ -0,0 +1,20 @@
+import { ProcedureContract } from "@orpc/contract";
+import { getConstructor } from "@orpc/shared";
+export class Procedure {
+	"~orpc";
+	constructor(def) {
+		this["~orpc"] = def;
+	}
+	
+	static [Symbol.hasInstance](instance) {
+		if (this !== Procedure) {
+			
+			return Function.prototype[Symbol.hasInstance].call(this, instance);
+		}
+		const constructor = getConstructor(instance);
+		if (constructor === Procedure) {
+			return true;
+		}
+		return instance instanceof ProcedureContract && Array.isArray(instance["~orpc"].orderedMiddlewares) && typeof instance["~orpc"].handler === "function";
+	}
+}