@kaito-http/core 3.0.1 → 3.0.3

package/dist/cors/cors.cjs

@@ -0,0 +1,60 @@
+"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/cors/cors.ts
+var cors_exports = {};
+__export(cors_exports, {
+  experimental_createCORSTransform: () => experimental_createCORSTransform,
+  experimental_createOriginMatcher: () => experimental_createOriginMatcher
+});
+module.exports = __toCommonJS(cors_exports);
+function experimental_createOriginMatcher(origins) {
+  if (origins.length === 0) {
+    return () => false;
+  }
+  const source = origins.map((origin) => {
+    if (origin.startsWith("*.")) {
+      const escapedDomain = origin.slice(2).replace(/[.+?^${}()|[\]\\]/g, "\\$&");
+      return `^(?:https?://)[^.]+\\.${escapedDomain}$`;
+    } else {
+      const escapedOrigin = origin.replace(/[.+?^${}()|[\]\\]/g, "\\$&");
+      return `^${escapedOrigin}$`;
+    }
+  }).join("|");
+  const regex = new RegExp(source);
+  return (origin) => regex.test(origin);
+}
+function experimental_createCORSTransform(origins) {
+  const matcher = experimental_createOriginMatcher(origins);
+  return (request, response) => {
+    const origin = request.headers.get("Origin");
+    if (origin && matcher(origin)) {
+      response.headers.set("Access-Control-Allow-Origin", origin);
+      response.headers.set("Access-Control-Allow-Methods", "GET, POST, PUT, DELETE, OPTIONS");
+      response.headers.set("Access-Control-Allow-Headers", "Content-Type, Authorization");
+      response.headers.set("Access-Control-Max-Age", "86400");
+      response.headers.set("Access-Control-Allow-Credentials", "true");
+    }
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  experimental_createCORSTransform,
+  experimental_createOriginMatcher
+});

package/dist/cors/cors.d.cts

@@ -0,0 +1,55 @@
+/**
+ * Creates a function that matches origins against a predefined set of patterns, supporting wildcards.
+ * The matcher handles both exact matches and wildcard subdomain patterns (e.g., '*.example.com').
+ *
+ * **⚠️ This API is experimental and may change or even be removed in the future. ⚠️**
+ *
+ * @param origins Array of origin patterns to match against.
+ * Patterns can be exact origins (e.g., 'https://example.com') or wildcard patterns (e.g., '*.example.com') that match subdomains.
+ * @returns A function that tests if an origin matches any of the patterns
+ *
+ * @example
+ * ```typescript
+ * const allowedOrigins = [
+ *   'https://example.com',
+ *   '*.trusted-domain.com' // Won't match https://evil-domain.com, only subdomains
+ * ];
+ *
+ * const matcher = createOriginMatcher(allowedOrigins);
+ *
+ * // Exact match
+ * console.log(matcher('https://example.com')); // true
+ * console.log(matcher('http://example.com')); // false
+ *
+ * // Wildcard subdomain matches
+ * console.log(matcher('https://app.trusted-domain.com')); // true
+ * console.log(matcher('https://staging.trusted-domain.com')); // true
+ * console.log(matcher('https://trusted-domain.com')); // false, because it's not a subdomain
+ * console.log(matcher('https://evil-domain.com')); // false
+ * ```
+ */
+declare function experimental_createOriginMatcher(origins: string[]): (origin: string) => boolean;
+/**
+ * Create a function to apply CORS headers with sane defaults for most apps.
+ *
+ * **⚠️ This API is experimental and may change or even be removed in the future. ⚠️**
+ *
+ * @param options Options object
+ * @returns A function that will mutate the Response object by applying the CORS headers
+ * @example
+ * ```ts
+ * const cors = createCORSHandler({
+ *   origins: ['https://example.com', "*.allows-subdomains.com", "http://localhost:3000"],
+ * });
+ *
+ * const handler = createKaitoHandler({
+ *  // ...
+ *  transform: async (request, response) => {
+ *    cors(request, response);
+ *  }
+ * });
+ * ```
+ */
+declare function experimental_createCORSTransform(origins: string[]): (request: Request, response: Response) => void;
+
+export { experimental_createCORSTransform, experimental_createOriginMatcher };

package/dist/cors/cors.d.ts

@@ -0,0 +1,55 @@
+/**
+ * Creates a function that matches origins against a predefined set of patterns, supporting wildcards.
+ * The matcher handles both exact matches and wildcard subdomain patterns (e.g., '*.example.com').
+ *
+ * **⚠️ This API is experimental and may change or even be removed in the future. ⚠️**
+ *
+ * @param origins Array of origin patterns to match against.
+ * Patterns can be exact origins (e.g., 'https://example.com') or wildcard patterns (e.g., '*.example.com') that match subdomains.
+ * @returns A function that tests if an origin matches any of the patterns
+ *
+ * @example
+ * ```typescript
+ * const allowedOrigins = [
+ *   'https://example.com',
+ *   '*.trusted-domain.com' // Won't match https://evil-domain.com, only subdomains
+ * ];
+ *
+ * const matcher = createOriginMatcher(allowedOrigins);
+ *
+ * // Exact match
+ * console.log(matcher('https://example.com')); // true
+ * console.log(matcher('http://example.com')); // false
+ *
+ * // Wildcard subdomain matches
+ * console.log(matcher('https://app.trusted-domain.com')); // true
+ * console.log(matcher('https://staging.trusted-domain.com')); // true
+ * console.log(matcher('https://trusted-domain.com')); // false, because it's not a subdomain
+ * console.log(matcher('https://evil-domain.com')); // false
+ * ```
+ */
+declare function experimental_createOriginMatcher(origins: string[]): (origin: string) => boolean;
+/**
+ * Create a function to apply CORS headers with sane defaults for most apps.
+ *
+ * **⚠️ This API is experimental and may change or even be removed in the future. ⚠️**
+ *
+ * @param options Options object
+ * @returns A function that will mutate the Response object by applying the CORS headers
+ * @example
+ * ```ts
+ * const cors = createCORSHandler({
+ *   origins: ['https://example.com', "*.allows-subdomains.com", "http://localhost:3000"],
+ * });
+ *
+ * const handler = createKaitoHandler({
+ *  // ...
+ *  transform: async (request, response) => {
+ *    cors(request, response);
+ *  }
+ * });
+ * ```
+ */
+declare function experimental_createCORSTransform(origins: string[]): (request: Request, response: Response) => void;
+
+export { experimental_createCORSTransform, experimental_createOriginMatcher };

package/dist/cors/cors.js

@@ -0,0 +1,34 @@
+// src/cors/cors.ts
+function experimental_createOriginMatcher(origins) {
+  if (origins.length === 0) {
+    return () => false;
+  }
+  const source = origins.map((origin) => {
+    if (origin.startsWith("*.")) {
+      const escapedDomain = origin.slice(2).replace(/[.+?^${}()|[\]\\]/g, "\\$&");
+      return `^(?:https?://)[^.]+\\.${escapedDomain}$`;
+    } else {
+      const escapedOrigin = origin.replace(/[.+?^${}()|[\]\\]/g, "\\$&");
+      return `^${escapedOrigin}$`;
+    }
+  }).join("|");
+  const regex = new RegExp(source);
+  return (origin) => regex.test(origin);
+}
+function experimental_createCORSTransform(origins) {
+  const matcher = experimental_createOriginMatcher(origins);
+  return (request, response) => {
+    const origin = request.headers.get("Origin");
+    if (origin && matcher(origin)) {
+      response.headers.set("Access-Control-Allow-Origin", origin);
+      response.headers.set("Access-Control-Allow-Methods", "GET, POST, PUT, DELETE, OPTIONS");
+      response.headers.set("Access-Control-Allow-Headers", "Content-Type, Authorization");
+      response.headers.set("Access-Control-Max-Age", "86400");
+      response.headers.set("Access-Control-Allow-Credentials", "true");
+    }
+  };
+}
+export {
+  experimental_createCORSTransform,
+  experimental_createOriginMatcher
+};

package/dist/index.cjs

@@ -21,6 +21,7 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var index_exports = {};
 __export(index_exports, {
   KaitoError: () => KaitoError,
+  KaitoHead: () => KaitoHead,
   KaitoRequest: () => KaitoRequest,
   Router: () => Router,
   WrappedError: () => WrappedError,
@@ -77,44 +78,6 @@ function createKaitoHandler(config) {
   };
 }
 
-// src/request.ts
-var KaitoRequest = class {
-  url;
-  _request;
-  constructor(url, request) {
-    this._request = request;
-    this.url = url;
-  }
-  get headers() {
-    return this._request.headers;
-  }
-  get method() {
-    return this._request.method;
-  }
-  async arrayBuffer() {
-    return this._request.arrayBuffer();
-  }
-  async blob() {
-    return this._request.blob();
-  }
-  async formData() {
-    return this._request.formData();
-  }
-  async bytes() {
-    const buffer = await this.arrayBuffer();
-    return new Uint8Array(buffer);
-  }
-  async json() {
-    return this._request.json();
-  }
-  async text() {
-    return this._request.text();
-  }
-  get request() {
-    return this._request;
-  }
-};
-
 // src/head.ts
 var KaitoHead = class {
   _headers;
@@ -158,6 +121,44 @@ var KaitoHead = class {
   }
 };
 
+// src/request.ts
+var KaitoRequest = class {
+  url;
+  _request;
+  constructor(url, request) {
+    this._request = request;
+    this.url = url;
+  }
+  get headers() {
+    return this._request.headers;
+  }
+  get method() {
+    return this._request.method;
+  }
+  async arrayBuffer() {
+    return this._request.arrayBuffer();
+  }
+  async blob() {
+    return this._request.blob();
+  }
+  async formData() {
+    return this._request.formData();
+  }
+  async bytes() {
+    const buffer = await this.arrayBuffer();
+    return new Uint8Array(buffer);
+  }
+  async json() {
+    return this._request.json();
+  }
+  async text() {
+    return this._request.text();
+  }
+  get request() {
+    return this._request;
+  }
+};
+
 // src/util.ts
 var isNodeLikeDev = typeof process !== "undefined" && typeof process.env !== "undefined" && process.env.NODE_ENV === "development";
 function createUtilities(getContext) {
@@ -334,6 +335,7 @@ var Router = class _Router {
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   KaitoError,
+  KaitoHead,
   KaitoRequest,
   Router,
   WrappedError,

package/dist/index.d.cts

@@ -154,7 +154,7 @@ type Route<ContextFrom, ContextTo, Result, Path extends string, Method extends K
     method: Method;
     run(arg: RouteArgument<Path, ContextTo, {
         [Key in keyof Query]: InferParsable<Query[Key]>['output'];
-    }, InferParsable<Body>['output']>): Promise<Result>;
+    }, InferParsable<Body>['output']>): Promise<Result> | Result;
 };
 type AnyRoute<ContextFrom = any, ContextTo = any> = Route<ContextFrom, ContextTo, any, any, any, AnyQueryDefinition, any>;
 
@@ -175,13 +175,13 @@ declare class Router<ContextFrom, ContextTo, R extends AnyRoute> {
     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<HandlerConfig<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, 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>>;
+    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"]>) => Result | 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"]>) => Result | 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"]>) => Result | 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"]>) => Result | 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"]>) => Result | 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"]>) => Result | 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"]>) => Result | 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>(through: (context: ContextTo) => Promise<NextContext>) => Router<ContextFrom, NextContext, R>;
 }
 
@@ -228,7 +228,7 @@ type HandlerConfig<ContextFrom> = {
      * }
      * ```
      */
-    before?: (req: Request) => Promise<Response | void | undefined>;
+    before?: (req: Request) => Promise<Response | void | undefined> | Response | void | undefined;
     /**
      * Transforms the response before it is sent to the client. Very useful for settings headers like CORS.
      *
@@ -248,8 +248,8 @@ type HandlerConfig<ContextFrom> = {
      * }
      * ```
      */
-    transform?: (req: Request, res: Response) => Promise<Response | void | undefined>;
+    transform?: (req: Request, res: Response) => Promise<Response | void | undefined> | Response | void | undefined;
 };
 declare function createKaitoHandler<Context>(config: HandlerConfig<Context>): (request: Request) => Promise<Response>;
 
-export { type APIResponse, type AnyQueryDefinition, type AnyResponse, type AnyRoute, type ErroredAPIResponse, type ExtractRouteParams, type GetContext, type HandlerConfig, type InferParsable, type InferRoutes, KaitoError, type KaitoMethod, KaitoRequest, type MakeOptional, type Parsable, type Route, type RouteArgument, Router, type RouterState, type SuccessfulAPIResponse, type Through, WrappedError, createKaitoHandler, createUtilities, isNodeLikeDev, parsable };
+export { type APIResponse, type AnyQueryDefinition, type AnyResponse, type AnyRoute, type ErroredAPIResponse, type ExtractRouteParams, type GetContext, type HandlerConfig, type InferParsable, type InferRoutes, KaitoError, KaitoHead, type KaitoMethod, KaitoRequest, type MakeOptional, type Parsable, type Route, type RouteArgument, Router, type RouterState, type SuccessfulAPIResponse, type Through, WrappedError, createKaitoHandler, createUtilities, isNodeLikeDev, parsable };

package/dist/index.d.ts

@@ -154,7 +154,7 @@ type Route<ContextFrom, ContextTo, Result, Path extends string, Method extends K
     method: Method;
     run(arg: RouteArgument<Path, ContextTo, {
         [Key in keyof Query]: InferParsable<Query[Key]>['output'];
-    }, InferParsable<Body>['output']>): Promise<Result>;
+    }, InferParsable<Body>['output']>): Promise<Result> | Result;
 };
 type AnyRoute<ContextFrom = any, ContextTo = any> = Route<ContextFrom, ContextTo, any, any, any, AnyQueryDefinition, any>;
 
@@ -175,13 +175,13 @@ declare class Router<ContextFrom, ContextTo, R extends AnyRoute> {
     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<HandlerConfig<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, 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>>;
+    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"]>) => Result | 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"]>) => Result | 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"]>) => Result | 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"]>) => Result | 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"]>) => Result | 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"]>) => Result | 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"]>) => Result | 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>(through: (context: ContextTo) => Promise<NextContext>) => Router<ContextFrom, NextContext, R>;
 }
 
@@ -228,7 +228,7 @@ type HandlerConfig<ContextFrom> = {
      * }
      * ```
      */
-    before?: (req: Request) => Promise<Response | void | undefined>;
+    before?: (req: Request) => Promise<Response | void | undefined> | Response | void | undefined;
     /**
      * Transforms the response before it is sent to the client. Very useful for settings headers like CORS.
      *
@@ -248,8 +248,8 @@ type HandlerConfig<ContextFrom> = {
      * }
      * ```
      */
-    transform?: (req: Request, res: Response) => Promise<Response | void | undefined>;
+    transform?: (req: Request, res: Response) => Promise<Response | void | undefined> | Response | void | undefined;
 };
 declare function createKaitoHandler<Context>(config: HandlerConfig<Context>): (request: Request) => Promise<Response>;
 
-export { type APIResponse, type AnyQueryDefinition, type AnyResponse, type AnyRoute, type ErroredAPIResponse, type ExtractRouteParams, type GetContext, type HandlerConfig, type InferParsable, type InferRoutes, KaitoError, type KaitoMethod, KaitoRequest, type MakeOptional, type Parsable, type Route, type RouteArgument, Router, type RouterState, type SuccessfulAPIResponse, type Through, WrappedError, createKaitoHandler, createUtilities, isNodeLikeDev, parsable };
+export { type APIResponse, type AnyQueryDefinition, type AnyResponse, type AnyRoute, type ErroredAPIResponse, type ExtractRouteParams, type GetContext, type HandlerConfig, type InferParsable, type InferRoutes, KaitoError, KaitoHead, type KaitoMethod, KaitoRequest, type MakeOptional, type Parsable, type Route, type RouteArgument, Router, type RouterState, type SuccessfulAPIResponse, type Through, WrappedError, createKaitoHandler, createUtilities, isNodeLikeDev, parsable };

package/dist/index.js

@@ -44,44 +44,6 @@ function createKaitoHandler(config) {
   };
 }
 
-// src/request.ts
-var KaitoRequest = class {
-  url;
-  _request;
-  constructor(url, request) {
-    this._request = request;
-    this.url = url;
-  }
-  get headers() {
-    return this._request.headers;
-  }
-  get method() {
-    return this._request.method;
-  }
-  async arrayBuffer() {
-    return this._request.arrayBuffer();
-  }
-  async blob() {
-    return this._request.blob();
-  }
-  async formData() {
-    return this._request.formData();
-  }
-  async bytes() {
-    const buffer = await this.arrayBuffer();
-    return new Uint8Array(buffer);
-  }
-  async json() {
-    return this._request.json();
-  }
-  async text() {
-    return this._request.text();
-  }
-  get request() {
-    return this._request;
-  }
-};
-
 // src/head.ts
 var KaitoHead = class {
   _headers;
@@ -125,6 +87,44 @@ var KaitoHead = class {
   }
 };
 
+// src/request.ts
+var KaitoRequest = class {
+  url;
+  _request;
+  constructor(url, request) {
+    this._request = request;
+    this.url = url;
+  }
+  get headers() {
+    return this._request.headers;
+  }
+  get method() {
+    return this._request.method;
+  }
+  async arrayBuffer() {
+    return this._request.arrayBuffer();
+  }
+  async blob() {
+    return this._request.blob();
+  }
+  async formData() {
+    return this._request.formData();
+  }
+  async bytes() {
+    const buffer = await this.arrayBuffer();
+    return new Uint8Array(buffer);
+  }
+  async json() {
+    return this._request.json();
+  }
+  async text() {
+    return this._request.text();
+  }
+  get request() {
+    return this._request;
+  }
+};
+
 // src/util.ts
 var isNodeLikeDev = typeof process !== "undefined" && typeof process.env !== "undefined" && process.env.NODE_ENV === "development";
 function createUtilities(getContext) {
@@ -300,6 +300,7 @@ var Router = class _Router {
 };
 export {
   KaitoError,
+  KaitoHead,
   KaitoRequest,
   Router,
   WrappedError,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kaito-http/core",
-  "version": "3.0.1",
+  "version": "3.0.3",
   "type": "module",
   "author": "Alistair Smith <hi@alistair.sh>",
   "description": "Functional HTTP Framework for TypeScript",
@@ -12,18 +12,16 @@
   "exports": {
     "./package.json": "./package.json",
     ".": {
-      "import": {
-        "types": "./src/index.ts",
-        "default": "./dist/index.js"
-      },
+      "import": "./dist/index.js",
       "require": "./dist/index.cjs"
     },
     "./stream": {
-      "import": {
-        "types": "./src/stream/stream.ts",
-        "default": "./dist/stream/stream.js"
-      },
+      "import": "./dist/stream/stream.js",
       "require": "./dist/stream/stream.cjs"
+    },
+    "./cors": {
+      "import": "./dist/cors/cors.js",
+      "require": "./dist/cors/cors.cjs"
     }
   },
   "homepage": "https://github.com/kaito-http/kaito",
@@ -43,8 +41,7 @@
   "files": [
     "package.json",
     "README.md",
-    "dist",
-    "src"
+    "dist"
   ],
   "bugs": {
     "url": "https://github.com/kaito-http/kaito/issues"

package/src/error.ts

@@ -1,26 +0,0 @@
-export class WrappedError<T> extends Error {
-	public static maybe<T>(maybeError: T) {
-		if (maybeError instanceof Error) {
-			return maybeError;
-		}
-
-		return WrappedError.from(maybeError);
-	}
-
-	public static from<T>(data: T) {
-		return new WrappedError(data);
-	}
-
-	private constructor(public readonly data: T) {
-		super('Something was thrown, but it was not an instance of Error, so a WrappedError was created.');
-	}
-}
-
-export class KaitoError extends Error {
-	constructor(
-		public readonly status: number,
-		message: string,
-	) {
-		super(message);
-	}
-}