@tyno/tyno 2.1.3

package/src/cache/drivers/file.ts

@@ -0,0 +1,79 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import type { CacheDriver } from '../types.ts';
+
+interface FileEntry {
+    value: string;
+    expires: number | null; // 毫秒时间戳，null 表示永不过期
+}
+
+/** 文件缓存驱动：每个 key 一个 JSON 文件 */
+export class FileDriver implements CacheDriver {
+    private dir: string;
+
+    constructor(dir: string = './storage/cache') {
+        this.dir = path.resolve(dir);
+        fs.mkdirSync(this.dir, { recursive: true });
+    }
+
+    async get(key: string): Promise<string | null> {
+        const filePath = this._keyPath(key);
+        try {
+            const data = JSON.parse(await fs.promises.readFile(filePath, 'utf-8')) as FileEntry;
+            if (data.expires !== null && Date.now() > data.expires) {
+                await fs.promises.unlink(filePath).catch(() => {});
+                return null;
+            }
+            return data.value;
+        } catch (e: unknown) {
+            if ((e as NodeJS.ErrnoException).code === 'ENOENT') return null;
+            throw e;
+        }
+    }
+
+    async set(key: string, value: string, ttl?: number): Promise<void> {
+        const expires = ttl && ttl > 0 ? Date.now() + ttl * 1000 : null;
+        const filePath = this._keyPath(key);
+        await fs.promises.writeFile(filePath, JSON.stringify({ value, expires }), 'utf-8');
+    }
+
+    async delete(key: string): Promise<boolean> {
+        try {
+            await fs.promises.unlink(this._keyPath(key));
+            return true;
+        } catch {
+            return false;
+        }
+    }
+
+    async has(key: string): Promise<boolean> {
+        const filePath = this._keyPath(key);
+        try {
+            const data = JSON.parse(await fs.promises.readFile(filePath, 'utf-8')) as FileEntry;
+            if (data.expires !== null && Date.now() > data.expires) {
+                await fs.promises.unlink(filePath).catch(() => {});
+                return false;
+            }
+            return true;
+        } catch {
+            return false;
+        }
+    }
+
+    async clear(): Promise<void> {
+        try {
+            const files = await fs.promises.readdir(this.dir);
+            await Promise.all(files.map(f => fs.promises.unlink(path.join(this.dir, f)).catch(() => {})));
+        } catch { /* ignore */ }
+    }
+
+    async close(): Promise<void> {
+        // 文件驱动无需关闭连接
+    }
+
+    private _keyPath(key: string): string {
+        // 将 key 中的 : / 等替换为 _，防止路径问题
+        const safe = key.replace(/[^a-zA-Z0-9_-]/g, '_');
+        return path.join(this.dir, `${safe}.json`);
+    }
+}

package/src/cache/drivers/memory.ts

@@ -0,0 +1,72 @@
+import type { CacheDriver } from '../types.ts';
+
+interface CacheEntry {
+    value: string;
+    expires: number; // 毫秒时间戳，0 表示永不过期
+}
+
+/** 内存缓存驱动：基于 Map + TTL */
+export class MemoryDriver implements CacheDriver {
+    private store = new Map<string, CacheEntry>();
+    private maxSize: number;
+
+    constructor(maxSize: number = 10000) {
+        this.maxSize = maxSize;
+    }
+
+    async get(key: string): Promise<string | null> {
+        const entry = this.store.get(key);
+        if (!entry) return null;
+        if (entry.expires !== 0 && Date.now() > entry.expires) {
+            this.store.delete(key);
+            return null;
+        }
+        return entry.value;
+    }
+
+    async set(key: string, value: string, ttl?: number): Promise<void> {
+        // 容量保护：满时清理过期条目，仍满则删除最旧条目
+        if (this.store.size >= this.maxSize && !this.store.has(key)) {
+            this._evict();
+        }
+        const expires = ttl && ttl > 0 ? Date.now() + ttl * 1000 : 0;
+        this.store.set(key, { value, expires });
+    }
+
+    async delete(key: string): Promise<boolean> {
+        return this.store.delete(key);
+    }
+
+    async has(key: string): Promise<boolean> {
+        const entry = this.store.get(key);
+        if (!entry) return false;
+        if (entry.expires !== 0 && Date.now() > entry.expires) {
+            this.store.delete(key);
+            return false;
+        }
+        return true;
+    }
+
+    async clear(): Promise<void> {
+        this.store.clear();
+    }
+
+    async close(): Promise<void> {
+        this.store.clear();
+    }
+
+    /** 懒清理：删除过期条目，仍超容量则删除最旧的条目 */
+    private _evict(): void {
+        const now = Date.now();
+        for (const [key, entry] of this.store) {
+            if (entry.expires !== 0 && now > entry.expires) {
+                this.store.delete(key);
+            }
+        }
+        // 仍满则删除最旧条目
+        if (this.store.size >= this.maxSize) {
+            const first = this.store.keys().next().value;
+            if (first !== undefined) this.store.delete(first);
+        }
+    }
+}

package/src/cache/drivers/redis.ts

@@ -0,0 +1,72 @@
+import type { CacheDriver } from '../types.ts';
+
+/** Redis 缓存驱动：基于官方 redis 包（@redis/client） */
+export class RedisDriver implements CacheDriver {
+    private client: Record<string, (...args: unknown[]) => Promise<unknown>>;
+
+    private constructor(client: Record<string, (...args: unknown[]) => Promise<unknown>>) {
+        this.client = client;
+    }
+
+    /**
+     * 创建 RedisDriver 实例。
+     * 运行时动态加载官方 redis 包，未安装时抛出明确错误。
+     */
+    static async create(config: { host?: string; port?: number; password?: string; db?: number } = {}): Promise<RedisDriver> {
+        // 动态构造模块名，避免 TypeScript 静态分析
+        const modName = 'redis';
+        let createClient: (...args: unknown[]) => unknown;
+        try {
+            const mod = await (Function('m', 'return import(m)') as (m: string) => Promise<unknown>)(modName);
+            createClient = (mod as Record<string, unknown>).createClient as (...args: unknown[]) => unknown;
+            if (!createClient) throw new Error('createClient not found');
+        } catch {
+            throw new Error(
+                '[tyno] Redis cache driver requires the official "redis" package. Install it: npm install redis'
+            );
+        }
+
+        const socket: Record<string, unknown> = {
+            host: config.host ?? '127.0.0.1',
+            port: config.port ?? 6379,
+        };
+        const opts: Record<string, unknown> = { socket };
+        if (config.password) opts.password = config.password;
+        if (config.db != null) opts.database = config.db;
+
+        const client = createClient(opts) as Record<string, (...args: unknown[]) => Promise<unknown>>;
+        await client.connect();
+        return new RedisDriver(client);
+    }
+
+    async get(key: string): Promise<string | null> {
+        const val = await this.client.get(key) as string | null;
+        return val ?? null;
+    }
+
+    async set(key: string, value: string, ttl?: number): Promise<void> {
+        if (ttl && ttl > 0) {
+            await this.client.set(key, value, { EX: ttl });
+        } else {
+            await this.client.set(key, value);
+        }
+    }
+
+    async delete(key: string): Promise<boolean> {
+        const count = await this.client.del(key) as number;
+        return count > 0;
+    }
+
+    async has(key: string): Promise<boolean> {
+        const exists = await this.client.exists(key) as number;
+        return exists > 0;
+    }
+
+    async clear(): Promise<void> {
+        await this.client.flushDb();
+    }
+
+    async close(): Promise<void> {
+        await this.client.quit();
+    }
+}

package/src/cache/index.ts

@@ -0,0 +1,5 @@
+export { CacheManager } from './manager.ts';
+export { MemoryDriver } from './drivers/memory.ts';
+export { FileDriver } from './drivers/file.ts';
+export { RedisDriver } from './drivers/redis.ts';
+export type { CacheDriver, CacheConfig } from './types.ts';

package/src/cache/manager.ts

@@ -0,0 +1,106 @@
+import { MemoryDriver } from './drivers/memory.ts';
+import { FileDriver } from './drivers/file.ts';
+import { RedisDriver } from './drivers/redis.ts';
+import type { CacheDriver, CacheConfig } from './types.ts';
+
+/**
+ * 缓存管理器：统一 API + 自动 JSON 序列化 + 驱动委托。
+ *
+ * @example
+ * const cache = new CacheManager({ driver: 'memory', ttl: 60 });
+ * await cache.set('user:1', { name: 'Alice' });
+ * const user = await cache.get('user:1');       // { name: 'Alice' }
+ * await cache.remember('config', 3600, () => loadConfig());
+ */
+export class CacheManager {
+    private driver: CacheDriver | null = null;
+    private config: CacheConfig;
+    private prefix: string;
+    private defaultTtl: number;
+
+    constructor(config: CacheConfig = {}) {
+        this.config = config;
+        this.prefix = config.prefix ?? 'tyno:';
+        this.defaultTtl = config.ttl ?? 3600;
+    }
+
+    /** 获取缓存值，不存在返回 null */
+    async get<T = unknown>(key: string): Promise<T | null> {
+        const raw = await (await this._driver()).get(this.prefix + key);
+        if (raw === null) return null;
+        try { return JSON.parse(raw) as T; }
+        catch { return raw as unknown as T; }
+    }
+
+    /** 设置缓存值（自动 JSON 序列化），ttl 单位秒，省略用默认值 */
+    async set(key: string, value: unknown, ttl?: number): Promise<void> {
+        const serialized = typeof value === 'string' ? value : JSON.stringify(value);
+        await (await this._driver()).set(this.prefix + key, serialized, ttl ?? this.defaultTtl);
+    }
+
+    /** 检查 key 是否存在 */
+    async has(key: string): Promise<boolean> {
+        return (await this._driver()).has(this.prefix + key);
+    }
+
+    /** 删除缓存 */
+    async delete(key: string): Promise<boolean> {
+        return (await this._driver()).delete(this.prefix + key);
+    }
+
+    /** 清空所有缓存 */
+    async clear(): Promise<void> {
+        await (await this._driver()).clear();
+    }
+
+    /**
+     * 获取或设置：key 存在则返回缓存值，不存在则调用 factory 并缓存结果。
+     *
+     * @example
+     * const config = await cache.remember('app:config', 3600, async () => {
+     *     return await loadConfigFromDB();
+     * });
+     */
+    async remember<T>(key: string, ttl: number, factory: () => T | Promise<T>): Promise<T> {
+        const cached = await this.get<T>(key);
+        if (cached !== null) return cached;
+        const value = await factory();
+        await this.set(key, value, ttl);
+        return value;
+    }
+
+    /** 关闭驱动连接 */
+    async close(): Promise<void> {
+        if (this.driver) {
+            await this.driver.close?.();
+        }
+    }
+
+    /** 获取底层驱动实例（高级用法，异步） */
+    async getDriver(): Promise<CacheDriver> {
+        return this._driver();
+    }
+
+    /** 异步懒初始化驱动 */
+    private async _driver(): Promise<CacheDriver> {
+        if (!this.driver) {
+            this.driver = await this._createDriver();
+        }
+        return this.driver;
+    }
+
+    /** 创建驱动 */
+    private async _createDriver(): Promise<CacheDriver> {
+        const driver = this.config.driver ?? 'memory';
+        switch (driver) {
+            case 'memory':
+                return new MemoryDriver();
+            case 'file':
+                return new FileDriver(this.config.file?.path);
+            case 'redis':
+                return RedisDriver.create(this.config.redis ?? {});
+            default:
+                throw new Error(`[tyno] Unknown cache driver: "${driver}"`);
+        }
+    }
+}

package/src/cache/types.ts

@@ -0,0 +1,24 @@
+/** 缓存驱动接口 */
+export interface CacheDriver {
+    get(key: string): Promise<string | null>;
+    set(key: string, value: string, ttl?: number): Promise<void>;
+    delete(key: string): Promise<boolean>;
+    has(key: string): Promise<boolean>;
+    clear(): Promise<void>;
+    /** 关闭驱动连接（如 Redis） */
+    close?(): Promise<void>;
+}
+
+/** 缓存配置 */
+export interface CacheConfig {
+    /** 驱动类型，默认 'memory' */
+    driver?: 'memory' | 'file' | 'redis';
+    /** key 前缀，默认 'tyno:' */
+    prefix?: string;
+    /** 默认 TTL（秒），默认 3600 */
+    ttl?: number;
+    /** 文件驱动配置 */
+    file?: { path?: string };
+    /** Redis 驱动配置 */
+    redis?: { host?: string; port?: number; password?: string; db?: number };
+}

package/src/cache-facade.ts

@@ -0,0 +1,64 @@
+import { requestStore } from './context.ts';
+import type { CacheManager } from './cache/index.ts';
+
+const CACHE_KEY = '_tyno_cache';
+
+/**
+ * 全局缓存门面。
+ *
+ * 在任意中间件或深层业务函数中直接导入，无需通过 app.cache() 访问。
+ * 底层基于 AsyncLocalStorage，在请求生命周期内可从任意深度访问。
+ *
+ * @example
+ * import { cache } from 'tyno';
+ *
+ * app.use(async (req, next) => {
+ *     await cache.set('user:1', { name: 'Alice' }, 60);
+ *     const user = await cache.get('user:1');
+ *     return Response.json(user);
+ * });
+ */
+export const cache = {
+    /** 获取缓存值，不存在返回 null */
+    async get<T = unknown>(key: string): Promise<T | null> {
+        return (await _getCacheManager()).get<T>(key);
+    },
+
+    /** 设置缓存值，ttl 单位秒 */
+    async set(key: string, value: unknown, ttl?: number): Promise<void> {
+        await (await _getCacheManager()).set(key, value, ttl);
+    },
+
+    /** 检查 key 是否存在 */
+    async has(key: string): Promise<boolean> {
+        return (await _getCacheManager()).has(key);
+    },
+
+    /** 删除缓存 */
+    async delete(key: string): Promise<boolean> {
+        return (await _getCacheManager()).delete(key);
+    },
+
+    /** 清空所有缓存 */
+    async clear(): Promise<void> {
+        await (await _getCacheManager()).clear();
+    },
+
+    /** 获取或设置：不存在时调用 factory 并缓存 */
+    async remember<T>(key: string, ttl: number, factory: () => T | Promise<T>): Promise<T> {
+        return (await _getCacheManager()).remember<T>(key, ttl, factory);
+    }
+};
+
+/** @internal 从请求上下文获取 CacheManager */
+async function _getCacheManager(): Promise<CacheManager> {
+    const req = requestStore.getStore();
+    if (!req) {
+        throw new Error('No active request context. Use cache facade only inside middleware or the request lifecycle.');
+    }
+    const mgr = (req as unknown as Record<string, unknown>)[CACHE_KEY] as CacheManager | undefined;
+    if (!mgr) {
+        throw new Error('Cache not configured. Add cache config to new Tyno({ cache: { ... } }).');
+    }
+    return mgr;
+}

package/src/compose.ts

@@ -0,0 +1,139 @@
+import { Response } from './response.ts';
+import { IS_ERROR_MIDDLEWARE } from './types.ts';
+import type { AnyMiddleware, TynoRequest, NextFunction } from './types.ts';
+
+/**
+ * 将任意中间件返回值规范化为 Response 实例
+ */
+export function normalizeResponse(res: unknown): Response {
+    if (res instanceof Response) return res;
+
+    if (typeof res === 'string' || Buffer.isBuffer(res)) {
+        return Response.text(res);
+    }
+
+    if (typeof res === 'object' && res !== null) {
+        if (typeof (res as Record<string, unknown>)[Symbol.asyncIterator as unknown as string] === 'function') {
+            return new Response(200, {
+                'Content-Type': 'text/event-stream',
+                'Cache-Control': 'no-cache',
+                'Connection': 'keep-alive'
+            }, res as AsyncIterable<unknown>);
+        }
+        if (typeof (res as Record<string, unknown>).pipe === 'function') {
+            return new Response(200, {}, res as NodeJS.ReadableStream);
+        }
+        return Response.json(res);
+    }
+
+    if (res == null) {
+        return Response.empty(204);
+    }
+
+    return Response.text(String(res));
+}
+
+/**
+ * 判断中间件是否为错误中间件。
+ * 优先级：Symbol 标记 > fn.length 检测
+ */
+function isErrorMiddleware(fn: AnyMiddleware): boolean {
+    return (fn as unknown as Record<string | symbol, unknown>)[IS_ERROR_MIDDLEWARE] === true || fn.length >= 3;
+}
+
+/**
+ * 显式标记一个函数为错误中间件。
+ * 适用于 fn.length < 3 但仍需作为错误中间件使用的场景（如经过包装的函数）。
+ */
+export function asErrorMiddleware(fn: AnyMiddleware): AnyMiddleware {
+    (fn as unknown as Record<string | symbol, unknown>)[IS_ERROR_MIDDLEWARE] = true;
+    return fn;
+}
+
+/** 错误中间件处理函数签名 */
+type ErrorHandlerFn = (err: unknown, req: TynoRequest, next: NextFunction) => unknown;
+
+/**
+ * 中间件组合函数，实现洋葱模型。
+ *
+ * 中间件签名约定：
+ *   - 普通中间件：async (req, next?) => unknown      （无 Symbol 标记，fn.length <= 2）
+ *   - 错误中间件：async (err, req, next) => unknown  （有 IS_ERROR_MIDDLEWARE 标记或 fn.length >= 3）
+ */
+export function compose(req: TynoRequest, middlewares: AnyMiddleware[]): Promise<Response> {
+    let index = -1;
+
+    const dispatch = (i: number): Promise<Response> => {
+        if (i <= index) return Promise.reject(new Error('next() called multiple times'));
+        index = i;
+
+        if (i === middlewares.length) {
+            return Promise.resolve(new Response(404, {}, 'Not Found'));
+        }
+
+        const fn = middlewares[i];
+
+        // 错误中间件在正常流程中跳过
+        if (isErrorMiddleware(fn)) {
+            return dispatch(i + 1);
+        }
+
+        try {
+            const next: NextFunction = (err?: unknown): Promise<Response> => {
+                if (err !== undefined && err !== null) return Promise.reject(err);
+                return dispatch(i + 1);
+            };
+
+            let result: unknown;
+            if (fn.length > 1) {
+                result = (fn as (req: TynoRequest, next: NextFunction) => unknown)(req, next);
+            } else {
+                result = (fn as (req: TynoRequest) => unknown)(req);
+            }
+
+            return Promise.resolve(result).then((res: unknown) => normalizeResponse(res));
+        } catch (err) {
+            return Promise.reject(err);
+        }
+    };
+
+    return dispatch(0).catch((err: unknown) => runErrorHandlers(req, middlewares, err));
+}
+
+/**
+ * 依次执行所有错误中间件，直到某个中间件消费错误并返回响应。
+ * next() 真正串联下一个错误处理器，返回有意义的响应。
+ */
+async function runErrorHandlers(req: TynoRequest, middlewares: AnyMiddleware[], err: unknown): Promise<Response> {
+    const errorHandlers = middlewares.filter(fn => isErrorMiddleware(fn));
+
+    let handlerIndex = 0;
+
+    const runNext = (currentErr: unknown): Promise<Response> => {
+        if (handlerIndex >= errorHandlers.length) {
+            return Promise.reject(currentErr); // 无处理器消费，向上抛出
+        }
+
+        const handler = errorHandlers[handlerIndex++];
+        let nextCalled = false;
+        let nextChain: Promise<Response> | null = null;
+
+        const next: NextFunction = (e?: unknown): Promise<Response> => {
+            nextCalled = true;
+            const errToForward = (e !== undefined && e !== null) ? e : currentErr;
+            nextChain = runNext(errToForward); // 真正串联下一个错误处理器
+            return nextChain;
+        };
+
+        return Promise.resolve()
+            .then(() => (handler as ErrorHandlerFn)(currentErr, req, next))
+            .then((result: unknown) => {
+                // next() 被调用 → 使用错误链的结果
+                // next() 未调用 → 使用 handler 自身的返回值
+                if (nextCalled && nextChain) return nextChain;
+                return normalizeResponse(result);
+            });
+    };
+
+    return runNext(err);
+}

package/src/context.ts

@@ -0,0 +1,5 @@
+import { AsyncLocalStorage } from 'node:async_hooks';
+import type { TynoRequest } from './types.ts';
+
+/** 请求上下文存储（AsyncLocalStorage），供所有门面共享 */
+export const requestStore = new AsyncLocalStorage<TynoRequest>();

package/src/errors/app-error.ts

@@ -0,0 +1,37 @@
+export interface AppErrorOptions {
+    status?: number;
+    expose?: boolean;
+    code?: string | number | null;
+    cause?: Error | null;
+    [key: string]: any;
+}
+
+export class AppError extends Error {
+    status: number;
+    expose: boolean;
+    code: string | number | null;
+    cause: Error | null;
+
+    constructor(message: string, options: AppErrorOptions = {}) {
+        super(message);
+        this.name = 'AppError';
+        this.status = options.status ?? 500;
+        this.expose = options.expose ?? false;
+        this.code = options.code ?? null;
+        this.cause = options.cause ?? null;
+        for (const k in options) {
+            if (!['status', 'expose', 'code', 'cause'].includes(k)) {
+                (this as any)[k] = options[k];
+            }
+        }
+    }
+
+    toJSON({ reveal = false }: { reveal?: boolean } = {}): Record<string, any> {
+        const base: Record<string, any> = { error: this.message, status: this.status };
+        if (this.code != null) base.code = this.code;
+        if (reveal || this.expose) {
+            if (this.cause?.message) base.cause = this.cause.message;
+        }
+        return base;
+    }
+}

package/src/errors/http-error.ts

@@ -0,0 +1,34 @@
+import { AppError } from './app-error.ts';
+import type { AppErrorOptions } from './app-error.ts';
+
+const STATUS_TEXT: Record<number, string> = {
+    400: 'Bad Request', 401: 'Unauthorized', 403: 'Forbidden', 404: 'Not Found',
+    405: 'Method Not Allowed', 409: 'Conflict', 413: 'Payload Too Large',
+    415: 'Unsupported Media Type', 422: 'Unprocessable Entity', 429: 'Too Many Requests',
+    500: 'Internal Server Error', 501: 'Not Implemented', 502: 'Bad Gateway',
+    503: 'Service Unavailable', 504: 'Gateway Timeout'
+};
+
+export class HttpError extends AppError {
+    constructor(status: number, message?: string, props: AppErrorOptions = {}) {
+        super(message || STATUS_TEXT[status] || 'Error', {
+            status,
+            expose: props.expose ?? (status >= 400 && status < 500),
+            ...props
+        });
+        this.name = 'HttpError';
+    }
+}
+
+export function createError(status: number, message?: string, props?: AppErrorOptions): HttpError {
+    return new HttpError(status, message, props);
+}
+
+export class BadRequest extends HttpError { constructor(msg?: string, props?: AppErrorOptions) { super(400, msg, props); } }
+export class Unauthorized extends HttpError { constructor(msg?: string, props?: AppErrorOptions) { super(401, msg, props); } }
+export class Forbidden extends HttpError { constructor(msg?: string, props?: AppErrorOptions) { super(403, msg, props); } }
+export class NotFound extends HttpError { constructor(msg?: string, props?: AppErrorOptions) { super(404, msg, props); } }
+export class Conflict extends HttpError { constructor(msg?: string, props?: AppErrorOptions) { super(409, msg, props); } }
+export class PayloadTooLarge extends HttpError { constructor(msg?: string, props?: AppErrorOptions) { super(413, msg, props); } }
+export class TooManyRequests extends HttpError { constructor(msg?: string, props?: AppErrorOptions) { super(429, msg, props); } }
+export class InternalServerError extends HttpError { constructor(msg?: string, props?: AppErrorOptions) { super(500, msg, props); } }

package/src/errors/index.ts

@@ -0,0 +1,4 @@
+export { AppError } from './app-error.ts';
+export type { AppErrorOptions } from './app-error.ts';
+export { HttpError, createError, BadRequest, Unauthorized, Forbidden, NotFound, Conflict, PayloadTooLarge, TooManyRequests, InternalServerError } from './http-error.ts';
+export { RuntimeError, isRuntimeError } from './runtime-error.ts';

package/src/errors/runtime-error.ts

@@ -0,0 +1,19 @@
+import { AppError } from './app-error.ts';
+import type { AppErrorOptions } from './app-error.ts';
+
+export class RuntimeError extends AppError {
+    constructor(message: string, options: AppErrorOptions = {}) {
+        super(message, {
+            status: options.status ?? 500,
+            expose: options.expose ?? false,
+            code: options.code,
+            cause: options.cause,
+            ...options
+        });
+        this.name = 'RuntimeError';
+    }
+}
+
+export function isRuntimeError(err: any): err is RuntimeError {
+    return err instanceof RuntimeError;
+}

package/src/facade/index.ts

@@ -0,0 +1,3 @@
+// 全局门面导出
+export { default as request } from '../request-global.ts';
+export { cache as Cache, cache } from '../cache-facade.ts';