@taserjs/router 0.1.4 → 0.1.5

package/dist/esm/middleware/timing.js

@@ -1,9 +1,9 @@
-import { defineMiddleware } from "../define/middleware.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
 function timing(...args) {
-	return defineMiddleware(honoMw(timing$1(...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 { defineMiddleware } from \"../define/middleware.js\";\nimport { honoMw } from \"./hono-mw.js\";\n\nexport function timing(...args: Parameters<typeof honoTiming>) {\n  return defineMiddleware(honoMw(honoTiming(...args)));\n}\n\nexport type TimingOptions = NonNullable<Parameters<typeof honoTiming>[0]>;\n"],"mappings":";;;;AAKA,SAAgB,OAAO,GAAG,MAAqC;CAC7D,OAAO,iBAAiB,OAAO,SAAW,GAAG,IAAI,CAAC,CAAC;AACrD"}
+{"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, Method, MiddlewareDefinition, MiddlewareReturnFromParts, MiddlewareUnit, NextFn, 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, HttpMethod, IsUnknown, Method, MiddlewareDefinition, MiddlewareNext, MiddlewareReturnFromParts, MiddlewareUnit, MiddlewareUnitBuilder, 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;
 }>;

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 { 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,18 +46,20 @@ export type StandaloneMiddlewareContext<TQuery = unknown, TParams = unknown, TBo
     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 MiddlewareUnitBuilder<TQuery = unknown, TParams = unknown, TBody = unknown, TReturns extends ReturnsMap = {}, TRequiredLayouts = unknown, TRequiredState = {}, TAppContext extends Record<string, unknown> = AppContext, TInheritedState = {}, TQueryIn = unknown, TParamsIn = unknown, TBodyIn = unknown> = {
-    query<Q, QIn = unknown>(schema: Schema<Q, QIn>): MiddlewareUnitBuilder<Q, TParams, TBody, TReturns, TRequiredLayouts, TRequiredState, TAppContext, TInheritedState, QIn, TParamsIn, TBodyIn>;
-    params<P, PIn = unknown>(schema: Schema<P, PIn>): MiddlewareUnitBuilder<TQuery, P, TBody, TReturns, TRequiredLayouts, TRequiredState, TAppContext, TInheritedState, TQueryIn, PIn, TBodyIn>;
-    body<B, BIn = unknown>(schema: Schema<B, BIn>): MiddlewareUnitBuilder<TQuery, TParams, B, TReturns, TRequiredLayouts, TRequiredState, TAppContext, TInheritedState, TQueryIn, TParamsIn, BIn>;
-    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>;
-    returns<const M extends ReturnsMap>(map: M): MiddlewareUnitBuilder<TQuery, TParams, TBody, Omit<TReturns, keyof M> & M, TRequiredLayouts, TRequiredState, TAppContext, TInheritedState, TQueryIn, TParamsIn, TBodyIn>;
-    requires<Requires extends Record<string, unknown>>(): MiddlewareUnitBuilder<TQuery, TParams, TBody, TReturns, TRequiredLayouts, TRequiredState & Requires, TAppContext, TInheritedState, TQueryIn, TParamsIn, TBodyIn>;
-    handler<TState = unknown, R = unknown>(fn: (ctx: StandaloneMiddlewareContext<TQuery, TParams, TBody, TAppContext, TInheritedState & TRequiredState>, next: NextFn<NoInfer<TState>>) => Awaitable<R>): DefineMiddlewareResult<TQuery, TParams, TBody, TState, R, TQueryIn, TParamsIn, TBodyIn, TReturns, TRequiredLayouts, TRequiredState>;
+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>;
 };

package/package.json

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

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

@@ -9,7 +9,19 @@ export function createMiddlewareUnitBuilder(requiredLayouts?: string | readonly
   let bodyMode: BodyMode | undefined;
   let returnsMap: ReturnsMap | undefined;
 
-  const builder = {
+  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;
@@ -38,18 +50,17 @@ export function createMiddlewareUnitBuilder(requiredLayouts?: string | readonly
       return builder;
     },
     handler(fn: (ctx: any, next: any) => any) {
-      const schemas = pickDefinedSchemas(validators);
-      const unit = {
-        handler: fn,
-        ...schemas,
-        ...(bodyMode ? { bodyMode } : {}),
-        ...(returnsMap ? { returns: returnsMap, __returns: returnsMap } : {}),
-        ...(requiredLayouts !== undefined ? { __requiredLayouts: requiredLayouts } : {}),
-        __middlewareAcc: undefined as unknown,
-      };
-      return unit;
+      return toUnit(fn);
+    },
+    toUnit() {
+      return toUnit();
     },
+    __middlewareAcc: undefined as unknown,
   };
 
+  if (requiredLayouts !== undefined) {
+    builder.__requiredLayouts = requiredLayouts;
+  }
+
   return builder;
 }

package/src/builder/middleware.ts

@@ -12,6 +12,8 @@ export function createMiddleware<const Layout extends LayoutId>(
     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);
       }

package/src/builder/route.ts

@@ -104,6 +104,8 @@ export function createRouteBuilder(
     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);
       }

package/src/builder/router.ts

@@ -6,30 +6,10 @@ import {
 } from "@taserjs/router-core";
 import { isPromise, normalizeOnError } from "@taserjs/router-utils";
 
-import {
-  createAllRoute,
-  createAnyRoute,
-  createDeleteRoute,
-  createGetRoute,
-  createHeadRoute,
-  createOptionsRoute,
-  createPatchRoute,
-  createPostRoute,
-  createPutRoute,
-} from "./factories.js";
-import { defineMiddleware, type DefineMiddlewareFn } from "../define/middleware.js";
-import { createMiddleware } from "./middleware.js";
 import { TaserApp } from "./app.js";
 import type { ContextDefinition, CreateTaserAppOptions, OnErrorOptions } from "../types/app.js";
-import type { AppContext } from "../types/units.js";
-import type { LayoutId, MiddlewareBuilder } from "../types/index.js";
+import type { EmptyAppContext } from "../types/units.js";
 import type { ReturnsMap } from "../types/returns.js";
-import type {
-  CreateAllRoute,
-  CreateAnyRoute,
-  CreateWithBodyRoute,
-  CreateWithoutBodyRoute,
-} from "./factories.js";
 
 function toOnErrorHandler(
   onErrorOptions: OnErrorOptions | OnErrorOptions["handle"],
@@ -47,10 +27,13 @@ type RouterState = {
 const emptyContext: ContextDefinition<Record<string, unknown>, Record<string, unknown>> = {};
 
 export class TaserRouter<
-  TAppContext extends Record<string, unknown> = AppContext,
+  TAppContext extends Record<string, unknown> = EmptyAppContext,
   THasNotFound extends boolean = false,
 > {
   private readonly state: RouterState;
+  readonly $Infer!: {
+    Context: TAppContext;
+  };
 
   constructor(options: CreateTaserAppOptions = {}, state?: Partial<Omit<RouterState, "options">>) {
     this.state = {
@@ -82,42 +65,6 @@ export class TaserRouter<
     return this as unknown as TaserRouter<TAppContext, true>;
   }
 
-  get: CreateWithoutBodyRoute<"GET", TAppContext> = createGetRoute as CreateWithoutBodyRoute<
-    "GET",
-    TAppContext
-  >;
-  post: CreateWithBodyRoute<"POST", TAppContext> = createPostRoute as CreateWithBodyRoute<
-    "POST",
-    TAppContext
-  >;
-  put: CreateWithBodyRoute<"PUT", TAppContext> = createPutRoute as CreateWithBodyRoute<
-    "PUT",
-    TAppContext
-  >;
-  patch: CreateWithBodyRoute<"PATCH", TAppContext> = createPatchRoute as CreateWithBodyRoute<
-    "PATCH",
-    TAppContext
-  >;
-  delete: CreateWithoutBodyRoute<"DELETE", TAppContext> =
-    createDeleteRoute as CreateWithoutBodyRoute<"DELETE", TAppContext>;
-  options: CreateWithoutBodyRoute<"OPTIONS", TAppContext> =
-    createOptionsRoute as CreateWithoutBodyRoute<"OPTIONS", TAppContext>;
-  head: CreateWithoutBodyRoute<"HEAD", TAppContext> = createHeadRoute as CreateWithoutBodyRoute<
-    "HEAD",
-    TAppContext
-  >;
-  any: CreateAnyRoute<TAppContext> = createAnyRoute as CreateAnyRoute<TAppContext>;
-  all: CreateAllRoute<TAppContext> = createAllRoute as CreateAllRoute<TAppContext>;
-
-  middleware<const Layout extends LayoutId>(
-    layout: Layout,
-  ): MiddlewareBuilder<Layout, readonly [], TAppContext> {
-    return createMiddleware(layout) as MiddlewareBuilder<Layout, readonly [], TAppContext>;
-  }
-
-  defineMiddleware: DefineMiddlewareFn<TAppContext> =
-    defineMiddleware as DefineMiddlewareFn<TAppContext>;
-
   create<const TManifest extends RouteManifestShape>(
     manifest: TManifest,
     runtimeOptions?: { basePath?: string },
@@ -192,6 +139,6 @@ export class TaserRouter<
 
 export function createTaserApp(
   options: CreateTaserAppOptions = {},
-): TaserRouter<AppContext, false> {
-  return new TaserRouter<AppContext, false>(options);
+): TaserRouter<EmptyAppContext, false> {
+  return new TaserRouter<EmptyAppContext, false>(options);
 }

package/src/builder/standalone.ts

@@ -0,0 +1,70 @@
+import type { AppContext, LayoutBuilder } from "../types/index.js";
+import {
+  createAllRoute,
+  createAnyRoute,
+  createDeleteRoute,
+  createGetRoute,
+  createHeadRoute,
+  createOptionsRoute,
+  createPatchRoute,
+  createPostRoute,
+  createPutRoute,
+  type CreateAllRoute,
+  type CreateAnyRoute,
+  type CreateWithBodyRoute,
+  type CreateWithoutBodyRoute,
+} from "./factories.js";
+import { createMiddleware } from "./middleware.js";
+import { middleware as createMiddlewareFn, type MiddlewareFn } from "../define/middleware.js";
+
+export const get: CreateWithoutBodyRoute<"GET", AppContext> =
+  createGetRoute as CreateWithoutBodyRoute<"GET", AppContext>;
+export const post: CreateWithBodyRoute<"POST", AppContext> = createPostRoute as CreateWithBodyRoute<
+  "POST",
+  AppContext
+>;
+export const put: CreateWithBodyRoute<"PUT", AppContext> = createPutRoute as CreateWithBodyRoute<
+  "PUT",
+  AppContext
+>;
+export const patch: CreateWithBodyRoute<"PATCH", AppContext> =
+  createPatchRoute as CreateWithBodyRoute<"PATCH", AppContext>;
+export const del: CreateWithoutBodyRoute<"DELETE", AppContext> =
+  createDeleteRoute as CreateWithoutBodyRoute<"DELETE", AppContext>;
+export const options: CreateWithoutBodyRoute<"OPTIONS", AppContext> =
+  createOptionsRoute as CreateWithoutBodyRoute<"OPTIONS", AppContext>;
+export const head: CreateWithoutBodyRoute<"HEAD", AppContext> =
+  createHeadRoute as CreateWithoutBodyRoute<"HEAD", AppContext>;
+export const any: CreateAnyRoute<AppContext> = createAnyRoute as CreateAnyRoute<AppContext>;
+export const all: CreateAllRoute<AppContext> = createAllRoute as CreateAllRoute<AppContext>;
+
+export const layout: LayoutBuilder<AppContext> = createMiddleware as LayoutBuilder<AppContext>;
+export const middleware: MiddlewareFn<AppContext> = createMiddlewareFn as MiddlewareFn<AppContext>;
+
+export type TaserNamespace<TAppContext extends Record<string, unknown> = AppContext> = {
+  readonly get: CreateWithoutBodyRoute<"GET", TAppContext>;
+  readonly post: CreateWithBodyRoute<"POST", TAppContext>;
+  readonly put: CreateWithBodyRoute<"PUT", TAppContext>;
+  readonly patch: CreateWithBodyRoute<"PATCH", TAppContext>;
+  readonly delete: CreateWithoutBodyRoute<"DELETE", TAppContext>;
+  readonly options: CreateWithoutBodyRoute<"OPTIONS", TAppContext>;
+  readonly head: CreateWithoutBodyRoute<"HEAD", TAppContext>;
+  readonly any: CreateAnyRoute<TAppContext>;
+  readonly all: CreateAllRoute<TAppContext>;
+  readonly layout: LayoutBuilder<TAppContext>;
+  readonly middleware: MiddlewareFn<TAppContext>;
+};
+
+export const t: TaserNamespace<AppContext> = {
+  get,
+  post,
+  put,
+  patch,
+  delete: del,
+  options,
+  head,
+  any,
+  all,
+  layout,
+  middleware,
+};

package/src/define/middleware.ts

@@ -1,8 +1,5 @@
-import { type Awaitable } from "@taserjs/router-core";
-
 import { createMiddlewareUnitBuilder } from "../builder/middleware-unit.js";
 import type {
-  AppContext,
   DefineMiddlewareResult,
   ExtractState,
   IsUnknown,
@@ -11,30 +8,44 @@ import type {
   StandaloneMiddlewareContext,
 } from "../types/units.js";
 import type {
+  AppContext,
   LayoutId,
   ResolveLayoutMiddlewaresState,
   ResolveLayoutsState,
 } from "../types/index.js";
 
-export interface DefineMiddlewareFn<TAppContext extends Record<string, unknown> = AppContext> {
+export interface MiddlewareFn<TAppContext extends Record<string, unknown> = AppContext> {
   /**
-   * Constructs a fluent unscoped middleware builder.
+   * Constructs a fluent unscoped middleware builder, with optional explicit State generic.
    *
    * @example
    * ```ts
-   * const auth = defineMiddleware()
+   * const auth = middleware<{ user: string }>()
    *   .query(z.object({ token: z.string() }))
    *   .body("form", z.object({ file: z.instanceof(File) }))
    *   .returns({ 401: z.string() })
    *   .handler(async (ctx, next) => next({ user: "alice" }));
    * ```
    */
-  (): MiddlewareUnitBuilder<unknown, unknown, unknown, {}, null, {}, TAppContext>;
+  <TState = unknown>(): MiddlewareUnitBuilder<
+    unknown,
+    unknown,
+    unknown,
+    {},
+    null,
+    {},
+    TAppContext,
+    {},
+    unknown,
+    unknown,
+    unknown,
+    TState
+  >;
 
   /**
-   * Constructs a fluent middleware builder scoped to a single layout branch.
+   * Constructs a fluent middleware builder scoped to a single layout branch, with optional explicit State generic.
    */
-  <const Layout extends LayoutId>(
+  <const Layout extends LayoutId, TState = unknown>(
     layout: Layout,
   ): MiddlewareUnitBuilder<
     unknown,
@@ -44,13 +55,17 @@ export interface DefineMiddlewareFn<TAppContext extends Record<string, unknown>
     Layout,
     {},
     TAppContext,
-    ResolveLayoutMiddlewaresState<Layout>
+    ResolveLayoutMiddlewaresState<Layout>,
+    unknown,
+    unknown,
+    unknown,
+    TState
   >;
 
   /**
-   * Constructs a fluent middleware builder scoped to multiple layout branches (branch union).
+   * Constructs a fluent middleware builder scoped to multiple layout branches (branch union), with optional explicit State generic.
    */
-  <const Layouts extends readonly [LayoutId, ...LayoutId[]]>(
+  <const Layouts extends readonly [LayoutId, ...LayoutId[]], TState = unknown>(
     layouts: Layouts,
   ): MiddlewareUnitBuilder<
     unknown,
@@ -60,7 +75,11 @@ export interface DefineMiddlewareFn<TAppContext extends Record<string, unknown>
     Layouts,
     {},
     TAppContext,
-    ResolveLayoutsState<Layouts>
+    ResolveLayoutsState<Layouts>,
+    unknown,
+    unknown,
+    unknown,
+    TState
   >;
 
   /**
@@ -77,7 +96,7 @@ export interface DefineMiddlewareFn<TAppContext extends Record<string, unknown>
         ResolveLayoutMiddlewaresState<Layout> & TRequires
       >,
       next: NextFn<NoInfer<TState>>,
-    ) => Awaitable<R>,
+    ) => R,
   ): DefineMiddlewareResult<
     unknown,
     unknown,
@@ -111,7 +130,7 @@ export interface DefineMiddlewareFn<TAppContext extends Record<string, unknown>
         ResolveLayoutsState<Layouts> & TRequires
       >,
       next: NextFn<NoInfer<TState>>,
-    ) => Awaitable<R>,
+    ) => R,
   ): DefineMiddlewareResult<
     unknown,
     unknown,
@@ -131,7 +150,7 @@ export interface DefineMiddlewareFn<TAppContext extends Record<string, unknown>
    *
    * @example
    * ```ts
-   * const auth = defineMiddleware((ctx, next) => {
+   * const auth = middleware((ctx, next) => {
    *   return next({ user: "alice" });
    * });
    * ```
@@ -140,7 +159,7 @@ export interface DefineMiddlewareFn<TAppContext extends Record<string, unknown>
     fn: (
       ctx: StandaloneMiddlewareContext<unknown, unknown, unknown, TAppContext, TRequires>,
       next: NextFn<NoInfer<TState>>,
-    ) => Awaitable<R>,
+    ) => R,
   ): DefineMiddlewareResult<
     unknown,
     unknown,
@@ -156,7 +175,7 @@ export interface DefineMiddlewareFn<TAppContext extends Record<string, unknown>
   >;
 }
 
-export const defineMiddleware: DefineMiddlewareFn<AppContext> = function defineMiddleware(
+export const middleware: MiddlewareFn<AppContext> = function middleware(
   first?: any,
   second?: any,
 ): any {

package/src/index.ts

@@ -1,17 +1,25 @@
-export type { RouterRegister } from "./register.js";
+export interface RouterRegister {}
 export type {
+  AppContext,
+  EmptyAppContext,
   HttpMethod,
   InferInput,
   InferOutput,
   InferRouteContext,
   InferRouteInput,
+  InferRouteInputFromPath,
   InferRouteOutput,
+  LayoutBuilder,
+  LayoutId,
+  LayoutTree,
   Method,
+  MiddlewareBuilder,
   MiddlewareDefinition,
   MiddlewareUnit,
   MiddlewareUnitBuilder,
   PathParams,
   ReturnsMap,
+  RouteByPathMethod,
   RouteDefinition,
   RouteExport,
   RoutePath,
@@ -31,10 +39,26 @@ export type {
 export { ValidationError, validationErrorSchema } from "@taserjs/router-utils";
 export type { ResponseValidationFailureHandler, SuccessStatusCode } from "@taserjs/router-utils";
 
+export {
+  all,
+  any,
+  del,
+  get,
+  head,
+  layout,
+  middleware,
+  options,
+  patch,
+  post,
+  put,
+  t,
+  type TaserNamespace,
+} from "./builder/standalone.js";
+
 export { createTaserApp, TaserRouter } from "./builder/router.js";
 export { TaserApp } from "./builder/app.js";
 export { createContext } from "./context/create-context.js";
-export { defineMiddleware } from "./define/middleware.js";
 export { honoMw } from "./middleware/hono-mw.js";
+export type { MiddlewareFn } from "./define/middleware.js";
 
 export type { TaserCookieJar, TaserHeaders } from "@taserjs/router-core";