layercache 1.0.2 → 1.2.0

package/dist/index.js

@@ -1,12 +1,279 @@
 import {
   PatternMatcher,
   RedisTagIndex
-} from "./chunk-IILH5XTS.js";
+} from "./chunk-BWM4MU2X.js";
 
 // src/CacheStack.ts
 import { randomUUID } from "crypto";
-import { promises as fs } from "fs";
 import { EventEmitter } from "events";
+import { promises as fs } from "fs";
+
+// src/CacheNamespace.ts
+var CacheNamespace = class _CacheNamespace {
+  constructor(cache, prefix) {
+    this.cache = cache;
+    this.prefix = prefix;
+  }
+  cache;
+  prefix;
+  async get(key, fetcher, options) {
+    return this.cache.get(this.qualify(key), fetcher, options);
+  }
+  async getOrSet(key, fetcher, options) {
+    return this.cache.getOrSet(this.qualify(key), fetcher, options);
+  }
+  /**
+   * Like `get()`, but throws `CacheMissError` instead of returning `null`.
+   */
+  async getOrThrow(key, fetcher, options) {
+    return this.cache.getOrThrow(this.qualify(key), fetcher, options);
+  }
+  async has(key) {
+    return this.cache.has(this.qualify(key));
+  }
+  async ttl(key) {
+    return this.cache.ttl(this.qualify(key));
+  }
+  async set(key, value, options) {
+    await this.cache.set(this.qualify(key), value, options);
+  }
+  async delete(key) {
+    await this.cache.delete(this.qualify(key));
+  }
+  async mdelete(keys) {
+    await this.cache.mdelete(keys.map((k) => this.qualify(k)));
+  }
+  async clear() {
+    await this.cache.invalidateByPattern(`${this.prefix}:*`);
+  }
+  async mget(entries) {
+    return this.cache.mget(
+      entries.map((entry) => ({
+        ...entry,
+        key: this.qualify(entry.key)
+      }))
+    );
+  }
+  async mset(entries) {
+    await this.cache.mset(
+      entries.map((entry) => ({
+        ...entry,
+        key: this.qualify(entry.key)
+      }))
+    );
+  }
+  async invalidateByTag(tag) {
+    await this.cache.invalidateByTag(tag);
+  }
+  async invalidateByPattern(pattern) {
+    await this.cache.invalidateByPattern(this.qualify(pattern));
+  }
+  /**
+   * Returns detailed metadata about a single cache key within this namespace.
+   */
+  async inspect(key) {
+    return this.cache.inspect(this.qualify(key));
+  }
+  wrap(keyPrefix, fetcher, options) {
+    return this.cache.wrap(`${this.prefix}:${keyPrefix}`, fetcher, options);
+  }
+  warm(entries, options) {
+    return this.cache.warm(
+      entries.map((entry) => ({
+        ...entry,
+        key: this.qualify(entry.key)
+      })),
+      options
+    );
+  }
+  getMetrics() {
+    return this.cache.getMetrics();
+  }
+  getHitRate() {
+    return this.cache.getHitRate();
+  }
+  /**
+   * Creates a nested namespace. Keys are prefixed with `parentPrefix:childPrefix:`.
+   *
+   * ```ts
+   * const tenant = cache.namespace('tenant:abc')
+   * const posts = tenant.namespace('posts')
+   * // keys become: "tenant:abc:posts:mykey"
+   * ```
+   */
+  namespace(childPrefix) {
+    return new _CacheNamespace(this.cache, `${this.prefix}:${childPrefix}`);
+  }
+  qualify(key) {
+    return `${this.prefix}:${key}`;
+  }
+};
+
+// src/internal/CircuitBreakerManager.ts
+var CircuitBreakerManager = class {
+  breakers = /* @__PURE__ */ new Map();
+  maxEntries;
+  constructor(options) {
+    this.maxEntries = options.maxEntries;
+  }
+  /**
+   * Throws if the circuit is open for the given key.
+   * Automatically resets if the cooldown has elapsed.
+   */
+  assertClosed(key, options) {
+    const state = this.breakers.get(key);
+    if (!state?.openUntil) {
+      return;
+    }
+    const now = Date.now();
+    if (state.openUntil <= now) {
+      state.openUntil = null;
+      state.failures = 0;
+      this.breakers.set(key, state);
+      return;
+    }
+    const remainingMs = state.openUntil - now;
+    const remainingSecs = Math.ceil(remainingMs / 1e3);
+    throw new Error(`Circuit breaker is open for key "${key}" (resets in ${remainingSecs}s).`);
+  }
+  recordFailure(key, options) {
+    if (!options) {
+      return;
+    }
+    const failureThreshold = options.failureThreshold ?? 3;
+    const cooldownMs = options.cooldownMs ?? 3e4;
+    const state = this.breakers.get(key) ?? { failures: 0, openUntil: null };
+    state.failures += 1;
+    if (state.failures >= failureThreshold) {
+      state.openUntil = Date.now() + cooldownMs;
+    }
+    this.breakers.set(key, state);
+    this.pruneIfNeeded();
+  }
+  recordSuccess(key) {
+    this.breakers.delete(key);
+  }
+  isOpen(key) {
+    const state = this.breakers.get(key);
+    if (!state?.openUntil) {
+      return false;
+    }
+    if (state.openUntil <= Date.now()) {
+      state.openUntil = null;
+      state.failures = 0;
+      return false;
+    }
+    return true;
+  }
+  delete(key) {
+    this.breakers.delete(key);
+  }
+  clear() {
+    this.breakers.clear();
+  }
+  tripCount() {
+    let count = 0;
+    for (const state of this.breakers.values()) {
+      if (state.openUntil !== null) {
+        count += 1;
+      }
+    }
+    return count;
+  }
+  pruneIfNeeded() {
+    if (this.breakers.size <= this.maxEntries) {
+      return;
+    }
+    for (const [key, state] of this.breakers.entries()) {
+      if (this.breakers.size <= this.maxEntries) {
+        break;
+      }
+      if (!state.openUntil || state.openUntil <= Date.now()) {
+        this.breakers.delete(key);
+      }
+    }
+    for (const key of this.breakers.keys()) {
+      if (this.breakers.size <= this.maxEntries) {
+        break;
+      }
+      this.breakers.delete(key);
+    }
+  }
+};
+
+// src/internal/MetricsCollector.ts
+var MetricsCollector = class {
+  data = this.empty();
+  get snapshot() {
+    return {
+      ...this.data,
+      hitsByLayer: { ...this.data.hitsByLayer },
+      missesByLayer: { ...this.data.missesByLayer },
+      latencyByLayer: Object.fromEntries(Object.entries(this.data.latencyByLayer).map(([k, v]) => [k, { ...v }]))
+    };
+  }
+  increment(field, amount = 1) {
+    ;
+    this.data[field] += amount;
+  }
+  incrementLayer(map, layerName) {
+    this.data[map][layerName] = (this.data[map][layerName] ?? 0) + 1;
+  }
+  /**
+   * Records a read latency sample for the given layer.
+   * Maintains a rolling average and max using Welford's online algorithm.
+   */
+  recordLatency(layerName, durationMs) {
+    const existing = this.data.latencyByLayer[layerName];
+    if (!existing) {
+      this.data.latencyByLayer[layerName] = { avgMs: durationMs, maxMs: durationMs, count: 1 };
+      return;
+    }
+    existing.count += 1;
+    existing.avgMs += (durationMs - existing.avgMs) / existing.count;
+    if (durationMs > existing.maxMs) {
+      existing.maxMs = durationMs;
+    }
+  }
+  reset() {
+    this.data = this.empty();
+  }
+  hitRate() {
+    const total = this.data.hits + this.data.misses;
+    const overall = total === 0 ? 0 : this.data.hits / total;
+    const byLayer = {};
+    const allLayers = /* @__PURE__ */ new Set([...Object.keys(this.data.hitsByLayer), ...Object.keys(this.data.missesByLayer)]);
+    for (const layer of allLayers) {
+      const h = this.data.hitsByLayer[layer] ?? 0;
+      const m = this.data.missesByLayer[layer] ?? 0;
+      byLayer[layer] = h + m === 0 ? 0 : h / (h + m);
+    }
+    return { overall, byLayer };
+  }
+  empty() {
+    return {
+      hits: 0,
+      misses: 0,
+      fetches: 0,
+      sets: 0,
+      deletes: 0,
+      backfills: 0,
+      invalidations: 0,
+      staleHits: 0,
+      refreshes: 0,
+      refreshErrors: 0,
+      writeFailures: 0,
+      singleFlightWaits: 0,
+      negativeCacheHits: 0,
+      circuitBreakerTrips: 0,
+      degradedOperations: 0,
+      hitsByLayer: {},
+      missesByLayer: {},
+      latencyByLayer: {},
+      resetAt: Date.now()
+    };
+  }
+};
 
 // src/internal/StoredValue.ts
 function isStoredValueEnvelope(value) {
@@ -109,58 +376,91 @@ function normalizePositiveSeconds(value) {
   return value;
 }
 
-// src/CacheNamespace.ts
-var CacheNamespace = class {
-  constructor(cache, prefix) {
-    this.cache = cache;
-    this.prefix = prefix;
-  }
-  cache;
-  prefix;
-  async get(key, fetcher, options) {
-    return this.cache.get(this.qualify(key), fetcher, options);
-  }
-  async set(key, value, options) {
-    await this.cache.set(this.qualify(key), value, options);
-  }
-  async delete(key) {
-    await this.cache.delete(this.qualify(key));
+// src/internal/TtlResolver.ts
+var DEFAULT_NEGATIVE_TTL_SECONDS = 60;
+var TtlResolver = class {
+  accessProfiles = /* @__PURE__ */ new Map();
+  maxProfileEntries;
+  constructor(options) {
+    this.maxProfileEntries = options.maxProfileEntries;
   }
-  async clear() {
-    await this.cache.invalidateByPattern(`${this.prefix}:*`);
+  recordAccess(key) {
+    const profile = this.accessProfiles.get(key) ?? { hits: 0, lastAccessAt: Date.now() };
+    profile.hits += 1;
+    profile.lastAccessAt = Date.now();
+    this.accessProfiles.set(key, profile);
+    this.pruneIfNeeded();
   }
-  async mget(entries) {
-    return this.cache.mget(entries.map((entry) => ({
-      ...entry,
-      key: this.qualify(entry.key)
-    })));
+  deleteProfile(key) {
+    this.accessProfiles.delete(key);
   }
-  async mset(entries) {
-    await this.cache.mset(entries.map((entry) => ({
-      ...entry,
-      key: this.qualify(entry.key)
-    })));
+  clearProfiles() {
+    this.accessProfiles.clear();
   }
-  async invalidateByTag(tag) {
-    await this.cache.invalidateByTag(tag);
+  resolveFreshTtl(key, layerName, kind, options, fallbackTtl, globalNegativeTtl, globalTtl) {
+    const baseTtl = kind === "empty" ? this.resolveLayerSeconds(
+      layerName,
+      options?.negativeTtl,
+      globalNegativeTtl,
+      this.resolveLayerSeconds(layerName, options?.ttl, globalTtl, fallbackTtl) ?? DEFAULT_NEGATIVE_TTL_SECONDS
+    ) : this.resolveLayerSeconds(layerName, options?.ttl, globalTtl, fallbackTtl);
+    const adaptiveTtl = this.applyAdaptiveTtl(key, layerName, baseTtl, options?.adaptiveTtl);
+    const jitter = this.resolveLayerSeconds(layerName, options?.ttlJitter, void 0);
+    return this.applyJitter(adaptiveTtl, jitter);
   }
-  async invalidateByPattern(pattern) {
-    await this.cache.invalidateByPattern(this.qualify(pattern));
+  resolveLayerSeconds(layerName, override, globalDefault, fallback) {
+    if (override !== void 0) {
+      return this.readLayerNumber(layerName, override) ?? fallback;
+    }
+    if (globalDefault !== void 0) {
+      return this.readLayerNumber(layerName, globalDefault) ?? fallback;
+    }
+    return fallback;
   }
-  wrap(keyPrefix, fetcher, options) {
-    return this.cache.wrap(`${this.prefix}:${keyPrefix}`, fetcher, options);
+  applyAdaptiveTtl(key, layerName, ttl, adaptiveTtl) {
+    if (!ttl || !adaptiveTtl) {
+      return ttl;
+    }
+    const profile = this.accessProfiles.get(key);
+    if (!profile) {
+      return ttl;
+    }
+    const config = adaptiveTtl === true ? {} : adaptiveTtl;
+    const hotAfter = config.hotAfter ?? 3;
+    if (profile.hits < hotAfter) {
+      return ttl;
+    }
+    const step = this.resolveLayerSeconds(layerName, config.step, void 0, Math.max(1, Math.round(ttl / 2))) ?? 0;
+    const maxTtl = this.resolveLayerSeconds(layerName, config.maxTtl, void 0, ttl + step * 4) ?? ttl;
+    const multiplier = Math.floor(profile.hits / hotAfter);
+    return Math.min(maxTtl, ttl + step * multiplier);
   }
-  warm(entries, options) {
-    return this.cache.warm(entries.map((entry) => ({
-      ...entry,
-      key: this.qualify(entry.key)
-    })), options);
+  applyJitter(ttl, jitter) {
+    if (!ttl || ttl <= 0 || !jitter || jitter <= 0) {
+      return ttl;
+    }
+    const delta = (Math.random() * 2 - 1) * jitter;
+    return Math.max(1, Math.round(ttl + delta));
   }
-  getMetrics() {
-    return this.cache.getMetrics();
+  readLayerNumber(layerName, value) {
+    if (typeof value === "number") {
+      return value;
+    }
+    return value[layerName];
   }
-  qualify(key) {
-    return `${this.prefix}:${key}`;
+  pruneIfNeeded() {
+    if (this.accessProfiles.size <= this.maxProfileEntries) {
+      return;
+    }
+    const toRemove = Math.ceil(this.maxProfileEntries * 0.1);
+    let removed = 0;
+    for (const key of this.accessProfiles.keys()) {
+      if (removed >= toRemove) {
+        break;
+      }
+      this.accessProfiles.delete(key);
+      removed += 1;
+    }
   }
 };
 
@@ -169,11 +469,17 @@ var TagIndex = class {
   tagToKeys = /* @__PURE__ */ new Map();
   keyToTags = /* @__PURE__ */ new Map();
   knownKeys = /* @__PURE__ */ new Set();
+  maxKnownKeys;
+  constructor(options = {}) {
+    this.maxKnownKeys = options.maxKnownKeys;
+  }
   async touch(key) {
     this.knownKeys.add(key);
+    this.pruneKnownKeysIfNeeded();
   }
   async track(key, tags) {
     this.knownKeys.add(key);
+    this.pruneKnownKeysIfNeeded();
     if (tags.length === 0) {
       return;
     }
@@ -212,6 +518,9 @@ var TagIndex = class {
   async keysForTag(tag) {
     return [...this.tagToKeys.get(tag) ?? /* @__PURE__ */ new Set()];
   }
+  async tagsForKey(key) {
+    return [...this.keyToTags.get(key) ?? /* @__PURE__ */ new Set()];
+  }
   async matchPattern(pattern) {
     return [...this.knownKeys].filter((key) => PatternMatcher.matches(pattern, key));
   }
@@ -220,6 +529,21 @@ var TagIndex = class {
     this.keyToTags.clear();
     this.knownKeys.clear();
   }
+  pruneKnownKeysIfNeeded() {
+    if (this.maxKnownKeys === void 0 || this.knownKeys.size <= this.maxKnownKeys) {
+      return;
+    }
+    const toRemove = Math.ceil(this.maxKnownKeys * 0.1);
+    let removed = 0;
+    for (const key of this.knownKeys) {
+      if (removed >= toRemove) {
+        break;
+      }
+      this.knownKeys.delete(key);
+      this.keyToTags.delete(key);
+      removed += 1;
+    }
+  }
 };
 
 // src/stampede/StampedeGuard.ts
@@ -248,31 +572,22 @@ var StampedeGuard = class {
   }
 };
 
+// src/types.ts
+var CacheMissError = class extends Error {
+  key;
+  constructor(key) {
+    super(`Cache miss for key "${key}".`);
+    this.name = "CacheMissError";
+    this.key = key;
+  }
+};
+
 // src/CacheStack.ts
-var DEFAULT_NEGATIVE_TTL_SECONDS = 60;
 var DEFAULT_SINGLE_FLIGHT_LEASE_MS = 3e4;
 var DEFAULT_SINGLE_FLIGHT_TIMEOUT_MS = 5e3;
 var DEFAULT_SINGLE_FLIGHT_POLL_MS = 50;
 var MAX_CACHE_KEY_LENGTH = 1024;
-var EMPTY_METRICS = () => ({
-  hits: 0,
-  misses: 0,
-  fetches: 0,
-  sets: 0,
-  deletes: 0,
-  backfills: 0,
-  invalidations: 0,
-  staleHits: 0,
-  refreshes: 0,
-  refreshErrors: 0,
-  writeFailures: 0,
-  singleFlightWaits: 0,
-  negativeCacheHits: 0,
-  circuitBreakerTrips: 0,
-  degradedOperations: 0,
-  hitsByLayer: {},
-  missesByLayer: {}
-});
+var DEFAULT_MAX_PROFILE_ENTRIES = 1e5;
 var DebugLogger = class {
   enabled;
   constructor(enabled) {
@@ -307,6 +622,14 @@ var CacheStack = class extends EventEmitter {
       throw new Error("CacheStack requires at least one cache layer.");
     }
     this.validateConfiguration();
+    const maxProfileEntries = options.maxProfileEntries ?? DEFAULT_MAX_PROFILE_ENTRIES;
+    this.ttlResolver = new TtlResolver({ maxProfileEntries });
+    this.circuitBreakerManager = new CircuitBreakerManager({ maxEntries: maxProfileEntries });
+    if (options.publishSetInvalidation !== void 0) {
+      console.warn(
+        "[layercache] CacheStackOptions.publishSetInvalidation is deprecated. Use broadcastL1Invalidation instead."
+      );
+    }
     const debugEnv = process.env.DEBUG?.split(",").includes("layercache:debug") ?? false;
     this.logger = typeof options.logger === "object" ? options.logger : new DebugLogger(Boolean(options.logger) || debugEnv);
     this.tagIndex = options.tagIndex ?? new TagIndex();
@@ -315,36 +638,42 @@ var CacheStack = class extends EventEmitter {
   layers;
   options;
   stampedeGuard = new StampedeGuard();
-  metrics = EMPTY_METRICS();
+  metricsCollector = new MetricsCollector();
   instanceId = randomUUID();
   startup;
   unsubscribeInvalidation;
   logger;
   tagIndex;
   backgroundRefreshes = /* @__PURE__ */ new Map();
-  accessProfiles = /* @__PURE__ */ new Map();
   layerDegradedUntil = /* @__PURE__ */ new Map();
-  circuitBreakers = /* @__PURE__ */ new Map();
+  ttlResolver;
+  circuitBreakerManager;
   isDisconnecting = false;
   disconnectPromise;
+  /**
+   * Read-through cache get.
+   * Returns the cached value if present and fresh, or invokes `fetcher` on a miss
+   * and stores the result across all layers. Returns `null` if the key is not found
+   * and no `fetcher` is provided.
+   */
   async get(key, fetcher, options) {
     const normalizedKey = this.validateCacheKey(key);
     this.validateWriteOptions(options);
     await this.startup;
     const hit = await this.readFromLayers(normalizedKey, options, "allow-stale");
     if (hit.found) {
-      this.recordAccess(normalizedKey);
+      this.ttlResolver.recordAccess(normalizedKey);
       if (this.isNegativeStoredValue(hit.stored)) {
-        this.metrics.negativeCacheHits += 1;
+        this.metricsCollector.increment("negativeCacheHits");
       }
       if (hit.state === "fresh") {
-        this.metrics.hits += 1;
+        this.metricsCollector.increment("hits");
         await this.applyFreshReadPolicies(normalizedKey, hit, options, fetcher);
         return hit.value;
       }
       if (hit.state === "stale-while-revalidate") {
-        this.metrics.hits += 1;
-        this.metrics.staleHits += 1;
+        this.metricsCollector.increment("hits");
+        this.metricsCollector.increment("staleHits");
         this.emit("stale-serve", { key: normalizedKey, state: hit.state, layer: hit.layerName });
         if (fetcher) {
           this.scheduleBackgroundRefresh(normalizedKey, fetcher, options);
@@ -352,47 +681,148 @@ var CacheStack = class extends EventEmitter {
         return hit.value;
       }
       if (!fetcher) {
-        this.metrics.hits += 1;
-        this.metrics.staleHits += 1;
+        this.metricsCollector.increment("hits");
+        this.metricsCollector.increment("staleHits");
         this.emit("stale-serve", { key: normalizedKey, state: hit.state, layer: hit.layerName });
         return hit.value;
       }
       try {
         return await this.fetchWithGuards(normalizedKey, fetcher, options);
       } catch (error) {
-        this.metrics.staleHits += 1;
-        this.metrics.refreshErrors += 1;
+        this.metricsCollector.increment("staleHits");
+        this.metricsCollector.increment("refreshErrors");
         this.logger.debug?.("stale-if-error", { key: normalizedKey, error: this.formatError(error) });
         return hit.value;
       }
     }
-    this.metrics.misses += 1;
+    this.metricsCollector.increment("misses");
     if (!fetcher) {
       return null;
     }
     return this.fetchWithGuards(normalizedKey, fetcher, options);
   }
+  /**
+   * Alias for `get(key, fetcher, options)` — explicit get-or-set pattern.
+   * Fetches and caches the value if not already present.
+   */
+  async getOrSet(key, fetcher, options) {
+    return this.get(key, fetcher, options);
+  }
+  /**
+   * Like `get()`, but throws `CacheMissError` instead of returning `null`.
+   * Useful when the value is expected to exist or the fetcher is expected to
+   * return non-null.
+   */
+  async getOrThrow(key, fetcher, options) {
+    const value = await this.get(key, fetcher, options);
+    if (value === null) {
+      throw new CacheMissError(key);
+    }
+    return value;
+  }
+  /**
+   * Returns true if the given key exists and is not expired in any layer.
+   */
+  async has(key) {
+    const normalizedKey = this.validateCacheKey(key);
+    await this.startup;
+    for (const layer of this.layers) {
+      if (this.shouldSkipLayer(layer)) {
+        continue;
+      }
+      if (layer.has) {
+        try {
+          const exists = await layer.has(normalizedKey);
+          if (exists) {
+            return true;
+          }
+        } catch {
+        }
+      } else {
+        try {
+          const value = await layer.get(normalizedKey);
+          if (value !== null) {
+            return true;
+          }
+        } catch {
+        }
+      }
+    }
+    return false;
+  }
+  /**
+   * Returns the remaining TTL in seconds for the key in the fastest layer
+   * that has it, or null if the key is not found / has no TTL.
+   */
+  async ttl(key) {
+    const normalizedKey = this.validateCacheKey(key);
+    await this.startup;
+    for (const layer of this.layers) {
+      if (this.shouldSkipLayer(layer)) {
+        continue;
+      }
+      if (layer.ttl) {
+        try {
+          const remaining = await layer.ttl(normalizedKey);
+          if (remaining !== null) {
+            return remaining;
+          }
+        } catch {
+        }
+      }
+    }
+    return null;
+  }
+  /**
+   * Stores a value in all cache layers. Overwrites any existing value.
+   */
   async set(key, value, options) {
     const normalizedKey = this.validateCacheKey(key);
     this.validateWriteOptions(options);
     await this.startup;
     await this.storeEntry(normalizedKey, "value", value, options);
   }
+  /**
+   * Deletes the key from all layers and publishes an invalidation message.
+   */
   async delete(key) {
     const normalizedKey = this.validateCacheKey(key);
     await this.startup;
     await this.deleteKeys([normalizedKey]);
-    await this.publishInvalidation({ scope: "key", keys: [normalizedKey], sourceId: this.instanceId, operation: "delete" });
+    await this.publishInvalidation({
+      scope: "key",
+      keys: [normalizedKey],
+      sourceId: this.instanceId,
+      operation: "delete"
+    });
   }
   async clear() {
     await this.startup;
     await Promise.all(this.layers.map((layer) => layer.clear()));
     await this.tagIndex.clear();
-    this.accessProfiles.clear();
-    this.metrics.invalidations += 1;
+    this.ttlResolver.clearProfiles();
+    this.circuitBreakerManager.clear();
+    this.metricsCollector.increment("invalidations");
     this.logger.debug?.("clear");
     await this.publishInvalidation({ scope: "clear", sourceId: this.instanceId, operation: "clear" });
   }
+  /**
+   * Deletes multiple keys at once. More efficient than calling `delete()` in a loop.
+   */
+  async mdelete(keys) {
+    if (keys.length === 0) {
+      return;
+    }
+    await this.startup;
+    const normalizedKeys = keys.map((k) => this.validateCacheKey(k));
+    await this.deleteKeys(normalizedKeys);
+    await this.publishInvalidation({
+      scope: "keys",
+      keys: normalizedKeys,
+      sourceId: this.instanceId,
+      operation: "delete"
+    });
+  }
   async mget(entries) {
     if (entries.length === 0) {
       return [];
@@ -430,7 +860,9 @@ var CacheStack = class extends EventEmitter {
     const indexesByKey = /* @__PURE__ */ new Map();
     const resultsByKey = /* @__PURE__ */ new Map();
     for (let index = 0; index < normalizedEntries.length; index += 1) {
-      const key = normalizedEntries[index].key;
+      const entry = normalizedEntries[index];
+      if (!entry) continue;
+      const key = entry.key;
       const indexes = indexesByKey.get(key) ?? [];
       indexes.push(index);
       indexesByKey.set(key, indexes);
@@ -438,6 +870,7 @@ var CacheStack = class extends EventEmitter {
     }
     for (let layerIndex = 0; layerIndex < this.layers.length; layerIndex += 1) {
       const layer = this.layers[layerIndex];
+      if (!layer) continue;
       const keys = [...pending];
       if (keys.length === 0) {
         break;
@@ -446,7 +879,7 @@ var CacheStack = class extends EventEmitter {
       for (let offset = 0; offset < values.length; offset += 1) {
         const key = keys[offset];
         const stored = values[offset];
-        if (stored === null) {
+        if (!key || stored === null) {
           continue;
         }
         const resolved = resolveStoredValue(stored);
@@ -458,13 +891,13 @@ var CacheStack = class extends EventEmitter {
         await this.backfill(key, stored, layerIndex - 1);
         resultsByKey.set(key, resolved.value);
         pending.delete(key);
-        this.metrics.hits += indexesByKey.get(key)?.length ?? 1;
+        this.metricsCollector.increment("hits", indexesByKey.get(key)?.length ?? 1);
       }
     }
     if (pending.size > 0) {
       for (const key of pending) {
         await this.tagIndex.remove(key);
-        this.metrics.misses += indexesByKey.get(key)?.length ?? 1;
+        this.metricsCollector.increment("misses", indexesByKey.get(key)?.length ?? 1);
       }
     }
     return normalizedEntries.map((entry) => resultsByKey.get(entry.key) ?? null);
@@ -479,26 +912,38 @@ var CacheStack = class extends EventEmitter {
   }
   async warm(entries, options = {}) {
     const concurrency = Math.max(1, options.concurrency ?? 4);
+    const total = entries.length;
+    let completed = 0;
     const queue = [...entries].sort((left, right) => (right.priority ?? 0) - (left.priority ?? 0));
-    const workers = Array.from({ length: Math.min(concurrency, queue.length) }, async () => {
+    const workers = Array.from({ length: Math.min(concurrency, queue.length || 1) }, async () => {
       while (queue.length > 0) {
         const entry = queue.shift();
         if (!entry) {
           return;
         }
+        let success = false;
         try {
           await this.get(entry.key, entry.fetcher, entry.options);
           this.emit("warm", { key: entry.key });
+          success = true;
         } catch (error) {
           this.emitError("warm", { key: entry.key, error: this.formatError(error) });
           if (!options.continueOnError) {
             throw error;
           }
+        } finally {
+          completed += 1;
+          const progress = { completed, total, key: entry.key, success };
+          options.onProgress?.(progress);
         }
       }
     });
     await Promise.all(workers);
   }
+  /**
+   * Returns a cached version of `fetcher`. The cache key is derived from
+   * `prefix` plus the serialized arguments unless a `keyResolver` is provided.
+   */
   wrap(prefix, fetcher, options = {}) {
     return (...args) => {
       const suffix = options.keyResolver ? options.keyResolver(...args) : args.map((argument) => this.serializeKeyPart(argument)).join(":");
@@ -506,6 +951,10 @@ var CacheStack = class extends EventEmitter {
       return this.get(key, () => fetcher(...args), options);
     };
   }
+  /**
+   * Creates a `CacheNamespace` that automatically prefixes all keys with
+   * `prefix:`. Useful for multi-tenant or module-level isolation.
+   */
   namespace(prefix) {
     return new CacheNamespace(this, prefix);
   }
@@ -522,7 +971,7 @@ var CacheStack = class extends EventEmitter {
     await this.publishInvalidation({ scope: "keys", keys, sourceId: this.instanceId, operation: "invalidate" });
   }
   getMetrics() {
-    return { ...this.metrics };
+    return this.metricsCollector.snapshot;
   }
   getStats() {
     return {
@@ -536,7 +985,53 @@ var CacheStack = class extends EventEmitter {
     };
   }
   resetMetrics() {
-    Object.assign(this.metrics, EMPTY_METRICS());
+    this.metricsCollector.reset();
+  }
+  /**
+   * Returns computed hit-rate statistics (overall and per-layer).
+   */
+  getHitRate() {
+    return this.metricsCollector.hitRate();
+  }
+  /**
+   * Returns detailed metadata about a single cache key: which layers contain it,
+   * remaining fresh/stale/error TTLs, and associated tags.
+   * Returns `null` if the key does not exist in any layer.
+   */
+  async inspect(key) {
+    const normalizedKey = this.validateCacheKey(key);
+    await this.startup;
+    const foundInLayers = [];
+    let freshTtlSeconds = null;
+    let staleTtlSeconds = null;
+    let errorTtlSeconds = null;
+    let isStale = false;
+    for (const layer of this.layers) {
+      if (this.shouldSkipLayer(layer)) {
+        continue;
+      }
+      const stored = await this.readLayerEntry(layer, normalizedKey);
+      if (stored === null) {
+        continue;
+      }
+      const resolved = resolveStoredValue(stored);
+      if (resolved.state === "expired") {
+        continue;
+      }
+      foundInLayers.push(layer.name);
+      if (foundInLayers.length === 1 && resolved.envelope) {
+        const now = Date.now();
+        freshTtlSeconds = resolved.envelope.freshUntil !== null ? Math.max(0, Math.ceil((resolved.envelope.freshUntil - now) / 1e3)) : null;
+        staleTtlSeconds = resolved.envelope.staleUntil !== null ? Math.max(0, Math.ceil((resolved.envelope.staleUntil - now) / 1e3)) : null;
+        errorTtlSeconds = resolved.envelope.errorUntil !== null ? Math.max(0, Math.ceil((resolved.envelope.errorUntil - now) / 1e3)) : null;
+        isStale = resolved.state === "stale-while-revalidate" || resolved.state === "stale-if-error";
+      }
+    }
+    if (foundInLayers.length === 0) {
+      return null;
+    }
+    const tags = await this.getTagsForKey(normalizedKey);
+    return { key: normalizedKey, foundInLayers, freshTtlSeconds, staleTtlSeconds, errorTtlSeconds, isStale, tags };
   }
   async exportState() {
     await this.startup;
@@ -565,10 +1060,12 @@ var CacheStack = class extends EventEmitter {
   }
   async importState(entries) {
     await this.startup;
-    await Promise.all(entries.map(async (entry) => {
-      await Promise.all(this.layers.map((layer) => layer.set(entry.key, entry.value, entry.ttl)));
-      await this.tagIndex.touch(entry.key);
-    }));
+    await Promise.all(
+      entries.map(async (entry) => {
+        await Promise.all(this.layers.map((layer) => layer.set(entry.key, entry.value, entry.ttl)));
+        await this.tagIndex.touch(entry.key);
+      })
+    );
   }
   async persistToFile(filePath) {
     const snapshot = await this.exportState();
@@ -576,11 +1073,21 @@ var CacheStack = class extends EventEmitter {
   }
   async restoreFromFile(filePath) {
     const raw = await fs.readFile(filePath, "utf8");
-    const snapshot = JSON.parse(raw);
-    if (!this.isCacheSnapshotEntries(snapshot)) {
-      throw new Error("Invalid snapshot file: expected CacheSnapshotEntry[]");
+    let parsed;
+    try {
+      parsed = JSON.parse(raw, (_key, value) => {
+        if (value !== null && typeof value === "object" && !Array.isArray(value)) {
+          return Object.assign(/* @__PURE__ */ Object.create(null), value);
+        }
+        return value;
+      });
+    } catch (cause) {
+      throw new Error(`Invalid snapshot file: could not parse JSON (${this.formatError(cause)})`);
     }
-    await this.importState(snapshot);
+    if (!this.isCacheSnapshotEntries(parsed)) {
+      throw new Error("Invalid snapshot file: expected an array of { key: string, value, ttl? } entries");
+    }
+    await this.importState(parsed);
   }
   async disconnect() {
     if (!this.disconnectPromise) {
@@ -605,7 +1112,7 @@ var CacheStack = class extends EventEmitter {
     const fetchTask = async () => {
       const secondHit = await this.readFromLayers(key, options, "fresh-only");
       if (secondHit.found) {
-        this.metrics.hits += 1;
+        this.metricsCollector.increment("hits");
         return secondHit.value;
       }
       return this.fetchAndPopulate(key, fetcher, options);
@@ -630,12 +1137,12 @@ var CacheStack = class extends EventEmitter {
     const timeoutMs = this.options.singleFlightTimeoutMs ?? DEFAULT_SINGLE_FLIGHT_TIMEOUT_MS;
     const pollIntervalMs = this.options.singleFlightPollMs ?? DEFAULT_SINGLE_FLIGHT_POLL_MS;
     const deadline = Date.now() + timeoutMs;
-    this.metrics.singleFlightWaits += 1;
+    this.metricsCollector.increment("singleFlightWaits");
     this.emit("stampede-dedupe", { key });
     while (Date.now() < deadline) {
       const hit = await this.readFromLayers(key, options, "fresh-only");
       if (hit.found) {
-        this.metrics.hits += 1;
+        this.metricsCollector.increment("hits");
         return hit.value;
       }
       await this.sleep(pollIntervalMs);
@@ -643,12 +1150,14 @@ var CacheStack = class extends EventEmitter {
     return this.fetchAndPopulate(key, fetcher, options);
   }
   async fetchAndPopulate(key, fetcher, options) {
-    this.assertCircuitClosed(key, options?.circuitBreaker ?? this.options.circuitBreaker);
-    this.metrics.fetches += 1;
+    this.circuitBreakerManager.assertClosed(key, options?.circuitBreaker ?? this.options.circuitBreaker);
+    this.metricsCollector.increment("fetches");
+    const fetchStart = Date.now();
     let fetched;
     try {
       fetched = await fetcher();
-      this.resetCircuitBreaker(key);
+      this.circuitBreakerManager.recordSuccess(key);
+      this.logger.debug?.("fetch", { key, durationMs: Date.now() - fetchStart });
     } catch (error) {
       this.recordCircuitFailure(key, options?.circuitBreaker ?? this.options.circuitBreaker, error);
       throw error;
@@ -660,6 +1169,9 @@ var CacheStack = class extends EventEmitter {
       await this.storeEntry(key, "empty", null, options);
       return null;
     }
+    if (options?.shouldCache && !options.shouldCache(fetched)) {
+      return fetched;
+    }
     await this.storeEntry(key, "value", fetched, options);
     return fetched;
   }
@@ -670,7 +1182,7 @@ var CacheStack = class extends EventEmitter {
     } else {
       await this.tagIndex.touch(key);
     }
-    this.metrics.sets += 1;
+    this.metricsCollector.increment("sets");
     this.logger.debug?.("set", { key, kind, tags: options?.tags });
     this.emit("set", { key, kind, tags: options?.tags });
     if (this.shouldBroadcastL1Invalidation()) {
@@ -681,9 +1193,13 @@ var CacheStack = class extends EventEmitter {
     let sawRetainableValue = false;
     for (let index = 0; index < this.layers.length; index += 1) {
       const layer = this.layers[index];
+      if (!layer) continue;
+      const readStart = performance.now();
       const stored = await this.readLayerEntry(layer, key);
+      const readDuration = performance.now() - readStart;
+      this.metricsCollector.recordLatency(layer.name, readDuration);
       if (stored === null) {
-        this.incrementMetricMap(this.metrics.missesByLayer, layer.name);
+        this.metricsCollector.incrementLayer("missesByLayer", layer.name);
         continue;
       }
       const resolved = resolveStoredValue(stored);
@@ -697,10 +1213,17 @@ var CacheStack = class extends EventEmitter {
       }
       await this.tagIndex.touch(key);
       await this.backfill(key, stored, index - 1, options);
-      this.incrementMetricMap(this.metrics.hitsByLayer, layer.name);
+      this.metricsCollector.incrementLayer("hitsByLayer", layer.name);
       this.logger.debug?.("hit", { key, layer: layer.name, state: resolved.state });
       this.emit("hit", { key, layer: layer.name, state: resolved.state });
-      return { found: true, value: resolved.value, stored, state: resolved.state, layerIndex: index, layerName: layer.name };
+      return {
+        found: true,
+        value: resolved.value,
+        stored,
+        state: resolved.state,
+        layerIndex: index,
+        layerName: layer.name
+      };
     }
     if (!sawRetainableValue) {
       await this.tagIndex.remove(key);
@@ -732,7 +1255,7 @@ var CacheStack = class extends EventEmitter {
     }
     for (let index = 0; index <= upToIndex; index += 1) {
       const layer = this.layers[index];
-      if (this.shouldSkipLayer(layer)) {
+      if (!layer || this.shouldSkipLayer(layer)) {
         continue;
       }
       const ttl = remainingStoredTtlSeconds(stored) ?? this.resolveLayerSeconds(layer.name, options?.ttl, void 0, layer.defaultTtl);
@@ -742,7 +1265,7 @@ var CacheStack = class extends EventEmitter {
         await this.handleLayerFailure(layer, "backfill", error);
         continue;
       }
-      this.metrics.backfills += 1;
+      this.metricsCollector.increment("backfills");
       this.logger.debug?.("backfill", { key, layer: layer.name });
       this.emit("backfill", { key, layer: layer.name });
     }
@@ -759,11 +1282,7 @@ var CacheStack = class extends EventEmitter {
         options?.staleWhileRevalidate,
         this.options.staleWhileRevalidate
       );
-      const staleIfError = this.resolveLayerSeconds(
-        layer.name,
-        options?.staleIfError,
-        this.options.staleIfError
-      );
+      const staleIfError = this.resolveLayerSeconds(layer.name, options?.staleIfError, this.options.staleIfError);
       const payload = createStoredValueEnvelope({
         kind,
         value,
@@ -791,7 +1310,7 @@ var CacheStack = class extends EventEmitter {
     if (failures.length === 0) {
       return;
     }
-    this.metrics.writeFailures += failures.length;
+    this.metricsCollector.increment("writeFailures", failures.length);
     this.logger.debug?.("write-failure", {
       ...context,
       failures: failures.map((failure) => this.formatError(failure.reason))
@@ -804,42 +1323,10 @@ var CacheStack = class extends EventEmitter {
     }
   }
   resolveFreshTtl(key, layerName, kind, options, fallbackTtl) {
-    const baseTtl = kind === "empty" ? this.resolveLayerSeconds(
-      layerName,
-      options?.negativeTtl,
-      this.options.negativeTtl,
-      this.resolveLayerSeconds(layerName, options?.ttl, void 0, fallbackTtl) ?? DEFAULT_NEGATIVE_TTL_SECONDS
-    ) : this.resolveLayerSeconds(layerName, options?.ttl, void 0, fallbackTtl);
-    const adaptiveTtl = this.applyAdaptiveTtl(
-      key,
-      layerName,
-      baseTtl,
-      options?.adaptiveTtl ?? this.options.adaptiveTtl
-    );
-    const jitter = this.resolveLayerSeconds(layerName, options?.ttlJitter, this.options.ttlJitter);
-    return this.applyJitter(adaptiveTtl, jitter);
+    return this.ttlResolver.resolveFreshTtl(key, layerName, kind, options, fallbackTtl, this.options.negativeTtl);
   }
   resolveLayerSeconds(layerName, override, globalDefault, fallback) {
-    if (override !== void 0) {
-      return this.readLayerNumber(layerName, override) ?? fallback;
-    }
-    if (globalDefault !== void 0) {
-      return this.readLayerNumber(layerName, globalDefault) ?? fallback;
-    }
-    return fallback;
-  }
-  readLayerNumber(layerName, value) {
-    if (typeof value === "number") {
-      return value;
-    }
-    return value[layerName];
-  }
-  applyJitter(ttl, jitter) {
-    if (!ttl || ttl <= 0 || !jitter || jitter <= 0) {
-      return ttl;
-    }
-    const delta = (Math.random() * 2 - 1) * jitter;
-    return Math.max(1, Math.round(ttl + delta));
+    return this.ttlResolver.resolveLayerSeconds(layerName, override, globalDefault, fallback);
   }
   shouldNegativeCache(options) {
     return options?.negativeCache ?? this.options.negativeCaching ?? false;
@@ -849,11 +1336,11 @@ var CacheStack = class extends EventEmitter {
       return;
     }
     const refresh = (async () => {
-      this.metrics.refreshes += 1;
+      this.metricsCollector.increment("refreshes");
       try {
         await this.fetchWithGuards(key, fetcher, options);
       } catch (error) {
-        this.metrics.refreshErrors += 1;
+        this.metricsCollector.increment("refreshErrors");
         this.logger.debug?.("refresh-error", { key, error: this.formatError(error) });
       } finally {
         this.backgroundRefreshes.delete(key);
@@ -875,10 +1362,11 @@ var CacheStack = class extends EventEmitter {
     await this.deleteKeysFromLayers(this.layers, keys);
     for (const key of keys) {
       await this.tagIndex.remove(key);
-      this.accessProfiles.delete(key);
+      this.ttlResolver.deleteProfile(key);
+      this.circuitBreakerManager.delete(key);
     }
-    this.metrics.deletes += keys.length;
-    this.metrics.invalidations += 1;
+    this.metricsCollector.increment("deletes", keys.length);
+    this.metricsCollector.increment("invalidations");
     this.logger.debug?.("delete", { keys });
     this.emit("delete", { keys });
   }
@@ -899,7 +1387,7 @@ var CacheStack = class extends EventEmitter {
     if (message.scope === "clear") {
       await Promise.all(localLayers.map((layer) => layer.clear()));
       await this.tagIndex.clear();
-      this.accessProfiles.clear();
+      this.ttlResolver.clearProfiles();
       return;
     }
     const keys = message.keys ?? [];
@@ -907,10 +1395,16 @@ var CacheStack = class extends EventEmitter {
     if (message.operation !== "write") {
       for (const key of keys) {
         await this.tagIndex.remove(key);
-        this.accessProfiles.delete(key);
+        this.ttlResolver.deleteProfile(key);
       }
     }
   }
+  async getTagsForKey(key) {
+    if (this.tagIndex.tagsForKey) {
+      return this.tagIndex.tagsForKey(key);
+    }
+    return [];
+  }
   formatError(error) {
     if (error instanceof Error) {
       return error.message;
@@ -937,13 +1431,15 @@ var CacheStack = class extends EventEmitter {
           }
           return;
         }
-        await Promise.all(keys.map(async (key) => {
-          try {
-            await layer.delete(key);
-          } catch (error) {
-            await this.handleLayerFailure(layer, "delete", error);
-          }
-        }));
+        await Promise.all(
+          keys.map(async (key) => {
+            try {
+              await layer.delete(key);
+            } catch (error) {
+              await this.handleLayerFailure(layer, "delete", error);
+            }
+          })
+        );
       })
     );
   }
@@ -1044,46 +1540,19 @@ var CacheStack = class extends EventEmitter {
       const ttl = remainingStoredTtlSeconds(refreshed);
       for (let index = 0; index <= hit.layerIndex; index += 1) {
         const layer = this.layers[index];
-        if (this.shouldSkipLayer(layer)) {
+        if (!layer || this.shouldSkipLayer(layer)) {
           continue;
         }
         try {
-          await layer.set(key, refreshed, ttl);
-        } catch (error) {
-          await this.handleLayerFailure(layer, "sliding-ttl", error);
-        }
-      }
-    }
-    if (fetcher && refreshAhead > 0 && remainingFreshTtl > 0 && remainingFreshTtl <= refreshAhead) {
-      this.scheduleBackgroundRefresh(key, fetcher, options);
-    }
-  }
-  applyAdaptiveTtl(key, layerName, ttl, adaptiveTtl) {
-    if (!ttl || !adaptiveTtl) {
-      return ttl;
-    }
-    const profile = this.accessProfiles.get(key);
-    if (!profile) {
-      return ttl;
+          await layer.set(key, refreshed, ttl);
+        } catch (error) {
+          await this.handleLayerFailure(layer, "sliding-ttl", error);
+        }
+      }
     }
-    const config = adaptiveTtl === true ? {} : adaptiveTtl;
-    const hotAfter = config.hotAfter ?? 3;
-    if (profile.hits < hotAfter) {
-      return ttl;
+    if (fetcher && refreshAhead > 0 && remainingFreshTtl > 0 && remainingFreshTtl <= refreshAhead) {
+      this.scheduleBackgroundRefresh(key, fetcher, options);
     }
-    const step = this.resolveLayerSeconds(layerName, config.step, void 0, Math.max(1, Math.round(ttl / 2))) ?? 0;
-    const maxTtl = this.resolveLayerSeconds(layerName, config.maxTtl, void 0, ttl + step * 4) ?? ttl;
-    const multiplier = Math.floor(profile.hits / hotAfter);
-    return Math.min(maxTtl, ttl + step * multiplier);
-  }
-  recordAccess(key) {
-    const profile = this.accessProfiles.get(key) ?? { hits: 0, lastAccessAt: Date.now() };
-    profile.hits += 1;
-    profile.lastAccessAt = Date.now();
-    this.accessProfiles.set(key, profile);
-  }
-  incrementMetricMap(target, key) {
-    target[key] = (target[key] ?? 0) + 1;
   }
   shouldSkipLayer(layer) {
     const degradedUntil = this.layerDegradedUntil.get(layer.name);
@@ -1095,7 +1564,7 @@ var CacheStack = class extends EventEmitter {
     }
     const retryAfterMs = typeof this.options.gracefulDegradation === "object" ? this.options.gracefulDegradation.retryAfterMs ?? 1e4 : 1e4;
     this.layerDegradedUntil.set(layer.name, Date.now() + retryAfterMs);
-    this.metrics.degradedOperations += 1;
+    this.metricsCollector.increment("degradedOperations");
     this.logger.warn?.("layer-degraded", { layer: layer.name, operation, error: this.formatError(error) });
     this.emitError(operation, { layer: layer.name, degraded: true, error: this.formatError(error) });
     return null;
@@ -1103,37 +1572,15 @@ var CacheStack = class extends EventEmitter {
   isGracefulDegradationEnabled() {
     return Boolean(this.options.gracefulDegradation);
   }
-  assertCircuitClosed(key, options) {
-    const state = this.circuitBreakers.get(key);
-    if (!state?.openUntil) {
-      return;
-    }
-    if (state.openUntil <= Date.now()) {
-      state.openUntil = null;
-      state.failures = 0;
-      this.circuitBreakers.set(key, state);
-      return;
-    }
-    this.emitError("circuit-breaker-open", { key, openUntil: state.openUntil });
-    throw new Error(`Circuit breaker is open for key "${key}".`);
-  }
   recordCircuitFailure(key, options, error) {
     if (!options) {
       return;
     }
-    const failureThreshold = options.failureThreshold ?? 3;
-    const cooldownMs = options.cooldownMs ?? 3e4;
-    const state = this.circuitBreakers.get(key) ?? { failures: 0, openUntil: null };
-    state.failures += 1;
-    if (state.failures >= failureThreshold) {
-      state.openUntil = Date.now() + cooldownMs;
-      this.metrics.circuitBreakerTrips += 1;
+    this.circuitBreakerManager.recordFailure(key, options);
+    if (this.circuitBreakerManager.isOpen(key)) {
+      this.metricsCollector.increment("circuitBreakerTrips");
     }
-    this.circuitBreakers.set(key, state);
-    this.emitError("fetch", { key, error: this.formatError(error), failures: state.failures });
-  }
-  resetCircuitBreaker(key) {
-    this.circuitBreakers.delete(key);
+    this.emitError("fetch", { key, error: this.formatError(error) });
   }
   isNegativeStoredValue(stored) {
     return isStoredValueEnvelope(stored) && stored.kind === "empty";
@@ -1178,35 +1625,36 @@ var RedisInvalidationBus = class {
   channel;
   publisher;
   subscriber;
-  activeListener;
+  handlers = /* @__PURE__ */ new Set();
+  sharedListener;
   constructor(options) {
     this.publisher = options.publisher;
     this.subscriber = options.subscriber ?? options.publisher.duplicate();
     this.channel = options.channel ?? "layercache:invalidation";
   }
   async subscribe(handler) {
-    if (this.activeListener) {
-      throw new Error("RedisInvalidationBus already has an active subscription.");
-    }
-    const listener = (_channel, payload) => {
-      void this.handleMessage(payload, handler);
-    };
-    this.activeListener = listener;
-    this.subscriber.on("message", listener);
-    await this.subscriber.subscribe(this.channel);
+    if (this.handlers.size === 0) {
+      const listener = (_channel, payload) => {
+        void this.dispatchToHandlers(payload);
+      };
+      this.sharedListener = listener;
+      this.subscriber.on("message", listener);
+      await this.subscriber.subscribe(this.channel);
+    }
+    this.handlers.add(handler);
     return async () => {
-      if (this.activeListener !== listener) {
-        return;
+      this.handlers.delete(handler);
+      if (this.handlers.size === 0 && this.sharedListener) {
+        this.subscriber.off("message", this.sharedListener);
+        this.sharedListener = void 0;
+        await this.subscriber.unsubscribe(this.channel);
       }
-      this.activeListener = void 0;
-      this.subscriber.off("message", listener);
-      await this.subscriber.unsubscribe(this.channel);
     };
   }
   async publish(message) {
     await this.publisher.publish(this.channel, JSON.stringify(message));
   }
-  async handleMessage(payload, handler) {
+  async dispatchToHandlers(payload) {
     let message;
     try {
       const parsed = JSON.parse(payload);
@@ -1218,11 +1666,15 @@ var RedisInvalidationBus = class {
       this.reportError("invalid invalidation payload", error);
       return;
     }
-    try {
-      await handler(message);
-    } catch (error) {
-      this.reportError("invalidation handler failed", error);
-    }
+    await Promise.all(
+      [...this.handlers].map(async (handler) => {
+        try {
+          await handler(message);
+        } catch (error) {
+          this.reportError("invalidation handler failed", error);
+        }
+      })
+    );
   }
   isInvalidationMessage(value) {
     if (!value || typeof value !== "object") {
@@ -1283,6 +1735,39 @@ function createFastifyLayercachePlugin(cache, options = {}) {
   };
 }
 
+// src/integrations/express.ts
+function createExpressCacheMiddleware(cache, options = {}) {
+  const allowedMethods = new Set((options.methods ?? ["GET"]).map((m) => m.toUpperCase()));
+  return async (req, res, next) => {
+    const method = (req.method ?? "GET").toUpperCase();
+    if (!allowedMethods.has(method)) {
+      next();
+      return;
+    }
+    const key = options.keyResolver ? options.keyResolver(req) : `${method}:${req.originalUrl ?? req.url ?? "/"}`;
+    const cached = await cache.get(key, void 0, options);
+    if (cached !== null) {
+      res.setHeader?.("content-type", "application/json; charset=utf-8");
+      res.setHeader?.("x-cache", "HIT");
+      if (res.json) {
+        res.json(cached);
+      } else {
+        res.end?.(JSON.stringify(cached));
+      }
+      return;
+    }
+    const originalJson = res.json?.bind(res);
+    if (originalJson) {
+      res.json = (body) => {
+        res.setHeader?.("x-cache", "MISS");
+        void cache.set(key, body, options);
+        return originalJson(body);
+      };
+    }
+    next();
+  };
+}
+
 // src/integrations/graphql.ts
 function cacheGraphqlResolver(cache, prefix, resolver, options = {}) {
   const wrapped = cache.wrap(prefix, resolver, {
@@ -1323,11 +1808,13 @@ var MemoryLayer = class {
   defaultTtl;
   isLocal = true;
   maxSize;
+  evictionPolicy;
   entries = /* @__PURE__ */ new Map();
   constructor(options = {}) {
     this.name = options.name ?? "memory";
     this.defaultTtl = options.ttl;
     this.maxSize = options.maxSize ?? 1e3;
+    this.evictionPolicy = options.evictionPolicy ?? "lru";
   }
   async get(key) {
     const value = await this.getEntry(key);
@@ -1342,8 +1829,13 @@ var MemoryLayer = class {
       this.entries.delete(key);
       return null;
     }
-    this.entries.delete(key);
-    this.entries.set(key, entry);
+    if (this.evictionPolicy === "lru") {
+      this.entries.delete(key);
+      entry.accessCount += 1;
+      this.entries.set(key, entry);
+    } else if (this.evictionPolicy === "lfu") {
+      entry.accessCount += 1;
+    }
     return entry.value;
   }
   async getMany(keys) {
@@ -1357,15 +1849,42 @@ var MemoryLayer = class {
     this.entries.delete(key);
     this.entries.set(key, {
       value,
-      expiresAt: ttl && ttl > 0 ? Date.now() + ttl * 1e3 : null
+      expiresAt: ttl && ttl > 0 ? Date.now() + ttl * 1e3 : null,
+      accessCount: 0,
+      insertedAt: Date.now()
     });
     while (this.entries.size > this.maxSize) {
-      const oldestKey = this.entries.keys().next().value;
-      if (!oldestKey) {
-        break;
-      }
-      this.entries.delete(oldestKey);
+      this.evict();
+    }
+  }
+  async has(key) {
+    const entry = this.entries.get(key);
+    if (!entry) {
+      return false;
+    }
+    if (this.isExpired(entry)) {
+      this.entries.delete(key);
+      return false;
+    }
+    return true;
+  }
+  async ttl(key) {
+    const entry = this.entries.get(key);
+    if (!entry) {
+      return null;
     }
+    if (this.isExpired(entry)) {
+      this.entries.delete(key);
+      return null;
+    }
+    if (entry.expiresAt === null) {
+      return null;
+    }
+    return Math.max(0, Math.ceil((entry.expiresAt - Date.now()) / 1e3));
+  }
+  async size() {
+    this.pruneExpired();
+    return this.entries.size;
   }
   async delete(key) {
     this.entries.delete(key);
@@ -1397,15 +1916,35 @@ var MemoryLayer = class {
       }
       this.entries.set(entry.key, {
         value: entry.value,
-        expiresAt: entry.expiresAt
+        expiresAt: entry.expiresAt,
+        accessCount: 0,
+        insertedAt: Date.now()
       });
     }
     while (this.entries.size > this.maxSize) {
+      this.evict();
+    }
+  }
+  evict() {
+    if (this.evictionPolicy === "lru" || this.evictionPolicy === "fifo") {
       const oldestKey = this.entries.keys().next().value;
-      if (!oldestKey) {
-        break;
+      if (oldestKey !== void 0) {
+        this.entries.delete(oldestKey);
+      }
+      return;
+    }
+    let victimKey;
+    let minCount = Number.POSITIVE_INFINITY;
+    let minInsertedAt = Number.POSITIVE_INFINITY;
+    for (const [key, entry] of this.entries.entries()) {
+      if (entry.accessCount < minCount || entry.accessCount === minCount && entry.insertedAt < minInsertedAt) {
+        minCount = entry.accessCount;
+        minInsertedAt = entry.insertedAt;
+        victimKey = key;
       }
-      this.entries.delete(oldestKey);
+    }
+    if (victimKey !== void 0) {
+      this.entries.delete(victimKey);
     }
   }
   pruneExpired() {
@@ -1421,7 +1960,8 @@ var MemoryLayer = class {
 };
 
 // src/layers/RedisLayer.ts
-import { brotliCompressSync, brotliDecompressSync, gzipSync, gunzipSync } from "zlib";
+import { promisify } from "util";
+import { brotliCompress, brotliDecompress, gunzip, gzip } from "zlib";
 
 // src/serialization/JsonSerializer.ts
 var JsonSerializer = class {
@@ -1435,6 +1975,11 @@ var JsonSerializer = class {
 };
 
 // src/layers/RedisLayer.ts
+var BATCH_DELETE_SIZE = 500;
+var gzipAsync = promisify(gzip);
+var gunzipAsync = promisify(gunzip);
+var brotliCompressAsync = promisify(brotliCompress);
+var brotliDecompressAsync = promisify(brotliDecompress);
 var RedisLayer = class {
   name;
   defaultTtl;
@@ -1486,12 +2031,13 @@ var RedisLayer = class {
         if (error || payload === null || !this.isSerializablePayload(payload)) {
           return null;
         }
-        return this.deserializeOrDelete(keys[index], payload);
+        return this.deserializeOrDelete(keys[index] ?? "", payload);
       })
     );
   }
   async set(key, value, ttl = this.defaultTtl) {
-    const payload = this.encodePayload(this.serializer.serialize(value));
+    const serialized = this.serializer.serialize(value);
+    const payload = await this.encodePayload(serialized);
     const normalizedKey = this.withPrefix(key);
     if (ttl && ttl > 0) {
       await this.client.set(normalizedKey, payload, "EX", ttl);
@@ -1508,14 +2054,44 @@ var RedisLayer = class {
     }
     await this.client.del(...keys.map((key) => this.withPrefix(key)));
   }
-  async clear() {
-    if (!this.prefix && !this.allowUnprefixedClear) {
-      throw new Error("RedisLayer.clear() requires a prefix or allowUnprefixedClear=true to avoid deleting unrelated keys.");
+  async has(key) {
+    const exists = await this.client.exists(this.withPrefix(key));
+    return exists > 0;
+  }
+  async ttl(key) {
+    const remaining = await this.client.ttl(this.withPrefix(key));
+    if (remaining < 0) {
+      return null;
     }
+    return remaining;
+  }
+  async size() {
     const keys = await this.keys();
-    if (keys.length > 0) {
-      await this.deleteMany(keys);
+    return keys.length;
+  }
+  /**
+   * Deletes all keys matching the layer's prefix in batches to avoid
+   * loading millions of keys into memory at once.
+   */
+  async clear() {
+    if (!this.prefix && !this.allowUnprefixedClear) {
+      throw new Error(
+        "RedisLayer.clear() requires a prefix or allowUnprefixedClear=true to avoid deleting unrelated keys."
+      );
     }
+    const pattern = `${this.prefix}*`;
+    let cursor = "0";
+    do {
+      const [nextCursor, keys] = await this.client.scan(cursor, "MATCH", pattern, "COUNT", this.scanCount);
+      cursor = nextCursor;
+      if (keys.length === 0) {
+        continue;
+      }
+      for (let i = 0; i < keys.length; i += BATCH_DELETE_SIZE) {
+        const batch = keys.slice(i, i + BATCH_DELETE_SIZE);
+        await this.client.del(...batch);
+      }
+    } while (cursor !== "0");
   }
   async keys() {
     const pattern = `${this.prefix}*`;
@@ -1540,7 +2116,7 @@ var RedisLayer = class {
   }
   async deserializeOrDelete(key, payload) {
     try {
-      return this.serializer.deserialize(this.decodePayload(payload));
+      return this.serializer.deserialize(await this.decodePayload(payload));
     } catch {
       await this.client.del(this.withPrefix(key)).catch(() => void 0);
       return null;
@@ -1549,7 +2125,11 @@ var RedisLayer = class {
   isSerializablePayload(payload) {
     return typeof payload === "string" || Buffer.isBuffer(payload);
   }
-  encodePayload(payload) {
+  /**
+   * Compresses the payload asynchronously if compression is enabled and the
+   * payload exceeds the threshold. This avoids blocking the event loop.
+   */
+  async encodePayload(payload) {
     if (!this.compression) {
       return payload;
     }
@@ -1558,23 +2138,269 @@ var RedisLayer = class {
       return payload;
     }
     const header = Buffer.from(`LCZ1:${this.compression}:`);
-    const compressed = this.compression === "gzip" ? gzipSync(source) : brotliCompressSync(source);
+    const compressed = this.compression === "gzip" ? await gzipAsync(source) : await brotliCompressAsync(source);
     return Buffer.concat([header, compressed]);
   }
-  decodePayload(payload) {
+  /**
+   * Decompresses the payload asynchronously if a compression header is present.
+   */
+  async decodePayload(payload) {
     if (!Buffer.isBuffer(payload)) {
       return payload;
     }
     if (payload.subarray(0, 10).toString() === "LCZ1:gzip:") {
-      return gunzipSync(payload.subarray(10));
+      return gunzipAsync(payload.subarray(10));
     }
     if (payload.subarray(0, 12).toString() === "LCZ1:brotli:") {
-      return brotliDecompressSync(payload.subarray(12));
+      return brotliDecompressAsync(payload.subarray(12));
     }
     return payload;
   }
 };
 
+// src/layers/DiskLayer.ts
+import { createHash } from "crypto";
+import { promises as fs2 } from "fs";
+import { join } from "path";
+var DiskLayer = class {
+  name;
+  defaultTtl;
+  isLocal = true;
+  directory;
+  serializer;
+  maxFiles;
+  constructor(options) {
+    this.directory = options.directory;
+    this.defaultTtl = options.ttl;
+    this.name = options.name ?? "disk";
+    this.serializer = options.serializer ?? new JsonSerializer();
+    this.maxFiles = options.maxFiles;
+  }
+  async get(key) {
+    return unwrapStoredValue(await this.getEntry(key));
+  }
+  async getEntry(key) {
+    const filePath = this.keyToPath(key);
+    let raw;
+    try {
+      raw = await fs2.readFile(filePath);
+    } catch {
+      return null;
+    }
+    let entry;
+    try {
+      entry = this.serializer.deserialize(raw);
+    } catch {
+      await this.safeDelete(filePath);
+      return null;
+    }
+    if (entry.expiresAt !== null && entry.expiresAt <= Date.now()) {
+      await this.safeDelete(filePath);
+      return null;
+    }
+    return entry.value;
+  }
+  async set(key, value, ttl = this.defaultTtl) {
+    await fs2.mkdir(this.directory, { recursive: true });
+    const entry = {
+      key,
+      value,
+      expiresAt: ttl && ttl > 0 ? Date.now() + ttl * 1e3 : null
+    };
+    const payload = this.serializer.serialize(entry);
+    await fs2.writeFile(this.keyToPath(key), payload);
+    if (this.maxFiles !== void 0) {
+      await this.enforceMaxFiles();
+    }
+  }
+  async has(key) {
+    const value = await this.getEntry(key);
+    return value !== null;
+  }
+  async ttl(key) {
+    const filePath = this.keyToPath(key);
+    let raw;
+    try {
+      raw = await fs2.readFile(filePath);
+    } catch {
+      return null;
+    }
+    let entry;
+    try {
+      entry = this.serializer.deserialize(raw);
+    } catch {
+      return null;
+    }
+    if (entry.expiresAt === null) {
+      return null;
+    }
+    const remaining = Math.ceil((entry.expiresAt - Date.now()) / 1e3);
+    if (remaining <= 0) {
+      return null;
+    }
+    return remaining;
+  }
+  async delete(key) {
+    await this.safeDelete(this.keyToPath(key));
+  }
+  async deleteMany(keys) {
+    await Promise.all(keys.map((key) => this.delete(key)));
+  }
+  async clear() {
+    let entries;
+    try {
+      entries = await fs2.readdir(this.directory);
+    } catch {
+      return;
+    }
+    await Promise.all(
+      entries.filter((name) => name.endsWith(".lc")).map((name) => this.safeDelete(join(this.directory, name)))
+    );
+  }
+  /**
+   * Returns the original cache key strings stored on disk.
+   * Expired entries are skipped and cleaned up during the scan.
+   */
+  async keys() {
+    let entries;
+    try {
+      entries = await fs2.readdir(this.directory);
+    } catch {
+      return [];
+    }
+    const lcFiles = entries.filter((name) => name.endsWith(".lc"));
+    const keys = [];
+    await Promise.all(
+      lcFiles.map(async (name) => {
+        const filePath = join(this.directory, name);
+        let raw;
+        try {
+          raw = await fs2.readFile(filePath);
+        } catch {
+          return;
+        }
+        let entry;
+        try {
+          entry = this.serializer.deserialize(raw);
+        } catch {
+          await this.safeDelete(filePath);
+          return;
+        }
+        if (entry.expiresAt !== null && entry.expiresAt <= Date.now()) {
+          await this.safeDelete(filePath);
+          return;
+        }
+        keys.push(entry.key);
+      })
+    );
+    return keys;
+  }
+  async size() {
+    const keys = await this.keys();
+    return keys.length;
+  }
+  keyToPath(key) {
+    const hash = createHash("sha256").update(key).digest("hex");
+    return join(this.directory, `${hash}.lc`);
+  }
+  async safeDelete(filePath) {
+    try {
+      await fs2.unlink(filePath);
+    } catch {
+    }
+  }
+  /**
+   * Removes the oldest files (by mtime) when the directory exceeds maxFiles.
+   */
+  async enforceMaxFiles() {
+    if (this.maxFiles === void 0) {
+      return;
+    }
+    let entries;
+    try {
+      entries = await fs2.readdir(this.directory);
+    } catch {
+      return;
+    }
+    const lcFiles = entries.filter((name) => name.endsWith(".lc"));
+    if (lcFiles.length <= this.maxFiles) {
+      return;
+    }
+    const withStats = await Promise.all(
+      lcFiles.map(async (name) => {
+        const filePath = join(this.directory, name);
+        try {
+          const stat = await fs2.stat(filePath);
+          return { filePath, mtimeMs: stat.mtimeMs };
+        } catch {
+          return { filePath, mtimeMs: 0 };
+        }
+      })
+    );
+    withStats.sort((a, b) => a.mtimeMs - b.mtimeMs);
+    const toEvict = withStats.slice(0, lcFiles.length - this.maxFiles);
+    await Promise.all(toEvict.map(({ filePath }) => this.safeDelete(filePath)));
+  }
+};
+
+// src/layers/MemcachedLayer.ts
+var MemcachedLayer = class {
+  name;
+  defaultTtl;
+  isLocal = false;
+  client;
+  keyPrefix;
+  serializer;
+  constructor(options) {
+    this.client = options.client;
+    this.defaultTtl = options.ttl;
+    this.name = options.name ?? "memcached";
+    this.keyPrefix = options.keyPrefix ?? "";
+    this.serializer = options.serializer ?? new JsonSerializer();
+  }
+  async get(key) {
+    return unwrapStoredValue(await this.getEntry(key));
+  }
+  async getEntry(key) {
+    const result = await this.client.get(this.withPrefix(key));
+    if (!result || result.value === null) {
+      return null;
+    }
+    try {
+      return this.serializer.deserialize(result.value);
+    } catch {
+      return null;
+    }
+  }
+  async getMany(keys) {
+    return Promise.all(keys.map((key) => this.getEntry(key)));
+  }
+  async set(key, value, ttl = this.defaultTtl) {
+    const payload = this.serializer.serialize(value);
+    await this.client.set(this.withPrefix(key), payload, {
+      expires: ttl && ttl > 0 ? ttl : void 0
+    });
+  }
+  async has(key) {
+    const result = await this.client.get(this.withPrefix(key));
+    return result !== null && result.value !== null;
+  }
+  async delete(key) {
+    await this.client.delete(this.withPrefix(key));
+  }
+  async deleteMany(keys) {
+    await Promise.all(keys.map((key) => this.delete(key)));
+  }
+  async clear() {
+    throw new Error(
+      "MemcachedLayer.clear() is not supported. Use a key prefix and rotate it to effectively invalidate all keys."
+    );
+  }
+  withPrefix(key) {
+    return `${this.keyPrefix}${key}`;
+  }
+};
+
 // src/serialization/MsgpackSerializer.ts
 import { decode, encode } from "@msgpack/msgpack";
 var MsgpackSerializer = class {
@@ -1616,10 +2442,92 @@ var RedisSingleFlightCoordinator = class {
     return waiter();
   }
 };
+
+// src/metrics/PrometheusExporter.ts
+function createPrometheusMetricsExporter(stacks) {
+  return () => {
+    const entries = Array.isArray(stacks) ? stacks : [{ stack: stacks, name: "default" }];
+    const lines = [];
+    lines.push("# HELP layercache_hits_total Total number of cache hits");
+    lines.push("# TYPE layercache_hits_total counter");
+    lines.push("# HELP layercache_misses_total Total number of cache misses");
+    lines.push("# TYPE layercache_misses_total counter");
+    lines.push("# HELP layercache_fetches_total Total fetcher invocations (full misses)");
+    lines.push("# TYPE layercache_fetches_total counter");
+    lines.push("# HELP layercache_sets_total Total number of cache sets");
+    lines.push("# TYPE layercache_sets_total counter");
+    lines.push("# HELP layercache_deletes_total Total number of cache deletes");
+    lines.push("# TYPE layercache_deletes_total counter");
+    lines.push("# HELP layercache_backfills_total Total number of backfill operations");
+    lines.push("# TYPE layercache_backfills_total counter");
+    lines.push("# HELP layercache_stale_hits_total Total number of stale hits served");
+    lines.push("# TYPE layercache_stale_hits_total counter");
+    lines.push("# HELP layercache_refreshes_total Background refreshes triggered");
+    lines.push("# TYPE layercache_refreshes_total counter");
+    lines.push("# HELP layercache_refresh_errors_total Background refresh errors");
+    lines.push("# TYPE layercache_refresh_errors_total counter");
+    lines.push("# HELP layercache_negative_cache_hits_total Negative cache hits");
+    lines.push("# TYPE layercache_negative_cache_hits_total counter");
+    lines.push("# HELP layercache_circuit_breaker_trips_total Circuit breaker trips");
+    lines.push("# TYPE layercache_circuit_breaker_trips_total counter");
+    lines.push("# HELP layercache_degraded_operations_total Operations run in degraded mode");
+    lines.push("# TYPE layercache_degraded_operations_total counter");
+    lines.push("# HELP layercache_hit_rate Overall cache hit rate (0-1)");
+    lines.push("# TYPE layercache_hit_rate gauge");
+    lines.push("# HELP layercache_hits_by_layer_total Hits broken down by layer");
+    lines.push("# TYPE layercache_hits_by_layer_total counter");
+    lines.push("# HELP layercache_misses_by_layer_total Misses broken down by layer");
+    lines.push("# TYPE layercache_misses_by_layer_total counter");
+    lines.push("# HELP layercache_layer_latency_avg_ms Average read latency per layer in milliseconds");
+    lines.push("# TYPE layercache_layer_latency_avg_ms gauge");
+    lines.push("# HELP layercache_layer_latency_max_ms Maximum read latency per layer in milliseconds");
+    lines.push("# TYPE layercache_layer_latency_max_ms gauge");
+    lines.push("# HELP layercache_layer_latency_count Number of read latency samples per layer");
+    lines.push("# TYPE layercache_layer_latency_count counter");
+    for (const { stack, name } of entries) {
+      const m = stack.getMetrics();
+      const hr = stack.getHitRate();
+      const label = `cache="${sanitizeLabel(name)}"`;
+      lines.push(`layercache_hits_total{${label}} ${m.hits}`);
+      lines.push(`layercache_misses_total{${label}} ${m.misses}`);
+      lines.push(`layercache_fetches_total{${label}} ${m.fetches}`);
+      lines.push(`layercache_sets_total{${label}} ${m.sets}`);
+      lines.push(`layercache_deletes_total{${label}} ${m.deletes}`);
+      lines.push(`layercache_backfills_total{${label}} ${m.backfills}`);
+      lines.push(`layercache_stale_hits_total{${label}} ${m.staleHits}`);
+      lines.push(`layercache_refreshes_total{${label}} ${m.refreshes}`);
+      lines.push(`layercache_refresh_errors_total{${label}} ${m.refreshErrors}`);
+      lines.push(`layercache_negative_cache_hits_total{${label}} ${m.negativeCacheHits}`);
+      lines.push(`layercache_circuit_breaker_trips_total{${label}} ${m.circuitBreakerTrips}`);
+      lines.push(`layercache_degraded_operations_total{${label}} ${m.degradedOperations}`);
+      lines.push(`layercache_hit_rate{${label}} ${hr.overall.toFixed(6)}`);
+      for (const [layerName, count] of Object.entries(m.hitsByLayer)) {
+        lines.push(`layercache_hits_by_layer_total{${label},layer="${sanitizeLabel(layerName)}"} ${count}`);
+      }
+      for (const [layerName, count] of Object.entries(m.missesByLayer)) {
+        lines.push(`layercache_misses_by_layer_total{${label},layer="${sanitizeLabel(layerName)}"} ${count}`);
+      }
+      for (const [layerName, latency] of Object.entries(m.latencyByLayer)) {
+        const layerLabel = `${label},layer="${sanitizeLabel(layerName)}"`;
+        lines.push(`layercache_layer_latency_avg_ms{${layerLabel}} ${latency.avgMs.toFixed(4)}`);
+        lines.push(`layercache_layer_latency_max_ms{${layerLabel}} ${latency.maxMs.toFixed(4)}`);
+        lines.push(`layercache_layer_latency_count{${layerLabel}} ${latency.count}`);
+      }
+    }
+    lines.push("");
+    return lines.join("\n");
+  };
+}
+function sanitizeLabel(value) {
+  return value.replace(/["\\\n]/g, "_");
+}
 export {
+  CacheMissError,
   CacheNamespace,
   CacheStack,
+  DiskLayer,
   JsonSerializer,
+  MemcachedLayer,
   MemoryLayer,
   MsgpackSerializer,
   PatternMatcher,
@@ -1632,6 +2540,8 @@ export {
   cacheGraphqlResolver,
   createCacheStatsHandler,
   createCachedMethodDecorator,
+  createExpressCacheMiddleware,
   createFastifyLayercachePlugin,
+  createPrometheusMetricsExporter,
   createTrpcCacheMiddleware
 };