rouzer 2.0.1 → 3.0.1

package/dist/server/router.js

@@ -1,4 +1,5 @@
 import { RoutePattern } from '@remix-run/route-pattern';
+import { createMatcher } from '@remix-run/route-pattern/match';
 import { chain, MiddlewareChain, } from 'alien-middleware';
 import * as z from 'zod';
 import { mapValues } from '../common.js';
@@ -13,14 +14,14 @@ class RouterObject extends MiddlewareChain {
         this.basePath = config.basePath?.replace(/\/?$/, '/');
         const allowOrigins = config.cors?.allowOrigins?.map(createOriginPattern);
         if (allowOrigins) {
-            super.use((ctx) => {
+            super.use(((ctx) => {
                 const origin = ctx.request.headers.get('Origin');
                 if (origin &&
                     allowOrigins &&
                     !allowOrigins.some(pattern => pattern.test(origin))) {
                     return new Response(null, { status: 403 });
                 }
-            });
+            }));
         }
     }
     use(...args) {
@@ -31,28 +32,13 @@ class RouterObject extends MiddlewareChain {
     /** @internal */
     useRoutes(routeSchemas, handlers) {
         const { config, basePath } = this;
-        const routes = Object.entries(routeSchemas).map(([name, route]) => ({
-            name,
-            path: basePath
-                ? new RoutePattern(route.path.source.replace(/^\/?/, basePath))
-                : route.path,
-            methods: mapValues(route.methods, (schema, method) => {
-                const handler = handlers[name][method];
-                if (!handler && config.debug) {
-                    console.error(`Handler missing for route: ${method} ${name}`);
-                }
-                return {
-                    schema,
-                    handler,
-                };
-            }),
-        }));
+        const routes = flattenRoutes(routeSchemas, handlers, basePath ?? '', config.debug);
         const addDebugHeaders = config.debug
             ? (context, route) => {
                 context.setHeader('X-Route-Name', route.name);
             }
             : null;
-        return super.use(async function (context) {
+        return super.use((async function (context) {
             const request = context.request;
             const origin = request.headers.get('Origin');
             const url = (context.url ??= new URL(request.url));
@@ -65,28 +51,18 @@ class RouterObject extends MiddlewareChain {
                         'GET';
             }
             for (const route of routes) {
-                const props = route.methods.hasOwnProperty(method)
-                    ? route.methods[method]
-                    : route.methods.ALL;
-                if (!props) {
+                if (route.method !== method) {
                     continue;
                 }
-                const { schema, handler } = props;
+                const { schema, handler } = route;
                 if (!handler) {
                     continue;
                 }
-                const match = route.path.match(url);
+                const match = route.matcher.match(url);
                 if (!match) {
                     continue;
                 }
                 if (isPreflight) {
-                    const optionsHandler = handlers[route.name].OPTIONS;
-                    if (optionsHandler) {
-                        const response = await optionsHandler(context);
-                        if (response) {
-                            return response;
-                        }
-                    }
                     return new Response(null, {
                         headers: {
                             'Access-Control-Allow-Origin': origin ?? '',
@@ -136,7 +112,7 @@ class RouterObject extends MiddlewareChain {
                 }
                 return Response.json(result);
             }
-        });
+        }));
     }
 }
 /**
@@ -153,6 +129,32 @@ export function createRouter(config = {}) {
     Object.setPrototypeOf(handler, router);
     return handler;
 }
+function flattenRoutes(tree, handlers, prefix, debug) {
+    const routes = [];
+    for (const [name, node] of Object.entries(tree)) {
+        if (node.kind === 'resource') {
+            routes.push(...flattenRoutes(node.children, handlers[name], joinPaths(prefix, node.path.source), debug));
+        }
+        else {
+            const handler = handlers[name];
+            if (!handler && debug) {
+                console.error(`Handler missing for route: ${node.method} ${name}`);
+            }
+            routes.push({
+                name,
+                path: RoutePattern.parse(joinPaths(prefix, node.path?.source ?? '')),
+                matcher: createMatcher(joinPaths(prefix, node.path?.source ?? '')),
+                method: node.method,
+                schema: node.schema,
+                handler,
+            });
+        }
+    }
+    return routes;
+}
+function joinPaths(left, right) {
+    return [left, right].filter(Boolean).join('/').replace(/\/+/g, '/');
+}
 function httpClientError(error, message, config) {
     return Response.json({
         ...error,

package/dist/server/types.d.ts

@@ -1,46 +1,42 @@
-import type { Params } from '@remix-run/route-pattern';
+import type { MatchParams } from '@remix-run/route-pattern/match';
 import type { AnyMiddlewareChain, MiddlewareChain, MiddlewareContext } from 'alien-middleware';
 import type * as z from 'zod';
 import { Promisable } from '../common.js';
-import type { InferRouteResponse, Routes, RouteSchema } from '../types.js';
+import type { HttpAction, HttpResource, HttpRouteTree } from '../http.js';
+import type { InferRouteResponse, RouteSchema } from '../types.js';
 type RequestContext<TMiddleware extends AnyMiddlewareChain> = MiddlewareContext<TMiddleware>;
 type RouteRequestHandler<TMiddleware extends AnyMiddlewareChain, TArgs extends object, TResult> = (context: RequestContext<TMiddleware> & TArgs) => Promisable<TResult | Response>;
-type InferRouteRequestHandler<TMiddleware extends AnyMiddlewareChain, TSchema extends RouteSchema, TMethod extends string, TPath extends string> = TMethod extends 'GET' ? RouteRequestHandler<TMiddleware, {
-    path: TSchema extends {
+type InferActionHandler<TMiddleware extends AnyMiddlewareChain, TAction extends HttpAction, TPath extends string> = TAction['method'] extends 'GET' ? RouteRequestHandler<TMiddleware, {
+    path: TAction['schema'] extends {
         path: any;
-    } ? z.infer<TSchema['path']> : Params<TPath>;
-    query: TSchema extends {
+    } ? z.infer<TAction['schema']['path']> : MatchParams<TPath>;
+    query: TAction['schema'] extends {
         query: any;
-    } ? z.infer<TSchema['query']> : undefined;
-    headers: TSchema extends {
+    } ? z.infer<TAction['schema']['query']> : undefined;
+    headers: TAction['schema'] extends {
         headers: any;
-    } ? z.infer<TSchema['headers']> : undefined;
-}, InferRouteResponse<TSchema>> : RouteRequestHandler<TMiddleware, {
-    path: TSchema extends {
+    } ? z.infer<TAction['schema']['headers']> : undefined;
+}, InferRouteResponse<Extract<TAction['schema'], RouteSchema>>> : RouteRequestHandler<TMiddleware, {
+    path: TAction['schema'] extends {
         path: any;
-    } ? z.infer<TSchema['path']> : Params<TPath>;
-    body: TSchema extends {
+    } ? z.infer<TAction['schema']['path']> : MatchParams<TPath>;
+    body: TAction['schema'] extends {
         body: any;
-    } ? z.infer<TSchema['body']> : undefined;
-    headers: TSchema extends {
+    } ? z.infer<TAction['schema']['body']> : undefined;
+    headers: TAction['schema'] extends {
         headers: any;
-    } ? z.infer<TSchema['headers']> : undefined;
-}, InferRouteResponse<TSchema>>;
+    } ? z.infer<TAction['schema']['headers']> : undefined;
+}, InferRouteResponse<Extract<TAction['schema'], RouteSchema>>>;
+type Join<A extends string, B extends string> = A extends '' ? B : B extends '' ? A : `${A}/${B}`;
 /**
  * Handler map shape required by `createRouter().use(routes, handlers)`.
  *
- * @remarks Each route key must provide handlers for the methods declared by its
- * route schema. Handler context is inferred from middleware plus the route's
- * path, query/body, and header schemas. An optional `OPTIONS` handler can
- * customize CORS preflight responses for a route.
+ * @remarks The handler object mirrors the HTTP route tree. Resource nodes become
+ * nested handler objects, while action nodes become direct handler functions.
+ * Handler context is inferred from middleware plus accumulated path params,
+ * query/body schemas, and header schemas.
  */
-export type RouteRequestHandlerMap<TRoutes extends Routes = Routes, TMiddleware extends AnyMiddlewareChain = MiddlewareChain> = {
-    [K in keyof TRoutes]: {
-        [TMethod in keyof TRoutes[K]['methods']]: InferRouteRequestHandler<TMiddleware, Extract<TRoutes[K]['methods'][TMethod], RouteSchema>, Extract<TMethod, string>, TRoutes[K]['path']['source']>;
-    } & {
-        OPTIONS?: RouteRequestHandler<TMiddleware, {
-            path: Params<TRoutes[K]['path']['source']>;
-        }, void>;
-    };
+export type RouteRequestHandlerMap<TRoutes extends HttpRouteTree = HttpRouteTree, TMiddleware extends AnyMiddlewareChain = MiddlewareChain, TPrefix extends string = ''> = {
+    [K in keyof TRoutes]: TRoutes[K] extends HttpResource<infer P, infer C> ? RouteRequestHandlerMap<C, TMiddleware, Join<TPrefix, P>> : TRoutes[K] extends HttpAction<infer P, any, any> ? InferActionHandler<TMiddleware, TRoutes[K], Join<TPrefix, P>> : never;
 };
 export {};

package/dist/type.d.ts

@@ -0,0 +1,22 @@
+import { Unchecked } from './common.js';
+/**
+ * Create a compile-time-only marker for an action's JSON response payload type.
+ *
+ * @remarks `$type<T>()` does not perform runtime validation. It lets Rouzer type
+ * server handler return values and client action functions for HTTP actions
+ * whose responses are expected to be JSON.
+ *
+ * @example
+ * ```ts
+ * import { $type } from 'rouzer'
+ * import * as http from 'rouzer/http'
+ *
+ * const hello = http.get('hello/:name', {
+ *   response: $type<{ message: string }>(),
+ * })
+ * ```
+ */
+export declare function $type<T>(): Unchecked<T>;
+export declare namespace $type {
+    var symbol: symbol;
+}

package/dist/type.js

@@ -0,0 +1,21 @@
+/**
+ * Create a compile-time-only marker for an action's JSON response payload type.
+ *
+ * @remarks `$type<T>()` does not perform runtime validation. It lets Rouzer type
+ * server handler return values and client action functions for HTTP actions
+ * whose responses are expected to be JSON.
+ *
+ * @example
+ * ```ts
+ * import { $type } from 'rouzer'
+ * import * as http from 'rouzer/http'
+ *
+ * const hello = http.get('hello/:name', {
+ *   response: $type<{ message: string }>(),
+ * })
+ * ```
+ */
+export function $type() {
+    return $type.symbol;
+}
+$type.symbol = Symbol();

package/dist/types/args.d.ts

@@ -0,0 +1,51 @@
+import type { MatchParams } from '@remix-run/route-pattern/match';
+import type * as z from 'zod';
+import type { MutationRouteSchema, QueryRouteSchema, RouteSchema } from './schema.js';
+declare class Any {
+    private isAny;
+}
+type PathArgs<T, P extends string> = T extends {
+    path: infer TPath;
+} ? {} extends z.infer<TPath> ? {
+    [K in keyof T as 'path']?: z.infer<TPath>;
+} : {
+    [K in keyof T as 'path']: z.infer<TPath>;
+} : MatchParams<P> extends infer TParams ? {} extends TParams ? {
+    [K in keyof T as 'path']?: TParams;
+} : {
+    [K in keyof T as 'path']: TParams;
+} : unknown;
+type QueryArgs<T> = T extends QueryRouteSchema & {
+    query: infer TQuery;
+} ? {} extends z.infer<TQuery> ? {
+    [K in keyof T as 'query']?: z.infer<TQuery>;
+} : {
+    [K in keyof T as 'query']: z.infer<TQuery>;
+} : unknown;
+type MutationArgs<T> = T extends MutationRouteSchema ? T extends {
+    body: infer TBody;
+} ? {} extends z.infer<TBody> ? {
+    [K in keyof T as 'body']?: z.infer<TBody>;
+} : {
+    [K in keyof T as 'body']: z.infer<TBody>;
+} : {
+    body?: unknown;
+} : unknown;
+/**
+ * Arguments accepted by a client action function or low-level request factory.
+ *
+ * @remarks The type is derived from an action schema and route pattern. `path`,
+ * `query`, `body`, and `headers` are validated by the client before `fetch` when
+ * a matching schema exists. Other `RequestInit` fields are forwarded to `fetch`,
+ * except `method`, `body`, and `headers`, which Rouzer derives from the action
+ * schema and call arguments.
+ */
+export type RouteArgs<T extends RouteSchema = any, P extends string = string> = ([T] extends [Any] ? {
+    query?: any;
+    body?: any;
+    path?: any;
+} : QueryArgs<T> & MutationArgs<T> & PathArgs<T, P>) & Omit<RequestInit, 'method' | 'body' | 'headers'> & {
+    /** Headers for this request. Undefined values are removed before `fetch`. */
+    headers?: Record<string, string | undefined>;
+};
+export {};

package/dist/types/args.js

@@ -0,0 +1 @@
+export {};

package/dist/types/handler.d.ts

@@ -0,0 +1,31 @@
+import type { MatchParams } from '@remix-run/route-pattern/match';
+import type { AnyMiddlewareChain, MiddlewareContext } from 'alien-middleware';
+import type * as z from 'zod';
+import { Promisable } from '../common.js';
+import type { HttpAction } from '../http.js';
+import type { InferRouteResponse } from './response.js';
+import type { RouteSchema } from './schema.js';
+type RequestContext<TMiddleware extends AnyMiddlewareChain> = MiddlewareContext<TMiddleware>;
+export type RouteRequestHandler<TMiddleware extends AnyMiddlewareChain, TArgs extends object, TResult> = (context: RequestContext<TMiddleware> & TArgs) => Promisable<TResult | Response>;
+export type InferActionHandler<TMiddleware extends AnyMiddlewareChain, TAction extends HttpAction, TPath extends string> = TAction['method'] extends 'GET' ? RouteRequestHandler<TMiddleware, {
+    path: TAction['schema'] extends {
+        path: any;
+    } ? z.infer<TAction['schema']['path']> : MatchParams<TPath>;
+    query: TAction['schema'] extends {
+        query: any;
+    } ? z.infer<TAction['schema']['query']> : undefined;
+    headers: TAction['schema'] extends {
+        headers: any;
+    } ? z.infer<TAction['schema']['headers']> : undefined;
+}, InferRouteResponse<Extract<TAction['schema'], RouteSchema>>> : RouteRequestHandler<TMiddleware, {
+    path: TAction['schema'] extends {
+        path: any;
+    } ? z.infer<TAction['schema']['path']> : MatchParams<TPath>;
+    body: TAction['schema'] extends {
+        body: any;
+    } ? z.infer<TAction['schema']['body']> : undefined;
+    headers: TAction['schema'] extends {
+        headers: any;
+    } ? z.infer<TAction['schema']['headers']> : undefined;
+}, InferRouteResponse<Extract<TAction['schema'], RouteSchema>>>;
+export {};

package/dist/types/handler.js

@@ -0,0 +1 @@
+export {};

package/dist/types/index.d.ts

@@ -0,0 +1,7 @@
+export type * from './args.js';
+export type * from './handler.js';
+export type * from './infer.js';
+export type * from './request.js';
+export type * from './response.js';
+export type * from './schema.js';
+export type * from './server.js';

package/dist/types/index.js

@@ -0,0 +1 @@
+export {};

package/dist/types/infer.d.ts

@@ -0,0 +1,19 @@
+import type * as z from 'zod';
+import type { MutationRouteSchema, RouteSchema } from './schema.js';
+import type { RouteRequestFactory } from './request.js';
+type InferRouteSchemaBody<TSchema> = TSchema extends MutationRouteSchema ? TSchema extends {
+    body: infer TBody;
+} ? z.infer<TBody> : unknown : never;
+type InferRouteArgsBody<TArgs> = TArgs extends {
+    body?: infer TBody;
+} ? TBody : never;
+/**
+ * Infer the request body type from an action schema or request factory.
+ *
+ * @remarks HTTP action schemas can be inspected with
+ * `InferRouteBody<typeof action.schema>`. Request factories for mutation actions
+ * infer their `body` argument type. Schemas without a body schema infer
+ * `unknown`.
+ */
+export type InferRouteBody<T> = T extends RouteRequestFactory<any, any> ? InferRouteArgsBody<T['$args']> : T extends RouteSchema ? InferRouteSchemaBody<T> : never;
+export {};

package/dist/types/infer.js

@@ -0,0 +1 @@
+export {};

package/dist/types/path.d.ts

@@ -0,0 +1 @@
+export type Join<A extends string, B extends string> = A extends '' ? B : B extends '' ? A : `${A}/${B}`;

package/dist/types/path.js

@@ -0,0 +1 @@
+export {};

package/dist/types/request.d.ts

@@ -0,0 +1,35 @@
+import type { RoutePattern } from '@remix-run/route-pattern';
+import type { RouteArgs } from './args.js';
+import type { InferRouteResponse } from './response.js';
+import type { RouteSchema } from './schema.js';
+/**
+ * Request descriptor produced by an HTTP action request factory.
+ *
+ * @remarks Pass this object to `client.request(...)` for a raw `Response` or
+ * `client.json(...)` for parsed JSON handling.
+ */
+export type RouteRequest<TResult = any> = {
+    /** Method schema used for client-side validation. */
+    schema: RouteSchema;
+    /** Parsed route pattern used to generate the request URL. */
+    path: RoutePattern;
+    /** HTTP method to send. */
+    method: string;
+    /** Validated route arguments and request options. */
+    args: RouteArgs;
+    /** Phantom result type consumed by `client.json(...)`. */
+    $result: TResult;
+};
+/**
+ * Callable factory attached to an HTTP action.
+ *
+ * @remarks Calling a factory validates no data by itself; it creates a typed
+ * `RouteRequest` descriptor for `createClient` to validate and send.
+ */
+export type RouteRequestFactory<T extends RouteSchema, P extends string> = {
+    (...p: RouteArgs<T, P> extends infer TArgs ? {} extends TArgs ? [args?: TArgs] : [args: TArgs] : never): RouteRequest<InferRouteResponse<T>>;
+    /** Inferred argument type for this request factory. */
+    $args: RouteArgs<T, P>;
+    /** Inferred JSON response type for this request factory. */
+    $response: InferRouteResponse<T>;
+};

package/dist/types/request.js

@@ -0,0 +1 @@
+export {};

package/dist/types/response.d.ts

@@ -0,0 +1,9 @@
+import type { Unchecked, RouteSchema } from './schema.js';
+/** `Response` whose `.json()` method resolves to a known payload type. */
+export type RouteResponse<TResult = any> = Response & {
+    json(): Promise<TResult>;
+};
+/** Infer the JSON response payload type from an action schema. */
+export type InferRouteResponse<T extends RouteSchema> = T extends {
+    response: Unchecked<infer TResponse>;
+} ? TResponse : void;

package/dist/types/response.js

@@ -0,0 +1 @@
+export {};

package/dist/types/schema.d.ts

@@ -0,0 +1,37 @@
+import * as z from 'zod';
+import { Unchecked } from '../common.js';
+/**
+ * Compile-time-only marker used by `$type<T>()` for unchecked response types.
+ *
+ * @remarks Application code should usually call `$type<T>()` instead of naming
+ * this marker directly.
+ */
+export type { Unchecked };
+/** Schema shape for `GET` route methods. */
+export type QueryRouteSchema = {
+    /** Optional Zod object used to validate path params. */
+    path?: z.ZodObject<any>;
+    /** Optional Zod object used to validate URL query params. */
+    query?: z.ZodObject<any>;
+    /** `GET` routes do not accept request bodies. */
+    body?: never;
+    /** Optional Zod object used to validate request headers. */
+    headers?: z.ZodObject<any>;
+    /** Optional compile-time-only JSON response type marker. */
+    response?: Unchecked<any>;
+};
+/** Schema shape for mutation route methods. */
+export type MutationRouteSchema = {
+    /** Optional Zod object used to validate path params. */
+    path?: z.ZodObject<any>;
+    /** Mutation routes do not accept query schemas. */
+    query?: never;
+    /** Optional Zod schema used to validate the JSON request body. */
+    body?: z.ZodType<any, any>;
+    /** Optional Zod object used to validate request headers. */
+    headers?: z.ZodObject<any>;
+    /** Optional compile-time-only JSON response type marker. */
+    response?: Unchecked<any>;
+};
+/** Any HTTP action schema Rouzer can execute. */
+export type RouteSchema = QueryRouteSchema | MutationRouteSchema;

package/dist/types/schema.js

@@ -0,0 +1 @@
+export {};

package/dist/types/server.d.ts

@@ -0,0 +1,15 @@
+import type { AnyMiddlewareChain, MiddlewareChain } from 'alien-middleware';
+import type { HttpAction, HttpResource, HttpRouteTree } from '../http.js';
+import type { InferActionHandler } from './handler.js';
+import type { Join } from './path.js';
+/**
+ * Handler map shape required by `createRouter().use(routes, handlers)`.
+ *
+ * @remarks The handler object mirrors the HTTP route tree. Resource nodes become
+ * nested handler objects, while action nodes become direct handler functions.
+ * Handler context is inferred from middleware plus accumulated path params,
+ * query/body schemas, and header schemas.
+ */
+export type RouteRequestHandlerMap<TRoutes extends HttpRouteTree = HttpRouteTree, TMiddleware extends AnyMiddlewareChain = MiddlewareChain, TPrefix extends string = ''> = {
+    [K in keyof TRoutes]: TRoutes[K] extends HttpResource<infer P, infer C> ? RouteRequestHandlerMap<C, TMiddleware, Join<TPrefix, P>> : TRoutes[K] extends HttpAction<infer P, any, any> ? InferActionHandler<TMiddleware, TRoutes[K], Join<TPrefix, P>> : never;
+};

package/dist/types/server.js

@@ -0,0 +1 @@
+export {};

package/dist/types.d.ts

@@ -1,4 +1,5 @@
-import { Params, RoutePattern } from '@remix-run/route-pattern';
+import type { MatchParams } from '@remix-run/route-pattern/match';
+import { RoutePattern } from '@remix-run/route-pattern';
 import * as z from 'zod';
 import { Unchecked } from './common.js';
 /**
@@ -34,41 +35,8 @@ export type MutationRouteSchema = {
     /** Optional compile-time-only JSON response type marker. */
     response?: Unchecked<any>;
 };
-/**
- * Method schema map accepted by `route(...)`.
- *
- * @remarks `GET` validates query input, mutation methods validate JSON body
- * input, and `ALL` acts as a fallback for methods that are not declared
- * explicitly.
- */
-export type RouteSchemaMap = {
-    GET?: QueryRouteSchema;
-    POST?: MutationRouteSchema;
-    PUT?: MutationRouteSchema;
-    PATCH?: MutationRouteSchema;
-    DELETE?: MutationRouteSchema;
-    ALL?: {
-        /** Optional Zod object used to validate path params. */
-        path?: z.ZodObject<any>;
-        /** Optional Zod object used to validate URL query params. */
-        query?: z.ZodObject<any>;
-        /** `ALL` fallback routes do not accept request bodies. */
-        body?: never;
-        /** Optional Zod object used to validate request headers. */
-        headers?: z.ZodObject<any>;
-        /** `ALL` fallback routes do not define typed JSON responses. */
-        response?: never;
-    };
-};
-/** Any route method schema Rouzer can execute. */
+/** Any HTTP action schema Rouzer can execute. */
 export type RouteSchema = QueryRouteSchema | MutationRouteSchema;
-/** Route map accepted by `createRouter().use(...)` and `createClient(...)`. */
-export type Routes = {
-    [key: string]: {
-        path: RoutePattern;
-        methods: RouteSchemaMap;
-    };
-};
 declare class Any {
     private isAny;
 }
@@ -78,7 +46,7 @@ type PathArgs<T, P extends string> = T extends {
     [K in keyof T as 'path']?: z.infer<TPath>;
 } : {
     [K in keyof T as 'path']: z.infer<TPath>;
-} : Params<P> extends infer TParams ? {} extends TParams ? {
+} : MatchParams<P> extends infer TParams ? {} extends TParams ? {
     [K in keyof T as 'path']?: TParams;
 } : {
     [K in keyof T as 'path']: TParams;
@@ -100,13 +68,13 @@ type MutationArgs<T> = T extends MutationRouteSchema ? T extends {
     body?: unknown;
 } : unknown;
 /**
- * Arguments accepted by a route request factory such as `route.GET(...)`.
+ * Arguments accepted by a client action function or low-level request factory.
  *
- * @remarks The type is derived from a method schema and route pattern. `path`,
+ * @remarks The type is derived from an action schema and route pattern. `path`,
  * `query`, `body`, and `headers` are validated by the client before `fetch` when
- * a matching schema exists. The client forwards the HTTP method, JSON body, and
- * headers; extra `RequestInit` fields are accepted by the type surface but are
- * not forwarded.
+ * a matching schema exists. Other `RequestInit` fields are forwarded to `fetch`,
+ * except `method`, `body`, and `headers`, which Rouzer derives from the action
+ * schema and call arguments.
  */
 export type RouteArgs<T extends RouteSchema = any, P extends string = string> = ([T] extends [Any] ? {
     query?: any;
@@ -117,7 +85,7 @@ export type RouteArgs<T extends RouteSchema = any, P extends string = string> =
     headers?: Record<string, string | undefined>;
 };
 /**
- * Request descriptor produced by a route request factory.
+ * Request descriptor produced by an HTTP action request factory.
  *
  * @remarks Pass this object to `client.request(...)` for a raw `Response` or
  * `client.json(...)` for parsed JSON handling.
@@ -138,7 +106,7 @@ export type RouteRequest<TResult = any> = {
 export type RouteResponse<TResult = any> = Response & {
     json(): Promise<TResult>;
 };
-/** Infer the JSON response payload type from a method schema. */
+/** Infer the JSON response payload type from an action schema. */
 export type InferRouteResponse<T extends RouteSchema> = T extends {
     response: Unchecked<infer TResponse>;
 } ? TResponse : void;
@@ -149,23 +117,16 @@ type InferRouteArgsBody<TArgs> = TArgs extends {
     body?: infer TBody;
 } ? TBody : never;
 /**
- * Infer the request body type from a mutation schema or route request factory.
+ * Infer the request body type from an action schema or request factory.
  *
- * @remarks Route request factories for mutation methods infer their `body`
- * argument type. Mutation schemas without a body schema infer `unknown`.
+ * @remarks HTTP action schemas can be inspected with
+ * `InferRouteBody<typeof action.schema>`. Request factories for mutation actions
+ * infer their `body` argument type. Schemas without a body schema infer
+ * `unknown`.
  */
 export type InferRouteBody<T> = T extends RouteRequestFactory<any, any> ? InferRouteArgsBody<T['$args']> : T extends RouteSchema ? InferRouteSchemaBody<T> : never;
 /**
- * Infer the request body type for a named method on a `Route`.
- *
- * @remarks `GET` and `ALL` infer `never` because they do not accept request
- * bodies.
- */
-export type InferRouteMethodBody<TRoute extends {
-    methods: RouteSchemaMap;
-}, TMethod extends keyof TRoute['methods']> = TMethod extends 'GET' | 'ALL' ? never : TMethod extends keyof TRoute ? InferRouteBody<TRoute[TMethod]> : InferRouteBody<Extract<TRoute['methods'][TMethod], RouteSchema>>;
-/**
- * Callable factory attached to a `Route` for each declared method.
+ * Callable factory attached to an HTTP action.
  *
  * @remarks Calling a factory validates no data by itself; it creates a typed
  * `RouteRequest` descriptor for `createClient` to validate and send.