@taserjs/router 0.1.3 → 0.1.5

package/dist/esm/middleware/jwt.js

@@ -1,5 +1,5 @@
-import { defineMiddleware } from "../define/middleware.js";
-import { extractJwtPayload } from "./wrap-hono.js";
+import { middleware } from "../define/middleware.js";
+import { honoMw } from "./hono-mw.js";
 import { jwt as jwt$1 } from "hono/jwt";
 //#region src/middleware/jwt.ts
 /**
@@ -7,7 +7,11 @@ import { jwt as jwt$1 } from "hono/jwt";
 * Successfully decoded payload is placed in `ctx.state.jwtPayload`.
 */
 function jwt(options) {
-	return defineMiddleware({ handler: extractJwtPayload(jwt$1(options)) });
+	const mw = honoMw(jwt$1(options));
+	return middleware((ctx, next) => mw(ctx, async () => {
+		const payload = ctx.var.jwtPayload;
+		return next({ jwtPayload: payload });
+	}));
 }
 //#endregion
 export { jwt };

package/dist/esm/middleware/jwt.js.map

@@ -1 +1 @@
-{"version":3,"file":"jwt.js","names":[],"sources":["../../../src/middleware/jwt.ts"],"sourcesContent":["import type { MiddlewareHandler } from \"hono\";\nimport { jwt as honoJwt } from \"hono/jwt\";\n\nimport { defineMiddleware } from \"../define/middleware.js\";\nimport type { MiddlewareReturnFromParts, MiddlewareUnit } from \"../types/units.js\";\nimport { extractJwtPayload } from \"./wrap-hono.js\";\n\nexport type JwtPayloadState<TPayload> = {\n  jwtPayload: TPayload;\n};\n\nexport type JwtMiddlewareUnit<TPayload> = MiddlewareUnit<\n  MiddlewareReturnFromParts<unknown, unknown, unknown, JwtPayloadState<TPayload>>\n>;\n\nexport type JwtOptions = Parameters<typeof honoJwt>[0];\n\n/**\n * JWT auth middleware. Invalid or missing tokens return **401** (Hono).\n * Successfully decoded payload is placed in `ctx.state.jwtPayload`.\n */\nexport function jwt<TPayload = Record<string, unknown>>(\n  options: JwtOptions,\n): JwtMiddlewareUnit<TPayload> {\n  const honoMw: MiddlewareHandler = honoJwt(options);\n  return defineMiddleware<JwtPayloadState<TPayload>>({\n    handler: extractJwtPayload<TPayload>(honoMw),\n  });\n}\n"],"mappings":";;;;;;;;AAqBA,SAAgB,IACd,SAC6B;CAE7B,OAAO,iBAA4C,EACjD,SAAS,kBAFuB,MAAQ,OAEH,CAAM,EAC7C,CAAC;AACH"}
+{"version":3,"file":"jwt.js","names":[],"sources":["../../../src/middleware/jwt.ts"],"sourcesContent":["import { jwt as honoJwt } from \"hono/jwt\";\n\nimport { middleware } from \"../define/middleware.js\";\nimport type { MiddlewareReturnFromParts, MiddlewareUnit } from \"../types/units.js\";\nimport { honoMw } from \"./hono-mw.js\";\n\nexport type JwtPayloadState<TPayload> = {\n  jwtPayload: TPayload;\n};\n\nexport type JwtMiddlewareUnit<TPayload> = MiddlewareUnit<\n  MiddlewareReturnFromParts<unknown, unknown, unknown, JwtPayloadState<TPayload>>\n>;\n\nexport type JwtOptions = Parameters<typeof honoJwt>[0];\n\n/**\n * JWT auth middleware. Invalid or missing tokens return **401** (Hono).\n * Successfully decoded payload is placed in `ctx.state.jwtPayload`.\n */\nexport function jwt<TPayload = Record<string, unknown>>(\n  options: JwtOptions,\n): JwtMiddlewareUnit<TPayload> {\n  const mw = honoMw(honoJwt(options));\n  return middleware<JwtPayloadState<TPayload>>((ctx, next) =>\n    mw(ctx, async () => {\n      const payload = (ctx as unknown as { var: { jwtPayload?: unknown } }).var.jwtPayload;\n      return next({ jwtPayload: payload as TPayload });\n    }),\n  );\n}\n"],"mappings":";;;;;;;;AAoBA,SAAgB,IACd,SAC6B;CAC7B,MAAM,KAAK,OAAO,MAAQ,OAAO,CAAC;CAClC,OAAO,YAAuC,KAAK,SACjD,GAAG,KAAK,YAAY;EAClB,MAAM,UAAW,IAAqD,IAAI;EAC1E,OAAO,KAAK,EAAE,YAAY,QAAoB,CAAC;CACjD,CAAC,CACH;AACF"}

package/dist/esm/middleware/secure-headers.d.ts

@@ -1,3 +1,3 @@
 import { secureHeaders as honoSecureHeaders } from 'hono/secure-headers';
-export declare function secureHeaders(...args: Parameters<typeof honoSecureHeaders>): import('../types/units.js').MiddlewareUnit<import('../types/units.js').MiddlewareReturnFromParts<unknown, unknown, unknown, {}>>;
+export declare function secureHeaders(...args: Parameters<typeof honoSecureHeaders>): import('../types/units.js').DefineMiddlewareResult<unknown, unknown, unknown, {}, Promise<Response>, unknown, unknown, unknown, {}, null, {}>;
 export type SecureHeadersOptions = NonNullable<Parameters<typeof honoSecureHeaders>[0]>;

package/dist/esm/middleware/secure-headers.js

@@ -1,9 +1,9 @@
-import { wrapHonoMiddleware } from "./wrap-hono.js";
+import { middleware } from "../define/middleware.js";
+import { honoMw } from "./hono-mw.js";
 import { secureHeaders as secureHeaders$1 } from "hono/secure-headers";
 //#region src/middleware/secure-headers.ts
-var wrapped = wrapHonoMiddleware(secureHeaders$1);
 function secureHeaders(...args) {
-	return wrapped(...args);
+	return middleware(honoMw(secureHeaders$1(...args)));
 }
 //#endregion
 export { secureHeaders };

package/dist/esm/middleware/secure-headers.js.map

@@ -1 +1 @@
-{"version":3,"file":"secure-headers.js","names":[],"sources":["../../../src/middleware/secure-headers.ts"],"sourcesContent":["import { secureHeaders as honoSecureHeaders } from \"hono/secure-headers\";\n\nimport { wrapHonoMiddleware } from \"./wrap-hono.js\";\n\nconst wrapped = wrapHonoMiddleware(honoSecureHeaders);\n\nexport function secureHeaders(...args: Parameters<typeof honoSecureHeaders>) {\n  return wrapped(...args);\n}\n\nexport type SecureHeadersOptions = NonNullable<Parameters<typeof honoSecureHeaders>[0]>;\n"],"mappings":";;;AAIA,IAAM,UAAU,mBAAmB,eAAiB;AAEpD,SAAgB,cAAc,GAAG,MAA4C;CAC3E,OAAO,QAAQ,GAAG,IAAI;AACxB"}
+{"version":3,"file":"secure-headers.js","names":[],"sources":["../../../src/middleware/secure-headers.ts"],"sourcesContent":["import { secureHeaders as honoSecureHeaders } from \"hono/secure-headers\";\n\nimport { middleware } from \"../define/middleware.js\";\nimport { honoMw } from \"./hono-mw.js\";\n\nexport function secureHeaders(...args: Parameters<typeof honoSecureHeaders>) {\n  return middleware(honoMw(honoSecureHeaders(...args)));\n}\n\nexport type SecureHeadersOptions = NonNullable<Parameters<typeof honoSecureHeaders>[0]>;\n"],"mappings":";;;;AAKA,SAAgB,cAAc,GAAG,MAA4C;CAC3E,OAAO,WAAW,OAAO,gBAAkB,GAAG,IAAI,CAAC,CAAC;AACtD"}

package/dist/esm/middleware/timing.d.ts

@@ -1,3 +1,3 @@
 import { timing as honoTiming } from 'hono/timing';
-export declare function timing(...args: Parameters<typeof honoTiming>): import('../types/units.js').MiddlewareUnit<import('../types/units.js').MiddlewareReturnFromParts<unknown, unknown, unknown, {}>>;
+export declare function timing(...args: Parameters<typeof honoTiming>): import('../types/units.js').DefineMiddlewareResult<unknown, unknown, unknown, {}, Promise<Response>, unknown, unknown, unknown, {}, null, {}>;
 export type TimingOptions = NonNullable<Parameters<typeof honoTiming>[0]>;

package/dist/esm/middleware/timing.js

@@ -1,9 +1,9 @@
-import { wrapHonoMiddleware } from "./wrap-hono.js";
+import { middleware } from "../define/middleware.js";
+import { honoMw } from "./hono-mw.js";
 import { timing as timing$1 } from "hono/timing";
 //#region src/middleware/timing.ts
-var wrapped = wrapHonoMiddleware(timing$1);
 function timing(...args) {
-	return wrapped(...args);
+	return middleware(honoMw(timing$1(...args)));
 }
 //#endregion
 export { timing };

package/dist/esm/middleware/timing.js.map

@@ -1 +1 @@
-{"version":3,"file":"timing.js","names":[],"sources":["../../../src/middleware/timing.ts"],"sourcesContent":["import { timing as honoTiming } from \"hono/timing\";\n\nimport { wrapHonoMiddleware } from \"./wrap-hono.js\";\n\nconst wrapped = wrapHonoMiddleware(honoTiming);\n\nexport function timing(...args: Parameters<typeof honoTiming>) {\n  return wrapped(...args);\n}\n\nexport type TimingOptions = NonNullable<Parameters<typeof honoTiming>[0]>;\n"],"mappings":";;;AAIA,IAAM,UAAU,mBAAmB,QAAU;AAE7C,SAAgB,OAAO,GAAG,MAAqC;CAC7D,OAAO,QAAQ,GAAG,IAAI;AACxB"}
+{"version":3,"file":"timing.js","names":[],"sources":["../../../src/middleware/timing.ts"],"sourcesContent":["import { timing as honoTiming } from \"hono/timing\";\n\nimport { middleware } from \"../define/middleware.js\";\nimport { honoMw } from \"./hono-mw.js\";\n\nexport function timing(...args: Parameters<typeof honoTiming>) {\n  return middleware(honoMw(honoTiming(...args)));\n}\n\nexport type TimingOptions = NonNullable<Parameters<typeof honoTiming>[0]>;\n"],"mappings":";;;;AAKA,SAAgB,OAAO,GAAG,MAAqC;CAC7D,OAAO,WAAW,OAAO,SAAW,GAAG,IAAI,CAAC,CAAC;AAC/C"}

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

@@ -1,15 +1,17 @@
 import { Awaitable, TaserCookieJar, TaserHeaders } from '@taserjs/router-core';
-import { RouterRegister } from '../register.js';
+import { RouterRegister } from '../index.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, ValidatorParts } from './units.js';
+import { EmptyAppContext, ExtractState, Method, MiddlewareDefinition, MiddlewareReturnFromParts, MiddlewareUnit, NextFn, 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, 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 { EmptyAppContext, ExtractState, HttpMethod, IsUnknown, Method, MiddlewareDefinition, MiddlewareReturnFromParts, MiddlewareUnit, MiddlewareUnitBuilder, NextFn, NextResult, StandaloneMiddlewareContext, StateBrand, ValidatorParts, } from './units.js';
+export type AppContext = RouterRegister extends {
+    AppContext: infer C;
+} ? C : EmptyAppContext;
 export type RoutePath = RouterRegister extends {
     RoutePath: infer P;
 } ? P : never;
@@ -22,6 +24,7 @@ export type LayoutTree = RouterRegister extends {
 export type RouteByPathMethod = RouterRegister extends {
     RouteByPathMethod: infer R;
 } ? R : Record<never, never>;
+export type LayoutBuilder<TAppContext extends Record<string, unknown> = AppContext> = <const Layout extends LayoutId>(layout: Layout) => MiddlewareBuilder<Layout, readonly [], TAppContext>;
 type ParseParam<Segment extends string> = Segment extends "*" ? {
     _splat: string;
 } : Segment extends `:${infer Name extends string}` ? Name extends "" ? {} : {
@@ -30,14 +33,17 @@ 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 {
+type LayoutParentsMap = RouterRegister extends {
+    LayoutParents: infer LP extends Record<string, unknown>;
+} ? LP : {};
+type LayoutParent<Layout extends LayoutId> = Layout extends keyof LayoutParentsMap ? LayoutParentsMap[Layout] extends LayoutId ? LayoutParentsMap[Layout] : null : LayoutTree[Layout] extends {
     parent: infer Parent extends LayoutId | null;
 } ? Parent : null;
-type ResolveLayoutMiddlewares<Layout extends LayoutId | null> = Layout extends null ? readonly [] : Layout extends LayoutId ? readonly [
-    ...ResolveLayoutMiddlewares<LayoutParent<Layout>>,
+type ResolveLayoutMiddlewares<Layout extends LayoutId | null, Depth extends readonly unknown[] = []> = Depth["length"] extends 10 ? readonly [] : Layout extends LayoutId ? readonly [
+    ...ResolveLayoutMiddlewares<LayoutParent<Layout>, [...Depth, unknown]>,
     ...LayoutTree[Layout]["middlewares"]
 ] : readonly [];
-export type ResolveLayoutIdChain<L extends LayoutId | null> = L extends null ? readonly [] : L extends LayoutId ? readonly [...ResolveLayoutIdChain<LayoutParent<L>>, L] : readonly [];
+export type ResolveLayoutIdChain<L extends LayoutId | null, Depth extends readonly unknown[] = []> = Depth["length"] extends 10 ? readonly [] : L extends LayoutId ? readonly [...ResolveLayoutIdChain<LayoutParent<L>, [...Depth, unknown]>, L] : readonly [];
 export type ResolveLayoutMiddlewaresState<Layout extends LayoutId | null> = Layout extends LayoutId ? MergeMiddlewareField<ResolveLayoutMiddlewares<Layout>, "state"> : {};
 export type ResolveLayoutsState<Layouts extends LayoutId | readonly LayoutId[]> = Layouts extends LayoutId ? ResolveLayoutMiddlewaresState<Layouts> : Layouts extends readonly LayoutId[] ? UnionToIntersection<Layouts[number] extends infer L extends LayoutId ? ResolveLayoutMiddlewaresState<L> : never> : {};
 /** Fold layout middleware Acc from a route's layoutChain (shallow → deep). */
@@ -61,12 +67,11 @@ export type RouteLayoutMiddlewares<Path extends RoutePath, TMethod extends Metho
 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>;
 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<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">>;
+    query: Simplify<MergePart<TQuery, RouteResolvedField<Path, TMethod, Acc, "query">>>;
+    params: Simplify<ResolveParams<PathParams<Path>, MergePart<TParams, RouteResolvedField<Path, TMethod, Acc, "params">>>>;
+    body: Simplify<MergePart<TBody, RouteResolvedField<Path, TMethod, Acc, "body">>>;
+    state: Simplify<RouteResolvedField<Path, TMethod, Acc, "state">>;
     headers: TaserHeaders;
     cookies: TaserCookieJar;
 }>;
@@ -169,17 +174,13 @@ export type MiddlewareBuilder<Layout extends LayoutId, Acc extends readonly unkn
             actualState: MiddlewareChainField<Layout, Acc, "state">;
         }
     ]): MiddlewareBuilder<Layout, readonly [...Acc, TAcc], TAppContext>;
-    use<TQuery = unknown, TParams = unknown, TBody = unknown, TReturns extends ReturnsMap = {}, TQueryIn = unknown, TParamsIn = unknown, TBodyIn = unknown, R = unknown>(options: InlineMiddlewareOptions<MiddlewareChainContext<Layout, Acc, TQuery, TParams, TBody, TAppContext>, TQuery, TParams, TBody, TReturns, TQueryIn, TParamsIn, TBodyIn, R>): MiddlewareBuilder<Layout, readonly [
-        ...Acc,
-        MiddlewareReturnFromParts<TQuery, TParams, TBody, ExtractState<R>, TQueryIn, TParamsIn, TBodyIn>
-    ], TAppContext>;
+    use<R = unknown>(fn: (ctx: MiddlewareChainContext<Layout, Acc, unknown, unknown, unknown, TAppContext>, next: NextFn) => Awaitable<R>): MiddlewareBuilder<Layout, readonly [...Acc, MiddlewareReturnFromParts<unknown, unknown, unknown, ExtractState<R>>], TAppContext>;
 };
 export type RouteExport<Path extends RoutePath, TMethod extends Method, Acc extends readonly unknown[], TReturns extends ReturnsMap = {}, TOutput = Response> = Acc & {
     readonly path: Path;
     readonly method: TMethod | "ANY" | "ALL";
     readonly methods?: readonly Method[];
     readonly middlewares: readonly MiddlewareDefinition[];
-    readonly handlerMiddlewares: readonly MiddlewareDefinition[];
     readonly returns?: TReturns;
     readonly bodyMode?: "json" | "form" | "urlencoded";
     handler: (ctx: unknown) => Awaitable<Response>;
@@ -191,9 +192,6 @@ export type RouteExport<Path extends RoutePath, TMethod extends Method, Acc exte
     query?: Schema<unknown>;
     params?: Schema<unknown>;
     body?: Schema<unknown>;
-    handlerQuery?: Schema<unknown>;
-    handlerParams?: Schema<unknown>;
-    handlerBody?: Schema<unknown>;
 };
 type RouteHandleResult<Path extends RoutePath, TMethod extends Method, Acc extends readonly unknown[], Validators extends ValidatorParts, TReturns extends ReturnsMap = {}, TOutput = Response, TAppContext extends Record<string, unknown> = AppContext> = Omit<RouteExport<Path, TMethod, Acc, TReturns, TOutput>, "$Infer"> & {
     readonly $Infer: {
@@ -231,17 +229,13 @@ export type RouteBuilderBase<Path extends RoutePath, TMethod extends Method, Acc
             actualState: RouteResolvedField<Path, TMethod, Acc, "state">;
         }
     ]): RouteBuilder<Path, TMethod, readonly [...Acc, TAcc], Validators, Omit<TReturns, keyof UReturns> & UReturns, TAppContext>;
-    use<TQuery = unknown, TParams = unknown, TBody = unknown, UReturns extends ReturnsMap = {}, TQueryIn = unknown, TParamsIn = unknown, TBodyIn = unknown, R = unknown>(options: InlineMiddlewareOptions<RouteChainContext<Path, TMethod, Acc, TQuery, TParams, TBody, TAppContext>, TQuery, TParams, TBody, UReturns, TQueryIn, TParamsIn, TBodyIn, R>): RouteBuilder<Path, TMethod, readonly [
-        ...Acc,
-        MiddlewareReturnFromParts<TQuery, TParams, TBody, ExtractState<R>, TQueryIn, TParamsIn, TBodyIn>
-    ], Validators, Omit<TReturns, keyof UReturns> & UReturns, TAppContext>;
+    use<R = unknown>(fn: (ctx: RouteChainContext<Path, TMethod, Acc, unknown, unknown, unknown, TAppContext>, next: NextFn) => Awaitable<R>): RouteBuilder<Path, TMethod, readonly [...Acc, MiddlewareReturnFromParts<unknown, unknown, unknown, ExtractState<R>>], Validators, TReturns, TAppContext>;
     handler<R extends Response = Response>(fn: (ctx: TMethod extends "GET" | "DELETE" | "HEAD" | "OPTIONS" ? RouteHandleContextWithoutBody<Path, TMethod, Acc, Validators, TAppContext> : RouteHandleContext<Path, TMethod, Acc, Validators, TAppContext>) => Awaitable<R>, ..._assert: [R] extends [ValidHandlerReply<R, TReturns>] ? [] : [
         {
             expected: ValidHandlerReply<R, TReturns>;
             actual: R;
         }
     ]): 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"> & {
@@ -253,32 +247,6 @@ export type RouteBuilder<Path extends RoutePath, TMethod extends Method, Acc ext
         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 [
-        true
-    ] ? [] : [
-        {
-            error: "Middleware cannot be attached to this handler";
-            requiredState: TRequiredState;
-            actualState: MergeMiddlewareField<Acc, "state">;
-        }
-    ]): HandlerBuilder<readonly [...Acc, TAcc], Validators, Omit<TReturns, keyof UReturns> & UReturns, TAppContext>;
-    use<TQuery = unknown, TParams = unknown, TBody = unknown, UReturns extends ReturnsMap = {}, TQueryIn = unknown, TParamsIn = unknown, TBodyIn = unknown, R = unknown>(options: InlineMiddlewareOptions<HandlerContext<Acc, {
-        query: TQuery;
-        params: TParams;
-        body: TBody;
-    }, TAppContext>, TQuery, TParams, TBody, UReturns, TQueryIn, TParamsIn, TBodyIn, R>): HandlerBuilder<readonly [
-        ...Acc,
-        MiddlewareReturnFromParts<TQuery, TParams, TBody, ExtractState<R>, TQueryIn, TParamsIn, TBodyIn>
-    ], Validators, Omit<TReturns, keyof UReturns> & UReturns, TAppContext>;
-    handler<R extends Response = Response>(fn: (ctx: HandlerContext<Acc, Validators, TAppContext>) => Awaitable<R>, ..._assert: [R] extends [ValidHandlerReply<R, TReturns>] ? [] : [
-        {
-            expected: ValidHandlerReply<R, TReturns>;
-            actual: R;
-        }
-    ]): 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: {

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

@@ -37,8 +37,8 @@ export type MiddlewareInputField<Middleware, Field extends MiddlewareInputFieldN
         [K in Field]: infer V;
     };
 } ? 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 MergeMiddlewareField<Middlewares extends readonly unknown[], Field extends MiddlewareFieldName> = Middlewares extends readonly [] ? {} : Middlewares extends readonly [infer Head, ...infer Tail] ? MiddlewareField<Head, Field> & MergeMiddlewareField<Tail, Field> : MiddlewareField<Middlewares[number], Field>;
+export type MergeMiddlewareInputField<Middlewares extends readonly unknown[], Field extends MiddlewareInputFieldName> = Middlewares extends readonly [] ? {} : Middlewares extends readonly [infer Head, ...infer Tail] ? MiddlewareInputField<Head, Field> & MergeMiddlewareInputField<Tail, Field> : MiddlewareInputField<Middlewares[number], Field>;
 export type RuntimeContextFields = {
     request: Request;
     method: Method;

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

@@ -1,11 +1,11 @@
-import { Awaitable, MiddlewareDefinition as CoreMiddlewareDefinition, TaserCookieJar, TaserHeaders } from '@taserjs/router-core';
-import { MergeMiddlewareField, MergePart, RequestShape, Simplify, UnitRuntimeContext, UnwrapPart } from './type-utils.js';
+import { MiddlewareDefinition as CoreMiddlewareDefinition, TaserCookieJar, TaserHeaders } from '@taserjs/router-core';
+import { 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 EmptyAppContext = Record<never, never>;
 export type ValidatorParts = {
     query?: unknown;
     params?: unknown;
@@ -18,16 +18,12 @@ export declare const StateBrand: unique symbol;
 export type NextResult<TState = unknown> = Response & {
     readonly [StateBrand]?: TState;
 };
-export type ExtractState<T> = [Extract<Awaited<T>, {
-    [StateBrand]?: unknown;
-}>] extends [never] ? {} : Extract<Awaited<T>, {
-    [StateBrand]?: unknown;
-}> extends {
-    [StateBrand]?: infer S;
-} ? [S] extends [never] ? {} : S : {};
+export type ExtractStateFromUnion<T> = T extends {
+    readonly [StateBrand]?: infer S;
+} ? [S] extends [never] ? never : [unknown] extends [S] ? {} : S : never;
+export type ExtractState<T> = [ExtractStateFromUnion<Awaited<T>>] extends [never] ? {} : ExtractStateFromUnion<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 = CoreMiddlewareDefinition<ReturnsMap>;
 export type MiddlewareReturnFromParts<TQuery, TParams, TBody, TState, TQueryIn = TQuery, TParamsIn = TParams, TBodyIn = TBody> = {
     query: Simplify<UnwrapPart<TQuery>>;
@@ -42,7 +38,7 @@ export type MiddlewareReturnFromParts<TQuery, TParams, TBody, TState, TQueryIn =
     };
 };
 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 & {
+export type StandaloneMiddlewareContext<TQuery = unknown, TParams = unknown, TBody = unknown, TAppContext extends Record<string, unknown> = EmptyAppContext, TState = {}> = Simplify<TAppContext & UnitRuntimeContext & {
     query: Simplify<UnwrapPart<TQuery>>;
     params: Simplify<UnwrapPart<TParams>>;
     body: Simplify<UnwrapPart<TBody>>;
@@ -50,43 +46,20 @@ export type StandaloneMiddlewareContext<TQuery = unknown, TParams = unknown, TBo
     headers: TaserHeaders;
     cookies: TaserCookieJar;
 }>;
-export type HandlerContext<Acc extends readonly unknown[], Validators extends ValidatorParts, TAppContext extends Record<string, unknown> = AppContext> = Simplify<TAppContext & UnitRuntimeContext & {
-    query: Simplify<MergePart<Validators extends {
-        query?: infer Q;
-    } ? Q : unknown, MergeMiddlewareField<Acc, "query">>>;
-    params: Simplify<MergePart<Validators extends {
-        params?: infer P;
-    } ? P : unknown, MergeMiddlewareField<Acc, "params">>>;
-    body: Simplify<MergePart<Validators extends {
-        body?: infer B;
-    } ? B : unknown, MergeMiddlewareField<Acc, "body">>>;
-    state: Simplify<MergeMiddlewareField<Acc, "state">>;
-    headers: TaserHeaders;
-    cookies: TaserCookieJar;
-}>;
+export declare const MiddlewareUnitBrand: unique symbol;
 export type MiddlewareUnit<TAcc = unknown, TReturns extends ReturnsMap = {}, TRequiredLayouts = unknown, TRequiredState = unknown> = MiddlewareDefinition & {
+    readonly [MiddlewareUnitBrand]: true;
     readonly __middlewareAcc: TAcc;
     readonly __returns?: TReturns;
     readonly __requiredLayouts?: TRequiredLayouts;
     readonly __requiredState?: TRequiredState;
 };
-export type HandlerUnit<_Acc extends readonly unknown[], _Validators extends ValidatorParts, TReturns extends ReturnsMap = {}, TOutput = Response> = {
-    readonly __returns?: TReturns;
-    readonly $Infer: {
-        Output: TOutput;
-    };
-    middlewares: readonly MiddlewareDefinition[];
-    handler: (ctx: unknown) => Awaitable<Response>;
-    returns?: ReturnsMap;
-    query?: Schema<unknown>;
-    params?: Schema<unknown>;
-    body?: Schema<unknown>;
-};
-export type InlineMiddlewareOptions<Ctx = unknown, TQuery = unknown, TParams = unknown, TBody = unknown, TReturns extends ReturnsMap = {}, TQueryIn = unknown, TParamsIn = unknown, TBodyIn = unknown, R = unknown> = {
-    query?: Schema<TQuery, TQueryIn>;
-    params?: Schema<TParams, TParamsIn>;
-    body?: Schema<TBody, TBodyIn>;
-    returns?: TReturns;
-    handler: (ctx: Ctx, next: NextFn) => Awaitable<R>;
+export type MiddlewareUnitBuilder<TQuery = unknown, TParams = unknown, TBody = unknown, TReturns extends ReturnsMap = {}, TRequiredLayouts = unknown, TRequiredState = {}, TAppContext extends Record<string, unknown> = EmptyAppContext, TInheritedState = {}, TQueryIn = unknown, TParamsIn = unknown, TBodyIn = unknown, TExpectedState = unknown> = MiddlewareUnit<MiddlewareReturnFromParts<TQuery, TParams, TBody, IsUnknown<TExpectedState> extends true ? {} : TExpectedState, TQueryIn, TParamsIn, TBodyIn>, TReturns, TRequiredLayouts, TRequiredState> & {
+    query<Q, QIn = unknown>(schema: Schema<Q, QIn>): MiddlewareUnitBuilder<Q, TParams, TBody, TReturns, TRequiredLayouts, TRequiredState, TAppContext, TInheritedState, QIn, TParamsIn, TBodyIn, TExpectedState>;
+    params<P, PIn = unknown>(schema: Schema<P, PIn>): MiddlewareUnitBuilder<TQuery, P, TBody, TReturns, TRequiredLayouts, TRequiredState, TAppContext, TInheritedState, TQueryIn, PIn, TBodyIn, TExpectedState>;
+    body<B, BIn = unknown>(schema: Schema<B, BIn>): MiddlewareUnitBuilder<TQuery, TParams, B, TReturns, TRequiredLayouts, TRequiredState, TAppContext, TInheritedState, TQueryIn, TParamsIn, BIn, TExpectedState>;
+    body<Mode extends "json" | "form" | "urlencoded", B, BIn = unknown>(mode: Mode, schema: Schema<B, BIn>): MiddlewareUnitBuilder<TQuery, TParams, B, TReturns, TRequiredLayouts, TRequiredState, TAppContext, TInheritedState, TQueryIn, TParamsIn, BIn, TExpectedState>;
+    returns<const M extends ReturnsMap>(map: M): MiddlewareUnitBuilder<TQuery, TParams, TBody, Omit<TReturns, keyof M> & M, TRequiredLayouts, TRequiredState, TAppContext, TInheritedState, TQueryIn, TParamsIn, TBodyIn, TExpectedState>;
+    requires<Requires extends Record<string, unknown>>(): MiddlewareUnitBuilder<TQuery, TParams, TBody, TReturns, TRequiredLayouts, TRequiredState & Requires, TAppContext, TInheritedState, TQueryIn, TParamsIn, TBodyIn, TExpectedState>;
+    handler<R>(fn: (ctx: StandaloneMiddlewareContext<TQuery, TParams, TBody, TAppContext, TInheritedState & TRequiredState>, next: NextFn<TExpectedState>) => R): DefineMiddlewareResult<TQuery, TParams, TBody, IsUnknown<TExpectedState> extends true ? ExtractState<R> : TExpectedState, R, TQueryIn, TParamsIn, TBodyIn, TReturns, TRequiredLayouts, TRequiredState>;
 };
-export declare function isHandlerUnit(value: unknown): value is HandlerUnit<readonly unknown[], ValidatorParts>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@taserjs/router",
-  "version": "0.1.3",
+  "version": "0.1.5",
   "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.1.3",
-    "@taserjs/router-utils": "0.1.3"
+    "@taserjs/router-utils": "0.1.5",
+    "@taserjs/router-core": "0.1.5"
   },
   "devDependencies": {
     "@tanstack/vite-config": "^0.6.0",

package/src/builder/constants.ts

@@ -2,9 +2,3 @@
 export const SCHEMA_KEYS = ["query", "params", "body"] as const;
 
 export type SchemaKey = (typeof SCHEMA_KEYS)[number];
-
-export const HANDLER_SCHEMA_KEY_MAP = {
-  query: "handlerQuery",
-  params: "handlerParams",
-  body: "handlerBody",
-} as const satisfies Record<SchemaKey, string>;

package/src/builder/factories.ts

@@ -1,6 +1,6 @@
 import { createRouteBuilder } from "./route.js";
-import type { RouteBuilder, RoutePath } from "../types/index.js";
-import type { AppContext, HttpMethod } from "../types/units.js";
+import type { AppContext, RouteBuilder, RoutePath } from "../types/index.js";
+import type { HttpMethod } from "../types/units.js";
 
 export type CreateWithoutBodyRoute<
   M extends "GET" | "DELETE" | "OPTIONS" | "HEAD",

package/src/builder/middleware-unit.ts

@@ -0,0 +1,66 @@
+import type { BodyMode } from "@taserjs/router-core";
+
+import type { ReturnsMap } from "../types/returns.js";
+import type { Schema } from "../types/schema.js";
+import { pickDefinedSchemas, type SchemaValidators } from "../define/validators.js";
+
+export function createMiddlewareUnitBuilder(requiredLayouts?: string | readonly string[]) {
+  const validators: SchemaValidators = {};
+  let bodyMode: BodyMode | undefined;
+  let returnsMap: ReturnsMap | undefined;
+
+  function toUnit(fn?: (ctx: any, next: any) => any) {
+    const schemas = pickDefinedSchemas(validators);
+    return {
+      ...(fn ? { handler: fn } : {}),
+      ...schemas,
+      ...(bodyMode ? { bodyMode } : {}),
+      ...(returnsMap ? { returns: returnsMap, __returns: returnsMap } : {}),
+      ...(requiredLayouts !== undefined ? { __requiredLayouts: requiredLayouts } : {}),
+      __middlewareAcc: undefined as unknown,
+    };
+  }
+
+  const builder: any = {
+    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) {
+      returnsMap = { ...returnsMap, ...map };
+      return builder;
+    },
+    requires() {
+      return builder;
+    },
+    handler(fn: (ctx: any, next: any) => any) {
+      return toUnit(fn);
+    },
+    toUnit() {
+      return toUnit();
+    },
+    __middlewareAcc: undefined as unknown,
+  };
+
+  if (requiredLayouts !== undefined) {
+    builder.__requiredLayouts = requiredLayouts;
+  }
+
+  return builder;
+}

package/src/builder/middleware.ts

@@ -9,8 +9,14 @@ export function createMiddleware<const Layout extends LayoutId>(
   const chain = {
     layout,
     middlewares: entries,
-    use(definition: MiddlewareDefinition) {
-      entries.push(definition);
+    use(definition: MiddlewareDefinition | ((ctx: any, next: any) => any)) {
+      if (typeof definition === "function") {
+        entries.push({ handler: definition as any });
+      } else if (typeof (definition as any)?.toUnit === "function") {
+        entries.push((definition as any).toUnit());
+      } else {
+        entries.push(definition);
+      }
       return chain;
     },
   };

package/src/builder/route.ts

@@ -16,8 +16,6 @@ import type {
   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";
 
 function toUtilsMap(map: ReturnsMap | undefined): Record<number, StandardSchemaV1> {
@@ -36,24 +34,16 @@ function toUtilsMap(map: ReturnsMap | undefined): Record<number, StandardSchemaV
 function buildEffectiveReturns(args: {
   middlewareReturns: ReturnsMap;
   routeReturns: ReturnsMap;
-  handlerMiddlewareReturns: ReturnsMap;
-  handlerReturns: ReturnsMap | undefined;
   schemas: {
     query?: unknown;
     params?: unknown;
     body?: unknown;
-    handlerQuery?: unknown;
-    handlerParams?: unknown;
-    handlerBody?: unknown;
     middlewares?: readonly MiddlewareDefinition[];
-    handlerMiddlewares?: readonly MiddlewareDefinition[];
   };
 }): Record<number, StandardSchemaV1> | undefined {
   const merged = mergeReturnsMaps(
     toUtilsMap(args.middlewareReturns),
     toUtilsMap(args.routeReturns),
-    toUtilsMap(args.handlerMiddlewareReturns),
-    toUtilsMap(args.handlerReturns),
   );
   const with422 = withAuto422(merged, hasInputSchemas(args.schemas));
   return Object.keys(with422).length > 0 ? with422 : undefined;
@@ -111,47 +101,33 @@ export function createRouteBuilder(
       routeReturns = { ...routeReturns, ...toUtilsMap(map) };
       return builder;
     },
-    use(definition: MiddlewareDefinition) {
-      middlewares.push(definition);
+    use(definition: MiddlewareDefinition | ((ctx: any, next: any) => any)) {
+      if (typeof definition === "function") {
+        middlewares.push({ handler: definition as any });
+      } else if (typeof (definition as any)?.toUnit === "function") {
+        middlewares.push((definition as any).toUnit());
+      } else {
+        middlewares.push(definition);
+      }
       return builder;
     },
-    handler(fnOrUnit: ((ctx: unknown) => unknown) | unknown) {
+    handler(fn: (ctx: unknown) => Response | Promise<Response>) {
       const routeSchemas = pickDefinedSchemas(validators);
       const base = buildRouteBase(path, method, methods, middlewares);
 
-      const unit = isHandlerUnit(fnOrUnit)
-        ? fnOrUnit
-        : {
-            handler: fnOrUnit as (ctx: unknown) => Response | Promise<Response>,
-            middlewares: [] as MiddlewareDefinition[],
-            returns: undefined as ReturnsMap | undefined,
-          };
-
-      const handlerSchemas = isHandlerUnit(fnOrUnit)
-        ? pickDefinedSchemas(fnOrUnit, HANDLER_SCHEMA_KEY_MAP)
-        : {};
-
       const returns = buildEffectiveReturns({
         middlewareReturns: collectReturnsFromDefinitions(middlewares),
         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: [...unit.middlewares],
-        handler: unit.handler,
+        handler: fn,
         ...routeSchemas,
-        ...handlerSchemas,
         ...(bodyMode ? { bodyMode } : {}),
         ...(returns ? { returns } : {}),
       };