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

package/dist/procedure-client.js

@@ -1,175 +1,158 @@
-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.js';
-export function createProcedureClient(lazyableProcedure, ...rest) {
-    const options = resolveMaybeOptionalOptions(rest);
-    return async (...[input, callerOptions]) => {
-        const path = toArray(options.path);
-        const { default: procedure } = await unlazy(lazyableProcedure);
-        // callerOptions.context can be undefined when all field is optional
-        const clientContext = callerOptions?.context ?? {};
-        // options.context can be undefined when all field is optional
-        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 can be optional if it is undefinable
-                    input: input,
-                    errors,
-                    path,
-                    procedure: procedure,
-                    signal: callerOptions?.signal,
-                    lastEventId: callerOptions?.lastEventId,
-                }, (interceptorOptions) => executeProcedureInternal(interceptorOptions.procedure, interceptorOptions));
-            });
-            if (isAsyncIteratorObject(output)) {
-                /**
-                 * traceAsyncIterator/wrapAsyncIteratorPreservingEventMeta return AsyncIteratorClass
-                 * which is backwards compatible with AsyncIteratorObject.
-                 *
-                 * @warning
-                 * If remove this return, can be breaking change
-                 * because AsyncIteratorClass convert `.throw` to `.return` (rarely used)
-                 *
-                 * @warning
-                 * Remember use `override` for AsyncIteratorObject to remain other special properties
-                 */
-                return override(output, wrapAsyncIteratorPreservingEventMeta(getTracer()
-                    ? traceAsyncIterator('consume_async_iterator_object_output', output)
-                    : output, { mapError: reconcileError }));
-            }
-            else if (getTracer() && output instanceof ReadableStream) {
-                /**
-                 * @warning
-                 * Remember use `override` for ReadableStream to remain other special properties
-                 */
-                return override(output, traceReadableStream('consume_octet_stream_output', output));
-            }
-            return output;
-        }
-        catch (e) {
-            throw await reconcileError(e);
-        }
-    };
+import { unlazy } from "./lazy.js";
+import { ValidationError, createORPCErrorConstructorMap, reconcileORPCError } from "@orpc/contract";
+import { getTracer, intercept, isAsyncIteratorObject, mergeTwoLevels, override, resolveMaybeOptionalOptions, runWithSpan, toArray, traceAsyncIterator, traceReadableStream, value } from "@orpc/shared";
+import { ORPCError, wrapAsyncIteratorPreservingEventMeta } from "@orpc/client";
+// src/procedure-client.ts
+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))
+ /**
+			* traceAsyncIterator/wrapAsyncIteratorPreservingEventMeta return AsyncIteratorClass
+			* which is backwards compatible with AsyncIteratorObject.
+			*
+			* @warning
+			* If remove this return, can be breaking change
+			* because AsyncIteratorClass convert `.throw` to `.return` (rarely used)
+			*
+			* @warning
+			* Remember use `override` for AsyncIteratorObject to remain other special properties
+			*/
+			return override(output, wrapAsyncIteratorPreservingEventMeta(getTracer() ? traceAsyncIterator("consume_async_iterator_object_output", output) : output, { mapError: reconcileError }));
+			else if (getTracer() && output instanceof ReadableStream)
+ /**
+			* @warning
+			* Remember use `override` for ReadableStream to remain other special properties
+			*/
+			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;
-    });
+	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;
-    });
+	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 can be undefined when all field is optional
-        context: options.context ?? {},
-    };
+	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);
-        /**
-         * Each schema after the first validates the original input with the results so far applied, then
-         * its result is merged in, so no schema loses a field an earlier one stripped. Values that are not
-         * plain objects stay piped, which keeps schemas like `asyncIteratorObject` wrapping each other.
-         */
-        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);
-                        // context can be undefined when all field is optional
-                        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;
+	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;
+		/**
+		* Each schema after the first validates the original input with the results so far applied, then
+		* its result is merged in, so no schema loses a field an earlier one stripped. Values that are not
+		* plain objects stay piped, which keeps schemas like `asyncIteratorObject` wrapping each other.
+		*/
+		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;
 }
+export { createProcedureClient };

package/dist/procedure-decorated.d.ts

@@ -1,10 +1,10 @@
-import type { AnySchema, ErrorMap, InferSchemaInput, InferSchemaOutput, MergedErrorMap, MetaPlugin } from '@orpc/contract';
-import type { IntersectPick } from '@orpc/shared';
-import type { Context, MergedContext, MergedInitialContext } from './context.ts';
-import type { Middleware } from './middleware.ts';
-import { Procedure } from './procedure.ts';
+import { Context, MergedContext, MergedInitialContext } from "./context.js";
+import { Middleware } from "./middleware.js";
+import { Procedure } from "./procedure.js";
+import { AnySchema, ErrorMap, InferSchemaInput, InferSchemaOutput, MergedErrorMap, MetaPlugin } from "@orpc/contract";
+import { IntersectPick } from "@orpc/shared";
 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>>;
-}
+  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.js

@@ -1,44 +1,36 @@
-import { getHiddenMetaPlugins, mergeErrorMap, resolveMetaPlugins } from '@orpc/contract';
-import { Procedure } from './procedure.js';
-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) {
-        // Since middleware executes before the handler, we use `IntersectPick` to ensure
-        // that the middleware's output context ($OutContext) is compatible with the
-        // context requirements of the handler, which may have already been defined.
-        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;
-    }
-}
+import { Procedure } from "./procedure.js";
+import { getHiddenMetaPlugins, mergeErrorMap, resolveMetaPlugins } from "@orpc/contract";
+// src/procedure-decorated.ts
+var DecoratedProcedure = 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;
+	}
+};
+export { DecoratedProcedure };

package/dist/procedure-utils.d.ts

@@ -1,32 +1,12 @@
-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.ts';
-import type { Lazyable } from './lazy.ts';
-import { Lazy } from './lazy.ts';
-import type { ProcedureClientOptions } from './procedure-client.ts';
-import type { AnyProcedure } from './procedure.ts';
-import { Procedure } from './procedure.ts';
-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>
-];
+import { Context } from "./context.js";
+import { Lazyable } from "./lazy.js";
+import { Procedure } from "./procedure.js";
+import { ProcedureClientOptions } from "./procedure-client.js";
+import { AnySchema, ErrorMap, InferSchemaInput, InferSchemaOutput, ORPCErrorFromErrorMap } from "@orpc/contract";
+import { PromiseWithError, ThrowableError as ThrowableError$1 } from "@orpc/shared";
+import { ClientOptions } from "@orpc/client";
+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.
  *
@@ -38,4 +18,4 @@ export type CallRest<TInitialContext extends Context, TInputSchema extends AnySc
  *
  * @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>;
+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$1>;

package/dist/procedure-utils.js

@@ -1,49 +1,48 @@
-import { Lazy, unlazy } from './lazy.js';
-import { createProcedureClient } from './procedure-client.js';
-import { Procedure } from './procedure.js';
-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(`
+import { Lazy, unlazy } from "./lazy.js";
+import { Procedure } from "./procedure.js";
+import { createProcedureClient } from "./procedure-client.js";
+// src/procedure-utils.ts
+function createGuardedProcedureLazy(lazy) {
+	return 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;
+			return { default: maybeProcedure };
+		}
+	});
 }
 /**
- * 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 function createContractProcedure(procedure, contract) {
-    return new Procedure({
-        ...procedure['~orpc'],
-        errorMap: contract['~orpc'].errorMap,
-        meta: contract['~orpc'].meta,
-        metaPlugins: contract['~orpc'].metaPlugins,
-    });
+* 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.
+*/
+function createContractProcedure(procedure, contract) {
+	return new Procedure({
+		...procedure["~orpc"],
+		errorMap: contract["~orpc"].errorMap,
+		meta: contract["~orpc"].meta,
+		metaPlugins: contract["~orpc"].metaPlugins
+	});
 }
 /**
- * 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 function call(lazyableProcedure, ...[input = undefined, options = {},]) {
-    return createProcedureClient(lazyableProcedure, options)(input, options);
+* 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}
+*/
+function call(lazyableProcedure, ...[input = void 0, options = {}]) {
+	return createProcedureClient(lazyableProcedure, options)(input, options);
 }
+export { call, createContractProcedure, createGuardedProcedureLazy };