@taserjs/router 0.0.4 → 0.1.0

package/src/middleware/timing.ts

@@ -2,10 +2,10 @@ import { timing as honoTiming } from "hono/timing";
 
 import { wrapHonoMiddleware } from "./wrap-hono.js";
 
-const honoTimingMiddleware = wrapHonoMiddleware(honoTiming);
+const wrapped = wrapHonoMiddleware(honoTiming);
 
 export function timing(...args: Parameters<typeof honoTiming>) {
-  return honoTimingMiddleware(...args);
+  return wrapped(...args);
 }
 
 export type TimingOptions = NonNullable<Parameters<typeof honoTiming>[0]>;

package/src/middleware/wrap-hono.ts

@@ -1,3 +1,4 @@
+import { createTaserCompatHandler } from "@taserjs/router-core";
 import type { MiddlewareHandler } from "hono";
 
 import { defineMiddleware } from "../define/middleware.js";
@@ -10,3 +11,15 @@ export function wrapHonoMiddleware<F extends (...args: never[]) => MiddlewareHan
 ) => MiddlewareUnit<MiddlewareReturnFromParts<unknown, unknown, unknown, {}>> {
   return (...args) => defineMiddleware(honoFactory(...args));
 }
+
+/** Extracts the jwtPayload from Hono's variable bag and forwards it into Taser's state via next(). */
+export function extractJwtPayload<TPayload>(
+  honoMw: MiddlewareHandler,
+): (ctx: unknown, next: (state: { jwtPayload: TPayload }) => unknown) => unknown {
+  const taserHandler = createTaserCompatHandler(honoMw);
+  return (ctx, next) =>
+    taserHandler(ctx, async () => {
+      const payload = (ctx as unknown as { var: { jwtPayload?: unknown } }).var.jwtPayload;
+      return next({ jwtPayload: payload as TPayload });
+    });
+}

package/src/reply.ts

@@ -1,11 +1 @@
-export { errorReply, reply, successReply } from "@taserjs/router-utils/reply";
-export type {
-  BinaryBody,
-  BodyKind,
-  FileReplyInit,
-  RedirectInit,
-  ReplyBodyKind,
-  ReplyInit,
-  ReplyOf,
-  SuccessReplyData,
-} from "@taserjs/router-utils/reply";
+export * from "@taserjs/router-utils/reply";

package/src/stream.ts

@@ -1 +1 @@
-export { blob, buffer, file, pipe, stream } from "@taserjs/router-utils";
+export * from "@taserjs/router-utils/stream";

package/src/types/app.ts

@@ -1,31 +1,18 @@
+import type { CookieRuntimeConfig, RouteManifestShape } from "@taserjs/router-core";
 import type { ResponseValidationFailureHandler } from "@taserjs/router-utils";
 
-import type { TaserApp } from "../taser-app.js";
+import type { TaserApp } from "../builder/app.js";
 import type { ReturnsMap } from "./returns.js";
 import type { Schema } from "./schema.js";
 
 export type CreateTaserAppOptions = {
-  basePath?: string;
   response?: {
     /** Validate handler replies against returns maps. Default true. */
     validate?: boolean;
     onValidationFailure?: ResponseValidationFailureHandler;
   };
   /** Global cookie defaults and signing secret. Per-call `ctx.cookies.set` options override defaults. */
-  cookies?: {
-    secret?: string | BufferSource;
-    path?: string;
-    httpOnly?: boolean;
-    sameSite?: "Strict" | "Lax" | "None" | "strict" | "lax" | "none";
-    secure?: boolean;
-    domain?: string;
-    maxAge?: number;
-    expires?: Date;
-  };
-};
-
-export type CreateContextArgs = {
-  native?: import("./units.js").NativeContext;
+  cookies?: CookieRuntimeConfig;
 };
 
 export type ContextDefinition<
@@ -33,7 +20,7 @@ export type ContextDefinition<
   TReq extends Record<string, unknown> = Record<string, never>,
 > = {
   boot?: () => TBoot | Promise<TBoot>;
-  request?: (args: CreateContextArgs) => TReq | Promise<TReq>;
+  request?: (req: Request) => TReq | Promise<TReq>;
 };
 
 export type InferAppContext<
@@ -45,19 +32,17 @@ export type OnErrorOptions<TResponses extends ReturnsMap = ReturnsMap> = {
   handle: (error: unknown, ctx?: unknown) => Response | Promise<Response>;
 };
 
-export type InferAppManifest<TApp> = TApp extends TaserApp<infer TManifest> ? TManifest : never;
-
-export type TaserHandler<TFrameworkApp> = {
-  /**
-   * Mount the Taser handler on a framework app.
-   * Use universal wildcard patterns (`/*`, `/prefix/*`) for Hono/Fastify.
-   * Use framework-native splat patterns for Express (e.g. `/{*splat}`, `/*splat`).
-   */
-  mount(pattern: string, frameworkApp: TFrameworkApp): void;
-};
+export type InferAppManifest<TApp> =
+  TApp extends TaserApp<infer TManifest, any>
+    ? TManifest
+    : TApp extends { manifest: infer TManifest }
+      ? TManifest
+      : TApp extends RouteManifestShape
+        ? TApp
+        : never;
 
 export type { RouteManifestShape } from "@taserjs/router-core";
 
 export type { Schema };
 
-export type { TaserApp, TaserNativeBound } from "../taser-app.js";
+export type { TaserApp } from "../builder/app.js";

package/src/types/index.ts

@@ -5,9 +5,9 @@ import type {
   MergeMiddlewareInputField,
   MergePart,
   RequestShape,
-  RuntimeContextFields,
   Simplify,
   UnionToIntersection,
+  UnitRuntimeContext,
 } from "./type-utils.js";
 import type { ReturnsMap, ValidHandlerReply } from "./returns.js";
 import type { Schema } from "./schema.js";
@@ -21,7 +21,6 @@ import type {
   MiddlewareDefinition,
   MiddlewareReturnFromParts,
   MiddlewareUnit,
-  NativeContext,
   ValidatorParts,
 } from "./units.js";
 
@@ -40,6 +39,7 @@ export type {
   MergePart,
   RequestShape,
   Simplify,
+  UnitRuntimeContext,
   UnwrapPart,
 } from "./type-utils.js";
 export type {
@@ -48,7 +48,7 @@ export type {
   HandlerReply,
   HasReturns,
   MergeReturns,
-  ReplyResultFor,
+  ReplyFor,
   ReturnsMap,
   StatusCode,
   ValidHandlerReply,
@@ -66,7 +66,6 @@ export type {
   MiddlewareNext,
   MiddlewareReturnFromParts,
   MiddlewareUnit,
-  NativeContext,
   NextFn,
   NextResult,
   StandaloneMiddlewareContext,
@@ -97,6 +96,13 @@ 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;
 }
@@ -162,13 +168,29 @@ type RouteLayoutChain<Path extends RoutePath, TMethod extends Method> =
       ? readonly [RouteParent<Path, TMethod>]
       : readonly [];
 
+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",
-> = MergeMiddlewareField<ResolveLayoutChainMiddlewares<RouteLayoutChain<Path, TMethod>>, Field> &
-  MergeMiddlewareField<Acc, Field>;
+> = RouteLayoutField<Path, TMethod, Field> & MergeMiddlewareField<Acc, Field>;
 
 type RouteChainField<
   Path extends RoutePath,
@@ -177,8 +199,6 @@ type RouteChainField<
   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,
@@ -192,7 +212,10 @@ export type RouteChainContext<
     UnitRuntimeContext & {
       query: Simplify<MergePart<TQuery, RouteChainField<Path, TMethod, Acc, "query">>>;
       params: Simplify<
-        PathParams<Path> & MergePart<TParams, RouteChainField<Path, TMethod, Acc, "params">>
+        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">>;
@@ -223,11 +246,13 @@ export type RouteHandleContext<
         >
       >;
       params: Simplify<
-        PathParams<Path> &
+        ResolveParams<
+          PathParams<Path>,
           MergePart<
             Validators extends { params?: infer P } ? P : unknown,
             RouteResolvedField<Path, TMethod, Acc, "params">
           >
+        >
       >;
       body: Simplify<
         MergePart<
@@ -262,11 +287,13 @@ export type RouteHandleContextWithoutBody<
         >
       >;
       params: Simplify<
-        PathParams<Path> &
+        ResolveParams<
+          PathParams<Path>,
           MergePart<
             Validators extends { params?: infer P } ? P : unknown,
             RouteResolvedField<Path, TMethod, Acc, "params">
           >
+        >
       >;
       body: never;
       state: Simplify<RouteResolvedField<Path, TMethod, Acc, "state">>;
@@ -280,11 +307,7 @@ type RouteResolvedInputField<
   TMethod extends Method,
   Acc extends readonly unknown[],
   Field extends "query" | "params" | "body",
-> = MergeMiddlewareInputField<
-  ResolveLayoutChainMiddlewares<RouteLayoutChain<Path, TMethod>>,
-  Field
-> &
-  MergeMiddlewareInputField<Acc, Field>;
+> = RouteLayoutInputField<Path, TMethod, Field> & MergeMiddlewareInputField<Acc, Field>;
 
 type IsNever<T> = [T] extends [never] ? true : false;
 
@@ -348,7 +371,8 @@ type RouteParamsInput<
   Acc extends readonly unknown[],
   Validators extends ValidatorParts,
 > = Simplify<
-  PathParams<Path> &
+  ResolveParams<
+    PathParams<Path>,
     MergePart<
       RequestShape<
         Validators extends { paramsIn?: infer PI } ? PI : unknown,
@@ -356,6 +380,7 @@ type RouteParamsInput<
       >,
       RouteResolvedInputField<Path, TMethod, Acc, "params">
     >
+  >
 >;
 
 type RouteBodyInput<
@@ -393,19 +418,23 @@ export type RouteHandleInput<
     InputFacet<RouteBodyInput<Path, TMethod, Acc, Validators>, "body">
 >;
 
-export type InferRouteInput<Path extends RoutePath, TMethod extends Method> =
+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;
 
+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",
-> = MergeMiddlewareField<ResolveLayoutMiddlewares<LayoutParent<Layout>>, Field> &
-  MergeMiddlewareField<Acc, Field>;
+> = MiddlewareLayoutField<Layout, Field> & MergeMiddlewareField<Acc, Field>;
 
 export type MiddlewareChainContext<
   Layout extends LayoutId,
@@ -505,12 +534,15 @@ export type RouteExport<
   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>;
@@ -541,7 +573,7 @@ type RouteHandleResult<
   };
 };
 
-export type RouteBuilder<
+export type RouteBuilderBase<
   Path extends RoutePath,
   TMethod extends Method,
   Acc extends readonly unknown[] = readonly [],
@@ -555,7 +587,31 @@ export type RouteBuilder<
     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>;
@@ -656,6 +712,40 @@ export type RouteBuilder<
   >;
 };
 
+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 = {},
@@ -734,3 +824,17 @@ export type HandlerBuilder<
         ]
   ): 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/src/types/returns.ts

@@ -1,95 +1,26 @@
-import type { ReplyOf } from "@taserjs/router-utils";
+import type { ReplyOf } from "@taserjs/router-utils/reply";
+import type { StatusCode } from "@taserjs/router-utils";
 
 import type { Simplify } from "./type-utils.js";
 import type { Schema } from "./schema.js";
 import type { 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
+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];
+}[keyof M & number];
 
 export type EmptyReturns = {};
 
@@ -127,4 +58,4 @@ export type EnforceHandlerReply<R, M extends ReturnsMap> = [R] extends [ValidHan
  * Prefer constraining handler generics with {@link EnforceHandlerReply}.
  */
 export type HandlerReply<M extends ReturnsMap> =
-  HasReturns<M> extends true ? ReplyResultFor<M> | Response : Response;
+  HasReturns<M> extends true ? ReplyFor<M> | Response : Response;

package/src/types/type-utils.ts

@@ -1,5 +1,8 @@
-export type Method = "GET" | "POST" | "PUT" | "DELETE" | "PATCH" | "OPTIONS" | "HEAD";
-export type HttpMethod = Method;
+import type { TaserCookieJar, TaserHeaders } from "@taserjs/router-core";
+import type { HttpMethod, HttpVerb } from "@taserjs/router-utils/http";
+
+export type Method = HttpMethod;
+export type { HttpMethod, HttpVerb };
 
 export type MiddlewareFieldName = "query" | "params" | "body" | "state";
 
@@ -71,12 +74,13 @@ export type MergeMiddlewareInputField<
   ? {}
   : 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 type UnitRuntimeContext = Omit<RuntimeContextFields, "var">;

package/src/types/units.ts

@@ -1,13 +1,16 @@
-import type { Awaitable, TaserCookieJar, TaserHeaders } from "@taserjs/router-core";
-import type { ReplyResult } from "@taserjs/router-utils";
+import type {
+  Awaitable,
+  MiddlewareDefinition as CoreMiddlewareDefinition,
+  TaserCookieJar,
+  TaserHeaders,
+} from "@taserjs/router-core";
 
-import type { RouterRegister } from "../register.js";
 import type {
   MergeMiddlewareField,
   MergePart,
   RequestShape,
-  RuntimeContextFields,
   Simplify,
+  UnitRuntimeContext,
   UnwrapPart,
 } from "./type-utils.js";
 import type { ReturnsMap } from "./returns.js";
@@ -28,8 +31,6 @@ export type {
 /** 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;
@@ -41,7 +42,7 @@ export type ValidatorParts = {
 
 export declare const StateBrand: unique symbol;
 
-export type NextResult<TState = unknown> = ReplyResult & {
+export type NextResult<TState = unknown> = Response & {
   readonly [StateBrand]?: TState;
 };
 
@@ -62,13 +63,7 @@ export type NextFn<TExpectedState = unknown> =
 
 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,
@@ -91,7 +86,32 @@ export type MiddlewareReturnFromParts<
   };
 };
 
-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,
@@ -165,7 +185,7 @@ export type HandlerUnit<
     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/cjs/constants.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"constants.cjs","names":[],"sources":["../../src/constants.ts"],"sourcesContent":["/** Input schema keys validated by middleware and route handlers. Headers/cookies are parsed only. */\nexport const SCHEMA_KEYS = [\"query\", \"params\", \"body\"] as const;\n\nexport type SchemaKey = (typeof SCHEMA_KEYS)[number];\n\nexport const HANDLER_SCHEMA_KEY_MAP = {\n  query: \"handlerQuery\",\n  params: \"handlerParams\",\n  body: \"handlerBody\",\n} as const satisfies Record<SchemaKey, string>;\n"],"mappings":";;AACA,IAAa,cAAc;CAAC;CAAS;CAAU;AAAM;AAIrD,IAAa,yBAAyB;CACpC,OAAO;CACP,QAAQ;CACR,MAAM;AACR"}

package/dist/cjs/create-context.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"create-context.cjs","names":[],"sources":["../../src/create-context.ts"],"sourcesContent":["import type { ReservedContextKey } from \"@taserjs/router-core\";\n\nimport type { ContextDefinition } from \"./types/app.js\";\n\ntype NoReservedKeysConstraint<\n  TBoot extends Record<string, unknown>,\n  TReq extends Record<string, unknown>,\n> = Extract<keyof TBoot | keyof TReq, ReservedContextKey> extends never ? unknown : never;\n\nexport function createContext<\n  TBoot extends Record<string, unknown> = Record<string, never>,\n  TReq extends Record<string, unknown> = Record<string, never>,\n>(\n  definition: ContextDefinition<TBoot, TReq> & NoReservedKeysConstraint<TBoot, TReq>,\n): ContextDefinition<TBoot, TReq> {\n  return definition;\n}\n\nexport type { ContextDefinition, InferAppContext } from \"./types/app.js\";\n"],"mappings":";AASA,SAAgB,cAId,YACgC;CAChC,OAAO;AACT"}