rouzer 3.0.0 → 3.0.1

package/dist/client/index.d.ts

@@ -1,6 +1,9 @@
 import { Promisable } from '../common.js';
 import type { HttpAction, HttpResource, HttpRouteTree } from '../http.js';
-import type { InferRouteResponse, RouteArgs, RouteRequest, RouteSchema } from '../types.js';
+import type { RouteArgs } from '../types/args.js';
+import type { RouteRequest } from '../types/request.js';
+import type { InferRouteResponse } from '../types/response.js';
+import type { RouteSchema } from '../types/schema.js';
 /** Client type inferred from an HTTP route tree passed to `createClient`. */
 export type RouzerClient<TRoutes extends HttpRouteTree = Record<string, never>> = ReturnType<typeof createClient<TRoutes>>;
 /**
@@ -80,7 +83,7 @@ export declare function createClient<TRoutes extends HttpRouteTree = Record<stri
         /** Custom `fetch` implementation to use for requests. */
         fetch?: typeof globalThis.fetch;
     };
-    request: <T extends RouteRequest>({ path: pathBuilder, method, args: { path, query, body, headers }, schema, }: T) => Promise<Response & {
+    request: <T extends RouteRequest>({ path: pathBuilder, method, args, schema, }: T) => Promise<Response & {
         json(): Promise<T['$result']>;
     }>;
     json: <T extends RouteRequest>(props: T) => Promise<T['$result']>;

package/dist/client/index.js

@@ -12,7 +12,8 @@ export function createClient(config) {
     const baseURL = config.baseURL.replace(/\/?$/, '/');
     const defaultHeaders = config.headers && shake(config.headers);
     const fetch = config.fetch ?? globalThis.fetch;
-    async function request({ path: pathBuilder, method, args: { path, query, body, headers }, schema, }) {
+    async function request({ path: pathBuilder, method, args, schema, }) {
+        let { path, query, body, headers, ...init } = args;
         if (schema.path) {
             path = schema.path.parse(path);
         }
@@ -48,6 +49,7 @@ export function createClient(config) {
             headers = schema.headers.parse(headers);
         }
         return fetch(url, {
+            ...init,
             method,
             body: body !== undefined ? JSON.stringify(body) : undefined,
             headers: (headers ?? defaultHeaders),

package/dist/http.d.ts

@@ -1,5 +1,6 @@
 import { RoutePattern } from '@remix-run/route-pattern';
-import type { RouteRequestFactory, RouteSchema } from './types.js';
+import type { RouteRequestFactory } from './types/request.js';
+import type { RouteSchema } from './types/schema.js';
 /** HTTP methods supported by Rouzer action declarations. */
 export type HttpMethod = 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE';
 /**
@@ -61,7 +62,6 @@ export declare function put<const T extends RouteSchema>(schema: T): HttpAction<
 export declare function patch<const P extends string, const T extends RouteSchema>(path: P, schema: T): HttpAction<P, T, 'PATCH'>;
 export declare function patch<const T extends RouteSchema>(schema: T): HttpAction<'', T, 'PATCH'>;
 /** Declare a DELETE action, optionally with an action-local path segment. */
-export declare function del<const P extends string, const T extends RouteSchema>(path: P, schema: T): HttpAction<P, T, 'DELETE'>;
-export declare function del<const T extends RouteSchema>(schema: T): HttpAction<'', T, 'DELETE'>;
-/** Alias for `del(...)`, exported for namespace imports as `http.delete(...)`. */
-export { del as delete };
+declare function deleteAction<const P extends string, const T extends RouteSchema>(path: P, schema: T): HttpAction<P, T, 'DELETE'>;
+declare function deleteAction<const T extends RouteSchema>(schema: T): HttpAction<'', T, 'DELETE'>;
+export { deleteAction as delete };

package/dist/http.js

@@ -25,11 +25,10 @@ export function put(pathOrSchema, schema) {
 export function patch(pathOrSchema, schema) {
     return action('PATCH', pathOrSchema, schema);
 }
-export function del(pathOrSchema, schema) {
+function deleteAction(pathOrSchema, schema) {
     return action('DELETE', pathOrSchema, schema);
 }
-/** Alias for `del(...)`, exported for namespace imports as `http.delete(...)`. */
-export { del as delete };
+export { deleteAction as delete };
 function action(method, pathOrSchema, schema) {
     const path = typeof pathOrSchema === 'string' ? RoutePattern.parse(pathOrSchema) : undefined;
     schema ??= typeof pathOrSchema === 'string' ? {} : pathOrSchema;

package/dist/index.d.ts

@@ -1,5 +1,5 @@
 export * from './client/index.js';
-export * from './route.js';
+export * from './type.js';
 export * from './server/router.js';
-export type * from './types.js';
+export type * from './types/index.js';
 export * from 'alien-middleware';

package/dist/index.js

@@ -1,4 +1,4 @@
 export * from './client/index.js';
-export * from './route.js';
+export * from './type.js';
 export * from './server/router.js';
 export * from 'alien-middleware';

package/dist/internal.d.ts

@@ -0,0 +1,17 @@
+import type { RoutePattern } from '@remix-run/route-pattern';
+import type { RouteRequestFactory, RouteSchema } from './types.js';
+/** @internal */
+export type RouteSchemaMap = {
+    GET?: RouteSchema;
+    POST?: RouteSchema;
+    PUT?: RouteSchema;
+    PATCH?: RouteSchema;
+    DELETE?: RouteSchema;
+};
+/** @internal */
+export type Route<P extends string = string, T extends RouteSchemaMap = RouteSchemaMap> = {
+    path: RoutePattern<P>;
+    methods: T;
+} & {
+    [K in keyof T]: RouteRequestFactory<Extract<T[K], RouteSchema>, P>;
+};

package/dist/internal.js

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

package/dist/server/router.d.ts

@@ -1,7 +1,7 @@
 import type { HattipHandler } from '@hattip/core';
 import { ApplyMiddleware, chain, ExtractMiddleware, MiddlewareChain, MiddlewareTypes } from 'alien-middleware';
 import type { HttpRouteTree } from '../http.js';
-import type { RouteRequestHandlerMap } from './types.js';
+import type { RouteRequestHandlerMap } from '../types/server.js';
 export { chain };
 /** Configuration for `createRouter`. */
 export type RouterConfig = {

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,5 +1,5 @@
-import { 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';
 /**
@@ -35,47 +35,8 @@ export type MutationRouteSchema = {
     /** Optional compile-time-only JSON response type marker. */
     response?: Unchecked<any>;
 };
-/**
- * Method schema map accepted by the low-level `route(...)` helper.
- *
- * @remarks `GET` validates query input and mutation methods validate JSON body
- * input. Prefer `rouzer/http` actions for route trees registered with
- * `createRouter().use(...)` or `createClient({ routes })`.
- */
-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;
-/**
- * Low-level route map shape produced from `route(...)` declarations.
- *
- * @remarks The router and client shorthand registration APIs now expect
- * `HttpRouteTree` values from the `rouzer/http` subpath. Use this type only for
- * code that still works directly with low-level `route(...)` descriptors.
- */
-export type Routes = {
-    [key: string]: {
-        path: RoutePattern;
-        methods: RouteSchemaMap;
-    };
-};
 declare class Any {
     private isAny;
 }
@@ -107,14 +68,13 @@ type MutationArgs<T> = T extends MutationRouteSchema ? T extends {
     body?: unknown;
 } : unknown;
 /**
- * Arguments accepted by a request factory such as an HTTP action's `.request(...)`
- * or a low-level `route.GET(...)` factory.
+ * 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;
@@ -125,7 +85,7 @@ export type RouteArgs<T extends RouteSchema = any, P extends string = string> =
     headers?: Record<string, string | undefined>;
 };
 /**
- * Request descriptor produced by an HTTP action or 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.
@@ -146,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;
@@ -157,26 +117,16 @@ type InferRouteArgsBody<TArgs> = TArgs extends {
     body?: infer TBody;
 } ? TBody : never;
 /**
- * Infer the request body type from a schema or request factory.
+ * 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 methods
+ * `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 low-level `Route`.
- *
- * @remarks `GET` and `ALL` infer `never` because they do not accept request
- * bodies. For `rouzer/http` actions, prefer
- * `InferRouteBody<typeof action.schema>`.
- */
-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 an HTTP action or low-level `Route` 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.

package/docs/context.md

@@ -39,9 +39,8 @@ export const routes = { getProfile }
 ```
 
 An action is a callable endpoint leaf. Use `http.get`, `http.post`, `http.put`,
-`http.patch`, or `http.del`/`http.delete` to declare one HTTP operation. The key
-you put the action under is the client and handler name; the action path is the
-URL pattern.
+`http.patch`, or `http.delete` to declare one HTTP operation. The key you put the
+action under is the client and handler name; the action path is the URL pattern.
 
 Use `http.resource(path, children)` when several actions share a path prefix or
 when you want nested client/handler namespaces:
@@ -83,7 +82,7 @@ Method schemas describe the request pieces Rouzer should validate:
 | Action helper                         | Request schemas                        | Notes            |
 | ------------------------------------- | -------------------------------------- | ---------------- |
 | `http.get(...)`                       | `path`, `query`, `headers`, `response` | No request body. |
-| `http.post/put/patch/delete/del(...)` | `path`, `body`, `headers`, `response`  | No query schema. |
+| `http.post/put/patch/delete(...)` | `path`, `body`, `headers`, `response`  | No query schema. |
 
 If you omit a `path` schema, TypeScript infers path params from the pattern and
 server handlers receive them as strings. Add a Zod `path` schema when you need
@@ -165,16 +164,6 @@ Default headers can be supplied with `headers`, per-request headers are merged o
 top, and a custom `fetch` implementation can be supplied for tests or non-browser
 runtimes.
 
-### Low-level `route(...)` descriptors
-
-The root package still exports `route(pattern, methods)`. It creates method-keyed
-request descriptor factories such as `legacyRoute.GET(args)` for explicit
-`client.request(...)` or `client.json(...)` calls.
-
-Prefer `rouzer/http` route trees for shared server/client routing. The router and
-client shorthand registration APIs expect `HttpAction`/`HttpResource` trees, not
-the older method-map objects produced by `route(...)`.
-
 ## Lifecycle
 
 1. Define shared HTTP actions/resources with `rouzer/http` and Zod schemas.
@@ -332,7 +321,8 @@ await client.profiles.update({
 - Nested action `.request(...)` factories do not include parent resource paths;
   prefer client action functions for nested resources.
 - Extra `RequestInit` fields in route args, such as `signal` or `credentials`,
-  are accepted by the type surface but are not forwarded by `createClient`.
+  are forwarded by `createClient`; `method`, `body`, and `headers` are reserved
+  for Rouzer's action metadata and validated call arguments.
 - The HTTP action API has no `ALL` fallback route. Declare explicit actions for
   supported methods.
 - Rouzer does not automatically set `Access-Control-Allow-Credentials`; set it in

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rouzer",
-  "version": "3.0.0",
+  "version": "3.0.1",
   "type": "module",
   "exports": {
     ".": {

package/dist/route.d.ts

@@ -1,56 +0,0 @@
-import { RoutePattern } from '@remix-run/route-pattern';
-import { Unchecked } from './common.js';
-import type { RouteRequestFactory, RouteSchema, RouteSchemaMap } from './types.js';
-/**
- * Create a compile-time-only marker for a route'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 routes 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;
-}
-/**
- * Low-level route declaration produced by `route(...)`.
- *
- * @remarks A `Route` stores the parsed URL pattern, the method schema map, and a
- * request factory for each declared method. Use those factories with
- * `client.request(...)` or `client.json(...)` when you need explicit response
- * handling. For shared server/client route trees, prefer `rouzer/http` actions
- * and resources; `createRouter().use(...)` and `createClient({ routes })` expect
- * that HTTP route tree shape.
- */
-export type Route<P extends string = string, T extends RouteSchemaMap = RouteSchemaMap> = {
-    /** Parsed route pattern used for request URL generation. */
-    path: RoutePattern<P>;
-    /** Method schemas declared for this route. */
-    methods: T;
-} & {
-    [K in keyof T]: RouteRequestFactory<Extract<T[K], RouteSchema>, P>;
-};
-/**
- * Declare one URL pattern and its supported HTTP method schemas.
- *
- * @remarks This helper creates low-level request descriptor factories. Prefer
- * `rouzer/http` action helpers for routes that will be registered with
- * `createRouter().use(...)` or mirrored by `createClient({ routes })`.
- *
- * @param pattern Route pattern parsed by `@remix-run/route-pattern`.
- * @param methods Method schemas that describe request validation and optional
- * response typing.
- * @returns A route declaration with request factories such as `.GET(...)` and
- * `.POST(...)` for the declared methods.
- */
-export declare function route<P extends string, T extends RouteSchemaMap>(pattern: P, methods: T): Route<P, T>;

package/dist/route.js

@@ -1,52 +0,0 @@
-import { RoutePattern } from '@remix-run/route-pattern';
-import { mapEntries } from './common.js';
-/**
- * Create a compile-time-only marker for a route'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 routes 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();
-/**
- * Declare one URL pattern and its supported HTTP method schemas.
- *
- * @remarks This helper creates low-level request descriptor factories. Prefer
- * `rouzer/http` action helpers for routes that will be registered with
- * `createRouter().use(...)` or mirrored by `createClient({ routes })`.
- *
- * @param pattern Route pattern parsed by `@remix-run/route-pattern`.
- * @param methods Method schemas that describe request validation and optional
- * response typing.
- * @returns A route declaration with request factories such as `.GET(...)` and
- * `.POST(...)` for the declared methods.
- */
-export function route(pattern, methods) {
-    const path = RoutePattern.parse(pattern);
-    const createFetch = (method, schema) => (args = {}) => {
-        return {
-            schema,
-            path,
-            method,
-            args,
-            $result: undefined,
-        };
-    };
-    return Object.assign({ path, methods }, mapEntries(methods, (method, schema) => [
-        method,
-        createFetch(method, schema),
-    ]));
-}