@adonix.org/cloud-spark 0.0.94 → 0.0.97

package/dist/index.d.ts

@@ -2,113 +2,6 @@ import CacheLib from 'cache-control-parser';
 import { StatusCodes } from 'http-status-codes';
 export { StatusCodes } from 'http-status-codes';
 
-/**
- * Represents the constructor of a Worker or a subclass of Worker.
- *
- * @template T - The specific type of Worker being constructed. Defaults to `Worker`.
- * @param req - The `Request` object to be handled by the worker instance.
- * @param env - The environment bindings available to the worker.
- * @param ctx - The `ExecutionContext` for the worker invocation.
- * @returns An instance of the worker type `T`.
- */
-type WorkerConstructor<T extends Worker = Worker> = new (req: Request, env: Env, ctx: ExecutionContext) => T;
-/**
- * Defines the contract for a Cloudflare-compatible Worker.
- *
- * Implementations are responsible for handling incoming requests,
- * providing access to the request, environment bindings, and
- * execution context.
- */
-interface Worker {
-    /**
-     * Processes the incoming {@link Request} and produces a {@link Response}.
-     *
-     * @returns A Promise that resolves to the HTTP {@link Response}.
-     */
-    fetch(): Promise<Response>;
-    /**
-     * The original {@link Request} being processed by this worker instance.
-     */
-    get request(): Request;
-    /**
-     * The environment bindings provided at runtime (e.g., KV, R2, secrets).
-     */
-    get env(): Env;
-    /**
-     * The {@link ExecutionContext} associated with the current request,
-     * used to manage background tasks and request lifecycle.
-     */
-    get ctx(): ExecutionContext;
-}
-
-/**
- * A type-safe Cloudflare Worker handler where `fetch` is required.
- *
- * Extends `ExportedHandler` but guarantees that the `fetch` method exists
- * and has the correct signature for Cloudflare Worker invocation.
- *
- * @template E - The type of environment bindings passed to the worker. Defaults to `Env`.
- */
-interface FetchHandler<E = Env> extends ExportedHandler<E> {
-    /**
-     * Handles an incoming request and produces a response.
-     *
-     * @param request - The incoming `Request` object.
-     * @param env - Environment bindings (e.g., KV namespaces, secrets, Durable Objects).
-     * @param ctx - Optional execution context for background tasks (`waitUntil`).
-     * @returns A `Promise` that resolves to the response.
-     */
-    fetch: (request: Request, env: E, ctx: ExecutionContext) => Promise<Response>;
-}
-/**
- * Provides the foundational structure for handling requests, environment bindings,
- * and the worker execution context. Subclasses are expected to implement the
- * `fetch` method to handle the request and return a Response.
- *
- * Features:
- * - Holds the current `Request` object (`request` getter).
- * - Provides access to environment bindings (`env` getter).
- * - Provides access to the worker execution context (`ctx` getter), if available.
- * - Subclasses must implement `fetch()` to process the request.
- */
-declare abstract class BaseWorker implements Worker {
-    private readonly _request;
-    private readonly _env;
-    private readonly _ctx;
-    constructor(_request: Request, _env: Env, _ctx: ExecutionContext);
-    /** The Request object associated with this worker invocation */
-    get request(): Request;
-    /** Environment bindings (e.g., KV, secrets, or other globals) */
-    get env(): Env;
-    /** Optional execution context for background tasks or `waitUntil` */
-    get ctx(): ExecutionContext;
-    /**
-     * Creates a new instance of the current Worker subclass.
-     *
-     * @param request - The request to pass to the new worker instance.
-     * @returns A new worker instance of the same subclass as `this`.
-     */
-    protected createWorker(request: Request): this;
-    /**
-     * Process the request and produce a Response.
-     * Subclasses must implement this method.
-     *
-     * @returns A Promise resolving to the Response for the request
-     */
-    abstract fetch(): Promise<Response>;
-    /**
-     * **Ignite** your `Worker` implementation into a Cloudflare-compatible handler.
-     *
-     * @returns A `FetchHandler` that launches a new worker instance for each request.
-     *
-     * @example
-     * ```ts
-     * export default MyWorker.ignite();
-     * ```
-     */
-    static ignite<W extends Worker>(this: WorkerConstructor<W>): FetchHandler;
-}
-
 /**
  * @see {@link https://github.com/etienne-martin/cache-control-parser | cache-control-parser}
  */
@@ -130,14 +23,15 @@ declare const CacheControl: {
  */
 declare namespace HttpHeader {
     const VARY = "Vary";
+    const ALLOW = "Allow";
     const CONTENT_TYPE = "Content-Type";
     const CACHE_CONTROL = "Cache-Control";
-    const X_CONTENT_TYPE_OPTIONS = "X-Content-Type-Options";
     const X_FRAME_OPTIONS = "X-Frame-Options";
-    const STRICT_TRANSPORT_SECURITY = "Strict-Transport-Security";
-    const CONTENT_SECURITY_POLICY = "Content-Security-Policy";
+    const X_CONTENT_TYPE_OPTIONS = "X-Content-Type-Options";
     const REFERRER_POLICY = "Referrer-Policy";
     const PERMISSIONS_POLICY = "Permissions-Policy";
+    const CONTENT_SECURITY_POLICY = "Content-Security-Policy";
+    const STRICT_TRANSPORT_SECURITY = "Strict-Transport-Security";
     const NOSNIFF = "nosniff";
     const ORIGIN = "Origin";
 }
@@ -159,10 +53,10 @@ declare const Time: {
 declare enum Method {
     GET = "GET",
     PUT = "PUT",
+    HEAD = "HEAD",
     POST = "POST",
     PATCH = "PATCH",
     DELETE = "DELETE",
-    HEAD = "HEAD",
     OPTIONS = "OPTIONS"
 }
 /**
@@ -295,12 +189,12 @@ interface CorsProvider {
  * Constants for common CORS headers.
  */
 declare namespace Cors {
+    const MAX_AGE = "Access-Control-Max-Age";
     const ALLOW_ORIGIN = "Access-Control-Allow-Origin";
-    const ALLOW_CREDENTIALS = "Access-Control-Allow-Credentials";
-    const EXPOSE_HEADERS = "Access-Control-Expose-Headers";
     const ALLOW_HEADERS = "Access-Control-Allow-Headers";
     const ALLOW_METHODS = "Access-Control-Allow-Methods";
-    const MAX_AGE = "Access-Control-Max-Age";
+    const EXPOSE_HEADERS = "Access-Control-Expose-Headers";
+    const ALLOW_CREDENTIALS = "Access-Control-Allow-Credentials";
     const ALLOW_ALL_ORIGINS = "*";
 }
 /**
@@ -319,105 +213,92 @@ declare namespace Cors {
 declare function addCorsHeaders(origin: string | null, cors: CorsProvider, headers: Headers): void;
 
 /**
- * Abstract base class for Workers to provide a default CORS policy.
+ * A callback function for a route.
  *
- * Implements the `CorsProvider` interface and provides a standard policy:
- * - Allows all origins (`*`) by default.
- * - Allows GET, OPTIONS, and HEAD methods.
- * - Allows the `Content-Type` header.
- * - Exposes no additional headers.
- * - Sets CORS preflight max-age to one week.
+ * @param matches - Captured groups from the route RegExp, or the full match at index 0
+ * @returns A Response object or a Promise that resolves to a Response
+ */
+type RouteCallback = (...matches: string[]) => Response | Promise<Response>;
+/**
+ * Tuple used to initialize a route.
  *
- * Subclasses can override any of the methods to customize the CORS behavior.
+ * [HTTP method, path pattern (string or RegExp), callback function]
  */
-declare abstract class CorsWorker$1 extends BaseWorker implements CorsProvider {
-    getAllowOrigins(): string[];
-    allowAnyOrigin(): boolean;
-    getAllowMethods(): Method[];
-    getAllowHeaders(): string[];
-    getExposeHeaders(): string[];
-    getMaxAge(): number;
+type RouteInit = [Method, RegExp | string, RouteCallback];
+/**
+ * Represents a single route with a pattern and a callback.
+ */
+declare class Route {
+    readonly callback: RouteCallback;
+    readonly pattern: RegExp;
+    /**
+     * @param pattern - A RegExp or string used to match the request path
+     * @param callback - Function to handle requests matching the pattern
+     */
+    constructor(pattern: RegExp | string, callback: RouteCallback);
 }
-
 /**
- * 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.
+ * A collection of routes grouped by HTTP method.
  *
- * Subclasses should override `getCacheKey()` to customize cache key generation if needed.
+ * Supports adding routes and retrieving the first matching route for a given method and URL.
  */
-declare abstract class CacheWorker extends CorsWorker$1 {
+declare class Routes {
+    private readonly map;
     /**
-     * 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.
+     * Adds a route to the collection under the given HTTP method.
      *
-     * @returns {URL | RequestInfo} The URL or RequestInfo used as the cache key.
+     * @param method - HTTP method (GET, POST, etc.)
+     * @param route - Route instance to add
+     * @returns The Routes instance (for chaining)
      */
-    protected getCacheKey(): URL | RequestInfo;
+    add(method: Method, route: Route): this;
     /**
-     * Retrieves a cached Response for the current request, if one exists.
-     *
-     * 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.
+     * Finds the first route that matches the given method and URL.
      *
-     * @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}
+     * @param method - HTTP method of the request
+     * @param url - Full URL string of the request
+     * @returns The first matching Route, or undefined if none match
      */
-    protected getCachedResponse(cacheName?: string): Promise<Response | undefined>;
+    get(method: Method, url: string): Route | undefined;
+}
+
+/**
+ * Represents the constructor of a Worker or a subclass of Worker.
+ *
+ * @template T - The specific type of Worker being constructed. Defaults to `Worker`.
+ * @param req - The `Request` object to be handled by the worker instance.
+ * @param env - The environment bindings available to the worker.
+ * @param ctx - The `ExecutionContext` for the worker invocation.
+ * @returns An instance of the worker type `T`.
+ */
+type WorkerConstructor<T extends Worker = Worker> = new (req: Request, env: Env, ctx: ExecutionContext) => T;
+/**
+ * Defines the contract for a Cloudflare-compatible Worker.
+ *
+ * Implementations are responsible for handling incoming requests,
+ * providing access to the request, environment bindings, and
+ * execution context.
+ */
+interface Worker {
     /**
-     * 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.
+     * Processes the incoming {@link Request} and produces a {@link Response}.
      *
-     * @param {Response} response The Response to cache.
-     * @param {string} [cacheName] Optional named cache; defaults to `caches.default`.
-     * @see {@link getCachedResponse}
-     * @see {@link getCacheKey}
+     * @returns A Promise that resolves to the HTTP {@link Response}.
      */
-    protected setCachedResponse(response: Response, cacheName?: string): Promise<void>;
+    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}
+     * The original {@link Request} being processed by this worker instance.
      */
-    private addCacheHeaders;
+    get request(): Request;
     /**
-     * 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}
+     * The environment bindings provided at runtime (e.g., KV, R2, secrets).
      */
-    private removeCacheHeaders;
+    get env(): Env;
     /**
-     * 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}
+     * The {@link ExecutionContext} associated with the current request,
+     * used to manage background tasks and request lifecycle.
      */
-    protected excludeCacheHeaders(): string[];
+    get ctx(): ExecutionContext;
 }
 
 interface ErrorJson {
@@ -431,28 +312,28 @@ interface ErrorJson {
  * Used by response builders that require both Worker
  * and CORS functionality.
  */
-type CorsWorker = Worker & CorsProvider;
+type CorsWorker$1 = Worker & CorsProvider;
 declare abstract class BaseResponse {
-    readonly worker: CorsWorker;
+    readonly worker: CorsWorker$1;
     headers: Headers;
     body: BodyInit | null;
     status: StatusCodes;
     statusText?: string;
     mediaType?: MediaType;
-    constructor(worker: CorsWorker, content?: BodyInit | null);
+    constructor(worker: CorsWorker$1, content?: BodyInit | null);
     protected get responseInit(): ResponseInit;
     setHeader(key: string, value: string | string[]): void;
     mergeHeader(key: string, value: string | string[]): void;
     addContentType(): void;
 }
 declare abstract class CorsResponse extends BaseResponse {
-    constructor(worker: CorsWorker, content?: BodyInit | null);
+    constructor(worker: CorsWorker$1, content?: BodyInit | null);
     protected addCorsHeaders(): void;
     protected getOrigin(): string | null;
 }
 declare abstract class CacheResponse extends CorsResponse {
     cache?: CacheControl | undefined;
-    constructor(worker: CorsWorker, body?: BodyInit | null, cache?: CacheControl | undefined);
+    constructor(worker: CorsWorker$1, body?: BodyInit | null, cache?: CacheControl | undefined);
     protected addCacheHeaders(): void;
 }
 declare abstract class WorkerResponse extends CacheResponse {
@@ -460,131 +341,249 @@ declare abstract class WorkerResponse extends CacheResponse {
     protected addSecurityHeaders(): void;
 }
 declare class ClonedResponse extends WorkerResponse {
-    constructor(worker: CorsWorker, response: Response, cache?: CacheControl);
+    constructor(worker: CorsWorker$1, response: Response, cache?: CacheControl);
 }
 declare class SuccessResponse extends WorkerResponse {
-    constructor(worker: CorsWorker, body?: BodyInit | null, cache?: CacheControl, status?: StatusCodes);
+    constructor(worker: CorsWorker$1, body?: BodyInit | null, cache?: CacheControl, status?: StatusCodes);
 }
 declare class JsonResponse extends SuccessResponse {
-    constructor(worker: CorsWorker, json?: unknown, cache?: CacheControl, status?: StatusCodes);
+    constructor(worker: CorsWorker$1, json?: unknown, cache?: CacheControl, status?: StatusCodes);
 }
 declare class HtmlResponse extends SuccessResponse {
-    constructor(worker: CorsWorker, body: string, cache?: CacheControl, status?: StatusCodes);
+    constructor(worker: CorsWorker$1, body: string, cache?: CacheControl, status?: StatusCodes);
 }
 declare class TextResponse extends SuccessResponse {
-    constructor(worker: CorsWorker, content: string, cache?: CacheControl, status?: StatusCodes);
+    constructor(worker: CorsWorker$1, content: string, cache?: CacheControl, status?: StatusCodes);
 }
 /**
  * Removes the body from a GET response.
  */
 declare class Head extends WorkerResponse {
-    constructor(worker: CorsWorker, get: Response);
+    constructor(worker: CorsWorker$1, get: Response);
 }
 declare class Options extends SuccessResponse {
-    constructor(worker: CorsWorker);
+    constructor(worker: CorsWorker$1);
 }
 declare class HttpError extends JsonResponse {
     protected readonly details?: string | undefined;
-    constructor(worker: CorsWorker, status: StatusCodes, details?: string | undefined);
+    constructor(worker: CorsWorker$1, status: StatusCodes, details?: string | undefined);
     get json(): ErrorJson;
     createResponse(): Response;
 }
 declare class BadRequest extends HttpError {
-    constructor(worker: CorsWorker, details?: string);
+    constructor(worker: CorsWorker$1, details?: string);
 }
 declare class Unauthorized extends HttpError {
-    constructor(worker: CorsWorker, details?: string);
+    constructor(worker: CorsWorker$1, details?: string);
 }
 declare class Forbidden extends HttpError {
-    constructor(worker: CorsWorker, details?: string);
+    constructor(worker: CorsWorker$1, details?: string);
 }
 declare class NotFound extends HttpError {
-    constructor(worker: CorsWorker, details?: string);
+    constructor(worker: CorsWorker$1, details?: string);
 }
 declare class MethodNotAllowed extends HttpError {
-    constructor(worker: CorsWorker, method: string);
+    constructor(worker: CorsWorker$1);
     get json(): ErrorJson & {
         allowed: Method[];
     };
 }
 declare class InternalServerError extends HttpError {
-    constructor(worker: CorsWorker, details?: string);
+    constructor(worker: CorsWorker$1, details?: string);
 }
 declare class NotImplemented extends HttpError {
-    constructor(worker: CorsWorker, details?: string);
+    constructor(worker: CorsWorker$1, details?: string);
 }
 declare class MethodNotImplemented extends NotImplemented {
-    constructor(worker: CorsWorker, method: Method);
+    constructor(worker: CorsWorker$1);
 }
 declare class ServiceUnavailable extends HttpError {
-    constructor(worker: CorsWorker, details?: string);
-}
-
-declare abstract class BasicWorker extends CacheWorker {
-    fetch(): Promise<Response>;
-    protected dispatch(): Promise<Response>;
-    protected get(): Promise<Response>;
-    protected put(): Promise<Response>;
-    protected post(): Promise<Response>;
-    protected patch(): Promise<Response>;
-    protected delete(): Promise<Response>;
-    protected options(): Promise<Response>;
-    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>;
-    isAllowed(method: string): boolean;
+    constructor(worker: CorsWorker$1, details?: string);
 }
 
 /**
- * A callback function for a route.
+ * A type-safe Cloudflare Worker handler.
  *
- * @param matches - Captured groups from the route RegExp, or the full match at index 0
- * @returns A Response object or a Promise that resolves to a Response
- */
-type RouteCallback = (...matches: string[]) => Response | Promise<Response>;
-/**
- * Tuple used to initialize a route.
+ * Extends `ExportedHandler` but guarantees that the `fetch` method exists
+ * and has the correct signature for Cloudflare Worker invocation.
  *
- * [HTTP method, path pattern (string or RegExp), callback function]
+ * @template E - The type of environment bindings passed to the worker. Defaults to `Env`.
  */
-type RouteInit = [Method, RegExp | string, RouteCallback];
+interface FetchHandler<E = Env> extends ExportedHandler<E> {
+    /**
+     * Handles an incoming request and produces a response.
+     *
+     * @param request - The incoming `Request` object.
+     * @param env - Environment bindings (e.g., KV namespaces, secrets, Durable Objects).
+     * @param ctx - Execution context for background tasks (`waitUntil`).
+     * @returns A `Promise` that resolves to the response.
+     */
+    fetch: (request: Request, env: E, ctx: ExecutionContext) => Promise<Response>;
+}
 /**
- * Represents a single route with a pattern and a callback.
+ * Provides the foundational structure for handling requests,
+ * environment bindings, and the worker execution context.
+ *
+ * Features:
+ * - Holds the current `Request` object (`request` getter).
+ * - Provides access to environment bindings (`env` getter).
+ * - Provides access to the worker execution context (`ctx` getter).
+ * - Subclasses must implement `fetch()` to process the request.
  */
-declare class Route {
-    readonly callback: RouteCallback;
-    readonly pattern: RegExp;
+declare abstract class BaseWorker implements Worker {
+    private readonly _request;
+    private readonly _env;
+    private readonly _ctx;
+    constructor(_request: Request, _env: Env, _ctx: ExecutionContext);
+    /** The Request object associated with this worker invocation */
+    get request(): Request;
+    /** Environment bindings (e.g., KV, secrets, or other globals) */
+    get env(): Env;
+    /** Execution context for background tasks or `waitUntil` */
+    get ctx(): ExecutionContext;
     /**
-     * @param pattern - A RegExp or string used to match the request path
-     * @param callback - Function to handle requests matching the pattern
+     * Creates a new instance of the current Worker subclass.
+     *
+     * @param request - The {@link Request} to pass to the new worker instance.
+     * @returns A new worker instance of the same subclass as `this`.
      */
-    constructor(pattern: RegExp | string, callback: RouteCallback);
+    protected createWorker(request: Request): this;
+    /**
+     * Process the {@link Request} and produce a {@link Response}.
+     *
+     * @returns A {@link Response} promise for the {@link Request}.
+     */
+    abstract fetch(): Promise<Response>;
+    /**
+     * **Ignite** your `Worker` implementation into a Cloudflare-compatible handler.
+     *
+     * @returns A `FetchHandler` that launches a new worker instance for each request.
+     *
+     * @example
+     * ```ts
+     * export default MyWorker.ignite();
+     * ```
+     */
+    static ignite<W extends Worker>(this: WorkerConstructor<W>): FetchHandler;
 }
+
 /**
- * A collection of routes grouped by HTTP method.
+ * Abstract base class for Workers to provide a default CORS policy.
  *
- * Supports adding routes and retrieving the first matching route for a given method and URL.
+ * Implements the `CorsProvider` interface and provides a standard policy:
+ * - Allows all origins (`*`) by default.
+ * - Allows GET, OPTIONS, and HEAD methods.
+ * - 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 class Routes {
-    private readonly map;
+declare abstract class CorsWorker extends BaseWorker implements CorsProvider {
+    getAllowOrigins(): string[];
+    allowAnyOrigin(): boolean;
+    getAllowMethods(): Method[];
+    getAllowHeaders(): string[];
+    getExposeHeaders(): 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.
+ */
+declare abstract class CacheWorker extends CorsWorker {
     /**
-     * Adds a route to the collection under the given HTTP method.
+     * Returns the cache key for the current request.
      *
-     * @param method - HTTP method (GET, POST, etc.)
-     * @param route - Route instance to add
-     * @returns The Routes instance (for chaining)
+     * 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.
      */
-    add(method: Method, route: Route): this;
+    protected getCacheKey(): URL | RequestInfo;
     /**
-     * Finds the first route that matches the given method and URL.
+     * Retrieves a cached Response for the current request, if one exists.
      *
-     * @param method - HTTP method of the request
-     * @param url - Full URL string of the request
-     * @returns The first matching Route, or undefined if none match
+     * 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.
+     *
+     * @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}
      */
-    get(method: Method, url: string): Route | undefined;
+    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>;
+    /**
+     * 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}
+     */
+    private addCacheHeaders;
+    /**
+     * 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}
+     */
+    private removeCacheHeaders;
+    /**
+     * 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}
+     */
+    protected excludeCacheHeaders(): string[];
+}
+
+declare abstract class BasicWorker extends CacheWorker {
+    fetch(): Promise<Response>;
+    protected dispatch(): Promise<Response>;
+    isAllowed(method: string): boolean;
+    protected get(): Promise<Response>;
+    protected put(): Promise<Response>;
+    protected post(): Promise<Response>;
+    protected patch(): Promise<Response>;
+    protected delete(): Promise<Response>;
+    protected options(): Promise<Response>;
+    protected head(): Promise<Response>;
+    protected getResponse<T extends WorkerResponse, Ctor extends new (worker: CorsWorker$1, ...args: any[]) => T>(ResponseClass: Ctor, ...args: ConstructorParameters<Ctor> extends [CorsWorker$1, ...infer R] ? R : never): Promise<Response>;
 }
 
-declare abstract class RoutedWorker extends BasicWorker {
+declare abstract class RouteWorker extends BasicWorker {
     private readonly routes;
     protected initialize(routes: RouteInit[]): void;
     protected add(method: Method, pattern: RegExp | string, callback: RouteCallback): this;
@@ -596,4 +595,4 @@ declare abstract class RoutedWorker 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, MediaType, Method, MethodNotAllowed, MethodNotImplemented, NotFound, NotImplemented, Options, Route, type RouteCallback, type RouteInit, RoutedWorker, Routes, ServiceUnavailable, SuccessResponse, TextResponse, Time, Unauthorized, type Worker, type WorkerConstructor, WorkerResponse, addCorsHeaders, getContentType, getOrigin, isMethod, mergeHeader, normalizeUrl, setHeader };
+export { BadRequest, BasicWorker, CacheControl, ClonedResponse, Cors, type CorsProvider, type CorsWorker$1 as CorsWorker, type ErrorJson, Forbidden, Head, HtmlResponse, HttpError, HttpHeader, InternalServerError, JsonResponse, MediaType, Method, MethodNotAllowed, MethodNotImplemented, NotFound, NotImplemented, Options, Route, type RouteCallback, type RouteInit, RouteWorker, Routes, ServiceUnavailable, SuccessResponse, TextResponse, Time, Unauthorized, type Worker, type WorkerConstructor, WorkerResponse, addCorsHeaders, getContentType, getOrigin, isMethod, mergeHeader, normalizeUrl, setHeader };