routup 5.0.0-beta.2 → 5.0.0-beta.4

package/dist/{index-BBvBVzPm.d.mts → index-doDmTYzg.d.mts}

@@ -1,55 +1,59 @@
-import { HTTPError, HTTPErrorInput, HTTPErrorInput as HTTPErrorInput$1 } from "@ebec/http";
 import { FastURL, ServerRequest } from "srvx";
-import { Key, ParseOptions, PathToRegexpOptions } from "path-to-regexp";
+import { HTTPError, HTTPErrorInput, HTTPErrorInput as HTTPErrorInput$1 } from "@ebec/http";
 import Negotiator from "negotiator";
+import { Key, ParseOptions, PathToRegexpOptions } from "path-to-regexp";
 import { IncomingMessage, ServerResponse } from "node:http";
 
 //#region src/constants.d.ts
-declare enum MethodName {
-  GET = "GET",
-  POST = "POST",
-  PUT = "PUT",
-  PATCH = "PATCH",
-  DELETE = "DELETE",
-  OPTIONS = "OPTIONS",
-  HEAD = "HEAD"
-}
-declare enum HeaderName {
-  ACCEPT = "accept",
-  ACCEPT_CHARSET = "accept-charset",
-  ACCEPT_ENCODING = "accept-encoding",
-  ACCEPT_LANGUAGE = "accept-language",
-  ACCEPT_RANGES = "accept-ranges",
-  ALLOW = "allow",
-  CACHE_CONTROL = "cache-control",
-  CONTENT_DISPOSITION = "content-disposition",
-  CONTENT_ENCODING = "content-encoding",
-  CONTENT_LENGTH = "content-length",
-  CONTENT_RANGE = "content-range",
-  CONTENT_TYPE = "content-type",
-  CONNECTION = "connection",
-  COOKIE = "cookie",
-  ETag = "etag",
-  HOST = "host",
-  IF_MODIFIED_SINCE = "if-modified-since",
-  IF_NONE_MATCH = "if-none-match",
-  LAST_MODIFIED = "last-modified",
-  LOCATION = "location",
-  RANGE = "range",
-  RATE_LIMIT_LIMIT = "ratelimit-limit",
-  RATE_LIMIT_REMAINING = "ratelimit-remaining",
-  RATE_LIMIT_RESET = "ratelimit-reset",
-  RETRY_AFTER = "retry-after",
-  SET_COOKIE = "set-cookie",
-  TRANSFER_ENCODING = "transfer-encoding",
-  X_ACCEL_BUFFERING = "x-accel-buffering",
-  X_FORWARDED_HOST = "x-forwarded-host",
-  X_FORWARDED_FOR = "x-forwarded-for",
-  X_FORWARDED_PROTO = "x-forwarded-proto"
-}
+declare const MethodName: {
+  readonly GET: "GET";
+  readonly POST: "POST";
+  readonly PUT: "PUT";
+  readonly PATCH: "PATCH";
+  readonly DELETE: "DELETE";
+  readonly OPTIONS: "OPTIONS";
+  readonly HEAD: "HEAD";
+};
+type MethodName = typeof MethodName[keyof typeof MethodName];
+declare const HeaderName: {
+  readonly ACCEPT: "accept";
+  readonly ACCEPT_CHARSET: "accept-charset";
+  readonly ACCEPT_ENCODING: "accept-encoding";
+  readonly ACCEPT_LANGUAGE: "accept-language";
+  readonly ACCEPT_RANGES: "accept-ranges";
+  readonly ALLOW: "allow";
+  readonly CACHE_CONTROL: "cache-control";
+  readonly CONTENT_DISPOSITION: "content-disposition";
+  readonly CONTENT_ENCODING: "content-encoding";
+  readonly CONTENT_LENGTH: "content-length";
+  readonly CONTENT_RANGE: "content-range";
+  readonly CONTENT_TYPE: "content-type";
+  readonly CONNECTION: "connection";
+  readonly COOKIE: "cookie";
+  readonly ETag: "etag";
+  readonly HOST: "host";
+  readonly IF_MODIFIED_SINCE: "if-modified-since";
+  readonly IF_NONE_MATCH: "if-none-match";
+  readonly LAST_MODIFIED: "last-modified";
+  readonly LOCATION: "location";
+  readonly RANGE: "range";
+  readonly RATE_LIMIT_LIMIT: "ratelimit-limit";
+  readonly RATE_LIMIT_REMAINING: "ratelimit-remaining";
+  readonly RATE_LIMIT_RESET: "ratelimit-reset";
+  readonly RETRY_AFTER: "retry-after";
+  readonly SET_COOKIE: "set-cookie";
+  readonly TRANSFER_ENCODING: "transfer-encoding";
+  readonly X_ACCEL_BUFFERING: "x-accel-buffering";
+  readonly X_FORWARDED_HOST: "x-forwarded-host";
+  readonly X_FORWARDED_FOR: "x-forwarded-for";
+  readonly X_FORWARDED_PROTO: "x-forwarded-proto";
+};
+type HeaderName = typeof HeaderName[keyof typeof HeaderName];
 //#endregion
 //#region src/error/module.d.ts
+declare const ErrorSymbol: unique symbol;
 declare class RoutupError extends HTTPError {
+  readonly '@instanceof': symbol;
   constructor(input?: HTTPErrorInput$1);
 }
 //#endregion
@@ -57,9 +61,9 @@ declare class RoutupError extends HTTPError {
 type RoutupResponse = {
   status: number;
   headers: Headers;
-  statusText?: string;
 };
 type RoutupRequest = ServerRequest;
+type NextFn = (error?: Error) => unknown | Promise<unknown>;
 interface IRoutupEvent {
   /**
    * The srvx ServerRequest (extends Web Standard Request).
@@ -68,11 +72,11 @@ interface IRoutupEvent {
   /**
    * Route parameters extracted from the URL path pattern.
    */
-  params: Record<string, any>;
+  readonly params: Record<string, any>;
   /**
    * Current request path, adjusted relative to the mount point during router nesting.
    */
-  path: string;
+  readonly path: string;
   /**
    * HTTP method (GET, POST, PUT, etc.).
    */
@@ -80,16 +84,7 @@ interface IRoutupEvent {
   /**
    * Accumulated mount path from nested routers.
    */
-  mountPath: string;
-  /**
-   * Error that occurred during dispatch, if any.
-   */
-  error?: RoutupError;
-  /**
-   * Router ID stack for nesting tracking.
-   * Used internally by router options resolution.
-   */
-  routerPath: number[];
+  readonly mountPath: string;
   /**
    * Web Standard Headers from the request.
    */
@@ -108,10 +103,6 @@ interface IRoutupEvent {
    * that go through `toResponse()`.
    */
   readonly response: RoutupResponse;
-  /**
-   * Whether a response has been produced.
-   */
-  dispatched: boolean;
   /**
    * Per-request store for caching and plugin state.
    *
@@ -119,86 +110,168 @@ interface IRoutupEvent {
    * Data is garbage collected with the event when the request completes.
    */
   readonly store: Record<string | symbol, unknown>;
+  /**
+   * Pre-resolved router options for the current dispatch context.
+   *
+   * Contains merged options from the router path stack with defaults applied.
+   */
+  readonly routerOptions: RouterOptions;
+  /**
+   * Abort signal tied to the request lifecycle.
+   *
+   * When a `timeout` router option is set, this signal aborts after the
+   * specified duration. Handlers performing long I/O (fetch, streams, DB queries)
+   * can pass this signal to those operations for cooperative cancellation.
+   */
+  readonly signal: AbortSignal;
   /**
    * Call the next handler in the pipeline (onion model).
    *
    * The result is cached — calling `next()` multiple times returns the same response.
    * Returns the downstream `Response`, or `undefined` if no handler matched.
    */
-  next(): Promise<Response | undefined>;
+  next(error?: Error): Promise<Response | undefined>;
 }
 //#endregion
 //#region src/event/module.d.ts
+type RoutupEventCreateContext = {
+  request: RoutupRequest;
+  params: Record<string, any>;
+  path: string;
+  method: string;
+  mountPath: string;
+  headers: Headers;
+  searchParams: URLSearchParams;
+  response: RoutupResponse;
+  store: Record<string | symbol, unknown>;
+  signal: AbortSignal;
+  routerOptions: () => RouterOptions;
+  next: (event: IRoutupEvent, error?: Error) => Promise<Response | undefined>;
+};
 declare class RoutupEvent implements IRoutupEvent {
   readonly request: RoutupRequest;
+  readonly params: Record<string, any>;
+  readonly path: string;
+  readonly method: string;
+  readonly mountPath: string;
+  readonly headers: Headers;
+  readonly searchParams: URLSearchParams;
+  readonly response: RoutupResponse;
+  readonly store: Record<string | symbol, unknown>;
+  readonly signal: AbortSignal;
+  protected _context: RoutupEventCreateContext;
+  protected _routerOptions?: RouterOptions;
+  constructor(context: RoutupEventCreateContext);
+  get routerOptions(): RouterOptions;
+  next(error?: Error): Promise<Response | undefined>;
+}
+//#endregion
+//#region src/hook/constants.d.ts
+declare const HookName: {
+  readonly REQUEST: "request";
+  readonly RESPONSE: "response";
+  readonly ERROR: "error";
+  readonly CHILD_MATCH: "childMatch";
+  readonly CHILD_DISPATCH_BEFORE: "childDispatchBefore";
+  readonly CHILD_DISPATCH_AFTER: "childDispatchAfter";
+};
+type HookName = typeof HookName[keyof typeof HookName];
+//#endregion
+//#region src/dispatcher/types.d.ts
+interface IDispatcherEvent {
+  /**
+   * The srvx ServerRequest (extends Web Standard Request).
+   */
+  readonly request: RoutupRequest;
+  /**
+   * Route parameters extracted from the URL path pattern.
+   */
   params: Record<string, any>;
+  /**
+   * Current request path, adjusted relative to the mount point during router nesting.
+   */
   path: string;
+  /**
+   * HTTP method (GET, POST, PUT, etc.).
+   */
   readonly method: string;
+  /**
+   * Accumulated mount path from nested routers.
+   */
   mountPath: string;
+  /**
+   * Response accumulator — set status/headers before returning a plain value.
+   */
+  readonly response: RoutupResponse;
+  /**
+   * Whether a response has been produced.
+   */
+  dispatched: boolean;
+  /**
+   * Error that occurred during dispatch, if any.
+   */
   error?: RoutupError;
-  routerPath: number[];
   /**
-   * Collected allowed methods (for OPTIONS).
+   * Router stack for nesting tracking.
+   * Used internally by router options resolution.
    */
-  methodsAllowed: string[];
-  readonly store: Record<string | symbol, unknown>;
-  protected _dispatched: boolean;
-  protected _response?: RoutupResponse;
+  routerPath: RouterPathNode[];
   /**
-   * Cached parsed URL (avoids double-parsing).
+   * Abort signal for cooperative cancellation.
+   *
+   * When a `timeout` router option is set, this signal aborts after the
+   * specified duration. Handlers can pass it to fetch(), streams, or other
+   * AbortSignal-aware APIs.
    */
-  protected _url: InstanceType<typeof FastURL>;
-  protected _searchParams?: URLSearchParams;
+  signal: AbortSignal;
   /**
-   * Continuation function for middleware onion model.
+   * Collected allowed methods for the current path (used for OPTIONS / 405 responses).
    */
-  _next?: () => Promise<Response | undefined>;
+  methodsAllowed: Set<string>;
   /**
-   * Whether _next has already been called (guard against double-invocation).
+   * Set the continuation function for this event.
+   *
+   * Replaces the current continuation. The provided function receives
+   * an optional error and may return any value — it will be converted
+   * to a `Response` via `toResponse()`.
+   *
+   * Passing `undefined` clears the continuation function.
    */
-  _nextCalled: boolean;
+  setNext(fn?: NextFn): void;
   /**
-   * The cached result of the next handler.
+   * Build a public RoutupEvent from the current dispatch state.
+   *
+   * Creates a lightweight snapshot with shared references (store, response, headers)
+   * and pre-resolved router options. This is the event passed to handler functions.
+   *
+   * @param signal - Optional AbortSignal override. When provided, the built event
+   *                 uses this signal instead of the dispatcher event's own signal.
+   *                 Used by per-handler timeout to provide a handler-scoped signal.
    */
-  _nextResult?: Promise<Response | undefined>;
-  constructor(request: RoutupRequest);
-  get headers(): Headers;
-  get searchParams(): URLSearchParams;
-  get response(): RoutupResponse;
-  get dispatched(): boolean;
-  set dispatched(value: boolean);
-  next(): Promise<Response | undefined>;
+  build(signal?: AbortSignal): RoutupEvent;
 }
-//#endregion
-//#region src/dispatcher/types.d.ts
 interface IDispatcher {
-  dispatch(event: RoutupEvent): Promise<Response | undefined>;
-}
-//#endregion
-//#region src/hook/constants.d.ts
-declare enum HookName {
-  REQUEST = "request",
-  RESPONSE = "response",
-  ERROR = "error",
-  CHILD_MATCH = "childMatch",
-  CHILD_DISPATCH_BEFORE = "childDispatchBefore",
-  CHILD_DISPATCH_AFTER = "childDispatchAfter"
+  dispatch(event: IDispatcherEvent): Promise<Response | undefined>;
 }
 //#endregion
 //#region src/hook/types.d.ts
-type HookErrorListener = (event: IRoutupEvent) => Promise<unknown> | unknown;
-type HookDefaultListener = (event: IRoutupEvent) => Promise<unknown> | unknown;
+type HookErrorListener = (event: IDispatcherEvent) => Promise<unknown> | unknown;
+type HookDefaultListener = (event: IDispatcherEvent) => Promise<unknown> | unknown;
 type HookListener = HookErrorListener | HookDefaultListener;
 type HookUnsubscribeFn = () => void;
 //#endregion
 //#region src/hook/module.d.ts
+type HookEntry = {
+  fn: HookListener;
+  priority: number;
+};
 declare class HookManager {
-  protected items: Record<string, HookListener[]>;
+  protected items: Record<string, HookEntry[]>;
   constructor();
-  addListener(name: `${HookName}`, fn: HookListener): HookUnsubscribeFn;
-  removeListener(name: `${HookName}`): void;
-  removeListener(name: `${HookName}`, fn: HookListener): void;
-  trigger(name: `${HookName}`, event: IRoutupEvent): Promise<void>;
+  addListener(name: HookName, fn: HookListener, priority?: number): HookUnsubscribeFn;
+  removeListener(name: HookName): void;
+  removeListener(name: HookName, fn: HookListener): void;
+  trigger(name: HookName, event: IDispatcherEvent): Promise<void>;
   private triggerListener;
   private isErrorListenerHook;
 }
@@ -226,16 +299,25 @@ declare class PathMatcher {
 declare function isPath(input: unknown): input is Path;
 //#endregion
 //#region src/handler/constants.d.ts
-declare enum HandlerType {
-  CORE = "core",
-  ERROR = "error"
-}
+declare const HandlerType: {
+  readonly CORE: "core";
+  readonly ERROR: "error";
+};
+type HandlerType = typeof HandlerType[keyof typeof HandlerType];
 declare const HandlerSymbol: unique symbol;
 //#endregion
 //#region src/handler/types-base.d.ts
 type HandlerBaseOptions = {
   method?: Uppercase<MethodName> | Lowercase<MethodName>;
   path?: Path;
+  /**
+   * Per-handler timeout in milliseconds.
+   *
+   * Overrides the router's `handlerTimeout` default. Whether this value
+   * can extend or only narrow the default is controlled by the router's
+   * `handlerTimeoutOverridable` option.
+   */
+  timeout?: number;
   onError?: HookErrorListener;
   onBefore?: HookDefaultListener;
   onAfter?: HookDefaultListener;
@@ -244,7 +326,7 @@ type HandlerBaseOptions = {
 //#region src/handler/error/types.d.ts
 type ErrorHandler = (error: RoutupError, event: IRoutupEvent) => unknown | Promise<unknown>;
 type ErrorHandlerOptions = HandlerBaseOptions & {
-  type: `${HandlerType.ERROR}`;
+  type: typeof HandlerType.ERROR;
   fn: ErrorHandler;
 };
 //#endregion
@@ -280,18 +362,20 @@ declare class Handler implements IDispatcher {
   get type(): "error" | "core";
   get path(): string | undefined;
   get method(): MethodName | undefined;
-  dispatch(event: RoutupEvent): Promise<Response | undefined>;
+  dispatch(event: IDispatcherEvent): Promise<Response | undefined>;
   matchPath(path: string): boolean;
   setPath(path?: Path): void;
-  matchMethod(method: `${MethodName}`): boolean;
-  setMethod(input?: `${MethodName}`): void;
+  matchMethod(method: MethodName): boolean;
+  setMethod(input?: MethodName): void;
+  protected executeWithTimeout(fn: () => unknown | Promise<unknown>, routerOptions: RouterOptions, controller?: AbortController): Promise<unknown>;
+  protected resolveTimeout(routerOptions: RouterOptions): number | undefined;
   protected mountHooks(): void;
 }
 //#endregion
 //#region src/handler/core/types.d.ts
 type CoreHandler = (event: IRoutupEvent) => unknown | Promise<unknown>;
 type CoreHandlerOptions = HandlerBaseOptions & {
-  type: `${HandlerType.CORE}`;
+  type: typeof HandlerType.CORE;
   fn: CoreHandler;
 };
 //#endregion
@@ -394,28 +478,142 @@ declare function isWebHandler(input: unknown): input is WebHandler;
 declare function isHandlerOptions(input: unknown): input is HandlerOptions;
 declare function isHandler(input: unknown): input is Handler;
 //#endregion
-//#region src/router/constants.d.ts
-declare enum RouterPipelineStep {
-  START = 0,
-  LOOKUP = 1,
-  CHILD_BEFORE = 2,
-  CHILD_DISPATCH = 3,
-  CHILD_AFTER = 4,
-  FINISH = 5
+//#region src/plugin/error/constants.d.ts
+declare const PluginErrorCode: {
+  readonly PLUGIN: "PLUGIN";
+  readonly NOT_INSTALLED: "PLUGIN_NOT_INSTALLED";
+  readonly INSTALL: "PLUGIN_INSTALL";
+};
+type PluginErrorCode = typeof PluginErrorCode[keyof typeof PluginErrorCode];
+//#endregion
+//#region src/plugin/error/module.d.ts
+declare class PluginError extends RoutupError {
+  constructor(input?: HTTPErrorInput);
 }
 //#endregion
+//#region src/plugin/error/is.d.ts
+declare function isPluginError(input: unknown): input is PluginError;
+//#endregion
+//#region src/plugin/error/sub/install.d.ts
+declare class PluginInstallError extends PluginError {
+  readonly pluginName: string;
+  constructor(pluginName: string, cause?: Error);
+}
+//#endregion
+//#region src/plugin/error/sub/not-installed.d.ts
+declare class PluginNotInstalledError extends PluginError {
+  readonly pluginName: string;
+  readonly helperName: string;
+  constructor(pluginName: string, helperName: string);
+}
+//#endregion
+//#region src/plugin/types.d.ts
+type PluginInstallFn = (router: IRouter) => any;
+type Plugin = {
+  /**
+   * The name of the plugin.
+   */
+  name: string;
+  /**
+   * The installation function called on registration.
+   */
+  install: PluginInstallFn;
+};
+type PluginInstallContext = {
+  /**
+   * The name property overwrites the name defined by the plugin.
+   */
+  name?: string;
+  /**
+   * By specifying a path, the plugin will be installed as a child router.
+   */
+  path?: Path;
+};
+//#endregion
+//#region src/plugin/is.d.ts
+declare function isPlugin(input: unknown): input is Plugin;
+//#endregion
+//#region src/utils/etag/type.d.ts
+type EtagOptions = {
+  /**
+   * Create a weak ETag?
+   * Output is prefixed with: /W
+   */
+  weak?: boolean;
+  /**
+   * Threshold of bytes from which an etag is generated.
+   *
+   * default: undefined
+   */
+  threshold?: number;
+};
+type EtagFn = (body: any, encoding?: BufferEncoding, size?: number) => Promise<string | undefined>;
+type EtagInput = boolean | EtagOptions | EtagFn;
+//#endregion
+//#region src/utils/trust-proxy/type.d.ts
+type TrustProxyFn = (address: string, hop: number) => boolean;
+type TrustProxyInput = boolean | number | string | string[] | TrustProxyFn;
+//#endregion
+//#region src/router/constants.d.ts
+declare const RouterPipelineStep: {
+  readonly START: 0;
+  readonly LOOKUP: 1;
+  readonly CHILD_BEFORE: 2;
+  readonly CHILD_DISPATCH: 3;
+  readonly CHILD_AFTER: 4;
+  readonly FINISH: 5;
+};
+type RouterPipelineStep = typeof RouterPipelineStep[keyof typeof RouterPipelineStep];
+//#endregion
 //#region src/router/types.d.ts
+type RouterOptions = {
+  path?: Path;
+  name?: string;
+  /**
+   * Global request timeout in milliseconds.
+   *
+   * Applies to the entire dispatch pipeline in `fetch()`. When exceeded,
+   * the request is aborted and a 408 response is returned. The AbortSignal
+   * on the event is also aborted for cooperative cancellation.
+   */
+  timeout?: number;
+  /**
+   * Default per-handler timeout in milliseconds.
+   *
+   * Applies individually to each handler's `fn()` execution. Handlers can
+   * override this value via their own `timeout` option — see
+   * `handlerTimeoutOverridable` to control whether overrides can extend
+   * or only narrow this default.
+   */
+  handlerTimeout?: number;
+  /**
+   * Whether handlers can extend the `handlerTimeout` default.
+   *
+   * When `false` (default), a handler's `timeout` is clamped to
+   * `Math.min(handlerTimeout, handler.timeout)`. When `true`, the
+   * handler's `timeout` fully replaces the router default.
+   */
+  handlerTimeoutOverridable?: boolean;
+  subdomainOffset: number;
+  proxyIpMax: number;
+  etag: EtagFn;
+  trustProxy: TrustProxyFn;
+};
+type RouterOptionsInput = Omit<Partial<RouterOptions>, 'etag' | 'trustProxy'> & {
+  etag?: EtagInput;
+  trustProxy?: TrustProxyInput;
+};
+type RouterPathNode = {
+  readonly name?: string;
+  readonly options: Partial<RouterOptions>;
+};
 type RouterPipelineContext = {
   step: RouterPipelineStep;
-  event: RoutupEvent;
+  event: IDispatcherEvent;
   stackIndex: number;
   response?: Response;
 };
 interface IRouter extends IDispatcher {
-  /**
-   * Unique identifier for this router instance.
-   */
-  readonly id: number;
   /**
    * Optional label for the router instance.
    */
@@ -467,111 +665,66 @@ interface IRouter extends IDispatcher {
   /**
    * Add a hook listener.
    */
-  on(name: `${HookName.REQUEST}` | `${HookName.RESPONSE}` | `${HookName.CHILD_DISPATCH_BEFORE}` | `${HookName.CHILD_DISPATCH_AFTER}`, fn: HookDefaultListener): HookUnsubscribeFn;
-  on(name: `${HookName.CHILD_MATCH}`, fn: HookDefaultListener): HookUnsubscribeFn;
-  on(name: `${HookName.ERROR}`, fn: HookErrorListener): HookUnsubscribeFn;
+  on(name: typeof HookName.REQUEST | typeof HookName.RESPONSE | typeof HookName.CHILD_DISPATCH_BEFORE | typeof HookName.CHILD_DISPATCH_AFTER, fn: HookDefaultListener): HookUnsubscribeFn;
+  on(name: typeof HookName.CHILD_MATCH, fn: HookDefaultListener): HookUnsubscribeFn;
+  on(name: typeof HookName.ERROR, fn: HookErrorListener): HookUnsubscribeFn;
   /**
    * Remove a specific or all hook listeners for the given hook name.
    */
-  off(name: `${HookName}`): this;
-  off(name: `${HookName}`, fn: HookListener): this;
+  off(name: HookName): this;
+  off(name: HookName, fn: HookListener): this;
 }
 //#endregion
-//#region src/plugin/types.d.ts
-type PluginInstallFn = (router: IRouter) => any;
-type Plugin = {
-  /**
-   * The name of the plugin.
-   */
-  name: string;
-  /**
-   * The installation function called on registration.
-   */
-  install: PluginInstallFn;
-};
-type PluginInstallContext = {
-  /**
-   * The name property overwrites the name defined by the plugin.
-   */
-  name?: string;
-  /**
-   * By specifying a path, the plugin will be installed as a child router.
-   */
-  path?: Path;
-};
-//#endregion
-//#region src/plugin/is.d.ts
-declare function isPlugin(input: unknown): input is Plugin;
-//#endregion
-//#region src/utils/etag/type.d.ts
-type EtagOptions = {
-  /**
-   * Create a weak ETag?
-   * Output is prefixed with: /W
-   */
-  weak?: boolean;
-  /**
-   * Threshold of bytes from which an etag is generated.
-   *
-   * default: undefined
-   */
-  threshold?: number;
-};
-type EtagFn = (body: any, encoding?: BufferEncoding, size?: number) => Promise<string | undefined>;
-type EtagInput = boolean | EtagOptions | EtagFn;
-//#endregion
-//#region src/utils/trust-proxy/type.d.ts
-type TrustProxyFn = (address: string, hop: number) => boolean;
-type TrustProxyInput = boolean | number | string | string[] | TrustProxyFn;
-//#endregion
-//#region src/router-options/type.d.ts
-type RouterOptions = {
-  /**
-   * The path the router is mounted on.
-   *
-   * @type string
-   * @default '/'
-   */
-  path?: Path;
-  /**
-   * Name of the router.
-   */
-  name?: string;
-  /**
-   * default: 2
-   */
-  subdomainOffset: number;
+//#region src/dispatcher/module.d.ts
+declare class DispatcherEvent implements IDispatcherEvent {
+  readonly request: RoutupRequest;
+  params: Record<string, any>;
+  path: string;
+  readonly method: string;
   /**
-   * default: 0
+   * Collected allowed methods (for OPTIONS).
    */
-  proxyIpMax: number;
+  methodsAllowed: Set<string>;
+  mountPath: string;
+  error?: RoutupError;
+  routerPath: RouterPathNode[];
+  protected _dispatched: boolean;
+  protected _response?: RoutupResponse;
+  protected _store?: Record<string | symbol, unknown>;
   /**
-   * default: () => true
+   * Cached parsed URL (avoids double-parsing).
    */
-  etag: EtagFn;
+  protected _url: InstanceType<typeof FastURL>;
   /**
-   * default: () => false
+   * Continuation function for middleware onion model.
    */
-  trustProxy: TrustProxyFn;
-};
-type RouterOptionsInput = Omit<Partial<RouterOptions>, 'etag' | 'trustProxy'> & {
+  protected _next?: (event: IRoutupEvent, error?: Error) => Promise<Response | undefined>;
+  protected _signal?: AbortSignal;
+  protected _signalCleanup?: () => void;
   /**
-   * default: true
+   * Whether _next has already been called (guard against double-invocation).
    */
-  etag?: EtagInput;
+  protected _nextCalled: boolean;
   /**
-   * default: false
+   * The cached result of the next handler.
    */
-  trustProxy?: TrustProxyInput;
-};
+  protected _nextResult?: Promise<Response | undefined>;
+  constructor(request: RoutupRequest);
+  get response(): RoutupResponse;
+  get signal(): AbortSignal;
+  set signal(value: AbortSignal);
+  get dispatched(): boolean;
+  set dispatched(value: boolean);
+  protected next(event: IRoutupEvent, error?: Error): Promise<Response | undefined>;
+  setNext(fn?: NextFn): void;
+  build(signal?: AbortSignal): RoutupEvent;
+  protected get store(): Record<string | symbol, unknown>;
+  protected resolveOptions(): RouterOptions;
+}
 //#endregion
 //#region src/router/module.d.ts
 declare class Router implements IRouter {
   readonly '@instanceof': symbol;
-  /**
-   * An identifier for the router instance.
-   */
-  readonly id: number;
   /**
    * A label for the router instance.
    */
@@ -594,15 +747,19 @@ declare class Router implements IRouter {
    * @protected
    */
   protected hookManager: HookManager;
-  constructor(options?: RouterOptionsInput);
+  /**
+   * Normalized options for this router instance.
+   */
+  protected _options: Partial<RouterOptions>;
+  constructor(input?: RouterOptionsInput);
   matchPath(path: string): boolean;
   setPath(value?: Path): void;
   /**
-   * Public entry point — creates a RoutupEvent from the request,
+   * Public entry point — creates a DispatcherEvent from the request,
    * runs the pipeline, and returns a Response (with 404/500 fallbacks).
    */
   fetch(request: RoutupRequest): Promise<Response>;
-  protected buildFallbackResponse(request: RoutupRequest, event: RoutupEvent, status: number, message: string): Response;
+  protected buildFallbackResponse(request: RoutupRequest, event: IDispatcherEvent, status: number, message: string): Response;
   protected executePipelineStep(context: RouterPipelineContext): Promise<void>;
   protected executePipelineStepStart(context: RouterPipelineContext): Promise<void>;
   protected executePipelineStepLookup(context: RouterPipelineContext): Promise<void>;
@@ -610,7 +767,7 @@ declare class Router implements IRouter {
   protected executePipelineStepChildAfter(context: RouterPipelineContext): Promise<void>;
   protected executePipelineStepChildDispatch(context: RouterPipelineContext): Promise<void>;
   protected executePipelineStepFinish(context: RouterPipelineContext): Promise<void>;
-  dispatch(event: RoutupEvent): Promise<Response | undefined>;
+  dispatch(event: IDispatcherEvent): Promise<Response | undefined>;
   delete(...handlers: (Handler | HandlerOptions)[]): this;
   delete(path: Path, ...handlers: (Handler | HandlerOptions)[]): this;
   get(...handlers: (Handler | HandlerOptions)[]): this;
@@ -639,16 +796,16 @@ declare class Router implements IRouter {
    * @param name
    * @param fn
    */
-  on(name: `${HookName.REQUEST}` | `${HookName.RESPONSE}` | `${HookName.CHILD_DISPATCH_BEFORE}` | `${HookName.CHILD_DISPATCH_AFTER}`, fn: HookDefaultListener): HookUnsubscribeFn;
-  on(name: `${HookName.CHILD_MATCH}`, fn: HookDefaultListener): HookUnsubscribeFn;
-  on(name: `${HookName.ERROR}`, fn: HookErrorListener): HookUnsubscribeFn;
+  on(name: typeof HookName.REQUEST | typeof HookName.RESPONSE | typeof HookName.CHILD_DISPATCH_BEFORE | typeof HookName.CHILD_DISPATCH_AFTER, fn: HookDefaultListener, priority?: number): HookUnsubscribeFn;
+  on(name: typeof HookName.CHILD_MATCH, fn: HookDefaultListener, priority?: number): HookUnsubscribeFn;
+  on(name: typeof HookName.ERROR, fn: HookErrorListener, priority?: number): HookUnsubscribeFn;
   /**
    * Remove single or all hook listeners.
    *
    * @param name
    */
-  off(name: `${HookName}`): this;
-  off(name: `${HookName}`, fn: HookListener): this;
+  off(name: HookName): this;
+  off(name: HookName, fn: HookListener): this;
 }
 //#endregion
 //#region src/error/create.d.ts
@@ -657,7 +814,7 @@ declare class Router implements IRouter {
  * - an existing RoutupError (returned as-is)
  * - an HTTPError (wrapped into a RoutupError preserving status)
  * - an Error (wrapped preserving message and cause)
- * - an options object (statusCode, statusMessage, etc.)
+ * - an options object (status, message, etc.)
  * - a message string
  *
  * @param input
@@ -706,7 +863,7 @@ type EventStreamOptions = {
   maxMessageSize?: number;
 };
 type EventStreamHandle = {
-  write(message: string | EventStreamMessage): void;
+  write(message: string | EventStreamMessage): boolean;
   end(): void;
   response: Response;
 };
@@ -715,10 +872,6 @@ declare function createEventStream(event: IRoutupEvent, options?: EventStreamOpt
 //#region src/response/helpers/event-stream/utils.d.ts
 declare function serializeEventStreamMessage(message: EventStreamMessage): string;
 //#endregion
-//#region src/response/helpers/gone.d.ts
-declare function isResponseGone(event: IRoutupEvent): boolean;
-declare function setResponseGone(event: IRoutupEvent): void;
-//#endregion
 //#region src/response/helpers/header.d.ts
 declare function appendResponseHeader(event: IRoutupEvent, name: string, value: string | string[]): void;
 declare function appendResponseHeaderDirective(event: IRoutupEvent, name: string, value: string | string[]): void;
@@ -773,23 +926,6 @@ declare function setResponseContentTypeByFileName(event: IRoutupEvent, fileName:
 //#region src/response/to-response.d.ts
 declare function toResponse(value: unknown, event: IRoutupEvent): Promise<Response | undefined>;
 //#endregion
-//#region src/request/helpers/body.d.ts
-/**
- * Read and parse the request body.
- *
- * - `application/x-www-form-urlencoded` → plain object (duplicate keys become arrays)
- * - `application/json` or other → attempts JSON parse, returns undefined on failure
- *
- * The result is cached on the event store — calling `readBody()` multiple
- * times returns the same parsed result.
- *
- * For binary or streaming access, use `event.request.arrayBuffer()`,
- * `event.request.blob()`, or `event.request.body` directly.
- *
- * @experimental
- */
-declare function readBody<T = unknown>(event: IRoutupEvent): Promise<T | undefined>;
-//#endregion
 //#region src/request/helpers/cache.d.ts
 declare function isRequestCacheable(event: IRoutupEvent, modifiedTime: string | Date): boolean;
 //#endregion
@@ -844,5 +980,8 @@ type RequestProtocolOptions = {
 };
 declare function getRequestProtocol(event: IRoutupEvent, options?: RequestProtocolOptions): string;
 //#endregion
-export { RouterPipelineContext as $, sendAccepted as A, RoutupRequest as At, createEventStream as B, sendRedirect as C, PathMatcher as Ct, SendFileStats as D, IDispatcher as Dt, SendFileOptions as E, PathMatcherOptions as Et, isResponseGone as F, MethodName as Ft, isError as G, EventStreamMessage as H, setResponseGone as I, isPlugin as J, createError as K, serializeEventStreamMessage as L, setResponseHeaderAttachment as M, HTTPErrorInput$1 as Mt, appendResponseHeader as N, RoutupError as Nt, sendFile as O, RoutupEvent as Ot, appendResponseHeaderDirective as P, HeaderName as Pt, IRouter as Q, EventStreamHandle as R, sendStream as S, isPath as St, SendFileContentOptions as T, PathMatcherExecResult as Tt, ResponseCacheHeadersOptions as U, EventStreamListener as V, setResponseCacheHeaders as W, PluginInstallContext as X, Plugin as Y, PluginInstallFn as Z, getRequestHeader as _, ErrorHandler as _t, getRequestIP as a, WebHandler as at, toResponse as b, HandlerSymbol as bt, matchRequestContentType as c, fromNodeMiddleware as ct, getRequestAcceptableEncoding as d, defineCoreHandler as dt, isHandler as et, getRequestAcceptableEncodings as f, CoreHandler as ft, getRequestAcceptableContentTypes as g, defineErrorHandler as gt, getRequestAcceptableContentType as h, HandlerOptions as ht, RequestIpOptions as i, fromWebHandler as it, setResponseHeaderContentType as j, RoutupResponse as jt, sendCreated as k, IRoutupEvent as kt, getRequestAcceptableLanguage as l, NodeHandler as lt, getRequestAcceptableCharsets as m, Handler as mt, getRequestProtocol as n, isWebHandler as nt, RequestHostNameOptions as o, WebHandlerProvider as ot, getRequestAcceptableCharset as p, CoreHandlerOptions as pt, Router as q, useRequestNegotiator as r, isWebHandlerProvider as rt, getRequestHostName as s, fromNodeHandler as st, RequestProtocolOptions as t, isHandlerOptions as tt, getRequestAcceptableLanguages as u, NodeMiddleware as ut, isRequestCacheable as v, ErrorHandlerOptions as vt, sendFormat as w, Path as wt, setResponseContentTypeByFileName as x, HandlerType as xt, readBody as y, HandlerBaseOptions as yt, EventStreamOptions as z };
-//# sourceMappingURL=index-BBvBVzPm.d.mts.map
+//#region src/router/options.d.ts
+declare function normalizeRouterOptions(input: RouterOptionsInput): Partial<RouterOptions>;
+//#endregion
+export { Plugin as $, sendAccepted as A, PathMatcher as At, EventStreamMessage as B, RoutupRequest as Bt, sendRedirect as C, defineErrorHandler as Ct, SendFileStats as D, HandlerSymbol as Dt, SendFileOptions as E, HandlerBaseOptions as Et, serializeEventStreamMessage as F, IDispatcherEvent as Ft, Router as G, HeaderName as Gt, setResponseCacheHeaders as H, ErrorSymbol as Ht, EventStreamHandle as I, RoutupEvent as It, RouterOptions as J, DispatcherEvent as K, MethodName as Kt, EventStreamOptions as L, RoutupEventCreateContext as Lt, setResponseHeaderAttachment as M, PathMatcherExecResult as Mt, appendResponseHeader as N, PathMatcherOptions as Nt, sendFile as O, HandlerType as Ot, appendResponseHeaderDirective as P, IDispatcher as Pt, isPlugin as Q, createEventStream as R, IRoutupEvent as Rt, sendStream as S, HandlerOptions as St, SendFileContentOptions as T, ErrorHandlerOptions as Tt, isError as U, HTTPErrorInput$1 as Ut, ResponseCacheHeadersOptions as V, RoutupResponse as Vt, createError as W, RoutupError as Wt, RouterPathNode as X, RouterOptionsInput as Y, RouterPipelineContext as Z, getRequestAcceptableContentTypes as _, NodeMiddleware as _t, RequestIpOptions as a, PluginError as at, toResponse as b, CoreHandlerOptions as bt, getRequestHostName as c, isHandlerOptions as ct, getRequestAcceptableLanguages as d, fromWebHandler as dt, PluginInstallContext as et, getRequestAcceptableEncoding as f, WebHandler as ft, getRequestAcceptableContentType as g, NodeHandler as gt, getRequestAcceptableCharsets as h, fromNodeMiddleware as ht, useRequestNegotiator as i, isPluginError as it, setResponseHeaderContentType as j, Path as jt, sendCreated as k, isPath as kt, matchRequestContentType as l, isWebHandler as lt, getRequestAcceptableCharset as m, fromNodeHandler as mt, RequestProtocolOptions as n, PluginNotInstalledError as nt, getRequestIP as o, PluginErrorCode as ot, getRequestAcceptableEncodings as p, WebHandlerProvider as pt, IRouter as q, getRequestProtocol as r, PluginInstallError as rt, RequestHostNameOptions as s, isHandler as st, normalizeRouterOptions as t, PluginInstallFn as tt, getRequestAcceptableLanguage as u, isWebHandlerProvider as ut, getRequestHeader as v, defineCoreHandler as vt, sendFormat as w, ErrorHandler as wt, setResponseContentTypeByFileName as x, Handler as xt, isRequestCacheable as y, CoreHandler as yt, EventStreamListener as z, NextFn as zt };
+//# sourceMappingURL=index-doDmTYzg.d.mts.map