layercache 1.2.5 → 1.2.7

package/dist/index.cjs

@@ -62,26 +62,148 @@ var import_node_events = require("events");
 
 // src/CacheNamespace.ts
 var import_async_mutex = require("async-mutex");
+
+// src/internal/CacheNamespaceMetrics.ts
+function createEmptyNamespaceMetrics(resetAt = Date.now()) {
+  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
+  };
+}
+function cloneNamespaceMetrics(metrics) {
+  return {
+    ...metrics,
+    hitsByLayer: { ...metrics.hitsByLayer },
+    missesByLayer: { ...metrics.missesByLayer },
+    latencyByLayer: Object.fromEntries(
+      Object.entries(metrics.latencyByLayer).map(([key, value]) => [key, { ...value }])
+    )
+  };
+}
+function diffNamespaceMetrics(before, after) {
+  const latencyByLayer = Object.fromEntries(
+    Object.entries(after.latencyByLayer).map(([layer, value]) => [
+      layer,
+      {
+        avgMs: value.avgMs,
+        maxMs: value.maxMs,
+        count: Math.max(0, value.count - (before.latencyByLayer[layer]?.count ?? 0))
+      }
+    ])
+  );
+  return {
+    hits: after.hits - before.hits,
+    misses: after.misses - before.misses,
+    fetches: after.fetches - before.fetches,
+    sets: after.sets - before.sets,
+    deletes: after.deletes - before.deletes,
+    backfills: after.backfills - before.backfills,
+    invalidations: after.invalidations - before.invalidations,
+    staleHits: after.staleHits - before.staleHits,
+    refreshes: after.refreshes - before.refreshes,
+    refreshErrors: after.refreshErrors - before.refreshErrors,
+    writeFailures: after.writeFailures - before.writeFailures,
+    singleFlightWaits: after.singleFlightWaits - before.singleFlightWaits,
+    negativeCacheHits: after.negativeCacheHits - before.negativeCacheHits,
+    circuitBreakerTrips: after.circuitBreakerTrips - before.circuitBreakerTrips,
+    degradedOperations: after.degradedOperations - before.degradedOperations,
+    hitsByLayer: diffMetricMap(before.hitsByLayer, after.hitsByLayer),
+    missesByLayer: diffMetricMap(before.missesByLayer, after.missesByLayer),
+    latencyByLayer,
+    resetAt: after.resetAt
+  };
+}
+function addNamespaceMetrics(base, delta) {
+  return {
+    hits: base.hits + delta.hits,
+    misses: base.misses + delta.misses,
+    fetches: base.fetches + delta.fetches,
+    sets: base.sets + delta.sets,
+    deletes: base.deletes + delta.deletes,
+    backfills: base.backfills + delta.backfills,
+    invalidations: base.invalidations + delta.invalidations,
+    staleHits: base.staleHits + delta.staleHits,
+    refreshes: base.refreshes + delta.refreshes,
+    refreshErrors: base.refreshErrors + delta.refreshErrors,
+    writeFailures: base.writeFailures + delta.writeFailures,
+    singleFlightWaits: base.singleFlightWaits + delta.singleFlightWaits,
+    negativeCacheHits: base.negativeCacheHits + delta.negativeCacheHits,
+    circuitBreakerTrips: base.circuitBreakerTrips + delta.circuitBreakerTrips,
+    degradedOperations: base.degradedOperations + delta.degradedOperations,
+    hitsByLayer: addMetricMap(base.hitsByLayer, delta.hitsByLayer),
+    missesByLayer: addMetricMap(base.missesByLayer, delta.missesByLayer),
+    latencyByLayer: cloneNamespaceMetrics(delta).latencyByLayer,
+    resetAt: base.resetAt
+  };
+}
+function computeNamespaceHitRate(metrics) {
+  const total = metrics.hits + metrics.misses;
+  const overall = total === 0 ? 0 : metrics.hits / total;
+  const byLayer = {};
+  const layers = /* @__PURE__ */ new Set([...Object.keys(metrics.hitsByLayer), ...Object.keys(metrics.missesByLayer)]);
+  for (const layer of layers) {
+    const hits = metrics.hitsByLayer[layer] ?? 0;
+    const misses = metrics.missesByLayer[layer] ?? 0;
+    byLayer[layer] = hits + misses === 0 ? 0 : hits / (hits + misses);
+  }
+  return { overall, byLayer };
+}
+function diffMetricMap(before, after) {
+  const keys = /* @__PURE__ */ new Set([...Object.keys(before), ...Object.keys(after)]);
+  const result = {};
+  for (const key of keys) {
+    result[key] = (after[key] ?? 0) - (before[key] ?? 0);
+  }
+  return result;
+}
+function addMetricMap(base, delta) {
+  const keys = /* @__PURE__ */ new Set([...Object.keys(base), ...Object.keys(delta)]);
+  const result = {};
+  for (const key of keys) {
+    result[key] = (base[key] ?? 0) + (delta[key] ?? 0);
+  }
+  return result;
+}
+
+// src/CacheNamespace.ts
 var CacheNamespace = class _CacheNamespace {
   constructor(cache, prefix) {
     this.cache = cache;
     this.prefix = prefix;
+    validateNamespaceKey(prefix);
   }
   cache;
   prefix;
   static metricsMutexes = /* @__PURE__ */ new WeakMap();
-  metrics = emptyMetrics();
+  metrics = createEmptyNamespaceMetrics();
   async get(key, fetcher, options) {
-    return this.trackMetrics(() => this.cache.get(this.qualify(key), fetcher, options));
+    return this.trackMetrics(() => this.cache.get(this.qualify(key), fetcher, this.qualifyGetOptions(options)));
   }
   async getOrSet(key, fetcher, options) {
-    return this.trackMetrics(() => this.cache.getOrSet(this.qualify(key), fetcher, options));
+    return this.trackMetrics(() => this.cache.getOrSet(this.qualify(key), fetcher, this.qualifyGetOptions(options)));
   }
   /**
    * Like `get()`, but throws `CacheMissError` instead of returning `null`.
    */
   async getOrThrow(key, fetcher, options) {
-    return this.trackMetrics(() => this.cache.getOrThrow(this.qualify(key), fetcher, options));
+    return this.trackMetrics(() => this.cache.getOrThrow(this.qualify(key), fetcher, this.qualifyGetOptions(options)));
   }
   async has(key) {
     return this.trackMetrics(() => this.cache.has(this.qualify(key)));
@@ -90,7 +212,7 @@ var CacheNamespace = class _CacheNamespace {
     return this.trackMetrics(() => this.cache.ttl(this.qualify(key)));
   }
   async set(key, value, options) {
-    await this.trackMetrics(() => this.cache.set(this.qualify(key), value, options));
+    await this.trackMetrics(() => this.cache.set(this.qualify(key), value, this.qualifyWriteOptions(options)));
   }
   async delete(key) {
     await this.trackMetrics(() => this.cache.delete(this.qualify(key)));
@@ -106,7 +228,8 @@ var CacheNamespace = class _CacheNamespace {
       () => this.cache.mget(
         entries.map((entry) => ({
           ...entry,
-          key: this.qualify(entry.key)
+          key: this.qualify(entry.key),
+          options: this.qualifyGetOptions(entry.options)
         }))
       )
     );
@@ -116,16 +239,22 @@ var CacheNamespace = class _CacheNamespace {
       () => this.cache.mset(
         entries.map((entry) => ({
           ...entry,
-          key: this.qualify(entry.key)
+          key: this.qualify(entry.key),
+          options: this.qualifyWriteOptions(entry.options)
         }))
       )
     );
   }
   async invalidateByTag(tag) {
-    await this.trackMetrics(() => this.cache.invalidateByTag(tag));
+    await this.trackMetrics(() => this.cache.invalidateByTag(this.qualifyTag(tag)));
   }
   async invalidateByTags(tags, mode = "any") {
-    await this.trackMetrics(() => this.cache.invalidateByTags(tags, mode));
+    await this.trackMetrics(
+      () => this.cache.invalidateByTags(
+        tags.map((tag) => this.qualifyTag(tag)),
+        mode
+      )
+    );
   }
   async invalidateByPattern(pattern) {
     await this.trackMetrics(() => this.cache.invalidateByPattern(this.qualify(pattern)));
@@ -137,34 +266,33 @@ var CacheNamespace = class _CacheNamespace {
    * Returns detailed metadata about a single cache key within this namespace.
    */
   async inspect(key) {
-    return this.cache.inspect(this.qualify(key));
+    const result = await this.cache.inspect(this.qualify(key));
+    if (result === null) {
+      return null;
+    }
+    return {
+      ...result,
+      tags: result.tags.filter((tag) => tag.startsWith(`${this.prefix}:`)).map((tag) => tag.slice(this.prefix.length + 1))
+    };
   }
   wrap(keyPrefix, fetcher, options) {
-    return this.cache.wrap(`${this.prefix}:${keyPrefix}`, fetcher, options);
+    return this.cache.wrap(`${this.prefix}:${keyPrefix}`, fetcher, this.qualifyWrapOptions(options));
   }
   warm(entries, options) {
     return this.cache.warm(
       entries.map((entry) => ({
         ...entry,
-        key: this.qualify(entry.key)
+        key: this.qualify(entry.key),
+        options: this.qualifyGetOptions(entry.options)
       })),
       options
     );
   }
   getMetrics() {
-    return cloneMetrics(this.metrics);
+    return cloneNamespaceMetrics(this.metrics);
   }
   getHitRate() {
-    const total = this.metrics.hits + this.metrics.misses;
-    const overall = total === 0 ? 0 : this.metrics.hits / total;
-    const byLayer = {};
-    const layers = /* @__PURE__ */ new Set([...Object.keys(this.metrics.hitsByLayer), ...Object.keys(this.metrics.missesByLayer)]);
-    for (const layer of layers) {
-      const hits = this.metrics.hitsByLayer[layer] ?? 0;
-      const misses = this.metrics.missesByLayer[layer] ?? 0;
-      byLayer[layer] = hits + misses === 0 ? 0 : hits / (hits + misses);
-    }
-    return { overall, byLayer };
+    return computeNamespaceHitRate(this.metrics);
   }
   /**
    * Creates a nested namespace. Keys are prefixed with `parentPrefix:childPrefix:`.
@@ -182,12 +310,30 @@ var CacheNamespace = class _CacheNamespace {
   qualify(key) {
     return `${this.prefix}:${key}`;
   }
+  qualifyTag(tag) {
+    return `${this.prefix}:${tag}`;
+  }
+  qualifyGetOptions(options) {
+    return this.qualifyWriteOptions(options);
+  }
+  qualifyWrapOptions(options) {
+    return this.qualifyWriteOptions(options);
+  }
+  qualifyWriteOptions(options) {
+    if (!options?.tags || options.tags.length === 0) {
+      return options;
+    }
+    return {
+      ...options,
+      tags: options.tags.map((tag) => this.qualifyTag(tag))
+    };
+  }
   async trackMetrics(operation) {
     return this.getMetricsMutex().runExclusive(async () => {
       const before = this.cache.getMetrics();
       const result = await operation();
       const after = this.cache.getMetrics();
-      this.metrics = addMetrics(this.metrics, diffMetrics(before, after));
+      this.metrics = addNamespaceMetrics(this.metrics, diffNamespaceMetrics(before, after));
       return result;
     });
   }
@@ -201,223 +347,773 @@ var CacheNamespace = class _CacheNamespace {
     return mutex;
   }
 };
-function emptyMetrics() {
-  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()
-  };
-}
-function cloneMetrics(metrics) {
-  return {
-    ...metrics,
-    hitsByLayer: { ...metrics.hitsByLayer },
-    missesByLayer: { ...metrics.missesByLayer },
-    latencyByLayer: Object.fromEntries(
-      Object.entries(metrics.latencyByLayer).map(([key, value]) => [key, { ...value }])
-    )
-  };
+function validateNamespaceKey(key) {
+  if (key.length === 0) {
+    throw new Error("Namespace prefix must not be empty.");
+  }
+  if (key.length > 256) {
+    throw new Error("Namespace prefix must be at most 256 characters.");
+  }
+  if (/[\u0000-\u001F\u007F]/.test(key)) {
+    throw new Error("Namespace prefix contains unsupported control characters.");
+  }
+  if (/[\uD800-\uDFFF]/.test(key)) {
+    throw new Error("Namespace prefix contains unsupported surrogate code points.");
+  }
 }
-function diffMetrics(before, after) {
-  const latencyByLayer = Object.fromEntries(
-    Object.entries(after.latencyByLayer).map(([layer, value]) => [
-      layer,
-      {
-        avgMs: value.avgMs,
-        maxMs: value.maxMs,
-        count: Math.max(0, value.count - (before.latencyByLayer[layer]?.count ?? 0))
+
+// src/invalidation/PatternMatcher.ts
+var PatternMatcher = class _PatternMatcher {
+  /**
+   * Tests whether a glob-style pattern matches a value.
+   * Supports `*` (any sequence of characters) and `?` (any single character).
+   * Uses a two-pointer algorithm to avoid ReDoS vulnerabilities and
+   * quadratic memory usage on long patterns/keys.
+   */
+  static matches(pattern, value) {
+    return _PatternMatcher.matchLinear(pattern, value);
+  }
+  /**
+   * Linear-time glob matching with O(1) extra memory.
+   */
+  static matchLinear(pattern, value) {
+    let patternIndex = 0;
+    let valueIndex = 0;
+    let starIndex = -1;
+    let backtrackValueIndex = 0;
+    while (valueIndex < value.length) {
+      const patternChar = pattern[patternIndex];
+      const valueChar = value[valueIndex];
+      if (patternChar === "*" && patternIndex < pattern.length) {
+        starIndex = patternIndex;
+        patternIndex += 1;
+        backtrackValueIndex = valueIndex;
+        continue;
       }
-    ])
-  );
-  return {
-    hits: after.hits - before.hits,
-    misses: after.misses - before.misses,
-    fetches: after.fetches - before.fetches,
-    sets: after.sets - before.sets,
-    deletes: after.deletes - before.deletes,
-    backfills: after.backfills - before.backfills,
-    invalidations: after.invalidations - before.invalidations,
-    staleHits: after.staleHits - before.staleHits,
-    refreshes: after.refreshes - before.refreshes,
-    refreshErrors: after.refreshErrors - before.refreshErrors,
-    writeFailures: after.writeFailures - before.writeFailures,
-    singleFlightWaits: after.singleFlightWaits - before.singleFlightWaits,
-    negativeCacheHits: after.negativeCacheHits - before.negativeCacheHits,
-    circuitBreakerTrips: after.circuitBreakerTrips - before.circuitBreakerTrips,
-    degradedOperations: after.degradedOperations - before.degradedOperations,
-    hitsByLayer: diffMap(before.hitsByLayer, after.hitsByLayer),
-    missesByLayer: diffMap(before.missesByLayer, after.missesByLayer),
-    latencyByLayer,
-    resetAt: after.resetAt
-  };
-}
-function addMetrics(base, delta) {
-  return {
-    hits: base.hits + delta.hits,
-    misses: base.misses + delta.misses,
-    fetches: base.fetches + delta.fetches,
-    sets: base.sets + delta.sets,
-    deletes: base.deletes + delta.deletes,
-    backfills: base.backfills + delta.backfills,
-    invalidations: base.invalidations + delta.invalidations,
-    staleHits: base.staleHits + delta.staleHits,
-    refreshes: base.refreshes + delta.refreshes,
-    refreshErrors: base.refreshErrors + delta.refreshErrors,
-    writeFailures: base.writeFailures + delta.writeFailures,
-    singleFlightWaits: base.singleFlightWaits + delta.singleFlightWaits,
-    negativeCacheHits: base.negativeCacheHits + delta.negativeCacheHits,
-    circuitBreakerTrips: base.circuitBreakerTrips + delta.circuitBreakerTrips,
-    degradedOperations: base.degradedOperations + delta.degradedOperations,
-    hitsByLayer: addMap(base.hitsByLayer, delta.hitsByLayer),
-    missesByLayer: addMap(base.missesByLayer, delta.missesByLayer),
-    latencyByLayer: cloneMetrics(delta).latencyByLayer,
-    resetAt: base.resetAt
-  };
-}
-function diffMap(before, after) {
-  const keys = /* @__PURE__ */ new Set([...Object.keys(before), ...Object.keys(after)]);
-  const result = {};
-  for (const key of keys) {
-    result[key] = (after[key] ?? 0) - (before[key] ?? 0);
+      if (patternChar === "?" || patternChar === valueChar) {
+        patternIndex += 1;
+        valueIndex += 1;
+        continue;
+      }
+      if (starIndex !== -1) {
+        patternIndex = starIndex + 1;
+        backtrackValueIndex += 1;
+        valueIndex = backtrackValueIndex;
+        continue;
+      }
+      return false;
+    }
+    while (patternIndex < pattern.length && pattern[patternIndex] === "*") {
+      patternIndex += 1;
+    }
+    return patternIndex === pattern.length;
   }
-  return result;
-}
-function addMap(base, delta) {
-  const keys = /* @__PURE__ */ new Set([...Object.keys(base), ...Object.keys(delta)]);
-  const result = {};
-  for (const key of keys) {
-    result[key] = (base[key] ?? 0) + (delta[key] ?? 0);
+};
+
+// src/internal/CacheKeyDiscovery.ts
+var CacheKeyDiscovery = class {
+  constructor(options) {
+    this.options = options;
+  }
+  options;
+  async collectKeysWithPrefix(prefix, maxMatches = false) {
+    const { tagIndex } = this.options;
+    const matches = /* @__PURE__ */ new Set();
+    if (tagIndex.forEachKeyForPrefix) {
+      await tagIndex.forEachKeyForPrefix(prefix, async (key) => {
+        matches.add(key);
+        this.assertWithinMatchLimit(matches, maxMatches);
+      });
+    } else {
+      const initialMatches = tagIndex.keysForPrefix ? await tagIndex.keysForPrefix(prefix) : await tagIndex.matchPattern(`${prefix}*`);
+      for (const key of initialMatches) {
+        matches.add(key);
+        this.assertWithinMatchLimit(matches, maxMatches);
+      }
+    }
+    await Promise.all(
+      this.options.layers.map(async (layer) => {
+        if (!layer.keys && !layer.forEachKey || this.options.shouldSkipLayer(layer)) {
+          return;
+        }
+        try {
+          if (layer.forEachKey) {
+            await layer.forEachKey(async (key) => {
+              if (key.startsWith(prefix)) {
+                matches.add(key);
+                this.assertWithinMatchLimit(matches, maxMatches);
+              }
+            });
+            return;
+          }
+          const keys = await layer.keys?.();
+          for (const key of keys ?? []) {
+            if (key.startsWith(prefix)) {
+              matches.add(key);
+              this.assertWithinMatchLimit(matches, maxMatches);
+            }
+          }
+        } catch (error) {
+          await this.options.handleLayerFailure(layer, "invalidate-prefix-scan", error);
+        }
+      })
+    );
+    return [...matches];
+  }
+  async collectKeysMatchingPattern(pattern, maxMatches = false) {
+    const matches = /* @__PURE__ */ new Set();
+    if (this.options.tagIndex.forEachKeyMatchingPattern) {
+      await this.options.tagIndex.forEachKeyMatchingPattern(pattern, async (key) => {
+        matches.add(key);
+        this.assertWithinMatchLimit(matches, maxMatches);
+      });
+    } else {
+      for (const key of await this.options.tagIndex.matchPattern(pattern)) {
+        matches.add(key);
+        this.assertWithinMatchLimit(matches, maxMatches);
+      }
+    }
+    await Promise.all(
+      this.options.layers.map(async (layer) => {
+        if (!layer.keys && !layer.forEachKey || this.options.shouldSkipLayer(layer)) {
+          return;
+        }
+        try {
+          if (layer.forEachKey) {
+            await layer.forEachKey(async (key) => {
+              if (PatternMatcher.matches(pattern, key)) {
+                matches.add(key);
+                this.assertWithinMatchLimit(matches, maxMatches);
+              }
+            });
+            return;
+          }
+          const keys = await layer.keys?.();
+          for (const key of keys ?? []) {
+            if (PatternMatcher.matches(pattern, key)) {
+              matches.add(key);
+              this.assertWithinMatchLimit(matches, maxMatches);
+            }
+          }
+        } catch (error) {
+          await this.options.handleLayerFailure(layer, "invalidate-pattern-scan", error);
+        }
+      })
+    );
+    return [...matches];
+  }
+  assertWithinMatchLimit(matches, maxMatches) {
+    if (maxMatches !== false && matches.size > maxMatches) {
+      throw new Error(`Invalidation matched too many keys (${matches.size} > ${maxMatches}).`);
+    }
+  }
+};
+
+// src/internal/CacheKeySerialization.ts
+var DANGEROUS_OBJECT_KEYS = /* @__PURE__ */ new Set(["__proto__", "prototype", "constructor"]);
+function normalizeForSerialization(value) {
+  if (Array.isArray(value)) {
+    return value.map((entry) => normalizeForSerialization(entry));
+  }
+  if (value && typeof value === "object") {
+    return Object.keys(value).sort().reduce((normalized, key) => {
+      if (DANGEROUS_OBJECT_KEYS.has(key)) {
+        return normalized;
+      }
+      normalized[key] = normalizeForSerialization(value[key]);
+      return normalized;
+    }, {});
+  }
+  return value;
+}
+function serializeKeyPart(value) {
+  if (typeof value === "string") {
+    return `s:${value}`;
+  }
+  if (typeof value === "number") {
+    return `n:${value}`;
+  }
+  if (typeof value === "boolean") {
+    return `b:${value}`;
+  }
+  return `j:${JSON.stringify(normalizeForSerialization(value))}`;
+}
+function serializeOptions(options) {
+  return JSON.stringify(normalizeForSerialization(options) ?? null);
+}
+function createInstanceId() {
+  if (globalThis.crypto?.randomUUID) {
+    return globalThis.crypto.randomUUID();
+  }
+  const bytes = new Uint8Array(16);
+  if (globalThis.crypto?.getRandomValues) {
+    globalThis.crypto.getRandomValues(bytes);
+  } else {
+    for (let i = 0; i < bytes.length; i += 1) {
+      bytes[i] = Math.floor(Math.random() * 256);
+    }
+  }
+  return `layercache-${Array.from(bytes, (byte) => byte.toString(16).padStart(2, "0")).join("")}`;
+}
+
+// src/internal/CacheSnapshotFile.ts
+function isWithinSnapshotBase(realBaseDir, candidatePath, pathSeparator, path) {
+  const relative = path.relative(realBaseDir, candidatePath);
+  return !(relative === ".." || relative.startsWith(`..${pathSeparator}`) || path.isAbsolute(relative));
+}
+async function findExistingAncestor(directory, fs2, path) {
+  let current = directory;
+  while (true) {
+    try {
+      await fs2.lstat(current);
+      return current;
+    } catch (error) {
+      if (error.code !== "ENOENT") {
+        throw error;
+      }
+    }
+    const parent = path.dirname(current);
+    if (parent === current) {
+      return current;
+    }
+    current = parent;
+  }
+}
+async function validateSnapshotFilePath(filePath, mode, snapshotBaseDir, cwd = process.cwd()) {
+  if (filePath.length === 0) {
+    throw new Error("filePath must not be empty.");
+  }
+  if (filePath.includes("\0")) {
+    throw new Error("filePath must not contain null bytes.");
+  }
+  const { promises: fs2 } = await import("fs");
+  const path = await import("path");
+  const resolved = path.resolve(filePath);
+  const baseDir = snapshotBaseDir === false ? false : path.resolve(snapshotBaseDir ?? cwd);
+  if (baseDir === false) {
+    return resolved;
+  }
+  await fs2.mkdir(baseDir, { recursive: true });
+  const realBaseDir = await fs2.realpath(baseDir);
+  if (!isWithinSnapshotBase(realBaseDir, resolved, path.sep, path)) {
+    throw new Error(`filePath is outside the allowed snapshot directory: ${realBaseDir}`);
+  }
+  if (mode === "read") {
+    const realTarget = await fs2.realpath(resolved);
+    if (!isWithinSnapshotBase(realBaseDir, realTarget, path.sep, path)) {
+      throw new Error(`filePath is outside the allowed snapshot directory: ${realBaseDir}`);
+    }
+    return realTarget;
+  }
+  const parentDir = path.dirname(resolved);
+  const existingAncestor = await findExistingAncestor(parentDir, fs2, path);
+  const realExistingAncestor = await fs2.realpath(existingAncestor);
+  if (!isWithinSnapshotBase(realBaseDir, realExistingAncestor, path.sep, path)) {
+    throw new Error(`filePath is outside the allowed snapshot directory: ${realBaseDir}`);
+  }
+  await fs2.mkdir(parentDir, { recursive: true });
+  const realParentDir = await fs2.realpath(parentDir);
+  if (!isWithinSnapshotBase(realBaseDir, realParentDir, path.sep, path)) {
+    throw new Error(`filePath is outside the allowed snapshot directory: ${realBaseDir}`);
+  }
+  const targetPath = path.join(realParentDir, path.basename(resolved));
+  try {
+    const existing = await fs2.lstat(targetPath);
+    if (existing.isSymbolicLink()) {
+      throw new Error("filePath must not point to a symbolic link.");
+    }
+  } catch (error) {
+    if (error.code !== "ENOENT") {
+      throw error;
+    }
+  }
+  return targetPath;
+}
+async function readUtf8HandleWithLimit(handle, byteLimit) {
+  if (byteLimit === false) {
+    return handle.readFile({ encoding: "utf8" });
+  }
+  const chunks = [];
+  let totalBytes = 0;
+  let position = 0;
+  while (true) {
+    const buffer = Buffer.allocUnsafe(Math.min(64 * 1024, byteLimit - totalBytes + 1));
+    const { bytesRead } = await handle.read(buffer, 0, buffer.byteLength, position);
+    if (bytesRead === 0) {
+      break;
+    }
+    totalBytes += bytesRead;
+    if (totalBytes > byteLimit) {
+      throw new Error(`Snapshot file exceeds snapshotMaxBytes limit (${totalBytes} bytes > ${byteLimit} bytes).`);
+    }
+    chunks.push(buffer.subarray(0, bytesRead));
+    position += bytesRead;
+  }
+  return Buffer.concat(chunks).toString("utf8");
+}
+
+// src/internal/CacheStackGeneration.ts
+var DEFAULT_GENERATION_CLEANUP_BATCH_SIZE = 500;
+function generationPrefix(generation) {
+  return generation === void 0 ? "" : `v${generation}:`;
+}
+function qualifyGenerationKey(key, generation) {
+  const prefix = generationPrefix(generation);
+  return prefix ? `${prefix}${key}` : key;
+}
+function qualifyGenerationPattern(pattern, generation) {
+  return qualifyGenerationKey(pattern, generation);
+}
+function stripGenerationPrefix(key, generation) {
+  const prefix = generationPrefix(generation);
+  if (!prefix || !key.startsWith(prefix)) {
+    return key;
+  }
+  return key.slice(prefix.length);
+}
+function resolveGenerationCleanupTarget({
+  previousGeneration,
+  nextGeneration,
+  generationCleanup
+}) {
+  if (!generationCleanup || previousGeneration === void 0 || previousGeneration === nextGeneration) {
+    return null;
+  }
+  return previousGeneration;
+}
+function resolveGenerationCleanupBatchSize(generationCleanup) {
+  if (typeof generationCleanup !== "object" || generationCleanup === null) {
+    return DEFAULT_GENERATION_CLEANUP_BATCH_SIZE;
+  }
+  return generationCleanup.batchSize ?? DEFAULT_GENERATION_CLEANUP_BATCH_SIZE;
+}
+function planGenerationCleanupBatches(keys, generationCleanup) {
+  if (keys.length === 0) {
+    return [];
+  }
+  const batchSize = resolveGenerationCleanupBatchSize(generationCleanup);
+  const batches = [];
+  for (let index = 0; index < keys.length; index += batchSize) {
+    batches.push(keys.slice(index, index + batchSize));
+  }
+  return batches;
+}
+
+// src/internal/CacheStackMaintenance.ts
+var CacheStackMaintenance = class {
+  keyEpochs = /* @__PURE__ */ new Map();
+  writeBehindQueue = [];
+  writeBehindTimer;
+  writeBehindFlushPromise;
+  generationCleanupPromise;
+  clearEpoch = 0;
+  initializeWriteBehindTimer(writeStrategy, options, flush) {
+    if (writeStrategy !== "write-behind") {
+      return;
+    }
+    const flushIntervalMs = options?.flushIntervalMs;
+    if (!flushIntervalMs || flushIntervalMs <= 0) {
+      return;
+    }
+    this.disposeWriteBehindTimer();
+    this.writeBehindTimer = setInterval(() => {
+      void flush();
+    }, flushIntervalMs);
+    this.writeBehindTimer.unref?.();
+  }
+  disposeWriteBehindTimer() {
+    if (!this.writeBehindTimer) {
+      return;
+    }
+    clearInterval(this.writeBehindTimer);
+    this.writeBehindTimer = void 0;
+  }
+  beginClearEpoch() {
+    this.clearEpoch += 1;
+    this.keyEpochs.clear();
+    this.writeBehindQueue.length = 0;
+  }
+  currentClearEpoch() {
+    return this.clearEpoch;
+  }
+  currentKeyEpoch(key) {
+    return this.keyEpochs.get(key) ?? 0;
+  }
+  bumpKeyEpochs(keys) {
+    for (const key of keys) {
+      this.keyEpochs.set(key, this.currentKeyEpoch(key) + 1);
+    }
+  }
+  isWriteOutdated(key, expectedClearEpoch, expectedKeyEpoch) {
+    if (expectedClearEpoch !== void 0 && expectedClearEpoch !== this.clearEpoch) {
+      return true;
+    }
+    if (expectedKeyEpoch !== void 0 && expectedKeyEpoch !== this.currentKeyEpoch(key)) {
+      return true;
+    }
+    return false;
+  }
+  async enqueueWriteBehind(operation, options, flushBatch) {
+    this.writeBehindQueue.push(operation);
+    const batchSize = options?.batchSize ?? 100;
+    const maxQueueSize = options?.maxQueueSize ?? batchSize * 10;
+    if (this.writeBehindQueue.length >= batchSize) {
+      await this.flushWriteBehindQueue(options, flushBatch);
+      return;
+    }
+    if (this.writeBehindQueue.length >= maxQueueSize) {
+      await this.flushWriteBehindQueue(options, flushBatch);
+    }
+  }
+  async flushWriteBehindQueue(options, flushBatch) {
+    if (this.writeBehindFlushPromise || this.writeBehindQueue.length === 0) {
+      await this.writeBehindFlushPromise;
+      return;
+    }
+    const batchSize = options?.batchSize ?? 100;
+    const batch = this.writeBehindQueue.splice(0, batchSize);
+    this.writeBehindFlushPromise = flushBatch(batch);
+    try {
+      await this.writeBehindFlushPromise;
+    } finally {
+      this.writeBehindFlushPromise = void 0;
+    }
+    if (this.writeBehindQueue.length > 0) {
+      await this.flushWriteBehindQueue(options, flushBatch);
+    }
+  }
+  scheduleGenerationCleanup(generation, task, onError) {
+    const scheduledTask = (this.generationCleanupPromise ?? Promise.resolve()).then(() => task(generation)).catch((error) => {
+      onError(generation, error);
+    });
+    this.generationCleanupPromise = scheduledTask.finally(() => {
+      if (this.generationCleanupPromise === scheduledTask) {
+        this.generationCleanupPromise = void 0;
+      }
+    });
+  }
+  async waitForGenerationCleanup() {
+    await this.generationCleanupPromise;
+  }
+};
+
+// src/internal/StoredValue.ts
+function isStoredValueEnvelope(value) {
+  if (typeof value !== "object" || value === null) {
+    return false;
+  }
+  const v = value;
+  if (v.__layercache !== 1) {
+    return false;
+  }
+  if (v.kind !== "value" && v.kind !== "empty") {
+    return false;
+  }
+  if (v.freshUntil !== null && (!Number.isFinite(v.freshUntil) || typeof v.freshUntil !== "number")) {
+    return false;
+  }
+  if (v.staleUntil !== null && (!Number.isFinite(v.staleUntil) || typeof v.staleUntil !== "number")) {
+    return false;
+  }
+  if (v.errorUntil !== null && (!Number.isFinite(v.errorUntil) || typeof v.errorUntil !== "number")) {
+    return false;
+  }
+  const maxTimestamp = Date.now() + 10 * 365 * 24 * 60 * 60 * 1e3;
+  if (typeof v.freshUntil === "number" && v.freshUntil > maxTimestamp) {
+    return false;
+  }
+  if (typeof v.staleUntil === "number" && v.staleUntil > maxTimestamp) {
+    return false;
+  }
+  if (typeof v.errorUntil === "number" && v.errorUntil > maxTimestamp) {
+    return false;
+  }
+  if (v.freshUntil === null && (v.staleUntil !== null || v.errorUntil !== null)) {
+    return false;
+  }
+  if (typeof v.freshUntil === "number" && typeof v.staleUntil === "number" && v.staleUntil < v.freshUntil) {
+    return false;
+  }
+  if (typeof v.freshUntil === "number" && typeof v.errorUntil === "number" && v.errorUntil < v.freshUntil) {
+    return false;
+  }
+  const maxTtlSeconds = 10 * 365 * 24 * 60 * 60;
+  if (!isValidEnvelopeTtlSeconds(v.freshTtlSeconds, maxTtlSeconds)) {
+    return false;
+  }
+  if (!isValidEnvelopeTtlSeconds(v.staleWhileRevalidateSeconds, maxTtlSeconds)) {
+    return false;
+  }
+  if (!isValidEnvelopeTtlSeconds(v.staleIfErrorSeconds, maxTtlSeconds)) {
+    return false;
+  }
+  if (v.freshTtlSeconds == null && (v.staleWhileRevalidateSeconds != null || v.staleIfErrorSeconds != null)) {
+    return false;
+  }
+  return true;
+}
+function createStoredValueEnvelope(options) {
+  const now = options.now ?? Date.now();
+  const freshTtlSeconds = normalizePositiveSeconds(options.freshTtlSeconds);
+  const staleWhileRevalidateSeconds = normalizePositiveSeconds(options.staleWhileRevalidateSeconds);
+  const staleIfErrorSeconds = normalizePositiveSeconds(options.staleIfErrorSeconds);
+  const freshUntil = freshTtlSeconds ? now + freshTtlSeconds * 1e3 : null;
+  const staleUntil = freshUntil && staleWhileRevalidateSeconds ? freshUntil + staleWhileRevalidateSeconds * 1e3 : null;
+  const errorUntil = freshUntil && staleIfErrorSeconds ? freshUntil + staleIfErrorSeconds * 1e3 : null;
+  return {
+    __layercache: 1,
+    kind: options.kind,
+    value: options.value,
+    freshUntil,
+    staleUntil,
+    errorUntil,
+    freshTtlSeconds: freshTtlSeconds ?? null,
+    staleWhileRevalidateSeconds: staleWhileRevalidateSeconds ?? null,
+    staleIfErrorSeconds: staleIfErrorSeconds ?? null
+  };
+}
+function resolveStoredValue(stored, now = Date.now()) {
+  if (!isStoredValueEnvelope(stored)) {
+    return { state: "fresh", value: stored, stored };
+  }
+  if (stored.freshUntil === null || stored.freshUntil > now) {
+    return { state: "fresh", value: unwrapStoredValue(stored), stored, envelope: stored };
+  }
+  if (stored.staleUntil !== null && stored.staleUntil > now) {
+    return { state: "stale-while-revalidate", value: unwrapStoredValue(stored), stored, envelope: stored };
+  }
+  if (stored.errorUntil !== null && stored.errorUntil > now) {
+    return { state: "stale-if-error", value: unwrapStoredValue(stored), stored, envelope: stored };
+  }
+  return { state: "expired", value: null, stored, envelope: stored };
+}
+function unwrapStoredValue(stored) {
+  if (!isStoredValueEnvelope(stored)) {
+    return stored;
+  }
+  if (stored.kind === "empty") {
+    return null;
+  }
+  return stored.value ?? null;
+}
+function remainingStoredTtlSeconds(stored, now = Date.now()) {
+  if (!isStoredValueEnvelope(stored)) {
+    return void 0;
+  }
+  const expiry = maxExpiry(stored);
+  if (expiry === null) {
+    return void 0;
+  }
+  const remainingMs = expiry - now;
+  if (remainingMs <= 0) {
+    return 1;
+  }
+  return Math.max(1, Math.ceil(remainingMs / 1e3));
+}
+function remainingFreshTtlSeconds(stored, now = Date.now()) {
+  if (!isStoredValueEnvelope(stored) || stored.freshUntil === null) {
+    return void 0;
+  }
+  const remainingMs = stored.freshUntil - now;
+  if (remainingMs <= 0) {
+    return 0;
+  }
+  return Math.max(1, Math.ceil(remainingMs / 1e3));
+}
+function refreshStoredEnvelope(stored, now = Date.now()) {
+  if (!isStoredValueEnvelope(stored)) {
+    return stored;
+  }
+  return createStoredValueEnvelope({
+    kind: stored.kind,
+    value: stored.value,
+    freshTtlSeconds: stored.freshTtlSeconds ?? void 0,
+    staleWhileRevalidateSeconds: stored.staleWhileRevalidateSeconds ?? void 0,
+    staleIfErrorSeconds: stored.staleIfErrorSeconds ?? void 0,
+    now
+  });
+}
+function maxExpiry(stored) {
+  const values = [stored.freshUntil, stored.staleUntil, stored.errorUntil].filter(
+    (value) => value !== null
+  );
+  if (values.length === 0) {
+    return null;
+  }
+  return Math.max(...values);
+}
+function normalizePositiveSeconds(value) {
+  if (!value || value <= 0) {
+    return void 0;
+  }
+  return value;
+}
+function isValidEnvelopeTtlSeconds(value, maxTtlSeconds) {
+  if (value == null) {
+    return true;
+  }
+  return typeof value === "number" && Number.isFinite(value) && value > 0 && value <= maxTtlSeconds;
+}
+
+// src/internal/CacheStackRuntimePolicy.ts
+function shouldSkipLayer(degradedUntil, now = Date.now()) {
+  return degradedUntil !== void 0 && degradedUntil > now;
+}
+function shouldStartBackgroundRefresh({
+  isDisconnecting,
+  hasRefreshInFlight
+}) {
+  return !isDisconnecting && !hasRefreshInFlight;
+}
+function resolveRecoverableLayerFailure(gracefulDegradation, now = Date.now()) {
+  if (!gracefulDegradation) {
+    return { degrade: false };
+  }
+  const retryAfterMs = typeof gracefulDegradation === "object" ? gracefulDegradation.retryAfterMs ?? 1e4 : 1e4;
+  return {
+    degrade: true,
+    degradedUntil: now + retryAfterMs
+  };
+}
+function planFreshReadPolicies({
+  stored,
+  hasFetcher,
+  slidingTtl,
+  refreshAheadSeconds
+}) {
+  const refreshedStored = slidingTtl && isStoredValueEnvelope(stored) ? refreshStoredEnvelope(stored) : void 0;
+  const refreshedStoredTtl = refreshedStored ? remainingStoredTtlSeconds(refreshedStored) ?? void 0 : void 0;
+  const remainingFreshTtl = remainingFreshTtlSeconds(stored) ?? 0;
+  return {
+    refreshedStored,
+    refreshedStoredTtl,
+    shouldScheduleBackgroundRefresh: hasFetcher && refreshAheadSeconds > 0 && remainingFreshTtl > 0 && remainingFreshTtl <= refreshAheadSeconds
+  };
+}
+
+// src/internal/CacheStackValidation.ts
+var MAX_CACHE_KEY_LENGTH = 1024;
+var MAX_PATTERN_LENGTH = 1024;
+var MAX_TAGS_PER_OPERATION = 128;
+function validatePositiveNumber(name, value) {
+  if (value === void 0) {
+    return;
+  }
+  if (!Number.isFinite(value) || value <= 0) {
+    throw new Error(`${name} must be a positive finite number.`);
+  }
+}
+function validateNonNegativeNumber(name, value) {
+  if (!Number.isFinite(value) || value < 0) {
+    throw new Error(`${name} must be a non-negative finite number.`);
+  }
+}
+function validateLayerNumberOption(name, value) {
+  if (value === void 0) {
+    return;
+  }
+  if (typeof value === "number") {
+    validateNonNegativeNumber(name, value);
+    return;
+  }
+  for (const [layerName, layerValue] of Object.entries(value)) {
+    if (layerValue === void 0) {
+      continue;
+    }
+    validateNonNegativeNumber(`${name}.${layerName}`, layerValue);
+  }
+}
+function validateRateLimitOptions(name, options) {
+  if (!options) {
+    return;
+  }
+  validatePositiveNumber(`${name}.maxConcurrent`, options.maxConcurrent);
+  validatePositiveNumber(`${name}.intervalMs`, options.intervalMs);
+  validatePositiveNumber(`${name}.maxPerInterval`, options.maxPerInterval);
+  if (options.scope && !["global", "key", "fetcher"].includes(options.scope)) {
+    throw new Error(`${name}.scope must be one of "global", "key", or "fetcher".`);
+  }
+  if (options.bucketKey !== void 0 && options.bucketKey.length === 0) {
+    throw new Error(`${name}.bucketKey must not be empty.`);
   }
-  return result;
 }
-function validateNamespaceKey(key) {
+function validateCacheKey(key) {
   if (key.length === 0) {
-    throw new Error("Namespace prefix must not be empty.");
+    throw new Error("Cache key must not be empty.");
   }
-  if (key.length > 256) {
-    throw new Error("Namespace prefix must be at most 256 characters.");
+  if (key.length > MAX_CACHE_KEY_LENGTH) {
+    throw new Error(`Cache key length must be at most ${MAX_CACHE_KEY_LENGTH} characters.`);
   }
   if (/[\u0000-\u001F\u007F]/.test(key)) {
-    throw new Error("Namespace prefix contains unsupported control characters.");
+    throw new Error("Cache key contains unsupported control characters.");
+  }
+  if (/[\uD800-\uDFFF]/.test(key)) {
+    throw new Error("Cache key contains unsupported surrogate code points.");
   }
+  return key;
 }
-
-// src/invalidation/PatternMatcher.ts
-var PatternMatcher = class _PatternMatcher {
-  /**
-   * Tests whether a glob-style pattern matches a value.
-   * Supports `*` (any sequence of characters) and `?` (any single character).
-   * Uses a two-pointer algorithm to avoid ReDoS vulnerabilities and
-   * quadratic memory usage on long patterns/keys.
-   */
-  static matches(pattern, value) {
-    return _PatternMatcher.matchLinear(pattern, value);
+function validateTag(tag) {
+  if (tag.length === 0) {
+    throw new Error("Cache tag must not be empty.");
   }
-  /**
-   * Linear-time glob matching with O(1) extra memory.
-   */
-  static matchLinear(pattern, value) {
-    let patternIndex = 0;
-    let valueIndex = 0;
-    let starIndex = -1;
-    let backtrackValueIndex = 0;
-    while (valueIndex < value.length) {
-      const patternChar = pattern[patternIndex];
-      const valueChar = value[valueIndex];
-      if (patternChar === "*" && patternIndex < pattern.length) {
-        starIndex = patternIndex;
-        patternIndex += 1;
-        backtrackValueIndex = valueIndex;
-        continue;
-      }
-      if (patternChar === "?" || patternChar === valueChar) {
-        patternIndex += 1;
-        valueIndex += 1;
-        continue;
-      }
-      if (starIndex !== -1) {
-        patternIndex = starIndex + 1;
-        backtrackValueIndex += 1;
-        valueIndex = backtrackValueIndex;
-        continue;
-      }
-      return false;
-    }
-    while (patternIndex < pattern.length && pattern[patternIndex] === "*") {
-      patternIndex += 1;
-    }
-    return patternIndex === pattern.length;
+  if (tag.length > MAX_CACHE_KEY_LENGTH) {
+    throw new Error(`Cache tag length must be at most ${MAX_CACHE_KEY_LENGTH} characters.`);
   }
-};
-
-// src/internal/CacheKeyDiscovery.ts
-var CacheKeyDiscovery = class {
-  constructor(options) {
-    this.options = options;
+  if (/[\u0000-\u001F\u007F]/.test(tag)) {
+    throw new Error("Cache tag contains unsupported control characters.");
   }
-  options;
-  async collectKeysWithPrefix(prefix) {
-    const { tagIndex } = this.options;
-    const matches = new Set(
-      tagIndex.keysForPrefix ? await tagIndex.keysForPrefix(prefix) : await tagIndex.matchPattern(`${prefix}*`)
-    );
-    await Promise.all(
-      this.options.layers.map(async (layer) => {
-        if (!layer.keys || this.options.shouldSkipLayer(layer)) {
-          return;
-        }
-        try {
-          const keys = await layer.keys();
-          for (const key of keys) {
-            if (key.startsWith(prefix)) {
-              matches.add(key);
-            }
-          }
-        } catch (error) {
-          await this.options.handleLayerFailure(layer, "invalidate-prefix-scan", error);
-        }
-      })
-    );
-    return [...matches];
+  if (/[\uD800-\uDFFF]/.test(tag)) {
+    throw new Error("Cache tag contains unsupported surrogate code points.");
   }
-  async collectKeysMatchingPattern(pattern) {
-    const matches = new Set(await this.options.tagIndex.matchPattern(pattern));
-    await Promise.all(
-      this.options.layers.map(async (layer) => {
-        if (!layer.keys || this.options.shouldSkipLayer(layer)) {
-          return;
-        }
-        try {
-          const keys = await layer.keys();
-          for (const key of keys) {
-            if (PatternMatcher.matches(pattern, key)) {
-              matches.add(key);
-            }
-          }
-        } catch (error) {
-          await this.options.handleLayerFailure(layer, "invalidate-pattern-scan", error);
-        }
-      })
-    );
-    return [...matches];
+  return tag;
+}
+function validateTags(tags) {
+  if (!tags) {
+    return;
   }
-};
+  if (tags.length > MAX_TAGS_PER_OPERATION) {
+    throw new Error(`options.tags must contain at most ${MAX_TAGS_PER_OPERATION} tags.`);
+  }
+  for (const tag of tags) {
+    validateTag(tag);
+  }
+}
+function validatePattern(pattern) {
+  if (pattern.length === 0) {
+    throw new Error("Pattern must not be empty.");
+  }
+  if (pattern.length > MAX_PATTERN_LENGTH) {
+    throw new Error(`Pattern length must be at most ${MAX_PATTERN_LENGTH} characters.`);
+  }
+  if (/[\u0000-\u001F\u007F]/.test(pattern)) {
+    throw new Error("Pattern contains unsupported control characters.");
+  }
+}
+function validateTtlPolicy(name, policy) {
+  if (!policy || typeof policy === "function" || policy === "until-midnight" || policy === "next-hour") {
+    return;
+  }
+  if ("alignTo" in policy) {
+    validatePositiveNumber(`${name}.alignTo`, policy.alignTo);
+    return;
+  }
+  throw new Error(`${name} is invalid.`);
+}
+function validateAdaptiveTtlOptions(options) {
+  if (!options || options === true) {
+    return;
+  }
+  validatePositiveNumber("adaptiveTtl.hotAfter", options.hotAfter);
+  validateLayerNumberOption("adaptiveTtl.step", options.step);
+  validateLayerNumberOption("adaptiveTtl.maxTtl", options.maxTtl);
+}
+function validateCircuitBreakerOptions(options) {
+  if (!options) {
+    return;
+  }
+  validatePositiveNumber("circuitBreaker.failureThreshold", options.failureThreshold);
+  validatePositiveNumber("circuitBreaker.cooldownMs", options.cooldownMs);
+}
 
 // src/internal/CircuitBreakerManager.ts
 var CircuitBreakerManager = class {
@@ -448,7 +1144,6 @@ var CircuitBreakerManager = class {
     if (!options) {
       return;
     }
-    this.pruneIfNeeded();
     const failureThreshold = options.failureThreshold ?? 3;
     const cooldownMs = options.cooldownMs ?? 3e4;
     const state = this.breakers.get(key) ?? { failures: 0, openUntil: null, createdAt: Date.now() };
@@ -457,6 +1152,7 @@ var CircuitBreakerManager = class {
       state.openUntil = Date.now() + cooldownMs;
     }
     this.breakers.set(key, state);
+    this.pruneIfNeeded();
   }
   recordSuccess(key) {
     this.breakers.delete(key);
@@ -741,188 +1437,64 @@ var MetricsCollector = class {
     ;
     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) {
-  if (typeof value !== "object" || value === null) {
-    return false;
-  }
-  const v = value;
-  if (v.__layercache !== 1) {
-    return false;
-  }
-  if (v.kind !== "value" && v.kind !== "empty") {
-    return false;
-  }
-  if (v.freshUntil !== null && typeof v.freshUntil !== "number") {
-    return false;
-  }
-  if (v.staleUntil !== null && typeof v.staleUntil !== "number") {
-    return false;
-  }
-  if (v.errorUntil !== null && typeof v.errorUntil !== "number") {
-    return false;
-  }
-  const maxTimestamp = Date.now() + 10 * 365 * 24 * 60 * 60 * 1e3;
-  if (typeof v.freshUntil === "number" && v.freshUntil > maxTimestamp) {
-    return false;
-  }
-  return true;
-}
-function createStoredValueEnvelope(options) {
-  const now = options.now ?? Date.now();
-  const freshTtlSeconds = normalizePositiveSeconds(options.freshTtlSeconds);
-  const staleWhileRevalidateSeconds = normalizePositiveSeconds(options.staleWhileRevalidateSeconds);
-  const staleIfErrorSeconds = normalizePositiveSeconds(options.staleIfErrorSeconds);
-  const freshUntil = freshTtlSeconds ? now + freshTtlSeconds * 1e3 : null;
-  const staleUntil = freshUntil && staleWhileRevalidateSeconds ? freshUntil + staleWhileRevalidateSeconds * 1e3 : null;
-  const errorUntil = freshUntil && staleIfErrorSeconds ? freshUntil + staleIfErrorSeconds * 1e3 : null;
-  return {
-    __layercache: 1,
-    kind: options.kind,
-    value: options.value,
-    freshUntil,
-    staleUntil,
-    errorUntil,
-    freshTtlSeconds: freshTtlSeconds ?? null,
-    staleWhileRevalidateSeconds: staleWhileRevalidateSeconds ?? null,
-    staleIfErrorSeconds: staleIfErrorSeconds ?? null
-  };
-}
-function resolveStoredValue(stored, now = Date.now()) {
-  if (!isStoredValueEnvelope(stored)) {
-    return { state: "fresh", value: stored, stored };
-  }
-  if (stored.freshUntil === null || stored.freshUntil > now) {
-    return { state: "fresh", value: unwrapStoredValue(stored), stored, envelope: stored };
-  }
-  if (stored.staleUntil !== null && stored.staleUntil > now) {
-    return { state: "stale-while-revalidate", value: unwrapStoredValue(stored), stored, envelope: stored };
-  }
-  if (stored.errorUntil !== null && stored.errorUntil > now) {
-    return { state: "stale-if-error", value: unwrapStoredValue(stored), stored, envelope: stored };
-  }
-  return { state: "expired", value: null, stored, envelope: stored };
-}
-function unwrapStoredValue(stored) {
-  if (!isStoredValueEnvelope(stored)) {
-    return stored;
-  }
-  if (stored.kind === "empty") {
-    return null;
-  }
-  return stored.value ?? null;
-}
-function remainingStoredTtlSeconds(stored, now = Date.now()) {
-  if (!isStoredValueEnvelope(stored)) {
-    return void 0;
-  }
-  const expiry = maxExpiry(stored);
-  if (expiry === null) {
-    return void 0;
-  }
-  const remainingMs = expiry - now;
-  if (remainingMs <= 0) {
-    return 1;
-  }
-  return Math.max(1, Math.ceil(remainingMs / 1e3));
-}
-function remainingFreshTtlSeconds(stored, now = Date.now()) {
-  if (!isStoredValueEnvelope(stored) || stored.freshUntil === null) {
-    return void 0;
+  incrementLayer(map, layerName) {
+    this.data[map][layerName] = (this.data[map][layerName] ?? 0) + 1;
   }
-  const remainingMs = stored.freshUntil - now;
-  if (remainingMs <= 0) {
-    return 0;
+  /**
+   * 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;
+    }
   }
-  return Math.max(1, Math.ceil(remainingMs / 1e3));
-}
-function refreshStoredEnvelope(stored, now = Date.now()) {
-  if (!isStoredValueEnvelope(stored)) {
-    return stored;
+  reset() {
+    this.data = this.empty();
   }
-  return createStoredValueEnvelope({
-    kind: stored.kind,
-    value: stored.value,
-    freshTtlSeconds: stored.freshTtlSeconds ?? void 0,
-    staleWhileRevalidateSeconds: stored.staleWhileRevalidateSeconds ?? void 0,
-    staleIfErrorSeconds: stored.staleIfErrorSeconds ?? void 0,
-    now
-  });
-}
-function maxExpiry(stored) {
-  const values = [stored.freshUntil, stored.staleUntil, stored.errorUntil].filter(
-    (value) => value !== null
-  );
-  if (values.length === 0) {
-    return null;
+  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 };
   }
-  return Math.max(...values);
-}
-function normalizePositiveSeconds(value) {
-  if (!value || value <= 0) {
-    return void 0;
+  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()
+    };
   }
-  return value;
-}
+};
 
 // src/internal/TtlResolver.ts
 var DEFAULT_NEGATIVE_TTL_SECONDS = 60;
@@ -1077,6 +1649,11 @@ var TagIndex = class {
   async keysForTag(tag) {
     return [...this.tagToKeys.get(tag) ?? /* @__PURE__ */ new Set()];
   }
+  async forEachKeyForTag(tag, visitor) {
+    for (const key of this.tagToKeys.get(tag) ?? /* @__PURE__ */ new Set()) {
+      await visitor(key);
+    }
+  }
   async keysForPrefix(prefix) {
     const node = this.findNode(prefix);
     if (!node) {
@@ -1086,6 +1663,13 @@ var TagIndex = class {
     this.collectFromNode(node, prefix, matches);
     return matches;
   }
+  async forEachKeyForPrefix(prefix, visitor) {
+    const node = this.findNode(prefix);
+    if (!node) {
+      return;
+    }
+    await this.visitFromNode(node, prefix, visitor);
+  }
   async tagsForKey(key) {
     return [...this.keyToTags.get(key) ?? /* @__PURE__ */ new Set()];
   }
@@ -1094,6 +1678,12 @@ var TagIndex = class {
     this.collectPatternMatches(this.root, "", pattern, 0, matches, /* @__PURE__ */ new Set(), 0);
     return [...matches];
   }
+  async forEachKeyMatchingPattern(pattern, visitor) {
+    const matches = await this.matchPattern(pattern);
+    for (const key of matches) {
+      await visitor(key);
+    }
+  }
   async clear() {
     this.tagToKeys.clear();
     this.keyToTags.clear();
@@ -1143,6 +1733,14 @@ var TagIndex = class {
       this.collectFromNode(child, `${prefix}${character}`, matches);
     }
   }
+  async visitFromNode(node, prefix, visitor) {
+    if (node.terminal) {
+      await visitor(prefix);
+    }
+    for (const [character, child] of node.children) {
+      await this.visitFromNode(child, `${prefix}${character}`, visitor);
+    }
+  }
   collectPatternMatches(node, prefix, pattern, patternIndex, matches, visited, depth) {
     if (depth > MAX_PATTERN_RECURSION_DEPTH) {
       return;
@@ -1260,22 +1858,27 @@ var TagIndex = class {
 
 // src/serialization/JsonSerializer.ts
 var DANGEROUS_JSON_KEYS = /* @__PURE__ */ new Set(["__proto__", "prototype", "constructor"]);
+var MAX_SANITIZE_NODES = 1e4;
 var JsonSerializer = class {
   serialize(value) {
     return JSON.stringify(value);
   }
   deserialize(payload) {
     const normalized = Buffer.isBuffer(payload) ? payload.toString("utf8") : payload;
-    return sanitizeJsonValue(JSON.parse(normalized), 0);
+    return sanitizeJsonValue(JSON.parse(normalized), 0, { count: 0 });
   }
 };
 var MAX_SANITIZE_DEPTH = 200;
-function sanitizeJsonValue(value, depth) {
+function sanitizeJsonValue(value, depth, state) {
+  state.count += 1;
+  if (state.count > MAX_SANITIZE_NODES) {
+    throw new Error(`JSON payload exceeds max node count of ${MAX_SANITIZE_NODES}.`);
+  }
   if (depth > MAX_SANITIZE_DEPTH) {
-    return value;
+    throw new Error(`JSON payload exceeds max depth of ${MAX_SANITIZE_DEPTH}.`);
   }
   if (Array.isArray(value)) {
-    return value.map((entry) => sanitizeJsonValue(entry, depth + 1));
+    return value.map((entry) => sanitizeJsonValue(entry, depth + 1, state));
   }
   if (!isPlainObject(value)) {
     return value;
@@ -1285,7 +1888,7 @@ function sanitizeJsonValue(value, depth) {
     if (DANGEROUS_JSON_KEYS.has(key)) {
       continue;
     }
-    sanitized[key] = sanitizeJsonValue(entry, depth + 1);
+    sanitized[key] = sanitizeJsonValue(entry, depth + 1, state);
   }
   return sanitized;
 }
@@ -1335,10 +1938,11 @@ var DEFAULT_SINGLE_FLIGHT_LEASE_MS = 3e4;
 var DEFAULT_SINGLE_FLIGHT_TIMEOUT_MS = 5e3;
 var DEFAULT_SINGLE_FLIGHT_POLL_MS = 50;
 var DEFAULT_BACKGROUND_REFRESH_TIMEOUT_MS = 3e4;
-var MAX_CACHE_KEY_LENGTH = 1024;
-var MAX_PATTERN_LENGTH = 1024;
+var DEFAULT_SNAPSHOT_MAX_BYTES = 16 * 1024 * 1024;
+var DEFAULT_SNAPSHOT_MAX_ENTRIES = 1e4;
+var DEFAULT_SNAPSHOT_IMPORT_BATCH_SIZE = 50;
+var DEFAULT_INVALIDATION_MAX_KEYS = 1e4;
 var DEFAULT_MAX_PROFILE_ENTRIES = 1e5;
-var DANGEROUS_OBJECT_KEYS = /* @__PURE__ */ new Set(["__proto__", "prototype", "constructor"]);
 var DebugLogger = class {
   enabled;
   constructor(enabled) {
@@ -1425,13 +2029,10 @@ var CacheStack = class extends import_node_events.EventEmitter {
   snapshotSerializer = new JsonSerializer();
   backgroundRefreshes = /* @__PURE__ */ new Map();
   layerDegradedUntil = /* @__PURE__ */ new Map();
+  maintenance = new CacheStackMaintenance();
   ttlResolver;
   circuitBreakerManager;
   currentGeneration;
-  writeBehindQueue = [];
-  writeBehindTimer;
-  writeBehindFlushPromise;
-  generationCleanupPromise;
   isDisconnecting = false;
   disconnectPromise;
   /**
@@ -1441,7 +2042,7 @@ var CacheStack = class extends import_node_events.EventEmitter {
    * and no `fetcher` is provided.
    */
   async get(key, fetcher, options) {
-    const normalizedKey = this.qualifyKey(this.validateCacheKey(key));
+    const normalizedKey = this.qualifyKey(validateCacheKey(key));
     this.validateWriteOptions(options);
     await this.awaitStartup("get");
     return this.getPrepared(normalizedKey, fetcher, options);
@@ -1511,7 +2112,7 @@ var CacheStack = class extends import_node_events.EventEmitter {
    * Returns true if the given key exists and is not expired in any layer.
    */
   async has(key) {
-    const normalizedKey = this.qualifyKey(this.validateCacheKey(key));
+    const normalizedKey = this.qualifyKey(validateCacheKey(key));
     await this.awaitStartup("has");
     for (const layer of this.layers) {
       if (this.shouldSkipLayer(layer)) {
@@ -1544,7 +2145,7 @@ var CacheStack = class extends import_node_events.EventEmitter {
    * that has it, or null if the key is not found / has no TTL.
    */
   async ttl(key) {
-    const normalizedKey = this.qualifyKey(this.validateCacheKey(key));
+    const normalizedKey = this.qualifyKey(validateCacheKey(key));
     await this.awaitStartup("ttl");
     for (const layer of this.layers) {
       if (this.shouldSkipLayer(layer)) {
@@ -1566,7 +2167,7 @@ var CacheStack = class extends import_node_events.EventEmitter {
    * Stores a value in all cache layers. Overwrites any existing value.
    */
   async set(key, value, options) {
-    const normalizedKey = this.qualifyKey(this.validateCacheKey(key));
+    const normalizedKey = this.qualifyKey(validateCacheKey(key));
     this.validateWriteOptions(options);
     await this.awaitStartup("set");
     await this.storeEntry(normalizedKey, "value", value, options);
@@ -1575,7 +2176,7 @@ var CacheStack = class extends import_node_events.EventEmitter {
    * Deletes the key from all layers and publishes an invalidation message.
    */
   async delete(key) {
-    const normalizedKey = this.qualifyKey(this.validateCacheKey(key));
+    const normalizedKey = this.qualifyKey(validateCacheKey(key));
     await this.awaitStartup("delete");
     await this.deleteKeys([normalizedKey]);
     await this.publishInvalidation({
@@ -1587,6 +2188,7 @@ var CacheStack = class extends import_node_events.EventEmitter {
   }
   async clear() {
     await this.awaitStartup("clear");
+    this.maintenance.beginClearEpoch();
     await Promise.all(this.layers.map((layer) => layer.clear()));
     await this.tagIndex.clear();
     this.ttlResolver.clearProfiles();
@@ -1603,7 +2205,7 @@ var CacheStack = class extends import_node_events.EventEmitter {
       return;
     }
     await this.awaitStartup("mdelete");
-    const normalizedKeys = keys.map((k) => this.validateCacheKey(k));
+    const normalizedKeys = keys.map((k) => validateCacheKey(k));
     const cacheKeys = normalizedKeys.map((key) => this.qualifyKey(key));
     await this.deleteKeys(cacheKeys);
     await this.publishInvalidation({
@@ -1620,7 +2222,7 @@ var CacheStack = class extends import_node_events.EventEmitter {
     }
     const normalizedEntries = entries.map((entry) => ({
       ...entry,
-      key: this.qualifyKey(this.validateCacheKey(entry.key))
+      key: this.qualifyKey(validateCacheKey(entry.key))
     }));
     normalizedEntries.forEach((entry) => this.validateWriteOptions(entry.options));
     const canFastPath = normalizedEntries.every((entry) => entry.fetch === void 0 && entry.options === void 0);
@@ -1629,7 +2231,7 @@ var CacheStack = class extends import_node_events.EventEmitter {
       const pendingReads = /* @__PURE__ */ new Map();
       return Promise.all(
         normalizedEntries.map((entry) => {
-          const optionsSignature = this.serializeOptions(entry.options);
+          const optionsSignature = serializeOptions(entry.options);
           const existing = pendingReads.get(entry.key);
           if (!existing) {
             const promise = this.getPrepared(entry.key, entry.fetch, entry.options);
@@ -1698,7 +2300,7 @@ var CacheStack = class extends import_node_events.EventEmitter {
     this.assertActive("mset");
     const normalizedEntries = entries.map((entry) => ({
       ...entry,
-      key: this.qualifyKey(this.validateCacheKey(entry.key))
+      key: this.qualifyKey(validateCacheKey(entry.key))
     }));
     normalizedEntries.forEach((entry) => this.validateWriteOptions(entry.options));
     await this.awaitStartup("mset");
@@ -1741,7 +2343,7 @@ var CacheStack = class extends import_node_events.EventEmitter {
    */
   wrap(prefix, fetcher, options = {}) {
     return (...args) => {
-      const suffix = options.keyResolver ? options.keyResolver(...args) : args.map((argument) => this.serializeKeyPart(argument)).join(":");
+      const suffix = options.keyResolver ? options.keyResolver(...args) : args.map((argument) => serializeKeyPart(argument)).join(":");
       const key = suffix.length > 0 ? `${prefix}:${suffix}` : prefix;
       return this.get(key, () => fetcher(...args), options);
     };
@@ -1751,11 +2353,13 @@ var CacheStack = class extends import_node_events.EventEmitter {
    * `prefix:`. Useful for multi-tenant or module-level isolation.
    */
   namespace(prefix) {
+    validateNamespaceKey(prefix);
     return new CacheNamespace(this, prefix);
   }
   async invalidateByTag(tag) {
+    validateTag(tag);
     await this.awaitStartup("invalidateByTag");
-    const keys = await this.tagIndex.keysForTag(tag);
+    const keys = await this.collectKeysForTag(tag);
     await this.deleteKeys(keys);
     await this.publishInvalidation({ scope: "keys", keys, sourceId: this.instanceId, operation: "invalidate" });
   }
@@ -1763,23 +2367,28 @@ var CacheStack = class extends import_node_events.EventEmitter {
     if (tags.length === 0) {
       return;
     }
+    validateTags(tags);
     await this.awaitStartup("invalidateByTags");
-    const keysByTag = await Promise.all(tags.map((tag) => this.tagIndex.keysForTag(tag)));
+    const keysByTag = await Promise.all(tags.map((tag) => this.collectKeysForTag(tag)));
     const keys = mode === "all" ? this.intersectKeys(keysByTag) : [...new Set(keysByTag.flat())];
+    this.assertWithinInvalidationKeyLimit(keys.length);
     await this.deleteKeys(keys);
     await this.publishInvalidation({ scope: "keys", keys, sourceId: this.instanceId, operation: "invalidate" });
   }
   async invalidateByPattern(pattern) {
-    this.validatePattern(pattern);
+    validatePattern(pattern);
     await this.awaitStartup("invalidateByPattern");
-    const keys = await this.keyDiscovery.collectKeysMatchingPattern(this.qualifyPattern(pattern));
+    const keys = await this.keyDiscovery.collectKeysMatchingPattern(
+      this.qualifyPattern(pattern),
+      this.invalidationMaxKeys()
+    );
     await this.deleteKeys(keys);
     await this.publishInvalidation({ scope: "keys", keys, sourceId: this.instanceId, operation: "invalidate" });
   }
   async invalidateByPrefix(prefix) {
     await this.awaitStartup("invalidateByPrefix");
-    const qualifiedPrefix = this.qualifyKey(this.validateCacheKey(prefix));
-    const keys = await this.keyDiscovery.collectKeysWithPrefix(qualifiedPrefix);
+    const qualifiedPrefix = this.qualifyKey(validateCacheKey(prefix));
+    const keys = await this.keyDiscovery.collectKeysWithPrefix(qualifiedPrefix, this.invalidationMaxKeys());
     await this.deleteKeys(keys);
     await this.publishInvalidation({ scope: "keys", keys, sourceId: this.instanceId, operation: "invalidate" });
   }
@@ -1837,9 +2446,15 @@ var CacheStack = class extends import_node_events.EventEmitter {
   bumpGeneration(nextGeneration) {
     const current = this.currentGeneration ?? 0;
     const previousGeneration = this.currentGeneration;
-    this.currentGeneration = nextGeneration ?? current + 1;
-    if (previousGeneration !== void 0 && previousGeneration !== this.currentGeneration && this.shouldCleanupGenerations()) {
-      this.scheduleGenerationCleanup(previousGeneration);
+    const updatedGeneration = nextGeneration ?? current + 1;
+    const generationToCleanup = resolveGenerationCleanupTarget({
+      previousGeneration,
+      nextGeneration: updatedGeneration,
+      generationCleanup: this.options.generationCleanup
+    });
+    this.currentGeneration = updatedGeneration;
+    if (generationToCleanup !== null) {
+      this.scheduleGenerationCleanup(generationToCleanup);
     }
     return this.currentGeneration;
   }
@@ -1849,7 +2464,7 @@ var CacheStack = class extends import_node_events.EventEmitter {
    * Returns `null` if the key does not exist in any layer.
    */
   async inspect(key) {
-    const userKey = this.validateCacheKey(key);
+    const userKey = validateCacheKey(key);
     const normalizedKey = this.qualifyKey(userKey);
     await this.awaitStartup("inspect");
     const foundInLayers = [];
@@ -1886,50 +2501,79 @@ var CacheStack = class extends import_node_events.EventEmitter {
   }
   async exportState() {
     await this.awaitStartup("exportState");
-    const exported = /* @__PURE__ */ new Map();
-    for (const layer of this.layers) {
-      if (!layer.keys) {
-        continue;
-      }
-      const keys = await layer.keys();
-      for (const key of keys) {
-        const exportedKey = this.stripQualifiedKey(key);
-        if (exported.has(exportedKey)) {
-          continue;
-        }
-        const stored = await this.readLayerEntry(layer, key);
-        if (stored === null) {
-          continue;
-        }
-        exported.set(exportedKey, {
-          key: exportedKey,
-          value: stored,
-          ttl: remainingStoredTtlSeconds(stored)
-        });
-      }
-    }
-    return [...exported.values()];
+    const entries = [];
+    await this.visitExportEntries(this.snapshotMaxEntries(), async (entry) => {
+      entries.push(entry);
+    });
+    return entries;
   }
   async importState(entries) {
     await this.awaitStartup("importState");
-    await Promise.all(
-      entries.map(async (entry) => {
-        const qualifiedKey = this.qualifyKey(entry.key);
-        await Promise.all(this.layers.map((layer) => layer.set(qualifiedKey, entry.value, entry.ttl)));
-        await this.tagIndex.touch(qualifiedKey);
-      })
-    );
+    const normalizedEntries = entries.map((entry) => ({
+      key: this.qualifyKey(validateCacheKey(entry.key)),
+      value: entry.value,
+      ttl: entry.ttl
+    }));
+    for (let index = 0; index < normalizedEntries.length; index += DEFAULT_SNAPSHOT_IMPORT_BATCH_SIZE) {
+      const batch = normalizedEntries.slice(index, index + DEFAULT_SNAPSHOT_IMPORT_BATCH_SIZE);
+      await Promise.all(
+        batch.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) {
     this.assertActive("persistToFile");
-    const snapshot = await this.exportState();
     const { promises: fs2 } = await import("fs");
-    await fs2.writeFile(await this.validateSnapshotFilePath(filePath), JSON.stringify(snapshot, null, 2), "utf8");
+    const path = await import("path");
+    const targetPath = await validateSnapshotFilePath(filePath, "write", this.options.snapshotBaseDir);
+    const tempPath = path.join(
+      path.dirname(targetPath),
+      `.layercache-${process.pid}-${Date.now()}-${Math.random().toString(36).slice(2)}.tmp`
+    );
+    let handle;
+    try {
+      handle = await fs2.open(tempPath, "wx");
+      const openedHandle = handle;
+      await openedHandle.writeFile("[", "utf8");
+      let wroteAny = false;
+      await this.visitExportEntries(this.snapshotMaxEntries(), async (entry) => {
+        await openedHandle.writeFile(wroteAny ? ",\n" : "\n", "utf8");
+        await openedHandle.writeFile(JSON.stringify(entry, null, 2), "utf8");
+        wroteAny = true;
+      });
+      await openedHandle.writeFile(wroteAny ? "\n]" : "]", "utf8");
+      await openedHandle.close();
+      handle = void 0;
+      await fs2.rename(tempPath, targetPath);
+    } catch (error) {
+      await handle?.close().catch(() => void 0);
+      await fs2.unlink(tempPath).catch(() => void 0);
+      throw error;
+    }
   }
   async restoreFromFile(filePath) {
     this.assertActive("restoreFromFile");
-    const { promises: fs2 } = await import("fs");
-    const raw = await fs2.readFile(await this.validateSnapshotFilePath(filePath), "utf8");
+    const { promises: fs2, constants } = await import("fs");
+    const validatedPath = await validateSnapshotFilePath(filePath, "read", this.options.snapshotBaseDir);
+    const handle = await fs2.open(validatedPath, constants.O_RDONLY | (constants.O_NOFOLLOW ?? 0));
+    const snapshotMaxBytes = this.snapshotMaxBytes();
+    let raw;
+    try {
+      if (snapshotMaxBytes !== false) {
+        const stat = await handle.stat();
+        if (stat.size > snapshotMaxBytes) {
+          throw new Error(
+            `Snapshot file exceeds snapshotMaxBytes limit (${stat.size} bytes > ${snapshotMaxBytes} bytes).`
+          );
+        }
+      }
+      raw = await readUtf8HandleWithLimit(handle, snapshotMaxBytes);
+    } finally {
+      await handle.close();
+    }
     let parsed;
     try {
       parsed = JSON.parse(raw);
@@ -1954,12 +2598,9 @@ var CacheStack = class extends import_node_events.EventEmitter {
         await this.startup;
         await this.unsubscribeInvalidation?.();
         await this.flushWriteBehindQueue();
-        await this.generationCleanupPromise;
+        await this.maintenance.waitForGenerationCleanup();
         await Promise.allSettled([...this.backgroundRefreshes.values()]);
-        if (this.writeBehindTimer) {
-          clearInterval(this.writeBehindTimer);
-          this.writeBehindTimer = void 0;
-        }
+        this.maintenance.disposeWriteBehindTimer();
         await Promise.allSettled(this.layers.map((layer) => layer.dispose?.() ?? Promise.resolve()));
       })();
     }
@@ -1973,14 +2614,14 @@ var CacheStack = class extends import_node_events.EventEmitter {
       await this.handleInvalidationMessage(message);
     });
   }
-  async fetchWithGuards(key, fetcher, options) {
+  async fetchWithGuards(key, fetcher, options, expectedClearEpoch, expectedKeyEpoch) {
     const fetchTask = async () => {
       const secondHit = await this.readFromLayers(key, options, "fresh-only");
       if (secondHit.found) {
         this.metricsCollector.increment("hits");
         return secondHit.value;
       }
-      return this.fetchAndPopulate(key, fetcher, options);
+      return this.fetchAndPopulate(key, fetcher, options, expectedClearEpoch, expectedKeyEpoch);
     };
     const singleFlightTask = async () => {
       if (!this.options.singleFlightCoordinator) {
@@ -1990,7 +2631,7 @@ var CacheStack = class extends import_node_events.EventEmitter {
         key,
         this.resolveSingleFlightOptions(),
         fetchTask,
-        () => this.waitForFreshValue(key, fetcher, options)
+        () => this.waitForFreshValue(key, fetcher, options, expectedClearEpoch, expectedKeyEpoch)
       );
     };
     if (this.options.stampedePrevention === false) {
@@ -1998,7 +2639,7 @@ var CacheStack = class extends import_node_events.EventEmitter {
     }
     return this.stampedeGuard.execute(key, singleFlightTask);
   }
-  async waitForFreshValue(key, fetcher, options) {
+  async waitForFreshValue(key, fetcher, options, expectedClearEpoch, expectedKeyEpoch) {
     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;
@@ -2012,9 +2653,9 @@ var CacheStack = class extends import_node_events.EventEmitter {
       }
       await this.sleep(pollIntervalMs);
     }
-    return this.fetchAndPopulate(key, fetcher, options);
+    return this.fetchAndPopulate(key, fetcher, options, expectedClearEpoch, expectedKeyEpoch);
   }
-  async fetchAndPopulate(key, fetcher, options) {
+  async fetchAndPopulate(key, fetcher, options, expectedClearEpoch, expectedKeyEpoch) {
     this.circuitBreakerManager.assertClosed(key, options?.circuitBreaker ?? this.options.circuitBreaker);
     this.metricsCollector.increment("fetches");
     const fetchStart = Date.now();
@@ -2035,6 +2676,16 @@ var CacheStack = class extends import_node_events.EventEmitter {
       if (!this.shouldNegativeCache(options)) {
         return null;
       }
+      if (this.maintenance.isWriteOutdated(key, expectedClearEpoch, expectedKeyEpoch)) {
+        this.logger.debug?.("skip-negative-store-after-invalidation", {
+          key,
+          expectedClearEpoch,
+          clearEpoch: this.maintenance.currentClearEpoch(),
+          expectedKeyEpoch,
+          keyEpoch: this.maintenance.currentKeyEpoch(key)
+        });
+        return null;
+      }
       await this.storeEntry(key, "empty", null, options);
       return null;
     }
@@ -2047,11 +2698,26 @@ var CacheStack = class extends import_node_events.EventEmitter {
         this.logger.warn?.("shouldCache-error", { key, error: this.formatError(error) });
       }
     }
+    if (this.maintenance.isWriteOutdated(key, expectedClearEpoch, expectedKeyEpoch)) {
+      this.logger.debug?.("skip-store-after-invalidation", {
+        key,
+        expectedClearEpoch,
+        clearEpoch: this.maintenance.currentClearEpoch(),
+        expectedKeyEpoch,
+        keyEpoch: this.maintenance.currentKeyEpoch(key)
+      });
+      return fetched;
+    }
     await this.storeEntry(key, "value", fetched, options);
     return fetched;
   }
   async storeEntry(key, kind, value, options) {
+    const clearEpoch = this.maintenance.currentClearEpoch();
+    const keyEpoch = this.maintenance.currentKeyEpoch(key);
     await this.writeAcrossLayers(key, kind, value, options);
+    if (this.maintenance.isWriteOutdated(key, clearEpoch, keyEpoch)) {
+      return;
+    }
     if (options?.tags) {
       await this.tagIndex.track(key, options.tags);
     } else {
@@ -2066,6 +2732,8 @@ var CacheStack = class extends import_node_events.EventEmitter {
   }
   async writeBatch(entries) {
     const now = Date.now();
+    const clearEpoch = this.maintenance.currentClearEpoch();
+    const entryEpochs = new Map(entries.map((entry) => [entry.key, this.maintenance.currentKeyEpoch(entry.key)]));
     const entriesByLayer = /* @__PURE__ */ new Map();
     const immediateOperations = [];
     const deferredOperations = [];
@@ -2082,12 +2750,21 @@ var CacheStack = class extends import_node_events.EventEmitter {
     }
     for (const [layer, layerEntries] of entriesByLayer.entries()) {
       const operation = async () => {
+        if (clearEpoch !== this.maintenance.currentClearEpoch()) {
+          return;
+        }
+        const activeEntries = layerEntries.filter(
+          (entry) => (entryEpochs.get(entry.key) ?? 0) === this.maintenance.currentKeyEpoch(entry.key)
+        );
+        if (activeEntries.length === 0) {
+          return;
+        }
         try {
           if (layer.setMany) {
-            await layer.setMany(layerEntries);
+            await layer.setMany(activeEntries);
             return;
           }
-          await Promise.all(layerEntries.map((entry) => layer.set(entry.key, entry.value, entry.ttl)));
+          await Promise.all(activeEntries.map((entry) => layer.set(entry.key, entry.value, entry.ttl)));
         } catch (error) {
           await this.handleLayerFailure(layer, "write", error);
         }
@@ -2100,7 +2777,13 @@ var CacheStack = class extends import_node_events.EventEmitter {
     }
     await this.executeLayerOperations(immediateOperations, { key: "batch", action: "mset" });
     await Promise.all(deferredOperations.map((operation) => this.enqueueWriteBehind(operation)));
+    if (clearEpoch !== this.maintenance.currentClearEpoch()) {
+      return;
+    }
     for (const entry of entries) {
+      if (this.maintenance.isWriteOutdated(entry.key, clearEpoch, entryEpochs.get(entry.key))) {
+        continue;
+      }
       if (entry.options?.tags) {
         await this.tagIndex.track(entry.key, entry.options.tags);
       } else {
@@ -2202,10 +2885,15 @@ var CacheStack = class extends import_node_events.EventEmitter {
   }
   async writeAcrossLayers(key, kind, value, options) {
     const now = Date.now();
+    const clearEpoch = this.maintenance.currentClearEpoch();
+    const keyEpoch = this.maintenance.currentKeyEpoch(key);
     const immediateOperations = [];
     const deferredOperations = [];
     for (const layer of this.layers) {
       const operation = async () => {
+        if (this.maintenance.isWriteOutdated(key, clearEpoch, keyEpoch)) {
+          return;
+        }
         if (this.shouldSkipLayer(layer)) {
           return;
         }
@@ -2266,13 +2954,18 @@ var CacheStack = class extends import_node_events.EventEmitter {
     return options?.negativeCache ?? this.options.negativeCaching ?? false;
   }
   scheduleBackgroundRefresh(key, fetcher, options) {
-    if (this.isDisconnecting || this.backgroundRefreshes.has(key)) {
+    if (!shouldStartBackgroundRefresh({
+      isDisconnecting: this.isDisconnecting,
+      hasRefreshInFlight: this.backgroundRefreshes.has(key)
+    })) {
       return;
     }
+    const clearEpoch = this.maintenance.currentClearEpoch();
+    const keyEpoch = this.maintenance.currentKeyEpoch(key);
     const refresh = (async () => {
       this.metricsCollector.increment("refreshes");
       try {
-        await this.runBackgroundRefresh(key, fetcher, options);
+        await this.runBackgroundRefresh(key, fetcher, options, clearEpoch, keyEpoch);
       } catch (error) {
         this.metricsCollector.increment("refreshErrors");
         this.logger.debug?.("refresh-error", { key, error: this.formatError(error) });
@@ -2282,14 +2975,16 @@ var CacheStack = class extends import_node_events.EventEmitter {
     })();
     this.backgroundRefreshes.set(key, refresh);
   }
-  async runBackgroundRefresh(key, fetcher, options) {
+  async runBackgroundRefresh(key, fetcher, options, expectedClearEpoch, expectedKeyEpoch) {
     const timeoutMs = this.options.backgroundRefreshTimeoutMs ?? DEFAULT_BACKGROUND_REFRESH_TIMEOUT_MS;
     await this.fetchWithGuards(
       key,
       () => this.withTimeout(fetcher(), timeoutMs, () => {
         return new Error(`Background refresh timed out after ${timeoutMs}ms for key "${key}".`);
       }),
-      options
+      options,
+      expectedClearEpoch,
+      expectedKeyEpoch
     );
   }
   resolveSingleFlightOptions() {
@@ -2304,6 +2999,7 @@ var CacheStack = class extends import_node_events.EventEmitter {
     if (keys.length === 0) {
       return;
     }
+    this.maintenance.bumpKeyEpochs(keys);
     await this.deleteKeysFromLayers(this.layers, keys);
     for (const key of keys) {
       await this.tagIndex.remove(key);
@@ -2326,21 +3022,22 @@ var CacheStack = class extends import_node_events.EventEmitter {
       return;
     }
     const localLayers = this.layers.filter((layer) => layer.isLocal);
-    if (localLayers.length === 0) {
-      return;
-    }
     if (message.scope === "clear") {
+      this.maintenance.beginClearEpoch();
       await Promise.all(localLayers.map((layer) => layer.clear()));
       await this.tagIndex.clear();
       this.ttlResolver.clearProfiles();
+      this.circuitBreakerManager.clear();
       return;
     }
     const keys = message.keys ?? [];
+    this.maintenance.bumpKeyEpochs(keys);
     await this.deleteKeysFromLayers(localLayers, keys);
     if (message.operation !== "write") {
       for (const key of keys) {
         await this.tagIndex.remove(key);
         this.ttlResolver.deleteProfile(key);
+        this.circuitBreakerManager.delete(key);
       }
     }
   }
@@ -2392,35 +3089,22 @@ var CacheStack = class extends import_node_events.EventEmitter {
   shouldBroadcastL1Invalidation() {
     return this.options.broadcastL1Invalidation ?? this.options.publishSetInvalidation ?? false;
   }
-  shouldCleanupGenerations() {
-    return Boolean(this.options.generationCleanup);
-  }
-  generationCleanupBatchSize() {
-    const configured = typeof this.options.generationCleanup === "object" ? this.options.generationCleanup.batchSize : void 0;
-    return configured ?? 500;
-  }
   scheduleGenerationCleanup(generation) {
-    const task = (this.generationCleanupPromise ?? Promise.resolve()).then(() => this.cleanupGeneration(generation)).catch((error) => {
-      this.logger.warn?.("generation-cleanup-error", {
-        generation,
-        error: this.formatError(error)
-      });
-    });
-    this.generationCleanupPromise = task.finally(() => {
-      if (this.generationCleanupPromise === task) {
-        this.generationCleanupPromise = void 0;
+    this.maintenance.scheduleGenerationCleanup(
+      generation,
+      async (generationToClean) => this.cleanupGeneration(generationToClean),
+      (failedGeneration, error) => {
+        this.logger.warn?.("generation-cleanup-error", {
+          generation: failedGeneration,
+          error: this.formatError(error)
+        });
       }
-    });
+    );
   }
   async cleanupGeneration(generation) {
     const prefix = `v${generation}:`;
     const keys = await this.keyDiscovery.collectKeysWithPrefix(prefix);
-    if (keys.length === 0) {
-      return;
-    }
-    const batchSize = this.generationCleanupBatchSize();
-    for (let index = 0; index < keys.length; index += batchSize) {
-      const batch = keys.slice(index, index + batchSize);
+    for (const batch of planGenerationCleanupBatches(keys, this.options.generationCleanup)) {
       await this.deleteKeys(batch);
       await this.publishInvalidation({
         scope: "keys",
@@ -2431,58 +3115,34 @@ var CacheStack = class extends import_node_events.EventEmitter {
     }
   }
   initializeWriteBehind(options) {
-    if (this.options.writeStrategy !== "write-behind") {
-      return;
-    }
-    const flushIntervalMs = options?.flushIntervalMs;
-    if (!flushIntervalMs || flushIntervalMs <= 0) {
-      return;
-    }
-    this.writeBehindTimer = setInterval(() => {
-      void this.flushWriteBehindQueue();
-    }, flushIntervalMs);
-    this.writeBehindTimer.unref?.();
+    this.maintenance.initializeWriteBehindTimer(
+      this.options.writeStrategy,
+      options,
+      this.flushWriteBehindQueue.bind(this)
+    );
   }
   shouldWriteBehind(layer) {
     return this.options.writeStrategy === "write-behind" && !layer.isLocal;
   }
   async enqueueWriteBehind(operation) {
-    this.writeBehindQueue.push(operation);
-    const batchSize = this.options.writeBehind?.batchSize ?? 100;
-    const maxQueueSize = this.options.writeBehind?.maxQueueSize ?? batchSize * 10;
-    if (this.writeBehindQueue.length >= batchSize) {
-      await this.flushWriteBehindQueue();
-      return;
-    }
-    if (this.writeBehindQueue.length >= maxQueueSize) {
-      await this.flushWriteBehindQueue();
-    }
+    await this.maintenance.enqueueWriteBehind(operation, this.options.writeBehind, this.runWriteBehindBatch.bind(this));
   }
   async flushWriteBehindQueue() {
-    if (this.writeBehindFlushPromise || this.writeBehindQueue.length === 0) {
-      await this.writeBehindFlushPromise;
+    await this.maintenance.flushWriteBehindQueue(this.options.writeBehind, this.runWriteBehindBatch.bind(this));
+  }
+  async runWriteBehindBatch(batch) {
+    const results = await Promise.allSettled(batch.map((operation) => operation()));
+    const failures = results.filter((result) => result.status === "rejected");
+    if (failures.length === 0) {
       return;
     }
-    const batchSize = this.options.writeBehind?.batchSize ?? 100;
-    const batch = this.writeBehindQueue.splice(0, batchSize);
-    this.writeBehindFlushPromise = (async () => {
-      const results = await Promise.allSettled(batch.map((operation) => operation()));
-      const failures = results.filter((result) => result.status === "rejected");
-      if (failures.length > 0) {
-        this.metricsCollector.increment("writeFailures", failures.length);
-        this.logger.error?.("write-behind-flush-failure", {
-          failed: failures.length,
-          total: batch.length,
-          errors: failures.map((failure) => this.formatError(failure.reason))
-        });
-        this.emitError("write-behind", { failed: failures.length, total: batch.length });
-      }
-    })();
-    await this.writeBehindFlushPromise;
-    this.writeBehindFlushPromise = void 0;
-    if (this.writeBehindQueue.length > 0) {
-      await this.flushWriteBehindQueue();
-    }
+    this.metricsCollector.increment("writeFailures", failures.length);
+    this.logger.error?.("write-behind-flush-failure", {
+      failed: failures.length,
+      total: batch.length,
+      errors: failures.map((failure) => this.formatError(failure.reason))
+    });
+    this.emitError("write-behind", { failed: failures.length, total: batch.length });
   }
   buildLayerSetEntry(layer, key, kind, value, options, now) {
     const freshTtl = this.resolveFreshTtl(key, layer.name, kind, options, layer.defaultTtl, value);
@@ -2512,32 +3172,17 @@ var CacheStack = class extends import_node_events.EventEmitter {
       return [];
     }
     const [firstGroup, ...rest] = groups;
-    if (!firstGroup) {
-      return [];
-    }
     const restSets = rest.map((group) => new Set(group));
     return [...new Set(firstGroup)].filter((key) => restSets.every((group) => group.has(key)));
   }
   qualifyKey(key) {
-    const prefix = this.generationPrefix();
-    return prefix ? `${prefix}${key}` : key;
+    return qualifyGenerationKey(key, this.currentGeneration);
   }
   qualifyPattern(pattern) {
-    const prefix = this.generationPrefix();
-    return prefix ? `${prefix}${pattern}` : pattern;
+    return qualifyGenerationPattern(pattern, this.currentGeneration);
   }
   stripQualifiedKey(key) {
-    const prefix = this.generationPrefix();
-    if (!prefix || !key.startsWith(prefix)) {
-      return key;
-    }
-    return key.slice(prefix.length);
-  }
-  generationPrefix() {
-    if (this.currentGeneration === void 0) {
-      return "";
-    }
-    return `v${this.currentGeneration}:`;
+    return stripGenerationPrefix(key, this.currentGeneration);
   }
   async deleteKeysFromLayers(layers, keys) {
     await Promise.all(
@@ -2572,118 +3217,50 @@ var CacheStack = class extends import_node_events.EventEmitter {
     if (this.options.stampedePrevention === false && this.options.singleFlightCoordinator) {
       throw new Error("singleFlightCoordinator requires stampedePrevention to remain enabled.");
     }
-    this.validateLayerNumberOption("negativeTtl", this.options.negativeTtl);
-    this.validateLayerNumberOption("staleWhileRevalidate", this.options.staleWhileRevalidate);
-    this.validateLayerNumberOption("staleIfError", this.options.staleIfError);
-    this.validateLayerNumberOption("ttlJitter", this.options.ttlJitter);
-    this.validateLayerNumberOption("refreshAhead", this.options.refreshAhead);
-    this.validatePositiveNumber("singleFlightLeaseMs", this.options.singleFlightLeaseMs);
-    this.validatePositiveNumber("singleFlightTimeoutMs", this.options.singleFlightTimeoutMs);
-    this.validatePositiveNumber("singleFlightPollMs", this.options.singleFlightPollMs);
-    this.validatePositiveNumber("singleFlightRenewIntervalMs", this.options.singleFlightRenewIntervalMs);
-    this.validatePositiveNumber("backgroundRefreshTimeoutMs", this.options.backgroundRefreshTimeoutMs);
-    this.validateRateLimitOptions("fetcherRateLimit", this.options.fetcherRateLimit);
-    this.validateAdaptiveTtlOptions(this.options.adaptiveTtl);
-    this.validateCircuitBreakerOptions(this.options.circuitBreaker);
+    validateLayerNumberOption("negativeTtl", this.options.negativeTtl);
+    validateLayerNumberOption("staleWhileRevalidate", this.options.staleWhileRevalidate);
+    validateLayerNumberOption("staleIfError", this.options.staleIfError);
+    validateLayerNumberOption("ttlJitter", this.options.ttlJitter);
+    validateLayerNumberOption("refreshAhead", this.options.refreshAhead);
+    validatePositiveNumber("singleFlightLeaseMs", this.options.singleFlightLeaseMs);
+    validatePositiveNumber("singleFlightTimeoutMs", this.options.singleFlightTimeoutMs);
+    validatePositiveNumber("singleFlightPollMs", this.options.singleFlightPollMs);
+    validatePositiveNumber("singleFlightRenewIntervalMs", this.options.singleFlightRenewIntervalMs);
+    validatePositiveNumber("backgroundRefreshTimeoutMs", this.options.backgroundRefreshTimeoutMs);
+    if (this.options.snapshotMaxBytes !== false) {
+      validatePositiveNumber("snapshotMaxBytes", this.options.snapshotMaxBytes);
+    }
+    if (this.options.snapshotMaxEntries !== false) {
+      validatePositiveNumber("snapshotMaxEntries", this.options.snapshotMaxEntries);
+    }
+    if (this.options.invalidationMaxKeys !== false) {
+      validatePositiveNumber("invalidationMaxKeys", this.options.invalidationMaxKeys);
+    }
+    validateRateLimitOptions("fetcherRateLimit", this.options.fetcherRateLimit);
+    validateAdaptiveTtlOptions(this.options.adaptiveTtl);
+    validateCircuitBreakerOptions(this.options.circuitBreaker);
     if (typeof this.options.generationCleanup === "object") {
-      this.validatePositiveNumber("generationCleanup.batchSize", this.options.generationCleanup.batchSize);
+      validatePositiveNumber("generationCleanup.batchSize", this.options.generationCleanup.batchSize);
     }
     if (this.options.generation !== void 0) {
-      this.validateNonNegativeNumber("generation", this.options.generation);
-    }
-  }
-  validateWriteOptions(options) {
-    if (!options) {
-      return;
-    }
-    this.validateLayerNumberOption("options.ttl", options.ttl);
-    this.validateLayerNumberOption("options.negativeTtl", options.negativeTtl);
-    this.validateLayerNumberOption("options.staleWhileRevalidate", options.staleWhileRevalidate);
-    this.validateLayerNumberOption("options.staleIfError", options.staleIfError);
-    this.validateLayerNumberOption("options.ttlJitter", options.ttlJitter);
-    this.validateLayerNumberOption("options.refreshAhead", options.refreshAhead);
-    this.validateTtlPolicy("options.ttlPolicy", options.ttlPolicy);
-    this.validateAdaptiveTtlOptions(options.adaptiveTtl);
-    this.validateCircuitBreakerOptions(options.circuitBreaker);
-    this.validateRateLimitOptions("options.fetcherRateLimit", options.fetcherRateLimit);
-  }
-  validateLayerNumberOption(name, value) {
-    if (value === void 0) {
-      return;
-    }
-    if (typeof value === "number") {
-      this.validateNonNegativeNumber(name, value);
-      return;
-    }
-    for (const [layerName, layerValue] of Object.entries(value)) {
-      if (layerValue === void 0) {
-        continue;
-      }
-      this.validateNonNegativeNumber(`${name}.${layerName}`, layerValue);
-    }
-  }
-  validatePositiveNumber(name, value) {
-    if (value === void 0) {
-      return;
-    }
-    if (!Number.isFinite(value) || value <= 0) {
-      throw new Error(`${name} must be a positive finite number.`);
-    }
-  }
-  validateRateLimitOptions(name, options) {
-    if (!options) {
-      return;
-    }
-    this.validatePositiveNumber(`${name}.maxConcurrent`, options.maxConcurrent);
-    this.validatePositiveNumber(`${name}.intervalMs`, options.intervalMs);
-    this.validatePositiveNumber(`${name}.maxPerInterval`, options.maxPerInterval);
-    if (options.scope && !["global", "key", "fetcher"].includes(options.scope)) {
-      throw new Error(`${name}.scope must be one of "global", "key", or "fetcher".`);
-    }
-    if (options.bucketKey !== void 0 && options.bucketKey.length === 0) {
-      throw new Error(`${name}.bucketKey must not be empty.`);
-    }
-  }
-  validateNonNegativeNumber(name, value) {
-    if (!Number.isFinite(value) || value < 0) {
-      throw new Error(`${name} must be a non-negative finite number.`);
-    }
-  }
-  validateCacheKey(key) {
-    if (key.length === 0) {
-      throw new Error("Cache key must not be empty.");
-    }
-    if (key.length > MAX_CACHE_KEY_LENGTH) {
-      throw new Error(`Cache key length must be at most ${MAX_CACHE_KEY_LENGTH} characters.`);
-    }
-    if (/[\u0000-\u001F\u007F]/.test(key)) {
-      throw new Error("Cache key contains unsupported control characters.");
-    }
-    if (/[\uD800-\uDFFF]/.test(key)) {
-      throw new Error("Cache key contains unsupported surrogate code points.");
-    }
-    return key;
-  }
-  validatePattern(pattern) {
-    if (pattern.length === 0) {
-      throw new Error("Pattern must not be empty.");
-    }
-    if (pattern.length > MAX_PATTERN_LENGTH) {
-      throw new Error(`Pattern length must be at most ${MAX_PATTERN_LENGTH} characters.`);
-    }
-    if (/[\u0000-\u001F\u007F]/.test(pattern)) {
-      throw new Error("Pattern contains unsupported control characters.");
+      validateNonNegativeNumber("generation", this.options.generation);
     }
   }
-  validateTtlPolicy(name, policy) {
-    if (!policy || typeof policy === "function" || policy === "until-midnight" || policy === "next-hour") {
-      return;
-    }
-    if ("alignTo" in policy) {
-      this.validatePositiveNumber(`${name}.alignTo`, policy.alignTo);
+  validateWriteOptions(options) {
+    if (!options) {
       return;
     }
-    throw new Error(`${name} is invalid.`);
+    validateLayerNumberOption("options.ttl", options.ttl);
+    validateLayerNumberOption("options.negativeTtl", options.negativeTtl);
+    validateLayerNumberOption("options.staleWhileRevalidate", options.staleWhileRevalidate);
+    validateLayerNumberOption("options.staleIfError", options.staleIfError);
+    validateLayerNumberOption("options.ttlJitter", options.ttlJitter);
+    validateLayerNumberOption("options.refreshAhead", options.refreshAhead);
+    validateTtlPolicy("options.ttlPolicy", options.ttlPolicy);
+    validateAdaptiveTtlOptions(options.adaptiveTtl);
+    validateCircuitBreakerOptions(options.circuitBreaker);
+    validateRateLimitOptions("options.fetcherRateLimit", options.fetcherRateLimit);
+    validateTags(options.tags);
   }
   assertActive(operation) {
     if (this.isDisconnecting) {
@@ -2695,56 +3272,39 @@ var CacheStack = class extends import_node_events.EventEmitter {
     await this.startup;
     this.assertActive(operation);
   }
-  serializeOptions(options) {
-    return JSON.stringify(this.normalizeForSerialization(options) ?? null);
-  }
-  validateAdaptiveTtlOptions(options) {
-    if (!options || options === true) {
-      return;
-    }
-    this.validatePositiveNumber("adaptiveTtl.hotAfter", options.hotAfter);
-    this.validateLayerNumberOption("adaptiveTtl.step", options.step);
-    this.validateLayerNumberOption("adaptiveTtl.maxTtl", options.maxTtl);
-  }
-  validateCircuitBreakerOptions(options) {
-    if (!options) {
-      return;
-    }
-    this.validatePositiveNumber("circuitBreaker.failureThreshold", options.failureThreshold);
-    this.validatePositiveNumber("circuitBreaker.cooldownMs", options.cooldownMs);
-  }
   async applyFreshReadPolicies(key, hit, options, fetcher) {
-    const refreshAhead = this.resolveLayerSeconds(hit.layerName, options?.refreshAhead, this.options.refreshAhead, 0) ?? 0;
-    const remainingFreshTtl = remainingFreshTtlSeconds(hit.stored) ?? 0;
-    if ((options?.slidingTtl ?? false) && isStoredValueEnvelope(hit.stored)) {
-      const refreshed = refreshStoredEnvelope(hit.stored);
-      const ttl = remainingStoredTtlSeconds(refreshed);
+    const plan = planFreshReadPolicies({
+      stored: hit.stored,
+      hasFetcher: Boolean(fetcher),
+      slidingTtl: options?.slidingTtl ?? false,
+      refreshAheadSeconds: this.resolveLayerSeconds(hit.layerName, options?.refreshAhead, this.options.refreshAhead, 0) ?? 0
+    });
+    if (plan.refreshedStored) {
       for (let index = 0; index <= hit.layerIndex; index += 1) {
         const layer = this.layers[index];
         if (!layer || this.shouldSkipLayer(layer)) {
           continue;
         }
         try {
-          await layer.set(key, refreshed, ttl);
+          await layer.set(key, plan.refreshedStored, plan.refreshedStoredTtl);
         } catch (error) {
           await this.handleLayerFailure(layer, "sliding-ttl", error);
         }
       }
     }
-    if (fetcher && refreshAhead > 0 && remainingFreshTtl > 0 && remainingFreshTtl <= refreshAhead) {
+    if (fetcher && plan.shouldScheduleBackgroundRefresh) {
       this.scheduleBackgroundRefresh(key, fetcher, options);
     }
   }
   shouldSkipLayer(layer) {
-    const degradedUntil = this.layerDegradedUntil.get(layer.name);
-    return degradedUntil !== void 0 && degradedUntil > Date.now();
+    return shouldSkipLayer(this.layerDegradedUntil.get(layer.name));
   }
   async handleLayerFailure(layer, operation, error) {
-    if (!this.isGracefulDegradationEnabled()) {
+    const recovery = resolveRecoverableLayerFailure(this.options.gracefulDegradation);
+    if (!recovery.degrade) {
       throw error;
     }
-    const retryAfterMs = typeof this.options.gracefulDegradation === "object" ? this.options.gracefulDegradation.retryAfterMs ?? 1e4 : 1e4;
-    this.layerDegradedUntil.set(layer.name, Date.now() + retryAfterMs);
+    this.layerDegradedUntil.set(layer.name, recovery.degradedUntil);
     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) });
@@ -2780,18 +3340,6 @@ var CacheStack = class extends import_node_events.EventEmitter {
       this.emit("error", { operation, ...context });
     }
   }
-  serializeKeyPart(value) {
-    if (typeof value === "string") {
-      return `s:${value}`;
-    }
-    if (typeof value === "number") {
-      return `n:${value}`;
-    }
-    if (typeof value === "boolean") {
-      return `b:${value}`;
-    }
-    return `j:${JSON.stringify(this.normalizeForSerialization(value))}`;
-  }
   isCacheSnapshotEntries(value) {
     return Array.isArray(value) && value.every((entry) => {
       if (!entry || typeof entry !== "object") {
@@ -2804,54 +3352,72 @@ var CacheStack = class extends import_node_events.EventEmitter {
   sanitizeSnapshotValue(value) {
     return this.snapshotSerializer.deserialize(this.snapshotSerializer.serialize(value));
   }
-  async validateSnapshotFilePath(filePath) {
-    if (filePath.length === 0) {
-      throw new Error("filePath must not be empty.");
-    }
-    if (filePath.includes("\0")) {
-      throw new Error("filePath must not contain null bytes.");
+  snapshotMaxBytes() {
+    return this.options.snapshotMaxBytes === false ? false : this.options.snapshotMaxBytes ?? DEFAULT_SNAPSHOT_MAX_BYTES;
+  }
+  snapshotMaxEntries() {
+    return this.options.snapshotMaxEntries === false ? false : this.options.snapshotMaxEntries ?? DEFAULT_SNAPSHOT_MAX_ENTRIES;
+  }
+  invalidationMaxKeys() {
+    return this.options.invalidationMaxKeys === false ? false : this.options.invalidationMaxKeys ?? DEFAULT_INVALIDATION_MAX_KEYS;
+  }
+  async collectKeysForTag(tag) {
+    const keys = /* @__PURE__ */ new Set();
+    if (this.tagIndex.forEachKeyForTag) {
+      await this.tagIndex.forEachKeyForTag(tag, async (key) => {
+        keys.add(key);
+        this.assertWithinInvalidationKeyLimit(keys.size);
+      });
+      return [...keys];
     }
-    const path = await import("path");
-    const resolved = path.resolve(filePath);
-    const baseDir = this.options.snapshotBaseDir === false ? false : path.resolve(this.options.snapshotBaseDir ?? process.cwd());
-    if (baseDir !== false) {
-      const relative = path.relative(baseDir, resolved);
-      if (relative === ".." || relative.startsWith(`..${path.sep}`) || path.isAbsolute(relative)) {
-        throw new Error(`filePath is outside the allowed snapshot directory: ${baseDir}`);
-      }
+    for (const key of await this.tagIndex.keysForTag(tag)) {
+      keys.add(key);
+      this.assertWithinInvalidationKeyLimit(keys.size);
     }
-    return resolved;
+    return [...keys];
   }
-  normalizeForSerialization(value) {
-    if (Array.isArray(value)) {
-      return value.map((entry) => this.normalizeForSerialization(entry));
+  assertWithinInvalidationKeyLimit(size) {
+    const maxKeys = this.invalidationMaxKeys();
+    if (maxKeys !== false && size > maxKeys) {
+      throw new Error(`Invalidation matched too many keys (${size} > ${maxKeys}).`);
     }
-    if (value && typeof value === "object") {
-      return Object.keys(value).sort().reduce((normalized, key) => {
-        if (DANGEROUS_OBJECT_KEYS.has(key)) {
-          return normalized;
+  }
+  async visitExportEntries(maxEntries, visitor) {
+    const exported = /* @__PURE__ */ new Set();
+    for (const layer of this.layers) {
+      if (!layer.keys && !layer.forEachKey) {
+        continue;
+      }
+      const visitKey = async (key) => {
+        const exportedKey = this.stripQualifiedKey(key);
+        if (exported.has(exportedKey)) {
+          return;
         }
-        normalized[key] = this.normalizeForSerialization(value[key]);
-        return normalized;
-      }, {});
+        const stored = await this.readLayerEntry(layer, key);
+        if (stored === null) {
+          return;
+        }
+        exported.add(exportedKey);
+        if (maxEntries !== false && exported.size > maxEntries) {
+          throw new Error(`Snapshot export exceeds snapshotMaxEntries limit (${exported.size} > ${maxEntries}).`);
+        }
+        await visitor({
+          key: exportedKey,
+          value: stored,
+          ttl: remainingStoredTtlSeconds(stored)
+        });
+      };
+      if (layer.forEachKey) {
+        await layer.forEachKey(visitKey);
+        continue;
+      }
+      const keys = await layer.keys?.();
+      for (const key of keys ?? []) {
+        await visitKey(key);
+      }
     }
-    return value;
   }
 };
-function createInstanceId() {
-  if (globalThis.crypto?.randomUUID) {
-    return globalThis.crypto.randomUUID();
-  }
-  const bytes = new Uint8Array(16);
-  if (globalThis.crypto?.getRandomValues) {
-    globalThis.crypto.getRandomValues(bytes);
-  } else {
-    for (let i = 0; i < bytes.length; i++) {
-      bytes[i] = Math.floor(Math.random() * 256);
-    }
-  }
-  return `layercache-${Array.from(bytes, (b) => b.toString(16).padStart(2, "0")).join("")}`;
-}
 
 // src/invalidation/RedisInvalidationBus.ts
 var RedisInvalidationBus = class {
@@ -2930,15 +3496,24 @@ var RedisInvalidationBus = class {
   }
 };
 var DANGEROUS_KEYS = /* @__PURE__ */ new Set(["__proto__", "prototype", "constructor"]);
-function sanitizeJsonValue2(value) {
+var MAX_SANITIZE_DEPTH2 = 64;
+var MAX_SANITIZE_NODES2 = 1e4;
+function sanitizeJsonValue2(value, depth = 0, state = { count: 0 }) {
+  state.count += 1;
+  if (state.count > MAX_SANITIZE_NODES2) {
+    throw new Error(`Invalidation payload exceeds max node count of ${MAX_SANITIZE_NODES2}.`);
+  }
+  if (depth > MAX_SANITIZE_DEPTH2) {
+    throw new Error(`Invalidation payload exceeds max depth of ${MAX_SANITIZE_DEPTH2}.`);
+  }
   if (Array.isArray(value)) {
-    return value.map(sanitizeJsonValue2);
+    return value.map((entry) => sanitizeJsonValue2(entry, depth + 1, state));
   }
   if (value && typeof value === "object") {
     const result = /* @__PURE__ */ Object.create(null);
     for (const key of Object.keys(value)) {
       if (!DANGEROUS_KEYS.has(key)) {
-        result[key] = sanitizeJsonValue2(value[key]);
+        result[key] = sanitizeJsonValue2(value[key], depth + 1, state);
       }
     }
     return result;
@@ -2992,6 +3567,17 @@ var RedisTagIndex = class {
   async keysForTag(tag) {
     return this.client.smembers(this.tagKeysKey(tag));
   }
+  async forEachKeyForTag(tag, visitor) {
+    let cursor = "0";
+    const tagKey = this.tagKeysKey(tag);
+    do {
+      const [nextCursor, keys] = await this.client.sscan(tagKey, cursor, "COUNT", this.scanCount);
+      cursor = nextCursor;
+      for (const key of keys) {
+        await visitor(key);
+      }
+    } while (cursor !== "0");
+  }
   async keysForPrefix(prefix) {
     const matches = [];
     for (const knownKeysKey of this.knownKeysKeys()) {
@@ -3004,6 +3590,20 @@ var RedisTagIndex = class {
     }
     return matches;
   }
+  async forEachKeyForPrefix(prefix, visitor) {
+    for (const knownKeysKey of this.knownKeysKeys()) {
+      let cursor = "0";
+      do {
+        const [nextCursor, keys] = await this.client.sscan(knownKeysKey, cursor, "COUNT", this.scanCount);
+        cursor = nextCursor;
+        for (const key of keys) {
+          if (key.startsWith(prefix)) {
+            await visitor(key);
+          }
+        }
+      } while (cursor !== "0");
+    }
+  }
   async tagsForKey(key) {
     return this.client.smembers(this.keyTagsKey(key));
   }
@@ -3026,6 +3626,27 @@ var RedisTagIndex = class {
     }
     return matches;
   }
+  async forEachKeyMatchingPattern(pattern, visitor) {
+    for (const knownKeysKey of this.knownKeysKeys()) {
+      let cursor = "0";
+      do {
+        const [nextCursor, keys] = await this.client.sscan(
+          knownKeysKey,
+          cursor,
+          "MATCH",
+          pattern,
+          "COUNT",
+          this.scanCount
+        );
+        cursor = nextCursor;
+        for (const key of keys) {
+          if (PatternMatcher.matches(pattern, key)) {
+            await visitor(key);
+          }
+        }
+      } while (cursor !== "0");
+    }
+  }
   async clear() {
     const indexKeys = await this.scanIndexKeys();
     if (indexKeys.length === 0) {
@@ -3081,12 +3702,18 @@ function simpleHash(value) {
 }
 
 // src/http/createCacheStatsHandler.ts
-function createCacheStatsHandler(cache) {
-  return async (_request, response) => {
-    response.statusCode = 200;
+function createCacheStatsHandler(cache, options = {}) {
+  return async (request, response) => {
     response.setHeader?.("content-type", "application/json; charset=utf-8");
     response.setHeader?.("cache-control", "no-store");
     response.setHeader?.("x-content-type-options", "nosniff");
+    const isAuthorized = options.allowPublicAccess === true || (options.authorize ? await options.authorize(request) : false);
+    if (!isAuthorized) {
+      response.statusCode = options.unauthorizedStatusCode ?? 403;
+      response.end(JSON.stringify({ error: "Forbidden" }));
+      return;
+    }
+    response.statusCode = 200;
     response.end(JSON.stringify(cache.getStats(), null, 2));
   };
 }
@@ -3121,7 +3748,26 @@ function createFastifyLayercachePlugin(cache, options = {}) {
   return async (fastify) => {
     fastify.decorate("cache", cache);
     if (options.exposeStatsRoute === true && fastify.get) {
-      fastify.get(options.statsPath ?? "/cache/stats", async () => cache.getStats());
+      fastify.get(options.statsPath ?? "/cache/stats", async (request, reply) => {
+        const isAuthorized = options.allowPublicStatsRoute === true || (options.authorizeStatsRoute ? await options.authorizeStatsRoute(request) : false);
+        reply.header?.("cache-control", "no-store");
+        reply.header?.("x-content-type-options", "nosniff");
+        if (!isAuthorized) {
+          reply.statusCode = options.unauthorizedStatusCode ?? 403;
+          const body2 = { error: "Forbidden" };
+          if (reply.send) {
+            reply.send(body2);
+            return;
+          }
+          return body2;
+        }
+        const body = cache.getStats();
+        if (reply.send) {
+          reply.send(body);
+          return;
+        }
+        return body;
+      });
     }
   };
 }
@@ -3136,6 +3782,10 @@ function createExpressCacheMiddleware(cache, options = {}) {
         next();
         return;
       }
+      if (!options.keyResolver && options.allowPrivateCaching !== true) {
+        next();
+        return;
+      }
       const rawUrl = req.originalUrl ?? req.url ?? "/";
       const key = options.keyResolver ? options.keyResolver(req) : `${method}:${normalizeUrl(rawUrl)}`;
       const cached = await cache.get(key, void 0, options);
@@ -3180,6 +3830,11 @@ function normalizeUrl(url) {
 
 // src/integrations/graphql.ts
 function cacheGraphqlResolver(cache, prefix, resolver, options = {}) {
+  if (!options.keyResolver && options.allowImplicitContextCaching !== true) {
+    throw new Error(
+      "cacheGraphqlResolver requires a keyResolver or allowImplicitContextCaching=true because resolver output may depend on request context."
+    );
+  }
   const wrapped = cache.wrap(prefix, resolver, {
     ...options,
     keyResolver: options.keyResolver
@@ -3196,14 +3851,17 @@ function createHonoCacheMiddleware(cache, options = {}) {
       await next();
       return;
     }
+    if (!options.keyResolver && options.allowPrivateCaching !== true) {
+      await next();
+      return;
+    }
     const rawPath = context.req.path ?? context.req.url ?? "/";
     const key = options.keyResolver ? options.keyResolver(context.req) : `${method}:${normalizeUrl2(rawPath)}`;
     const cached = await cache.get(key, void 0, options);
     if (cached !== null) {
       context.header?.("x-cache", "HIT");
       context.header?.("content-type", "application/json; charset=utf-8");
-      context.json(cached);
-      return;
+      return context.json(cached);
     }
     const originalJson = context.json.bind(context);
     context.json = (body, status) => {
@@ -3293,6 +3951,11 @@ function instrument(name, tracer, method, attributes) {
 
 // src/integrations/trpc.ts
 function createTrpcCacheMiddleware(cache, prefix, options = {}) {
+  if (!options.keyResolver && options.allowImplicitContextCaching !== true) {
+    throw new Error(
+      "createTrpcCacheMiddleware requires a keyResolver or allowImplicitContextCaching=true because procedure output may depend on request context."
+    );
+  }
   return async (context) => {
     const key = options.keyResolver ? `${prefix}:${options.keyResolver(context.rawInput, context.path, context.type)}` : `${prefix}:${context.path ?? "procedure"}:${JSON.stringify(context.rawInput ?? null)}`;
     let didFetch = false;
@@ -3432,6 +4095,12 @@ var MemoryLayer = class {
     this.pruneExpired();
     return [...this.entries.keys()];
   }
+  async forEachKey(visitor) {
+    this.pruneExpired();
+    for (const key of this.entries.keys()) {
+      await visitor(key);
+    }
+  }
   exportState() {
     this.pruneExpired();
     return [...this.entries.entries()].map(([key, entry]) => ({
@@ -3499,13 +4168,12 @@ var MemoryLayer = class {
 };
 
 // src/layers/RedisLayer.ts
+var import_node_stream = require("stream");
 var import_node_util = require("util");
 var import_node_zlib = require("zlib");
 var BATCH_DELETE_SIZE = 500;
 var gzipAsync = (0, import_node_util.promisify)(import_node_zlib.gzip);
-var gunzipAsync = (0, import_node_util.promisify)(import_node_zlib.gunzip);
 var brotliCompressAsync = (0, import_node_util.promisify)(import_node_zlib.brotliCompress);
-var brotliDecompressAsync = (0, import_node_util.promisify)(import_node_zlib.brotliDecompress);
 var RedisLayer = class {
   name;
   defaultTtl;
@@ -3613,8 +4281,18 @@ var RedisLayer = class {
     return remaining;
   }
   async size() {
-    const keys = await this.keys();
-    return keys.length;
+    if (!this.prefix) {
+      return this.client.dbsize();
+    }
+    const pattern = `${this.prefix}*`;
+    let cursor = "0";
+    let count = 0;
+    do {
+      const [nextCursor, keys] = await this.client.scan(cursor, "MATCH", pattern, "COUNT", this.scanCount);
+      cursor = nextCursor;
+      count += keys.length;
+    } while (cursor !== "0");
+    return count;
   }
   async ping() {
     try {
@@ -3660,6 +4338,17 @@ var RedisLayer = class {
     }
     return keys.map((key) => key.slice(this.prefix.length));
   }
+  async forEachKey(visitor) {
+    const pattern = `${this.prefix}*`;
+    let cursor = "0";
+    do {
+      const [nextCursor, keys] = await this.client.scan(cursor, "MATCH", pattern, "COUNT", this.scanCount);
+      cursor = nextCursor;
+      for (const key of keys) {
+        await visitor(this.prefix ? key.slice(this.prefix.length) : key);
+      }
+    } while (cursor !== "0");
+  }
   async scanKeys(pattern) {
     const matches = [];
     let cursor = "0";
@@ -3674,7 +4363,13 @@ var RedisLayer = class {
     return `${this.prefix}${key}`;
   }
   async deserializeOrDelete(key, payload) {
-    const decodedPayload = await this.decodePayload(payload);
+    let decodedPayload;
+    try {
+      decodedPayload = await this.decodePayload(payload);
+    } catch {
+      await this.deleteCorruptedKey(key);
+      return null;
+    }
     for (const serializer of this.serializers) {
       try {
         const value = serializer.deserialize(decodedPayload);
@@ -3685,12 +4380,15 @@ var RedisLayer = class {
       } catch {
       }
     }
+    await this.deleteCorruptedKey(key);
+    return null;
+  }
+  async deleteCorruptedKey(key) {
     try {
       await this.client.del(this.withPrefix(key));
     } catch (deleteError) {
       console.warn(`[layercache] RedisLayer: failed to delete corrupted key "${key}"`, deleteError);
     }
-    return null;
   }
   async rewriteWithPrimarySerializer(key, value) {
     const serialized = this.primarySerializer().serialize(value);
@@ -3737,31 +4435,72 @@ var RedisLayer = class {
       return payload;
     }
     if (payload.subarray(0, 10).toString() === "LCZ1:gzip:") {
-      const decompressed = await gunzipAsync(payload.subarray(10));
-      if (decompressed.byteLength > this.decompressionMaxBytes) {
-        throw new Error(
-          `Decompressed payload (${decompressed.byteLength} bytes) exceeds decompressionMaxBytes limit (${this.decompressionMaxBytes} bytes).`
-        );
-      }
-      return decompressed;
+      return this.decompressWithLimit((0, import_node_zlib.createGunzip)(), payload.subarray(10));
     }
     if (payload.subarray(0, 12).toString() === "LCZ1:brotli:") {
-      const decompressed = await brotliDecompressAsync(payload.subarray(12));
-      if (decompressed.byteLength > this.decompressionMaxBytes) {
-        throw new Error(
-          `Decompressed payload (${decompressed.byteLength} bytes) exceeds decompressionMaxBytes limit (${this.decompressionMaxBytes} bytes).`
-        );
-      }
-      return decompressed;
+      return this.decompressWithLimit((0, import_node_zlib.createBrotliDecompress)(), payload.subarray(12));
     }
     return payload;
   }
+  async decompressWithLimit(decompressor, payload) {
+    return new Promise((resolve2, reject) => {
+      const source = import_node_stream.Readable.from(payload);
+      const chunks = [];
+      let totalBytes = 0;
+      let settled = false;
+      const cleanup = () => {
+        decompressor.removeAllListeners();
+      };
+      const fail = (error) => {
+        if (settled) {
+          return;
+        }
+        settled = true;
+        cleanup();
+        source.unpipe(decompressor);
+        source.destroy();
+        decompressor.destroy();
+        reject(error);
+      };
+      decompressor.on("data", (chunk) => {
+        const normalized = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+        totalBytes += normalized.byteLength;
+        if (totalBytes > this.decompressionMaxBytes) {
+          fail(
+            new Error(
+              `Decompressed payload (${totalBytes} bytes) exceeds decompressionMaxBytes limit (${this.decompressionMaxBytes} bytes).`
+            )
+          );
+          return;
+        }
+        chunks.push(normalized);
+      });
+      decompressor.once("error", (error) => {
+        if (settled) {
+          return;
+        }
+        settled = true;
+        cleanup();
+        reject(error);
+      });
+      decompressor.once("end", () => {
+        if (settled) {
+          return;
+        }
+        settled = true;
+        cleanup();
+        resolve2(Buffer.concat(chunks));
+      });
+      source.pipe(decompressor);
+    });
+  }
 };
 
 // src/layers/DiskLayer.ts
 var import_node_crypto = require("crypto");
 var import_node_fs = require("fs");
 var import_node_path = require("path");
+var FILE_SCAN_CONCURRENCY = 32;
 var DiskLayer = class {
   name;
   defaultTtl;
@@ -3769,6 +4508,7 @@ var DiskLayer = class {
   directory;
   serializer;
   maxFiles;
+  maxEntryBytes;
   writeQueue = Promise.resolve();
   constructor(options) {
     this.directory = this.resolveDirectory(options.directory);
@@ -3776,16 +4516,15 @@ var DiskLayer = class {
     this.name = options.name ?? "disk";
     this.serializer = options.serializer ?? new JsonSerializer();
     this.maxFiles = this.normalizeMaxFiles(options.maxFiles);
+    this.maxEntryBytes = this.normalizeMaxEntryBytes(options.maxEntryBytes);
   }
   async get(key) {
     return unwrapStoredValue(await this.getEntry(key));
   }
   async getEntry(key) {
     const filePath = this.keyToPath(key);
-    let raw;
-    try {
-      raw = await import_node_fs.promises.readFile(filePath);
-    } catch {
+    const raw = await this.readEntryFile(filePath);
+    if (raw === null) {
       return null;
     }
     let entry;
@@ -3836,10 +4575,8 @@ var DiskLayer = class {
   }
   async ttl(key) {
     const filePath = this.keyToPath(key);
-    let raw;
-    try {
-      raw = await import_node_fs.promises.readFile(filePath);
-    } catch {
+    const raw = await this.readEntryFile(filePath);
+    if (raw === null) {
       return null;
     }
     let entry;
@@ -3863,7 +4600,7 @@ var DiskLayer = class {
   }
   async deleteMany(keys) {
     await this.enqueueWrite(async () => {
-      await Promise.all(keys.map((key) => this.safeDelete(this.keyToPath(key))));
+      await this.deletePathsWithConcurrency(keys.map((key) => this.keyToPath(key)));
     });
   }
   async clear() {
@@ -3874,8 +4611,8 @@ var DiskLayer = class {
       } catch {
         return;
       }
-      await Promise.all(
-        entries.filter((name) => name.endsWith(".lc")).map((name) => this.safeDelete((0, import_node_path.join)(this.directory, name)))
+      await this.deletePathsWithConcurrency(
+        entries.filter((name) => name.endsWith(".lc")).map((name) => (0, import_node_path.join)(this.directory, name))
       );
     });
   }
@@ -3884,42 +4621,23 @@ var DiskLayer = class {
    * Expired entries are skipped and cleaned up during the scan.
    */
   async keys() {
-    let entries;
-    try {
-      entries = await import_node_fs.promises.readdir(this.directory);
-    } catch {
-      return [];
-    }
-    const lcFiles = entries.filter((name) => name.endsWith(".lc"));
     const keys = [];
-    await Promise.all(
-      lcFiles.map(async (name) => {
-        const filePath = (0, import_node_path.join)(this.directory, name);
-        let raw;
-        try {
-          raw = await import_node_fs.promises.readFile(filePath);
-        } catch {
-          return;
-        }
-        let entry;
-        try {
-          entry = this.deserializeEntry(raw);
-        } catch {
-          await this.safeDelete(filePath);
-          return;
-        }
-        if (entry.expiresAt !== null && entry.expiresAt <= Date.now()) {
-          await this.safeDelete(filePath);
-          return;
-        }
-        keys.push(entry.key);
-      })
-    );
+    await this.scanEntries(async (entry) => {
+      keys.push(entry.key);
+    });
     return keys;
   }
+  async forEachKey(visitor) {
+    await this.scanEntries(async (entry) => {
+      await visitor(entry.key);
+    });
+  }
   async size() {
-    const keys = await this.keys();
-    return keys.length;
+    let count = 0;
+    await this.scanEntries(async () => {
+      count += 1;
+    });
+    return count;
   }
   async ping() {
     try {
@@ -3953,6 +4671,113 @@ var DiskLayer = class {
     }
     return maxFiles;
   }
+  normalizeMaxEntryBytes(maxEntryBytes) {
+    if (maxEntryBytes === false) {
+      return false;
+    }
+    const normalized = maxEntryBytes ?? 16 * 1024 * 1024;
+    if (!Number.isFinite(normalized) || normalized <= 0) {
+      throw new Error("DiskLayer.maxEntryBytes must be a positive number or false.");
+    }
+    return normalized;
+  }
+  async readEntryFile(filePath) {
+    let handle;
+    try {
+      handle = await import_node_fs.promises.open(filePath, "r");
+      return await this.readHandleWithLimit(handle);
+    } catch {
+      await this.safeDelete(filePath);
+      return null;
+    } finally {
+      await handle?.close().catch(() => void 0);
+    }
+  }
+  async readHandleWithLimit(handle) {
+    if (this.maxEntryBytes === false) {
+      return handle.readFile();
+    }
+    const stat = await handle.stat();
+    if (stat.size > this.maxEntryBytes) {
+      throw new Error(`DiskLayer entry exceeds maxEntryBytes limit (${stat.size} bytes > ${this.maxEntryBytes} bytes).`);
+    }
+    const chunks = [];
+    let totalBytes = 0;
+    let position = 0;
+    while (true) {
+      const buffer = Buffer.allocUnsafe(Math.min(64 * 1024, this.maxEntryBytes - totalBytes + 1));
+      const { bytesRead } = await handle.read(buffer, 0, buffer.byteLength, position);
+      if (bytesRead === 0) {
+        break;
+      }
+      totalBytes += bytesRead;
+      if (totalBytes > this.maxEntryBytes) {
+        throw new Error(
+          `DiskLayer entry exceeds maxEntryBytes limit (${totalBytes} bytes > ${this.maxEntryBytes} bytes).`
+        );
+      }
+      chunks.push(buffer.subarray(0, bytesRead));
+      position += bytesRead;
+    }
+    return Buffer.concat(chunks);
+  }
+  async scanEntries(visitor) {
+    let entries;
+    try {
+      entries = await import_node_fs.promises.readdir(this.directory);
+    } catch {
+      return;
+    }
+    const lcFiles = entries.filter((name) => name.endsWith(".lc"));
+    let nextIndex = 0;
+    const workerCount = Math.min(FILE_SCAN_CONCURRENCY, lcFiles.length);
+    await Promise.all(
+      Array.from({ length: workerCount }, async () => {
+        while (true) {
+          const currentIndex = nextIndex;
+          nextIndex += 1;
+          const name = lcFiles[currentIndex];
+          if (name === void 0) {
+            return;
+          }
+          const filePath = (0, import_node_path.join)(this.directory, name);
+          const raw = await this.readEntryFile(filePath);
+          if (raw === null) {
+            continue;
+          }
+          let entry;
+          try {
+            entry = this.deserializeEntry(raw);
+          } catch {
+            await this.safeDelete(filePath);
+            continue;
+          }
+          if (entry.expiresAt !== null && entry.expiresAt <= Date.now()) {
+            await this.safeDelete(filePath);
+            continue;
+          }
+          await visitor(entry);
+        }
+      })
+    );
+  }
+  async deletePathsWithConcurrency(paths) {
+    let nextIndex = 0;
+    const workerCount = Math.min(FILE_SCAN_CONCURRENCY, paths.length);
+    await Promise.all(
+      Array.from({ length: workerCount }, async () => {
+        while (true) {
+          const currentIndex = nextIndex;
+          nextIndex += 1;
+          const filePath = paths[currentIndex];
+          if (filePath === void 0) {
+            return;
+          }
+          await this.safeDelete(filePath);
+        }
+      })
+    );
+  }
   deserializeEntry(raw) {
     const entry = this.serializer.deserialize(raw);
     if (!isDiskEntry(entry)) {
@@ -4089,18 +4914,27 @@ var MemcachedLayer = class {
 // src/serialization/MsgpackSerializer.ts
 var import_msgpack = require("@msgpack/msgpack");
 var DANGEROUS_KEYS2 = /* @__PURE__ */ new Set(["__proto__", "prototype", "constructor"]);
+var MAX_SANITIZE_DEPTH3 = 64;
+var MAX_SANITIZE_NODES3 = 1e4;
 var MsgpackSerializer = class {
   serialize(value) {
     return Buffer.from((0, import_msgpack.encode)(value));
   }
   deserialize(payload) {
-    const normalized = Buffer.isBuffer(payload) ? payload : Buffer.from(payload);
-    return sanitizeMsgpackValue((0, import_msgpack.decode)(normalized));
+    const normalized = Buffer.isBuffer(payload) ? payload : Buffer.from(payload, "latin1");
+    return sanitizeMsgpackValue((0, import_msgpack.decode)(normalized), 0, { count: 0 });
   }
 };
-function sanitizeMsgpackValue(value) {
+function sanitizeMsgpackValue(value, depth, state) {
+  state.count += 1;
+  if (state.count > MAX_SANITIZE_NODES3) {
+    throw new Error(`MessagePack payload exceeds max node count of ${MAX_SANITIZE_NODES3}.`);
+  }
+  if (depth > MAX_SANITIZE_DEPTH3) {
+    throw new Error(`MessagePack payload exceeds max depth of ${MAX_SANITIZE_DEPTH3}.`);
+  }
   if (Array.isArray(value)) {
-    return value.map((entry) => sanitizeMsgpackValue(entry));
+    return value.map((entry) => sanitizeMsgpackValue(entry, depth + 1, state));
   }
   if (!isPlainObject2(value)) {
     return value;
@@ -4110,7 +4944,7 @@ function sanitizeMsgpackValue(value) {
     if (DANGEROUS_KEYS2.has(key)) {
       continue;
     }
-    sanitized[key] = sanitizeMsgpackValue(entry);
+    sanitized[key] = sanitizeMsgpackValue(entry, depth + 1, state);
   }
   return sanitized;
 }