layercache 1.2.5 → 1.2.6

package/packages/nestjs/dist/index.cjs

@@ -264,22 +264,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)));
@@ -288,7 +289,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)));
@@ -304,7 +305,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)
         }))
       )
     );
@@ -314,16 +316,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)));
@@ -335,16 +343,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
     );
@@ -380,6 +396,24 @@ 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();
@@ -514,6 +548,9 @@ function validateNamespaceKey(key) {
   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/invalidation/PatternMatcher.ts
@@ -570,21 +607,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) {
@@ -594,18 +651,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) {
@@ -615,8 +693,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, fs, path) {
+  let current = directory;
+  while (true) {
+    try {
+      await fs.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: fs } = 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 fs.mkdir(baseDir, { recursive: true });
+  const realBaseDir = await fs.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 fs.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, fs, path);
+  const realExistingAncestor = await fs.realpath(existingAncestor);
+  if (!isWithinSnapshotBase(realBaseDir, realExistingAncestor, path.sep, path)) {
+    throw new Error(`filePath is outside the allowed snapshot directory: ${realBaseDir}`);
+  }
+  await fs.mkdir(parentDir, { recursive: true });
+  const realParentDir = await fs.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 fs.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();
@@ -1010,19 +1360,47 @@ function isStoredValueEnvelope(value) {
   if (v.kind !== "value" && v.kind !== "empty") {
     return false;
   }
-  if (v.freshUntil !== null && typeof v.freshUntil !== "number") {
+  if (v.freshUntil !== null && (!Number.isFinite(v.freshUntil) || typeof v.freshUntil !== "number")) {
     return false;
   }
-  if (v.staleUntil !== null && typeof v.staleUntil !== "number") {
+  if (v.staleUntil !== null && (!Number.isFinite(v.staleUntil) || typeof v.staleUntil !== "number")) {
     return false;
   }
-  if (v.errorUntil !== null && typeof v.errorUntil !== "number") {
+  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) {
@@ -1121,6 +1499,12 @@ function normalizePositiveSeconds(value) {
   }
   return value;
 }
+function isValidEnvelopeTtlSeconds(value, maxTtlSeconds) {
+  if (value == null) {
+    return true;
+  }
+  return typeof value === "number" && Number.isFinite(value) && value > 0 && value <= maxTtlSeconds;
+}
 
 // ../../src/internal/TtlResolver.ts
 var DEFAULT_NEGATIVE_TTL_SECONDS = 60;
@@ -1275,6 +1659,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) {
@@ -1284,6 +1673,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()];
   }
@@ -1292,6 +1688,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();
@@ -1341,6 +1743,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;
@@ -1458,22 +1868,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;
@@ -1483,7 +1898,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;
 }
@@ -1532,10 +1947,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) {
@@ -1622,6 +2038,7 @@ var CacheStack = class extends import_node_events.EventEmitter {
   snapshotSerializer = new JsonSerializer();
   backgroundRefreshes = /* @__PURE__ */ new Map();
   layerDegradedUntil = /* @__PURE__ */ new Map();
+  keyEpochs = /* @__PURE__ */ new Map();
   ttlResolver;
   circuitBreakerManager;
   currentGeneration;
@@ -1629,6 +2046,7 @@ var CacheStack = class extends import_node_events.EventEmitter {
   writeBehindTimer;
   writeBehindFlushPromise;
   generationCleanupPromise;
+  clearEpoch = 0;
   isDisconnecting = false;
   disconnectPromise;
   /**
@@ -1638,7 +2056,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);
@@ -1708,7 +2126,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)) {
@@ -1741,7 +2159,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)) {
@@ -1763,7 +2181,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);
@@ -1772,7 +2190,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({
@@ -1784,6 +2202,7 @@ var CacheStack = class extends import_node_events.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();
@@ -1800,7 +2219,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({
@@ -1817,7 +2236,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);
@@ -1826,7 +2245,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);
@@ -1895,7 +2314,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");
@@ -1938,7 +2357,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);
     };
@@ -1948,11 +2367,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" });
   }
@@ -1960,23 +2381,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" });
   }
@@ -2046,7 +2472,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 = [];
@@ -2083,50 +2509,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: fs } = await import("fs");
-    await fs.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 fs.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 fs.rename(tempPath, targetPath);
+    } catch (error) {
+      await handle?.close().catch(() => void 0);
+      await fs.unlink(tempPath).catch(() => void 0);
+      throw error;
+    }
   }
   async restoreFromFile(filePath) {
     this.assertActive("restoreFromFile");
-    const { promises: fs } = await import("fs");
-    const raw = await fs.readFile(await this.validateSnapshotFilePath(filePath), "utf8");
+    const { promises: fs, constants } = await import("fs");
+    const validatedPath = await validateSnapshotFilePath(filePath, "read", this.options.snapshotBaseDir);
+    const handle = await fs.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);
@@ -2170,14 +2625,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) {
@@ -2187,7 +2642,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) {
@@ -2195,7 +2650,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;
@@ -2209,9 +2664,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();
@@ -2232,6 +2687,16 @@ var CacheStack = class extends import_node_events.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;
     }
@@ -2244,11 +2709,26 @@ var CacheStack = class extends import_node_events.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 {
@@ -2263,6 +2743,8 @@ var CacheStack = class extends import_node_events.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 = [];
@@ -2279,12 +2761,21 @@ var CacheStack = class extends import_node_events.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);
         }
@@ -2297,7 +2788,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.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 {
@@ -2399,10 +2896,15 @@ var CacheStack = class extends import_node_events.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;
         }
@@ -2466,10 +2968,12 @@ var CacheStack = class extends import_node_events.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) });
@@ -2479,14 +2983,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() {
@@ -2501,6 +3007,7 @@ var CacheStack = class extends import_node_events.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);
@@ -2523,21 +3030,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.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);
       }
     }
   }
@@ -2643,6 +3151,28 @@ var CacheStack = class extends import_node_events.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;
@@ -2769,118 +3299,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);
+      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.");
-    }
-  }
-  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) {
@@ -2892,24 +3354,6 @@ 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;
@@ -2977,18 +3421,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") {
@@ -3001,54 +3433,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/module.ts
 var InjectCacheStack = () => (0, import_common.Inject)(CACHE_STACK);