rouzer 3.2.0 → 5.0.0

package/README.md

@@ -2,6 +2,7 @@
 
 Rouzer lets you declare an HTTP route tree once and share its TypeScript types
 and Zod validation between a Hattip-compatible server and a typed fetch client.
+The client is always created from that route tree.
 
 ## What it does
 
@@ -45,7 +46,7 @@ Consider something else if:
 - Zod v4 or newer
 - a Hattip adapter when using `createRouter(...)`
 - a Fetch API implementation when using `createClient(...)`
-- an absolute `baseURL` for generated client URLs
+- an absolute `baseURL` and shared `routes` tree for generated client URLs
 
 ## Installation
 
@@ -96,14 +97,14 @@ const client = createClient({
 })
 
 const { message } = await client.hello({
-  path: { name: 'world' },
-  query: { excited: true },
+  name: 'world',
+  excited: true,
 })
 ```
 
-`handler` can be mounted with any Hattip adapter. Client action calls validate
-route arguments before `fetch`; server handlers validate matched path, query,
-headers, and JSON bodies before your handler runs.
+`handler` can be mounted with any Hattip adapter. Generated client action calls
+validate route arguments before `fetch`; server handlers validate matched path,
+query, headers, and JSON bodies before your handler runs.
 
 ### Typed status responses
 
@@ -142,7 +143,7 @@ const client = createClient({
   routes,
 })
 
-const [error, user, status] = await client.getUser({ path: { id: '42' } })
+const [error, user, status] = await client.getUser({ id: '42' })
 ```
 
 Success entries resolve as `[null, value, status]`; declared error entries

package/dist/client/index.d.ts

@@ -1,8 +1,7 @@
 import { Promisable } from '../common.js';
-import type { HttpAction, HttpResource, HttpRouteTree } from '../http.js';
+import { type HttpAction, type HttpResource, type HttpRouteTree } from '../http.js';
 import { type ClientResponsePlugin } from '../response.js';
-import type { RouteArgs } from '../types/args.js';
-import type { RouteRequest } from '../types/request.js';
+import type { RouteInput, RouteOptions } from '../types/args.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`. */
@@ -10,9 +9,8 @@ export type RouzerClient<TRoutes extends HttpRouteTree = Record<string, never>>
 /**
  * Create a typed fetch client for an HTTP route tree.
  *
- * @remarks The returned client always includes `request(...)` for raw responses
- * and `json(...)` for parsed JSON. Passing `routes` also mirrors the resource
- * tree and attaches direct action functions such as `client.users.list(...)`.
+ * @remarks The returned client mirrors the resource tree and attaches direct
+ * action functions such as `client.users.list(...)`.
  */
 export declare function createClient<TRoutes extends HttpRouteTree = Record<string, never>>(config: {
     /**
@@ -38,22 +36,22 @@ export declare function createClient<TRoutes extends HttpRouteTree = Record<stri
      * await client.users.list({ query: { page: 1 } })
      * ```
      */
-    routes?: TRoutes;
+    routes: TRoutes;
     /** Response codec plugins used by generated action functions. */
     plugins?: readonly ClientResponsePlugin[];
     /**
-     * Custom handler for non-2xx responses from `.json()` and generated response
-     * helpers.
+     * Custom handler for non-2xx responses from generated client action
+     * functions.
      *
-     * @remarks When provided, the return value is returned from the response
-     * helper as-is; Rouzer does not automatically parse a `Response` returned by
-     * this hook.
+     * @remarks When provided, the return value is returned from the client action
+     * as-is; Rouzer does not automatically parse a `Response` returned by this
+     * hook.
      */
     onJsonError?: (response: Response) => Promisable<unknown>;
     /** Custom `fetch` implementation to use for requests. */
     fetch?: typeof globalThis.fetch;
 }): ClientTree<TRoutes, ""> & {
-    config: {
+    clientConfig: {
         /**
          * Absolute base URL used for generated request URLs.
          *
@@ -77,25 +75,21 @@ export declare function createClient<TRoutes extends HttpRouteTree = Record<stri
          * await client.users.list({ query: { page: 1 } })
          * ```
          */
-        routes?: TRoutes;
+        routes: TRoutes;
         /** Response codec plugins used by generated action functions. */
         plugins?: readonly ClientResponsePlugin[];
         /**
-         * Custom handler for non-2xx responses from `.json()` and generated response
-         * helpers.
+         * Custom handler for non-2xx responses from generated client action
+         * functions.
          *
-         * @remarks When provided, the return value is returned from the response
-         * helper as-is; Rouzer does not automatically parse a `Response` returned by
-         * this hook.
+         * @remarks When provided, the return value is returned from the client action
+         * as-is; Rouzer does not automatically parse a `Response` returned by this
+         * hook.
          */
         onJsonError?: (response: Response) => Promisable<unknown>;
         /** Custom `fetch` implementation to use for requests. */
         fetch?: typeof globalThis.fetch;
     };
-    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']>;
 };
 type Join<A extends string, B extends string> = A extends '' ? B : B extends '' ? A : `${A}/${B}`;
 /** Client object shape produced from an HTTP route tree. */
@@ -112,7 +106,7 @@ export type ClientTree<T extends HttpRouteTree, TPrefix extends string = ''> = {
  * plugin's client result type. Actions without a response marker return the raw
  * `Response`.
  */
-export type RouteFunction<T extends RouteSchema, P extends string> = (...p: RouteArgs<T, P> extends infer TArgs ? {} extends TArgs ? [args?: TArgs] : [args: TArgs] : never) => Promise<T extends {
+export type RouteFunction<T extends RouteSchema, P extends string> = (...p: RouteInput<T, P> extends infer TInput ? {} extends TInput ? [input?: TInput, options?: RouteOptions<T>] : [input: TInput, options?: RouteOptions<T>] : never) => Promise<T extends {
     response: any;
 } ? InferRouteResponse<T> : Response>;
 export {};

package/dist/client/index.js

@@ -1,30 +1,27 @@
 import { RoutePattern } from '@remix-run/route-pattern';
 import { createHref } from '@remix-run/route-pattern/href';
 import { shake } from '../common.js';
-import { createResponsePluginMap, getResponsePluginMarkerId, } from '../response.js';
+import { isRawBodySchema, } from '../http.js';
 import { getResponseMapPluginIds, isErrorMarker, isResponseMap, } from '../response-map.js';
+import { createResponsePluginMap, getResponsePluginMarkerId, } from '../response.js';
 /**
  * Create a typed fetch client for an HTTP route tree.
  *
- * @remarks The returned client always includes `request(...)` for raw responses
- * and `json(...)` for parsed JSON. Passing `routes` also mirrors the resource
- * tree and attaches direct action functions such as `client.users.list(...)`.
+ * @remarks The returned client mirrors the resource tree and attaches direct
+ * action functions such as `client.users.list(...)`.
  */
 export function createClient(config) {
     const baseURL = config.baseURL.replace(/\/?$/, '/');
     const defaultHeaders = config.headers && shake(config.headers);
     const fetch = config.fetch ?? globalThis.fetch;
     const responsePlugins = createResponsePluginMap(config.plugins, 'client response');
-    if (config.routes) {
-        validateClientResponsePlugins(config.routes, responsePlugins);
-    }
-    async function request({ path: pathBuilder, method, args, schema, }) {
-        let { path, query, body, headers, ...init } = args;
-        if (schema.path) {
-            path = schema.path.parse(path);
-        }
+    validateClientResponsePlugins(config.routes, responsePlugins);
+    async function plainRequest({ path: pathPattern, method, input = {}, options: { body: rawBody, headers, ...init } = {}, schema, }) {
+        const path = schema.path
+            ? schema.path.parse(pickObjectSchemaFields(schema.path, input))
+            : input;
         let url;
-        const href = createHref(pathBuilder, path);
+        const href = createHref(pathPattern, path);
         if (href[0] === '/') {
             url = new URL(baseURL);
             url.pathname += href.slice(1);
@@ -33,17 +30,14 @@ export function createClient(config) {
             url = new URL(href, baseURL);
         }
         if (schema.query) {
-            query = schema.query.parse(query ?? {});
+            const query = schema.query.parse(pickObjectSchemaFields(schema.query, input));
             url.search = new URLSearchParams(shake(query)).toString();
         }
-        else if (query) {
-            throw new Error('Unexpected query parameters');
-        }
+        let body;
         if (schema.body) {
-            body = schema.body.parse(body !== undefined ? body : {});
-        }
-        else if (body !== undefined) {
-            throw new Error('Unexpected body');
+            body = isRawBodySchema(schema.body)
+                ? rawBody
+                : schema.body.parse(pickObjectSchemaFields(schema.body, input));
         }
         if (headers) {
             headers = shake(headers);
@@ -57,27 +51,24 @@ export function createClient(config) {
         return fetch(url, {
             ...init,
             method,
-            body: body !== undefined ? JSON.stringify(body) : undefined,
+            body: isRawBodySchema(schema.body)
+                ? body
+                : body !== undefined
+                    ? JSON.stringify(body)
+                    : undefined,
             headers: (headers ?? defaultHeaders),
         });
     }
-    async function json(props) {
-        const response = await request(props);
-        if (!response.ok) {
-            return handleResponseError(response, props);
-        }
-        return response.json();
-    }
-    async function response(props) {
-        const httpResponse = await request(props);
+    async function parsedRequest(props) {
+        const response = await plainRequest(props);
         const responseSchema = props.schema.response;
         // Handle status-keyed response maps
         if (isResponseMap(responseSchema)) {
-            const status = httpResponse.status;
+            const status = response.status;
             if (status in responseSchema) {
                 const marker = responseSchema[status];
                 if (isErrorMarker(marker)) {
-                    return [await httpResponse.json(), null, status];
+                    return [await response.json(), null, status];
                 }
                 const pluginId = getResponsePluginMarkerId(marker);
                 if (pluginId) {
@@ -87,20 +78,20 @@ export function createClient(config) {
                     }
                     return [
                         null,
-                        await plugin.decode(httpResponse, {
+                        await plugin.decode(response, {
                             marker: marker,
                             request: props,
                         }),
                         status,
                     ];
                 }
-                return [null, await httpResponse.json(), status];
+                return [null, await response.json(), status];
             }
             // Undeclared status — reject
-            return handleResponseError(httpResponse, props);
+            return handleResponseError(response, props);
         }
-        if (!httpResponse.ok) {
-            return handleResponseError(httpResponse, props);
+        if (!response.ok) {
+            return handleResponseError(response, props);
         }
         const pluginId = getResponsePluginMarkerId(responseSchema);
         if (pluginId) {
@@ -108,18 +99,18 @@ export function createClient(config) {
             if (!plugin) {
                 throw missingClientResponsePlugin(pluginId);
             }
-            return plugin.decode(httpResponse, {
+            return plugin.decode(response, {
                 marker: responseSchema,
                 request: props,
             });
         }
-        return httpResponse.json();
+        return response.json();
     }
     async function handleResponseError(response, props) {
         if (config.onJsonError) {
             return config.onJsonError(response);
         }
-        const error = new Error(`Request to ${props.method} ${createHref(props.path, props.args.path)} failed with status ${response.status}`);
+        const error = new Error(`Request to ${props.method} ${createHref(props.path, props.input)} failed with status ${response.status}`);
         const contentType = response.headers.get('content-type');
         if (contentType?.includes('application/json')) {
             Object.assign(error, await response.json());
@@ -127,31 +118,28 @@ export function createClient(config) {
         throw error;
     }
     return {
-        ...(config.routes
-            ? connectTree(config.routes, '', request, response)
-            : null),
-        config,
-        request,
-        json,
+        ...connectTree(config.routes, '', plainRequest, parsedRequest),
+        clientConfig: config,
     };
 }
-function connectTree(tree, prefix, request, response) {
+function connectTree(tree, prefix, plainRequest, parsedRequest) {
     return Object.fromEntries(Object.entries(tree).map(([key, node]) => {
         if (node.kind === 'resource') {
             return [
                 key,
-                connectTree(node.children, joinPaths(prefix, node.path.source), request, response),
+                connectTree(node.children, joinPaths(prefix, node.path.source), plainRequest, parsedRequest),
             ];
         }
         const path = RoutePattern.parse(joinPaths(prefix, node.path?.source ?? ''));
-        const fetch = node.schema.response ? response : request;
+        const fetch = node.schema.response ? parsedRequest : plainRequest;
         return [
             key,
-            (args = {}) => fetch({
+            (input, options) => fetch({
                 schema: node.schema,
                 path,
                 method: node.method,
-                args,
+                input,
+                options,
                 $result: undefined,
             }),
         ];
@@ -177,6 +165,14 @@ function validateClientResponsePlugins(tree, plugins) {
 function missingClientResponsePlugin(pluginId) {
     return new Error(`Missing client response plugin for ${pluginId}`);
 }
+function pickObjectSchemaFields(schema, input) {
+    if (typeof input !== 'object' || input === null) {
+        return input;
+    }
+    return Object.fromEntries(Object.keys(schema.shape)
+        .filter(key => key in input)
+        .map(key => [key, input[key]]));
+}
 function joinPaths(left, right) {
     return [left, right].filter(Boolean).join('/').replace(/\/+/g, '/');
 }

package/dist/http.d.ts

@@ -1,6 +1,5 @@
 import { RoutePattern } from '@remix-run/route-pattern';
-import type { RouteRequestFactory } from './types/request.js';
-import type { RouteSchema } from './types/schema.js';
+import type { RawBodySchema, RouteSchema } from './types/schema.js';
 /** HTTP methods supported by Rouzer action declarations. */
 export type HttpMethod = 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE';
 /**
@@ -18,8 +17,6 @@ export type HttpAction<P extends string = string, T extends RouteSchema = RouteS
     method: M;
     /** Request validation and optional response type schema. */
     schema: T;
-    /** Low-level request descriptor factory for this action. */
-    request: RouteRequestFactory<T, P>;
 };
 /**
  * Path-scoped namespace in an HTTP route tree.
@@ -65,3 +62,6 @@ export declare function patch<const T extends RouteSchema>(schema: T): HttpActio
 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 };
+/** Declare a request body that is passed through to `fetch` without JSON encoding. */
+export declare function rawBody(): RawBodySchema;
+export declare function isRawBodySchema(schema: unknown): schema is RawBodySchema;

package/dist/http.js

@@ -29,17 +29,17 @@ function deleteAction(pathOrSchema, schema) {
     return action('DELETE', pathOrSchema, schema);
 }
 export { deleteAction as delete };
+/** Declare a request body that is passed through to `fetch` without JSON encoding. */
+export function rawBody() {
+    return { __rawBody__: Symbol('rouzer.rawBody') };
+}
+export function isRawBodySchema(schema) {
+    return Boolean(schema && typeof schema === 'object' && '__rawBody__' in schema);
+}
 function action(method, pathOrSchema, schema) {
     const path = typeof pathOrSchema === 'string'
         ? RoutePattern.parse(pathOrSchema)
         : undefined;
     schema ??= typeof pathOrSchema === 'string' ? {} : pathOrSchema;
-    const request = ((args = {}) => ({
-        schema,
-        path: path ?? RoutePattern.parse(''),
-        method,
-        args,
-        $result: undefined,
-    }));
-    return { kind: 'action', path, method, schema, request };
+    return { kind: 'action', path, method, schema };
 }

package/dist/response.d.ts

@@ -1,5 +1,7 @@
 import type { Promisable } from './common.js';
-import type { RouteRequest } from './types/request.js';
+import type { RoutePattern } from '@remix-run/route-pattern';
+import type { RouteOptions } from './types/args.js';
+import type { RouteSchema } from './types/schema.js';
 /** Runtime key carried by response plugin markers. */
 export declare const responsePluginMarker: unique symbol;
 /**
@@ -24,9 +26,17 @@ export type ClientResponsePlugin = {
     /** Decode a successful `Response` into the client action result. */
     decode(response: Response, context: {
         marker: ResponsePluginMarker<any, any>;
-        request: RouteRequest;
+        request: ClientResponsePluginRequest;
     }): Promisable<unknown>;
 };
+/** Request metadata passed to client response plugins. */
+export type ClientResponsePluginRequest = {
+    schema: RouteSchema;
+    path: RoutePattern;
+    method: string;
+    input?: unknown;
+    options?: RouteOptions;
+};
 /** Router-side response plugin used by `createRouter({ plugins })`. */
 export type RouterResponsePlugin = {
     /** Stable response codec id matched against route response markers. */

package/dist/server/router.d.ts

@@ -1,6 +1,6 @@
 import type { HattipHandler } from '@hattip/core';
 import { ApplyMiddleware, chain, ExtractMiddleware, MiddlewareChain, MiddlewareTypes } from 'alien-middleware';
-import type { HttpRouteTree } from '../http.js';
+import { type HttpRouteTree } from '../http.js';
 import { type RouterResponsePlugin } from '../response.js';
 import type { RouteRequestHandlerMap } from '../types/server.js';
 export { chain };

package/dist/server/router.js

@@ -3,6 +3,7 @@ import { createMatcher } from '@remix-run/route-pattern/match';
 import { chain, MiddlewareChain, } from 'alien-middleware';
 import * as z from 'zod';
 import { mapValues } from '../common.js';
+import { isRawBodySchema } from '../http.js';
 import { createResponsePluginMap, getResponsePluginMarkerId, } from '../response.js';
 import { getDefaultSuccessStatus, getResponseMapPluginIds, isErrorMarker, isResponseMap, } from '../response-map.js';
 export { chain };
@@ -103,7 +104,7 @@ class RouterObject extends MiddlewareChain {
                         return httpClientError(error, 'Invalid query string', config);
                     }
                 }
-                if (schema.body) {
+                if (schema.body && !isRawBodySchema(schema.body)) {
                     const error = await parseRequestBody(context, schema.body);
                     if (error) {
                         addDebugHeaders?.(context, route);

package/dist/types/args.d.ts

@@ -1,51 +1,42 @@
 import type { MatchParams } from '@remix-run/route-pattern/match';
 import type * as z from 'zod';
-import type { MutationRouteSchema, QueryRouteSchema, RouteSchema } from './schema.js';
+import type { MutationRouteSchema, QueryRouteSchema, RawBodySchema, RouteSchema } from './schema.js';
 declare class Any {
     private isAny;
 }
-type PathArgs<T, P extends string> = T extends {
+type PathInput<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 & {
+} ? z.infer<TPath> : MatchParams<P>;
+type QueryInput<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 {
+} ? z.infer<TQuery> : unknown;
+type BodyInput<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;
+} ? TBody extends RawBodySchema ? unknown : z.infer<TBody> : unknown : unknown;
+type HeaderInput<T> = T extends {
+    headers: infer THeaders;
+} ? Partial<z.infer<THeaders>> : Record<string, string | undefined>;
 /**
- * Arguments accepted by a client action function or low-level request factory.
+ * Semantic input accepted by a generated client action function.
  *
- * @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.
+ * @remarks Path params, query params, and JSON body fields are flattened into a
+ * single object. Avoid declaring duplicate keys across path/query/body schemas,
+ * since a flat input cannot distinguish their source.
  */
-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'> & {
+export type RouteInput<T extends RouteSchema = any, P extends string = string> = [T] extends [Any] ? any : PathInput<T, P> & QueryInput<T> & BodyInput<T>;
+/**
+ * Fetch options accepted as the second argument to a generated client action.
+ *
+ * @remarks `headers` remains optional because required route headers may be
+ * supplied by `createClient({ headers })` defaults.
+ */
+type RouteBodyOption<T> = T extends {
+    body: RawBodySchema;
+} ? {
+    body: BodyInit | null;
+} : {};
+export type RouteOptions<T extends RouteSchema = any> = Omit<RequestInit, 'method' | 'body' | 'headers'> & RouteBodyOption<T> & {
     /** Headers for this request. Undefined values are removed before `fetch`. */
-    headers?: Record<string, string | undefined>;
+    headers?: HeaderInput<T>;
 };
 export {};

package/dist/types/handler.d.ts

@@ -4,7 +4,10 @@ import type * as z from 'zod';
 import { Promisable } from '../common.js';
 import type { HttpAction } from '../http.js';
 import type { InferRouteHandlerResult, InferResponseMapErrors, InferResponseMapSuccesses } from './response.js';
-import type { RouteResponseMap, RouteSchema } from './schema.js';
+import type { RawBodySchema, RouteResponseMap, RouteSchema } from './schema.js';
+type InferHandlerBody<T> = T extends {
+    body: infer TBody;
+} ? TBody extends RawBodySchema ? undefined : z.infer<TBody> : undefined;
 type RequestContext<TMiddleware extends AnyMiddlewareChain> = MiddlewareContext<TMiddleware>;
 /**
  * Error response returned by `ctx.error(status, body)` in route handlers.
@@ -51,9 +54,7 @@ export type InferActionHandler<TMiddleware extends AnyMiddlewareChain, TAction e
     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;
+    body: InferHandlerBody<TAction['schema']>;
     headers: TAction['schema'] extends {
         headers: any;
     } ? z.infer<TAction['schema']['headers']> : undefined;
@@ -71,9 +72,7 @@ export type InferActionHandler<TMiddleware extends AnyMiddlewareChain, TAction e
     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;
+    body: InferHandlerBody<TAction['schema']>;
     headers: TAction['schema'] extends {
         headers: any;
     } ? z.infer<TAction['schema']['headers']> : undefined;

package/dist/types/index.d.ts

@@ -1,7 +1,6 @@
 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/infer.d.ts

@@ -1,19 +1,14 @@
 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.
+ * Infer the request body type from an action schema.
  *
  * @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
+ * `InferRouteBody<typeof action.schema>`. 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 type InferRouteBody<T> = T extends RouteSchema ? InferRouteSchemaBody<T> : never;
 export {};

package/dist/types/schema.d.ts

@@ -36,14 +36,18 @@ export type QueryRouteSchema = {
     /** Optional compile-time-only JSON or plugin response type marker. */
     response?: RouteResponseSchema;
 };
+/** Marker for request bodies passed through to `fetch` without JSON encoding. */
+export type RawBodySchema = {
+    readonly __rawBody__: unique symbol;
+};
 /** 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 schema used to validate the JSON request body, or raw body marker. */
+    body?: z.ZodObject<any> | RawBodySchema;
     /** Optional Zod object used to validate request headers. */
     headers?: z.ZodObject<any>;
     /** Optional compile-time-only JSON or plugin response type marker. */

package/dist/types/server.d.ts

@@ -1,4 +1,4 @@
-import type { AnyMiddlewareChain, MiddlewareChain } from 'alien-middleware';
+import type { AnyMiddlewareChain } from 'alien-middleware';
 import type { HttpAction, HttpResource, HttpRouteTree } from '../http.js';
 import type { InferActionHandler } from './handler.js';
 import type { Join } from './path.js';
@@ -10,6 +10,6 @@ import type { Join } from './path.js';
  * 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 = ''> = {
+export type RouteRequestHandlerMap<TRoutes extends HttpRouteTree = HttpRouteTree, TMiddleware extends AnyMiddlewareChain = never, 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/docs/context.md

@@ -211,18 +211,16 @@ requests with an `Origin` header.
 
 ### Client
 
-`createClient({ baseURL, routes })` creates:
-
-- `client.request(action.request(args))` for a raw `Response` when the action
-  request factory contains the full path you want to call
-- `client.json(action.request(args))` for parsed JSON and default non-2xx
-  throwing
-- response-map support for generated client action functions, returning
-  `[error, value, status]` tuples for declared statuses
-- response plugin support for generated client action functions, such as
-  `ndjson.clientPlugin` for NDJSON response streams
-- a client tree that mirrors `routes`, with action functions such as
-  `client.profiles.get(args)` when `routes` is supplied
+`createClient({ baseURL, routes })` creates a client tree that mirrors
+`routes`, with action functions such as `client.profiles.get(args)`.
+Generated action functions include:
+
+- raw `Response` results for actions without a response schema
+- parsed JSON and default non-2xx throwing for `$type<T>()` responses
+- response-map support, returning `[error, value, status]` tuples for declared
+  statuses
+- response plugin support, such as `ndjson.clientPlugin` for NDJSON response
+  streams
 
 Prefer an absolute `baseURL` for generated client URLs:
 
@@ -235,7 +233,8 @@ const client = createClient({
 
 Default headers can be supplied with `headers`, per-request headers are merged on
 top, and a custom `fetch` implementation can be supplied for tests or non-browser
-runtimes.
+runtimes. The returned client exposes the original options as `clientConfig`, so
+route actions named `config` remain available as `client.config(...)`.
 
 ## Lifecycle
 
@@ -260,9 +259,9 @@ string-coercion step.
 
 ## Common tasks
 
-### Choose a client call style
+### Call client actions
 
-Use client action functions for normal application calls:
+Use generated client action functions for application calls:
 
 ```ts
 await client.profiles.get({ path: { id: '42' } })
@@ -272,29 +271,6 @@ await client.profiles.update({
 })
 ```
 
-Use longhand calls when you need to choose response handling explicitly. The
-action request factory must include the full path you want to call, so this style
-is most convenient for top-level actions:
-
-```ts
-export const getProfile = http.get('profiles/:id', {
-  response: $type<Profile>(),
-})
-export const routes = { getProfile }
-
-const response = await client.request(
-  routes.getProfile.request({ path: { id: '42' } })
-)
-
-const json = await client.json(
-  routes.getProfile.request({ path: { id: '42' } })
-)
-```
-
-Response maps and response plugins are applied by generated client action
-functions. For longhand calls to mapped or plugin-backed routes, use
-`client.request(...)` for the raw `Response` and decode the response yourself.
-
 ### Handle declared error responses
 
 Use `$error<T>()` inside a response map when an error status is part of the route
@@ -420,7 +396,7 @@ custom headers. Return a plain value for the default `Response.json(value)` path
 
 ### Customize JSON errors
 
-By default, `client.json(...)` and generated client action functions throw for
+By default, generated client action functions throw for
 non-2xx responses that are not declared in a response map. If the response body
 is JSON, its properties are copied onto the thrown `Error`.
 
@@ -484,7 +460,7 @@ await client.profiles.update({
 - Export route trees from a small shared module and import that module on both
   server and client.
 - Use `rouzer/http` actions for routes that are registered with
-  `createRouter().use(...)` or `createClient({ routes })`.
+  `createRouter().use(...)` or the required `createClient({ routes })` option.
 - Add Zod schemas when you need runtime guarantees; rely on inferred path params
   only when string params are sufficient.
 - Use `response: $type<T>()` for JSON endpoints that should have typed client
@@ -513,11 +489,10 @@ await client.profiles.update({
 - Pathname route patterns expect an absolute client `baseURL`.
 - Resource and action keys are API names only; paths come from the pattern
   strings passed to `http.resource(...)` and action helpers.
-- 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 forwarded by `createClient`; `method`, `body`, and `headers` are reserved
-  for Rouzer's action metadata and validated call arguments.
+  are forwarded by `createClient`; `method` and `body` are reserved for Rouzer's
+  action metadata and validated call arguments. Use route args or client defaults
+  for request headers.
 - 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/examples/basic-usage.ts

@@ -101,16 +101,9 @@ export async function runBasicUsageExample() {
     fetch: createLocalFetch(handler),
   })
 
-  const fetched = await client.profiles.get({
-    path: { id: '42' },
-    query: { includePosts: false },
-    headers: { 'x-request-id': 'docs' },
-  })
+  const fetched = await client.profiles.get({ id: '42', includePosts: false }, { headers: { 'x-request-id': 'docs' } })
 
-  const updated = await client.profiles.update({
-    path: { id: '42' },
-    body: { name: 'Grace' },
-  })
+  const updated = await client.profiles.update({ id: '42', name: 'Grace' })
 
   return { fetched, updated }
 }

package/examples/error-responses.ts

@@ -89,10 +89,10 @@ export async function runErrorResponsesExample() {
     fetch: createLocalFetch(handler),
   })
 
-  const found = await client.getUser({ path: { id: '42' } })
-  const created = await client.getUser({ path: { id: 'created' } })
-  const missing = await client.getUser({ path: { id: 'missing' } })
-  const unauthorized = await client.getUser({ path: { id: 'unauthorized' } })
+  const found = await client.getUser({ id: '42' })
+  const created = await client.getUser({ id: 'created' })
+  const missing = await client.getUser({ id: 'missing' })
+  const unauthorized = await client.getUser({ id: 'unauthorized' })
 
   return { found, created, missing, unauthorized }
 }

package/package.json

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

package/dist/types/request.d.ts

@@ -1,35 +0,0 @@
-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 response type for this request factory. */
-    $response: InferRouteResponse<T>;
-};

package/dist/types/request.js

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