routup 4.0.2 → 5.0.0-beta.0

package/dist/index-9K5FcIb3.d.cts

@@ -0,0 +1,786 @@
+import { FastURL, ServerRequest } from "srvx";
+import { HTTPError, HTTPErrorInput, HTTPErrorInput as HTTPErrorInput$1 } from "@ebec/http";
+import { Key, ParseOptions, PathToRegexpOptions } from "path-to-regexp";
+import { IncomingMessage, ServerResponse } from "node:http";
+import Negotiator from "negotiator";
+
+//#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"
+}
+//#endregion
+//#region src/error/module.d.ts
+declare class RoutupError extends HTTPError {
+  constructor(input?: HTTPErrorInput$1);
+}
+//#endregion
+//#region src/event/types.d.ts
+type RoutupResponse = {
+  status: number;
+  headers: Headers;
+  statusText?: string;
+};
+type RoutupRequest = ServerRequest;
+interface IRoutupEvent {
+  /**
+   * 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;
+  /**
+   * Error that occurred during dispatch, if any.
+   */
+  error?: RoutupError;
+  /**
+   * Router ID stack for nesting tracking.
+   * Used internally by router options resolution.
+   */
+  routerPath: number[];
+  /**
+   * Web Standard Headers from the request.
+   */
+  readonly headers: Headers;
+  /**
+   * Lazily-parsed URL search parameters.
+   *
+   * For advanced query parsing (arrays, nesting), use `@routup/query`.
+   */
+  readonly searchParams: URLSearchParams;
+  /**
+   * Response accumulator — set status/headers before returning a plain value.
+   *
+   * If the handler returns a `Response` object directly, these values are
+   * ignored. They only apply when returning plain values (string, object, etc.)
+   * that go through `toResponse()`.
+   */
+  readonly response: RoutupResponse;
+  /**
+   * Whether a response has been produced.
+   */
+  dispatched: boolean;
+  /**
+   * Per-request store for caching and plugin state.
+   *
+   * Use symbol keys (e.g., `Symbol.for('routup:body')`) to avoid collisions.
+   * Data is garbage collected with the event when the request completes.
+   */
+  readonly store: Record<string | symbol, unknown>;
+  /**
+   * 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>;
+}
+//#endregion
+//#region src/event/module.d.ts
+declare class RoutupEvent implements IRoutupEvent {
+  readonly request: RoutupRequest;
+  params: Record<string, any>;
+  path: string;
+  readonly method: string;
+  mountPath: string;
+  error?: RoutupError;
+  routerPath: number[];
+  /**
+   * Collected allowed methods (for OPTIONS).
+   */
+  methodsAllowed: string[];
+  readonly store: Record<string | symbol, unknown>;
+  protected _dispatched: boolean;
+  protected _response?: RoutupResponse;
+  /**
+   * Cached parsed URL (avoids double-parsing).
+   */
+  protected _url: InstanceType<typeof FastURL>;
+  protected _searchParams?: URLSearchParams;
+  /**
+   * Continuation function for middleware onion model.
+   */
+  _next?: () => Promise<Response | undefined>;
+  /**
+   * Whether _next has already been called (guard against double-invocation).
+   */
+  _nextCalled: boolean;
+  /**
+   * The cached result of the next handler.
+   */
+  _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>;
+}
+//#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"
+}
+//#endregion
+//#region src/hook/types.d.ts
+type HookErrorListener = (event: IRoutupEvent) => Promise<unknown> | unknown;
+type HookDefaultListener = (event: IRoutupEvent) => Promise<unknown> | unknown;
+type HookListener = HookErrorListener | HookDefaultListener;
+type HookUnsubscribeFn = () => void;
+//#endregion
+//#region src/hook/module.d.ts
+declare class HookManager {
+  protected items: Record<string, HookListener[]>;
+  constructor();
+  addListener(name: `${HookName}`, fn: HookListener): HookUnsubscribeFn;
+  removeListener(name: `${HookName}`): void;
+  removeListener(name: `${HookName}`, fn: HookListener): void;
+  trigger(name: `${HookName}`, event: IRoutupEvent): Promise<void>;
+  private triggerListener;
+  private isErrorListenerHook;
+}
+//#endregion
+//#region src/path/type.d.ts
+type PathMatcherOptions = PathToRegexpOptions & ParseOptions;
+type PathMatcherExecResult = {
+  path: string;
+  params: Record<string, any>;
+};
+type Path = string;
+//#endregion
+//#region src/path/matcher.d.ts
+declare class PathMatcher {
+  protected path: Path;
+  protected regexp: RegExp;
+  protected regexpKeys: Key[];
+  protected regexpOptions: PathMatcherOptions;
+  constructor(path: Path, options?: PathMatcherOptions);
+  test(path: string): boolean;
+  exec(path: string): PathMatcherExecResult | undefined;
+}
+//#endregion
+//#region src/path/utils.d.ts
+declare function isPath(input: unknown): input is Path;
+//#endregion
+//#region src/handler/constants.d.ts
+declare enum HandlerType {
+  CORE = "core",
+  ERROR = "error"
+}
+declare const HandlerSymbol: unique symbol;
+//#endregion
+//#region src/handler/types-base.d.ts
+type HandlerBaseConfig = {
+  method?: Uppercase<MethodName> | Lowercase<MethodName>;
+  path?: Path;
+  onError?: HookErrorListener;
+  onBefore?: HookDefaultListener;
+  onAfter?: HookDefaultListener;
+};
+//#endregion
+//#region src/handler/error/types.d.ts
+type ErrorHandlerFn = (error: RoutupError, event: IRoutupEvent) => unknown | Promise<unknown>;
+type ErrorHandlerConfig = HandlerBaseConfig & {
+  type: `${HandlerType.ERROR}`;
+  fn: ErrorHandlerFn;
+};
+//#endregion
+//#region src/handler/error/define.d.ts
+declare function errorHandler(input: Omit<ErrorHandlerConfig, 'type'>): Handler;
+declare function errorHandler(input: ErrorHandlerFn): Handler;
+//#endregion
+//#region src/handler/types.d.ts
+type HandlerConfig = CoreHandlerConfig | ErrorHandlerConfig;
+type HandlerFn = CoreHandlerFn | ErrorHandlerFn;
+//#endregion
+//#region src/handler/module.d.ts
+declare class Handler implements IDispatcher {
+  readonly '@instanceof': symbol;
+  protected config: HandlerConfig;
+  protected hookManager: HookManager;
+  protected pathMatcher: PathMatcher | undefined;
+  protected _method: MethodName | undefined;
+  constructor(handler: HandlerConfig);
+  get type(): "error" | "core";
+  get path(): string | undefined;
+  get method(): MethodName | undefined;
+  dispatch(event: RoutupEvent): Promise<Response | undefined>;
+  matchPath(path: string): boolean;
+  setPath(path?: Path): void;
+  matchMethod(method: `${MethodName}`): boolean;
+  setMethod(input?: `${MethodName}`): void;
+  protected mountHooks(): void;
+}
+//#endregion
+//#region src/handler/core/types.d.ts
+type CoreHandlerFn = (event: IRoutupEvent) => unknown | Promise<unknown>;
+type CoreHandlerConfig = HandlerBaseConfig & {
+  type: `${HandlerType.CORE}`;
+  fn: CoreHandlerFn;
+};
+//#endregion
+//#region src/handler/core/define.d.ts
+declare function coreHandler(input: Omit<CoreHandlerConfig, 'type'>): Handler;
+declare function coreHandler(input: CoreHandlerFn): Handler;
+//#endregion
+//#region src/handler/helpers/from-node-handler.d.ts
+type NodeHandler = (req: IncomingMessage, res: ServerResponse) => unknown | Promise<unknown>;
+type NodeMiddleware = (req: IncomingMessage, res: ServerResponse, next: (err?: unknown) => void) => unknown | Promise<unknown>;
+/**
+ * Wraps a Node.js `(req, res)` handler for use in the routup pipeline.
+ *
+ * @example
+ * ```typescript
+ * import { fromNodeHandler } from 'routup/node';
+ *
+ * router.use(fromNodeHandler((req, res) => {
+ *     res.end('Hello');
+ * }));
+ * ```
+ */
+declare function fromNodeHandler(handler: NodeHandler): Handler;
+/**
+ * Wraps a Node.js `(req, res, next)` middleware for use in the routup pipeline.
+ *
+ * @example
+ * ```typescript
+ * import cors from 'cors';
+ * import { fromNodeMiddleware } from 'routup/node';
+ *
+ * router.use(fromNodeMiddleware(cors()));
+ * ```
+ */
+declare function fromNodeMiddleware(handler: NodeMiddleware): Handler;
+//#endregion
+//#region src/handler/is.d.ts
+declare function isHandlerConfig(input: unknown): input is HandlerConfig;
+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
+}
+//#endregion
+//#region src/router/types.d.ts
+type RouterPipelineContext = {
+  step: RouterPipelineStep;
+  event: RoutupEvent;
+  stackIndex: number;
+  response?: Response;
+};
+interface IRouter extends IDispatcher {
+  /**
+   * Unique identifier for this router instance.
+   */
+  readonly id: number;
+  /**
+   * Optional label for the router instance.
+   */
+  readonly name?: string;
+  /**
+   * Public entry point — processes a request through the pipeline
+   * and returns a Response (with 404/500 fallbacks).
+   */
+  fetch(request: RoutupRequest): Promise<Response>;
+  /**
+   * Test if a path matches this router's mount path.
+   */
+  matchPath(path: string): boolean;
+  /**
+   * Set or clear the router's mount path.
+   */
+  setPath(value?: Path): void;
+  /**
+   * Register a handler, router, or plugin.
+   * When a path is provided, the item is mounted at that path.
+   */
+  use(router: IRouter): this;
+  use(handler: Handler | HandlerConfig): this;
+  use(plugin: Plugin): this;
+  use(path: Path, router: IRouter): this;
+  use(path: Path, handler: Handler | HandlerConfig): this;
+  use(path: Path, plugin: Plugin): this;
+  /** Register GET handler(s). */
+  get(...handlers: (Handler | HandlerConfig)[]): this;
+  get(path: Path, ...handlers: (Handler | HandlerConfig)[]): this;
+  /** Register POST handler(s). */
+  post(...handlers: (Handler | HandlerConfig)[]): this;
+  post(path: Path, ...handlers: (Handler | HandlerConfig)[]): this;
+  /** Register PUT handler(s). */
+  put(...handlers: (Handler | HandlerConfig)[]): this;
+  put(path: Path, ...handlers: (Handler | HandlerConfig)[]): this;
+  /** Register PATCH handler(s). */
+  patch(...handlers: (Handler | HandlerConfig)[]): this;
+  patch(path: Path, ...handlers: (Handler | HandlerConfig)[]): this;
+  /** Register DELETE handler(s). */
+  delete(...handlers: (Handler | HandlerConfig)[]): this;
+  delete(path: Path, ...handlers: (Handler | HandlerConfig)[]): this;
+  /** Register HEAD handler(s). */
+  head(...handlers: (Handler | HandlerConfig)[]): this;
+  head(path: Path, ...handlers: (Handler | HandlerConfig)[]): this;
+  /** Register OPTIONS handler(s). */
+  options(...handlers: (Handler | HandlerConfig)[]): this;
+  options(path: Path, ...handlers: (Handler | HandlerConfig)[]): this;
+  /**
+   * Mount an external fetch handler at the given path.
+   * The handler receives requests with the mount prefix stripped from the URL.
+   *
+   * @experimental
+   */
+  mount(path: Path, handler: {
+    fetch: (request: Request) => Response | Promise<Response>;
+  }): this;
+  mount(path: Path, handler: (request: Request) => Response | Promise<Response>): this;
+  /**
+   * 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;
+  /**
+   * Remove a specific or all hook listeners for the given hook name.
+   */
+  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;
+  /**
+   * default: 0
+   */
+  proxyIpMax: number;
+  /**
+   * default: () => true
+   */
+  etag: EtagFn;
+  /**
+   * default: () => false
+   */
+  trustProxy: TrustProxyFn;
+};
+type RouterOptionsInput = Omit<Partial<RouterOptions>, 'etag' | 'trustProxy'> & {
+  /**
+   * default: true
+   */
+  etag?: EtagInput;
+  /**
+   * default: false
+   */
+  trustProxy?: TrustProxyInput;
+};
+//#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.
+   */
+  readonly name?: string;
+  /**
+   * Array of mounted layers, routes & routers.
+   *
+   * @protected
+   */
+  protected stack: (Router | Handler)[];
+  /**
+   * Path matcher for the current mount path.
+   *
+   * @protected
+   */
+  protected pathMatcher: PathMatcher | undefined;
+  /**
+   * A hook manager.
+   *
+   * @protected
+   */
+  protected hookManager: HookManager;
+  constructor(options?: RouterOptionsInput);
+  matchPath(path: string): boolean;
+  setPath(value?: Path): void;
+  /**
+   * Public entry point — creates a RoutupEvent 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 executePipelineStep(context: RouterPipelineContext): Promise<void>;
+  protected executePipelineStepStart(context: RouterPipelineContext): Promise<void>;
+  protected executePipelineStepLookup(context: RouterPipelineContext): Promise<void>;
+  protected executePipelineStepChildBefore(context: RouterPipelineContext): Promise<void>;
+  protected executePipelineStepChildAfter(context: RouterPipelineContext): Promise<void>;
+  protected executePipelineStepChildDispatch(context: RouterPipelineContext): Promise<void>;
+  protected executePipelineStepFinish(context: RouterPipelineContext): Promise<void>;
+  dispatch(event: RoutupEvent): Promise<Response | undefined>;
+  delete(...handlers: (Handler | HandlerConfig)[]): this;
+  delete(path: Path, ...handlers: (Handler | HandlerConfig)[]): this;
+  get(...handlers: (Handler | HandlerConfig)[]): this;
+  get(path: Path, ...handlers: (Handler | HandlerConfig)[]): this;
+  post(...handlers: (Handler | HandlerConfig)[]): this;
+  post(path: Path, ...handlers: (Handler | HandlerConfig)[]): this;
+  put(...handlers: (Handler | HandlerConfig)[]): this;
+  put(path: Path, ...handlers: (Handler | HandlerConfig)[]): this;
+  patch(...handlers: (Handler | HandlerConfig)[]): this;
+  patch(path: Path, ...handlers: (Handler | HandlerConfig)[]): this;
+  head(...handlers: (Handler | HandlerConfig)[]): this;
+  head(path: Path, ...handlers: (Handler | HandlerConfig)[]): this;
+  options(...handlers: (Handler | HandlerConfig)[]): this;
+  options(path: Path, ...handlers: (Handler | HandlerConfig)[]): this;
+  protected useForMethod(method: MethodName, ...input: (Path | Handler | HandlerConfig)[]): void;
+  /**
+   * Mount an external fetch handler at the given path.
+   * The handler receives requests with the mount prefix stripped from the URL.
+   *
+   * @experimental
+   */
+  mount(path: Path, handler: {
+    fetch: (request: Request) => Response | Promise<Response>;
+  }): this;
+  mount(path: Path, handler: (request: Request) => Response | Promise<Response>): this;
+  use(router: Router): this;
+  use(handler: Handler | HandlerConfig): this;
+  use(plugin: Plugin): this;
+  use(path: Path, router: Router): this;
+  use(path: Path, handler: Handler | HandlerConfig): this;
+  use(path: Path, plugin: Plugin): this;
+  protected install(plugin: Plugin, context?: PluginInstallContext): this;
+  /**
+   * Add a hook listener.
+   *
+   * @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;
+  /**
+   * Remove single or all hook listeners.
+   *
+   * @param name
+   */
+  off(name: `${HookName}`): this;
+  off(name: `${HookName}`, fn: HookListener): this;
+}
+//#endregion
+//#region src/error/create.d.ts
+/**
+ * Create an internal error object by
+ * - 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.)
+ * - a message string
+ *
+ * @param input
+ */
+declare function createError(input: HTTPErrorInput | unknown): RoutupError;
+//#endregion
+//#region src/error/is.d.ts
+declare function isError(input: unknown): input is RoutupError;
+//#endregion
+//#region src/response/helpers/cache.d.ts
+type ResponseCacheHeadersOptions = {
+  maxAge?: number;
+  modifiedTime?: string | Date;
+  cacheControls?: string[];
+};
+declare function setResponseCacheHeaders(event: IRoutupEvent, options?: ResponseCacheHeadersOptions): void;
+//#endregion
+//#region src/response/helpers/event-stream/types.d.ts
+/**
+ * https://developer.mozilla.org/en-US/docs/Web/API/Server-sent_events/Using_server-sent_events#event_stream_format
+ */
+type EventStreamMessage = {
+  /**
+   * The event ID to set the EventSource object's last event ID value.
+   */
+  id?: string;
+  /**
+   * The reconnection time.
+   * If the connection to the server is lost, the browser will wait for the specified time before attempting to reconnect.
+   * This must be an integer, specifying the reconnection time in milliseconds.
+   */
+  retry?: number;
+  /**
+   * The data field for the message.
+   */
+  data: string;
+  /**
+   * A string identifying the type of event described.
+   */
+  event?: string;
+};
+type EventStreamListener<T = any> = (err: Error | null, data: T) => void | Promise<void>;
+//#endregion
+//#region src/response/helpers/event-stream/module.d.ts
+type EventStreamOptions = {
+  maxMessageSize?: number;
+};
+type EventStreamHandle = {
+  write(message: string | EventStreamMessage): void;
+  end(): void;
+  response: Response;
+};
+declare function createEventStream(event: IRoutupEvent, options?: EventStreamOptions): EventStreamHandle;
+//#endregion
+//#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;
+//#endregion
+//#region src/response/helpers/header-attachment.d.ts
+declare function setResponseHeaderAttachment(event: IRoutupEvent, filename?: string): void;
+//#endregion
+//#region src/response/helpers/header-content-type.d.ts
+declare function setResponseHeaderContentType(event: IRoutupEvent, input: string, ifNotExists?: boolean): void;
+//#endregion
+//#region src/response/helpers/send-accepted.d.ts
+declare function sendAccepted(event: IRoutupEvent, data?: unknown): Promise<Response>;
+//#endregion
+//#region src/response/helpers/send-created.d.ts
+declare function sendCreated(event: IRoutupEvent, data?: unknown): Promise<Response>;
+//#endregion
+//#region src/response/helpers/send-file.d.ts
+type SendFileContentOptions = {
+  end?: number;
+  start?: number;
+};
+type SendFileStats = {
+  size?: number;
+  mtime?: Date | number | string;
+  name?: string;
+};
+type SendFileOptions = {
+  stats: () => Promise<SendFileStats> | SendFileStats;
+  content: (options: SendFileContentOptions) => Promise<ReadableStream | ArrayBuffer | Uint8Array> | ReadableStream | ArrayBuffer | Uint8Array;
+  attachment?: boolean;
+  name?: string;
+};
+declare function sendFile(event: IRoutupEvent, options: SendFileOptions): Promise<Response>;
+//#endregion
+//#region src/response/helpers/send-format.d.ts
+type ResponseFormatHandler = () => Response | unknown;
+type ResponseFormats = {
+  default: ResponseFormatHandler;
+  [key: string]: ResponseFormatHandler;
+};
+declare function sendFormat(event: IRoutupEvent, input: ResponseFormats): Response | unknown | undefined;
+//#endregion
+//#region src/response/helpers/send-redirect.d.ts
+declare function sendRedirect(event: IRoutupEvent, location: string, statusCode?: number): Response;
+//#endregion
+//#region src/response/helpers/send-stream.d.ts
+declare function sendStream(event: IRoutupEvent, stream: ReadableStream): Response;
+//#endregion
+//#region src/response/helpers/utils.d.ts
+declare function setResponseContentTypeByFileName(event: IRoutupEvent, fileName: string): void;
+//#endregion
+//#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
+//#region src/request/helpers/header.d.ts
+declare function getRequestHeader(event: IRoutupEvent, name: string): string | null;
+//#endregion
+//#region src/request/helpers/header-accept.d.ts
+declare function getRequestAcceptableContentTypes(event: IRoutupEvent): string[];
+declare function getRequestAcceptableContentType(event: IRoutupEvent, input?: string | string[]): string | undefined;
+//#endregion
+//#region src/request/helpers/header-accept-charset.d.ts
+declare function getRequestAcceptableCharsets(event: IRoutupEvent): string[];
+declare function getRequestAcceptableCharset(event: IRoutupEvent, input: string | string[]): string | undefined;
+//#endregion
+//#region src/request/helpers/header-accept-encoding.d.ts
+declare function getRequestAcceptableEncodings(event: IRoutupEvent): string[];
+declare function getRequestAcceptableEncoding(event: IRoutupEvent, input: string | string[]): string | undefined;
+//#endregion
+//#region src/request/helpers/header-accept-language.d.ts
+declare function getRequestAcceptableLanguages(event: IRoutupEvent): string[];
+declare function getRequestAcceptableLanguage(event: IRoutupEvent, input?: string | string[]): string | undefined;
+//#endregion
+//#region src/request/helpers/header-content-type.d.ts
+declare function matchRequestContentType(event: IRoutupEvent, contentType: string): boolean;
+//#endregion
+//#region src/request/helpers/hostname.d.ts
+type RequestHostNameOptions = {
+  trustProxy?: TrustProxyInput;
+};
+declare function getRequestHostName(event: IRoutupEvent, options?: RequestHostNameOptions): string | undefined;
+//#endregion
+//#region src/request/helpers/ip.d.ts
+type RequestIpOptions = {
+  trustProxy?: boolean;
+};
+declare function getRequestIP(event: IRoutupEvent, options?: RequestIpOptions): string | undefined;
+//#endregion
+//#region src/request/helpers/negotiator.d.ts
+declare function useRequestNegotiator(event: IRoutupEvent): Negotiator;
+//#endregion
+//#region src/request/helpers/protocol.d.ts
+type RequestProtocolOptions = {
+  trustProxy?: TrustProxyInput;
+  default?: string;
+};
+declare function getRequestProtocol(event: IRoutupEvent, options?: RequestProtocolOptions): string;
+//#endregion
+export { RouterPipelineContext as $, sendAccepted as A, HeaderName as At, createEventStream as B, sendRedirect as C, IDispatcher as Ct, SendFileStats as D, RoutupResponse as Dt, SendFileOptions as E, RoutupRequest as Et, isResponseGone as F, isError as G, EventStreamMessage as H, setResponseGone as I, isPlugin as J, createError as K, serializeEventStreamMessage as L, setResponseHeaderAttachment as M, appendResponseHeader as N, sendFile as O, HTTPErrorInput$1 as Ot, appendResponseHeaderDirective as P, IRouter as Q, EventStreamHandle as R, sendStream as S, PathMatcherOptions as St, SendFileContentOptions as T, IRoutupEvent as Tt, ResponseCacheHeadersOptions as U, EventStreamListener as V, setResponseCacheHeaders as W, PluginInstallContext as X, Plugin as Y, PluginInstallFn as Z, getRequestHeader as _, HandlerType as _t, getRequestIP as a, fromNodeMiddleware as at, toResponse as b, Path as bt, matchRequestContentType as c, CoreHandlerFn as ct, getRequestAcceptableEncoding as d, HandlerFn as dt, isHandler as et, getRequestAcceptableEncodings as f, errorHandler as ft, getRequestAcceptableContentTypes as g, HandlerSymbol as gt, getRequestAcceptableContentType as h, HandlerBaseConfig as ht, RequestIpOptions as i, fromNodeHandler as it, setResponseHeaderContentType as j, MethodName as jt, sendCreated as k, RoutupError as kt, getRequestAcceptableLanguage as l, Handler as lt, getRequestAcceptableCharsets as m, ErrorHandlerFn as mt, getRequestProtocol as n, NodeHandler as nt, RequestHostNameOptions as o, coreHandler as ot, getRequestAcceptableCharset as p, ErrorHandlerConfig as pt, Router as q, useRequestNegotiator as r, NodeMiddleware as rt, getRequestHostName as s, CoreHandlerConfig as st, RequestProtocolOptions as t, isHandlerConfig as tt, getRequestAcceptableLanguages as u, HandlerConfig as ut, isRequestCacheable as v, isPath as vt, sendFormat as w, RoutupEvent as wt, setResponseContentTypeByFileName as x, PathMatcherExecResult as xt, readBody as y, PathMatcher as yt, EventStreamOptions as z };
+//# sourceMappingURL=index-9K5FcIb3.d.cts.map