@visulima/connect 3.0.25 → 3.0.26

package/CHANGELOG.md

@@ -1,3 +1,14 @@
+## @visulima/connect [3.0.26](https://github.com/visulima/visulima/compare/@visulima/connect@3.0.25...@visulima/connect@3.0.26) (2025-11-12)
+
+### Bug Fixes
+
+* update package configurations and TypeScript definitions ([b59aa59](https://github.com/visulima/visulima/commit/b59aa59dac1508216b944f4b917fb4a7ab1f70a4))
+
+### Miscellaneous Chores
+
+* Add jsr file to all packages for release ([#565](https://github.com/visulima/visulima/issues/565)) ([ec91652](https://github.com/visulima/visulima/commit/ec91652b4e4112adf14ba152c1239a7703ba425a))
+* update license files and clean up TypeScript definitions ([fe668cc](https://github.com/visulima/visulima/commit/fe668cc26de23591d4df54a0954455ebbe31b22d))
+
 ## @visulima/connect [3.0.25](https://github.com/visulima/visulima/compare/@visulima/connect@3.0.24...@visulima/connect@3.0.25) (2025-11-07)
 
 ### Bug Fixes

package/dist/adapter/express.d.cts

@@ -0,0 +1,7 @@
+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?: any) => 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

@@ -0,0 +1,7 @@
+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?: any) => 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

@@ -0,0 +1,7 @@
+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?: any) => 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

@@ -0,0 +1,8 @@
+import type { ZodObject } from "zod";
+import type { Nextable, NextHandler } from "../types.d.d.cts";
+declare const withZod: <Request, Response, Handler extends Nextable<any>, Schema extends ZodObject<{
+    body?: ZodObject<any>;
+    headers?: ZodObject<any>;
+    query?: ZodObject<any>;
+}>>(schema: Schema, handler: Handler) => (request: Request, response: Response, next: NextHandler) => Promise<Response>;
+export = withZod;

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

@@ -0,0 +1,8 @@
+import type { ZodObject } from "zod";
+import type { Nextable, NextHandler } from "../types.d.d.mts";
+declare const withZod: <Request, Response, Handler extends Nextable<any>, Schema extends ZodObject<{
+    body?: ZodObject<any>;
+    headers?: ZodObject<any>;
+    query?: ZodObject<any>;
+}>>(schema: Schema, handler: Handler) => (request: Request, response: Response, next: NextHandler) => Promise<Response>;
+export default withZod;

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

@@ -0,0 +1,8 @@
+import type { ZodObject } from "zod";
+import type { Nextable, NextHandler } from "../types.d.d.ts";
+declare const withZod: <Request, Response, Handler extends Nextable<any>, Schema extends ZodObject<{
+    body?: ZodObject<any>;
+    headers?: ZodObject<any>;
+    query?: ZodObject<any>;
+}>>(schema: Schema, handler: Handler) => (request: Request, response: Response, next: NextHandler) => Promise<Response>;
+export = withZod;

package/dist/edge.d.cts

@@ -0,0 +1,30 @@
+import type { ZodObject } 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 | void>;
+export declare class EdgeRouter<R extends Request = Request, Context = unknown, RResponse extends Response = Response, Schema extends ZodObject<any> = ZodObject<any>> {
+    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<any> | ReturnType<FunctionLike> | ValueOrPromise<RResponse>;
+    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;
+    private prepareRequest;
+}
+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

@@ -0,0 +1,30 @@
+import type { ZodObject } 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 | void>;
+export declare class EdgeRouter<R extends Request = Request, Context = unknown, RResponse extends Response = Response, Schema extends ZodObject<any> = ZodObject<any>> {
+    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<any> | ReturnType<FunctionLike> | ValueOrPromise<RResponse>;
+    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;
+    private prepareRequest;
+}
+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

@@ -0,0 +1,30 @@
+import type { ZodObject } 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 | void>;
+export declare class EdgeRouter<R extends Request = Request, Context = unknown, RResponse extends Response = Response, Schema extends ZodObject<any> = ZodObject<any>> {
+    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<any> | ReturnType<FunctionLike> | ValueOrPromise<RResponse>;
+    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;
+    private prepareRequest;
+}
+export declare const createEdgeRouter: <R extends Request, Context>(options?: HandlerOptions<RoutesExtendedRequestHandler<R, Context, Response, Route<Nextable<FunctionLike>>[]>>) => EdgeRouter<R, Context>;

package/dist/index.d.cts

@@ -1,128 +1,12 @@
-import { IncomingMessage, ServerResponse } from 'node:http';
-import { ZodObject } from 'zod';
-
-type HttpMethod = "CONNECT" | "DELETE" | "GET" | "HEAD" | "OPTIONS" | "PATCH" | "POST" | "PUT" | "TRACE";
-
-type FunctionLike = (...arguments_: any[]) => any;
-
-type RouteMatch = RegExp | string;
-
-type ValueOrPromise<T> = Promise<T> | T;
-
-type NextHandler = () => ValueOrPromise<any>;
-
-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,
-    // eslint-disable-next-line @typescript-eslint/no-invalid-void-type
-) => ValueOrPromise<RResponse | void>;
-
-interface HandlerOptions<Handler extends FunctionLike> {
-    onError?: (error: unknown, ...arguments_: Parameters<Handler>) => ReturnType<Handler>;
-    onNoMatch?: Handler;
-}
-
-type RouteShortcutMethod<This, Schema extends 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<any>;
-    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 ZodObject<any> = ZodObject<never>> {
-    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;
-    private prepareRequest;
-}
-declare const createRouter: <Request extends IncomingMessage, Response extends ServerResponse, Schema extends ZodObject<any> = ZodObject<{
-    body?: ZodObject<any>;
-    headers?: ZodObject<any>;
-    query?: ZodObject<any>;
-}>>(options?: HandlerOptions<RoutesExtendedRequestHandler<Request, Response, Response, Route<Nextable<FunctionLike>>[]>>) => NodeRouter<Request, Response, Schema>;
-
-type NextFunction = (error?: any) => 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: <Request, Response, Handler extends Nextable<any>, Schema extends ZodObject<{
-    body?: ZodObject<any>;
-    headers?: ZodObject<any>;
-    query?: ZodObject<any>;
-}>>(schema: Schema, handler: Handler) => (request: Request, response: Response, next: NextHandler) => Promise<Response>;
-
-type RequestHandler<R extends Request, Context> = (request: R, context_: Context) => ValueOrPromise<Response | void>;
-declare class EdgeRouter<R extends Request = Request, Context = unknown, RResponse extends Response = Response, Schema extends ZodObject<any> = ZodObject<any>> {
-    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<any> | ReturnType<FunctionLike> | ValueOrPromise<RResponse>;
-    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;
-    private prepareRequest;
-}
-declare const createEdgeRouter: <R extends Request, Context>(options?: HandlerOptions<RoutesExtendedRequestHandler<R, Context, Response, Route<Nextable<FunctionLike>>[]>>) => EdgeRouter<R, Context>;
-
-declare const sendJson: (response: ServerResponse, statusCode: number, jsonBody: unknown) => void;
-
-export { EdgeRouter, NodeRouter, Router, createEdgeRouter, createRouter as createNodeRouter, createRouter, expressWrapper, sendJson, withZod };
-export type { RequestHandler as EdgeRequestHandler, ExpressRequestHandler, FindResult, FunctionLike, HandlerOptions, HttpMethod, NextHandler, Nextable, RequestHandler$1 as NodeRequestHandler, Route, RouteShortcutMethod, ValueOrPromise };
+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";

package/dist/index.d.mts

@@ -1,128 +1,12 @@
-import { IncomingMessage, ServerResponse } from 'node:http';
-import { ZodObject } from 'zod';
-
-type HttpMethod = "CONNECT" | "DELETE" | "GET" | "HEAD" | "OPTIONS" | "PATCH" | "POST" | "PUT" | "TRACE";
-
-type FunctionLike = (...arguments_: any[]) => any;
-
-type RouteMatch = RegExp | string;
-
-type ValueOrPromise<T> = Promise<T> | T;
-
-type NextHandler = () => ValueOrPromise<any>;
-
-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,
-    // eslint-disable-next-line @typescript-eslint/no-invalid-void-type
-) => ValueOrPromise<RResponse | void>;
-
-interface HandlerOptions<Handler extends FunctionLike> {
-    onError?: (error: unknown, ...arguments_: Parameters<Handler>) => ReturnType<Handler>;
-    onNoMatch?: Handler;
-}
-
-type RouteShortcutMethod<This, Schema extends 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<any>;
-    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 ZodObject<any> = ZodObject<never>> {
-    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;
-    private prepareRequest;
-}
-declare const createRouter: <Request extends IncomingMessage, Response extends ServerResponse, Schema extends ZodObject<any> = ZodObject<{
-    body?: ZodObject<any>;
-    headers?: ZodObject<any>;
-    query?: ZodObject<any>;
-}>>(options?: HandlerOptions<RoutesExtendedRequestHandler<Request, Response, Response, Route<Nextable<FunctionLike>>[]>>) => NodeRouter<Request, Response, Schema>;
-
-type NextFunction = (error?: any) => 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: <Request, Response, Handler extends Nextable<any>, Schema extends ZodObject<{
-    body?: ZodObject<any>;
-    headers?: ZodObject<any>;
-    query?: ZodObject<any>;
-}>>(schema: Schema, handler: Handler) => (request: Request, response: Response, next: NextHandler) => Promise<Response>;
-
-type RequestHandler<R extends Request, Context> = (request: R, context_: Context) => ValueOrPromise<Response | void>;
-declare class EdgeRouter<R extends Request = Request, Context = unknown, RResponse extends Response = Response, Schema extends ZodObject<any> = ZodObject<any>> {
-    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<any> | ReturnType<FunctionLike> | ValueOrPromise<RResponse>;
-    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;
-    private prepareRequest;
-}
-declare const createEdgeRouter: <R extends Request, Context>(options?: HandlerOptions<RoutesExtendedRequestHandler<R, Context, Response, Route<Nextable<FunctionLike>>[]>>) => EdgeRouter<R, Context>;
-
-declare const sendJson: (response: ServerResponse, statusCode: number, jsonBody: unknown) => void;
-
-export { EdgeRouter, NodeRouter, Router, createEdgeRouter, createRouter as createNodeRouter, createRouter, expressWrapper, sendJson, withZod };
-export type { RequestHandler as EdgeRequestHandler, ExpressRequestHandler, FindResult, FunctionLike, HandlerOptions, HttpMethod, NextHandler, Nextable, RequestHandler$1 as NodeRequestHandler, Route, RouteShortcutMethod, ValueOrPromise };
+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";

package/dist/index.d.ts

@@ -1,128 +1,12 @@
-import { IncomingMessage, ServerResponse } from 'node:http';
-import { ZodObject } from 'zod';
-
-type HttpMethod = "CONNECT" | "DELETE" | "GET" | "HEAD" | "OPTIONS" | "PATCH" | "POST" | "PUT" | "TRACE";
-
-type FunctionLike = (...arguments_: any[]) => any;
-
-type RouteMatch = RegExp | string;
-
-type ValueOrPromise<T> = Promise<T> | T;
-
-type NextHandler = () => ValueOrPromise<any>;
-
-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,
-    // eslint-disable-next-line @typescript-eslint/no-invalid-void-type
-) => ValueOrPromise<RResponse | void>;
-
-interface HandlerOptions<Handler extends FunctionLike> {
-    onError?: (error: unknown, ...arguments_: Parameters<Handler>) => ReturnType<Handler>;
-    onNoMatch?: Handler;
-}
-
-type RouteShortcutMethod<This, Schema extends 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<any>;
-    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 ZodObject<any> = ZodObject<never>> {
-    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;
-    private prepareRequest;
-}
-declare const createRouter: <Request extends IncomingMessage, Response extends ServerResponse, Schema extends ZodObject<any> = ZodObject<{
-    body?: ZodObject<any>;
-    headers?: ZodObject<any>;
-    query?: ZodObject<any>;
-}>>(options?: HandlerOptions<RoutesExtendedRequestHandler<Request, Response, Response, Route<Nextable<FunctionLike>>[]>>) => NodeRouter<Request, Response, Schema>;
-
-type NextFunction = (error?: any) => 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: <Request, Response, Handler extends Nextable<any>, Schema extends ZodObject<{
-    body?: ZodObject<any>;
-    headers?: ZodObject<any>;
-    query?: ZodObject<any>;
-}>>(schema: Schema, handler: Handler) => (request: Request, response: Response, next: NextHandler) => Promise<Response>;
-
-type RequestHandler<R extends Request, Context> = (request: R, context_: Context) => ValueOrPromise<Response | void>;
-declare class EdgeRouter<R extends Request = Request, Context = unknown, RResponse extends Response = Response, Schema extends ZodObject<any> = ZodObject<any>> {
-    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<any> | ReturnType<FunctionLike> | ValueOrPromise<RResponse>;
-    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;
-    private prepareRequest;
-}
-declare const createEdgeRouter: <R extends Request, Context>(options?: HandlerOptions<RoutesExtendedRequestHandler<R, Context, Response, Route<Nextable<FunctionLike>>[]>>) => EdgeRouter<R, Context>;
-
-declare const sendJson: (response: ServerResponse, statusCode: number, jsonBody: unknown) => void;
-
-export { EdgeRouter, NodeRouter, Router, createEdgeRouter, createRouter as createNodeRouter, createRouter, expressWrapper, sendJson, withZod };
-export type { RequestHandler as EdgeRequestHandler, ExpressRequestHandler, FindResult, FunctionLike, HandlerOptions, HttpMethod, NextHandler, Nextable, RequestHandler$1 as NodeRequestHandler, Route, RouteShortcutMethod, ValueOrPromise };
+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";

package/dist/node.d.cts

@@ -0,0 +1,33 @@
+import type { IncomingMessage, ServerResponse } from "node:http";
+import type { ZodObject } 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 ZodObject<any> = ZodObject<never>> {
+    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;
+    private prepareRequest;
+}
+export declare const createRouter: <Request extends IncomingMessage, Response extends ServerResponse, Schema extends ZodObject<any> = ZodObject<{
+    body?: ZodObject<any>;
+    headers?: ZodObject<any>;
+    query?: ZodObject<any>;
+}>>(options?: HandlerOptions<RoutesExtendedRequestHandler<Request, Response, Response, Route<Nextable<FunctionLike>>[]>>) => NodeRouter<Request, Response, Schema>;

package/dist/node.d.mts

@@ -0,0 +1,33 @@
+import type { IncomingMessage, ServerResponse } from "node:http";
+import type { ZodObject } 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 ZodObject<any> = ZodObject<never>> {
+    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;
+    private prepareRequest;
+}
+export declare const createRouter: <Request extends IncomingMessage, Response extends ServerResponse, Schema extends ZodObject<any> = ZodObject<{
+    body?: ZodObject<any>;
+    headers?: ZodObject<any>;
+    query?: ZodObject<any>;
+}>>(options?: HandlerOptions<RoutesExtendedRequestHandler<Request, Response, Response, Route<Nextable<FunctionLike>>[]>>) => NodeRouter<Request, Response, Schema>;

package/dist/node.d.ts

@@ -0,0 +1,33 @@
+import type { IncomingMessage, ServerResponse } from "node:http";
+import type { ZodObject } 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 ZodObject<any> = ZodObject<never>> {
+    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;
+    private prepareRequest;
+}
+export declare const createRouter: <Request extends IncomingMessage, Response extends ServerResponse, Schema extends ZodObject<any> = ZodObject<{
+    body?: ZodObject<any>;
+    headers?: ZodObject<any>;
+    query?: ZodObject<any>;
+}>>(options?: HandlerOptions<RoutesExtendedRequestHandler<Request, Response, Response, Route<Nextable<FunctionLike>>[]>>) => NodeRouter<Request, Response, Schema>;

package/dist/router.d.cts

@@ -0,0 +1,21 @@
+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<any>;
+    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

@@ -0,0 +1,21 @@
+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<any>;
+    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

@@ -0,0 +1,21 @@
+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<any>;
+    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

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

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

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

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

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@visulima/connect",
-  "version": "3.0.25",
+  "version": "3.0.26",
   "description": "The minimal router and middleware layer for Next.js, Micro, Vercel, or Node.js http/http2 with support for zod validation.",
   "keywords": [
     "javascript",