@visulima/connect 4.0.0-alpha.10 → 4.0.0-alpha.12

package/CHANGELOG.md

@@ -1,3 +1,12 @@
+## @visulima/connect [4.0.0-alpha.12](https://github.com/visulima/visulima/compare/@visulima/connect@4.0.0-alpha.11...@visulima/connect@4.0.0-alpha.12) (2026-05-04)
+
+## @visulima/connect [4.0.0-alpha.11](https://github.com/visulima/visulima/compare/@visulima/connect@4.0.0-alpha.10...@visulima/connect@4.0.0-alpha.11) (2026-04-30)
+
+### Miscellaneous Chores
+
+* **connect:** upgrade packem to 2.0.0-alpha.76 ([7e3a33b](https://github.com/visulima/visulima/commit/7e3a33b6668284452fd51af3c99d2af3be2e61d5))
+* re-sort workspace package.json files via vis sort-package-json ([f625696](https://github.com/visulima/visulima/commit/f625696cfac974325774b3243e1a83c3d23acbd7))
+
 ## @visulima/connect [4.0.0-alpha.10](https://github.com/visulima/visulima/compare/@visulima/connect@4.0.0-alpha.9...@visulima/connect@4.0.0-alpha.10) (2026-04-22)
 
 ### Bug Fixes

package/dist/index.d.cts

@@ -1,12 +1,107 @@
-export type { ExpressRequestHandler } from "./adapter/express.d.cts";
-export { default as expressWrapper } from "./adapter/express.d.cts";
-export { default as withZod } from "./adapter/with-zod.d.cts";
-export type { RequestHandler as EdgeRequestHandler } from "./edge.d.cts";
-export { createEdgeRouter, EdgeRouter } from "./edge.d.cts";
-export type { RequestHandler as NodeRequestHandler } from "./node.d.cts";
-export { createRouter } from "./node.d.cts";
-export { createRouter as createNodeRouter, NodeRouter } from "./node.d.cts";
-export type { Route } from "./router.d.cts";
-export { Router } from "./router.d.cts";
-export type { FindResult, FunctionLike, HandlerOptions, HttpMethod, Nextable, NextHandler, RouteShortcutMethod, ValueOrPromise } from "./types.d.d.cts";
-export { default as sendJson } from "./utils/send-json.d.cts";
+import { IncomingMessage, ServerResponse } from 'node:http';
+import * as z from 'zod';
+type HttpMethod = "CONNECT" | "DELETE" | "GET" | "HEAD" | "OPTIONS" | "PATCH" | "POST" | "PUT" | "TRACE";
+// eslint-disable-next-line @typescript-eslint/no-explicit-any -- base function type requires `any` for variance compatibility
+type FunctionLike = (...arguments_: any[]) => any;
+type RouteMatch = RegExp | string;
+type ValueOrPromise<T> = Promise<T> | T;
+type NextHandler = () => ValueOrPromise<unknown>;
+// eslint-disable-next-line @typescript-eslint/no-explicit-any -- must return `any` to match arbitrary handler signatures
+type Nextable<H extends FunctionLike> = (...arguments_: [...Parameters<H>, NextHandler]) => ValueOrPromise<any>;
+interface FindResult<H extends FunctionLike> {
+  fns: Nextable<H>[];
+  middleOnly: boolean;
+  params: Record<string, string>;
+}
+type RoutesExtendedRequestHandler<Request extends object, Context, RResponse, Routes> = (request: Request, response: Context, routes: Routes) => ValueOrPromise<RResponse | undefined>;
+interface HandlerOptions<Handler extends FunctionLike> {
+  onError?: (error: unknown, ...arguments_: Parameters<Handler>) => ReturnType<Handler>;
+  onNoMatch?: Handler;
+}
+// eslint-disable-next-line @typescript-eslint/no-explicit-any -- ZodObject requires `any` for generic parameter compatibility
+type RouteShortcutMethod<This, Schema extends z.ZodObject<any>, H extends FunctionLike> = (route: Nextable<H> | RouteMatch, zodSchemaOrRouteOrFns?: Nextable<H> | RouteMatch | Schema | string, ...fns: Nextable<H>[]) => This;
+type Route<H> = {
+  fns: (H | Router<H extends FunctionLike ? H : never>)[];
+  isMiddleware: boolean;
+  method: HttpMethod | "";
+} & ({
+  keys: string[] | false;
+  pattern: RegExp;
+} | {
+  matchAll: true;
+});
+declare class Router<H extends FunctionLike> {
+  base: string;
+  routes: Route<Nextable<H>>[];
+  static exec<FL extends FunctionLike>(fns: (Nextable<FL> | undefined)[], ...arguments_: Parameters<FL>): Promise<unknown>;
+  private static extractRegExpParams;
+  private static extractKeyedParams;
+  private static isMethodMatch;
+  private static matchRoute;
+  private static resolveRouteFns;
+  constructor(base?: string, routes?: Route<Nextable<H>>[]);
+  add(method: HttpMethod | "", route: Nextable<H> | RouteMatch, ...fns: Nextable<H>[]): this;
+  clone(base?: string): Router<H>;
+  find(method: HttpMethod, pathname: string): FindResult<H>;
+  use(base: Nextable<H> | RouteMatch | Router<H>, ...fns: (Nextable<H> | Router<H>)[]): this;
+}
+type RequestHandler$1<Request extends IncomingMessage, Response extends ServerResponse> = (request: Request, response: Response) => ValueOrPromise<void>;
+declare class NodeRouter<Request extends IncomingMessage = IncomingMessage, Response extends ServerResponse = ServerResponse, Schema extends z.ZodObject<any> = z.ZodObject<any>> {
+  private static prepareRequest;
+  all: RouteShortcutMethod<this, Schema, RequestHandler$1<Request, Response>>;
+  connect: RouteShortcutMethod<this, Schema, RequestHandler$1<Request, Response>>;
+  delete: RouteShortcutMethod<this, Schema, RequestHandler$1<Request, Response>>;
+  get: RouteShortcutMethod<this, Schema, RequestHandler$1<Request, Response>>;
+  head: RouteShortcutMethod<this, Schema, RequestHandler$1<Request, Response>>;
+  options: RouteShortcutMethod<this, Schema, RequestHandler$1<Request, Response>>;
+  patch: RouteShortcutMethod<this, Schema, RequestHandler$1<Request, Response>>;
+  post: RouteShortcutMethod<this, Schema, RequestHandler$1<Request, Response>>;
+  put: RouteShortcutMethod<this, Schema, RequestHandler$1<Request, Response>>;
+  trace: RouteShortcutMethod<this, Schema, RequestHandler$1<Request, Response>>;
+  private readonly onError;
+  private readonly onNoMatch;
+  private router;
+  constructor(options?: HandlerOptions<RoutesExtendedRequestHandler<Request, Response, Response, Route<Nextable<FunctionLike>>[]>>);
+  clone(): NodeRouter<Request, Response, Schema>;
+  handler(): (request: Request, response: Response) => Promise<void>;
+  run(request: Request, response: Response): Promise<unknown>;
+  use(base: Nextable<RequestHandler$1<Request, Response>> | NodeRouter<Request, Response, Schema> | RouteMatch, ...fns: (Nextable<RequestHandler$1<Request, Response>> | NodeRouter<Request, Response, Schema>)[]): this;
+  private add;
+}
+declare const createRouter: <Request extends IncomingMessage, Response extends ServerResponse, Schema extends z.ZodObject<any> = z.ZodObject<any>>(options?: HandlerOptions<RoutesExtendedRequestHandler<Request, Response, Response, Route<Nextable<FunctionLike>>[]>>) => NodeRouter<Request, Response, Schema>;
+type NextFunction = (error?: Error) => void;
+declare const expressWrapper: <Request extends IncomingMessage, Response extends ServerResponse>(function_: ExpressRequestHandler<Request, Response>) => Nextable<RequestHandler$1<Request, Response>>;
+type ExpressRequestHandler<Request, Response> = (request: Request, response: Response, next: NextFunction) => void;
+declare const withZod: (schema: z.ZodObject<any>, handler: Nextable<FunctionLike>) => (request: unknown, response: unknown, next: NextHandler) => Promise<unknown>;
+type RequestHandler<R extends Request, Context> = (request: R, context_: Context) => ValueOrPromise<Response | undefined>;
+declare class EdgeRouter<R extends Request = Request, Context = unknown, RResponse extends Response = Response, Schema extends z.ZodObject<any> = z.ZodObject<any>> {
+  private static prepareRequest;
+  all: RouteShortcutMethod<this, Schema, RequestHandler<R, Context>>;
+  connect: RouteShortcutMethod<this, Schema, RequestHandler<R, Context>>;
+  delete: RouteShortcutMethod<this, Schema, RequestHandler<R, Context>>;
+  get: RouteShortcutMethod<this, Schema, RequestHandler<R, Context>>;
+  head: RouteShortcutMethod<this, Schema, RequestHandler<R, Context>>;
+  options: RouteShortcutMethod<this, Schema, RequestHandler<R, Context>>;
+  patch: RouteShortcutMethod<this, Schema, RequestHandler<R, Context>>;
+  post: RouteShortcutMethod<this, Schema, RequestHandler<R, Context>>;
+  put: RouteShortcutMethod<this, Schema, RequestHandler<R, Context>>;
+  trace: RouteShortcutMethod<this, Schema, RequestHandler<R, Context>>;
+  private readonly onError;
+  private readonly onNoMatch;
+  private router;
+  constructor(options?: HandlerOptions<RoutesExtendedRequestHandler<R, Context, RResponse, Route<Nextable<FunctionLike>>[]>>);
+  clone(): EdgeRouter<R, Context, RResponse, Schema>;
+  handler(): (request: R, context_: Context) => Promise<RResponse | undefined>;
+  run(request: R, context_: Context): Promise<unknown>;
+  use(base: EdgeRouter<R, Context> | Nextable<RequestHandler<R, Context>> | RouteMatch, ...fns: (EdgeRouter<R, Context> | Nextable<RequestHandler<R, Context>>)[]): this;
+  private add;
+}
+declare const createEdgeRouter: <R extends Request, Context>(options?: HandlerOptions<RoutesExtendedRequestHandler<R, Context, Response, Route<Nextable<FunctionLike>>[]>>) => EdgeRouter<R, Context>;
+/**
+* Send `JSON` object.
+* @param response Response object.
+* @param statusCode The HTTP status code.
+* @param jsonBody The body of data.
+*/
+declare const sendJson: (response: ServerResponse, statusCode: number, jsonBody: unknown) => void;
+export { type RequestHandler as EdgeRequestHandler, EdgeRouter, type ExpressRequestHandler, type FindResult, type FunctionLike, type HandlerOptions, type HttpMethod, type NextHandler, type Nextable, type RequestHandler$1 as NodeRequestHandler, NodeRouter, type Route, type RouteShortcutMethod, Router, type ValueOrPromise, createEdgeRouter, createRouter as createNodeRouter, createRouter, expressWrapper, sendJson, withZod };

package/dist/index.d.mts

@@ -1,12 +1,107 @@
-export type { ExpressRequestHandler } from "./adapter/express.d.mts";
-export { default as expressWrapper } from "./adapter/express.d.mts";
-export { default as withZod } from "./adapter/with-zod.d.mts";
-export type { RequestHandler as EdgeRequestHandler } from "./edge.d.mts";
-export { createEdgeRouter, EdgeRouter } from "./edge.d.mts";
-export type { RequestHandler as NodeRequestHandler } from "./node.d.mts";
-export { createRouter } from "./node.d.mts";
-export { createRouter as createNodeRouter, NodeRouter } from "./node.d.mts";
-export type { Route } from "./router.d.mts";
-export { Router } from "./router.d.mts";
-export type { FindResult, FunctionLike, HandlerOptions, HttpMethod, Nextable, NextHandler, RouteShortcutMethod, ValueOrPromise } from "./types.d.d.mts";
-export { default as sendJson } from "./utils/send-json.d.mts";
+import { IncomingMessage, ServerResponse } from 'node:http';
+import * as z from 'zod';
+type HttpMethod = "CONNECT" | "DELETE" | "GET" | "HEAD" | "OPTIONS" | "PATCH" | "POST" | "PUT" | "TRACE";
+// eslint-disable-next-line @typescript-eslint/no-explicit-any -- base function type requires `any` for variance compatibility
+type FunctionLike = (...arguments_: any[]) => any;
+type RouteMatch = RegExp | string;
+type ValueOrPromise<T> = Promise<T> | T;
+type NextHandler = () => ValueOrPromise<unknown>;
+// eslint-disable-next-line @typescript-eslint/no-explicit-any -- must return `any` to match arbitrary handler signatures
+type Nextable<H extends FunctionLike> = (...arguments_: [...Parameters<H>, NextHandler]) => ValueOrPromise<any>;
+interface FindResult<H extends FunctionLike> {
+  fns: Nextable<H>[];
+  middleOnly: boolean;
+  params: Record<string, string>;
+}
+type RoutesExtendedRequestHandler<Request extends object, Context, RResponse, Routes> = (request: Request, response: Context, routes: Routes) => ValueOrPromise<RResponse | undefined>;
+interface HandlerOptions<Handler extends FunctionLike> {
+  onError?: (error: unknown, ...arguments_: Parameters<Handler>) => ReturnType<Handler>;
+  onNoMatch?: Handler;
+}
+// eslint-disable-next-line @typescript-eslint/no-explicit-any -- ZodObject requires `any` for generic parameter compatibility
+type RouteShortcutMethod<This, Schema extends z.ZodObject<any>, H extends FunctionLike> = (route: Nextable<H> | RouteMatch, zodSchemaOrRouteOrFns?: Nextable<H> | RouteMatch | Schema | string, ...fns: Nextable<H>[]) => This;
+type Route<H> = {
+  fns: (H | Router<H extends FunctionLike ? H : never>)[];
+  isMiddleware: boolean;
+  method: HttpMethod | "";
+} & ({
+  keys: string[] | false;
+  pattern: RegExp;
+} | {
+  matchAll: true;
+});
+declare class Router<H extends FunctionLike> {
+  base: string;
+  routes: Route<Nextable<H>>[];
+  static exec<FL extends FunctionLike>(fns: (Nextable<FL> | undefined)[], ...arguments_: Parameters<FL>): Promise<unknown>;
+  private static extractRegExpParams;
+  private static extractKeyedParams;
+  private static isMethodMatch;
+  private static matchRoute;
+  private static resolveRouteFns;
+  constructor(base?: string, routes?: Route<Nextable<H>>[]);
+  add(method: HttpMethod | "", route: Nextable<H> | RouteMatch, ...fns: Nextable<H>[]): this;
+  clone(base?: string): Router<H>;
+  find(method: HttpMethod, pathname: string): FindResult<H>;
+  use(base: Nextable<H> | RouteMatch | Router<H>, ...fns: (Nextable<H> | Router<H>)[]): this;
+}
+type RequestHandler$1<Request extends IncomingMessage, Response extends ServerResponse> = (request: Request, response: Response) => ValueOrPromise<void>;
+declare class NodeRouter<Request extends IncomingMessage = IncomingMessage, Response extends ServerResponse = ServerResponse, Schema extends z.ZodObject<any> = z.ZodObject<any>> {
+  private static prepareRequest;
+  all: RouteShortcutMethod<this, Schema, RequestHandler$1<Request, Response>>;
+  connect: RouteShortcutMethod<this, Schema, RequestHandler$1<Request, Response>>;
+  delete: RouteShortcutMethod<this, Schema, RequestHandler$1<Request, Response>>;
+  get: RouteShortcutMethod<this, Schema, RequestHandler$1<Request, Response>>;
+  head: RouteShortcutMethod<this, Schema, RequestHandler$1<Request, Response>>;
+  options: RouteShortcutMethod<this, Schema, RequestHandler$1<Request, Response>>;
+  patch: RouteShortcutMethod<this, Schema, RequestHandler$1<Request, Response>>;
+  post: RouteShortcutMethod<this, Schema, RequestHandler$1<Request, Response>>;
+  put: RouteShortcutMethod<this, Schema, RequestHandler$1<Request, Response>>;
+  trace: RouteShortcutMethod<this, Schema, RequestHandler$1<Request, Response>>;
+  private readonly onError;
+  private readonly onNoMatch;
+  private router;
+  constructor(options?: HandlerOptions<RoutesExtendedRequestHandler<Request, Response, Response, Route<Nextable<FunctionLike>>[]>>);
+  clone(): NodeRouter<Request, Response, Schema>;
+  handler(): (request: Request, response: Response) => Promise<void>;
+  run(request: Request, response: Response): Promise<unknown>;
+  use(base: Nextable<RequestHandler$1<Request, Response>> | NodeRouter<Request, Response, Schema> | RouteMatch, ...fns: (Nextable<RequestHandler$1<Request, Response>> | NodeRouter<Request, Response, Schema>)[]): this;
+  private add;
+}
+declare const createRouter: <Request extends IncomingMessage, Response extends ServerResponse, Schema extends z.ZodObject<any> = z.ZodObject<any>>(options?: HandlerOptions<RoutesExtendedRequestHandler<Request, Response, Response, Route<Nextable<FunctionLike>>[]>>) => NodeRouter<Request, Response, Schema>;
+type NextFunction = (error?: Error) => void;
+declare const expressWrapper: <Request extends IncomingMessage, Response extends ServerResponse>(function_: ExpressRequestHandler<Request, Response>) => Nextable<RequestHandler$1<Request, Response>>;
+type ExpressRequestHandler<Request, Response> = (request: Request, response: Response, next: NextFunction) => void;
+declare const withZod: (schema: z.ZodObject<any>, handler: Nextable<FunctionLike>) => (request: unknown, response: unknown, next: NextHandler) => Promise<unknown>;
+type RequestHandler<R extends Request, Context> = (request: R, context_: Context) => ValueOrPromise<Response | undefined>;
+declare class EdgeRouter<R extends Request = Request, Context = unknown, RResponse extends Response = Response, Schema extends z.ZodObject<any> = z.ZodObject<any>> {
+  private static prepareRequest;
+  all: RouteShortcutMethod<this, Schema, RequestHandler<R, Context>>;
+  connect: RouteShortcutMethod<this, Schema, RequestHandler<R, Context>>;
+  delete: RouteShortcutMethod<this, Schema, RequestHandler<R, Context>>;
+  get: RouteShortcutMethod<this, Schema, RequestHandler<R, Context>>;
+  head: RouteShortcutMethod<this, Schema, RequestHandler<R, Context>>;
+  options: RouteShortcutMethod<this, Schema, RequestHandler<R, Context>>;
+  patch: RouteShortcutMethod<this, Schema, RequestHandler<R, Context>>;
+  post: RouteShortcutMethod<this, Schema, RequestHandler<R, Context>>;
+  put: RouteShortcutMethod<this, Schema, RequestHandler<R, Context>>;
+  trace: RouteShortcutMethod<this, Schema, RequestHandler<R, Context>>;
+  private readonly onError;
+  private readonly onNoMatch;
+  private router;
+  constructor(options?: HandlerOptions<RoutesExtendedRequestHandler<R, Context, RResponse, Route<Nextable<FunctionLike>>[]>>);
+  clone(): EdgeRouter<R, Context, RResponse, Schema>;
+  handler(): (request: R, context_: Context) => Promise<RResponse | undefined>;
+  run(request: R, context_: Context): Promise<unknown>;
+  use(base: EdgeRouter<R, Context> | Nextable<RequestHandler<R, Context>> | RouteMatch, ...fns: (EdgeRouter<R, Context> | Nextable<RequestHandler<R, Context>>)[]): this;
+  private add;
+}
+declare const createEdgeRouter: <R extends Request, Context>(options?: HandlerOptions<RoutesExtendedRequestHandler<R, Context, Response, Route<Nextable<FunctionLike>>[]>>) => EdgeRouter<R, Context>;
+/**
+* Send `JSON` object.
+* @param response Response object.
+* @param statusCode The HTTP status code.
+* @param jsonBody The body of data.
+*/
+declare const sendJson: (response: ServerResponse, statusCode: number, jsonBody: unknown) => void;
+export { type RequestHandler as EdgeRequestHandler, EdgeRouter, type ExpressRequestHandler, type FindResult, type FunctionLike, type HandlerOptions, type HttpMethod, type NextHandler, type Nextable, type RequestHandler$1 as NodeRequestHandler, NodeRouter, type Route, type RouteShortcutMethod, Router, type ValueOrPromise, createEdgeRouter, createRouter as createNodeRouter, createRouter, expressWrapper, sendJson, withZod };

package/dist/index.d.ts

@@ -1,12 +1,107 @@
-export type { ExpressRequestHandler } from "./adapter/express.d.ts";
-export { default as expressWrapper } from "./adapter/express.d.ts";
-export { default as withZod } from "./adapter/with-zod.d.ts";
-export type { RequestHandler as EdgeRequestHandler } from "./edge.d.ts";
-export { createEdgeRouter, EdgeRouter } from "./edge.d.ts";
-export type { RequestHandler as NodeRequestHandler } from "./node.d.ts";
-export { createRouter } from "./node.d.ts";
-export { createRouter as createNodeRouter, NodeRouter } from "./node.d.ts";
-export type { Route } from "./router.d.ts";
-export { Router } from "./router.d.ts";
-export type { FindResult, FunctionLike, HandlerOptions, HttpMethod, Nextable, NextHandler, RouteShortcutMethod, ValueOrPromise } from "./types.d.d.ts";
-export { default as sendJson } from "./utils/send-json.d.ts";
+import { IncomingMessage, ServerResponse } from 'node:http';
+import * as z from 'zod';
+type HttpMethod = "CONNECT" | "DELETE" | "GET" | "HEAD" | "OPTIONS" | "PATCH" | "POST" | "PUT" | "TRACE";
+// eslint-disable-next-line @typescript-eslint/no-explicit-any -- base function type requires `any` for variance compatibility
+type FunctionLike = (...arguments_: any[]) => any;
+type RouteMatch = RegExp | string;
+type ValueOrPromise<T> = Promise<T> | T;
+type NextHandler = () => ValueOrPromise<unknown>;
+// eslint-disable-next-line @typescript-eslint/no-explicit-any -- must return `any` to match arbitrary handler signatures
+type Nextable<H extends FunctionLike> = (...arguments_: [...Parameters<H>, NextHandler]) => ValueOrPromise<any>;
+interface FindResult<H extends FunctionLike> {
+  fns: Nextable<H>[];
+  middleOnly: boolean;
+  params: Record<string, string>;
+}
+type RoutesExtendedRequestHandler<Request extends object, Context, RResponse, Routes> = (request: Request, response: Context, routes: Routes) => ValueOrPromise<RResponse | undefined>;
+interface HandlerOptions<Handler extends FunctionLike> {
+  onError?: (error: unknown, ...arguments_: Parameters<Handler>) => ReturnType<Handler>;
+  onNoMatch?: Handler;
+}
+// eslint-disable-next-line @typescript-eslint/no-explicit-any -- ZodObject requires `any` for generic parameter compatibility
+type RouteShortcutMethod<This, Schema extends z.ZodObject<any>, H extends FunctionLike> = (route: Nextable<H> | RouteMatch, zodSchemaOrRouteOrFns?: Nextable<H> | RouteMatch | Schema | string, ...fns: Nextable<H>[]) => This;
+type Route<H> = {
+  fns: (H | Router<H extends FunctionLike ? H : never>)[];
+  isMiddleware: boolean;
+  method: HttpMethod | "";
+} & ({
+  keys: string[] | false;
+  pattern: RegExp;
+} | {
+  matchAll: true;
+});
+declare class Router<H extends FunctionLike> {
+  base: string;
+  routes: Route<Nextable<H>>[];
+  static exec<FL extends FunctionLike>(fns: (Nextable<FL> | undefined)[], ...arguments_: Parameters<FL>): Promise<unknown>;
+  private static extractRegExpParams;
+  private static extractKeyedParams;
+  private static isMethodMatch;
+  private static matchRoute;
+  private static resolveRouteFns;
+  constructor(base?: string, routes?: Route<Nextable<H>>[]);
+  add(method: HttpMethod | "", route: Nextable<H> | RouteMatch, ...fns: Nextable<H>[]): this;
+  clone(base?: string): Router<H>;
+  find(method: HttpMethod, pathname: string): FindResult<H>;
+  use(base: Nextable<H> | RouteMatch | Router<H>, ...fns: (Nextable<H> | Router<H>)[]): this;
+}
+type RequestHandler$1<Request extends IncomingMessage, Response extends ServerResponse> = (request: Request, response: Response) => ValueOrPromise<void>;
+declare class NodeRouter<Request extends IncomingMessage = IncomingMessage, Response extends ServerResponse = ServerResponse, Schema extends z.ZodObject<any> = z.ZodObject<any>> {
+  private static prepareRequest;
+  all: RouteShortcutMethod<this, Schema, RequestHandler$1<Request, Response>>;
+  connect: RouteShortcutMethod<this, Schema, RequestHandler$1<Request, Response>>;
+  delete: RouteShortcutMethod<this, Schema, RequestHandler$1<Request, Response>>;
+  get: RouteShortcutMethod<this, Schema, RequestHandler$1<Request, Response>>;
+  head: RouteShortcutMethod<this, Schema, RequestHandler$1<Request, Response>>;
+  options: RouteShortcutMethod<this, Schema, RequestHandler$1<Request, Response>>;
+  patch: RouteShortcutMethod<this, Schema, RequestHandler$1<Request, Response>>;
+  post: RouteShortcutMethod<this, Schema, RequestHandler$1<Request, Response>>;
+  put: RouteShortcutMethod<this, Schema, RequestHandler$1<Request, Response>>;
+  trace: RouteShortcutMethod<this, Schema, RequestHandler$1<Request, Response>>;
+  private readonly onError;
+  private readonly onNoMatch;
+  private router;
+  constructor(options?: HandlerOptions<RoutesExtendedRequestHandler<Request, Response, Response, Route<Nextable<FunctionLike>>[]>>);
+  clone(): NodeRouter<Request, Response, Schema>;
+  handler(): (request: Request, response: Response) => Promise<void>;
+  run(request: Request, response: Response): Promise<unknown>;
+  use(base: Nextable<RequestHandler$1<Request, Response>> | NodeRouter<Request, Response, Schema> | RouteMatch, ...fns: (Nextable<RequestHandler$1<Request, Response>> | NodeRouter<Request, Response, Schema>)[]): this;
+  private add;
+}
+declare const createRouter: <Request extends IncomingMessage, Response extends ServerResponse, Schema extends z.ZodObject<any> = z.ZodObject<any>>(options?: HandlerOptions<RoutesExtendedRequestHandler<Request, Response, Response, Route<Nextable<FunctionLike>>[]>>) => NodeRouter<Request, Response, Schema>;
+type NextFunction = (error?: Error) => void;
+declare const expressWrapper: <Request extends IncomingMessage, Response extends ServerResponse>(function_: ExpressRequestHandler<Request, Response>) => Nextable<RequestHandler$1<Request, Response>>;
+type ExpressRequestHandler<Request, Response> = (request: Request, response: Response, next: NextFunction) => void;
+declare const withZod: (schema: z.ZodObject<any>, handler: Nextable<FunctionLike>) => (request: unknown, response: unknown, next: NextHandler) => Promise<unknown>;
+type RequestHandler<R extends Request, Context> = (request: R, context_: Context) => ValueOrPromise<Response | undefined>;
+declare class EdgeRouter<R extends Request = Request, Context = unknown, RResponse extends Response = Response, Schema extends z.ZodObject<any> = z.ZodObject<any>> {
+  private static prepareRequest;
+  all: RouteShortcutMethod<this, Schema, RequestHandler<R, Context>>;
+  connect: RouteShortcutMethod<this, Schema, RequestHandler<R, Context>>;
+  delete: RouteShortcutMethod<this, Schema, RequestHandler<R, Context>>;
+  get: RouteShortcutMethod<this, Schema, RequestHandler<R, Context>>;
+  head: RouteShortcutMethod<this, Schema, RequestHandler<R, Context>>;
+  options: RouteShortcutMethod<this, Schema, RequestHandler<R, Context>>;
+  patch: RouteShortcutMethod<this, Schema, RequestHandler<R, Context>>;
+  post: RouteShortcutMethod<this, Schema, RequestHandler<R, Context>>;
+  put: RouteShortcutMethod<this, Schema, RequestHandler<R, Context>>;
+  trace: RouteShortcutMethod<this, Schema, RequestHandler<R, Context>>;
+  private readonly onError;
+  private readonly onNoMatch;
+  private router;
+  constructor(options?: HandlerOptions<RoutesExtendedRequestHandler<R, Context, RResponse, Route<Nextable<FunctionLike>>[]>>);
+  clone(): EdgeRouter<R, Context, RResponse, Schema>;
+  handler(): (request: R, context_: Context) => Promise<RResponse | undefined>;
+  run(request: R, context_: Context): Promise<unknown>;
+  use(base: EdgeRouter<R, Context> | Nextable<RequestHandler<R, Context>> | RouteMatch, ...fns: (EdgeRouter<R, Context> | Nextable<RequestHandler<R, Context>>)[]): this;
+  private add;
+}
+declare const createEdgeRouter: <R extends Request, Context>(options?: HandlerOptions<RoutesExtendedRequestHandler<R, Context, Response, Route<Nextable<FunctionLike>>[]>>) => EdgeRouter<R, Context>;
+/**
+* Send `JSON` object.
+* @param response Response object.
+* @param statusCode The HTTP status code.
+* @param jsonBody The body of data.
+*/
+declare const sendJson: (response: ServerResponse, statusCode: number, jsonBody: unknown) => void;
+export { type RequestHandler as EdgeRequestHandler, EdgeRouter, type ExpressRequestHandler, type FindResult, type FunctionLike, type HandlerOptions, type HttpMethod, type NextHandler, type Nextable, type RequestHandler$1 as NodeRequestHandler, NodeRouter, type Route, type RouteShortcutMethod, Router, type ValueOrPromise, createEdgeRouter, createRouter as createNodeRouter, createRouter, expressWrapper, sendJson, withZod };

package/package.json

@@ -1,18 +1,18 @@
 {
   "name": "@visulima/connect",
-  "version": "4.0.0-alpha.10",
+  "version": "4.0.0-alpha.12",
   "description": "The minimal router and middleware layer for Next.js, Micro, Vercel, or Node.js http/http2 with support for zod validation.",
   "keywords": [
-    "visulima",
+    "connect",
+    "http",
+    "http2",
     "javascript",
-    "nextjs",
     "middleware",
+    "nextjs",
+    "node",
     "router",
-    "connect",
     "vercel",
-    "node",
-    "http",
-    "http2",
+    "visulima",
     "zod"
   ],
   "homepage": "https://visulima.com/packages/connect/",
@@ -75,7 +75,7 @@
     "regexparam": "^3.0.0"
   },
   "peerDependencies": {
-    "zod": "4.3.6"
+    "zod": "4.4.3"
   },
   "engines": {
     "node": "^22.14.0 || >=24.10.0"

package/dist/adapter/express.d.cts

@@ -1,7 +0,0 @@
-import type { IncomingMessage, ServerResponse } from "node:http";
-import type { RequestHandler } from "../node.d.cts";
-import type { Nextable } from "../types.d.d.cts";
-type NextFunction = (error?: Error) => void;
-declare const expressWrapper: <Request extends IncomingMessage, Response extends ServerResponse>(function_: ExpressRequestHandler<Request, Response>) => Nextable<RequestHandler<Request, Response>>;
-export type ExpressRequestHandler<Request, Response> = (request: Request, response: Response, next: NextFunction) => void;
-export = expressWrapper;

package/dist/adapter/express.d.mts

@@ -1,7 +0,0 @@
-import type { IncomingMessage, ServerResponse } from "node:http";
-import type { RequestHandler } from "../node.d.mts";
-import type { Nextable } from "../types.d.d.mts";
-type NextFunction = (error?: Error) => void;
-declare const expressWrapper: <Request extends IncomingMessage, Response extends ServerResponse>(function_: ExpressRequestHandler<Request, Response>) => Nextable<RequestHandler<Request, Response>>;
-export type ExpressRequestHandler<Request, Response> = (request: Request, response: Response, next: NextFunction) => void;
-export default expressWrapper;

package/dist/adapter/express.d.ts

@@ -1,7 +0,0 @@
-import type { IncomingMessage, ServerResponse } from "node:http";
-import type { RequestHandler } from "../node.d.ts";
-import type { Nextable } from "../types.d.d.ts";
-type NextFunction = (error?: Error) => void;
-declare const expressWrapper: <Request extends IncomingMessage, Response extends ServerResponse>(function_: ExpressRequestHandler<Request, Response>) => Nextable<RequestHandler<Request, Response>>;
-export type ExpressRequestHandler<Request, Response> = (request: Request, response: Response, next: NextFunction) => void;
-export = expressWrapper;

package/dist/adapter/with-zod.d.cts

@@ -1,4 +0,0 @@
-import * as z from "zod";
-import type { FunctionLike, Nextable, NextHandler } from "../types.d.d.cts";
-declare const withZod: (schema: z.ZodObject<any>, handler: Nextable<FunctionLike>) => (request: unknown, response: unknown, next: NextHandler) => Promise<unknown>;
-export = withZod;

package/dist/adapter/with-zod.d.mts

@@ -1,4 +0,0 @@
-import * as z from "zod";
-import type { FunctionLike, Nextable, NextHandler } from "../types.d.d.mts";
-declare const withZod: (schema: z.ZodObject<any>, handler: Nextable<FunctionLike>) => (request: unknown, response: unknown, next: NextHandler) => Promise<unknown>;
-export default withZod;

package/dist/adapter/with-zod.d.ts

@@ -1,4 +0,0 @@
-import * as z from "zod";
-import type { FunctionLike, Nextable, NextHandler } from "../types.d.d.ts";
-declare const withZod: (schema: z.ZodObject<any>, handler: Nextable<FunctionLike>) => (request: unknown, response: unknown, next: NextHandler) => Promise<unknown>;
-export = withZod;

package/dist/edge.d.cts

@@ -1,30 +0,0 @@
-import type * as z from "zod";
-import type { Route } from "./router.d.cts";
-import type { FunctionLike, HandlerOptions, Nextable, RouteMatch, RoutesExtendedRequestHandler, RouteShortcutMethod, ValueOrPromise } from "./types.d.d.cts";
-export declare const getPathname: (request: Request & {
-    nextUrl?: URL;
-}) => string;
-export type RequestHandler<R extends Request, Context> = (request: R, context_: Context) => ValueOrPromise<Response | undefined>;
-export declare class EdgeRouter<R extends Request = Request, Context = unknown, RResponse extends Response = Response, Schema extends z.ZodObject<any> = z.ZodObject<any>> {
-    private static prepareRequest;
-    all: RouteShortcutMethod<this, Schema, RequestHandler<R, Context>>;
-    connect: RouteShortcutMethod<this, Schema, RequestHandler<R, Context>>;
-    delete: RouteShortcutMethod<this, Schema, RequestHandler<R, Context>>;
-    get: RouteShortcutMethod<this, Schema, RequestHandler<R, Context>>;
-    head: RouteShortcutMethod<this, Schema, RequestHandler<R, Context>>;
-    options: RouteShortcutMethod<this, Schema, RequestHandler<R, Context>>;
-    patch: RouteShortcutMethod<this, Schema, RequestHandler<R, Context>>;
-    post: RouteShortcutMethod<this, Schema, RequestHandler<R, Context>>;
-    put: RouteShortcutMethod<this, Schema, RequestHandler<R, Context>>;
-    trace: RouteShortcutMethod<this, Schema, RequestHandler<R, Context>>;
-    private readonly onError;
-    private readonly onNoMatch;
-    private router;
-    constructor(options?: HandlerOptions<RoutesExtendedRequestHandler<R, Context, RResponse, Route<Nextable<FunctionLike>>[]>>);
-    clone(): EdgeRouter<R, Context, RResponse, Schema>;
-    handler(): (request: R, context_: Context) => Promise<RResponse | undefined>;
-    run(request: R, context_: Context): Promise<unknown>;
-    use(base: EdgeRouter<R, Context> | Nextable<RequestHandler<R, Context>> | RouteMatch, ...fns: (EdgeRouter<R, Context> | Nextable<RequestHandler<R, Context>>)[]): this;
-    private add;
-}
-export declare const createEdgeRouter: <R extends Request, Context>(options?: HandlerOptions<RoutesExtendedRequestHandler<R, Context, Response, Route<Nextable<FunctionLike>>[]>>) => EdgeRouter<R, Context>;

package/dist/edge.d.mts

@@ -1,30 +0,0 @@
-import type * as z from "zod";
-import type { Route } from "./router.d.mts";
-import type { FunctionLike, HandlerOptions, Nextable, RouteMatch, RoutesExtendedRequestHandler, RouteShortcutMethod, ValueOrPromise } from "./types.d.d.mts";
-export declare const getPathname: (request: Request & {
-    nextUrl?: URL;
-}) => string;
-export type RequestHandler<R extends Request, Context> = (request: R, context_: Context) => ValueOrPromise<Response | undefined>;
-export declare class EdgeRouter<R extends Request = Request, Context = unknown, RResponse extends Response = Response, Schema extends z.ZodObject<any> = z.ZodObject<any>> {
-    private static prepareRequest;
-    all: RouteShortcutMethod<this, Schema, RequestHandler<R, Context>>;
-    connect: RouteShortcutMethod<this, Schema, RequestHandler<R, Context>>;
-    delete: RouteShortcutMethod<this, Schema, RequestHandler<R, Context>>;
-    get: RouteShortcutMethod<this, Schema, RequestHandler<R, Context>>;
-    head: RouteShortcutMethod<this, Schema, RequestHandler<R, Context>>;
-    options: RouteShortcutMethod<this, Schema, RequestHandler<R, Context>>;
-    patch: RouteShortcutMethod<this, Schema, RequestHandler<R, Context>>;
-    post: RouteShortcutMethod<this, Schema, RequestHandler<R, Context>>;
-    put: RouteShortcutMethod<this, Schema, RequestHandler<R, Context>>;
-    trace: RouteShortcutMethod<this, Schema, RequestHandler<R, Context>>;
-    private readonly onError;
-    private readonly onNoMatch;
-    private router;
-    constructor(options?: HandlerOptions<RoutesExtendedRequestHandler<R, Context, RResponse, Route<Nextable<FunctionLike>>[]>>);
-    clone(): EdgeRouter<R, Context, RResponse, Schema>;
-    handler(): (request: R, context_: Context) => Promise<RResponse | undefined>;
-    run(request: R, context_: Context): Promise<unknown>;
-    use(base: EdgeRouter<R, Context> | Nextable<RequestHandler<R, Context>> | RouteMatch, ...fns: (EdgeRouter<R, Context> | Nextable<RequestHandler<R, Context>>)[]): this;
-    private add;
-}
-export declare const createEdgeRouter: <R extends Request, Context>(options?: HandlerOptions<RoutesExtendedRequestHandler<R, Context, Response, Route<Nextable<FunctionLike>>[]>>) => EdgeRouter<R, Context>;

package/dist/edge.d.ts

@@ -1,30 +0,0 @@
-import type * as z from "zod";
-import type { Route } from "./router.d.ts";
-import type { FunctionLike, HandlerOptions, Nextable, RouteMatch, RoutesExtendedRequestHandler, RouteShortcutMethod, ValueOrPromise } from "./types.d.d.ts";
-export declare const getPathname: (request: Request & {
-    nextUrl?: URL;
-}) => string;
-export type RequestHandler<R extends Request, Context> = (request: R, context_: Context) => ValueOrPromise<Response | undefined>;
-export declare class EdgeRouter<R extends Request = Request, Context = unknown, RResponse extends Response = Response, Schema extends z.ZodObject<any> = z.ZodObject<any>> {
-    private static prepareRequest;
-    all: RouteShortcutMethod<this, Schema, RequestHandler<R, Context>>;
-    connect: RouteShortcutMethod<this, Schema, RequestHandler<R, Context>>;
-    delete: RouteShortcutMethod<this, Schema, RequestHandler<R, Context>>;
-    get: RouteShortcutMethod<this, Schema, RequestHandler<R, Context>>;
-    head: RouteShortcutMethod<this, Schema, RequestHandler<R, Context>>;
-    options: RouteShortcutMethod<this, Schema, RequestHandler<R, Context>>;
-    patch: RouteShortcutMethod<this, Schema, RequestHandler<R, Context>>;
-    post: RouteShortcutMethod<this, Schema, RequestHandler<R, Context>>;
-    put: RouteShortcutMethod<this, Schema, RequestHandler<R, Context>>;
-    trace: RouteShortcutMethod<this, Schema, RequestHandler<R, Context>>;
-    private readonly onError;
-    private readonly onNoMatch;
-    private router;
-    constructor(options?: HandlerOptions<RoutesExtendedRequestHandler<R, Context, RResponse, Route<Nextable<FunctionLike>>[]>>);
-    clone(): EdgeRouter<R, Context, RResponse, Schema>;
-    handler(): (request: R, context_: Context) => Promise<RResponse | undefined>;
-    run(request: R, context_: Context): Promise<unknown>;
-    use(base: EdgeRouter<R, Context> | Nextable<RequestHandler<R, Context>> | RouteMatch, ...fns: (EdgeRouter<R, Context> | Nextable<RequestHandler<R, Context>>)[]): this;
-    private add;
-}
-export declare const createEdgeRouter: <R extends Request, Context>(options?: HandlerOptions<RoutesExtendedRequestHandler<R, Context, Response, Route<Nextable<FunctionLike>>[]>>) => EdgeRouter<R, Context>;

package/dist/node.d.cts

@@ -1,29 +0,0 @@
-import type { IncomingMessage, ServerResponse } from "node:http";
-import type * as z from "zod";
-import type { Route } from "./router.d.cts";
-import type { FunctionLike, HandlerOptions, Nextable, RouteMatch, RoutesExtendedRequestHandler, RouteShortcutMethod, ValueOrPromise } from "./types.d.d.cts";
-export declare const getPathname: (url: string) => string;
-export type RequestHandler<Request extends IncomingMessage, Response extends ServerResponse> = (request: Request, response: Response) => ValueOrPromise<void>;
-export declare class NodeRouter<Request extends IncomingMessage = IncomingMessage, Response extends ServerResponse = ServerResponse, Schema extends z.ZodObject<any> = z.ZodObject<any>> {
-    private static prepareRequest;
-    all: RouteShortcutMethod<this, Schema, RequestHandler<Request, Response>>;
-    connect: RouteShortcutMethod<this, Schema, RequestHandler<Request, Response>>;
-    delete: RouteShortcutMethod<this, Schema, RequestHandler<Request, Response>>;
-    get: RouteShortcutMethod<this, Schema, RequestHandler<Request, Response>>;
-    head: RouteShortcutMethod<this, Schema, RequestHandler<Request, Response>>;
-    options: RouteShortcutMethod<this, Schema, RequestHandler<Request, Response>>;
-    patch: RouteShortcutMethod<this, Schema, RequestHandler<Request, Response>>;
-    post: RouteShortcutMethod<this, Schema, RequestHandler<Request, Response>>;
-    put: RouteShortcutMethod<this, Schema, RequestHandler<Request, Response>>;
-    trace: RouteShortcutMethod<this, Schema, RequestHandler<Request, Response>>;
-    private readonly onError;
-    private readonly onNoMatch;
-    private router;
-    constructor(options?: HandlerOptions<RoutesExtendedRequestHandler<Request, Response, Response, Route<Nextable<FunctionLike>>[]>>);
-    clone(): NodeRouter<Request, Response, Schema>;
-    handler(): (request: Request, response: Response) => Promise<void>;
-    run(request: Request, response: Response): Promise<unknown>;
-    use(base: Nextable<RequestHandler<Request, Response>> | NodeRouter<Request, Response, Schema> | RouteMatch, ...fns: (Nextable<RequestHandler<Request, Response>> | NodeRouter<Request, Response, Schema>)[]): this;
-    private add;
-}
-export declare const createRouter: <Request extends IncomingMessage, Response extends ServerResponse, Schema extends z.ZodObject<any> = z.ZodObject<any>>(options?: HandlerOptions<RoutesExtendedRequestHandler<Request, Response, Response, Route<Nextable<FunctionLike>>[]>>) => NodeRouter<Request, Response, Schema>;

package/dist/node.d.mts

@@ -1,29 +0,0 @@
-import type { IncomingMessage, ServerResponse } from "node:http";
-import type * as z from "zod";
-import type { Route } from "./router.d.mts";
-import type { FunctionLike, HandlerOptions, Nextable, RouteMatch, RoutesExtendedRequestHandler, RouteShortcutMethod, ValueOrPromise } from "./types.d.d.mts";
-export declare const getPathname: (url: string) => string;
-export type RequestHandler<Request extends IncomingMessage, Response extends ServerResponse> = (request: Request, response: Response) => ValueOrPromise<void>;
-export declare class NodeRouter<Request extends IncomingMessage = IncomingMessage, Response extends ServerResponse = ServerResponse, Schema extends z.ZodObject<any> = z.ZodObject<any>> {
-    private static prepareRequest;
-    all: RouteShortcutMethod<this, Schema, RequestHandler<Request, Response>>;
-    connect: RouteShortcutMethod<this, Schema, RequestHandler<Request, Response>>;
-    delete: RouteShortcutMethod<this, Schema, RequestHandler<Request, Response>>;
-    get: RouteShortcutMethod<this, Schema, RequestHandler<Request, Response>>;
-    head: RouteShortcutMethod<this, Schema, RequestHandler<Request, Response>>;
-    options: RouteShortcutMethod<this, Schema, RequestHandler<Request, Response>>;
-    patch: RouteShortcutMethod<this, Schema, RequestHandler<Request, Response>>;
-    post: RouteShortcutMethod<this, Schema, RequestHandler<Request, Response>>;
-    put: RouteShortcutMethod<this, Schema, RequestHandler<Request, Response>>;
-    trace: RouteShortcutMethod<this, Schema, RequestHandler<Request, Response>>;
-    private readonly onError;
-    private readonly onNoMatch;
-    private router;
-    constructor(options?: HandlerOptions<RoutesExtendedRequestHandler<Request, Response, Response, Route<Nextable<FunctionLike>>[]>>);
-    clone(): NodeRouter<Request, Response, Schema>;
-    handler(): (request: Request, response: Response) => Promise<void>;
-    run(request: Request, response: Response): Promise<unknown>;
-    use(base: Nextable<RequestHandler<Request, Response>> | NodeRouter<Request, Response, Schema> | RouteMatch, ...fns: (Nextable<RequestHandler<Request, Response>> | NodeRouter<Request, Response, Schema>)[]): this;
-    private add;
-}
-export declare const createRouter: <Request extends IncomingMessage, Response extends ServerResponse, Schema extends z.ZodObject<any> = z.ZodObject<any>>(options?: HandlerOptions<RoutesExtendedRequestHandler<Request, Response, Response, Route<Nextable<FunctionLike>>[]>>) => NodeRouter<Request, Response, Schema>;

package/dist/node.d.ts

@@ -1,29 +0,0 @@
-import type { IncomingMessage, ServerResponse } from "node:http";
-import type * as z from "zod";
-import type { Route } from "./router.d.ts";
-import type { FunctionLike, HandlerOptions, Nextable, RouteMatch, RoutesExtendedRequestHandler, RouteShortcutMethod, ValueOrPromise } from "./types.d.d.ts";
-export declare const getPathname: (url: string) => string;
-export type RequestHandler<Request extends IncomingMessage, Response extends ServerResponse> = (request: Request, response: Response) => ValueOrPromise<void>;
-export declare class NodeRouter<Request extends IncomingMessage = IncomingMessage, Response extends ServerResponse = ServerResponse, Schema extends z.ZodObject<any> = z.ZodObject<any>> {
-    private static prepareRequest;
-    all: RouteShortcutMethod<this, Schema, RequestHandler<Request, Response>>;
-    connect: RouteShortcutMethod<this, Schema, RequestHandler<Request, Response>>;
-    delete: RouteShortcutMethod<this, Schema, RequestHandler<Request, Response>>;
-    get: RouteShortcutMethod<this, Schema, RequestHandler<Request, Response>>;
-    head: RouteShortcutMethod<this, Schema, RequestHandler<Request, Response>>;
-    options: RouteShortcutMethod<this, Schema, RequestHandler<Request, Response>>;
-    patch: RouteShortcutMethod<this, Schema, RequestHandler<Request, Response>>;
-    post: RouteShortcutMethod<this, Schema, RequestHandler<Request, Response>>;
-    put: RouteShortcutMethod<this, Schema, RequestHandler<Request, Response>>;
-    trace: RouteShortcutMethod<this, Schema, RequestHandler<Request, Response>>;
-    private readonly onError;
-    private readonly onNoMatch;
-    private router;
-    constructor(options?: HandlerOptions<RoutesExtendedRequestHandler<Request, Response, Response, Route<Nextable<FunctionLike>>[]>>);
-    clone(): NodeRouter<Request, Response, Schema>;
-    handler(): (request: Request, response: Response) => Promise<void>;
-    run(request: Request, response: Response): Promise<unknown>;
-    use(base: Nextable<RequestHandler<Request, Response>> | NodeRouter<Request, Response, Schema> | RouteMatch, ...fns: (Nextable<RequestHandler<Request, Response>> | NodeRouter<Request, Response, Schema>)[]): this;
-    private add;
-}
-export declare const createRouter: <Request extends IncomingMessage, Response extends ServerResponse, Schema extends z.ZodObject<any> = z.ZodObject<any>>(options?: HandlerOptions<RoutesExtendedRequestHandler<Request, Response, Response, Route<Nextable<FunctionLike>>[]>>) => NodeRouter<Request, Response, Schema>;

package/dist/router.d.cts

@@ -1,26 +0,0 @@
-import type { FindResult, FunctionLike, HttpMethod, Nextable, RouteMatch } from "./types.d.d.cts";
-export type Route<H> = {
-    fns: (H | Router<H extends FunctionLike ? H : never>)[];
-    isMiddleware: boolean;
-    method: HttpMethod | "";
-} & ({
-    keys: string[] | false;
-    pattern: RegExp;
-} | {
-    matchAll: true;
-});
-export declare class Router<H extends FunctionLike> {
-    base: string;
-    routes: Route<Nextable<H>>[];
-    static exec<FL extends FunctionLike>(fns: (Nextable<FL> | undefined)[], ...arguments_: Parameters<FL>): Promise<unknown>;
-    private static extractRegExpParams;
-    private static extractKeyedParams;
-    private static isMethodMatch;
-    private static matchRoute;
-    private static resolveRouteFns;
-    constructor(base?: string, routes?: Route<Nextable<H>>[]);
-    add(method: HttpMethod | "", route: Nextable<H> | RouteMatch, ...fns: Nextable<H>[]): this;
-    clone(base?: string): Router<H>;
-    find(method: HttpMethod, pathname: string): FindResult<H>;
-    use(base: Nextable<H> | RouteMatch | Router<H>, ...fns: (Nextable<H> | Router<H>)[]): this;
-}

package/dist/router.d.mts

@@ -1,26 +0,0 @@
-import type { FindResult, FunctionLike, HttpMethod, Nextable, RouteMatch } from "./types.d.d.mts";
-export type Route<H> = {
-    fns: (H | Router<H extends FunctionLike ? H : never>)[];
-    isMiddleware: boolean;
-    method: HttpMethod | "";
-} & ({
-    keys: string[] | false;
-    pattern: RegExp;
-} | {
-    matchAll: true;
-});
-export declare class Router<H extends FunctionLike> {
-    base: string;
-    routes: Route<Nextable<H>>[];
-    static exec<FL extends FunctionLike>(fns: (Nextable<FL> | undefined)[], ...arguments_: Parameters<FL>): Promise<unknown>;
-    private static extractRegExpParams;
-    private static extractKeyedParams;
-    private static isMethodMatch;
-    private static matchRoute;
-    private static resolveRouteFns;
-    constructor(base?: string, routes?: Route<Nextable<H>>[]);
-    add(method: HttpMethod | "", route: Nextable<H> | RouteMatch, ...fns: Nextable<H>[]): this;
-    clone(base?: string): Router<H>;
-    find(method: HttpMethod, pathname: string): FindResult<H>;
-    use(base: Nextable<H> | RouteMatch | Router<H>, ...fns: (Nextable<H> | Router<H>)[]): this;
-}

package/dist/router.d.ts

@@ -1,26 +0,0 @@
-import type { FindResult, FunctionLike, HttpMethod, Nextable, RouteMatch } from "./types.d.d.ts";
-export type Route<H> = {
-    fns: (H | Router<H extends FunctionLike ? H : never>)[];
-    isMiddleware: boolean;
-    method: HttpMethod | "";
-} & ({
-    keys: string[] | false;
-    pattern: RegExp;
-} | {
-    matchAll: true;
-});
-export declare class Router<H extends FunctionLike> {
-    base: string;
-    routes: Route<Nextable<H>>[];
-    static exec<FL extends FunctionLike>(fns: (Nextable<FL> | undefined)[], ...arguments_: Parameters<FL>): Promise<unknown>;
-    private static extractRegExpParams;
-    private static extractKeyedParams;
-    private static isMethodMatch;
-    private static matchRoute;
-    private static resolveRouteFns;
-    constructor(base?: string, routes?: Route<Nextable<H>>[]);
-    add(method: HttpMethod | "", route: Nextable<H> | RouteMatch, ...fns: Nextable<H>[]): this;
-    clone(base?: string): Router<H>;
-    find(method: HttpMethod, pathname: string): FindResult<H>;
-    use(base: Nextable<H> | RouteMatch | Router<H>, ...fns: (Nextable<H> | Router<H>)[]): this;
-}

package/dist/utils/send-json.d.cts

@@ -1,9 +0,0 @@
-import type { ServerResponse } from "node:http";
-/**
- * Send `JSON` object.
- * @param response Response object.
- * @param statusCode The HTTP status code.
- * @param jsonBody The body of data.
- */
-declare const sendJson: (response: ServerResponse, statusCode: number, jsonBody: unknown) => void;
-export = sendJson;

package/dist/utils/send-json.d.mts

@@ -1,9 +0,0 @@
-import type { ServerResponse } from "node:http";
-/**
- * Send `JSON` object.
- * @param response Response object.
- * @param statusCode The HTTP status code.
- * @param jsonBody The body of data.
- */
-declare const sendJson: (response: ServerResponse, statusCode: number, jsonBody: unknown) => void;
-export default sendJson;

package/dist/utils/send-json.d.ts

@@ -1,9 +0,0 @@
-import type { ServerResponse } from "node:http";
-/**
- * Send `JSON` object.
- * @param response Response object.
- * @param statusCode The HTTP status code.
- * @param jsonBody The body of data.
- */
-declare const sendJson: (response: ServerResponse, statusCode: number, jsonBody: unknown) => void;
-export = sendJson;