@kaito-http/core 3.0.0-beta.16 → 3.0.0-beta.20

package/dist/index.cjs

@@ -106,6 +106,9 @@ var KaitoResponse = class {
     return this._headers;
   }
   status(status) {
+    if (status === void 0) {
+      return this._status;
+    }
     this._status = status;
     return this;
   }
@@ -232,10 +235,10 @@ var Router = class _Router {
       const request = new KaitoRequest(url, req);
       const response = new KaitoResponse();
       try {
-        const rootCtx = await server.getContext(request, response);
-        const ctx = await route.through(rootCtx);
         const body = route.body ? await route.body.parse(await req.json()) : void 0;
         const query = _Router.parseQuery(route.query, url);
+        const rootCtx = await server.getContext(request, response);
+        const ctx = await route.through(rootCtx);
         const result = await route.run({
           ctx,
           body,
@@ -243,6 +246,9 @@ var Router = class _Router {
           params
         });
         if (result instanceof Response) {
+          if (server.enableClientResponseHints) {
+            result.headers.set("x-kaito-is-response", "1");
+          }
           return result;
         }
         return response.toResponse({
@@ -288,20 +294,21 @@ var Router = class _Router {
 };
 
 // src/server.ts
-function createKaitoHandler(config) {
-  const match = config.router.freeze(config);
+function createKaitoHandler(userConfig) {
+  const config = {
+    enableClientResponseHints: true,
+    ...userConfig
+  };
+  const handle = config.router.freeze(config);
   return async (request) => {
-    let before = void 0;
     if (config.before) {
       const result = await config.before(request);
-      if (result instanceof Response) {
-        return result;
-      }
-      before = result;
+      if (result instanceof Response) return result;
     }
-    const response = await match(request);
-    if ("after" in config && config.after) {
-      await config.after(before, response);
+    const response = await handle(request);
+    if (config.transform) {
+      const result = await config.transform(request, response);
+      if (result instanceof Response) return result;
     }
     return response;
   };

package/dist/index.d.cts

@@ -34,10 +34,10 @@ type KaitoMethod = 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE' | 'HEAD' | 'OPTIO
  * ```ts
  * const response = new KaitoResponse();
  *
- * response.status = 200;
- * response.header('Content-Type', 'application/json');
+ * response.status(200);
+ * response.headers.set('Content-Type', 'application/json');
  *
- * console.log(response.headers); // Headers { 'content-type': 'application/json' }
+ * console.log(response.headers); // Headers {'content-type': 'application/json'}
  * ```
  */
 declare class KaitoResponse {
@@ -45,6 +45,16 @@ declare class KaitoResponse {
     private _status;
     constructor();
     get headers(): Headers;
+    /**
+     * Gets the status code of this KaitoResponse instance
+     * @returns The status code
+     */
+    status(): number;
+    /**
+     * Sets the status code of this KaitoResponse instance
+     * @param status The status code to set
+     * @returns This KaitoResponse instance
+     */
     status(status: number): this;
     /**
      * Turn this KaitoResponse instance into a Response instance
@@ -54,26 +64,87 @@ declare class KaitoResponse {
     toResponse<T>(body: APIResponse<T>): Response;
 }
 
-type Before<BeforeAfterContext> = (req: Request) => Promise<BeforeAfterContext | Response>;
-type After<BeforeAfterContext> = (ctx: BeforeAfterContext, response: Response) => Promise<void>;
-type ServerConfigWithBefore<BeforeAfterContext> = {
-    before: Before<BeforeAfterContext>;
-    after?: After<BeforeAfterContext>;
-} | {
-    before?: undefined;
-};
-type ServerConfig<ContextFrom, BeforeAfterContext> = ServerConfigWithBefore<BeforeAfterContext> & {
+type Before = (req: Request) => Promise<Response | void | undefined>;
+type ServerConfig<ContextFrom> = {
+    /**
+     * The root router to mount on this server.
+     */
     router: Router<ContextFrom, unknown, any>;
+    /**
+     * A function that is called to get the context for a request.
+     *
+     * This is useful for things like authentication, to pass in a database connection, etc.
+     *
+     * It's fine for this function to throw; if it does, the error is passed to the `onError` function.
+     */
     getContext: GetContext<ContextFrom>;
-    onError(arg: {
+    /**
+     * A function that is called when an error occurs inside a route handler.
+     *
+     * The result of this function is used to determine the response status and message, and is
+     * always sent to the client. You could include logic to check for production vs development
+     * environments here, and this would also be a good place to include error tracking
+     * like Sentry or Rollbar.
+     *
+     * @param arg - The error and the request
+     * @returns A KaitoError or an object with a status and message
+     */
+    onError: (arg: {
         error: Error;
         req: KaitoRequest;
-    }): Promise<KaitoError | {
+    }) => Promise<KaitoError | {
         status: number;
         message: string;
     }>;
+    /**
+     * A function that is called before every request. Most useful for bailing out early in the case of an OPTIONS request.
+     *
+     * @example
+     * ```ts
+     * before: async req => {
+     * 	if (req.method === 'OPTIONS') {
+     * 		return new Response(null, {status: 204});
+     * 	}
+     * }
+     * ```
+     */
+    before?: Before;
+    /**
+     * Transforms the response before it is sent to the client. Very useful for settings headers like CORS.
+     *
+     * You can also return a new response in this function, or just mutate the current one.
+     *
+     * @example
+     * ```ts
+     * transform: async (req, res) => {
+     * 	res.headers.set('Access-Control-Allow-Origin', 'http://localhost:3000');
+     * 	res.headers.set('Access-Control-Allow-Methods', 'GET, POST, PUT, DELETE, OPTIONS');
+     * 	res.headers.set('Access-Control-Allow-Headers', 'Content-Type, Authorization');
+     * 	res.headers.set('Access-Control-Max-Age', '86400');
+     * 	res.headers.set('Access-Control-Allow-Credentials', 'true');
+     * }
+     * ```
+     */
+    transform?: (req: Request, res: Response) => Promise<Response | void | undefined>;
+    /**
+     * Controls whether the server includes a header to indicate non-JSON responses.
+     *
+     * When a route handler returns a `Response` object, this setting determines if
+     * the server adds a header indicating the response should not be parsed as JSON.
+     *
+     * The `@kaito-http/client` package checks for this header's presence:
+     * - If present: Returns the raw Response object
+     * - If absent: Attempts to parse the response as JSON
+     *
+     * You might want to disable this feature when:
+     * 1. Using a custom client that doesn't recognize this header
+     * 2. Security requirements prevent exposing framework details in headers
+     *
+     * @default true
+     */
+    enableClientResponseHints: boolean;
 };
-declare function createKaitoHandler<Context, BeforeAfterContext = null>(config: ServerConfig<Context, BeforeAfterContext>): (request: Request) => Promise<Response>;
+declare function createKaitoHandler<Context>(userConfig: MakeOptional<ServerConfig<Context>, 'enableClientResponseHints'>): (request: Request) => Promise<Response>;
 
 type PrefixRoutesPathInner<R extends AnyRoute, Prefix extends `/${string}`> = R extends Route<infer ContextFrom, infer ContextTo, infer Result, infer Path, infer Method, infer Query, infer BodyOutput> ? Route<ContextFrom, ContextTo, Result, `${Prefix}${Path}`, Method, Query, BodyOutput> : never;
 type PrefixRoutesPath<Prefix extends `/${string}`, R extends AnyRoute> = R extends R ? PrefixRoutesPathInner<R, Prefix> : never;
@@ -88,17 +159,17 @@ declare class Router<ContextFrom, ContextTo, R extends AnyRoute> {
     private static parseQuery;
     constructor(options: RouterState<R, ContextFrom, ContextTo>);
     get routes(): Set<R>;
-    add: <Result, Path extends string, Method extends KaitoMethod, Query extends AnyQueryDefinition = {}, Body extends Parsable = never>(method: Method, path: Path, route: (Method extends "GET" ? Omit<Route<ContextFrom, ContextTo, Result, Path, Method, Query, Body>, "body" | "path" | "method" | "through"> : Omit<Route<ContextFrom, ContextTo, Result, Path, Method, Query, Body>, "path" | "method" | "through">) | Route<ContextFrom, ContextTo, Result, Path, Method, Query, Body>["run"]) => Router<ContextFrom, ContextTo, R | Route<ContextFrom, ContextTo, Result extends Response ? unknown : Result, Path, Method, Query, Body>>;
+    add: <Result, Path extends string, Method extends KaitoMethod, Query extends AnyQueryDefinition = {}, Body extends Parsable = never>(method: Method, path: Path, route: (Method extends "GET" ? Omit<Route<ContextFrom, ContextTo, Result, Path, Method, Query, Body>, "body" | "path" | "method" | "through"> : Omit<Route<ContextFrom, ContextTo, Result, Path, Method, Query, Body>, "path" | "method" | "through">) | Route<ContextFrom, ContextTo, Result, Path, Method, Query, Body>["run"]) => Router<ContextFrom, ContextTo, R | Route<ContextFrom, ContextTo, Result, Path, Method, Query, Body>>;
     readonly merge: <PathPrefix extends `/${string}`, OtherRoutes extends AnyRoute>(pathPrefix: PathPrefix, other: Router<ContextFrom, unknown, OtherRoutes>) => Router<ContextFrom, ContextTo, Extract<R | PrefixRoutesPath<PathPrefix, OtherRoutes>, AnyRoute>>;
-    freeze: (server: Omit<ServerConfig<ContextFrom, any>, "router">) => (req: Request) => Promise<Response>;
+    freeze: (server: Omit<ServerConfig<ContextFrom>, "router">) => (req: Request) => Promise<Response>;
     private readonly method;
-    get: <Result, Path extends string, Query extends AnyQueryDefinition = {}, Body extends Parsable = never>(path: Path, route: ((arg: RouteArgument<Path, ContextTo, { [Key in keyof Query]: InferParsable<Query[Key]>["output"]; }, InferParsable<Body>["output"]>) => Promise<Result>) | Omit<Route<ContextFrom, ContextTo, Result, Path, "GET", Query, Body>, "body" | "path" | "method" | "through">) => Router<ContextFrom, ContextTo, R | Route<ContextFrom, ContextTo, Result extends Response ? unknown : Result, Path, "GET", Query, Body>>;
-    post: <Result, Path extends string, Query extends AnyQueryDefinition = {}, Body extends Parsable = never>(path: Path, route: ((arg: RouteArgument<Path, ContextTo, { [Key in keyof Query]: InferParsable<Query[Key]>["output"]; }, InferParsable<Body>["output"]>) => Promise<Result>) | Omit<Route<ContextFrom, ContextTo, Result, Path, "POST", Query, Body>, "path" | "method" | "through">) => Router<ContextFrom, ContextTo, R | Route<ContextFrom, ContextTo, Result extends Response ? unknown : Result, Path, "POST", Query, Body>>;
-    put: <Result, Path extends string, Query extends AnyQueryDefinition = {}, Body extends Parsable = never>(path: Path, route: ((arg: RouteArgument<Path, ContextTo, { [Key in keyof Query]: InferParsable<Query[Key]>["output"]; }, InferParsable<Body>["output"]>) => Promise<Result>) | Omit<Route<ContextFrom, ContextTo, Result, Path, "PUT", Query, Body>, "path" | "method" | "through">) => Router<ContextFrom, ContextTo, R | Route<ContextFrom, ContextTo, Result extends Response ? unknown : Result, Path, "PUT", Query, Body>>;
-    patch: <Result, Path extends string, Query extends AnyQueryDefinition = {}, Body extends Parsable = never>(path: Path, route: ((arg: RouteArgument<Path, ContextTo, { [Key in keyof Query]: InferParsable<Query[Key]>["output"]; }, InferParsable<Body>["output"]>) => Promise<Result>) | Omit<Route<ContextFrom, ContextTo, Result, Path, "PATCH", Query, Body>, "path" | "method" | "through">) => Router<ContextFrom, ContextTo, R | Route<ContextFrom, ContextTo, Result extends Response ? unknown : Result, Path, "PATCH", Query, Body>>;
-    delete: <Result, Path extends string, Query extends AnyQueryDefinition = {}, Body extends Parsable = never>(path: Path, route: ((arg: RouteArgument<Path, ContextTo, { [Key in keyof Query]: InferParsable<Query[Key]>["output"]; }, InferParsable<Body>["output"]>) => Promise<Result>) | Omit<Route<ContextFrom, ContextTo, Result, Path, "DELETE", Query, Body>, "path" | "method" | "through">) => Router<ContextFrom, ContextTo, R | Route<ContextFrom, ContextTo, Result extends Response ? unknown : Result, Path, "DELETE", Query, Body>>;
-    head: <Result, Path extends string, Query extends AnyQueryDefinition = {}, Body extends Parsable = never>(path: Path, route: ((arg: RouteArgument<Path, ContextTo, { [Key in keyof Query]: InferParsable<Query[Key]>["output"]; }, InferParsable<Body>["output"]>) => Promise<Result>) | Omit<Route<ContextFrom, ContextTo, Result, Path, "HEAD", Query, Body>, "path" | "method" | "through">) => Router<ContextFrom, ContextTo, R | Route<ContextFrom, ContextTo, Result extends Response ? unknown : Result, Path, "HEAD", Query, Body>>;
-    options: <Result, Path extends string, Query extends AnyQueryDefinition = {}, Body extends Parsable = never>(path: Path, route: ((arg: RouteArgument<Path, ContextTo, { [Key in keyof Query]: InferParsable<Query[Key]>["output"]; }, InferParsable<Body>["output"]>) => Promise<Result>) | Omit<Route<ContextFrom, ContextTo, Result, Path, "OPTIONS", Query, Body>, "path" | "method" | "through">) => Router<ContextFrom, ContextTo, R | Route<ContextFrom, ContextTo, Result extends Response ? unknown : Result, Path, "OPTIONS", Query, Body>>;
+    get: <Result, Path extends string, Query extends AnyQueryDefinition = {}, Body extends Parsable = never>(path: Path, route: ((arg: RouteArgument<Path, ContextTo, { [Key in keyof Query]: InferParsable<Query[Key]>["output"]; }, InferParsable<Body>["output"]>) => Promise<Result>) | Omit<Route<ContextFrom, ContextTo, Result, Path, "GET", Query, Body>, "body" | "path" | "method" | "through">) => Router<ContextFrom, ContextTo, R | Route<ContextFrom, ContextTo, Result, Path, "GET", Query, Body>>;
+    post: <Result, Path extends string, Query extends AnyQueryDefinition = {}, Body extends Parsable = never>(path: Path, route: ((arg: RouteArgument<Path, ContextTo, { [Key in keyof Query]: InferParsable<Query[Key]>["output"]; }, InferParsable<Body>["output"]>) => Promise<Result>) | Omit<Route<ContextFrom, ContextTo, Result, Path, "POST", Query, Body>, "path" | "method" | "through">) => Router<ContextFrom, ContextTo, R | Route<ContextFrom, ContextTo, Result, Path, "POST", Query, Body>>;
+    put: <Result, Path extends string, Query extends AnyQueryDefinition = {}, Body extends Parsable = never>(path: Path, route: ((arg: RouteArgument<Path, ContextTo, { [Key in keyof Query]: InferParsable<Query[Key]>["output"]; }, InferParsable<Body>["output"]>) => Promise<Result>) | Omit<Route<ContextFrom, ContextTo, Result, Path, "PUT", Query, Body>, "path" | "method" | "through">) => Router<ContextFrom, ContextTo, R | Route<ContextFrom, ContextTo, Result, Path, "PUT", Query, Body>>;
+    patch: <Result, Path extends string, Query extends AnyQueryDefinition = {}, Body extends Parsable = never>(path: Path, route: ((arg: RouteArgument<Path, ContextTo, { [Key in keyof Query]: InferParsable<Query[Key]>["output"]; }, InferParsable<Body>["output"]>) => Promise<Result>) | Omit<Route<ContextFrom, ContextTo, Result, Path, "PATCH", Query, Body>, "path" | "method" | "through">) => Router<ContextFrom, ContextTo, R | Route<ContextFrom, ContextTo, Result, Path, "PATCH", Query, Body>>;
+    delete: <Result, Path extends string, Query extends AnyQueryDefinition = {}, Body extends Parsable = never>(path: Path, route: ((arg: RouteArgument<Path, ContextTo, { [Key in keyof Query]: InferParsable<Query[Key]>["output"]; }, InferParsable<Body>["output"]>) => Promise<Result>) | Omit<Route<ContextFrom, ContextTo, Result, Path, "DELETE", Query, Body>, "path" | "method" | "through">) => Router<ContextFrom, ContextTo, R | Route<ContextFrom, ContextTo, Result, Path, "DELETE", Query, Body>>;
+    head: <Result, Path extends string, Query extends AnyQueryDefinition = {}, Body extends Parsable = never>(path: Path, route: ((arg: RouteArgument<Path, ContextTo, { [Key in keyof Query]: InferParsable<Query[Key]>["output"]; }, InferParsable<Body>["output"]>) => Promise<Result>) | Omit<Route<ContextFrom, ContextTo, Result, Path, "HEAD", Query, Body>, "path" | "method" | "through">) => Router<ContextFrom, ContextTo, R | Route<ContextFrom, ContextTo, Result, Path, "HEAD", Query, Body>>;
+    options: <Result, Path extends string, Query extends AnyQueryDefinition = {}, Body extends Parsable = never>(path: Path, route: ((arg: RouteArgument<Path, ContextTo, { [Key in keyof Query]: InferParsable<Query[Key]>["output"]; }, InferParsable<Body>["output"]>) => Promise<Result>) | Omit<Route<ContextFrom, ContextTo, Result, Path, "OPTIONS", Query, Body>, "path" | "method" | "through">) => Router<ContextFrom, ContextTo, R | Route<ContextFrom, ContextTo, Result, Path, "OPTIONS", Query, Body>>;
     through: <NextContext>(transform: (context: ContextTo) => Promise<NextContext>) => Router<ContextFrom, NextContext, R>;
 }
 
@@ -114,6 +185,7 @@ type SuccessfulAPIResponse<T> = {
 };
 type APIResponse<T> = ErroredAPIResponse | SuccessfulAPIResponse<T>;
 type AnyResponse = APIResponse<unknown>;
+type MakeOptional<T, K extends keyof T> = T extends T ? Omit<T, K> & Partial<Pick<T, K>> : never;
 type ExtractRouteParams<T extends string> = string extends T ? Record<string, string> : T extends `${string}:${infer Param}/${infer Rest}` ? {
     [k in Param | keyof ExtractRouteParams<Rest>]: string;
 } : T extends `${string}:${infer Param}` ? {
@@ -172,4 +244,4 @@ type Route<ContextFrom, ContextTo, Result, Path extends string, Method extends K
 };
 type AnyRoute<ContextFrom = any, ContextTo = any> = Route<ContextFrom, ContextTo, any, any, any, AnyQueryDefinition, any>;
 
-export { type APIResponse, type After, type AnyQueryDefinition, type AnyResponse, type AnyRoute, type Before, type ErroredAPIResponse, type ExtractRouteParams, type GetContext, type InferParsable, type InferRoutes, KaitoError, type KaitoMethod, KaitoRequest, type Parsable, type Route, type RouteArgument, Router, type RouterState, type ServerConfig, type ServerConfigWithBefore, type SuccessfulAPIResponse, type Through, WrappedError, createKaitoHandler, createUtilities, parsable };
+export { type APIResponse, type AnyQueryDefinition, type AnyResponse, type AnyRoute, type Before, type ErroredAPIResponse, type ExtractRouteParams, type GetContext, type InferParsable, type InferRoutes, KaitoError, type KaitoMethod, KaitoRequest, type MakeOptional, type Parsable, type Route, type RouteArgument, Router, type RouterState, type ServerConfig, type SuccessfulAPIResponse, type Through, WrappedError, createKaitoHandler, createUtilities, parsable };

package/dist/index.d.ts

@@ -34,10 +34,10 @@ type KaitoMethod = 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE' | 'HEAD' | 'OPTIO
  * ```ts
  * const response = new KaitoResponse();
  *
- * response.status = 200;
- * response.header('Content-Type', 'application/json');
+ * response.status(200);
+ * response.headers.set('Content-Type', 'application/json');
  *
- * console.log(response.headers); // Headers { 'content-type': 'application/json' }
+ * console.log(response.headers); // Headers {'content-type': 'application/json'}
  * ```
  */
 declare class KaitoResponse {
@@ -45,6 +45,16 @@ declare class KaitoResponse {
     private _status;
     constructor();
     get headers(): Headers;
+    /**
+     * Gets the status code of this KaitoResponse instance
+     * @returns The status code
+     */
+    status(): number;
+    /**
+     * Sets the status code of this KaitoResponse instance
+     * @param status The status code to set
+     * @returns This KaitoResponse instance
+     */
     status(status: number): this;
     /**
      * Turn this KaitoResponse instance into a Response instance
@@ -54,26 +64,87 @@ declare class KaitoResponse {
     toResponse<T>(body: APIResponse<T>): Response;
 }
 
-type Before<BeforeAfterContext> = (req: Request) => Promise<BeforeAfterContext | Response>;
-type After<BeforeAfterContext> = (ctx: BeforeAfterContext, response: Response) => Promise<void>;
-type ServerConfigWithBefore<BeforeAfterContext> = {
-    before: Before<BeforeAfterContext>;
-    after?: After<BeforeAfterContext>;
-} | {
-    before?: undefined;
-};
-type ServerConfig<ContextFrom, BeforeAfterContext> = ServerConfigWithBefore<BeforeAfterContext> & {
+type Before = (req: Request) => Promise<Response | void | undefined>;
+type ServerConfig<ContextFrom> = {
+    /**
+     * The root router to mount on this server.
+     */
     router: Router<ContextFrom, unknown, any>;
+    /**
+     * A function that is called to get the context for a request.
+     *
+     * This is useful for things like authentication, to pass in a database connection, etc.
+     *
+     * It's fine for this function to throw; if it does, the error is passed to the `onError` function.
+     */
     getContext: GetContext<ContextFrom>;
-    onError(arg: {
+    /**
+     * A function that is called when an error occurs inside a route handler.
+     *
+     * The result of this function is used to determine the response status and message, and is
+     * always sent to the client. You could include logic to check for production vs development
+     * environments here, and this would also be a good place to include error tracking
+     * like Sentry or Rollbar.
+     *
+     * @param arg - The error and the request
+     * @returns A KaitoError or an object with a status and message
+     */
+    onError: (arg: {
         error: Error;
         req: KaitoRequest;
-    }): Promise<KaitoError | {
+    }) => Promise<KaitoError | {
         status: number;
         message: string;
     }>;
+    /**
+     * A function that is called before every request. Most useful for bailing out early in the case of an OPTIONS request.
+     *
+     * @example
+     * ```ts
+     * before: async req => {
+     * 	if (req.method === 'OPTIONS') {
+     * 		return new Response(null, {status: 204});
+     * 	}
+     * }
+     * ```
+     */
+    before?: Before;
+    /**
+     * Transforms the response before it is sent to the client. Very useful for settings headers like CORS.
+     *
+     * You can also return a new response in this function, or just mutate the current one.
+     *
+     * @example
+     * ```ts
+     * transform: async (req, res) => {
+     * 	res.headers.set('Access-Control-Allow-Origin', 'http://localhost:3000');
+     * 	res.headers.set('Access-Control-Allow-Methods', 'GET, POST, PUT, DELETE, OPTIONS');
+     * 	res.headers.set('Access-Control-Allow-Headers', 'Content-Type, Authorization');
+     * 	res.headers.set('Access-Control-Max-Age', '86400');
+     * 	res.headers.set('Access-Control-Allow-Credentials', 'true');
+     * }
+     * ```
+     */
+    transform?: (req: Request, res: Response) => Promise<Response | void | undefined>;
+    /**
+     * Controls whether the server includes a header to indicate non-JSON responses.
+     *
+     * When a route handler returns a `Response` object, this setting determines if
+     * the server adds a header indicating the response should not be parsed as JSON.
+     *
+     * The `@kaito-http/client` package checks for this header's presence:
+     * - If present: Returns the raw Response object
+     * - If absent: Attempts to parse the response as JSON
+     *
+     * You might want to disable this feature when:
+     * 1. Using a custom client that doesn't recognize this header
+     * 2. Security requirements prevent exposing framework details in headers
+     *
+     * @default true
+     */
+    enableClientResponseHints: boolean;
 };
-declare function createKaitoHandler<Context, BeforeAfterContext = null>(config: ServerConfig<Context, BeforeAfterContext>): (request: Request) => Promise<Response>;
+declare function createKaitoHandler<Context>(userConfig: MakeOptional<ServerConfig<Context>, 'enableClientResponseHints'>): (request: Request) => Promise<Response>;
 
 type PrefixRoutesPathInner<R extends AnyRoute, Prefix extends `/${string}`> = R extends Route<infer ContextFrom, infer ContextTo, infer Result, infer Path, infer Method, infer Query, infer BodyOutput> ? Route<ContextFrom, ContextTo, Result, `${Prefix}${Path}`, Method, Query, BodyOutput> : never;
 type PrefixRoutesPath<Prefix extends `/${string}`, R extends AnyRoute> = R extends R ? PrefixRoutesPathInner<R, Prefix> : never;
@@ -88,17 +159,17 @@ declare class Router<ContextFrom, ContextTo, R extends AnyRoute> {
     private static parseQuery;
     constructor(options: RouterState<R, ContextFrom, ContextTo>);
     get routes(): Set<R>;
-    add: <Result, Path extends string, Method extends KaitoMethod, Query extends AnyQueryDefinition = {}, Body extends Parsable = never>(method: Method, path: Path, route: (Method extends "GET" ? Omit<Route<ContextFrom, ContextTo, Result, Path, Method, Query, Body>, "body" | "path" | "method" | "through"> : Omit<Route<ContextFrom, ContextTo, Result, Path, Method, Query, Body>, "path" | "method" | "through">) | Route<ContextFrom, ContextTo, Result, Path, Method, Query, Body>["run"]) => Router<ContextFrom, ContextTo, R | Route<ContextFrom, ContextTo, Result extends Response ? unknown : Result, Path, Method, Query, Body>>;
+    add: <Result, Path extends string, Method extends KaitoMethod, Query extends AnyQueryDefinition = {}, Body extends Parsable = never>(method: Method, path: Path, route: (Method extends "GET" ? Omit<Route<ContextFrom, ContextTo, Result, Path, Method, Query, Body>, "body" | "path" | "method" | "through"> : Omit<Route<ContextFrom, ContextTo, Result, Path, Method, Query, Body>, "path" | "method" | "through">) | Route<ContextFrom, ContextTo, Result, Path, Method, Query, Body>["run"]) => Router<ContextFrom, ContextTo, R | Route<ContextFrom, ContextTo, Result, Path, Method, Query, Body>>;
     readonly merge: <PathPrefix extends `/${string}`, OtherRoutes extends AnyRoute>(pathPrefix: PathPrefix, other: Router<ContextFrom, unknown, OtherRoutes>) => Router<ContextFrom, ContextTo, Extract<R | PrefixRoutesPath<PathPrefix, OtherRoutes>, AnyRoute>>;
-    freeze: (server: Omit<ServerConfig<ContextFrom, any>, "router">) => (req: Request) => Promise<Response>;
+    freeze: (server: Omit<ServerConfig<ContextFrom>, "router">) => (req: Request) => Promise<Response>;
     private readonly method;
-    get: <Result, Path extends string, Query extends AnyQueryDefinition = {}, Body extends Parsable = never>(path: Path, route: ((arg: RouteArgument<Path, ContextTo, { [Key in keyof Query]: InferParsable<Query[Key]>["output"]; }, InferParsable<Body>["output"]>) => Promise<Result>) | Omit<Route<ContextFrom, ContextTo, Result, Path, "GET", Query, Body>, "body" | "path" | "method" | "through">) => Router<ContextFrom, ContextTo, R | Route<ContextFrom, ContextTo, Result extends Response ? unknown : Result, Path, "GET", Query, Body>>;
-    post: <Result, Path extends string, Query extends AnyQueryDefinition = {}, Body extends Parsable = never>(path: Path, route: ((arg: RouteArgument<Path, ContextTo, { [Key in keyof Query]: InferParsable<Query[Key]>["output"]; }, InferParsable<Body>["output"]>) => Promise<Result>) | Omit<Route<ContextFrom, ContextTo, Result, Path, "POST", Query, Body>, "path" | "method" | "through">) => Router<ContextFrom, ContextTo, R | Route<ContextFrom, ContextTo, Result extends Response ? unknown : Result, Path, "POST", Query, Body>>;
-    put: <Result, Path extends string, Query extends AnyQueryDefinition = {}, Body extends Parsable = never>(path: Path, route: ((arg: RouteArgument<Path, ContextTo, { [Key in keyof Query]: InferParsable<Query[Key]>["output"]; }, InferParsable<Body>["output"]>) => Promise<Result>) | Omit<Route<ContextFrom, ContextTo, Result, Path, "PUT", Query, Body>, "path" | "method" | "through">) => Router<ContextFrom, ContextTo, R | Route<ContextFrom, ContextTo, Result extends Response ? unknown : Result, Path, "PUT", Query, Body>>;
-    patch: <Result, Path extends string, Query extends AnyQueryDefinition = {}, Body extends Parsable = never>(path: Path, route: ((arg: RouteArgument<Path, ContextTo, { [Key in keyof Query]: InferParsable<Query[Key]>["output"]; }, InferParsable<Body>["output"]>) => Promise<Result>) | Omit<Route<ContextFrom, ContextTo, Result, Path, "PATCH", Query, Body>, "path" | "method" | "through">) => Router<ContextFrom, ContextTo, R | Route<ContextFrom, ContextTo, Result extends Response ? unknown : Result, Path, "PATCH", Query, Body>>;
-    delete: <Result, Path extends string, Query extends AnyQueryDefinition = {}, Body extends Parsable = never>(path: Path, route: ((arg: RouteArgument<Path, ContextTo, { [Key in keyof Query]: InferParsable<Query[Key]>["output"]; }, InferParsable<Body>["output"]>) => Promise<Result>) | Omit<Route<ContextFrom, ContextTo, Result, Path, "DELETE", Query, Body>, "path" | "method" | "through">) => Router<ContextFrom, ContextTo, R | Route<ContextFrom, ContextTo, Result extends Response ? unknown : Result, Path, "DELETE", Query, Body>>;
-    head: <Result, Path extends string, Query extends AnyQueryDefinition = {}, Body extends Parsable = never>(path: Path, route: ((arg: RouteArgument<Path, ContextTo, { [Key in keyof Query]: InferParsable<Query[Key]>["output"]; }, InferParsable<Body>["output"]>) => Promise<Result>) | Omit<Route<ContextFrom, ContextTo, Result, Path, "HEAD", Query, Body>, "path" | "method" | "through">) => Router<ContextFrom, ContextTo, R | Route<ContextFrom, ContextTo, Result extends Response ? unknown : Result, Path, "HEAD", Query, Body>>;
-    options: <Result, Path extends string, Query extends AnyQueryDefinition = {}, Body extends Parsable = never>(path: Path, route: ((arg: RouteArgument<Path, ContextTo, { [Key in keyof Query]: InferParsable<Query[Key]>["output"]; }, InferParsable<Body>["output"]>) => Promise<Result>) | Omit<Route<ContextFrom, ContextTo, Result, Path, "OPTIONS", Query, Body>, "path" | "method" | "through">) => Router<ContextFrom, ContextTo, R | Route<ContextFrom, ContextTo, Result extends Response ? unknown : Result, Path, "OPTIONS", Query, Body>>;
+    get: <Result, Path extends string, Query extends AnyQueryDefinition = {}, Body extends Parsable = never>(path: Path, route: ((arg: RouteArgument<Path, ContextTo, { [Key in keyof Query]: InferParsable<Query[Key]>["output"]; }, InferParsable<Body>["output"]>) => Promise<Result>) | Omit<Route<ContextFrom, ContextTo, Result, Path, "GET", Query, Body>, "body" | "path" | "method" | "through">) => Router<ContextFrom, ContextTo, R | Route<ContextFrom, ContextTo, Result, Path, "GET", Query, Body>>;
+    post: <Result, Path extends string, Query extends AnyQueryDefinition = {}, Body extends Parsable = never>(path: Path, route: ((arg: RouteArgument<Path, ContextTo, { [Key in keyof Query]: InferParsable<Query[Key]>["output"]; }, InferParsable<Body>["output"]>) => Promise<Result>) | Omit<Route<ContextFrom, ContextTo, Result, Path, "POST", Query, Body>, "path" | "method" | "through">) => Router<ContextFrom, ContextTo, R | Route<ContextFrom, ContextTo, Result, Path, "POST", Query, Body>>;
+    put: <Result, Path extends string, Query extends AnyQueryDefinition = {}, Body extends Parsable = never>(path: Path, route: ((arg: RouteArgument<Path, ContextTo, { [Key in keyof Query]: InferParsable<Query[Key]>["output"]; }, InferParsable<Body>["output"]>) => Promise<Result>) | Omit<Route<ContextFrom, ContextTo, Result, Path, "PUT", Query, Body>, "path" | "method" | "through">) => Router<ContextFrom, ContextTo, R | Route<ContextFrom, ContextTo, Result, Path, "PUT", Query, Body>>;
+    patch: <Result, Path extends string, Query extends AnyQueryDefinition = {}, Body extends Parsable = never>(path: Path, route: ((arg: RouteArgument<Path, ContextTo, { [Key in keyof Query]: InferParsable<Query[Key]>["output"]; }, InferParsable<Body>["output"]>) => Promise<Result>) | Omit<Route<ContextFrom, ContextTo, Result, Path, "PATCH", Query, Body>, "path" | "method" | "through">) => Router<ContextFrom, ContextTo, R | Route<ContextFrom, ContextTo, Result, Path, "PATCH", Query, Body>>;
+    delete: <Result, Path extends string, Query extends AnyQueryDefinition = {}, Body extends Parsable = never>(path: Path, route: ((arg: RouteArgument<Path, ContextTo, { [Key in keyof Query]: InferParsable<Query[Key]>["output"]; }, InferParsable<Body>["output"]>) => Promise<Result>) | Omit<Route<ContextFrom, ContextTo, Result, Path, "DELETE", Query, Body>, "path" | "method" | "through">) => Router<ContextFrom, ContextTo, R | Route<ContextFrom, ContextTo, Result, Path, "DELETE", Query, Body>>;
+    head: <Result, Path extends string, Query extends AnyQueryDefinition = {}, Body extends Parsable = never>(path: Path, route: ((arg: RouteArgument<Path, ContextTo, { [Key in keyof Query]: InferParsable<Query[Key]>["output"]; }, InferParsable<Body>["output"]>) => Promise<Result>) | Omit<Route<ContextFrom, ContextTo, Result, Path, "HEAD", Query, Body>, "path" | "method" | "through">) => Router<ContextFrom, ContextTo, R | Route<ContextFrom, ContextTo, Result, Path, "HEAD", Query, Body>>;
+    options: <Result, Path extends string, Query extends AnyQueryDefinition = {}, Body extends Parsable = never>(path: Path, route: ((arg: RouteArgument<Path, ContextTo, { [Key in keyof Query]: InferParsable<Query[Key]>["output"]; }, InferParsable<Body>["output"]>) => Promise<Result>) | Omit<Route<ContextFrom, ContextTo, Result, Path, "OPTIONS", Query, Body>, "path" | "method" | "through">) => Router<ContextFrom, ContextTo, R | Route<ContextFrom, ContextTo, Result, Path, "OPTIONS", Query, Body>>;
     through: <NextContext>(transform: (context: ContextTo) => Promise<NextContext>) => Router<ContextFrom, NextContext, R>;
 }
 
@@ -114,6 +185,7 @@ type SuccessfulAPIResponse<T> = {
 };
 type APIResponse<T> = ErroredAPIResponse | SuccessfulAPIResponse<T>;
 type AnyResponse = APIResponse<unknown>;
+type MakeOptional<T, K extends keyof T> = T extends T ? Omit<T, K> & Partial<Pick<T, K>> : never;
 type ExtractRouteParams<T extends string> = string extends T ? Record<string, string> : T extends `${string}:${infer Param}/${infer Rest}` ? {
     [k in Param | keyof ExtractRouteParams<Rest>]: string;
 } : T extends `${string}:${infer Param}` ? {
@@ -172,4 +244,4 @@ type Route<ContextFrom, ContextTo, Result, Path extends string, Method extends K
 };
 type AnyRoute<ContextFrom = any, ContextTo = any> = Route<ContextFrom, ContextTo, any, any, any, AnyQueryDefinition, any>;
 
-export { type APIResponse, type After, type AnyQueryDefinition, type AnyResponse, type AnyRoute, type Before, type ErroredAPIResponse, type ExtractRouteParams, type GetContext, type InferParsable, type InferRoutes, KaitoError, type KaitoMethod, KaitoRequest, type Parsable, type Route, type RouteArgument, Router, type RouterState, type ServerConfig, type ServerConfigWithBefore, type SuccessfulAPIResponse, type Through, WrappedError, createKaitoHandler, createUtilities, parsable };
+export { type APIResponse, type AnyQueryDefinition, type AnyResponse, type AnyRoute, type Before, type ErroredAPIResponse, type ExtractRouteParams, type GetContext, type InferParsable, type InferRoutes, KaitoError, type KaitoMethod, KaitoRequest, type MakeOptional, type Parsable, type Route, type RouteArgument, Router, type RouterState, type ServerConfig, type SuccessfulAPIResponse, type Through, WrappedError, createKaitoHandler, createUtilities, parsable };

package/dist/index.js

@@ -74,6 +74,9 @@ var KaitoResponse = class {
     return this._headers;
   }
   status(status) {
+    if (status === void 0) {
+      return this._status;
+    }
     this._status = status;
     return this;
   }
@@ -200,10 +203,10 @@ var Router = class _Router {
       const request = new KaitoRequest(url, req);
       const response = new KaitoResponse();
       try {
-        const rootCtx = await server.getContext(request, response);
-        const ctx = await route.through(rootCtx);
         const body = route.body ? await route.body.parse(await req.json()) : void 0;
         const query = _Router.parseQuery(route.query, url);
+        const rootCtx = await server.getContext(request, response);
+        const ctx = await route.through(rootCtx);
         const result = await route.run({
           ctx,
           body,
@@ -211,6 +214,9 @@ var Router = class _Router {
           params
         });
         if (result instanceof Response) {
+          if (server.enableClientResponseHints) {
+            result.headers.set("x-kaito-is-response", "1");
+          }
           return result;
         }
         return response.toResponse({
@@ -256,20 +262,21 @@ var Router = class _Router {
 };
 
 // src/server.ts
-function createKaitoHandler(config) {
-  const match = config.router.freeze(config);
+function createKaitoHandler(userConfig) {
+  const config = {
+    enableClientResponseHints: true,
+    ...userConfig
+  };
+  const handle = config.router.freeze(config);
   return async (request) => {
-    let before = void 0;
     if (config.before) {
       const result = await config.before(request);
-      if (result instanceof Response) {
-        return result;
-      }
-      before = result;
+      if (result instanceof Response) return result;
     }
-    const response = await match(request);
-    if ("after" in config && config.after) {
-      await config.after(before, response);
+    const response = await handle(request);
+    if (config.transform) {
+      const result = await config.transform(request, response);
+      if (result instanceof Response) return result;
     }
     return response;
   };

package/dist/stream/stream.cjs

@@ -0,0 +1,110 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/stream/stream.ts
+var stream_exports = {};
+__export(stream_exports, {
+  KaitoSSEResponse: () => KaitoSSEResponse,
+  KaitoStreamResponse: () => KaitoStreamResponse,
+  SSEController: () => SSEController,
+  sse: () => sse,
+  sseEventToString: () => sseEventToString,
+  stream: () => stream
+});
+module.exports = __toCommonJS(stream_exports);
+var KaitoStreamResponse = class extends Response {
+  constructor(body) {
+    super(body, {
+      headers: {
+        "Content-Type": "text/event-stream",
+        "Cache-Control": "no-cache",
+        Connection: "keep-alive"
+      }
+    });
+  }
+  async *[Symbol.asyncIterator]() {
+    for await (const chunk of this.body) {
+      yield chunk;
+    }
+  }
+};
+var KaitoSSEResponse = class extends KaitoStreamResponse {
+};
+function stream(body) {
+  return new KaitoStreamResponse(new ReadableStream(body));
+}
+function sseEventToString(event) {
+  let result = "";
+  if (event.event) {
+    result += `event:${event.event}
+`;
+  }
+  if (event.id) {
+    result += `id:${event.id}
+`;
+  }
+  if (event.retry) {
+    result += `retry:${event.retry}
+`;
+  }
+  if (event.data) {
+    result += `data:${event.data}`;
+  }
+  return result;
+}
+var SSEController = class {
+  controller;
+  constructor(controller) {
+    this.controller = controller;
+  }
+  enqueue(event) {
+    this.controller.enqueue(sseEventToString(event) + "\n\n");
+  }
+  close() {
+    this.controller.close();
+  }
+};
+function sse(source) {
+  const start = source.start;
+  const pull = source.pull;
+  const cancel = source.cancel;
+  const readable = new ReadableStream({
+    ...cancel ? { cancel } : {},
+    ...start ? {
+      start: async (controller) => {
+        await start(new SSEController(controller));
+      }
+    } : {},
+    ...pull ? {
+      pull: async (controller) => {
+        await pull(new SSEController(controller));
+      }
+    } : {}
+  });
+  return new KaitoSSEResponse(readable);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  KaitoSSEResponse,
+  KaitoStreamResponse,
+  SSEController,
+  sse,
+  sseEventToString,
+  stream
+});

package/dist/stream/stream.d.cts

@@ -0,0 +1,35 @@
+declare class KaitoStreamResponse<T> extends Response {
+    constructor(body: ReadableStream<T>);
+    [Symbol.asyncIterator](): AsyncGenerator<Uint8Array<ArrayBufferLike>, void, unknown>;
+}
+declare class KaitoSSEResponse extends KaitoStreamResponse<string> {
+}
+declare function stream<T = string>(body: UnderlyingDefaultSource<T>): KaitoStreamResponse<T>;
+type SSEEvent = ({
+    data: string;
+    event: string;
+} | {
+    data: string;
+    event?: string | undefined;
+} | {
+    data?: string | undefined;
+    event: string;
+}) & {
+    retry?: number;
+    id?: string;
+};
+declare function sseEventToString(event: SSEEvent): string;
+declare class SSEController {
+    private readonly controller;
+    constructor(controller: ReadableStreamDefaultController<string>);
+    enqueue(event: SSEEvent): void;
+    close(): void;
+}
+interface SSESource {
+    cancel?: UnderlyingSourceCancelCallback;
+    start?(controller: SSEController): Promise<void>;
+    pull?(controller: SSEController): Promise<void>;
+}
+declare function sse(source: SSESource): KaitoSSEResponse;
+
+export { KaitoSSEResponse, KaitoStreamResponse, SSEController, type SSEEvent, type SSESource, sse, sseEventToString, stream };