@temporary-name/server 1.9.3-alpha.5c041722542bb790586629fc98d4c72d9f6ee65e → 1.9.3-alpha.5dc8b200530586870ac736830d4584e0333cfd05

package/dist/shared/{server.B5czSQQh.d.ts → server.DkYpsO6W.d.ts}

@@ -1,9 +1,12 @@
-import { ErrorMap, ErrorMapItem, InferSchemaInput, Schemas, Meta, ContractProcedureDef, AnyContractRouter, ContractProcedure, InferSchemaOutput, EnhanceRouteOptions, MergedErrorMap, AnyContractProcedure, ContractRouter, AnySchema, ErrorFromErrorMap } from '@temporary-name/contract';
-import { ORPCErrorCode, MaybeOptionalOptions, ORPCErrorOptions, ORPCError, Promisable, HTTPPath, ClientContext, Interceptor, PromiseWithError, Value, Client } from '@temporary-name/shared';
+import { ErrorMap, ErrorMapItem, InferSchemaInput, Meta, Schemas, ContractProcedureDef, AnyContractRouter, ContractProcedure, InferProcedureClientInputs, InferSchemaOutput, EnhanceRouteOptions, MergedErrorMap, AnyContractProcedure, ContractRouter, AnySchema, ErrorFromErrorMap } from '@temporary-name/contract';
+import { ORPCErrorCode, MaybeOptionalOptions, ORPCErrorOptions, ORPCError, Promisable, StandardLazyRequest, HTTPPath, ClientContext, Interceptor, PromiseWithError, Value, Client } from '@temporary-name/shared';
 
 type Context = Record<PropertyKey, any>;
 type MergedInitialContext<TInitial extends Context, TAdditional extends Context, TCurrent extends Context> = TInitial & Omit<TAdditional, keyof TCurrent>;
 type MergedCurrentContext<T extends Context, U extends Context> = Omit<T, keyof U> & U;
+type BuildContextWithAuth<TContext extends Context, TAuthContext> = MergedCurrentContext<TContext, {
+    auth: TAuthContext | ('auth' extends keyof TContext ? TContext['auth'] : never);
+}>;
 declare function mergeCurrentContext<T extends Context, U extends Context>(context: T, other: U): MergedCurrentContext<T, U>;
 
 type ORPCErrorConstructorMapItemOptions<TData> = Omit<ORPCErrorOptions<TData>, 'defined' | 'status'>;
@@ -13,21 +16,56 @@ type ORPCErrorConstructorMap<T extends ErrorMap> = {
 };
 declare function createORPCErrorConstructorMap<T extends ErrorMap>(errors: T): ORPCErrorConstructorMap<T>;
 
-interface ProcedureHandlerOptions<TCurrentContext extends Context, TInput, TErrorConstructorMap extends ORPCErrorConstructorMap<any>, TMeta extends Meta> {
+type MiddlewareResult<TOutContext extends Context, TOutput> = Promisable<{
+    output: TOutput;
+    context: TOutContext;
+}>;
+interface MiddlewareNextFn<TOutput> {
+    <U extends Context = {}>(options?: {
+        context?: U;
+    }): MiddlewareResult<U, TOutput>;
+}
+interface MiddlewareOutputFn<TOutput> {
+    (output: TOutput): MiddlewareResult<Record<never, never>, TOutput>;
+}
+interface MiddlewareOptions<TInContext extends Context, TOutput, TErrorConstructorMap extends ORPCErrorConstructorMap<any>, TMeta extends Meta> extends ProcedureHandlerOptions<TInContext, TErrorConstructorMap, TMeta> {
+    next: MiddlewareNextFn<TOutput>;
+}
+/**
+ * A function that represents a middleware.
+ *
+ * @see {@link https://orpc.unnoq.com/docs/middleware Middleware Docs}
+ */
+interface Middleware<TInContext extends Context, TOutContext extends Context, TInput, TOutput, TErrorConstructorMap extends ORPCErrorConstructorMap<any>, TMeta extends Meta> {
+    (options: MiddlewareOptions<TInContext, TOutput, TErrorConstructorMap, TMeta>, input: TInput, output: MiddlewareOutputFn<TOutput>): Promisable<MiddlewareResult<TOutContext, TOutput>>;
+}
+type AnyMiddleware = Middleware<any, any, any, any, any, any>;
+interface MapInputMiddleware<TInput, TMappedInput> {
+    (input: TInput): TMappedInput;
+}
+declare function middlewareOutputFn<TOutput>(output: TOutput): MiddlewareResult<Record<never, never>, TOutput>;
+
+type DefaultProcedureHandlerOptions = ProcedureHandlerOptions<Context, ORPCErrorConstructorMap<ErrorMap>, Meta>;
+interface ProcedureHandlerOptions<TCurrentContext extends Context, TErrorConstructorMap extends ORPCErrorConstructorMap<any>, TMeta extends Meta> {
     context: TCurrentContext;
-    input: TInput;
     path: readonly string[];
     procedure: Procedure<Context, Context, Schemas, ErrorMap, TMeta>;
     signal?: AbortSignal;
+    request?: StandardLazyRequest;
     lastEventId: string | undefined;
     errors: TErrorConstructorMap;
 }
-interface ProcedureHandler<TCurrentContext extends Context, TInput, THandlerOutput, TErrorMap extends ErrorMap, TMeta extends Meta> {
-    (opt: ProcedureHandlerOptions<TCurrentContext, TInput, ORPCErrorConstructorMap<TErrorMap>, TMeta>): Promisable<THandlerOutput>;
+interface ProcedureHandler<TCurrentContext extends Context, TInput extends {
+    path: any;
+    query: any;
+    body: any;
+}, THandlerOutput, TErrorMap extends ErrorMap, TMeta extends Meta> {
+    (input: TInput, opt: ProcedureHandlerOptions<TCurrentContext, ORPCErrorConstructorMap<TErrorMap>, TMeta>): Promisable<THandlerOutput>;
 }
 interface ProcedureDef<TInitialContext extends Context, TCurrentContext extends Context, TSchemas extends Schemas, TErrorMap extends ErrorMap, TMeta extends Meta> extends ContractProcedureDef<TSchemas, TErrorMap, TMeta> {
     __initialContext?: (type: TInitialContext) => unknown;
     middlewares: readonly AnyMiddleware[];
+    authConfigs: TypedAuthConfig[];
     inputValidationIndex: number;
     outputValidationIndex: number;
     handler: ProcedureHandler<TCurrentContext, any, any, any, any>;
@@ -47,43 +85,23 @@ declare class Procedure<TInitialContext extends Context, TCurrentContext extends
 type AnyProcedure = Procedure<any, any, Schemas, any, any>;
 declare function isProcedure(item: unknown): item is AnyProcedure;
 
-type MiddlewareResult<TOutContext extends Context, TOutput> = Promisable<{
-    output: TOutput;
-    context: TOutContext;
-}>;
-type MiddlewareNextFnOptions<TOutContext extends Context> = Record<never, never> extends TOutContext ? {
-    context?: TOutContext;
-} : {
-    context: TOutContext;
-};
-interface MiddlewareNextFn<TOutput> {
-    <U extends Context = Record<never, never>>(...rest: MaybeOptionalOptions<MiddlewareNextFnOptions<U>>): MiddlewareResult<U, TOutput>;
-}
-interface MiddlewareOutputFn<TOutput> {
-    (output: TOutput): MiddlewareResult<Record<never, never>, TOutput>;
-}
-interface MiddlewareOptions<TInContext extends Context, TOutput, TErrorConstructorMap extends ORPCErrorConstructorMap<any>, TMeta extends Meta> {
-    context: TInContext;
-    path: readonly string[];
-    procedure: Procedure<Context, Context, Schemas, ErrorMap, TMeta>;
-    signal?: AbortSignal;
-    lastEventId: string | undefined;
-    next: MiddlewareNextFn<TOutput>;
-    errors: TErrorConstructorMap;
-}
-/**
- * A function that represents a middleware.
- *
- * @see {@link https://orpc.unnoq.com/docs/middleware Middleware Docs}
- */
-interface Middleware<TInContext extends Context, TOutContext extends Context, TInput, TOutput, TErrorConstructorMap extends ORPCErrorConstructorMap<any>, TMeta extends Meta> {
-    (options: MiddlewareOptions<TInContext, TOutput, TErrorConstructorMap, TMeta>, input: TInput, output: MiddlewareOutputFn<TOutput>): Promisable<MiddlewareResult<TOutContext, TOutput>>;
-}
-type AnyMiddleware = Middleware<any, any, any, any, any, any>;
-interface MapInputMiddleware<TInput, TMappedInput> {
-    (input: TInput): TMappedInput;
-}
-declare function middlewareOutputFn<TOutput>(output: TOutput): MiddlewareResult<Record<never, never>, TOutput>;
+type ValidatedAuthContext = {};
+interface BasicAuthConfig<TAuthContext extends ValidatedAuthContext, TCurrentContext extends Context, TMeta extends Meta> {
+    tokenPrefix?: string;
+    validate: (username: string, password: string, options: ProcedureHandlerOptions<TCurrentContext, ORPCErrorConstructorMap<any>, TMeta>) => Promisable<TAuthContext>;
+}
+interface TokenAuthConfig<TAuthContext extends ValidatedAuthContext, TCurrentContext extends Context, TMeta extends Meta> {
+    tokenPrefix?: string;
+    validate: (token: string, options: ProcedureHandlerOptions<TCurrentContext, ORPCErrorConstructorMap<any>, TMeta>) => Promisable<TAuthContext>;
+}
+interface NamedTokenAuthConfig<TAuthContext extends ValidatedAuthContext, TCurrentContext extends Context, TMeta extends Meta> extends TokenAuthConfig<TAuthContext, TCurrentContext, TMeta> {
+    name: string;
+}
+type AuthType = 'header' | 'query' | 'cookie' | 'bearer' | 'basic' | 'none';
+type AuthConfig<TAuthType extends AuthType, TAuthContext extends ValidatedAuthContext = ValidatedAuthContext, TCurrentContext extends Context = Context, TMeta extends Meta = Meta> = TAuthType extends 'basic' ? BasicAuthConfig<TAuthContext, TCurrentContext, TMeta> : TAuthType extends 'bearer' ? TokenAuthConfig<TAuthContext, TCurrentContext, TMeta> : TAuthType extends 'header' ? NamedTokenAuthConfig<TAuthContext, TCurrentContext, TMeta> : TAuthType extends 'query' ? NamedTokenAuthConfig<TAuthContext, TCurrentContext, TMeta> : TAuthType extends 'cookie' ? NamedTokenAuthConfig<TAuthContext, TCurrentContext, TMeta> : TAuthType extends 'none' ? {} : never;
+type TypedAuthConfig<TAuthType extends AuthType = AuthType> = {
+    type: TAuthType;
+} & AuthConfig<TAuthType, object>;
 
 /**
  * Represents a router, which defines a hierarchical structure of procedures.
@@ -120,7 +138,7 @@ type InferRouterCurrentContexts<T extends AnyRouter> = T extends Procedure<any,
  * @info A procedure is a router too.
  * @see {@link https://orpc.unnoq.com/docs/router#utilities Router Utilities Docs}
  */
-type InferRouterInputs<T extends AnyRouter> = T extends Procedure<any, any, infer USchemas, any, any> ? InferSchemaInput<USchemas['inputSchema']> : {
+type InferRouterInputs<T extends AnyRouter> = T extends Procedure<any, any, infer USchemas, any, any> ? InferProcedureClientInputs<USchemas> : {
     [K in keyof T]: T[K] extends Lazyable<infer U extends AnyRouter> ? InferRouterInputs<U> : never;
 };
 /**
@@ -203,15 +221,13 @@ declare function unlazy<T extends Lazyable<any>>(lazied: T): Promise<{
     default: T extends Lazy<infer U> ? U : T;
 }>;
 
-type ProcedureClient<TClientContext extends ClientContext, TSchemas extends Schemas, TErrorMap extends ErrorMap> = Client<TClientContext, InferSchemaInput<TSchemas['inputSchema']>, InferSchemaOutput<TSchemas['outputSchema']>, ErrorFromErrorMap<TErrorMap>>;
-interface ProcedureClientInterceptorOptions<TInitialContext extends Context, TErrorMap extends ErrorMap, TMeta extends Meta> {
-    context: TInitialContext;
-    input: unknown;
-    errors: ORPCErrorConstructorMap<TErrorMap>;
-    path: readonly string[];
-    procedure: Procedure<Context, Context, Schemas, ErrorMap, TMeta>;
-    signal?: AbortSignal;
-    lastEventId: string | undefined;
+type ProcedureClient<TClientContext extends ClientContext, TSchemas extends Schemas, TErrorMap extends ErrorMap> = Client<TClientContext, InferProcedureClientInputs<TSchemas>, InferSchemaOutput<TSchemas['outputSchema']>, ErrorFromErrorMap<TErrorMap>>;
+interface ProcedureClientInterceptorOptions<TInitialContext extends Context, TErrorMap extends ErrorMap, TMeta extends Meta> extends ProcedureHandlerOptions<TInitialContext, ORPCErrorConstructorMap<TErrorMap>, TMeta> {
+    input: {
+        path: unknown;
+        query: unknown;
+        body: unknown;
+    };
 }
 type CreateProcedureClientOptions<TInitialContext extends Context, TOutputSchema extends AnySchema, TErrorMap extends ErrorMap, TMeta extends Meta, TClientContext extends ClientContext> = {
     /**
@@ -231,5 +247,5 @@ type CreateProcedureClientOptions<TInitialContext extends Context, TOutputSchema
  */
 declare function createProcedureClient<TInitialContext extends Context, TSchemas extends Schemas, TErrorMap extends ErrorMap, TMeta extends Meta, TClientContext extends ClientContext>(lazyableProcedure: Lazyable<Procedure<TInitialContext, any, TSchemas, TErrorMap, TMeta>>, ...rest: MaybeOptionalOptions<CreateProcedureClientOptions<TInitialContext, TSchemas['outputSchema'], TErrorMap, TMeta, TClientContext>>): ProcedureClient<TClientContext, TSchemas, TErrorMap>;
 
-export { traverseContractProcedures as $, middlewareOutputFn as B, isProcedure as G, createProcedureClient as J, Procedure as P, getRouter as T, createAccessibleLazyRouter as V, enhanceRouter as W, resolveContractProcedures as a0, unlazyRouter as a2, mergeCurrentContext as m, createORPCErrorConstructorMap as n, LAZY_SYMBOL as o, lazyInternal as q, lazy as r, isLazy as s, getLazyMeta as t, unlazy as u };
-export type { AnyMiddleware as A, Context as C, ProcedureHandlerOptions as D, EnhanceRouterOptions as E, ProcedureDef as F, ProcedureClientInterceptorOptions as H, InferRouterInitialContext as I, InferRouterInitialContexts as K, Lazy as L, Middleware as M, InferRouterCurrentContexts as N, ORPCErrorConstructorMap as O, InferRouterInputs as Q, Router as R, InferRouterOutputs as S, AccessibleLazyRouter as U, TraverseContractProceduresOptions as X, TraverseContractProcedureCallbackOptions as Y, ContractProcedureCallbackOptions as Z, LazyTraverseContractProceduresOptions as _, CreateProcedureClientOptions as a, UnlaziedRouter as a1, ProcedureClient as b, MergedInitialContext as c, MergedCurrentContext as d, ProcedureHandler as e, EnhancedRouter as f, MapInputMiddleware as g, AnyProcedure as h, Lazyable as i, AnyRouter as j, ORPCErrorConstructorMapItemOptions as k, ORPCErrorConstructorMapItem as l, LazyMeta as p, MiddlewareResult as v, MiddlewareNextFnOptions as w, MiddlewareNextFn as x, MiddlewareOutputFn as y, MiddlewareOptions as z };
+export { enhanceRouter as $, middlewareOutputFn as F, isProcedure as K, Procedure as P, createProcedureClient as Q, getRouter as Y, createAccessibleLazyRouter as _, traverseContractProcedures as a4, resolveContractProcedures as a5, unlazyRouter as a7, mergeCurrentContext as m, createORPCErrorConstructorMap as p, LAZY_SYMBOL as q, lazyInternal as s, lazy as t, isLazy as u, getLazyMeta as v, unlazy as w };
+export type { AuthType as A, BuildContextWithAuth as B, Context as C, MiddlewareOptions as D, EnhanceRouterOptions as E, DefaultProcedureHandlerOptions as G, ProcedureHandlerOptions as H, InferRouterInitialContext as I, ProcedureDef as J, Lazy as L, Middleware as M, ProcedureClientInterceptorOptions as N, ORPCErrorConstructorMap as O, Router as R, InferRouterInitialContexts as S, TypedAuthConfig as T, InferRouterCurrentContexts as U, ValidatedAuthContext as V, InferRouterInputs as W, InferRouterOutputs as X, AccessibleLazyRouter as Z, CreateProcedureClientOptions as a, TraverseContractProceduresOptions as a0, TraverseContractProcedureCallbackOptions as a1, ContractProcedureCallbackOptions as a2, LazyTraverseContractProceduresOptions as a3, UnlaziedRouter as a6, ProcedureClient as b, MergedInitialContext as c, MergedCurrentContext as d, AuthConfig as e, ProcedureHandler as f, EnhancedRouter as g, MapInputMiddleware as h, AnyMiddleware as i, AnyProcedure as j, Lazyable as k, AnyRouter as l, ORPCErrorConstructorMapItemOptions as n, ORPCErrorConstructorMapItem as o, LazyMeta as r, MiddlewareResult as x, MiddlewareNextFn as y, MiddlewareOutputFn as z };

package/dist/shared/{server.D7UjcuIv.d.ts → server.DwNnHUZP.d.ts}

@@ -1,6 +1,6 @@
 import { HTTPPath } from '@temporary-name/shared';
-import { C as Context } from './server.B5czSQQh.js';
-import { c as StandardHandleOptions } from './server.C4l2ZA3m.js';
+import { C as Context } from './server.DkYpsO6W.js';
+import { c as StandardHandleOptions } from './server.B-meye9-.js';
 
 type FriendlyStandardHandleOptions<T extends Context> = Omit<StandardHandleOptions<T>, 'context'> & (Record<never, never> extends T ? {
     context?: T;

package/dist/shared/{server.Bk8Hmx7Z.d.mts → server.I-tTl_ce.d.mts}

@@ -1,6 +1,6 @@
 import { HTTPPath } from '@temporary-name/shared';
-import { C as Context } from './server.B5czSQQh.mjs';
-import { c as StandardHandleOptions } from './server.TgmlNh8r.mjs';
+import { C as Context } from './server.DkYpsO6W.mjs';
+import { c as StandardHandleOptions } from './server.vLcMd_kA.mjs';
 
 type FriendlyStandardHandleOptions<T extends Context> = Omit<StandardHandleOptions<T>, 'context'> & (Record<never, never> extends T ? {
     context?: T;

package/dist/shared/{server.Kxw442A9.mjs → server.JtIZ8YG7.mjs}

@@ -234,14 +234,4 @@ function deserialize(data) {
   return data;
 }
 
-function standardizeHTTPPath(path) {
-  return `/${path.replace(/\/{2,}/g, "/").replace(/^\/|\/$/g, "")}`;
-}
-function getDynamicParams(path) {
-  return path ? standardizeHTTPPath(path).match(/\/\{[^}]+\}/g)?.map((v) => ({
-    raw: v,
-    name: v.match(/\{\+?([^}]+)\}/)[1]
-  })) : void 0;
-}
-
-export { standardizeHTTPPath as a, bracketNotationDeserialize as b, deserialize as d, getDynamicParams as g, jsonSerialize as j, serialize as s };
+export { bracketNotationDeserialize as b, deserialize as d, jsonSerialize as j, serialize as s };

package/dist/shared/{server.BdGbIyq8.mjs → server.miXh-9wo.mjs}

@@ -1,7 +1,7 @@
 import { isContractProcedure, mergePrefix, mergeErrorMap, enhanceRoute, validateORPCError, ValidationError } from '@temporary-name/contract';
 import { resolveMaybeOptionalOptions, ORPCError, toArray, value, runWithSpan, intercept, isAsyncIteratorObject, overlayProxy, asyncIteratorWithSpan } from '@temporary-name/shared';
 import { HibernationEventIterator, mapEventIterator } from '@temporary-name/standard-server';
-import { safeParseAsync } from '@temporary-name/zod';
+import { safeDecodeAsync, safeEncodeAsync } from '@temporary-name/zod';
 
 function isStartWithMiddlewares(middlewares, compare) {
   if (compare.length > middlewares.length) {
@@ -269,14 +269,17 @@ function createProcedureClient(lazyableProcedure, ...rest) {
           {
             context,
             input,
-            // input only optional when it undefinable so we can safely cast it
             errors,
             path,
             procedure,
+            request: callerOptions?.request,
             signal: callerOptions?.signal,
             lastEventId: callerOptions?.lastEventId
           },
-          (interceptorOptions) => executeProcedureInternal(interceptorOptions.procedure, interceptorOptions)
+          (interceptorOptions) => {
+            const { input: input2, ...opts } = interceptorOptions;
+            return executeProcedureInternal(interceptorOptions.procedure, input2, opts);
+          }
         );
       });
       if (isAsyncIteratorObject(output)) {
@@ -304,26 +307,40 @@ function createProcedureClient(lazyableProcedure, ...rest) {
   };
 }
 async function validateInput(procedure, input) {
-  const schema = procedure["~orpc"].schemas.inputSchema;
-  if (!schema) {
-    return input;
-  }
+  const schemas = procedure["~orpc"].schemas;
   return runWithSpan({ name: "validate_input" }, async () => {
-    const result = await safeParseAsync(schema, input);
-    if (!result.success) {
+    const resultBody = await safeDecodeAsync(schemas.bodySchema, input.body, { parseType: "body" });
+    const resultPath = await safeDecodeAsync(schemas.pathSchema, input.path, { parseType: "path" });
+    const resultQuery = await safeDecodeAsync(schemas.querySchema, input.query, { parseType: "query" });
+    const issues = [];
+    if (!resultBody.success) {
+      issues.push(...resultBody.error.issues.map((i) => ({ ...i, path: ["body", ...i.path] })));
+    }
+    if (!resultPath.success) {
+      issues.push(...resultPath.error.issues.map((i) => ({ ...i, path: ["path", ...i.path] })));
+    }
+    if (!resultQuery.success) {
+      issues.push(...resultQuery.error.issues.map((i) => ({ ...i, path: ["query", ...i.path] })));
+    }
+    if (issues.length > 0) {
       throw new ORPCError("BAD_REQUEST", {
         message: "Input validation failed",
         data: {
-          issues: result.error.issues
+          issues
         },
         cause: new ValidationError({
           message: "Input validation failed",
-          issues: result.error.issues,
+          issues,
           data: input
         })
       });
     }
-    return result.data;
+    const results = {
+      body: resultBody.data,
+      path: resultPath.data,
+      query: resultQuery.data
+    };
+    return results;
   });
 }
 async function validateOutput(procedure, output) {
@@ -332,7 +349,7 @@ async function validateOutput(procedure, output) {
     return output;
   }
   return runWithSpan({ name: "validate_output" }, async () => {
-    const result = await safeParseAsync(schema, output);
+    const result = await safeEncodeAsync(schema, output, { parseType: "output" });
     if (!result.success) {
       throw new ORPCError("INTERNAL_SERVER_ERROR", {
         message: "Output validation failed",
@@ -346,7 +363,7 @@ async function validateOutput(procedure, output) {
     return result.data;
   });
 }
-async function executeProcedureInternal(procedure, options) {
+async function executeProcedureInternal(procedure, input, options) {
   const middlewares = procedure["~orpc"].middlewares;
   const inputValidationIndex = Math.min(
     Math.max(0, procedure["~orpc"].inputValidationIndex),
@@ -356,8 +373,8 @@ async function executeProcedureInternal(procedure, options) {
     Math.max(0, procedure["~orpc"].outputValidationIndex),
     middlewares.length
   );
-  const next = async (index, context, input) => {
-    let currentInput = input;
+  const next = async (index, context, input2) => {
+    let currentInput = input2;
     if (index === inputValidationIndex) {
       currentInput = await validateInput(procedure, currentInput);
     }
@@ -373,6 +390,9 @@ async function executeProcedureInternal(procedure, options) {
             const nextContext = nextOptions?.context ?? {};
             return {
               output: await next(index + 1, mergeCurrentContext(context, nextContext), currentInput),
+              // NB: Pretty sure this isn't used (or meant to be used) at runtime, it's just there
+              // to get type inference in the builder (via the caller returning the output of next() in
+              // the middleware function)
               context: nextContext
             };
           }
@@ -383,14 +403,14 @@ async function executeProcedureInternal(procedure, options) {
       return result.output;
     }) : await runWithSpan(
       { name: "handler", signal: options.signal },
-      () => procedure["~orpc"].handler({ ...options, context, input: currentInput })
+      () => procedure["~orpc"].handler(currentInput, { ...options, context })
     );
     if (index === outputValidationIndex) {
       return await validateOutput(procedure, output);
     }
     return output;
   };
-  return next(0, options.context, options.input);
+  return next(0, options.context, input);
 }
 
 export { LAZY_SYMBOL as L, Procedure as P, addMiddleware as a, isLazy as b, createProcedureClient as c, getRouter as d, enhanceRouter as e, createORPCErrorConstructorMap as f, getLazyMeta as g, lazy as h, isProcedure as i, middlewareOutputFn as j, isStartWithMiddlewares as k, lazyInternal as l, mergeCurrentContext as m, mergeMiddlewares as n, getHiddenRouterContract as o, createAccessibleLazyRouter as p, unlazyRouter as q, resolveContractProcedures as r, setHiddenRouterContract as s, traverseContractProcedures as t, unlazy as u };

package/dist/shared/{server.TgmlNh8r.d.mts → server.vLcMd_kA.d.mts}

@@ -1,7 +1,6 @@
 import { Meta } from '@temporary-name/contract';
-import { HTTPPath, Interceptor } from '@temporary-name/shared';
-import { StandardLazyRequest, StandardResponse } from '@temporary-name/standard-server';
-import { C as Context, R as Router, H as ProcedureClientInterceptorOptions } from './server.B5czSQQh.mjs';
+import { HTTPPath, StandardLazyRequest, Interceptor, StandardResponse } from '@temporary-name/shared';
+import { C as Context, R as Router, N as ProcedureClientInterceptorOptions } from './server.DkYpsO6W.mjs';
 
 interface StandardHandlerPlugin<T extends Context> {
     order?: number;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@temporary-name/server",
   "type": "module",
-  "version": "1.9.3-alpha.5c041722542bb790586629fc98d4c72d9f6ee65e",
+  "version": "1.9.3-alpha.5dc8b200530586870ac736830d4584e0333cfd05",
   "license": "MIT",
   "homepage": "https://www.stainless.com/",
   "repository": {
@@ -57,31 +57,19 @@
   "files": [
     "dist"
   ],
-  "peerDependencies": {
-    "drizzle-orm": "^0.44.5",
-    "drizzle-zod": "^0.8.3"
-  },
-  "peerDependenciesMeta": {
-    "drizzle-orm": {
-      "optional": true
-    },
-    "drizzle-zod": {
-      "optional": true
-    }
-  },
   "dependencies": {
     "cookie": "^1.0.2",
     "rou3": "^0.7.7",
     "zod": "^4.1.12",
-    "@temporary-name/interop": "1.9.3-alpha.5c041722542bb790586629fc98d4c72d9f6ee65e",
-    "@temporary-name/json-schema": "1.9.3-alpha.5c041722542bb790586629fc98d4c72d9f6ee65e",
-    "@temporary-name/shared": "1.9.3-alpha.5c041722542bb790586629fc98d4c72d9f6ee65e",
-    "@temporary-name/standard-server": "1.9.3-alpha.5c041722542bb790586629fc98d4c72d9f6ee65e",
-    "@temporary-name/standard-server-aws-lambda": "1.9.3-alpha.5c041722542bb790586629fc98d4c72d9f6ee65e",
-    "@temporary-name/contract": "1.9.3-alpha.5c041722542bb790586629fc98d4c72d9f6ee65e",
-    "@temporary-name/standard-server-fetch": "1.9.3-alpha.5c041722542bb790586629fc98d4c72d9f6ee65e",
-    "@temporary-name/standard-server-node": "1.9.3-alpha.5c041722542bb790586629fc98d4c72d9f6ee65e",
-    "@temporary-name/zod": "1.9.3-alpha.5c041722542bb790586629fc98d4c72d9f6ee65e"
+    "@temporary-name/contract": "1.9.3-alpha.5dc8b200530586870ac736830d4584e0333cfd05",
+    "@temporary-name/interop": "1.9.3-alpha.5dc8b200530586870ac736830d4584e0333cfd05",
+    "@temporary-name/shared": "1.9.3-alpha.5dc8b200530586870ac736830d4584e0333cfd05",
+    "@temporary-name/standard-server": "1.9.3-alpha.5dc8b200530586870ac736830d4584e0333cfd05",
+    "@temporary-name/standard-server-aws-lambda": "1.9.3-alpha.5dc8b200530586870ac736830d4584e0333cfd05",
+    "@temporary-name/standard-server-fetch": "1.9.3-alpha.5dc8b200530586870ac736830d4584e0333cfd05",
+    "@temporary-name/standard-server-node": "1.9.3-alpha.5dc8b200530586870ac736830d4584e0333cfd05",
+    "@temporary-name/zod": "1.9.3-alpha.5dc8b200530586870ac736830d4584e0333cfd05",
+    "@temporary-name/json-schema": "1.9.3-alpha.5dc8b200530586870ac736830d4584e0333cfd05"
   },
   "devDependencies": {
     "@types/supertest": "^6.0.3",