layercache 1.1.0 → 1.2.0

package/dist/index.js

@@ -1,7 +1,7 @@
 import {
   PatternMatcher,
   RedisTagIndex
-} from "./chunk-QUB5VZFZ.js";
+} from "./chunk-BWM4MU2X.js";
 
 // src/CacheStack.ts
 import { randomUUID } from "crypto";
@@ -9,7 +9,7 @@ import { EventEmitter } from "events";
 import { promises as fs } from "fs";
 
 // src/CacheNamespace.ts
-var CacheNamespace = class {
+var CacheNamespace = class _CacheNamespace {
   constructor(cache, prefix) {
     this.cache = cache;
     this.prefix = prefix;
@@ -22,6 +22,12 @@ var CacheNamespace = class {
   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));
   }
@@ -62,6 +68,12 @@ var CacheNamespace = class {
   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);
   }
@@ -80,6 +92,18 @@ var CacheNamespace = class {
   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}`;
   }
@@ -181,7 +205,12 @@ var CircuitBreakerManager = class {
 var MetricsCollector = class {
   data = this.empty();
   get snapshot() {
-    return { ...this.data };
+    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) {
     ;
@@ -190,6 +219,22 @@ var MetricsCollector = class {
   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();
   }
@@ -224,6 +269,7 @@ var MetricsCollector = class {
       degradedOperations: 0,
       hitsByLayer: {},
       missesByLayer: {},
+      latencyByLayer: {},
       resetAt: Date.now()
     };
   }
@@ -423,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;
     }
@@ -466,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));
   }
@@ -474,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
@@ -502,6 +572,16 @@ 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_SINGLE_FLIGHT_LEASE_MS = 3e4;
 var DEFAULT_SINGLE_FLIGHT_TIMEOUT_MS = 5e3;
@@ -628,6 +708,18 @@ var CacheStack = class extends EventEmitter {
   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.
    */
@@ -901,6 +993,46 @@ var CacheStack = class extends EventEmitter {
   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;
     const exported = /* @__PURE__ */ new Map();
@@ -1037,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;
   }
@@ -1059,7 +1194,10 @@ var CacheStack = class extends EventEmitter {
     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.metricsCollector.incrementLayer("missesByLayer", layer.name);
         continue;
@@ -1261,6 +1399,12 @@ var CacheStack = class extends EventEmitter {
       }
     }
   }
+  async getTagsForKey(key) {
+    if (this.tagIndex.tagsForKey) {
+      return this.tagIndex.tagsForKey(key);
+    }
+    return [];
+  }
   formatError(error) {
     if (error instanceof Error) {
       return error.message;
@@ -1481,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.");
+    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);
     }
-    const listener = (_channel, payload) => {
-      void this.handleMessage(payload, handler);
-    };
-    this.activeListener = 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);
@@ -1521,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") {
@@ -1586,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, {
@@ -1649,10 +1831,10 @@ var MemoryLayer = class {
     }
     if (this.evictionPolicy === "lru") {
       this.entries.delete(key);
-      entry.frequency += 1;
+      entry.accessCount += 1;
       this.entries.set(key, entry);
-    } else {
-      entry.frequency += 1;
+    } else if (this.evictionPolicy === "lfu") {
+      entry.accessCount += 1;
     }
     return entry.value;
   }
@@ -1668,7 +1850,7 @@ var MemoryLayer = class {
     this.entries.set(key, {
       value,
       expiresAt: ttl && ttl > 0 ? Date.now() + ttl * 1e3 : null,
-      frequency: 0,
+      accessCount: 0,
       insertedAt: Date.now()
     });
     while (this.entries.size > this.maxSize) {
@@ -1735,7 +1917,7 @@ var MemoryLayer = class {
       this.entries.set(entry.key, {
         value: entry.value,
         expiresAt: entry.expiresAt,
-        frequency: 0,
+        accessCount: 0,
         insertedAt: Date.now()
       });
     }
@@ -1752,11 +1934,11 @@ var MemoryLayer = class {
       return;
     }
     let victimKey;
-    let minFreq = Number.POSITIVE_INFINITY;
+    let minCount = Number.POSITIVE_INFINITY;
     let minInsertedAt = Number.POSITIVE_INFINITY;
     for (const [key, entry] of this.entries.entries()) {
-      if (entry.frequency < minFreq || entry.frequency === minFreq && entry.insertedAt < minInsertedAt) {
-        minFreq = entry.frequency;
+      if (entry.accessCount < minCount || entry.accessCount === minCount && entry.insertedAt < minInsertedAt) {
+        minCount = entry.accessCount;
         minInsertedAt = entry.insertedAt;
         victimKey = key;
       }
@@ -1778,7 +1960,8 @@ var MemoryLayer = class {
 };
 
 // src/layers/RedisLayer.ts
-import { brotliCompressSync, brotliDecompressSync, gunzipSync, gzipSync } from "zlib";
+import { promisify } from "util";
+import { brotliCompress, brotliDecompress, gunzip, gzip } from "zlib";
 
 // src/serialization/JsonSerializer.ts
 var JsonSerializer = class {
@@ -1793,6 +1976,10 @@ 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;
@@ -1849,7 +2036,8 @@ var RedisLayer = class {
     );
   }
   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);
@@ -1928,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;
@@ -1937,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;
     }
@@ -1946,18 +2138,21 @@ 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;
   }
@@ -1973,11 +2168,13 @@ var DiskLayer = class {
   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));
@@ -2006,11 +2203,15 @@ var DiskLayer = class {
   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);
@@ -2056,6 +2257,10 @@ var DiskLayer = class {
       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 {
@@ -2063,7 +2268,32 @@ var DiskLayer = class {
     } catch {
       return [];
     }
-    return entries.filter((name) => name.endsWith(".lc")).map((name) => name.slice(0, -3));
+    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();
@@ -2079,6 +2309,38 @@ var DiskLayer = class {
     } 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
@@ -2088,29 +2350,41 @@ var MemcachedLayer = class {
   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 JSON.parse(result.value.toString("utf8"));
+      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 = JSON.stringify(value);
+    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));
   }
@@ -2204,6 +2478,12 @@ function createPrometheusMetricsExporter(stacks) {
     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();
@@ -2227,6 +2507,12 @@ function createPrometheusMetricsExporter(stacks) {
       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");
@@ -2236,6 +2522,7 @@ function sanitizeLabel(value) {
   return value.replace(/["\\\n]/g, "_");
 }
 export {
+  CacheMissError,
   CacheNamespace,
   CacheStack,
   DiskLayer,
@@ -2253,6 +2540,7 @@ export {
   cacheGraphqlResolver,
   createCacheStatsHandler,
   createCachedMethodDecorator,
+  createExpressCacheMiddleware,
   createFastifyLayercachePlugin,
   createPrometheusMetricsExporter,
   createTrpcCacheMiddleware