@zudojs/http 0.1.0 → 1.0.0

package/dist/httpRouter/core/registry/httpRegistry.core.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Route registry implementation.
+ *
+ * @module httpRoute/registry/registry
+ */
+import type { RouteRegistryEntry, RouteRegistryOptions, RouteRegistrationOptions, RouteLookupOptions, RouteRegistrySnapshot } from "./core/httpRegistry.type.js";
+export declare class RouteRegistry {
+    private readonly routes;
+    private readonly options;
+    private version;
+    constructor(options?: RouteRegistryOptions);
+    register(path: string, method: string | readonly string[], handler: unknown, options?: RouteRegistrationOptions): void;
+    unregister(path: string, method: string): boolean;
+    lookup(path: string, options?: RouteLookupOptions): RouteRegistryEntry | undefined;
+    findAll(path: string, options?: RouteLookupOptions): readonly RouteRegistryEntry[];
+    has(path: string, method: string): boolean;
+    clear(): void;
+    snapshot(): RouteRegistrySnapshot;
+    get size(): number;
+    get version_number(): number;
+    private createKey;
+}
+//# sourceMappingURL=httpRegistry.core.d.ts.map

package/dist/httpRouter/core/registry/httpRegistry.core.js

@@ -0,0 +1,97 @@
+/**
+ * Route registry implementation.
+ *
+ * @module httpRoute/registry/registry
+ */
+import { normalizeMethod, normalizeMethods, normalizePath, matchesLookup, extractSequence, } from "./core/httpRegistry.helper.js";
+export class RouteRegistry {
+    routes = new Map();
+    options;
+    version = 0;
+    constructor(options = {}) {
+        this.options = {
+            caseSensitive: false,
+            strict: false,
+            end: true,
+            ...options,
+        };
+    }
+    register(path, method, handler, options = {}) {
+        const normalizedPath = normalizePath(path, this.options);
+        const methods = normalizeMethods(method);
+        for (const m of methods) {
+            const key = this.createKey(normalizedPath, m);
+            const entry = {
+                path: normalizedPath,
+                method: m,
+                handler,
+                options,
+                metadata: options.metadata ?? {},
+            };
+            this.routes.set(key, entry);
+            this.version++;
+        }
+    }
+    unregister(path, method) {
+        const normalizedPath = normalizePath(path, this.options);
+        const normalizedMethod = normalizeMethod(method);
+        const key = this.createKey(normalizedPath, normalizedMethod);
+        const existed = this.routes.delete(key);
+        if (existed) {
+            this.version++;
+        }
+        return existed;
+    }
+    lookup(path, options = {}) {
+        const normalizedPath = normalizePath(path, this.options);
+        const method = options.method ? normalizeMethod(options.method) : undefined;
+        for (const entry of this.routes.values()) {
+            if (matchesLookup(entry, normalizedPath, method, this.options)) {
+                return entry;
+            }
+        }
+        return undefined;
+    }
+    findAll(path, options = {}) {
+        const normalizedPath = normalizePath(path, this.options);
+        const method = options.method ? normalizeMethod(options.method) : undefined;
+        const results = [];
+        for (const entry of this.routes.values()) {
+            if (matchesLookup(entry, normalizedPath, method, this.options)) {
+                results.push(entry);
+            }
+        }
+        return results.sort((a, b) => {
+            const seqA = extractSequence(a.path);
+            const seqB = extractSequence(b.path);
+            return seqA - seqB;
+        });
+    }
+    has(path, method) {
+        return this.lookup(path, { method }) !== undefined;
+    }
+    clear() {
+        this.routes.clear();
+        this.version++;
+    }
+    snapshot() {
+        return {
+            routes: Array.from(this.routes.values()),
+            timestamp: Date.now(),
+            version: this.version,
+        };
+    }
+    get size() {
+        return this.routes.size;
+    }
+    get version_number() {
+        return this.version;
+    }
+    createKey(path, method) {
+        const caseSensitive = this.options.caseSensitive ?? false;
+        const normalizedPath = caseSensitive ? path : path.toLowerCase();
+        const normalizedMethod = caseSensitive ? method : method.toUpperCase();
+        return `${normalizedMethod}:${normalizedPath}`;
+    }
+}
+//# sourceMappingURL=httpRegistry.core.js.map

package/dist/httpRouter/core/registry/httpRegistry.factory.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Route registry factory functions.
+ *
+ * @module httpRoute/registry/factory
+ */
+import type { RouteRegistryOptions } from "./core/httpRegistry.type.js";
+import { RouteRegistry } from "./httpRegistry.core.js";
+import { RouteRegistryGroup } from "./httpRegistry.group.js";
+/**
+ * Creates a new route registry.
+ */
+export declare function createRouteRegistry(options?: RouteRegistryOptions): RouteRegistry;
+/**
+ * Creates a new route registry group.
+ */
+export declare function createRouteRegistryGroup(options?: RouteRegistryOptions): RouteRegistryGroup;
+/**
+ * Type guard for RouteRegistry.
+ */
+export declare function isRouteRegistry(value: unknown): value is RouteRegistry;
+/**
+ * Type guard for RouteRegistryGroup.
+ */
+export declare function isRouteRegistryGroup(value: unknown): value is RouteRegistryGroup;
+//# sourceMappingURL=httpRegistry.factory.d.ts.map

package/dist/httpRouter/core/registry/httpRegistry.factory.js

@@ -0,0 +1,32 @@
+/**
+ * Route registry factory functions.
+ *
+ * @module httpRoute/registry/factory
+ */
+import { RouteRegistry } from "./httpRegistry.core.js";
+import { RouteRegistryGroup } from "./httpRegistry.group.js";
+/**
+ * Creates a new route registry.
+ */
+export function createRouteRegistry(options = {}) {
+    return new RouteRegistry(options);
+}
+/**
+ * Creates a new route registry group.
+ */
+export function createRouteRegistryGroup(options = {}) {
+    return new RouteRegistryGroup(options);
+}
+/**
+ * Type guard for RouteRegistry.
+ */
+export function isRouteRegistry(value) {
+    return value instanceof RouteRegistry;
+}
+/**
+ * Type guard for RouteRegistryGroup.
+ */
+export function isRouteRegistryGroup(value) {
+    return value instanceof RouteRegistryGroup;
+}
+//# sourceMappingURL=httpRegistry.factory.js.map

package/dist/httpRouter/core/registry/httpRegistry.group.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Route registry group.
+ *
+ * @module httpRoute/registry/group
+ */
+import type { RouteRegistryEntry, RouteRegistryOptions, RouteRegistrationOptions, RouteLookupOptions } from "./core/httpRegistry.type.js";
+import { RouteRegistry } from "./httpRegistry.core.js";
+export declare class RouteRegistryGroup {
+    private readonly registries;
+    private readonly options;
+    constructor(options?: RouteRegistryOptions);
+    createGroup(name: string, options?: RouteRegistryOptions): RouteRegistry;
+    getGroup(name: string): RouteRegistry | undefined;
+    register(groupName: string, path: string, method: string | readonly string[], handler: unknown, options?: RouteRegistrationOptions): void;
+    lookup(path: string, options?: RouteLookupOptions): RouteRegistryEntry | undefined;
+    findAll(path: string, options?: RouteLookupOptions): readonly RouteRegistryEntry[];
+    has(path: string, method: string): boolean;
+    clear(): void;
+    get size(): number;
+    get groupCount(): number;
+    get groupNames(): readonly string[];
+}
+//# sourceMappingURL=httpRegistry.group.d.ts.map

package/dist/httpRouter/core/registry/httpRegistry.group.js

@@ -0,0 +1,72 @@
+/**
+ * Route registry group.
+ *
+ * @module httpRoute/registry/group
+ */
+import { RouteRegistry } from "./httpRegistry.core.js";
+export class RouteRegistryGroup {
+    registries = new Map();
+    options;
+    constructor(options = {}) {
+        this.options = options;
+    }
+    createGroup(name, options = {}) {
+        const mergedOptions = { ...this.options, ...options };
+        const registry = new RouteRegistry(mergedOptions);
+        this.registries.set(name, registry);
+        return registry;
+    }
+    getGroup(name) {
+        return this.registries.get(name);
+    }
+    register(groupName, path, method, handler, options = {}) {
+        const registry = this.registries.get(groupName);
+        if (!registry) {
+            throw new Error(`Route registry group not found: ${groupName}`);
+        }
+        registry.register(path, method, handler, options);
+    }
+    lookup(path, options = {}) {
+        for (const registry of this.registries.values()) {
+            const entry = registry.lookup(path, options);
+            if (entry) {
+                return entry;
+            }
+        }
+        return undefined;
+    }
+    findAll(path, options = {}) {
+        const results = [];
+        for (const registry of this.registries.values()) {
+            results.push(...registry.findAll(path, options));
+        }
+        return results;
+    }
+    has(path, method) {
+        for (const registry of this.registries.values()) {
+            if (registry.has(path, method)) {
+                return true;
+            }
+        }
+        return false;
+    }
+    clear() {
+        for (const registry of this.registries.values()) {
+            registry.clear();
+        }
+    }
+    get size() {
+        let total = 0;
+        for (const registry of this.registries.values()) {
+            total += registry.size;
+        }
+        return total;
+    }
+    get groupCount() {
+        return this.registries.size;
+    }
+    get groupNames() {
+        return Array.from(this.registries.keys());
+    }
+}
+//# sourceMappingURL=httpRegistry.group.js.map

package/dist/httpRouter/core/registry/index.d.ts

@@ -0,0 +1,16 @@
+/**
+ * @zudojs/http/httpRouter/core/registry
+ *
+ * HTTP route registry.
+ *
+ * Note: the registry's own method/path helpers (`normalizeMethod`,
+ * `normalizeMethods`, `isHttpMethod`, `normalizePath`) are deliberately not
+ * re-exported here. The router core owns those names — see
+ * `../factory/httpRoute.factory.base.ts` and `../util/httpRoute.util.ts`.
+ */
+export type { RouteRegistryEntry, RouteRegistryOptions, RouteRegistrationOptions, RouteLookupOptions, RouteRegistrySnapshot, } from "./core/httpRegistry.type.js";
+export { matchesLookup, extractSequence } from "./core/httpRegistry.helper.js";
+export { RouteRegistry } from "./httpRegistry.core.js";
+export { RouteRegistryGroup } from "./httpRegistry.group.js";
+export { createRouteRegistry, createRouteRegistryGroup, isRouteRegistry, isRouteRegistryGroup, } from "./httpRegistry.factory.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/httpRouter/core/registry/index.js

@@ -0,0 +1,15 @@
+/**
+ * @zudojs/http/httpRouter/core/registry
+ *
+ * HTTP route registry.
+ *
+ * Note: the registry's own method/path helpers (`normalizeMethod`,
+ * `normalizeMethods`, `isHttpMethod`, `normalizePath`) are deliberately not
+ * re-exported here. The router core owns those names — see
+ * `../factory/httpRoute.factory.base.ts` and `../util/httpRoute.util.ts`.
+ */
+export { matchesLookup, extractSequence } from "./core/httpRegistry.helper.js";
+export { RouteRegistry } from "./httpRegistry.core.js";
+export { RouteRegistryGroup } from "./httpRegistry.group.js";
+export { createRouteRegistry, createRouteRegistryGroup, isRouteRegistry, isRouteRegistryGroup, } from "./httpRegistry.factory.js";
+//# sourceMappingURL=index.js.map

package/dist/httpRouter/core/types/httpRouter.type.d.ts

@@ -0,0 +1,109 @@
+/**
+ * HTTP router type definitions.
+ *
+ * Core types for routing, route definitions, and router context.
+ */
+import type { HttpRequestContext as RequestContext } from "../../../httpRequest/httpRequest.context.js";
+import type { HttpResponseContext as ResponseContext } from "../../../httpResponse/httpResponse.context.js";
+import type { HttpMiddleware, HttpMiddlewareContext } from "../../../httpMiddleware/httpMiddleware.type.js";
+export type HttpMethod = "GET" | "HEAD" | "POST" | "PUT" | "PATCH" | "DELETE" | "OPTIONS" | "CONNECT" | "TRACE";
+export type RouterHandler = (context: HttpRouterContext) => ResponseContext | Response | void | Promise<ResponseContext | Response | void>;
+export type RouterHandlerLike = RouterHandler | HttpMiddleware;
+export interface HttpRouterContext {
+    readonly request: RequestContext;
+    readonly params: Readonly<Record<string, string>>;
+    readonly query: Readonly<Record<string, string | string[]>>;
+    readonly route: MatchedRoute;
+    readonly state: Map<string, unknown>;
+    readonly middleware: HttpMiddlewareContext;
+    readonly signal: AbortSignal;
+}
+export interface RouteDefinition {
+    readonly method: HttpMethod | readonly HttpMethod[] | "*";
+    readonly path: string;
+    readonly handler: RouterHandler;
+    readonly middleware?: readonly HttpMiddleware[];
+    readonly name?: string;
+    readonly metadata?: Readonly<Record<string, unknown>>;
+    readonly strictTrailingSlash?: boolean;
+}
+export interface RouteOptions {
+    readonly name?: string;
+    readonly middleware?: readonly HttpMiddleware[];
+    readonly metadata?: Readonly<Record<string, unknown>>;
+    readonly strictTrailingSlash?: boolean;
+}
+export interface MatchedRoute {
+    readonly id: string;
+    readonly method: HttpMethod | "*";
+    readonly path: string;
+    readonly name: string | undefined;
+    readonly params: Readonly<Record<string, string>>;
+    readonly metadata: Readonly<Record<string, unknown>>;
+    readonly handler: RouterHandler;
+    readonly middleware: readonly HttpMiddleware[];
+}
+export interface RouterMatch {
+    readonly matched: boolean;
+    readonly route: MatchedRoute | undefined;
+    readonly params: Readonly<Record<string, string>>;
+    readonly allowedMethods: readonly HttpMethod[];
+    readonly path: string;
+    readonly method: string;
+}
+export interface RouterResult {
+    readonly response: ResponseContext;
+    readonly route: MatchedRoute | undefined;
+}
+export interface RouterOptions {
+    readonly caseSensitive?: boolean;
+    readonly strictTrailingSlash?: boolean;
+    readonly automaticHead?: boolean;
+    readonly automaticOptions?: boolean;
+    readonly notFoundHandler?: RouterNotFoundHandler;
+    readonly methodNotAllowedHandler?: RouterMethodNotAllowedHandler;
+}
+export type RouterNotFoundHandler = (context: HttpRouterRequestContext) => ResponseContext | Response | Promise<ResponseContext | Response>;
+export type RouterMethodNotAllowedHandler = (context: HttpRouterRequestContext, allowedMethods: readonly HttpMethod[]) => ResponseContext | Response | Promise<ResponseContext | Response>;
+export interface HttpRouterRequestContext {
+    readonly request: RequestContext;
+    readonly path: string;
+    readonly method: string;
+    readonly signal: AbortSignal;
+    readonly state: Map<string, unknown>;
+}
+/**
+ * A literal path segment that must match verbatim.
+ */
+export interface CompiledSegmentLiteral {
+    readonly type: "literal";
+    readonly value: string;
+}
+/**
+ * A named parameter segment, optionally constrained by a regular expression.
+ */
+export interface CompiledSegmentParameter {
+    readonly type: "parameter";
+    readonly name: string;
+    readonly optional: boolean;
+    readonly pattern: RegExp | undefined;
+}
+/**
+ * A trailing wildcard segment that captures the remainder of the path.
+ */
+export interface CompiledSegmentWildcard {
+    readonly type: "wildcard";
+    readonly name: string;
+}
+export type CompiledSegment = CompiledSegmentLiteral | CompiledSegmentParameter | CompiledSegmentWildcard;
+/**
+ * A route definition paired with its compiled path segments.
+ */
+export interface CompiledRoute {
+    readonly definition: MatchedRoute;
+    readonly segments: readonly CompiledSegment[];
+    readonly score: number;
+    readonly strictTrailingSlash: boolean;
+}
+export { HttpRouterError, RouteConflictError, } from "../error/httpRouter.error.js";
+//# sourceMappingURL=httpRouter.type.d.ts.map

package/dist/httpRouter/core/types/httpRouter.type.js

@@ -0,0 +1,10 @@
+/**
+ * HTTP router type definitions.
+ *
+ * Core types for routing, route definitions, and router context.
+ */
+/* -------------------------------------------------------------------------- */
+/* Errors                                                                     */
+/* -------------------------------------------------------------------------- */
+export { HttpRouterError, RouteConflictError, } from "../error/httpRouter.error.js";
+//# sourceMappingURL=httpRouter.type.js.map

package/dist/httpRouter/core/types/index.d.ts

@@ -0,0 +1,7 @@
+/**
+ * @zudojs/http/httpRouter/core/types
+ *
+ * HTTP router type definitions.
+ */
+export * from "./httpRouter.type.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/httpRouter/core/types/index.js

@@ -0,0 +1,7 @@
+/**
+ * @zudojs/http/httpRouter/core/types
+ *
+ * HTTP router type definitions.
+ */
+export * from "./httpRouter.type.js";
+//# sourceMappingURL=index.js.map

package/dist/httpRouter/core/util/httpRoute.util.d.ts

@@ -0,0 +1,26 @@
+/**
+ * HTTP router utility helpers.
+ *
+ * Request accessors, URL/query parsing, and path normalization shared by the
+ * router core.
+ */
+import type { HttpRequestContext as RequestContext } from "../../../httpRequest/httpRequest.context.js";
+export declare function getRequestMethod(request: RequestContext): string;
+export declare function getRequestUrl(request: RequestContext): string;
+export declare function getRequestSignal(request: RequestContext): AbortSignal | undefined;
+export declare function parseUrl(value: string): URL;
+export declare function parseQuery(params: URLSearchParams): Readonly<Record<string, string | string[]>>;
+export declare function normalizePath(path: string): string;
+export declare function splitPath(path: string): string[];
+export declare function validateParameterName(name: string, path: string): void;
+export declare function decodeRouteValue(value: string): string;
+/**
+ * Decodes one matched path segment, rejecting anything that would smuggle a
+ * path separator, a NUL, or a `.`/`..` segment past the matcher.
+ *
+ * @param value - The raw (still percent-encoded) segment.
+ * @returns The decoded segment, or `undefined` if the segment is malformed or
+ *   carries a traversal payload. `undefined` must fail the match.
+ */
+export declare function decodeRouteSegment(value: string): string | undefined;
+//# sourceMappingURL=httpRoute.util.d.ts.map

package/dist/httpRouter/core/util/httpRoute.util.js

@@ -0,0 +1,113 @@
+/**
+ * HTTP router utility helpers.
+ *
+ * Request accessors, URL/query parsing, and path normalization shared by the
+ * router core.
+ */
+import { InvalidRoutePatternError } from "../error/httpRouter.error.js";
+export function getRequestMethod(request) {
+    const value = request.method;
+    return (value ?? "GET").toUpperCase();
+}
+export function getRequestUrl(request) {
+    const value = request.url;
+    if (value instanceof URL) {
+        return value.toString();
+    }
+    return value ?? "/";
+}
+export function getRequestSignal(request) {
+    return request.signal;
+}
+export function parseUrl(value) {
+    try {
+        return new URL(value, "http://zudojs.local");
+    }
+    catch {
+        return new URL("/", "http://zudojs.local");
+    }
+}
+export function parseQuery(params) {
+    const result = {};
+    for (const key of new Set(Array.from(params.keys()))) {
+        const values = params.getAll(key);
+        result[key] = values.length > 1 ? values : (values[0] ?? "");
+    }
+    return Object.freeze({
+        ...result,
+    });
+}
+/* -------------------------------------------------------------------------- */
+/* Path Helpers                                                               */
+/* -------------------------------------------------------------------------- */
+export function normalizePath(path) {
+    if (!path || path === "") {
+        return "/";
+    }
+    const withoutQuery = path.split("?", 1)[0] ?? path;
+    let normalized = withoutQuery.startsWith("/")
+        ? withoutQuery
+        : `/${withoutQuery}`;
+    normalized = normalized.replace(/\/{2,}/g, "/");
+    if (normalized.length > 1 && normalized.endsWith("/")) {
+        normalized = normalized.slice(0, -1);
+    }
+    return normalized;
+}
+export function splitPath(path) {
+    const normalized = normalizePath(path);
+    if (normalized === "/") {
+        return [];
+    }
+    return normalized.split("/").filter(Boolean);
+}
+export function validateParameterName(name, path) {
+    if (!/^[a-zA-Z_][a-zA-Z0-9_-]*$/.test(name)) {
+        throw new InvalidRoutePatternError(path, `Invalid parameter name "${name}".`);
+    }
+}
+export function decodeRouteValue(value) {
+    try {
+        return decodeURIComponent(value);
+    }
+    catch {
+        return value;
+    }
+}
+/**
+ * Characters and segment values that must never survive percent-decoding into
+ * a route parameter.
+ *
+ * A single path segment is matched *before* it is decoded, so `%2e%2e%2f`
+ * satisfies a `[^/]+`-shaped segment and then decodes to `../`. Any handler
+ * that uses the parameter as a path component — the overwhelmingly common
+ * case — receives a traversal payload the router has certified as one
+ * segment.
+ */
+const TRAVERSAL_CHARS = /[/\\\u0000]/;
+/**
+ * Decodes one matched path segment, rejecting anything that would smuggle a
+ * path separator, a NUL, or a `.`/`..` segment past the matcher.
+ *
+ * @param value - The raw (still percent-encoded) segment.
+ * @returns The decoded segment, or `undefined` if the segment is malformed or
+ *   carries a traversal payload. `undefined` must fail the match.
+ */
+export function decodeRouteSegment(value) {
+    let decoded;
+    try {
+        decoded = decodeURIComponent(value);
+    }
+    catch {
+        /* Malformed percent-encoding: `%zz`, a lone `%`, a truncated surrogate. */
+        return undefined;
+    }
+    if (TRAVERSAL_CHARS.test(decoded)) {
+        return undefined;
+    }
+    if (decoded === "." || decoded === "..") {
+        return undefined;
+    }
+    return decoded;
+}
+//# sourceMappingURL=httpRoute.util.js.map

package/dist/httpRouter/core/util/index.d.ts

@@ -0,0 +1,7 @@
+/**
+ * @zudojs/http/httpRouter/core/util
+ *
+ * HTTP router utility functions.
+ */
+export * from "./httpRoute.util.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/httpRouter/core/util/index.js

@@ -0,0 +1,7 @@
+/**
+ * @zudojs/http/httpRouter/core/util
+ *
+ * HTTP router utility functions.
+ */
+export * from "./httpRoute.util.js";
+//# sourceMappingURL=index.js.map

package/dist/httpRouter/dispatch/httpRoute.dispatcher.d.ts

@@ -0,0 +1,66 @@
+/**
+ * Zudojs HTTP route dispatcher.
+ *
+ * Responsible for taking a matched route and executing its middleware and
+ * handler pipeline. Route registration and route matching remain separate
+ * concerns.
+ */
+import type { HttpMethod, MatchedRoute, RouterHandler } from "../core/types/httpRouter.type.js";
+import type { RouteMatcher, RouteMatcherResult } from "../matching/httpRoute.matcher.js";
+import type { HttpRequestContext as RequestContext } from "../../httpRequest/httpRequest.context.js";
+import type { HttpResponseContext as ResponseContext } from "../../httpResponse/httpResponse.context.js";
+export type RouteDispatchNext = () => void | Promise<void>;
+export type RouteMiddleware = (request: RequestContext, response: ResponseContext, next: RouteDispatchNext) => void | Promise<void>;
+export type RouteDispatchHandler = (request: RequestContext, response: ResponseContext) => void | Promise<void>;
+export interface RouteDispatchContext {
+    readonly request: RequestContext;
+    readonly response: ResponseContext;
+    readonly route: MatchedRoute;
+    readonly params: Readonly<Record<string, string>>;
+    readonly method: HttpMethod | "*";
+    readonly path: string;
+    readonly match: RouteMatcherResult;
+}
+export interface RouteDispatchOptions {
+    readonly onError?: RouteDispatchErrorHandler;
+    readonly onComplete?: RouteDispatchCompleteHandler;
+    readonly preserveResponse?: boolean;
+}
+export type RouteDispatchErrorHandler = (error: unknown, context: RouteDispatchContext) => void | Promise<void>;
+export type RouteDispatchCompleteHandler = (context: RouteDispatchContext) => void | Promise<void>;
+export interface RouteDispatchResult {
+    readonly matched: boolean;
+    readonly handled: boolean;
+    readonly route: MatchedRoute | undefined;
+    readonly error: unknown | undefined;
+    readonly context: RouteDispatchContext | undefined;
+}
+export interface RouteDispatcherStats {
+    readonly dispatches: number;
+    readonly handled: number;
+    readonly unmatched: number;
+    readonly errors: number;
+}
+export declare class RouteDispatcher {
+    private readonly matcher;
+    private readonly options;
+    private dispatchCount;
+    private handledCount;
+    private unmatchedCount;
+    private errorCount;
+    constructor(matcher: RouteMatcher, options?: RouteDispatchOptions);
+    dispatch(request: RequestContext, response: ResponseContext): Promise<RouteDispatchResult>;
+    dispatchMatch(match: RouteMatcherResult, request: RequestContext, response: ResponseContext): Promise<RouteDispatchResult>;
+    execute(context: RouteDispatchContext): Promise<void>;
+    executeHandler(handler: RouteDispatchHandler, context: RouteDispatchContext): Promise<void>;
+    executeMiddleware(middleware: RouteMiddleware | readonly RouteMiddleware[], context: RouteDispatchContext): Promise<void>;
+    stats(): RouteDispatcherStats;
+    resetStats(): void;
+}
+export declare function createRouteDispatcher(matcher: RouteMatcher, options?: RouteDispatchOptions): RouteDispatcher;
+export declare function dispatchRoute(dispatcher: RouteDispatcher, request: RequestContext, response: ResponseContext): Promise<RouteDispatchResult>;
+export declare function composeRouteMiddleware(middleware: readonly RouteMiddleware[]): RouteMiddleware;
+export declare function createRouteHandler(handler: RouteDispatchHandler): RouterHandler;
+export declare function isRouteDispatcher(value: unknown): value is RouteDispatcher;
+export declare function isRouteDispatchResult(value: unknown): value is RouteDispatchResult;
+//# sourceMappingURL=httpRoute.dispatcher.d.ts.map