layercache 1.2.4 → 1.2.6

package/dist/index.js

@@ -1,11 +1,11 @@
 import {
   RedisTagIndex
-} from "./chunk-QHWG7QS5.js";
+} from "./chunk-BQLL6IM5.js";
 import {
   MemoryLayer,
   TagIndex,
   createHonoCacheMiddleware
-} from "./chunk-KOYGHLVP.js";
+} from "./chunk-GJBKCFE6.js";
 import {
   PatternMatcher,
   createStoredValueEnvelope,
@@ -15,7 +15,7 @@ import {
   remainingStoredTtlSeconds,
   resolveStoredValue,
   unwrapStoredValue
-} from "./chunk-7V7XAB74.js";
+} from "./chunk-4PPBOOXT.js";
 
 // src/CacheStack.ts
 import { EventEmitter } from "events";
@@ -26,22 +26,23 @@ var CacheNamespace = class _CacheNamespace {
   constructor(cache, prefix) {
     this.cache = cache;
     this.prefix = prefix;
+    validateNamespaceKey(prefix);
   }
   cache;
   prefix;
   static metricsMutexes = /* @__PURE__ */ new WeakMap();
   metrics = emptyMetrics();
   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)));
@@ -50,7 +51,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)));
@@ -66,7 +67,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)
         }))
       )
     );
@@ -76,16 +78,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)));
@@ -97,16 +105,24 @@ 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
     );
@@ -136,11 +152,30 @@ var CacheNamespace = class _CacheNamespace {
    * ```
    */
   namespace(childPrefix) {
+    validateNamespaceKey(childPrefix);
     return new _CacheNamespace(this.cache, `${this.prefix}:${childPrefix}`);
   }
   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();
@@ -265,6 +300,20 @@ function addMap(base, delta) {
   }
   return result;
 }
+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.");
+  }
+}
 
 // src/internal/CacheKeyDiscovery.ts
 var CacheKeyDiscovery = class {
@@ -272,21 +321,41 @@ var CacheKeyDiscovery = class {
     this.options = options;
   }
   options;
-  async collectKeysWithPrefix(prefix) {
+  async collectKeysWithPrefix(prefix, maxMatches = false) {
     const { tagIndex } = this.options;
-    const matches = new Set(
-      tagIndex.keysForPrefix ? await tagIndex.keysForPrefix(prefix) : await tagIndex.matchPattern(`${prefix}*`)
-    );
+    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 || this.options.shouldSkipLayer(layer)) {
+        if (!layer.keys && !layer.forEachKey || this.options.shouldSkipLayer(layer)) {
           return;
         }
         try {
-          const keys = await layer.keys();
-          for (const key of keys) {
+          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) {
@@ -296,18 +365,39 @@ var CacheKeyDiscovery = class {
     );
     return [...matches];
   }
-  async collectKeysMatchingPattern(pattern) {
-    const matches = new Set(await this.options.tagIndex.matchPattern(pattern));
+  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 || this.options.shouldSkipLayer(layer)) {
+        if (!layer.keys && !layer.forEachKey || this.options.shouldSkipLayer(layer)) {
           return;
         }
         try {
-          const keys = await layer.keys();
-          for (const key of keys) {
+          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) {
@@ -317,8 +407,280 @@ var CacheKeyDiscovery = class {
     );
     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/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.`);
+  }
+}
+function 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;
+}
+function validateTag(tag) {
+  if (tag.length === 0) {
+    throw new Error("Cache tag must not be empty.");
+  }
+  if (tag.length > MAX_CACHE_KEY_LENGTH) {
+    throw new Error(`Cache tag length must be at most ${MAX_CACHE_KEY_LENGTH} characters.`);
+  }
+  if (/[\u0000-\u001F\u007F]/.test(tag)) {
+    throw new Error("Cache tag contains unsupported control characters.");
+  }
+  if (/[\uD800-\uDFFF]/.test(tag)) {
+    throw new Error("Cache tag contains unsupported surrogate code points.");
+  }
+  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 {
   breakers = /* @__PURE__ */ new Map();
@@ -337,9 +699,7 @@ var CircuitBreakerManager = class {
     }
     const now = Date.now();
     if (state.openUntil <= now) {
-      state.openUntil = null;
-      state.failures = 0;
-      this.breakers.set(key, state);
+      this.breakers.delete(key);
       return;
     }
     const remainingMs = state.openUntil - now;
@@ -350,15 +710,15 @@ 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 };
+    const state = this.breakers.get(key) ?? { failures: 0, openUntil: null, createdAt: Date.now() };
     state.failures += 1;
     if (state.failures >= failureThreshold) {
       state.openUntil = Date.now() + cooldownMs;
     }
     this.breakers.set(key, state);
-    this.pruneIfNeeded();
   }
   recordSuccess(key) {
     this.breakers.delete(key);
@@ -369,8 +729,7 @@ var CircuitBreakerManager = class {
       return false;
     }
     if (state.openUntil <= Date.now()) {
-      state.openUntil = null;
-      state.failures = 0;
+      this.breakers.delete(key);
       return false;
     }
     return true;
@@ -394,15 +753,20 @@ var CircuitBreakerManager = class {
     if (this.breakers.size <= this.maxEntries) {
       return;
     }
+    const now = Date.now();
     for (const [key, state] of this.breakers.entries()) {
       if (this.breakers.size <= this.maxEntries) {
-        break;
+        return;
       }
-      if (!state.openUntil || state.openUntil <= Date.now()) {
+      if (!state.openUntil || state.openUntil <= now) {
         this.breakers.delete(key);
       }
     }
-    for (const key of this.breakers.keys()) {
+    if (this.breakers.size <= this.maxEntries) {
+      return;
+    }
+    const sorted = [...this.breakers.entries()].sort((a, b) => a[1].createdAt - b[1].createdAt);
+    for (const [key] of sorted) {
       if (this.breakers.size <= this.maxEntries) {
         break;
       }
@@ -412,6 +776,7 @@ var CircuitBreakerManager = class {
 };
 
 // src/internal/FetchRateLimiter.ts
+var MAX_BUCKETS = 1e4;
 var FetchRateLimiter = class {
   buckets = /* @__PURE__ */ new Map();
   queuesByBucket = /* @__PURE__ */ new Map();
@@ -577,10 +942,25 @@ var FetchRateLimiter = class {
     if (existing) {
       return existing;
     }
+    if (this.buckets.size >= MAX_BUCKETS) {
+      this.evictIdleBuckets();
+    }
     const bucket = { active: 0, startedAt: [] };
     this.buckets.set(bucketKey, bucket);
     return bucket;
   }
+  evictIdleBuckets() {
+    for (const [key, bucket] of this.buckets.entries()) {
+      if (this.buckets.size <= MAX_BUCKETS * 0.9) {
+        break;
+      }
+      if (bucket.active === 0 && bucket.startedAt.length === 0 && !this.queuesByBucket.has(key)) {
+        this.buckets.delete(key);
+        this.queuesByBucket.delete(key);
+        this.pendingBuckets.delete(key);
+      }
+    }
+  }
   cleanupBucket(bucketKey, bucket, intervalMs) {
     const queued = this.queuesByBucket.get(bucketKey)?.length ?? 0;
     if (queued === 0 && bucket.active === 0 && bucket.startedAt.length === 0) {
@@ -783,35 +1163,39 @@ var TtlResolver = class {
       return;
     }
     const toRemove = Math.ceil(this.maxProfileEntries * 0.1);
-    let removed = 0;
-    for (const key of this.accessProfiles.keys()) {
-      if (removed >= toRemove) {
-        break;
+    const sorted = [...this.accessProfiles.entries()].sort((a, b) => a[1].lastAccessAt - b[1].lastAccessAt);
+    for (let i = 0; i < toRemove && i < sorted.length; i++) {
+      const entry = sorted[i];
+      if (entry) {
+        this.accessProfiles.delete(entry[0]);
       }
-      this.accessProfiles.delete(key);
-      removed += 1;
     }
   }
 };
 
 // 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;
@@ -821,7 +1205,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;
 }
@@ -871,9 +1255,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 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) {
@@ -960,6 +1346,7 @@ var CacheStack = class extends EventEmitter {
   snapshotSerializer = new JsonSerializer();
   backgroundRefreshes = /* @__PURE__ */ new Map();
   layerDegradedUntil = /* @__PURE__ */ new Map();
+  keyEpochs = /* @__PURE__ */ new Map();
   ttlResolver;
   circuitBreakerManager;
   currentGeneration;
@@ -967,6 +1354,7 @@ var CacheStack = class extends EventEmitter {
   writeBehindTimer;
   writeBehindFlushPromise;
   generationCleanupPromise;
+  clearEpoch = 0;
   isDisconnecting = false;
   disconnectPromise;
   /**
@@ -976,7 +1364,7 @@ var CacheStack = class extends 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);
@@ -1046,7 +1434,7 @@ var CacheStack = class extends 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)) {
@@ -1079,7 +1467,7 @@ var CacheStack = class extends 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)) {
@@ -1101,7 +1489,7 @@ var CacheStack = class extends 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);
@@ -1110,7 +1498,7 @@ var CacheStack = class extends 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({
@@ -1122,6 +1510,7 @@ var CacheStack = class extends EventEmitter {
   }
   async clear() {
     await this.awaitStartup("clear");
+    this.beginClearEpoch();
     await Promise.all(this.layers.map((layer) => layer.clear()));
     await this.tagIndex.clear();
     this.ttlResolver.clearProfiles();
@@ -1138,7 +1527,7 @@ var CacheStack = class extends 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({
@@ -1155,7 +1544,7 @@ var CacheStack = class extends 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);
@@ -1164,7 +1553,7 @@ var CacheStack = class extends 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);
@@ -1233,7 +1622,7 @@ var CacheStack = class extends 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");
@@ -1276,7 +1665,7 @@ var CacheStack = class extends 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);
     };
@@ -1286,11 +1675,13 @@ var CacheStack = class extends 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" });
   }
@@ -1298,22 +1689,28 @@ var CacheStack = class extends 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) {
+    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" });
   }
@@ -1383,7 +1780,7 @@ var CacheStack = class extends 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 = [];
@@ -1420,50 +1817,79 @@ var CacheStack = class extends 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);
@@ -1507,14 +1933,14 @@ var CacheStack = class extends 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) {
@@ -1524,7 +1950,7 @@ var CacheStack = class extends EventEmitter {
         key,
         this.resolveSingleFlightOptions(),
         fetchTask,
-        () => this.waitForFreshValue(key, fetcher, options)
+        () => this.waitForFreshValue(key, fetcher, options, expectedClearEpoch, expectedKeyEpoch)
       );
     };
     if (this.options.stampedePrevention === false) {
@@ -1532,7 +1958,7 @@ var CacheStack = class extends 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;
@@ -1546,9 +1972,9 @@ var CacheStack = class extends 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();
@@ -1569,6 +1995,16 @@ var CacheStack = class extends EventEmitter {
       if (!this.shouldNegativeCache(options)) {
         return null;
       }
+      if (this.isWriteOutdated(key, expectedClearEpoch, expectedKeyEpoch)) {
+        this.logger.debug?.("skip-negative-store-after-invalidation", {
+          key,
+          expectedClearEpoch,
+          clearEpoch: this.clearEpoch,
+          expectedKeyEpoch,
+          keyEpoch: this.currentKeyEpoch(key)
+        });
+        return null;
+      }
       await this.storeEntry(key, "empty", null, options);
       return null;
     }
@@ -1581,11 +2017,26 @@ var CacheStack = class extends EventEmitter {
         this.logger.warn?.("shouldCache-error", { key, error: this.formatError(error) });
       }
     }
+    if (this.isWriteOutdated(key, expectedClearEpoch, expectedKeyEpoch)) {
+      this.logger.debug?.("skip-store-after-invalidation", {
+        key,
+        expectedClearEpoch,
+        clearEpoch: this.clearEpoch,
+        expectedKeyEpoch,
+        keyEpoch: this.currentKeyEpoch(key)
+      });
+      return fetched;
+    }
     await this.storeEntry(key, "value", fetched, options);
     return fetched;
   }
   async storeEntry(key, kind, value, options) {
+    const clearEpoch = this.clearEpoch;
+    const keyEpoch = this.currentKeyEpoch(key);
     await this.writeAcrossLayers(key, kind, value, options);
+    if (this.isWriteOutdated(key, clearEpoch, keyEpoch)) {
+      return;
+    }
     if (options?.tags) {
       await this.tagIndex.track(key, options.tags);
     } else {
@@ -1600,6 +2051,8 @@ var CacheStack = class extends EventEmitter {
   }
   async writeBatch(entries) {
     const now = Date.now();
+    const clearEpoch = this.clearEpoch;
+    const entryEpochs = new Map(entries.map((entry) => [entry.key, this.currentKeyEpoch(entry.key)]));
     const entriesByLayer = /* @__PURE__ */ new Map();
     const immediateOperations = [];
     const deferredOperations = [];
@@ -1616,12 +2069,21 @@ var CacheStack = class extends EventEmitter {
     }
     for (const [layer, layerEntries] of entriesByLayer.entries()) {
       const operation = async () => {
+        if (clearEpoch !== this.clearEpoch) {
+          return;
+        }
+        const activeEntries = layerEntries.filter(
+          (entry) => (entryEpochs.get(entry.key) ?? 0) === this.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);
         }
@@ -1634,7 +2096,13 @@ var CacheStack = class extends EventEmitter {
     }
     await this.executeLayerOperations(immediateOperations, { key: "batch", action: "mset" });
     await Promise.all(deferredOperations.map((operation) => this.enqueueWriteBehind(operation)));
+    if (clearEpoch !== this.clearEpoch) {
+      return;
+    }
     for (const entry of entries) {
+      if (this.isWriteOutdated(entry.key, clearEpoch, entryEpochs.get(entry.key))) {
+        continue;
+      }
       if (entry.options?.tags) {
         await this.tagIndex.track(entry.key, entry.options.tags);
       } else {
@@ -1736,10 +2204,15 @@ var CacheStack = class extends EventEmitter {
   }
   async writeAcrossLayers(key, kind, value, options) {
     const now = Date.now();
+    const clearEpoch = this.clearEpoch;
+    const keyEpoch = this.currentKeyEpoch(key);
     const immediateOperations = [];
     const deferredOperations = [];
     for (const layer of this.layers) {
       const operation = async () => {
+        if (this.isWriteOutdated(key, clearEpoch, keyEpoch)) {
+          return;
+        }
         if (this.shouldSkipLayer(layer)) {
           return;
         }
@@ -1803,10 +2276,12 @@ var CacheStack = class extends EventEmitter {
     if (this.isDisconnecting || this.backgroundRefreshes.has(key)) {
       return;
     }
+    const clearEpoch = this.clearEpoch;
+    const keyEpoch = this.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) });
@@ -1816,14 +2291,16 @@ var CacheStack = class extends 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() {
@@ -1838,6 +2315,7 @@ var CacheStack = class extends EventEmitter {
     if (keys.length === 0) {
       return;
     }
+    this.bumpKeyEpochs(keys);
     await this.deleteKeysFromLayers(this.layers, keys);
     for (const key of keys) {
       await this.tagIndex.remove(key);
@@ -1860,21 +2338,22 @@ var CacheStack = class extends EventEmitter {
       return;
     }
     const localLayers = this.layers.filter((layer) => layer.isLocal);
-    if (localLayers.length === 0) {
-      return;
-    }
     if (message.scope === "clear") {
+      this.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.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);
       }
     }
   }
@@ -1980,6 +2459,28 @@ var CacheStack = class extends EventEmitter {
   shouldWriteBehind(layer) {
     return this.options.writeStrategy === "write-behind" && !layer.isLocal;
   }
+  beginClearEpoch() {
+    this.clearEpoch += 1;
+    this.keyEpochs.clear();
+    this.writeBehindQueue.length = 0;
+  }
+  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) {
     this.writeBehindQueue.push(operation);
     const batchSize = this.options.writeBehind?.batchSize ?? 100;
@@ -2106,107 +2607,50 @@ var CacheStack = class extends 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);
+      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;
-  }
-  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);
-      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) {
@@ -2218,24 +2662,6 @@ var CacheStack = class extends 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;
@@ -2303,18 +2729,6 @@ var CacheStack = class extends 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") {
@@ -2327,43 +2741,72 @@ var CacheStack = class extends 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() {
-  return globalThis.crypto?.randomUUID?.() ?? `layercache-${Date.now()}-${Math.random().toString(36).slice(2)}`;
-}
 
 // src/invalidation/RedisInvalidationBus.ts
 var RedisInvalidationBus = class {
@@ -2404,7 +2847,7 @@ var RedisInvalidationBus = class {
   async dispatchToHandlers(payload) {
     let message;
     try {
-      const parsed = JSON.parse(payload);
+      const parsed = sanitizeJsonValue2(JSON.parse(payload));
       if (!this.isInvalidationMessage(parsed)) {
         throw new Error("Invalid invalidation payload shape.");
       }
@@ -2441,12 +2884,45 @@ var RedisInvalidationBus = class {
     console.error(`[layercache] ${message}`, error);
   }
 };
+var DANGEROUS_KEYS = /* @__PURE__ */ new Set(["__proto__", "prototype", "constructor"]);
+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((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], depth + 1, state);
+      }
+    }
+    return result;
+  }
+  return 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));
   };
 }
@@ -2481,7 +2957,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;
+      });
     }
   };
 }
@@ -2496,6 +2991,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);
@@ -2532,7 +3031,7 @@ function normalizeUrl(url) {
   try {
     const parsed = new URL(url, "http://localhost");
     parsed.searchParams.sort();
-    return decodeURIComponent(parsed.pathname) + parsed.search;
+    return parsed.pathname + parsed.search;
   } catch {
     return url;
   }
@@ -2540,6 +3039,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
@@ -2611,6 +3115,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;
@@ -2635,13 +3144,12 @@ function createTrpcCacheMiddleware(cache, prefix, options = {}) {
 }
 
 // src/layers/RedisLayer.ts
+import { Readable } from "stream";
 import { promisify } from "util";
-import { brotliCompress, brotliDecompress, gunzip, gzip } from "zlib";
+import { brotliCompress, createBrotliDecompress, createGunzip, gzip } from "zlib";
 var BATCH_DELETE_SIZE = 500;
 var gzipAsync = promisify(gzip);
-var gunzipAsync = promisify(gunzip);
 var brotliCompressAsync = promisify(brotliCompress);
-var brotliDecompressAsync = promisify(brotliDecompress);
 var RedisLayer = class {
   name;
   defaultTtl;
@@ -2749,8 +3257,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 {
@@ -2796,6 +3314,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";
@@ -2810,7 +3339,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);
@@ -2821,11 +3356,15 @@ var RedisLayer = class {
       } catch {
       }
     }
+    await this.deleteCorruptedKey(key);
+    return null;
+  }
+  async deleteCorruptedKey(key) {
     try {
-      await this.client.del(this.withPrefix(key)).catch(() => void 0);
-    } catch {
+      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);
@@ -2872,31 +3411,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(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(createBrotliDecompress(), payload.subarray(12));
     }
     return payload;
   }
+  async decompressWithLimit(decompressor, payload) {
+    return new Promise((resolve2, reject) => {
+      const source = 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
 import { createHash } from "crypto";
 import { promises as fs } from "fs";
 import { join, resolve } from "path";
+var FILE_SCAN_CONCURRENCY = 32;
 var DiskLayer = class {
   name;
   defaultTtl;
@@ -2904,6 +3484,7 @@ var DiskLayer = class {
   directory;
   serializer;
   maxFiles;
+  maxEntryBytes;
   writeQueue = Promise.resolve();
   constructor(options) {
     this.directory = this.resolveDirectory(options.directory);
@@ -2911,16 +3492,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 fs.readFile(filePath);
-    } catch {
+    const raw = await this.readEntryFile(filePath);
+    if (raw === null) {
       return null;
     }
     let entry;
@@ -2971,10 +3551,8 @@ var DiskLayer = class {
   }
   async ttl(key) {
     const filePath = this.keyToPath(key);
-    let raw;
-    try {
-      raw = await fs.readFile(filePath);
-    } catch {
+    const raw = await this.readEntryFile(filePath);
+    if (raw === null) {
       return null;
     }
     let entry;
@@ -2998,7 +3576,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() {
@@ -3009,8 +3587,8 @@ var DiskLayer = class {
       } catch {
         return;
       }
-      await Promise.all(
-        entries.filter((name) => name.endsWith(".lc")).map((name) => this.safeDelete(join(this.directory, name)))
+      await this.deletePathsWithConcurrency(
+        entries.filter((name) => name.endsWith(".lc")).map((name) => join(this.directory, name))
       );
     });
   }
@@ -3019,42 +3597,23 @@ var DiskLayer = class {
    * Expired entries are skipped and cleaned up during the scan.
    */
   async keys() {
-    let entries;
-    try {
-      entries = await fs.readdir(this.directory);
-    } catch {
-      return [];
-    }
-    const lcFiles = entries.filter((name) => name.endsWith(".lc"));
     const keys = [];
-    await Promise.all(
-      lcFiles.map(async (name) => {
-        const filePath = join(this.directory, name);
-        let raw;
-        try {
-          raw = await fs.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 {
@@ -3088,6 +3647,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 fs.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 fs.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 = 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)) {
@@ -3223,29 +3889,38 @@ var MemcachedLayer = class {
 
 // src/serialization/MsgpackSerializer.ts
 import { decode, encode } from "@msgpack/msgpack";
-var DANGEROUS_KEYS = /* @__PURE__ */ new Set(["__proto__", "prototype", "constructor"]);
+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(encode(value));
   }
   deserialize(payload) {
     const normalized = Buffer.isBuffer(payload) ? payload : Buffer.from(payload);
-    return sanitizeMsgpackValue(decode(normalized));
+    return sanitizeMsgpackValue(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;
   }
   const sanitized = {};
   for (const [key, entry] of Object.entries(value)) {
-    if (DANGEROUS_KEYS.has(key)) {
+    if (DANGEROUS_KEYS2.has(key)) {
       continue;
     }
-    sanitized[key] = sanitizeMsgpackValue(entry);
+    sanitized[key] = sanitizeMsgpackValue(entry, depth + 1, state);
   }
   return sanitized;
 }