rouzer 3.0.1 → 3.1.0

package/dist/type.d.ts

@@ -1,4 +1,4 @@
-import { Unchecked } from './common.js';
+import type { Unchecked } from './common.js';
 /**
  * Create a compile-time-only marker for an action's JSON response payload type.
  *

package/dist/types/handler.d.ts

@@ -3,7 +3,7 @@ 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 { InferRouteHandlerResult } 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>;
@@ -17,7 +17,7 @@ export type InferActionHandler<TMiddleware extends AnyMiddlewareChain, TAction e
     headers: TAction['schema'] extends {
         headers: any;
     } ? z.infer<TAction['schema']['headers']> : undefined;
-}, InferRouteResponse<Extract<TAction['schema'], RouteSchema>>> : RouteRequestHandler<TMiddleware, {
+}, InferRouteHandlerResult<Extract<TAction['schema'], RouteSchema>>> : RouteRequestHandler<TMiddleware, {
     path: TAction['schema'] extends {
         path: any;
     } ? z.infer<TAction['schema']['path']> : MatchParams<TPath>;
@@ -27,5 +27,5 @@ export type InferActionHandler<TMiddleware extends AnyMiddlewareChain, TAction e
     headers: TAction['schema'] extends {
         headers: any;
     } ? z.infer<TAction['schema']['headers']> : undefined;
-}, InferRouteResponse<Extract<TAction['schema'], RouteSchema>>>;
+}, InferRouteHandlerResult<Extract<TAction['schema'], RouteSchema>>>;
 export {};

package/dist/types/request.d.ts

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

package/dist/types/response.d.ts

@@ -1,9 +1,17 @@
-import type { Unchecked, RouteSchema } from './schema.js';
+import type { ResponsePluginMarker, RouteSchema, Unchecked } 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. */
+/** Infer the client response type from an action schema. */
 export type InferRouteResponse<T extends RouteSchema> = T extends {
+    response: ResponsePluginMarker<infer TClient, any>;
+} ? TClient : T extends {
+    response: Unchecked<infer TResponse>;
+} ? TResponse : void;
+/** Infer the non-`Response` handler result type from an action schema. */
+export type InferRouteHandlerResult<T extends RouteSchema> = T extends {
+    response: ResponsePluginMarker<any, infer TRouter>;
+} ? TRouter : T extends {
     response: Unchecked<infer TResponse>;
 } ? TResponse : void;

package/dist/types/schema.d.ts

@@ -1,12 +1,17 @@
 import * as z from 'zod';
-import { Unchecked } from '../common.js';
+import type { Unchecked } from '../common.js';
+import type { ResponsePluginMarker } from '../response.js';
 /**
- * Compile-time-only marker used by `$type<T>()` for unchecked response types.
+ * Compile-time-only marker used by `$type<T>()` for unchecked JSON response
+ * types.
  *
  * @remarks Application code should usually call `$type<T>()` instead of naming
  * this marker directly.
  */
 export type { Unchecked };
+export type { ResponsePluginMarker };
+/** Response marker accepted by HTTP action schemas. */
+export type RouteResponseSchema = Unchecked<any> | ResponsePluginMarker<any, any>;
 /** Schema shape for `GET` route methods. */
 export type QueryRouteSchema = {
     /** Optional Zod object used to validate path params. */
@@ -17,8 +22,8 @@ export type QueryRouteSchema = {
     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>;
+    /** Optional compile-time-only JSON or plugin response type marker. */
+    response?: RouteResponseSchema;
 };
 /** Schema shape for mutation route methods. */
 export type MutationRouteSchema = {
@@ -30,8 +35,8 @@ export type MutationRouteSchema = {
     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>;
+    /** Optional compile-time-only JSON or plugin response type marker. */
+    response?: RouteResponseSchema;
 };
 /** Any HTTP action schema Rouzer can execute. */
 export type RouteSchema = QueryRouteSchema | MutationRouteSchema;

package/docs/context.md

@@ -2,8 +2,8 @@
 
 Rouzer is for applications that want one TypeScript HTTP route tree to drive
 both the server and the client that calls it. A route tree combines URL
-patterns, named actions, HTTP method schemas, and optional compile-time response
-types.
+patterns, named actions, HTTP method schemas, and optional compile-time JSON or
+NDJSON response types.
 
 ## When to use Rouzer
 
@@ -18,8 +18,8 @@ Use Rouzer when:
   produced by a separate OpenAPI build step
 
 Rouzer is not a response validation library, an OpenAPI generator, or a complete
-server framework. It focuses on typed route contracts, validation, routing, and a
-small client wrapper.
+server framework. It focuses on typed route contracts, request validation,
+routing, and a small client wrapper.
 
 ## Core abstractions
 
@@ -79,9 +79,9 @@ them out of resource/base-path composition.
 
 Method schemas describe the request pieces Rouzer should validate:
 
-| Action helper                         | Request schemas                        | Notes            |
-| ------------------------------------- | -------------------------------------- | ---------------- |
-| `http.get(...)`                       | `path`, `query`, `headers`, `response` | No request body. |
+| Action helper                     | Request schemas                        | Notes            |
+| --------------------------------- | -------------------------------------- | ---------------- |
+| `http.get(...)`                   | `path`, `query`, `headers`, `response` | No request body. |
 | `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
@@ -92,15 +92,39 @@ The HTTP action API models explicit operations. It does not expose the old
 method-map `ALL` fallback route shape; declare the concrete methods your client
 and server support.
 
-### `$type<T>()`
+### `$type<T>()` and `ndjson.$type<T>()`
 
-`response: $type<T>()` is a TypeScript-only marker. It tells handlers and client
-action functions what response payload type to expect, but Rouzer does not
-validate response bodies at runtime.
+`response: $type<T>()` is a TypeScript-only marker for JSON response payloads.
+It tells handlers and client action functions what response payload type to
+expect, but Rouzer does not validate response bodies at runtime.
+
+`response: ndjson.$type<T>()` is a TypeScript-only marker for newline-delimited
+JSON response streams from the `rouzer/ndjson` subpath. Register
+`ndjson.routerPlugin` with `createRouter(...)` and `ndjson.clientPlugin` with
+`createClient(...)` for routes that use this marker. Handlers return an
+`Iterable<T>` or `AsyncIterable<T>`; Rouzer serializes each item as one JSON line
+and sets the response content type to `application/x-ndjson; charset=utf-8`.
+Client action functions resolve to an `AsyncIterable<T>` parsed from the
+response body. Streamed items are parsed as JSON but are not validated against a
+Zod schema.
 
 Actions without a `response` marker return a raw `Response` from client action
-functions. Actions with a `response` marker use `client.json(...)` under the hood
-and return parsed JSON typed as `T`.
+functions. Actions with `response: $type<T>()` use `client.json(...)` under the
+hood and return parsed JSON typed as `T`.
+
+### Response plugins
+
+Response plugins add non-JSON response codecs without changing route matching or
+request validation. A plugin package provides a compile-time response marker and
+matching runtime plugins. For NDJSON, those are `ndjson.$type<T>()`,
+`ndjson.routerPlugin`, and `ndjson.clientPlugin`.
+
+The router plugin encodes non-`Response` handler results into an HTTP `Response`.
+The client plugin decodes successful HTTP responses for generated client action
+functions. Rouzer validates plugin registration when routes are attached to a
+router or client, so routes that use an unregistered response marker fail fast
+instead of falling back to JSON. Response plugins do not automatically validate
+response payloads unless the plugin itself implements validation.
 
 ### Router
 
@@ -133,7 +157,10 @@ Handlers receive a context typed from middleware plus the action schema:
 - `GET` handlers receive `ctx.path`, `ctx.query`, and `ctx.headers`
 - mutation handlers receive `ctx.path`, `ctx.body`, and `ctx.headers`
 - handlers may return a plain JSON-serializable value or a `Response`
+- `ndjson.$type<T>()` handlers return an `Iterable<T>` or `AsyncIterable<T>`
+  unless they return a custom `Response`
 - plain values are returned with `Response.json(value)`
+- NDJSON iterables are returned as `application/x-ndjson` streams
 - return a `Response` when you need custom status, headers, or body handling
 
 `basePath` is prepended to route tree paths, `debug` adds matched-route debug
@@ -148,6 +175,8 @@ requests with an `Origin` header.
   request factory contains the full path you want to call
 - `client.json(action.request(args))` for parsed JSON and default non-2xx
   throwing
+- 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
 
@@ -167,14 +196,18 @@ runtimes.
 ## Lifecycle
 
 1. Define shared HTTP actions/resources with `rouzer/http` and Zod schemas.
-2. Attach that route tree to a server with `createRouter().use(routes, handlers)`.
-3. Create a client with the same route tree.
+2. Attach that route tree to a server with `createRouter().use(routes, handlers)`
+   or `createRouter({ plugins }).use(routes, handlers)` when response plugins
+   are needed.
+3. Create a client with the same route tree, plus matching client response
+   plugins when needed.
 4. Client action calls validate `path`, `query`, `body`, and `headers` before
    `fetch`.
 5. The router matches the request, validates the matched inputs, and calls the
    handler.
-6. Plain handler results become JSON responses; explicit `Response` objects pass
-   through unchanged.
+6. Plain handler results become JSON responses, plugin handler results become
+   plugin-encoded responses, and explicit `Response` objects pass through
+   unchanged.
 
 On the server, `path`, `query`, and `headers` values originate as strings. Rouzer
 coerces Zod `number` schemas with `Number(value)` and Zod `boolean` schemas from
@@ -214,6 +247,55 @@ const json = await client.json(
 )
 ```
 
+Response plugins are applied by generated client action functions. For longhand
+calls to plugin-backed routes, use `client.request(...)` for the raw `Response`
+and call the plugin subpath's decoder yourself.
+
+### Stream newline-delimited JSON
+
+Use `ndjson.$type<T>()` when a handler should produce a sequence of JSON values
+without buffering the whole response:
+
+```ts
+import { createClient, createRouter } from 'rouzer'
+import * as http from 'rouzer/http'
+import * as ndjson from 'rouzer/ndjson'
+
+export const events = http.get('events', {
+  response: ndjson.$type<{ id: number; message: string }>(),
+})
+export const routes = { events }
+
+createRouter({ plugins: [ndjson.routerPlugin] }).use(routes, {
+  async *events() {
+    yield { id: 1, message: 'ready' }
+    yield { id: 2, message: 'done' }
+  },
+})
+
+const client = createClient({
+  baseURL: 'https://example.com/api/',
+  routes,
+  plugins: [ndjson.clientPlugin],
+})
+for await (const event of await client.events()) {
+  console.log(event.message)
+}
+```
+
+A complete runnable version lives in
+[`examples/ndjson-stream.ts`](../examples/ndjson-stream.ts).
+
+Rouzer's decoder accepts `\n` and `\r\n`, handles UTF-8 chunk boundaries, and
+throws a `SyntaxError` with a line number for malformed JSON. If a consumer stops
+reading early, the response body is cancelled.
+
+Rouzer does not convert handler or generator failures into extra NDJSON items. If
+an async generator throws after the response starts, the response stream errors
+and the client's `for await` loop throws. Model application-level stream errors
+as part of your item type, for example `{ type: 'error'; message: string }`, when
+clients should receive them as data.
+
 ### Group resource actions
 
 Use resources when the public API reads better as a tree or when actions share
@@ -239,17 +321,18 @@ custom headers. Return a plain value for the default `Response.json(value)` path
 
 ### Customize JSON errors
 
-By default, `client.json(...)` throws for non-2xx responses. If the response body
-is JSON, its properties are copied onto the thrown `Error`.
+By default, `client.json(...)` and generated client action functions throw for
+non-2xx responses. If the response body is JSON, its properties are copied onto
+the thrown `Error`.
 
-`onJsonError` can override that behavior. Its return value is returned from
-`client.json(...)` as-is; Rouzer does not automatically parse a returned
-`Response` from `onJsonError`.
+`onJsonError` can override that behavior. Its return value is returned from the
+response helper as-is; Rouzer does not automatically parse a returned `Response`
+from `onJsonError`.
 
-### Update code written for v2.0.1
+### v2->v3 migration
 
 Rouzer now uses action/resource route trees for router registration and client
-shorthands. A v2.0.1 method-map route such as this:
+shorthands. In the v2->v3 migration, a method-map route such as this:
 
 ```ts
 export const profileRoute = route('profiles/:id', {
@@ -307,6 +390,9 @@ await client.profiles.update({
   only when string params are sufficient.
 - Use `response: $type<T>()` for JSON endpoints that should have typed client
   action functions.
+- Use `response: ndjson.$type<T>()` plus `ndjson.routerPlugin` and
+  `ndjson.clientPlugin` for response streams where each line is a JSON value and
+  the client should consume an `AsyncIterable<T>`.
 - Name actions after domain operations (`get`, `list`, `update`, `archive`) and
   let `http.get/post/put/patch/delete` own the transport method.
 - Set `content-type: application/json` yourself when your server or middleware
@@ -314,7 +400,12 @@ await client.profiles.update({
 
 ## Constraints and gotchas
 
-- `$type<T>()` is compile-time only and does not validate response payloads.
+- `$type<T>()` and `ndjson.$type<T>()` are compile-time only and do not validate
+  response payloads or streamed items.
+- NDJSON support is for response streams; request bodies still use the existing
+  JSON body schema path.
+- Routes that use a response plugin fail fast if the matching client or router
+  plugin is not registered.
 - 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.

package/examples/ndjson-stream.ts

@@ -0,0 +1,68 @@
+import type { HattipHandler } from '@hattip/core'
+import { createClient, createRouter } from 'rouzer'
+import * as http from 'rouzer/http'
+import * as ndjson from 'rouzer/ndjson'
+
+type Event = {
+  id: number
+  message: string
+}
+
+export const events = http.get('events', {
+  response: ndjson.$type<Event>(),
+})
+
+export const routes = { events }
+
+/**
+ * Tiny Hattip adapter used only to keep this example self-contained. Real apps
+ * mount the handler with a Hattip adapter for their runtime.
+ */
+function createLocalFetch(handler: HattipHandler): typeof fetch {
+  return async (input, init) => {
+    const request = new Request(input, init)
+    const response = await handler({
+      request,
+      ip: '127.0.0.1',
+      platform: undefined,
+      env() {
+        return undefined
+      },
+      passThrough() {},
+      waitUntil(promise) {
+        void promise
+      },
+    })
+
+    return response ?? new Response(null, { status: 404 })
+  }
+}
+
+async function collect<T>(source: AsyncIterable<T>) {
+  const values: T[] = []
+  for await (const value of source) {
+    values.push(value)
+  }
+  return values
+}
+
+export async function runNdjsonStreamExample() {
+  const handler = createRouter({
+    basePath: 'api/',
+    plugins: [ndjson.routerPlugin],
+  }).use(routes, {
+    async *events() {
+      yield { id: 1, message: 'ready' }
+      yield { id: 2, message: 'done' }
+    },
+  })
+
+  const client = createClient({
+    baseURL: 'https://example.test/api/',
+    routes,
+    plugins: [ndjson.clientPlugin],
+    fetch: createLocalFetch(handler),
+  })
+
+  return collect(await client.events())
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rouzer",
-  "version": "3.0.1",
+  "version": "3.1.0",
   "type": "module",
   "exports": {
     ".": {
@@ -10,6 +10,10 @@
     "./http": {
       "types": "./dist/http.d.ts",
       "import": "./dist/http.js"
+    },
+    "./ndjson": {
+      "types": "./dist/ndjson.d.ts",
+      "import": "./dist/ndjson.js"
     }
   },
   "peerDependencies": {
@@ -47,7 +51,7 @@
     "!*.tsbuildinfo"
   ],
   "scripts": {
-    "build": "tsgo -b tsconfig.json",
+    "build": "rm -rf dist && tsgo -b tsconfig.json",
     "test": "vitest run"
   }
 }

package/dist/internal.d.ts

@@ -1,17 +0,0 @@
-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

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

package/dist/server/types.d.ts

@@ -1,42 +0,0 @@
-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 { 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 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>>>;
-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 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;
-};
-export {};

package/dist/server/types.js

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

package/dist/types.d.ts

@@ -1,140 +0,0 @@
-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';
-/**
- * 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;
-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>;
-};
-/**
- * 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;
-};
-/** `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;
-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;
-/**
- * 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.js

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