rouzer 3.0.1 → 3.1.0

package/README.md

@@ -6,12 +6,14 @@ and Zod validation between a Hattip-compatible server and a typed fetch client.
 ## What it does
 
 A Rouzer HTTP route tree defines URL patterns, named actions, method schemas, and
-optional response types once, then reuses that contract to:
+optional JSON or newline-delimited JSON response types once, then reuses that
+contract to:
 
 - validate client arguments before `fetch`
 - match and validate server requests before handlers run
 - type handler context from path, query/body, headers, and middleware
 - attach typed client action functions such as `client.profiles.get(...)`
+- parse typed JSON responses and typed NDJSON response streams
 
 Rouzer optimizes for shared TypeScript route modules over language-agnostic API
 schemas or generated SDKs.
@@ -29,8 +31,8 @@ Consider something else if:
 
 - you need OpenAPI-first workflows, schema files, or generated clients for other
   languages
-- you need runtime response-body validation; `response: $type<T>()` is
-  compile-time only
+- you need runtime response-body validation; `response: $type<T>()` and
+  `response: ndjson.$type<T>()` are compile-time only
 - you want a framework that owns controllers, data loading, rendering, and
   deployment adapters
 - you cannot use ESM or Zod v4+
@@ -101,10 +103,46 @@ const { message } = await client.hello({
 route arguments before `fetch`; server handlers validate matched path, query,
 headers, and JSON bodies before your handler runs.
 
+### NDJSON response streams
+
+Use `response: ndjson.$type<T>()` for endpoints that stream
+newline-delimited JSON. Add `ndjson.routerPlugin` to the router and
+`ndjson.clientPlugin` to the client. Handlers return an `Iterable<T>` or
+`AsyncIterable<T>`; Rouzer wraps it in an `application/x-ndjson` response.
+Client action functions resolve to an `AsyncIterable<T>`.
+
+```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' }
+  },
+})
+
+const client = createClient({
+  baseURL: 'https://example.com/api/',
+  routes,
+  plugins: [ndjson.clientPlugin],
+})
+for await (const event of await client.events()) {
+  console.log(event.message)
+}
+```
+
 ## Documentation
 
-- [Concepts, API selection, and v2.0.1 migration notes](docs/context.md)
+- [Concepts, API selection, and v2->v3 migration notes](docs/context.md)
 - [Runnable shared-route example](examples/basic-usage.ts)
+- [Runnable NDJSON response-stream example](examples/ndjson-stream.ts)
 - Generated declarations in the published package provide the exact signatures
-  for every public export, including the `rouzer/http` subpath.
+  for every public export, including the `rouzer/http` and `rouzer/ndjson`
+  subpaths.
 - Public TSDoc in `src/` owns symbol-level behavior and option details.

package/dist/client/index.d.ts

@@ -1,5 +1,6 @@
 import { Promisable } from '../common.js';
 import type { HttpAction, HttpResource, 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 { InferRouteResponse } from '../types/response.js';
@@ -38,13 +39,17 @@ export declare function createClient<TRoutes extends HttpRouteTree = Record<stri
      * ```
      */
     routes?: TRoutes;
+    /** Response codec plugins used by generated action functions. */
+    plugins?: readonly ClientResponsePlugin[];
     /**
-     * Custom handler for non-2xx responses from `.json()`.
+     * Custom handler for non-2xx responses from `.json()` and generated response
+     * helpers.
      *
-     * @remarks When provided, the return value is returned from `.json()` as-is;
-     * Rouzer does not automatically parse a `Response` returned by this hook.
+     * @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.
      */
-    onJsonError?: (response: Response) => Promisable<Response>;
+    onJsonError?: (response: Response) => Promisable<unknown>;
     /** Custom `fetch` implementation to use for requests. */
     fetch?: typeof globalThis.fetch;
 }): ClientTree<TRoutes, ""> & {
@@ -73,13 +78,17 @@ export declare function createClient<TRoutes extends HttpRouteTree = Record<stri
          * ```
          */
         routes?: TRoutes;
+        /** Response codec plugins used by generated action functions. */
+        plugins?: readonly ClientResponsePlugin[];
         /**
-         * Custom handler for non-2xx responses from `.json()`.
+         * Custom handler for non-2xx responses from `.json()` and generated response
+         * helpers.
          *
-         * @remarks When provided, the return value is returned from `.json()` as-is;
-         * Rouzer does not automatically parse a `Response` returned by this hook.
+         * @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.
          */
-        onJsonError?: (response: Response) => Promisable<Response>;
+        onJsonError?: (response: Response) => Promisable<unknown>;
         /** Custom `fetch` implementation to use for requests. */
         fetch?: typeof globalThis.fetch;
     };
@@ -97,7 +106,9 @@ export type ClientTree<T extends HttpRouteTree, TPrefix extends string = ''> = {
  * Client action function attached for each HTTP action leaf.
  *
  * @remarks Actions whose schema has `response: $type<T>()` return parsed JSON
- * as `T`. Actions without a response marker return the raw `Response`.
+ * as `T`. Actions whose schema has a plugin response marker return the 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 {
     response: any;

package/dist/client/index.js

@@ -1,6 +1,7 @@
 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';
 /**
  * Create a typed fetch client for an HTTP route tree.
  *
@@ -12,6 +13,10 @@ 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) {
@@ -58,37 +63,58 @@ export function createClient(config) {
     async function json(props) {
         const response = await request(props);
         if (!response.ok) {
-            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 contentType = response.headers.get('content-type');
-            if (contentType?.includes('application/json')) {
-                Object.assign(error, await response.json());
-            }
-            throw error;
+            return handleResponseError(response, props);
         }
         return response.json();
     }
+    async function response(props) {
+        const httpResponse = await request(props);
+        if (!httpResponse.ok) {
+            return handleResponseError(httpResponse, props);
+        }
+        const pluginId = getResponsePluginMarkerId(props.schema.response);
+        if (pluginId) {
+            const plugin = responsePlugins.get(pluginId);
+            if (!plugin) {
+                throw missingClientResponsePlugin(pluginId);
+            }
+            return plugin.decode(httpResponse, {
+                marker: props.schema.response,
+                request: props,
+            });
+        }
+        return httpResponse.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 contentType = response.headers.get('content-type');
+        if (contentType?.includes('application/json')) {
+            Object.assign(error, await response.json());
+        }
+        throw error;
+    }
     return {
         ...(config.routes
-            ? connectTree(config.routes, '', request, json)
+            ? connectTree(config.routes, '', request, response)
             : null),
         config,
         request,
         json,
     };
 }
-function connectTree(tree, prefix, request, json) {
+function connectTree(tree, prefix, request, response) {
     return Object.fromEntries(Object.entries(tree).map(([key, node]) => {
         if (node.kind === 'resource') {
             return [
                 key,
-                connectTree(node.children, joinPaths(prefix, node.path.source), request, json),
+                connectTree(node.children, joinPaths(prefix, node.path.source), request, response),
             ];
         }
         const path = RoutePattern.parse(joinPaths(prefix, node.path?.source ?? ''));
-        const fetch = node.schema.response ? json : request;
+        const fetch = node.schema.response ? response : request;
         return [
             key,
             (args = {}) => fetch({
@@ -101,6 +127,22 @@ function connectTree(tree, prefix, request, json) {
         ];
     }));
 }
+function validateClientResponsePlugins(tree, plugins) {
+    for (const node of Object.values(tree)) {
+        if (node.kind === 'resource') {
+            validateClientResponsePlugins(node.children, plugins);
+        }
+        else {
+            const pluginId = getResponsePluginMarkerId(node.schema.response);
+            if (pluginId && !plugins.has(pluginId)) {
+                throw missingClientResponsePlugin(pluginId);
+            }
+        }
+    }
+}
+function missingClientResponsePlugin(pluginId) {
+    return new Error(`Missing client response plugin for ${pluginId}`);
+}
 function joinPaths(left, right) {
     return [left, right].filter(Boolean).join('/').replace(/\/+/g, '/');
 }

package/dist/index.d.ts

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

package/dist/index.js

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

package/dist/ndjson.d.ts

@@ -0,0 +1,54 @@
+import { type ClientResponsePlugin, type ResponsePluginMarker, type RouterResponsePlugin } from './response.js';
+declare const codecId = "rouzer/ndjson";
+/** Values accepted by Rouzer's NDJSON response encoder. */
+export type NdjsonSource<T = unknown> = Iterable<T> | AsyncIterable<T>;
+/**
+ * Create a compile-time marker for newline-delimited JSON response items.
+ *
+ * @remarks The returned marker is handled by `clientPlugin` in clients and
+ * `routerPlugin` in routers. Generated client action functions resolve to an
+ * `AsyncIterable<T>`, while route handlers may return either an `Iterable<T>`
+ * or an `AsyncIterable<T>`. Rouzer does not validate streamed items at runtime.
+ */
+export declare function $type<T>(): ResponsePluginMarker<AsyncIterable<T>, NdjsonSource<T>, typeof codecId>;
+/**
+ * Client plugin that decodes successful NDJSON responses.
+ *
+ * @remarks Register this plugin with `createClient({ plugins })` when the route
+ * tree contains `response: ndjson.$type<T>()` markers.
+ */
+export declare const clientPlugin: ClientResponsePlugin;
+/**
+ * Router plugin that encodes handler results as NDJSON responses.
+ *
+ * @remarks Register this plugin with `createRouter({ plugins })` when the route
+ * tree contains `response: ndjson.$type<T>()` markers. Handler or generator
+ * errors are not encoded as NDJSON items; model application-level errors in the
+ * item type when clients should receive them as data.
+ */
+export declare const routerPlugin: RouterResponsePlugin;
+/**
+ * Encode an iterable of values as a newline-delimited JSON byte stream.
+ *
+ * @remarks Each yielded value is serialized with `JSON.stringify` and followed
+ * by `\n`. Values that cannot be represented as a JSON text, such as
+ * `undefined`, cause the stream to error when read.
+ */
+export declare function encodeNdjson(source: NdjsonSource): ReadableStream<Uint8Array>;
+/**
+ * Decode a newline-delimited JSON byte stream.
+ *
+ * @remarks UTF-8 chunks may split JSON lines. Both `\n` and `\r\n` line endings
+ * are accepted, and a final line does not need a trailing newline. Malformed
+ * lines throw a `SyntaxError` that includes the 1-based line number.
+ */
+export declare function decodeNdjson<T = unknown>(stream: ReadableStream<Uint8Array>): AsyncIterable<T>;
+/**
+ * Create a `Response` whose body is encoded as newline-delimited JSON.
+ *
+ * @remarks The response defaults to
+ * `content-type: application/x-ndjson; charset=utf-8` unless the caller supplies
+ * a content type in `init.headers`.
+ */
+export declare function ndjsonResponse<T>(source: NdjsonSource<T>, init?: ResponseInit): Response;
+export {};

package/dist/ndjson.js

@@ -0,0 +1,161 @@
+import { createResponsePluginMarker, } from './response.js';
+const codecId = 'rouzer/ndjson';
+/**
+ * Create a compile-time marker for newline-delimited JSON response items.
+ *
+ * @remarks The returned marker is handled by `clientPlugin` in clients and
+ * `routerPlugin` in routers. Generated client action functions resolve to an
+ * `AsyncIterable<T>`, while route handlers may return either an `Iterable<T>`
+ * or an `AsyncIterable<T>`. Rouzer does not validate streamed items at runtime.
+ */
+export function $type() {
+    return createResponsePluginMarker(codecId);
+}
+/**
+ * Client plugin that decodes successful NDJSON responses.
+ *
+ * @remarks Register this plugin with `createClient({ plugins })` when the route
+ * tree contains `response: ndjson.$type<T>()` markers.
+ */
+export const clientPlugin = {
+    id: codecId,
+    decode(response) {
+        if (!response.body) {
+            throw new Error('NDJSON response has no body');
+        }
+        return decodeNdjson(response.body);
+    },
+};
+/**
+ * Router plugin that encodes handler results as NDJSON responses.
+ *
+ * @remarks Register this plugin with `createRouter({ plugins })` when the route
+ * tree contains `response: ndjson.$type<T>()` markers. Handler or generator
+ * errors are not encoded as NDJSON items; model application-level errors in the
+ * item type when clients should receive them as data.
+ */
+export const routerPlugin = {
+    id: codecId,
+    encode(value) {
+        return ndjsonResponse(value);
+    },
+};
+/**
+ * Encode an iterable of values as a newline-delimited JSON byte stream.
+ *
+ * @remarks Each yielded value is serialized with `JSON.stringify` and followed
+ * by `\n`. Values that cannot be represented as a JSON text, such as
+ * `undefined`, cause the stream to error when read.
+ */
+export function encodeNdjson(source) {
+    const iterator = getAsyncIterator(source);
+    const encoder = new TextEncoder();
+    return new ReadableStream({
+        async pull(controller) {
+            const { done, value } = await iterator.next();
+            if (done) {
+                controller.close();
+                return;
+            }
+            const line = JSON.stringify(value);
+            if (line === undefined) {
+                throw new TypeError('NDJSON items must serialize to a JSON text; received undefined');
+            }
+            controller.enqueue(encoder.encode(`${line}\n`));
+        },
+        async cancel(reason) {
+            await iterator.return?.(reason);
+        },
+    });
+}
+/**
+ * Decode a newline-delimited JSON byte stream.
+ *
+ * @remarks UTF-8 chunks may split JSON lines. Both `\n` and `\r\n` line endings
+ * are accepted, and a final line does not need a trailing newline. Malformed
+ * lines throw a `SyntaxError` that includes the 1-based line number.
+ */
+export async function* decodeNdjson(stream) {
+    const reader = stream.getReader();
+    const decoder = new TextDecoder();
+    let buffer = '';
+    let lineNumber = 0;
+    let doneReading = false;
+    try {
+        while (true) {
+            const { done, value } = await reader.read();
+            if (done) {
+                buffer += decoder.decode();
+                doneReading = true;
+                break;
+            }
+            buffer += decoder.decode(value, { stream: true });
+            let newlineIndex;
+            while ((newlineIndex = buffer.indexOf('\n')) !== -1) {
+                const line = stripCarriageReturn(buffer.slice(0, newlineIndex));
+                buffer = buffer.slice(newlineIndex + 1);
+                lineNumber += 1;
+                yield parseNdjsonLine(line, lineNumber);
+            }
+        }
+        if (buffer.length > 0) {
+            lineNumber += 1;
+            yield parseNdjsonLine(stripCarriageReturn(buffer), lineNumber);
+        }
+    }
+    finally {
+        if (!doneReading) {
+            await reader.cancel().catch(() => { });
+        }
+        reader.releaseLock();
+    }
+}
+/**
+ * Create a `Response` whose body is encoded as newline-delimited JSON.
+ *
+ * @remarks The response defaults to
+ * `content-type: application/x-ndjson; charset=utf-8` unless the caller supplies
+ * a content type in `init.headers`.
+ */
+export function ndjsonResponse(source, init = {}) {
+    const headers = new Headers(init.headers);
+    if (!headers.has('content-type')) {
+        headers.set('content-type', 'application/x-ndjson; charset=utf-8');
+    }
+    return new Response(encodeNdjson(source), {
+        ...init,
+        headers,
+    });
+}
+function getAsyncIterator(source) {
+    const asyncIterator = source[Symbol.asyncIterator]?.();
+    if (asyncIterator) {
+        return asyncIterator;
+    }
+    const iterator = source[Symbol.iterator]?.();
+    if (iterator) {
+        return {
+            next() {
+                return Promise.resolve(iterator.next());
+            },
+            async return() {
+                iterator.return?.();
+                return { done: true, value: undefined };
+            },
+        };
+    }
+    throw new TypeError('NDJSON source must be iterable');
+}
+function stripCarriageReturn(line) {
+    return line.endsWith('\r') ? line.slice(0, -1) : line;
+}
+function parseNdjsonLine(line, lineNumber) {
+    try {
+        return JSON.parse(line);
+    }
+    catch (cause) {
+        const error = new SyntaxError(`Invalid NDJSON at line ${lineNumber}: ${cause instanceof Error ? cause.message : String(cause)}`);
+        error.cause = cause;
+        throw error;
+    }
+}

package/dist/response.d.ts

@@ -0,0 +1,47 @@
+import type { Promisable } from './common.js';
+import type { RouteRequest } from './types/request.js';
+/** Runtime key carried by response plugin markers. */
+export declare const responsePluginMarkerSymbol: unique symbol;
+/**
+ * Compile-time response marker handled by a client/router response plugin pair.
+ *
+ * @remarks `TClient` is the value returned by generated client action
+ * functions. `TRouter` is the non-`Response` value accepted from route handlers.
+ */
+export type ResponsePluginMarker<TClient, TRouter = TClient, TId extends string = string> = {
+    readonly [responsePluginMarkerSymbol]: {
+        readonly id: TId;
+        readonly client: TClient;
+        readonly router: TRouter;
+    };
+};
+/** Client-side response plugin used by `createClient({ plugins })`. */
+export type ClientResponsePlugin = {
+    /** Stable response codec id matched against route response markers. */
+    readonly id: string;
+    /** Decode a successful `Response` into the client action result. */
+    decode(response: Response, context: {
+        marker: ResponsePluginMarker<any, any>;
+        request: RouteRequest;
+    }): Promisable<unknown>;
+};
+/** Router-side response plugin used by `createRouter({ plugins })`. */
+export type RouterResponsePlugin = {
+    /** Stable response codec id matched against route response markers. */
+    readonly id: string;
+    /** Encode a handler result into the HTTP response. */
+    encode(value: unknown, context: {
+        marker: ResponsePluginMarker<any, any>;
+        request: Request;
+    }): Promisable<Response>;
+};
+/** Create a response marker for a response plugin. */
+export declare function createResponsePluginMarker<TClient, TRouter = TClient, const TId extends string = string>(id: TId): ResponsePluginMarker<TClient, TRouter, TId>;
+/** Get the response plugin id from a plugin marker, if present. */
+export declare function getResponsePluginMarkerId(value: unknown): string | undefined;
+/** Return true when a route response marker is handled by a response plugin. */
+export declare function isResponsePluginMarker(value: unknown): value is ResponsePluginMarker<unknown, unknown>;
+/** Create a plugin lookup map and reject duplicate plugin ids. */
+export declare function createResponsePluginMap<TPlugin extends {
+    readonly id: string;
+}>(plugins?: readonly TPlugin[], label?: string): Map<string, TPlugin>;

package/dist/response.js

@@ -0,0 +1,35 @@
+/** Runtime key carried by response plugin markers. */
+export const responsePluginMarkerSymbol = Symbol.for('rouzer.response-plugin');
+/** Create a response marker for a response plugin. */
+export function createResponsePluginMarker(id) {
+    return {
+        [responsePluginMarkerSymbol]: {
+            id,
+            client: undefined,
+            router: undefined,
+        },
+    };
+}
+/** Get the response plugin id from a plugin marker, if present. */
+export function getResponsePluginMarkerId(value) {
+    return isResponsePluginMarker(value)
+        ? value[responsePluginMarkerSymbol].id
+        : undefined;
+}
+/** Return true when a route response marker is handled by a response plugin. */
+export function isResponsePluginMarker(value) {
+    return (typeof value === 'object' &&
+        value !== null &&
+        responsePluginMarkerSymbol in value);
+}
+/** Create a plugin lookup map and reject duplicate plugin ids. */
+export function createResponsePluginMap(plugins = [], label = 'response') {
+    const map = new Map();
+    for (const plugin of plugins) {
+        if (map.has(plugin.id)) {
+            throw new Error(`Duplicate ${label} plugin: ${plugin.id}`);
+        }
+        map.set(plugin.id, plugin);
+    }
+    return map;
+}

package/dist/server/router.d.ts

@@ -1,6 +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 RouterResponsePlugin } from '../response.js';
 import type { RouteRequestHandlerMap } from '../types/server.js';
 export { chain };
 /** Configuration for `createRouter`. */
@@ -25,6 +26,8 @@ export type RouterConfig = {
      * and logs missing route handlers to the console.
      */
     debug?: boolean;
+    /** Response codec plugins used for route handler results. */
+    plugins?: readonly RouterResponsePlugin[];
     /** CORS configuration for requests with an `Origin` header. */
     cors?: {
         /**
@@ -67,8 +70,8 @@ export interface Router<T extends MiddlewareTypes = any> extends HattipHandler<T
 /**
  * Create a Rouzer router that can be mounted by any Hattip adapter.
  *
- * @param config Optional router configuration for base path, debug behavior, and
- * CORS origin restrictions.
+ * @param config Optional router configuration for base path, debug behavior,
+ * response plugins, and CORS origin restrictions.
  * @returns A Hattip-compatible handler with `.use(...)` methods for middleware
  * and route registration.
  */

package/dist/server/router.js

@@ -3,15 +3,18 @@ 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 { createResponsePluginMap, getResponsePluginMarkerId, } from '../response.js';
 export { chain };
 // Internal prototype for the router instance.
 class RouterObject extends MiddlewareChain {
     config;
     basePath;
+    responsePlugins;
     constructor(config) {
         super();
         this.config = config;
         this.basePath = config.basePath?.replace(/\/?$/, '/');
+        this.responsePlugins = createResponsePluginMap(config.plugins, 'router response');
         const allowOrigins = config.cors?.allowOrigins?.map(createOriginPattern);
         if (allowOrigins) {
             super.use(((ctx) => {
@@ -31,14 +34,15 @@ class RouterObject extends MiddlewareChain {
     }
     /** @internal */
     useRoutes(routeSchemas, handlers) {
-        const { config, basePath } = this;
+        const { config, basePath, responsePlugins } = this;
         const routes = flattenRoutes(routeSchemas, handlers, basePath ?? '', config.debug);
+        validateRouterResponsePlugins(routes, responsePlugins);
         const addDebugHeaders = config.debug
             ? (context, route) => {
                 context.setHeader('X-Route-Name', route.name);
             }
             : null;
-        return super.use((async function (context) {
+        return super.use(async function (context) {
             const request = context.request;
             const origin = request.headers.get('Origin');
             const url = (context.url ??= new URL(request.url));
@@ -110,16 +114,27 @@ class RouterObject extends MiddlewareChain {
                 if (result instanceof Response) {
                     return result;
                 }
+                const pluginId = getResponsePluginMarkerId(schema.response);
+                if (pluginId) {
+                    const plugin = responsePlugins.get(pluginId);
+                    if (!plugin) {
+                        throw missingRouterResponsePlugin(pluginId);
+                    }
+                    return plugin.encode(result, {
+                        marker: schema.response,
+                        request,
+                    });
+                }
                 return Response.json(result);
             }
-        }));
+        });
     }
 }
 /**
  * Create a Rouzer router that can be mounted by any Hattip adapter.
  *
- * @param config Optional router configuration for base path, debug behavior, and
- * CORS origin restrictions.
+ * @param config Optional router configuration for base path, debug behavior,
+ * response plugins, and CORS origin restrictions.
  * @returns A Hattip-compatible handler with `.use(...)` methods for middleware
  * and route registration.
  */
@@ -152,6 +167,17 @@ function flattenRoutes(tree, handlers, prefix, debug) {
     }
     return routes;
 }
+function validateRouterResponsePlugins(routes, plugins) {
+    for (const route of routes) {
+        const pluginId = getResponsePluginMarkerId(route.schema.response);
+        if (pluginId && !plugins.has(pluginId)) {
+            throw missingRouterResponsePlugin(pluginId);
+        }
+    }
+}
+function missingRouterResponsePlugin(pluginId) {
+    return new Error(`Missing router response plugin for ${pluginId}`);
+}
 function joinPaths(left, right) {
     return [left, right].filter(Boolean).join('/').replace(/\/+/g, '/');
 }