@taserjs/router 0.0.4 → 0.1.0

package/dist/esm/types/index.d.ts

@@ -1,15 +1,15 @@
 import { Awaitable, TaserCookieJar, TaserHeaders } from '@taserjs/router-core';
 import { RouterRegister } from '../register.js';
-import { MergeMiddlewareField, MergeMiddlewareInputField, MergePart, RequestShape, RuntimeContextFields, Simplify, UnionToIntersection } from './type-utils.js';
+import { MergeMiddlewareField, MergeMiddlewareInputField, MergePart, RequestShape, Simplify, UnionToIntersection, UnitRuntimeContext } from './type-utils.js';
 import { ReturnsMap, ValidHandlerReply } from './returns.js';
 import { Schema } from './schema.js';
-import { AppContext, ExtractState, HandlerContext, HandlerUnit, InlineMiddlewareOptions, Method, MiddlewareDefinition, MiddlewareReturnFromParts, MiddlewareUnit, NativeContext, ValidatorParts } from './units.js';
+import { AppContext, ExtractState, HandlerContext, HandlerUnit, InlineMiddlewareOptions, Method, MiddlewareDefinition, MiddlewareReturnFromParts, MiddlewareUnit, ValidatorParts } from './units.js';
 export type { Awaitable } from '@taserjs/router-core';
 export type { SchemaRequestShape, InferInput, InferOutput, Schema, StandardSchemaV1, } from './schema.js';
 export type { RouterRegister } from '../register.js';
-export type { MergeMiddlewareField, MergeMiddlewareInputField, MergePart, RequestShape, Simplify, UnwrapPart, } from './type-utils.js';
-export type { EmptyReturns, EnforceHandlerReply, HandlerReply, HasReturns, MergeReturns, ReplyResultFor, ReturnsMap, StatusCode, ValidHandlerReply, } from './returns.js';
-export type { AppContext, ExtractState, HandlerContext, HandlerUnit, HttpMethod, InlineMiddlewareOptions, IsUnknown, Method, MiddlewareDefinition, MiddlewareNext, MiddlewareReturnFromParts, MiddlewareUnit, NativeContext, NextFn, NextResult, StandaloneMiddlewareContext, StateBrand, ValidatorParts, } from './units.js';
+export type { MergeMiddlewareField, MergeMiddlewareInputField, MergePart, RequestShape, Simplify, UnitRuntimeContext, UnwrapPart, } from './type-utils.js';
+export type { EmptyReturns, EnforceHandlerReply, HandlerReply, HasReturns, MergeReturns, ReplyFor, ReturnsMap, StatusCode, ValidHandlerReply, } from './returns.js';
+export type { AppContext, ExtractState, HandlerContext, HandlerUnit, HttpMethod, InlineMiddlewareOptions, IsUnknown, Method, MiddlewareDefinition, MiddlewareNext, MiddlewareReturnFromParts, MiddlewareUnit, NextFn, NextResult, StandaloneMiddlewareContext, StateBrand, ValidatorParts, } from './units.js';
 export type RoutePath = RouterRegister extends {
     RoutePath: infer P;
 } ? P : never;
@@ -29,6 +29,7 @@ type ParseParam<Segment extends string> = Segment extends "*" ? {
 } : {};
 type ParseParamsFromSegments<S extends string> = S extends `${infer Segment}/${infer Rest}` ? ParseParam<Segment> & ParseParamsFromSegments<Rest> : ParseParam<S>;
 export type PathParams<Path extends string> = Path extends `/${infer Rest}` ? ParseParamsFromSegments<Rest> : {};
+export type ResolveParams<TPathParams, TSchemaParams> = TSchemaParams extends Record<string, unknown> ? [keyof TSchemaParams] extends [never] ? TPathParams : Simplify<Omit<TPathParams, keyof TSchemaParams> & TSchemaParams> : TPathParams;
 type LayoutParent<Layout extends LayoutId> = LayoutTree[Layout] extends {
     parent: infer Parent extends LayoutId | null;
 } ? Parent : null;
@@ -56,12 +57,14 @@ type RouteParent<Path extends RoutePath, TMethod extends Method> = RouteEntry<Pa
 type RouteLayoutChain<Path extends RoutePath, TMethod extends Method> = RouteEntry<Path, TMethod> extends {
     layoutChain: infer Chain extends readonly LayoutId[];
 } ? Chain : RouteParent<Path, TMethod> extends LayoutId ? readonly [RouteParent<Path, TMethod>] : readonly [];
-type RouteResolvedField<Path extends RoutePath, TMethod extends Method, Acc extends readonly unknown[], Field extends "query" | "params" | "body" | "state"> = MergeMiddlewareField<ResolveLayoutChainMiddlewares<RouteLayoutChain<Path, TMethod>>, Field> & MergeMiddlewareField<Acc, Field>;
+export type RouteLayoutMiddlewares<Path extends RoutePath, TMethod extends Method> = ResolveLayoutChainMiddlewares<RouteLayoutChain<Path, TMethod>>;
+export type RouteLayoutField<Path extends RoutePath, TMethod extends Method, Field extends "query" | "params" | "body" | "state"> = MergeMiddlewareField<RouteLayoutMiddlewares<Path, TMethod>, Field>;
+export type RouteLayoutInputField<Path extends RoutePath, TMethod extends Method, Field extends "query" | "params" | "body"> = MergeMiddlewareInputField<RouteLayoutMiddlewares<Path, TMethod>, Field>;
+type RouteResolvedField<Path extends RoutePath, TMethod extends Method, Acc extends readonly unknown[], Field extends "query" | "params" | "body" | "state"> = RouteLayoutField<Path, TMethod, Field> & MergeMiddlewareField<Acc, Field>;
 type RouteChainField<Path extends RoutePath, TMethod extends Method, Acc extends readonly unknown[], Field extends "query" | "params" | "body" | "state"> = RouteResolvedField<Path, TMethod, Acc, Field>;
-type UnitRuntimeContext = Omit<RuntimeContextFields<NativeContext>, "var">;
 export type RouteChainContext<Path extends RoutePath, TMethod extends Method, Acc extends readonly unknown[], TQuery, TParams, TBody, TAppContext extends Record<string, unknown> = AppContext> = Simplify<TAppContext & UnitRuntimeContext & {
     query: Simplify<MergePart<TQuery, RouteChainField<Path, TMethod, Acc, "query">>>;
-    params: Simplify<PathParams<Path> & MergePart<TParams, RouteChainField<Path, TMethod, Acc, "params">>>;
+    params: Simplify<ResolveParams<PathParams<Path>, MergePart<TParams, RouteChainField<Path, TMethod, Acc, "params">>>>;
     body: Simplify<MergePart<TBody, RouteChainField<Path, TMethod, Acc, "body">>>;
     state: Simplify<RouteChainField<Path, TMethod, Acc, "state">>;
     headers: TaserHeaders;
@@ -77,9 +80,9 @@ export type RouteHandleContext<Path extends RoutePath, TMethod extends Method, A
     query: Simplify<MergePart<Validators extends {
         query?: infer Q;
     } ? Q : unknown, RouteResolvedField<Path, TMethod, Acc, "query">>>;
-    params: Simplify<PathParams<Path> & MergePart<Validators extends {
+    params: Simplify<ResolveParams<PathParams<Path>, MergePart<Validators extends {
         params?: infer P;
-    } ? P : unknown, RouteResolvedField<Path, TMethod, Acc, "params">>>;
+    } ? P : unknown, RouteResolvedField<Path, TMethod, Acc, "params">>>>;
     body: Simplify<MergePart<Validators extends {
         body?: infer B;
     } ? B : unknown, RouteResolvedField<Path, TMethod, Acc, "body">>>;
@@ -96,15 +99,15 @@ export type RouteHandleContextWithoutBody<Path extends RoutePath, TMethod extend
     query: Simplify<MergePart<Validators extends {
         query?: infer Q;
     } ? Q : unknown, RouteResolvedField<Path, TMethod, Acc, "query">>>;
-    params: Simplify<PathParams<Path> & MergePart<Validators extends {
+    params: Simplify<ResolveParams<PathParams<Path>, MergePart<Validators extends {
         params?: infer P;
-    } ? P : unknown, RouteResolvedField<Path, TMethod, Acc, "params">>>;
+    } ? P : unknown, RouteResolvedField<Path, TMethod, Acc, "params">>>>;
     body: never;
     state: Simplify<RouteResolvedField<Path, TMethod, Acc, "state">>;
     headers: TaserHeaders;
     cookies: TaserCookieJar;
 }>;
-type RouteResolvedInputField<Path extends RoutePath, TMethod extends Method, Acc extends readonly unknown[], Field extends "query" | "params" | "body"> = MergeMiddlewareInputField<ResolveLayoutChainMiddlewares<RouteLayoutChain<Path, TMethod>>, Field> & MergeMiddlewareInputField<Acc, Field>;
+type RouteResolvedInputField<Path extends RoutePath, TMethod extends Method, Acc extends readonly unknown[], Field extends "query" | "params" | "body"> = RouteLayoutInputField<Path, TMethod, Field> & MergeMiddlewareInputField<Acc, Field>;
 type IsNever<T> = [T] extends [never] ? true : false;
 type IsEmptyObject<T> = [keyof T] extends [never] ? true : false;
 export type IsLayoutAllowed<TRequiredLayouts, TChain extends readonly LayoutId[]> = [
@@ -119,11 +122,11 @@ type RouteQueryInput<Path extends RoutePath, TMethod extends Method, Acc extends
 } ? QI : unknown, Validators extends {
     query?: infer Q;
 } ? Q : unknown>, RouteResolvedInputField<Path, TMethod, Acc, "query">>>;
-type RouteParamsInput<Path extends RoutePath, TMethod extends Method, Acc extends readonly unknown[], Validators extends ValidatorParts> = Simplify<PathParams<Path> & MergePart<RequestShape<Validators extends {
+type RouteParamsInput<Path extends RoutePath, TMethod extends Method, Acc extends readonly unknown[], Validators extends ValidatorParts> = Simplify<ResolveParams<PathParams<Path>, MergePart<RequestShape<Validators extends {
     paramsIn?: infer PI;
 } ? PI : unknown, Validators extends {
     params?: infer P;
-} ? P : unknown>, RouteResolvedInputField<Path, TMethod, Acc, "params">>>;
+} ? P : unknown>, RouteResolvedInputField<Path, TMethod, Acc, "params">>>>;
 type RouteBodyInput<Path extends RoutePath, TMethod extends Method, Acc extends readonly unknown[], Validators extends ValidatorParts> = Simplify<MergePart<RequestShape<Validators extends {
     bodyIn?: infer BI;
 } ? BI : unknown, Validators extends {
@@ -131,14 +134,15 @@ type RouteBodyInput<Path extends RoutePath, TMethod extends Method, Acc extends
 } ? B : unknown>, RouteResolvedInputField<Path, TMethod, Acc, "body">>>;
 export type RouteHandleInputWithoutBody<Path extends RoutePath, TMethod extends Method, Acc extends readonly unknown[], Validators extends ValidatorParts = {}> = Simplify<InputFacet<RouteQueryInput<Path, TMethod, Acc, Validators>, "query"> & InputFacet<RouteParamsInput<Path, TMethod, Acc, Validators>, "params">>;
 export type RouteHandleInput<Path extends RoutePath, TMethod extends Method, Acc extends readonly unknown[], Validators extends ValidatorParts = {}> = Simplify<RouteHandleInputWithoutBody<Path, TMethod, Acc, Validators> & InputFacet<RouteBodyInput<Path, TMethod, Acc, Validators>, "body">>;
-export type InferRouteInput<Path extends RoutePath, TMethod extends Method> = RouteEntry<Path, TMethod> extends {
+export type InferRouteInputFromPath<Path extends RoutePath, TMethod extends Method> = RouteEntry<Path, TMethod> extends {
     route: infer Route;
 } ? Route extends {
     $Infer: {
         Input: infer I;
     };
 } ? I : never : never;
-type MiddlewareChainField<Layout extends LayoutId, Acc extends readonly unknown[], Field extends "query" | "params" | "body" | "state"> = MergeMiddlewareField<ResolveLayoutMiddlewares<LayoutParent<Layout>>, Field> & MergeMiddlewareField<Acc, Field>;
+export type MiddlewareLayoutField<Layout extends LayoutId, Field extends "query" | "params" | "body" | "state"> = MergeMiddlewareField<ResolveLayoutMiddlewares<LayoutParent<Layout>>, Field>;
+type MiddlewareChainField<Layout extends LayoutId, Acc extends readonly unknown[], Field extends "query" | "params" | "body" | "state"> = MiddlewareLayoutField<Layout, Field> & MergeMiddlewareField<Acc, Field>;
 export type MiddlewareChainContext<Layout extends LayoutId, Acc extends readonly unknown[], TQuery, TParams, TBody, TAppContext extends Record<string, unknown> = AppContext> = Simplify<TAppContext & UnitRuntimeContext & {
     query: Simplify<MergePart<TQuery, MiddlewareChainField<Layout, Acc, "query">>>;
     params: Simplify<MergePart<TParams, MiddlewareChainField<Layout, Acc, "params">>>;
@@ -177,10 +181,11 @@ export type RouteExport<Path extends RoutePath, TMethod extends Method, Acc exte
     readonly middlewares: readonly MiddlewareDefinition[];
     readonly handlerMiddlewares: readonly MiddlewareDefinition[];
     readonly returns?: TReturns;
+    readonly bodyMode?: "json" | "form" | "urlencoded";
     handler: (ctx: unknown) => Awaitable<Response>;
     readonly $Infer: {
         Context: TMethod extends "GET" | "DELETE" | "HEAD" | "OPTIONS" ? RouteHandleContextWithoutBody<Path, TMethod, Acc, {}> : RouteHandleContext<Path, TMethod, Acc, {}>;
-        /** Concrete handler reply (`ReplyOf` union) for client inference. */
+        Input: TMethod extends "GET" | "DELETE" | "HEAD" | "OPTIONS" ? RouteHandleInputWithoutBody<Path, TMethod, Acc, {}> : RouteHandleInput<Path, TMethod, Acc, {}>;
         Output: TOutput;
     };
     query?: Schema<unknown>;
@@ -197,12 +202,22 @@ type RouteHandleResult<Path extends RoutePath, TMethod extends Method, Acc exten
         Output: TOutput;
     };
 };
-export type RouteBuilder<Path extends RoutePath, TMethod extends Method, Acc extends readonly unknown[] = readonly [], Validators extends ValidatorParts = {}, TReturns extends ReturnsMap = {}, TAppContext extends Record<string, unknown> = AppContext> = {
+export type RouteBuilderBase<Path extends RoutePath, TMethod extends Method, Acc extends readonly unknown[] = readonly [], Validators extends ValidatorParts = {}, TReturns extends ReturnsMap = {}, TAppContext extends Record<string, unknown> = AppContext> = {
     readonly path: Path;
     readonly method: TMethod;
     readonly $Infer: {
         Context: TMethod extends "GET" | "DELETE" | "HEAD" | "OPTIONS" ? RouteHandleContextWithoutBody<Path, TMethod, Acc, Validators, TAppContext> : RouteHandleContext<Path, TMethod, Acc, Validators, TAppContext>;
+        Input: TMethod extends "GET" | "DELETE" | "HEAD" | "OPTIONS" ? RouteHandleInputWithoutBody<Path, TMethod, Acc, Validators> : RouteHandleInput<Path, TMethod, Acc, Validators>;
+        Output: TReturns;
     };
+    query<TQuery, TQueryIn = unknown>(schema: Schema<TQuery, TQueryIn>): RouteBuilder<Path, TMethod, Acc, Omit<Validators, "query" | "queryIn"> & {
+        query: TQuery;
+        queryIn: TQueryIn;
+    }, TReturns, TAppContext>;
+    params<TParams, TParamsIn = unknown>(schema: Schema<TParams, TParamsIn>): RouteBuilder<Path, TMethod, Acc, Omit<Validators, "params" | "paramsIn"> & {
+        params: TParams;
+        paramsIn: TParamsIn;
+    }, TReturns, TAppContext>;
     returns<const M extends ReturnsMap>(map: M): RouteBuilder<Path, TMethod, Acc, Validators, Omit<TReturns, keyof M> & M, TAppContext>;
     use<TAcc, UReturns extends ReturnsMap = {}, TRequiredLayouts = unknown, TRequiredState = unknown>(unit: MiddlewareUnit<TAcc, UReturns, TRequiredLayouts, TRequiredState>, ..._assert: [
         IsLayoutAllowed<TRequiredLayouts, RouteLayoutChain<Path, TMethod>>,
@@ -228,6 +243,16 @@ export type RouteBuilder<Path extends RoutePath, TMethod extends Method, Acc ext
     ]): RouteHandleResult<Path, TMethod, Acc, Validators, TReturns, R, TAppContext>;
     handler<HandlerAcc extends readonly unknown[] = readonly [], HandlerValidators extends ValidatorParts = ValidatorParts, HReturns extends ReturnsMap = {}, HOutput = Response>(unit: HandlerUnit<HandlerAcc, HandlerValidators, HReturns, HOutput>): RouteHandleResult<Path, TMethod, readonly [...Acc, ...HandlerAcc], Validators, Omit<TReturns, keyof HReturns> & HReturns, HOutput, TAppContext>;
 };
+export type RouteBuilder<Path extends RoutePath, TMethod extends Method, Acc extends readonly unknown[] = readonly [], Validators extends ValidatorParts = {}, TReturns extends ReturnsMap = {}, TAppContext extends Record<string, unknown> = AppContext> = RouteBuilderBase<Path, TMethod, Acc, Validators, TReturns, TAppContext> & (TMethod extends "GET" | "DELETE" | "HEAD" | "OPTIONS" ? {} : {
+    body<TBody, TBodyIn = unknown>(schema: Schema<TBody, TBodyIn>): RouteBuilder<Path, TMethod, Acc, Omit<Validators, "body" | "bodyIn"> & {
+        body: TBody;
+        bodyIn: TBodyIn;
+    }, TReturns, TAppContext>;
+    body<Mode extends "json" | "form" | "urlencoded", TBody, TBodyIn = unknown>(mode: Mode, schema: Schema<TBody, TBodyIn>): RouteBuilder<Path, TMethod, Acc, Omit<Validators, "body" | "bodyIn"> & {
+        body: TBody;
+        bodyIn: TBodyIn;
+    }, TReturns, TAppContext>;
+});
 export type HandlerBuilder<Acc extends readonly unknown[] = readonly [], Validators extends ValidatorParts = {}, TReturns extends ReturnsMap = {}, TAppContext extends Record<string, unknown> = AppContext> = {
     returns<const M extends ReturnsMap>(map: M): HandlerBuilder<Acc, Validators, Omit<TReturns, keyof M> & M, TAppContext>;
     use<TAcc, UReturns extends ReturnsMap = {}, TRequiredLayouts = unknown, TRequiredState = unknown>(unit: MiddlewareUnit<TAcc, UReturns, TRequiredLayouts, TRequiredState>, ..._assert: [IsStateSatisfied<MergeMiddlewareField<Acc, "state">, TRequiredState>] extends [
@@ -254,3 +279,19 @@ export type HandlerBuilder<Acc extends readonly unknown[] = readonly [], Validat
         }
     ]): HandlerUnit<Acc, Validators, TReturns, R>;
 };
+export type RouteDefinition<Path extends RoutePath = RoutePath, TMethod extends Method = Method, Acc extends readonly unknown[] = readonly unknown[], Validators extends ValidatorParts = ValidatorParts, TReturns extends ReturnsMap = ReturnsMap, TOutput = Response, TAppContext extends Record<string, unknown> = AppContext> = RouteHandleResult<Path, TMethod, Acc, Validators, TReturns, TOutput, TAppContext>;
+export type InferRouteContext<R> = R extends {
+    $Infer: {
+        Context: infer C;
+    };
+} ? C : never;
+export type InferRouteInput<R> = R extends {
+    $Infer: {
+        Input: infer I;
+    };
+} ? I : never;
+export type InferRouteOutput<R> = R extends {
+    $Infer: {
+        Output: infer O;
+    };
+} ? O : never;

package/dist/esm/types/returns.d.ts

@@ -1,21 +1,18 @@
-import { ReplyOf } from '@taserjs/router-utils';
+import { ReplyOf } from '@taserjs/router-utils/reply';
+import { StatusCode } from '@taserjs/router-utils';
 import { Simplify } from './type-utils.js';
 import { Schema, InferOutput } from './schema.js';
-/**
- * Known HTTP status codes. `number & {}` allows custom codes while keeping
- * literal autocomplete / inference for well-known values.
- */
-export type StatusCode = 100 | 101 | 102 | 103 | 200 | 201 | 202 | 203 | 204 | 205 | 206 | 207 | 208 | 226 | 300 | 301 | 302 | 303 | 304 | 305 | 306 | 307 | 308 | 400 | 401 | 402 | 403 | 404 | 405 | 406 | 407 | 408 | 409 | 410 | 411 | 412 | 413 | 414 | 415 | 416 | 417 | 418 | 421 | 422 | 423 | 424 | 425 | 426 | 428 | 429 | 431 | 451 | 500 | 501 | 502 | 503 | 504 | 505 | 506 | 507 | 508 | 510 | 511 | (number & {});
+export type { StatusCode };
 /** Status-code → Standard Schema map for route/middleware/handler outputs. */
 export type ReturnsMap = {
-    readonly [K in StatusCode]?: Schema<unknown>;
+    readonly [status: number]: Schema<unknown> | undefined;
 };
 /** Later map wins on overlapping status keys. */
 export type MergeReturns<A extends ReturnsMap, B extends ReturnsMap> = Omit<A, keyof B> & B;
 /** Typed reply union for statuses declared in a returns map. */
-export type ReplyResultFor<M extends ReturnsMap> = {
-    [S in keyof M]-?: S extends StatusCode ? M[S] extends Schema<unknown> ? ReplyOf<S, Simplify<InferOutput<M[S]>>> : never : never;
-}[keyof M];
+export type ReplyFor<M extends ReturnsMap> = {
+    [S in keyof M & number]: M[S] extends Schema<unknown> ? ReplyOf<S, Simplify<InferOutput<M[S]>>> : never;
+}[keyof M & number];
 export type EmptyReturns = {};
 /** True when no status schemas have been declared yet. */
 export type HasReturns<M extends ReturnsMap> = [keyof M] extends [never] ? false : true;
@@ -34,4 +31,4 @@ export type EnforceHandlerReply<R, M extends ReturnsMap> = [R] extends [ValidHan
  * Expected `.handler` return type for a returns map.
  * Prefer constraining handler generics with {@link EnforceHandlerReply}.
  */
-export type HandlerReply<M extends ReturnsMap> = HasReturns<M> extends true ? ReplyResultFor<M> | Response : Response;
+export type HandlerReply<M extends ReturnsMap> = HasReturns<M> extends true ? ReplyFor<M> | Response : Response;

package/dist/esm/types/type-utils.d.ts

@@ -1,5 +1,7 @@
-export type Method = "GET" | "POST" | "PUT" | "DELETE" | "PATCH" | "OPTIONS" | "HEAD";
-export type HttpMethod = Method;
+import { TaserCookieJar, TaserHeaders } from '@taserjs/router-core';
+import { HttpMethod, HttpVerb } from '@taserjs/router-utils/http';
+export type Method = HttpMethod;
+export type { HttpMethod, HttpVerb };
 export type MiddlewareFieldName = "query" | "params" | "body" | "state";
 export type MiddlewareInputFieldName = "query" | "params" | "body";
 export type UnwrapPart<T> = unknown extends T ? {} : T;
@@ -37,13 +39,12 @@ export type MiddlewareInputField<Middleware, Field extends MiddlewareInputFieldN
 } ? V : {};
 export type MergeMiddlewareField<Middlewares extends readonly unknown[], Field extends MiddlewareFieldName> = [Middlewares] extends [readonly []] ? {} : UnionToIntersection<MiddlewareField<Middlewares[number], Field>>;
 export type MergeMiddlewareInputField<Middlewares extends readonly unknown[], Field extends MiddlewareInputFieldName> = [Middlewares] extends [readonly []] ? {} : UnionToIntersection<MiddlewareInputField<Middlewares[number], Field>>;
-export type RuntimeContextFields<TNative = unknown> = {
+export type RuntimeContextFields = {
     request: Request;
     method: Method;
     url: URL;
-    headers: import('@taserjs/router-core').TaserHeaders;
-    cookies: import('@taserjs/router-core').TaserCookieJar;
+    headers: TaserHeaders;
+    cookies: TaserCookieJar;
     var: Record<string, unknown>;
-    native?: TNative;
 };
-export {};
+export type UnitRuntimeContext = Omit<RuntimeContextFields, "var">;

package/dist/esm/types/units.d.ts

@@ -1,16 +1,11 @@
-import { Awaitable, TaserCookieJar, TaserHeaders } from '@taserjs/router-core';
-import { ReplyResult } from '@taserjs/router-utils';
-import { RouterRegister } from '../register.js';
-import { MergeMiddlewareField, MergePart, RequestShape, RuntimeContextFields, Simplify, UnwrapPart } from './type-utils.js';
+import { Awaitable, MiddlewareDefinition as CoreMiddlewareDefinition, TaserCookieJar, TaserHeaders } from '@taserjs/router-core';
+import { MergeMiddlewareField, MergePart, RequestShape, Simplify, UnitRuntimeContext, UnwrapPart } from './type-utils.js';
 import { ReturnsMap } from './returns.js';
 import { Schema } from './schema.js';
 export type { HttpMethod, Method } from './type-utils.js';
 export type { EmptyReturns, MergeReturns, ReturnsMap, HandlerReply, HasReturns, StatusCode, ValidHandlerReply, EnforceHandlerReply, } from './returns.js';
 /** Default empty app context for standalone units without a bound router instance. */
 export type AppContext = Record<never, never>;
-export type NativeContext = RouterRegister extends {
-    NativeContext: infer N;
-} ? N : unknown;
 export type ValidatorParts = {
     query?: unknown;
     params?: unknown;
@@ -20,7 +15,7 @@ export type ValidatorParts = {
     bodyIn?: unknown;
 };
 export declare const StateBrand: unique symbol;
-export type NextResult<TState = unknown> = ReplyResult & {
+export type NextResult<TState = unknown> = Response & {
     readonly [StateBrand]?: TState;
 };
 export type ExtractState<T> = [Extract<Awaited<T>, {
@@ -33,13 +28,7 @@ export type ExtractState<T> = [Extract<Awaited<T>, {
 export type IsUnknown<T> = [unknown] extends [T] ? true : false;
 export type NextFn<TExpectedState = unknown> = IsUnknown<TExpectedState> extends true ? <S extends Record<string, unknown> = {}>(state?: S) => Promise<NextResult<S>> : (state: TExpectedState) => Promise<NextResult<TExpectedState>>;
 export type MiddlewareNext = NextFn;
-export type MiddlewareDefinition = {
-    query?: unknown;
-    params?: unknown;
-    body?: unknown;
-    returns?: ReturnsMap;
-    handler: (ctx: unknown, next: MiddlewareNext) => Awaitable<ReplyResult | Response | unknown>;
-};
+export type MiddlewareDefinition = CoreMiddlewareDefinition<ReturnsMap>;
 export type MiddlewareReturnFromParts<TQuery, TParams, TBody, TState, TQueryIn = TQuery, TParamsIn = TParams, TBodyIn = TBody> = {
     query: Simplify<UnwrapPart<TQuery>>;
     params: Simplify<UnwrapPart<TParams>>;
@@ -52,7 +41,7 @@ export type MiddlewareReturnFromParts<TQuery, TParams, TBody, TState, TQueryIn =
         body: RequestShape<TBodyIn, TBody>;
     };
 };
-type UnitRuntimeContext = Omit<RuntimeContextFields<NativeContext>, "var">;
+export type DefineMiddlewareResult<TQuery, TParams, TBody, TState, R, TQueryIn = TQuery, TParamsIn = TParams, TBodyIn = TBody, TReturns extends ReturnsMap = {}, TLayout = null, TRequires = {}> = MiddlewareUnit<MiddlewareReturnFromParts<TQuery, TParams, TBody, IsUnknown<TState> extends true ? ExtractState<R> : TState, TQueryIn, TParamsIn, TBodyIn>, TReturns, TLayout, TRequires>;
 export type StandaloneMiddlewareContext<TQuery = unknown, TParams = unknown, TBody = unknown, TAppContext extends Record<string, unknown> = AppContext, TState = {}> = Simplify<TAppContext & UnitRuntimeContext & {
     query: Simplify<UnwrapPart<TQuery>>;
     params: Simplify<UnwrapPart<TParams>>;
@@ -87,7 +76,7 @@ export type HandlerUnit<_Acc extends readonly unknown[], _Validators extends Val
         Output: TOutput;
     };
     middlewares: readonly MiddlewareDefinition[];
-    handler: (ctx: unknown) => Awaitable<ReplyResult | Response>;
+    handler: (ctx: unknown) => Awaitable<Response>;
     returns?: ReturnsMap;
     query?: Schema<unknown>;
     params?: Schema<unknown>;

package/dist/esm/types/units.js.map

@@ -1 +1 @@
-{"version":3,"file":"units.js","names":[],"sources":["../../../src/types/units.ts"],"sourcesContent":["import type { Awaitable, TaserCookieJar, TaserHeaders } from \"@taserjs/router-core\";\nimport type { ReplyResult } from \"@taserjs/router-utils\";\n\nimport type { RouterRegister } from \"../register.js\";\nimport type {\n  MergeMiddlewareField,\n  MergePart,\n  RequestShape,\n  RuntimeContextFields,\n  Simplify,\n  UnwrapPart,\n} from \"./type-utils.js\";\nimport type { ReturnsMap } from \"./returns.js\";\nimport type { Schema } from \"./schema.js\";\n\nexport type { HttpMethod, Method } from \"./type-utils.js\";\nexport type {\n  EmptyReturns,\n  MergeReturns,\n  ReturnsMap,\n  HandlerReply,\n  HasReturns,\n  StatusCode,\n  ValidHandlerReply,\n  EnforceHandlerReply,\n} from \"./returns.js\";\n\n/** Default empty app context for standalone units without a bound router instance. */\nexport type AppContext = Record<never, never>;\n\nexport type NativeContext = RouterRegister extends { NativeContext: infer N } ? N : unknown;\n\nexport type ValidatorParts = {\n  query?: unknown;\n  params?: unknown;\n  body?: unknown;\n  queryIn?: unknown;\n  paramsIn?: unknown;\n  bodyIn?: unknown;\n};\n\nexport declare const StateBrand: unique symbol;\n\nexport type NextResult<TState = unknown> = ReplyResult & {\n  readonly [StateBrand]?: TState;\n};\n\nexport type ExtractState<T> = [Extract<Awaited<T>, { [StateBrand]?: unknown }>] extends [never]\n  ? {}\n  : Extract<Awaited<T>, { [StateBrand]?: unknown }> extends { [StateBrand]?: infer S }\n    ? [S] extends [never]\n      ? {}\n      : S\n    : {};\n\nexport type IsUnknown<T> = [unknown] extends [T] ? true : false;\n\nexport type NextFn<TExpectedState = unknown> =\n  IsUnknown<TExpectedState> extends true\n    ? <S extends Record<string, unknown> = {}>(state?: S) => Promise<NextResult<S>>\n    : (state: TExpectedState) => Promise<NextResult<TExpectedState>>;\n\nexport type MiddlewareNext = NextFn;\n\nexport type MiddlewareDefinition = {\n  query?: unknown;\n  params?: unknown;\n  body?: unknown;\n  returns?: ReturnsMap;\n  handler: (ctx: unknown, next: MiddlewareNext) => Awaitable<ReplyResult | Response | unknown>;\n};\n\nexport type MiddlewareReturnFromParts<\n  TQuery,\n  TParams,\n  TBody,\n  TState,\n  TQueryIn = TQuery,\n  TParamsIn = TParams,\n  TBodyIn = TBody,\n> = {\n  query: Simplify<UnwrapPart<TQuery>>;\n  params: Simplify<UnwrapPart<TParams>>;\n  body: Simplify<UnwrapPart<TBody>>;\n  state: Simplify<UnwrapPart<TState>>;\n  /** Pre-parse shapes merged into route `$Infer.Input`. */\n  input: {\n    query: RequestShape<TQueryIn, TQuery>;\n    params: RequestShape<TParamsIn, TParams>;\n    body: RequestShape<TBodyIn, TBody>;\n  };\n};\n\ntype UnitRuntimeContext = Omit<RuntimeContextFields<NativeContext>, \"var\">;\n\nexport type StandaloneMiddlewareContext<\n  TQuery = unknown,\n  TParams = unknown,\n  TBody = unknown,\n  TAppContext extends Record<string, unknown> = AppContext,\n  TState = {},\n> = Simplify<\n  TAppContext &\n    UnitRuntimeContext & {\n      query: Simplify<UnwrapPart<TQuery>>;\n      params: Simplify<UnwrapPart<TParams>>;\n      body: Simplify<UnwrapPart<TBody>>;\n      state: Simplify<UnwrapPart<TState>>;\n      headers: TaserHeaders;\n      cookies: TaserCookieJar;\n    }\n>;\n\nexport type HandlerContext<\n  Acc extends readonly unknown[],\n  Validators extends ValidatorParts,\n  TAppContext extends Record<string, unknown> = AppContext,\n> = Simplify<\n  TAppContext &\n    UnitRuntimeContext & {\n      query: Simplify<\n        MergePart<\n          Validators extends { query?: infer Q } ? Q : unknown,\n          MergeMiddlewareField<Acc, \"query\">\n        >\n      >;\n      params: Simplify<\n        MergePart<\n          Validators extends { params?: infer P } ? P : unknown,\n          MergeMiddlewareField<Acc, \"params\">\n        >\n      >;\n      body: Simplify<\n        MergePart<\n          Validators extends { body?: infer B } ? B : unknown,\n          MergeMiddlewareField<Acc, \"body\">\n        >\n      >;\n      state: Simplify<MergeMiddlewareField<Acc, \"state\">>;\n      headers: TaserHeaders;\n      cookies: TaserCookieJar;\n    }\n>;\n\nexport type MiddlewareUnit<\n  TAcc = unknown,\n  TReturns extends ReturnsMap = {},\n  TRequiredLayouts = unknown,\n  TRequiredState = unknown,\n> = MiddlewareDefinition & {\n  readonly __middlewareAcc: TAcc;\n  readonly __returns?: TReturns;\n  readonly __requiredLayouts?: TRequiredLayouts;\n  readonly __requiredState?: TRequiredState;\n};\n\nexport type HandlerUnit<\n  _Acc extends readonly unknown[],\n  _Validators extends ValidatorParts,\n  TReturns extends ReturnsMap = {},\n  TOutput = Response,\n> = {\n  readonly __returns?: TReturns;\n  readonly $Infer: {\n    Output: TOutput;\n  };\n  middlewares: readonly MiddlewareDefinition[];\n  handler: (ctx: unknown) => Awaitable<ReplyResult | Response>;\n  returns?: ReturnsMap;\n  query?: Schema<unknown>;\n  params?: Schema<unknown>;\n  body?: Schema<unknown>;\n};\n\nexport type InlineMiddlewareOptions<\n  Ctx = unknown,\n  TQuery = unknown,\n  TParams = unknown,\n  TBody = unknown,\n  TReturns extends ReturnsMap = {},\n  TQueryIn = unknown,\n  TParamsIn = unknown,\n  TBodyIn = unknown,\n  R = unknown,\n> = {\n  query?: Schema<TQuery, TQueryIn>;\n  params?: Schema<TParams, TParamsIn>;\n  body?: Schema<TBody, TBodyIn>;\n  returns?: TReturns;\n  handler: (ctx: Ctx, next: NextFn) => Awaitable<R>;\n};\n\nexport function isHandlerUnit(\n  value: unknown,\n): value is HandlerUnit<readonly unknown[], ValidatorParts> {\n  return (\n    typeof value === \"object\" &&\n    value !== null &&\n    \"handler\" in value &&\n    \"middlewares\" in value &&\n    Array.isArray((value as HandlerUnit<readonly unknown[], ValidatorParts>).middlewares)\n  );\n}\n"],"mappings":";AAgMA,SAAgB,cACd,OAC0D;CAC1D,OACE,OAAO,UAAU,YACjB,UAAU,QACV,aAAa,SACb,iBAAiB,SACjB,MAAM,QAAS,MAA0D,WAAW;AAExF"}
+{"version":3,"file":"units.js","names":[],"sources":["../../../src/types/units.ts"],"sourcesContent":["import type {\n  Awaitable,\n  MiddlewareDefinition as CoreMiddlewareDefinition,\n  TaserCookieJar,\n  TaserHeaders,\n} from \"@taserjs/router-core\";\n\nimport type {\n  MergeMiddlewareField,\n  MergePart,\n  RequestShape,\n  Simplify,\n  UnitRuntimeContext,\n  UnwrapPart,\n} from \"./type-utils.js\";\nimport type { ReturnsMap } from \"./returns.js\";\nimport type { Schema } from \"./schema.js\";\n\nexport type { HttpMethod, Method } from \"./type-utils.js\";\nexport type {\n  EmptyReturns,\n  MergeReturns,\n  ReturnsMap,\n  HandlerReply,\n  HasReturns,\n  StatusCode,\n  ValidHandlerReply,\n  EnforceHandlerReply,\n} from \"./returns.js\";\n\n/** Default empty app context for standalone units without a bound router instance. */\nexport type AppContext = Record<never, never>;\n\nexport type ValidatorParts = {\n  query?: unknown;\n  params?: unknown;\n  body?: unknown;\n  queryIn?: unknown;\n  paramsIn?: unknown;\n  bodyIn?: unknown;\n};\n\nexport declare const StateBrand: unique symbol;\n\nexport type NextResult<TState = unknown> = Response & {\n  readonly [StateBrand]?: TState;\n};\n\nexport type ExtractState<T> = [Extract<Awaited<T>, { [StateBrand]?: unknown }>] extends [never]\n  ? {}\n  : Extract<Awaited<T>, { [StateBrand]?: unknown }> extends { [StateBrand]?: infer S }\n    ? [S] extends [never]\n      ? {}\n      : S\n    : {};\n\nexport type IsUnknown<T> = [unknown] extends [T] ? true : false;\n\nexport type NextFn<TExpectedState = unknown> =\n  IsUnknown<TExpectedState> extends true\n    ? <S extends Record<string, unknown> = {}>(state?: S) => Promise<NextResult<S>>\n    : (state: TExpectedState) => Promise<NextResult<TExpectedState>>;\n\nexport type MiddlewareNext = NextFn;\n\nexport type MiddlewareDefinition = CoreMiddlewareDefinition<ReturnsMap>;\n\nexport type MiddlewareReturnFromParts<\n  TQuery,\n  TParams,\n  TBody,\n  TState,\n  TQueryIn = TQuery,\n  TParamsIn = TParams,\n  TBodyIn = TBody,\n> = {\n  query: Simplify<UnwrapPart<TQuery>>;\n  params: Simplify<UnwrapPart<TParams>>;\n  body: Simplify<UnwrapPart<TBody>>;\n  state: Simplify<UnwrapPart<TState>>;\n  /** Pre-parse shapes merged into route `$Infer.Input`. */\n  input: {\n    query: RequestShape<TQueryIn, TQuery>;\n    params: RequestShape<TParamsIn, TParams>;\n    body: RequestShape<TBodyIn, TBody>;\n  };\n};\n\nexport type DefineMiddlewareResult<\n  TQuery,\n  TParams,\n  TBody,\n  TState,\n  R,\n  TQueryIn = TQuery,\n  TParamsIn = TParams,\n  TBodyIn = TBody,\n  TReturns extends ReturnsMap = {},\n  TLayout = null,\n  TRequires = {},\n> = MiddlewareUnit<\n  MiddlewareReturnFromParts<\n    TQuery,\n    TParams,\n    TBody,\n    IsUnknown<TState> extends true ? ExtractState<R> : TState,\n    TQueryIn,\n    TParamsIn,\n    TBodyIn\n  >,\n  TReturns,\n  TLayout,\n  TRequires\n>;\n\nexport type StandaloneMiddlewareContext<\n  TQuery = unknown,\n  TParams = unknown,\n  TBody = unknown,\n  TAppContext extends Record<string, unknown> = AppContext,\n  TState = {},\n> = Simplify<\n  TAppContext &\n    UnitRuntimeContext & {\n      query: Simplify<UnwrapPart<TQuery>>;\n      params: Simplify<UnwrapPart<TParams>>;\n      body: Simplify<UnwrapPart<TBody>>;\n      state: Simplify<UnwrapPart<TState>>;\n      headers: TaserHeaders;\n      cookies: TaserCookieJar;\n    }\n>;\n\nexport type HandlerContext<\n  Acc extends readonly unknown[],\n  Validators extends ValidatorParts,\n  TAppContext extends Record<string, unknown> = AppContext,\n> = Simplify<\n  TAppContext &\n    UnitRuntimeContext & {\n      query: Simplify<\n        MergePart<\n          Validators extends { query?: infer Q } ? Q : unknown,\n          MergeMiddlewareField<Acc, \"query\">\n        >\n      >;\n      params: Simplify<\n        MergePart<\n          Validators extends { params?: infer P } ? P : unknown,\n          MergeMiddlewareField<Acc, \"params\">\n        >\n      >;\n      body: Simplify<\n        MergePart<\n          Validators extends { body?: infer B } ? B : unknown,\n          MergeMiddlewareField<Acc, \"body\">\n        >\n      >;\n      state: Simplify<MergeMiddlewareField<Acc, \"state\">>;\n      headers: TaserHeaders;\n      cookies: TaserCookieJar;\n    }\n>;\n\nexport type MiddlewareUnit<\n  TAcc = unknown,\n  TReturns extends ReturnsMap = {},\n  TRequiredLayouts = unknown,\n  TRequiredState = unknown,\n> = MiddlewareDefinition & {\n  readonly __middlewareAcc: TAcc;\n  readonly __returns?: TReturns;\n  readonly __requiredLayouts?: TRequiredLayouts;\n  readonly __requiredState?: TRequiredState;\n};\n\nexport type HandlerUnit<\n  _Acc extends readonly unknown[],\n  _Validators extends ValidatorParts,\n  TReturns extends ReturnsMap = {},\n  TOutput = Response,\n> = {\n  readonly __returns?: TReturns;\n  readonly $Infer: {\n    Output: TOutput;\n  };\n  middlewares: readonly MiddlewareDefinition[];\n  handler: (ctx: unknown) => Awaitable<Response>;\n  returns?: ReturnsMap;\n  query?: Schema<unknown>;\n  params?: Schema<unknown>;\n  body?: Schema<unknown>;\n};\n\nexport type InlineMiddlewareOptions<\n  Ctx = unknown,\n  TQuery = unknown,\n  TParams = unknown,\n  TBody = unknown,\n  TReturns extends ReturnsMap = {},\n  TQueryIn = unknown,\n  TParamsIn = unknown,\n  TBodyIn = unknown,\n  R = unknown,\n> = {\n  query?: Schema<TQuery, TQueryIn>;\n  params?: Schema<TParams, TParamsIn>;\n  body?: Schema<TBody, TBodyIn>;\n  returns?: TReturns;\n  handler: (ctx: Ctx, next: NextFn) => Awaitable<R>;\n};\n\nexport function isHandlerUnit(\n  value: unknown,\n): value is HandlerUnit<readonly unknown[], ValidatorParts> {\n  return (\n    typeof value === \"object\" &&\n    value !== null &&\n    \"handler\" in value &&\n    \"middlewares\" in value &&\n    Array.isArray((value as HandlerUnit<readonly unknown[], ValidatorParts>).middlewares)\n  );\n}\n"],"mappings":";AAoNA,SAAgB,cACd,OAC0D;CAC1D,OACE,OAAO,UAAU,YACjB,UAAU,QACV,aAAa,SACb,iBAAiB,SACjB,MAAM,QAAS,MAA0D,WAAW;AAExF"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@taserjs/router",
-  "version": "0.0.4",
+  "version": "0.1.0",
   "description": "Type-safe Node.js router with runtime validation and middleware",
   "license": "ISC",
   "repository": {
@@ -147,8 +147,8 @@
   "dependencies": {
     "@standard-schema/spec": "^1.1.0",
     "hono": "^4.10.3",
-    "@taserjs/router-core": "0.0.4",
-    "@taserjs/router-utils": "0.0.4"
+    "@taserjs/router-core": "0.1.0",
+    "@taserjs/router-utils": "0.1.0"
   },
   "devDependencies": {
     "@tanstack/vite-config": "^0.6.0",

package/src/builder/app.ts

@@ -0,0 +1,39 @@
+import type { RouteManifestShape, TaserRuntime } from "@taserjs/router-core";
+
+export class TaserServeView<THasNotFound extends boolean = boolean> {
+  readonly fetch: (
+    request: Request,
+    env?: unknown,
+    executionCtx?: unknown,
+  ) => THasNotFound extends true
+    ? Promise<Response> | Response
+    : Promise<Response | undefined> | Response | undefined;
+
+  readonly request: (
+    path: string,
+    init?: RequestInit,
+  ) => THasNotFound extends true ? Promise<Response> : Promise<Response | undefined>;
+
+  constructor(protected readonly runtime: TaserRuntime<THasNotFound>) {
+    this.fetch = (request: Request, env?: unknown, executionCtx?: unknown) => {
+      return this.runtime.fetch(request, env, executionCtx as never);
+    };
+    this.request = (path: string, init?: RequestInit) => {
+      return this.runtime.request(path, init);
+    };
+  }
+}
+
+export class TaserApp<
+  TManifest extends RouteManifestShape = RouteManifestShape,
+  THasNotFound extends boolean = boolean,
+> extends TaserServeView<THasNotFound> {
+  readonly __manifest?: TManifest;
+
+  constructor(runtime: TaserRuntime<THasNotFound>, manifest?: TManifest) {
+    super(runtime);
+    if (manifest !== undefined) {
+      this.__manifest = manifest;
+    }
+  }
+}

package/src/builder/factories.ts

@@ -0,0 +1,58 @@
+import { createRouteBuilder } from "./route.js";
+import type { RouteBuilder, RoutePath } from "../types/index.js";
+import type { AppContext, HttpMethod } from "../types/units.js";
+
+export type CreateWithoutBodyRoute<
+  M extends "GET" | "DELETE" | "OPTIONS" | "HEAD",
+  TAppContext extends Record<string, unknown> = AppContext,
+> = <const Path extends RoutePath>(
+  path: Path,
+) => RouteBuilder<Path, M, readonly [], {}, {}, TAppContext>;
+
+export type CreateWithBodyRoute<
+  M extends "POST" | "PUT" | "PATCH",
+  TAppContext extends Record<string, unknown> = AppContext,
+> = <const Path extends RoutePath>(
+  path: Path,
+) => RouteBuilder<Path, M, readonly [], {}, {}, TAppContext>;
+
+export type CreateAnyRoute<TAppContext extends Record<string, unknown> = AppContext> = <
+  const Path extends RoutePath,
+  const Methods extends readonly HttpMethod[],
+>(
+  path: Path,
+  methods: Methods,
+) => RouteBuilder<Path, Methods[number], readonly [], {}, {}, TAppContext>;
+
+export type CreateAllRoute<TAppContext extends Record<string, unknown> = AppContext> = <
+  const Path extends RoutePath,
+>(
+  path: Path,
+) => RouteBuilder<Path, HttpMethod, readonly [], {}, {}, TAppContext>;
+
+function createWithoutBodyRoute<M extends "GET" | "DELETE" | "OPTIONS" | "HEAD">(
+  method: M,
+): CreateWithoutBodyRoute<M> {
+  return ((path: string) =>
+    createRouteBuilder(path, method)) as unknown as CreateWithoutBodyRoute<M>;
+}
+
+function createWithBodyRoute<M extends "POST" | "PUT" | "PATCH">(
+  method: M,
+): CreateWithBodyRoute<M> {
+  return ((path: string) => createRouteBuilder(path, method)) as unknown as CreateWithBodyRoute<M>;
+}
+
+export const createGetRoute = createWithoutBodyRoute("GET");
+export const createDeleteRoute = createWithoutBodyRoute("DELETE");
+export const createOptionsRoute = createWithoutBodyRoute("OPTIONS");
+export const createHeadRoute = createWithoutBodyRoute("HEAD");
+export const createPostRoute = createWithBodyRoute("POST");
+export const createPutRoute = createWithBodyRoute("PUT");
+export const createPatchRoute = createWithBodyRoute("PATCH");
+
+export const createAnyRoute: CreateAnyRoute = ((path: string, methods: readonly HttpMethod[]) =>
+  createRouteBuilder(path, "ANY", methods)) as unknown as CreateAnyRoute;
+
+export const createAllRoute: CreateAllRoute = ((path: string) =>
+  createRouteBuilder(path, "ALL")) as unknown as CreateAllRoute;

package/src/{middleware.ts → builder/middleware.ts}

@@ -1,5 +1,5 @@
-import type { LayoutId, MiddlewareBuilder } from "./types/index.js";
-import type { MiddlewareDefinition } from "./types/units.js";
+import type { LayoutId, MiddlewareBuilder } from "../types/index.js";
+import type { MiddlewareDefinition } from "../types/units.js";
 
 export function createMiddleware<const Layout extends LayoutId>(
   layout: Layout,

package/src/{route.ts → builder/route.ts}

@@ -5,12 +5,20 @@ import {
   mergeReturnsMaps,
   withAuto422,
 } from "@taserjs/router-utils";
+import type { BodyMode } from "@taserjs/router-core";
 
-import type { Method, RouteBuilder, RoutePath, ReturnsMap, ValidatorParts } from "./types/index.js";
-import type { HttpMethod, MiddlewareDefinition } from "./types/units.js";
-import { isHandlerUnit } from "./types/units.js";
+import type {
+  Method,
+  RouteBuilder,
+  RoutePath,
+  ReturnsMap,
+  ValidatorParts,
+  Schema,
+} from "../types/index.js";
+import type { HttpMethod, MiddlewareDefinition } from "../types/units.js";
+import { isHandlerUnit } from "../types/units.js";
 import { HANDLER_SCHEMA_KEY_MAP } from "./constants.js";
-import { pickDefinedSchemas, type SchemaValidators } from "./define/validators.js";
+import { pickDefinedSchemas, type SchemaValidators } from "../define/validators.js";
 
 function toUtilsMap(map: ReturnsMap | undefined): Record<number, StandardSchemaV1> {
   if (!map) {
@@ -69,15 +77,36 @@ function buildRouteBase(
 export function createRouteBuilder(
   path: string,
   method: HttpMethod | "ANY" | "ALL",
-  validators: SchemaValidators = {},
   methods?: readonly HttpMethod[],
 ): RouteBuilder<RoutePath, Method, readonly [], ValidatorParts> {
   const middlewares: MiddlewareDefinition[] = [];
   let routeReturns: Record<number, StandardSchemaV1> = {};
+  const validators: SchemaValidators = {};
+  let bodyMode: BodyMode | undefined;
 
   const builder = {
     path,
     method,
+    query(schema: Schema<unknown>) {
+      validators.query = schema;
+      return builder;
+    },
+    params(schema: Schema<unknown>) {
+      validators.params = schema;
+      return builder;
+    },
+    body(modeOrSchema: BodyMode | Schema<unknown>, schema?: Schema<unknown>) {
+      if (typeof modeOrSchema === "string") {
+        bodyMode = modeOrSchema as BodyMode;
+        if (schema !== undefined) {
+          validators.body = schema;
+        }
+      } else {
+        bodyMode = "json";
+        validators.body = modeOrSchema;
+      }
+      return builder;
+    },
     returns(map: ReturnsMap) {
       routeReturns = { ...routeReturns, ...toUtilsMap(map) };
       return builder;
@@ -90,49 +119,40 @@ export function createRouteBuilder(
       const routeSchemas = pickDefinedSchemas(validators);
       const base = buildRouteBase(path, method, methods, middlewares);
 
-      if (isHandlerUnit(fnOrUnit)) {
-        const handlerSchemas = pickDefinedSchemas(fnOrUnit, HANDLER_SCHEMA_KEY_MAP);
-        const returns = buildEffectiveReturns({
-          middlewareReturns: collectReturnsFromDefinitions(middlewares),
-          routeReturns: routeReturns,
-          handlerMiddlewareReturns: collectReturnsFromDefinitions(fnOrUnit.middlewares),
-          handlerReturns: fnOrUnit.returns,
-          schemas: {
-            ...validators,
-            handlerQuery: fnOrUnit.query,
-            handlerParams: fnOrUnit.params,
-            handlerBody: fnOrUnit.body,
-            middlewares,
-            handlerMiddlewares: fnOrUnit.middlewares,
-          },
-        });
+      const unit = isHandlerUnit(fnOrUnit)
+        ? fnOrUnit
+        : {
+            handler: fnOrUnit as (ctx: unknown) => Response | Promise<Response>,
+            middlewares: [] as MiddlewareDefinition[],
+            returns: undefined as ReturnsMap | undefined,
+          };
 
-        return {
-          ...base,
-          handlerMiddlewares: [...fnOrUnit.middlewares],
-          handler: fnOrUnit.handler,
-          ...routeSchemas,
-          ...handlerSchemas,
-          ...(returns ? { returns } : {}),
-        };
-      }
+      const handlerSchemas = isHandlerUnit(fnOrUnit)
+        ? pickDefinedSchemas(fnOrUnit, HANDLER_SCHEMA_KEY_MAP)
+        : {};
 
       const returns = buildEffectiveReturns({
         middlewareReturns: collectReturnsFromDefinitions(middlewares),
-        routeReturns: routeReturns,
-        handlerMiddlewareReturns: {},
-        handlerReturns: undefined,
+        routeReturns,
+        handlerMiddlewareReturns: collectReturnsFromDefinitions(unit.middlewares),
+        handlerReturns: unit.returns,
         schemas: {
           ...validators,
+          handlerQuery: (unit as any).query,
+          handlerParams: (unit as any).params,
+          handlerBody: (unit as any).body,
           middlewares,
+          handlerMiddlewares: unit.middlewares,
         },
       });
 
       return {
         ...base,
-        handlerMiddlewares: [],
-        handler: fnOrUnit as (ctx: unknown) => Response | Promise<Response>,
+        handlerMiddlewares: [...unit.middlewares],
+        handler: unit.handler,
         ...routeSchemas,
+        ...handlerSchemas,
+        ...(bodyMode ? { bodyMode } : {}),
         ...(returns ? { returns } : {}),
       };
     },