@ayepi/cache 0.1.0

package/dist/index.js

@@ -0,0 +1,209 @@
+import { ctx, middleware } from "@ayepi/core";
+//#region src/index.ts
+/**
+* # @ayepi/cache
+*
+* Response-caching middleware for [`@ayepi/core`](https://www.npmjs.com/package/@ayepi/core).
+* {@link cache} builds a middleware that derives a **key from the request** (method +
+* path + query, plus an optional dev-defined `vary` — e.g. the authenticated user) and,
+* on a **hit**, replays the stored response without running the handler. Entries live in
+* memory for a bounded **time** (`ttl`, with optional `stale-while-revalidate`) and a
+* bounded **space** (`maxBytes` / `maxEntryBytes` / `maxEntries`, LRU-evicted).
+*
+* ```ts
+* // shared.ts (frontend-safe): the def declares what it contributes
+* import { cache } from '@ayepi/cache'
+* const cached = cache()                                   // provides { cache } to handlers
+* spec({ endpoints: { ...cached.group({ … }) } })
+*
+* // server.ts: bind the policy (ttl, vary, bounds)
+* import { cache } from '@ayepi/cache/server'
+* implement(api).middleware(cache.server(cached, {
+*   ttl: 30_000,                                           // fresh for 30s
+*   vary: (io) => io.ctx.user.id,                          // per-user cache
+*   maxBytes: 64 * 1024 * 1024,
+* }))
+* ```
+*
+* - **Bounded memory** — the default {@link memoryCache} is an LRU store with total/entry
+*   byte caps and an entry-count cap; dead entries are swept lazily.
+* - **Time controls** — `ttl` (freshness) and `staleWhileRevalidate` (serve-stale grace).
+* - **Customizable** — `key`/`vary`, `methods`, `shouldCache`, response headers, `skip`,
+*   request `Cache-Control` respect, and per-response opt-out via `io.ctx.cache`.
+*
+* @module
+*/
+/** Default middleware name. */
+const DEFAULT_NAME = "cache";
+/** Milliseconds per second — `Age` / `Cache-Control: max-age` are expressed in seconds. */
+const MS_PER_SECOND = 1e3;
+/** Default total cache capacity (bytes) for {@link memoryCache}. */
+const DEFAULT_MAX_BYTES = 64 * 1024 * 1024;
+/** Default per-entry cap (bytes) — larger responses are not cached. */
+const DEFAULT_MAX_ENTRY_BYTES = 1024 * 1024;
+/** Default entry-count cap. */
+const DEFAULT_MAX_ENTRIES = 1e4;
+/**
+* Create an in-process LRU {@link CacheStore} bounded by total bytes, per-entry bytes,
+* and entry count. The default store — fine for a single instance. Most-recently-used
+* on `get`/`set`; when over a bound, evicts least-recently-used entries (or skips a
+* `set` whose entry alone exceeds `maxEntryBytes`).
+*/
+function memoryCache(opts = {}) {
+	const maxBytes = opts.maxBytes ?? DEFAULT_MAX_BYTES;
+	const maxEntryBytes = opts.maxEntryBytes ?? DEFAULT_MAX_ENTRY_BYTES;
+	const maxEntries = opts.maxEntries ?? DEFAULT_MAX_ENTRIES;
+	const entries = /* @__PURE__ */ new Map();
+	let totalBytes = 0;
+	const drop = (key) => {
+		const e = entries.get(key);
+		if (e) {
+			totalBytes -= e.bytes;
+			entries.delete(key);
+		}
+	};
+	const evictLRU = () => {
+		for (const key of entries.keys()) {
+			if (totalBytes <= maxBytes && entries.size <= maxEntries) break;
+			drop(key);
+		}
+	};
+	return {
+		get(key) {
+			const e = entries.get(key);
+			if (!e) return;
+			entries.delete(key);
+			entries.set(key, e);
+			return e;
+		},
+		set(key, entry) {
+			drop(key);
+			if (entry.bytes > maxEntryBytes) return;
+			entries.set(key, entry);
+			totalBytes += entry.bytes;
+			evictLRU();
+		},
+		delete(key) {
+			const existed = entries.has(key);
+			drop(key);
+			return existed;
+		},
+		clear() {
+			entries.clear();
+			totalBytes = 0;
+		},
+		invalidate(pred) {
+			let removed = 0;
+			for (const e of [...entries.values()]) if (pred(e)) {
+				drop(e.key);
+				removed++;
+			}
+			return removed;
+		}
+	};
+}
+/** Normalize a query input into a stable, order-independent list of `[k, v]` pairs. */
+function normalizeQuery(query) {
+	if (query === void 0) return [];
+	return [...typeof query === "string" ? new URLSearchParams(query) : query instanceof URLSearchParams ? query : new URLSearchParams([...query].map(([k, v]) => [k, v]))].sort((a, b) => a[0] === b[0] ? a[1] < b[1] ? -1 : 1 : a[0] < b[0] ? -1 : 1);
+}
+/** Recursively sort object keys so semantically-equal values serialize identically. */
+function sortDeep(v) {
+	if (Array.isArray(v)) return v.map(sortDeep);
+	if (v && typeof v === "object") {
+		const out = {};
+		for (const k of Object.keys(v).sort()) out[k] = sortDeep(v[k]);
+		return out;
+	}
+	return v;
+}
+/** Deterministic `JSON.stringify` — object keys sorted at every depth, so key order never matters. */
+function stableStringify(value) {
+	return JSON.stringify(sortDeep(value)) ?? "null";
+}
+/**
+* Build a stable cache key from request parts — the same string the middleware uses.
+* Query parameters are sorted and the body is canonicalized (sorted keys at every depth),
+* so equal requests share a key regardless of property order. Exported so you can target
+* {@link CacheStore.delete} after a mutation (e.g. bust a user's cached report).
+*/
+function cacheKey(parts) {
+	return stableStringify([
+		parts.method.toUpperCase(),
+		parts.path,
+		normalizeQuery(parts.query),
+		parts.body ?? null,
+		parts.vary ?? null
+	]);
+}
+/**
+* A fast, **non-cryptographic** hash (cyrb53 → base36) for shrinking a large cache key —
+* pass it as the `hash` option so the store keys on a short digest instead of the full
+* (possibly huge) JSON. Collisions are unlikely but possible; keep `checkKey` on (the
+* default when hashing) to fall through on one, or supply a crypto hash (e.g. sha-256)
+* for stronger guarantees.
+*/
+function hashKey(key) {
+	let h1 = 3735928559;
+	let h2 = 1103547991;
+	for (let i = 0; i < key.length; i++) {
+		const ch = key.charCodeAt(i);
+		h1 = Math.imul(h1 ^ ch, 2654435761);
+		h2 = Math.imul(h2 ^ ch, 1597334677);
+	}
+	h1 = Math.imul(h1 ^ h1 >>> 16, 2246822507) ^ Math.imul(h2 ^ h2 >>> 13, 3266489909);
+	h2 = Math.imul(h2 ^ h2 >>> 16, 2246822507) ^ Math.imul(h1 ^ h1 >>> 13, 3266489909);
+	return (4294967296 * (2097151 & h2) + (h1 >>> 0)).toString(36);
+}
+/**
+* Compute the informational cache headers for an entry: `Age` (seconds since it was
+* stored) and `Cache-Control: max-age` (seconds of freshness remaining). The middleware
+* adds the `X-Cache: HIT|STALE|MISS` marker separately.
+*/
+function cacheHeaders(entry, now) {
+	const age = Math.max(0, Math.floor((now - entry.storedAt) / MS_PER_SECOND));
+	const maxAge = Math.max(0, Math.ceil((entry.expires - now) / MS_PER_SECOND));
+	return {
+		age: String(age),
+		"cache-control": `max-age=${maxAge}`
+	};
+}
+/** The shape core produces for a multi-status (`responses:`) endpoint — `{ status, data }`. */
+function looksMultiStatus(r) {
+	const keys = Object.keys(r);
+	return keys.length === 2 && keys.includes("status") && keys.includes("data") && typeof r.status === "number";
+}
+/**
+* Whether a handler's result is a plain JSON response body the cache can store and
+* replay. `false` for an empty body (`null`/`undefined` → 204), a short-circuit
+* `Response`, a function, a streamed body (async-iterable / `ReadableStream`), or a
+* multi-status `{ status, data }` wrapper (whose replay status would be wrong). Useful in
+* a custom `shouldCache` or a custom {@link CacheStore}.
+*/
+function isCacheableResult(result) {
+	if (result === null || result === void 0) return false;
+	if (result instanceof Response) return false;
+	if (typeof result === "function") return false;
+	if (typeof result === "object") {
+		const o = result;
+		if (typeof o[Symbol.asyncIterator] === "function" || typeof o.getReader === "function") return false;
+		if (looksMultiStatus(result)) return false;
+	}
+	return true;
+}
+/**
+* Create a response-caching middleware **def**. The def declares what the middleware
+* contributes (`{ cache: CacheControl }`) but **no** policy. Bind the
+* ttl/vary/bounds with [`cache.server(def, { ttl })`](./server).
+*
+* @typeParam R - inferred from `requires`; their context types flow into the
+*   server-side `key`/`vary`/`skip`/`shouldCache`.
+*/
+function cache(opts) {
+	return middleware(opts?.name ?? DEFAULT_NAME, {
+		provides: ctx(),
+		requires: opts?.requires ?? []
+	});
+}
+//#endregion
+export { cache, cacheHeaders, cacheKey, hashKey, isCacheableResult, memoryCache, stableStringify };

package/dist/server.cjs

@@ -0,0 +1,178 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_index = require("./index.cjs");
+//#region src/server.ts
+/** The default methods whose responses are cached. */
+const DEFAULT_METHODS = ["GET"];
+/** Replayed responses are served as JSON. */
+const JSON_CONTENT_TYPE = "application/json";
+/** Parse the request `Cache-Control` directives we honor. */
+function parseCacheControl(header) {
+	if (!header) return {
+		noStore: false,
+		noCache: false
+	};
+	const directives = header.toLowerCase().split(",").map((d) => d.trim());
+	return {
+		noStore: directives.includes("no-store"),
+		noCache: directives.includes("no-cache")
+	};
+}
+/** Bind a {@link cache} def to its runtime policy. */
+function cacheServer(def, opts) {
+	const store = opts.store ?? require_index.memoryCache(opts);
+	const ttl = opts.ttl;
+	const swr = opts.staleWhileRevalidate ?? 0;
+	const methods = new Set((opts.methods ?? DEFAULT_METHODS).map((m) => m.toUpperCase()));
+	const emitHeaders = opts.headers !== false;
+	const now = opts.now ?? Date.now;
+	const checkKey = opts.checkKey ?? opts.hash !== void 0;
+	const inflight = /* @__PURE__ */ new Set();
+	/** Hand a swallowed error to `onError` (best-effort — a throwing handler is itself ignored). */
+	const reportError = (err, phase) => {
+		try {
+			opts.onError?.(err, phase);
+		} catch {}
+	};
+	const makeControl = (key) => ({
+		key,
+		hit: false,
+		store: true,
+		noStore() {
+			this.store = false;
+		},
+		ttl(ms) {
+			this.ttlOverride = ms;
+		}
+	});
+	/** The full (pre-hash) key — endpoint identity + the request's query/body (or ws args) + `vary`. */
+	const keyOf = (io, route) => {
+		const kio = {
+			req: io.req,
+			ctx: io.ctx
+		};
+		if (opts.key) return require_index.stableStringify(opts.key(kio));
+		const vary = opts.vary?.(kio);
+		if (io.transport === "ws") return require_index.cacheKey({
+			method: route.method,
+			path: route.path,
+			body: io.ws?.data,
+			vary
+		});
+		const url = new URL(io.req.url);
+		return require_index.cacheKey({
+			method: route.method,
+			path: route.path,
+			query: url.searchParams,
+			body: io.body,
+			vary
+		});
+	};
+	const replay = (entry, marker, at) => {
+		const headers = new Headers(entry.headers);
+		if (emitHeaders) {
+			headers.set("x-cache", marker);
+			for (const [k, v] of Object.entries(require_index.cacheHeaders(entry, at))) headers.set(k, v);
+		}
+		return new Response(entry.body, {
+			status: entry.status,
+			headers
+		});
+	};
+	/** Serialize + store a handler result, honoring the handler's `io.ctx.cache` opt-out and the store's bounds. */
+	const persist = async (io, storeKey, fullKey, control, result, route) => {
+		if (!control.store) return;
+		if (!require_index.isCacheableResult(result)) return;
+		if (opts.shouldCache && !opts.shouldCache({
+			req: io.req,
+			ctx: io.ctx
+		}, result)) return;
+		const body = JSON.stringify(result);
+		const bytes = new TextEncoder().encode(body).length;
+		const at = now();
+		const expires = at + (control.ttlOverride ?? ttl);
+		const entry = {
+			body,
+			status: 200,
+			headers: [["content-type", JSON_CONTENT_TYPE]],
+			storedAt: at,
+			expires,
+			staleUntil: expires + swr,
+			bytes,
+			method: route.method,
+			path: route.path,
+			key: checkKey ? fullKey : storeKey
+		};
+		await store.set(storeKey, entry);
+	};
+	/** Background refresh for a stale entry — single-flight per store key; failures leave the stale entry in place. */
+	const revalidate = (io, storeKey, fullKey, route) => {
+		if (inflight.has(storeKey)) return;
+		inflight.add(storeKey);
+		const control = makeControl(fullKey);
+		Promise.resolve(io.next({ cache: control })).then((result) => persist(io, storeKey, fullKey, control, result, route)).catch((err) => reportError(err, "revalidate")).finally(() => inflight.delete(storeKey));
+	};
+	/** The read phase — key derivation + store lookup. Runs no handler, so any throw here is a pure cache failure. */
+	const decide = async (io) => {
+		const kio = {
+			req: io.req,
+			ctx: io.ctx
+		};
+		const route = io.route;
+		const cc = parseCacheControl(io.req.headers.get("cache-control"));
+		const multipart = io.transport === "http" && (io.req.headers.get("content-type") ?? "").toLowerCase().includes("multipart/form-data");
+		if (route.kind !== "endpoint" || !methods.has(route.method) || opts.skip?.(kio) || cc.noStore || multipart) return { bypass: true };
+		const fullKey = keyOf(io, route);
+		const storeKey = opts.hash ? opts.hash(fullKey) : fullKey;
+		const control = makeControl(fullKey);
+		if (!cc.noCache) {
+			const entry = await store.get(storeKey);
+			if (entry && (!checkKey || entry.key === fullKey)) {
+				const at = now();
+				if (at < entry.expires) return { serve: replay(entry, "HIT", at) };
+				if (at < entry.staleUntil) {
+					revalidate(io, storeKey, fullKey, route);
+					return { serve: replay(entry, "STALE", at) };
+				}
+				await store.delete(storeKey);
+			} else if (entry) await store.delete(storeKey);
+		}
+		return {
+			proceed: true,
+			storeKey,
+			fullKey,
+			route,
+			control
+		};
+	};
+	const run = async (io) => {
+		let decision;
+		try {
+			decision = await decide(io);
+		} catch (err) {
+			reportError(err, "read");
+			return io.next({ cache: makeControl("") });
+		}
+		if ("serve" in decision) return decision.serve;
+		if ("bypass" in decision) return io.next({ cache: makeControl("") });
+		const result = await io.next({ cache: decision.control });
+		try {
+			if (emitHeaders) io.setHeader("x-cache", "MISS");
+			await persist(io, decision.storeKey, decision.fullKey, decision.control, result, decision.route);
+		} catch (err) {
+			reportError(err, "write");
+		}
+		return result;
+	};
+	return {
+		def,
+		impl: run
+	};
+}
+/**
+* The {@link cache} def factory, augmented with a `.server(def, opts)` binder. Import
+* from `@ayepi/cache/server` in your server entry to bind a def created in a
+* frontend-safe spec.
+*/
+const cache = Object.assign(require_index.cache, { server: cacheServer });
+//#endregion
+exports.cache = cache;

package/dist/server.d.cts

@@ -0,0 +1,78 @@
+import { CacheStore, cache as cache$1 } from "./index.cjs";
+import { AnyMiddleware, BoundMiddleware, Json, StackCtx } from "@ayepi/core";
+
+//#region src/server.d.ts
+
+/** The `requires` chain of a middleware def. */
+type ReqOf<M extends AnyMiddleware> = M['__req'];
+/** The argument passed to `key`/`vary`/`skip`/`shouldCache` — the request plus accumulated context. */
+interface CacheIO<Ctx extends object> {
+  readonly req: Request;
+  readonly ctx: Ctx;
+}
+/**
+ * Server-side options for binding a {@link cache} def — the caching policy, with
+ * `key`/`vary`/`skip`/`shouldCache` typed against the def's `requires` context. Extends
+ * {@link MemoryCacheOptions}, whose bounds configure the default {@link memoryCache} when
+ * no `store` is supplied.
+ *
+ * @typeParam M - the cache def being bound.
+ */
+interface CacheServerOptions<M extends AnyMiddleware> {
+  /** Freshness lifetime in milliseconds — a cached response is a `HIT` until it expires. */
+  readonly ttl: number;
+  /** Extra grace (ms) after `ttl` during which a stale entry is served immediately while it refreshes in the background. */
+  readonly staleWhileRevalidate?: number;
+  /** Which endpoint methods to cache (default `['GET']`) — keyed off the endpoint's declared method, so it governs HTTP and ws alike. */
+  readonly methods?: readonly string[];
+  /** An extra discriminator appended to the key (e.g. `io.ctx.user.id`) — for per-user/per-tenant caches. */
+  readonly vary?: (io: CacheIO<StackCtx<ReqOf<M>>>) => Json;
+  /** Replace the whole key derivation (default `method + path + query + body + vary`). Returns any JSON value. */
+  readonly key?: (io: CacheIO<StackCtx<ReqOf<M>>>) => Json;
+  /**
+   * Shrink the (possibly large) key to a store key — e.g. `hash: hashKey` or a crypto
+   * digest. Default: the full key is the store key. When set, {@link checkKey} defaults on.
+   */
+  readonly hash?: (fullKey: string) => string;
+  /**
+   * Store the full key in the entry and verify it on a hit, so a {@link hash} collision
+   * falls through to a miss instead of serving the wrong body. Defaults to `true` when
+   * `hash` is set; set `false` to drop the full key (leaner memory, accepts collision risk).
+   */
+  readonly checkKey?: boolean;
+  /** Backend store (default an in-process {@link memoryCache} built from the bounds below). */
+  readonly store?: CacheStore;
+  /** Total cache capacity in bytes for the default store (default 64 MiB). */
+  readonly maxBytes?: number;
+  /** Per-response cap in bytes for the default store (default 1 MiB) — larger responses aren't cached. */
+  readonly maxEntryBytes?: number;
+  /** Entry-count cap for the default store (default 10 000). */
+  readonly maxEntries?: number;
+  /** Decide per-response whether to cache it (runs on a miss, after the handler). */
+  readonly shouldCache?: (io: CacheIO<StackCtx<ReqOf<M>>>, result: unknown) => boolean;
+  /** Emit `X-Cache` / `Age` / `Cache-Control` response headers (default `true`). */
+  readonly headers?: boolean;
+  /** Bypass the cache for some requests (neither read nor write). */
+  readonly skip?: (io: CacheIO<StackCtx<ReqOf<M>>>) => boolean;
+  /**
+   * Observe an error the cache **swallowed** to stay fail-open — to log it, count a metric,
+   * etc. Not called by default (errors are silent). `phase` is where it happened: `'read'`
+   * (key/lookup → request served uncached), `'write'` (storing the result), or `'revalidate'`
+   * (a background stale refresh). It must not throw; if it does, the throw is ignored.
+   */
+  readonly onError?: (err: unknown, phase: 'read' | 'write' | 'revalidate') => void;
+  /** Clock injection (default `Date.now`) — for tests. */
+  readonly now?: () => number;
+}
+/** Bind a {@link cache} def to its runtime policy. */
+declare function cacheServer<M extends AnyMiddleware>(def: M, opts: CacheServerOptions<M>): BoundMiddleware<M>;
+/**
+ * The {@link cache} def factory, augmented with a `.server(def, opts)` binder. Import
+ * from `@ayepi/cache/server` in your server entry to bind a def created in a
+ * frontend-safe spec.
+ */
+declare const cache: typeof cache$1 & {
+  server: typeof cacheServer;
+};
+//#endregion
+export { CacheIO, CacheServerOptions, cache };

package/dist/server.d.ts

@@ -0,0 +1,78 @@
+import { CacheStore, cache as cache$1 } from "./index.js";
+import { AnyMiddleware, BoundMiddleware, Json, StackCtx } from "@ayepi/core";
+
+//#region src/server.d.ts
+
+/** The `requires` chain of a middleware def. */
+type ReqOf<M extends AnyMiddleware> = M['__req'];
+/** The argument passed to `key`/`vary`/`skip`/`shouldCache` — the request plus accumulated context. */
+interface CacheIO<Ctx extends object> {
+  readonly req: Request;
+  readonly ctx: Ctx;
+}
+/**
+ * Server-side options for binding a {@link cache} def — the caching policy, with
+ * `key`/`vary`/`skip`/`shouldCache` typed against the def's `requires` context. Extends
+ * {@link MemoryCacheOptions}, whose bounds configure the default {@link memoryCache} when
+ * no `store` is supplied.
+ *
+ * @typeParam M - the cache def being bound.
+ */
+interface CacheServerOptions<M extends AnyMiddleware> {
+  /** Freshness lifetime in milliseconds — a cached response is a `HIT` until it expires. */
+  readonly ttl: number;
+  /** Extra grace (ms) after `ttl` during which a stale entry is served immediately while it refreshes in the background. */
+  readonly staleWhileRevalidate?: number;
+  /** Which endpoint methods to cache (default `['GET']`) — keyed off the endpoint's declared method, so it governs HTTP and ws alike. */
+  readonly methods?: readonly string[];
+  /** An extra discriminator appended to the key (e.g. `io.ctx.user.id`) — for per-user/per-tenant caches. */
+  readonly vary?: (io: CacheIO<StackCtx<ReqOf<M>>>) => Json;
+  /** Replace the whole key derivation (default `method + path + query + body + vary`). Returns any JSON value. */
+  readonly key?: (io: CacheIO<StackCtx<ReqOf<M>>>) => Json;
+  /**
+   * Shrink the (possibly large) key to a store key — e.g. `hash: hashKey` or a crypto
+   * digest. Default: the full key is the store key. When set, {@link checkKey} defaults on.
+   */
+  readonly hash?: (fullKey: string) => string;
+  /**
+   * Store the full key in the entry and verify it on a hit, so a {@link hash} collision
+   * falls through to a miss instead of serving the wrong body. Defaults to `true` when
+   * `hash` is set; set `false` to drop the full key (leaner memory, accepts collision risk).
+   */
+  readonly checkKey?: boolean;
+  /** Backend store (default an in-process {@link memoryCache} built from the bounds below). */
+  readonly store?: CacheStore;
+  /** Total cache capacity in bytes for the default store (default 64 MiB). */
+  readonly maxBytes?: number;
+  /** Per-response cap in bytes for the default store (default 1 MiB) — larger responses aren't cached. */
+  readonly maxEntryBytes?: number;
+  /** Entry-count cap for the default store (default 10 000). */
+  readonly maxEntries?: number;
+  /** Decide per-response whether to cache it (runs on a miss, after the handler). */
+  readonly shouldCache?: (io: CacheIO<StackCtx<ReqOf<M>>>, result: unknown) => boolean;
+  /** Emit `X-Cache` / `Age` / `Cache-Control` response headers (default `true`). */
+  readonly headers?: boolean;
+  /** Bypass the cache for some requests (neither read nor write). */
+  readonly skip?: (io: CacheIO<StackCtx<ReqOf<M>>>) => boolean;
+  /**
+   * Observe an error the cache **swallowed** to stay fail-open — to log it, count a metric,
+   * etc. Not called by default (errors are silent). `phase` is where it happened: `'read'`
+   * (key/lookup → request served uncached), `'write'` (storing the result), or `'revalidate'`
+   * (a background stale refresh). It must not throw; if it does, the throw is ignored.
+   */
+  readonly onError?: (err: unknown, phase: 'read' | 'write' | 'revalidate') => void;
+  /** Clock injection (default `Date.now`) — for tests. */
+  readonly now?: () => number;
+}
+/** Bind a {@link cache} def to its runtime policy. */
+declare function cacheServer<M extends AnyMiddleware>(def: M, opts: CacheServerOptions<M>): BoundMiddleware<M>;
+/**
+ * The {@link cache} def factory, augmented with a `.server(def, opts)` binder. Import
+ * from `@ayepi/cache/server` in your server entry to bind a def created in a
+ * frontend-safe spec.
+ */
+declare const cache: typeof cache$1 & {
+  server: typeof cacheServer;
+};
+//#endregion
+export { CacheIO, CacheServerOptions, cache };