@adonix.org/cloud-spark 0.0.108 → 0.0.109

package/README.md

@@ -3,8 +3,8 @@
 [![npm version](https://img.shields.io/npm/v/@adonix.org/cloud-spark.svg?color=blue)](https://www.npmjs.com/package/@adonix.org/cloud-spark)
 [![Apache 2.0 License](https://img.shields.io/badge/License-Apache%202.0-blue.svg)](https://github.com/adonix-org/cloud-spark/blob/main/LICENSE)
 [![Build](https://github.com/adonix-org/cloud-spark/actions/workflows/build.yml/badge.svg)](https://github.com/adonix-org/postrise/actions/workflows/build.yml)
-[![Quality Gate Status](https://sonarcloud.io/api/project_badges/measure?project=adonix-org_cloud-spark&metric=alert_status)](https://sonarcloud.io/summary/new_code?id=adonix-org_cloud-spark)
-[![Security Rating](https://sonarcloud.io/api/project_badges/measure?project=adonix-org_cloud-spark&metric=security_rating)](https://sonarcloud.io/summary/new_code?id=adonix-org_cloud-spark)
-[![Coverage](https://sonarcloud.io/api/project_badges/measure?project=adonix-org_cloud-spark&metric=coverage)](https://sonarcloud.io/summary/new_code?id=adonix-org_cloud-spark)
+[![Quality Gate Status](https://sonarcloud.io/api/project_badges/measure?project=adonix-org_cloud-spark&metric=alert_status)](https://sonarcloud.io/summary/overall?id=adonix-org_cloud-spark&branch=main)
+[![Security Rating](https://sonarcloud.io/api/project_badges/measure?project=adonix-org_cloud-spark&metric=security_rating)](https://sonarcloud.io/summary/overall?id=adonix-org_cloud-spark&branch=main)
+[![Coverage](https://sonarcloud.io/api/project_badges/measure?project=adonix-org_cloud-spark&metric=coverage)](https://sonarcloud.io/summary/overall?id=adonix-org_cloud-spark&branch=main)
 
 Ignite your Cloudflare Workers with a type-safe library for rapid development.

package/dist/index.d.ts

@@ -1,6 +1,6 @@
+import CacheLib from 'cache-control-parser';
 import { StatusCodes } from 'http-status-codes';
 export { StatusCodes } from 'http-status-codes';
-import CacheLib from 'cache-control-parser';
 import { MatchFunction } from 'path-to-regexp';
 
 /**
@@ -223,136 +223,231 @@ interface Worker {
     getAllowedMethods(): Method[];
 }
 
-type CorsWorker = Worker & CorsProvider;
+/**
+ * Default CORS configuration used by `CorsProvider`.
+ *
+ * By default, all origins are allowed, only `Content-Type` is allowed as a header,
+ * no headers are exposed, and preflight caching is 1 week.
+ *
+ * @see {@link CorsConfig}
+ */
+declare const DEFAULT_CORS_CONFIG: Required<CorsConfig>;
+/**
+ * Configuration options for `CorsProvider`.
+ *
+ * @see {@link DEFAULT_CORS_CONFIG}
+ */
+interface CorsConfig {
+    /** Origins allowed for CORS requests. */
+    allowedOrigins?: string[];
+    /** Allowed HTTP headers for CORS requests. */
+    allowedHeaders?: string[];
+    /** HTTP headers exposed to the client. */
+    exposedHeaders?: string[];
+    /** Max age in seconds for CORS preflight caching. */
+    maxAge?: number;
+}
+/**
+ * Provides CORS settings for a worker.
+ *
+ * Combines a user-supplied `CorsConfig` with defaults. Used by
+ * `CorsHandler` to automatically set the appropriate headers.
+ */
+declare class CorsProvider {
+    private readonly config;
+    /**
+     * Create a new `CorsProvider`.
+     *
+     * @param config - Optional configuration to override defaults.
+     */
+    constructor(config?: CorsConfig);
+    /** Returns the allowed origins. Default: all (`*`). */
+    getAllowedOrigins(): string[];
+    /** Returns the allowed HTTP headers. Default: `["Content-Type"]`. */
+    getAllowedHeaders(): string[];
+    /** Returns headers exposed to the client. Default: `[]`. */
+    getExposedHeaders(): string[];
+    /** Returns the max age in seconds for preflight requests. Default: 1 week. */
+    getMaxAge(): number;
+}
+/**
+ * Constants for common CORS headers.
+ */
+declare namespace Cors {
+    const MAX_AGE = "Access-Control-Max-Age";
+    const ALLOW_ORIGIN = "Access-Control-Allow-Origin";
+    const ALLOW_HEADERS = "Access-Control-Allow-Headers";
+    const ALLOW_METHODS = "Access-Control-Allow-Methods";
+    const EXPOSE_HEADERS = "Access-Control-Expose-Headers";
+    const ALLOW_CREDENTIALS = "Access-Control-Allow-Credentials";
+    const ALLOW_ALL_ORIGINS = "*";
+}
+/**
+ * Adds or updates CORS headers on a Headers object according to the provided policy.
+ *
+ * Behavior:
+ * - Removes any existing CORS headers to avoid stale values.
+ * - If the request has no origin, the function exits early.
+ * - If wildcard `*` is allowed, sets Access-Control-Allow-Origin to `*`.
+ * - If the origin is explicitly allowed, sets the correct headers including credentials.
+ * - Optional headers (Expose-Headers, Allow-Headers, Allow-Methods, Max-Age) are always applied.
+ *
+ * @param cors The CorsProvider instance that determines allowed origins and headers
+ * @param headers The Headers object to update
+ */
+declare function addCorsHeaders(worker: Worker, cors: CorsProvider, headers: Headers): void;
+/**
+ * Determines if a CORS policy allows any origin (`*`).
+ *
+ * @param cors - The `CorsProvider` instance to check.
+ * @returns `true` if the allowed origins include `"*"`, otherwise `false`.
+ */
+declare function allowAnyOrigin(cors: CorsProvider): boolean;
+
+/**
+ * Base class for building HTTP responses.
+ * Manages headers, status, and media type.
+ */
 declare abstract class BaseResponse {
+    readonly worker: Worker;
+    constructor(worker: Worker);
+    /** HTTP headers for the response. */
     headers: Headers;
+    /** HTTP status code (default 200 OK). */
     status: StatusCodes;
+    /** Optional status text. Defaults to standard reason phrase. */
     statusText?: string;
+    /** Optional media type of the response body. */
     mediaType?: MediaType;
+    /** Converts current state to ResponseInit for constructing a Response. */
     protected get responseInit(): ResponseInit;
+    /** Sets a header, overwriting any existing value. */
     setHeader(key: string, value: string | string[]): void;
+    /** Merges a header with existing values (does not overwrite). */
     mergeHeader(key: string, value: string | string[]): void;
+    /** Adds a Content-Type header based on the media type if set. */
     addContentType(): void;
 }
-declare abstract class CorsResponse extends BaseResponse {
-    readonly worker: CorsWorker;
-    constructor(worker: CorsWorker);
-    protected addCorsHeaders(): void;
-    protected getOrigin(): string | null;
-}
-declare abstract class CacheResponse extends CorsResponse {
+/**
+ * Base response class that adds caching headers.
+ */
+declare abstract class CacheResponse extends BaseResponse {
     cache?: CacheControl | undefined;
-    constructor(worker: CorsWorker, cache?: CacheControl | undefined);
+    constructor(worker: Worker, cache?: CacheControl | undefined);
+    /** Adds Cache-Control header if caching is configured. */
     protected addCacheHeader(): void;
 }
+/**
+ * Core worker response. Combines caching, and security headers.
+ */
 declare abstract class WorkerResponse extends CacheResponse {
     private readonly body;
-    constructor(worker: CorsWorker, body?: BodyInit | null, cache?: CacheControl);
+    constructor(worker: Worker, body?: BodyInit | null, cache?: CacheControl);
+    /** Builds the Response object with body, headers, and status. */
     getResponse(): Promise<Response>;
+    /** Adds default security headers. */
     protected addSecurityHeaders(): void;
 }
+/**
+ * Wraps an existing Response and clones its body, headers, and status.
+ */
 declare class ClonedResponse extends WorkerResponse {
-    constructor(worker: CorsWorker, response: Response, cache?: CacheControl);
+    constructor(worker: Worker, response: Response, cache?: CacheControl);
 }
+/**
+ * Represents a successful response with customizable body and status.
+ */
 declare class SuccessResponse extends WorkerResponse {
-    constructor(worker: CorsWorker, body?: BodyInit | null, cache?: CacheControl, status?: StatusCodes);
+    constructor(worker: Worker, body?: BodyInit | null, cache?: CacheControl, status?: StatusCodes);
 }
+/**
+ * JSON response. Automatically sets Content-Type to application/json.
+ */
 declare class JsonResponse extends SuccessResponse {
-    constructor(worker: CorsWorker, json?: unknown, cache?: CacheControl, status?: StatusCodes);
-}
-declare class HtmlResponse extends SuccessResponse {
-    constructor(worker: CorsWorker, body: string, cache?: CacheControl, status?: StatusCodes);
-}
-declare class TextResponse extends SuccessResponse {
-    constructor(worker: CorsWorker, content: string, cache?: CacheControl, status?: StatusCodes);
+    constructor(worker: Worker, json?: unknown, cache?: CacheControl, status?: StatusCodes);
 }
 /**
- * Removes the body from a GET response.
+ * HTML response. Automatically sets Content-Type to text/html.
  */
-declare class Head extends WorkerResponse {
-    constructor(worker: CorsWorker, get: Response);
-}
-declare class Options extends SuccessResponse {
-    constructor(worker: CorsWorker);
+declare class HtmlResponse extends SuccessResponse {
+    constructor(worker: Worker, body: string, cache?: CacheControl, status?: StatusCodes);
 }
-
 /**
- * Implementations will provide a specific CORS policy.
+ * Plain text response. Automatically sets Content-Type to text/plain.
  */
-interface CorsProvider {
-    /** Returns a list of allowed origins. */
-    getAllowedOrigins(): string[];
-    /** Returns true if any origin is allowed (`*`). */
-    allowAnyOrigin(): boolean;
-    /** Returns the HTTP headers allowed by CORS. */
-    getAllowedHeaders(): string[];
-    /** Returns the HTTP headers that should be exposed to the browser. */
-    getExposedHeaders(): string[];
-    /** Returns the max age (in seconds) for CORS preflight caching. */
-    getMaxAge(): number;
+declare class TextResponse extends SuccessResponse {
+    constructor(worker: Worker, content: string, cache?: CacheControl, status?: StatusCodes);
 }
 /**
- * Constants for common CORS headers.
+ * Response for HEAD requests. Clones headers but has no body.
  */
-declare namespace Cors {
-    const MAX_AGE = "Access-Control-Max-Age";
-    const ALLOW_ORIGIN = "Access-Control-Allow-Origin";
-    const ALLOW_HEADERS = "Access-Control-Allow-Headers";
-    const ALLOW_METHODS = "Access-Control-Allow-Methods";
-    const EXPOSE_HEADERS = "Access-Control-Expose-Headers";
-    const ALLOW_CREDENTIALS = "Access-Control-Allow-Credentials";
-    const ALLOW_ALL_ORIGINS = "*";
+declare class Head extends WorkerResponse {
+    constructor(worker: Worker, get: Response);
 }
 /**
- * Adds or updates CORS headers on a Headers object according to the provided policy.
- *
- * Behavior:
- * - Removes any existing CORS headers to avoid stale values.
- * - If the request has no origin, the function exits early.
- * - If wildcard `*` is allowed, sets Access-Control-Allow-Origin to `*`.
- * - If the origin is explicitly allowed, sets the correct headers including credentials and Vary: Origin.
- * - Optional headers (Expose-Headers, Allow-Headers, Allow-Methods, Max-Age) are always applied.
- *
- * @param cors The CorsProvider instance that determines allowed origins and headers
- * @param headers The Headers object to update
+ * Response for OPTIONS requests. Sets allowed methods and returns 204 No Content.
  */
-declare function addCorsHeaders(origin: string | null, cors: CorsWorker, headers: Headers): void;
+declare class Options extends SuccessResponse {
+    constructor(worker: Worker);
+}
 
+/** Structure for JSON error responses. */
 interface ErrorJson {
+    /** HTTP status code. */
     status: number;
+    /** Standard HTTP reason phrase. */
     error: string;
+    /** Optional detailed message about the error. */
     details: string;
 }
+/**
+ * Generic HTTP error response.
+ * Sends a JSON body with status, error message, and details.
+ */
 declare class HttpError extends JsonResponse {
     protected readonly details?: string | undefined;
-    constructor(worker: CorsWorker, status: StatusCodes, details?: string | undefined);
+    /**
+     * @param worker The worker handling the request.
+     * @param status HTTP status code.
+     * @param details Optional detailed error message.
+     */
+    constructor(worker: Worker, status: StatusCodes, details?: string | undefined);
 }
+/** 400 Bad Request error response. */
 declare class BadRequest extends HttpError {
-    constructor(worker: CorsWorker, details?: string);
+    constructor(worker: Worker, details?: string);
 }
+/** 401 Unauthorized error response. */
 declare class Unauthorized extends HttpError {
-    constructor(worker: CorsWorker, details?: string);
+    constructor(worker: Worker, details?: string);
 }
+/** 403 Forbidden error response. */
 declare class Forbidden extends HttpError {
-    constructor(worker: CorsWorker, details?: string);
+    constructor(worker: Worker, details?: string);
 }
+/** 404 Not Found error response. */
 declare class NotFound extends HttpError {
-    constructor(worker: CorsWorker, details?: string);
+    constructor(worker: Worker, details?: string);
 }
+/** 405 Method Not Allowed error response. */
 declare class MethodNotAllowed extends HttpError {
-    constructor(worker: CorsWorker);
+    constructor(worker: Worker);
 }
+/** 500 Internal Server Error response. */
 declare class InternalServerError extends HttpError {
-    constructor(worker: CorsWorker, details?: string);
+    constructor(worker: Worker, details?: string);
 }
+/** 501 Not Implemented error response. */
 declare class NotImplemented extends HttpError {
-    constructor(worker: CorsWorker, details?: string);
+    constructor(worker: Worker, details?: string);
 }
+/** 501 Method Not Implemented error response for unsupported HTTP methods. */
 declare class MethodNotImplemented extends NotImplemented {
-    constructor(worker: CorsWorker);
+    constructor(worker: Worker);
 }
+/** 503 Service Unavailable error response. */
 declare class ServiceUnavailable extends HttpError {
-    constructor(worker: CorsWorker, details?: string);
+    constructor(worker: Worker, details?: string);
 }
 
 /** Parameters extracted from a matched route */
@@ -420,6 +515,33 @@ declare class Routes implements Iterable<Route> {
     [Symbol.iterator](): Iterator<Route>;
 }
 
+/**
+ * Abstract base class for Worker middleware.
+ * Provides a structured pre/post pattern around the next middleware or final handler,
+ * with optional short-circuit support.
+ */
+declare abstract class Middleware {
+    /**
+     * Implement this method to perform logic **before** the next middleware.
+     * Can inspect or modify the request via the worker instance.
+     * Return a Response to short-circuit the chain, or `undefined` to continue.
+     * @param worker The worker handling the request
+     */
+    protected pre(_worker: Worker): void | Response | Promise<void | Response>;
+    /**
+     * Implement this method to perform logic **after** the next middleware.
+     * Can inspect or modify the response before it is returned.
+     * @param worker The worker handling the request
+     * @param response The Response returned from the next middleware or final handler
+     */
+    protected post(_worker: Worker, _response: Response): void | Promise<void>;
+    /**
+     * Executes this middleware around the next middleware or final handler.
+     * Calls `pre`, then `next()` if not short-circuited, then `post`.
+     */
+    handle(worker: Worker, next: () => Promise<Response>): Promise<Response>;
+}
+
 /**
  * A type-safe Cloudflare Worker handler.
  *
@@ -460,6 +582,16 @@ declare abstract class BaseWorker implements Worker {
     get env(): Env;
     /** Execution context for background tasks or `waitUntil` */
     get ctx(): ExecutionContext;
+    /**
+     * Dispatches the incoming request to the appropriate handler and produces a response.
+     *
+     * Subclasses must implement this method to define how the worker generates a `Response`
+     * for the current request. This is the central point where request processing occurs,
+     * and where middleware chains, routing, or other custom behavior can be applied.
+     *
+     * @returns A Promise that resolves to the `Response` for the request.
+     */
+    protected abstract dispatch(): Promise<Response>;
     /**
      * The DEFAULT allowed HTTP methods for subclasses.
      */
@@ -491,141 +623,115 @@ declare abstract class BaseWorker implements Worker {
 }
 
 /**
- * Abstract base class for Workers to provide a default CORS policy.
- *
- * Implements the `CorsProvider` interface and provides a standard policy:
- * - Allows all origins (`*`) by default.
- * - Allows the `Content-Type` header.
- * - Exposes no additional headers.
- * - Sets CORS preflight max-age to one week.
- *
- * Subclasses can override any of the methods to customize the CORS behavior.
- */
-declare abstract class CorsDefaults extends BaseWorker implements CorsProvider {
-    getAllowedOrigins(): string[];
-    allowAnyOrigin(): boolean;
-    getAllowedHeaders(): string[];
-    getExposedHeaders(): string[];
-    getMaxAge(): number;
-}
-
-/**
- * Abstract worker class that adds caching support for GET requests.
- *
- * Behavior:
- * - Caches successful GET responses (`response.ok === true`) in the selected cache.
- * - Strips CORS headers from cached responses; all other origin headers are preserved.
- * - Dynamically adds CORS headers to cached responses when returned to the client.
- *
- * Subclasses should override `getCacheKey()` to customize cache key generation if needed.
+ * Worker that supports class-based middleware with optional always-run middleware.
+ * Extends CacheWorker to include caching logic automatically.
  */
-declare abstract class CacheWorker extends CorsDefaults {
+declare abstract class MiddlewareWorker extends BaseWorker {
+    private readonly middlewares;
     /**
-     * Returns the cache key for the current request.
-     *
-     * Behavior:
-     * - By default, returns the normalized request URL.
-     * - Query parameters are normalized so that the order does not affect the cache key.
-     *   For example, `?a=1&b=2` and `?b=2&a=1` produce the same cache key.
-     *
-     * Subclasses may override this method to implement custom cache key strategies.
-     *
-     * @returns {URL | RequestInfo} The URL or RequestInfo used as the cache key.
+     * Register a middleware instance.
+     * @param mw Middleware to register
      */
-    protected getCacheKey(): URL | RequestInfo;
+    use(mw: Middleware): this;
     /**
-     * Retrieves a cached Response for the current request, if one exists.
+     * Fetch the current request through the registered middleware chain
+     * and ultimately to the final worker handler.
      *
-     * Behavior:
-     * - Only GET requests are considered.
-     * - Returns a new Response with dynamic CORS headers applied via `addCacheHeaders`.
-     * - Returns `undefined` if no cached response is found.
-     * - Cloudflare dynamic headers (`CF-Cache-Status`, `Age`, `Connection`, etc.) will
-     *   always be present on the returned response, even though they are not stored in the cache.
+     * Middleware are executed in **last-registered-first-called** order (via reduceRight).
+     * Each middleware receives the worker instance and a `next` function to call the
+     * next middleware or final handler.
      *
-     * @param {string} [cacheName] Optional named cache; defaults to `caches.default`.
-     * @returns {Promise<Response | undefined>} A Response with CORS headers, or undefined.
-     * @see {@link setCachedResponse}
-     * @see {@link getCacheKey}
+     * @returns A Promise resolving to the Response returned by the middleware chain
+     *          or the final handler.
      */
-    protected getCachedResponse(cacheName?: string): Promise<Response | undefined>;
-    /**
-     * Stores a Response in the cache for the current request.
-     *
-     * Behavior:
-     * - Only caches successful GET responses (`response.ok === true`).
-     * - Strips headers via `removeCacheHeaders` before storing.
-     * - Uses `ctx.waitUntil` to perform caching asynchronously without blocking the response.
-     * - All other origin headers (e.g., Cache-Control, Expires) are preserved.
-     *
-     * @param {Response} response The Response to cache.
-     * @param {string} [cacheName] Optional named cache; defaults to `caches.default`.
-     * @see {@link getCachedResponse}
-     * @see {@link getCacheKey}
-     */
-    protected setCachedResponse(response: Response, cacheName?: string): Promise<void>;
+    fetch(): Promise<Response>;
+}
+
+/**
+ * Base worker class providing HTTP method dispatching, caching, and error handling.
+ * Extends `CacheWorker` and defines default implementations for HTTP methods.
+ */
+declare abstract class BasicWorker extends MiddlewareWorker {
     /**
-     * Controls whether the library's automatic caching is enabled.
-     *
-     * This method only affects the caching behavior provided by the library’s
-     * `getCachedResponse()` and `setCachedResponse()` methods. It does **not**
-     * prevent users from manually reading from or writing to `caches.default`
-     * or any other Cache API. By default, this returns `true`, enabling the
-     * library’s default caching behavior.
-     *
-     * Subclasses can override this method to disable automatic caching in
-     * development environments, for certain pathnames, or based on
-     * environment variables.
-     *
-     * @returns {boolean} `true` if the library should use its default caching,
-     *                    `false` to disable the library cache.
+     * Entry point to handle a fetch request.
+     * Checks allowed methods, serves cached responses, or dispatches to the appropriate handler.
      */
-    protected isCacheEnabled(): boolean | Promise<boolean>;
+    fetch(): Promise<Response>;
     /**
-     * Adds headers to a cached response.
-     *
-     * @param {Response} cached The cached Response.
-     * @returns {Response} A new Response with dynamic CORS headers applied.
-     * @see {@link removeCacheHeaders}
+     * Dispatches the request to the method-specific handler.
+     * Defaults to MethodNotAllowed if the HTTP method is not recognized.
      */
-    protected addCacheHeaders(cached: Response): Response;
+    protected dispatch(): Promise<Response>;
     /**
-     * Removes headers that should not be stored in the cache (currently only CORS headers).
-     *
-     * @param {Response} response The Response to clean before caching.
-     * @returns {Response} A new Response with excluded headers removed.
-     * @see {@link addCacheHeaders}
+     * Hook for subclasses to perform any setup, e.g., registering middleware,
+     * overriding defaults, or configuring state.
      */
-    protected removeCacheHeaders(response: Response): Response;
+    protected setup(): void;
     /**
-     * Returns the list of headers to exclude from the cached response.
-     * By default, excludes only dynamic CORS headers.
-     *
-     * @returns {string[]} Array of header names to exclude.
-     * @see {@link removeCacheHeaders}
+     * Checks if the given HTTP method is allowed for this worker.
+     * @param method HTTP method string
+     * @returns true if the method is allowed
      */
-    protected excludeCacheHeaders(): string[];
-}
-
-declare abstract class BasicWorker extends CacheWorker {
-    fetch(): Promise<Response>;
-    protected dispatch(): Promise<Response>;
     isAllowed(method: string): boolean;
+    /** Default handler for GET requests. Returns MethodNotImplemented unless overridden. */
     protected get(): Promise<Response>;
+    /** Default handler for PUT requests. Returns MethodNotImplemented unless overridden. */
     protected put(): Promise<Response>;
+    /** Default handler for POST requests. Returns MethodNotImplemented unless overridden. */
     protected post(): Promise<Response>;
+    /** Default handler for PATCH requests. Returns MethodNotImplemented unless overridden. */
     protected patch(): Promise<Response>;
+    /** Default handler for DELETE requests. Returns MethodNotImplemented unless overridden. */
     protected delete(): Promise<Response>;
+    /**
+     * Default handler for OPTIONS requests.
+     * Returns an Options response.
+     *
+     * Typically does not need to be overridden.
+     */
     protected options(): Promise<Response>;
+    /**
+     * Default handler for HEAD requests.
+     * Performs a GET request internally and removes the body for HEAD semantics.
+     *
+     * Usually does not need to be overridden, as this behavior covers standard HEAD requirements.
+     */
     protected head(): Promise<Response>;
-    protected getResponse<T extends WorkerResponse, Ctor extends new (worker: CorsWorker, ...args: any[]) => T>(ResponseClass: Ctor, ...args: ConstructorParameters<Ctor> extends [CorsWorker, ...infer R] ? R : never): Promise<Response>;
+    /**
+     * Helper to construct a WorkerResponse of the given class with arguments.
+     * @param ResponseClass The response class to instantiate
+     * @param args Additional constructor arguments
+     * @returns The final Response object
+     */
+    protected getResponse<T extends WorkerResponse, Ctor extends new (worker: Worker, ...args: any[]) => T>(ResponseClass: Ctor, ...args: ConstructorParameters<Ctor> extends [Worker, ...infer R] ? R : never): Promise<Response>;
 }
 
+/**
+ * Abstract worker that provides routing capabilities.
+ * Extends `BasicWorker` and uses a `Routes` table to map HTTP methods and paths
+ * to handler callbacks.
+ */
 declare abstract class RouteWorker extends BasicWorker {
+    /** Routing table used for registering and matching routes. */
     protected readonly routes: Routes;
-    protected abstract registerRoutes(): void;
+    /**
+     * Loads routes from a `RouteTable` into this worker's route table.
+     * @param table The table of routes to load.
+     */
     protected load(table: RouteTable): void;
+    /**
+     * Adds a single route to this worker.
+     * @param method HTTP method (GET, POST, etc.)
+     * @param path Route path
+     * @param callback Function to handle requests matching this route
+     * @returns The worker instance (for chaining)
+     */
     protected add(method: Method, path: string, callback: RouteCallback): this;
+    /**
+     * Matches the incoming request against registered routes and executes
+     * the corresponding callback. Falls back to `BasicWorker.dispatch()` if no match.
+     * @returns The response from the matched route or the default handler.
+     */
     protected dispatch(): Promise<Response>;
     protected get(): Promise<Response>;
     protected put(): Promise<Response>;
@@ -634,4 +740,4 @@ declare abstract class RouteWorker extends BasicWorker {
     protected delete(): Promise<Response>;
 }
 
-export { BadRequest, BasicWorker, CacheControl, ClonedResponse, Cors, type CorsProvider, type CorsWorker, type ErrorJson, Forbidden, Head, HtmlResponse, HttpError, HttpHeader, InternalServerError, JsonResponse, type MatchedRoute, MediaType, Method, MethodNotAllowed, MethodNotImplemented, NotFound, NotImplemented, Options, type Route, type RouteCallback, type RouteParams, type RouteTable, type RouteTuple, RouteWorker, Routes, ServiceUnavailable, SuccessResponse, TextResponse, Time, Unauthorized, type Worker, type WorkerConstructor, WorkerResponse, addCorsHeaders, getContentType, getOrigin, isMethod, lexCompare, mergeHeader, normalizeUrl, setHeader };
+export { BadRequest, BasicWorker, CacheControl, ClonedResponse, Cors, type CorsConfig, CorsProvider, DEFAULT_CORS_CONFIG, type ErrorJson, Forbidden, Head, HtmlResponse, HttpError, HttpHeader, InternalServerError, JsonResponse, type MatchedRoute, MediaType, Method, MethodNotAllowed, MethodNotImplemented, Middleware, NotFound, NotImplemented, Options, type Route, type RouteCallback, type RouteParams, type RouteTable, type RouteTuple, RouteWorker, Routes, ServiceUnavailable, SuccessResponse, TextResponse, Time, Unauthorized, type Worker, type WorkerConstructor, WorkerResponse, addCorsHeaders, allowAnyOrigin, getContentType, getOrigin, isMethod, lexCompare, mergeHeader, normalizeUrl, setHeader };