layercache 1.2.3 → 1.2.5

package/dist/index.cjs

@@ -176,6 +176,7 @@ var CacheNamespace = class _CacheNamespace {
    * ```
    */
   namespace(childPrefix) {
+    validateNamespaceKey(childPrefix);
     return new _CacheNamespace(this.cache, `${this.prefix}:${childPrefix}`);
   }
   qualify(key) {
@@ -305,6 +306,118 @@ 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.");
+  }
+}
+
+// src/invalidation/PatternMatcher.ts
+var PatternMatcher = class _PatternMatcher {
+  /**
+   * Tests whether a glob-style pattern matches a value.
+   * Supports `*` (any sequence of characters) and `?` (any single character).
+   * Uses a two-pointer algorithm to avoid ReDoS vulnerabilities and
+   * quadratic memory usage on long patterns/keys.
+   */
+  static matches(pattern, value) {
+    return _PatternMatcher.matchLinear(pattern, value);
+  }
+  /**
+   * Linear-time glob matching with O(1) extra memory.
+   */
+  static matchLinear(pattern, value) {
+    let patternIndex = 0;
+    let valueIndex = 0;
+    let starIndex = -1;
+    let backtrackValueIndex = 0;
+    while (valueIndex < value.length) {
+      const patternChar = pattern[patternIndex];
+      const valueChar = value[valueIndex];
+      if (patternChar === "*" && patternIndex < pattern.length) {
+        starIndex = patternIndex;
+        patternIndex += 1;
+        backtrackValueIndex = valueIndex;
+        continue;
+      }
+      if (patternChar === "?" || patternChar === valueChar) {
+        patternIndex += 1;
+        valueIndex += 1;
+        continue;
+      }
+      if (starIndex !== -1) {
+        patternIndex = starIndex + 1;
+        backtrackValueIndex += 1;
+        valueIndex = backtrackValueIndex;
+        continue;
+      }
+      return false;
+    }
+    while (patternIndex < pattern.length && pattern[patternIndex] === "*") {
+      patternIndex += 1;
+    }
+    return patternIndex === pattern.length;
+  }
+};
+
+// src/internal/CacheKeyDiscovery.ts
+var CacheKeyDiscovery = class {
+  constructor(options) {
+    this.options = options;
+  }
+  options;
+  async collectKeysWithPrefix(prefix) {
+    const { tagIndex } = this.options;
+    const matches = new Set(
+      tagIndex.keysForPrefix ? await tagIndex.keysForPrefix(prefix) : await tagIndex.matchPattern(`${prefix}*`)
+    );
+    await Promise.all(
+      this.options.layers.map(async (layer) => {
+        if (!layer.keys || this.options.shouldSkipLayer(layer)) {
+          return;
+        }
+        try {
+          const keys = await layer.keys();
+          for (const key of keys) {
+            if (key.startsWith(prefix)) {
+              matches.add(key);
+            }
+          }
+        } catch (error) {
+          await this.options.handleLayerFailure(layer, "invalidate-prefix-scan", error);
+        }
+      })
+    );
+    return [...matches];
+  }
+  async collectKeysMatchingPattern(pattern) {
+    const matches = new Set(await this.options.tagIndex.matchPattern(pattern));
+    await Promise.all(
+      this.options.layers.map(async (layer) => {
+        if (!layer.keys || this.options.shouldSkipLayer(layer)) {
+          return;
+        }
+        try {
+          const keys = await layer.keys();
+          for (const key of keys) {
+            if (PatternMatcher.matches(pattern, key)) {
+              matches.add(key);
+            }
+          }
+        } catch (error) {
+          await this.options.handleLayerFailure(layer, "invalidate-pattern-scan", error);
+        }
+      })
+    );
+    return [...matches];
+  }
+};
 
 // src/internal/CircuitBreakerManager.ts
 var CircuitBreakerManager = class {
@@ -324,9 +437,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;
@@ -337,15 +448,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);
@@ -356,8 +467,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;
@@ -381,15 +491,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;
       }
@@ -399,6 +514,7 @@ var CircuitBreakerManager = class {
 };
 
 // src/internal/FetchRateLimiter.ts
+var MAX_BUCKETS = 1e4;
 var FetchRateLimiter = class {
   buckets = /* @__PURE__ */ new Map();
   queuesByBucket = /* @__PURE__ */ new Map();
@@ -564,10 +680,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) {
@@ -894,66 +1025,18 @@ 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;
-      }
-      this.accessProfiles.delete(key);
-      removed += 1;
-    }
-  }
-};
-
-// src/invalidation/PatternMatcher.ts
-var PatternMatcher = class _PatternMatcher {
-  /**
-   * Tests whether a glob-style pattern matches a value.
-   * Supports `*` (any sequence of characters) and `?` (any single character).
-   * Uses a two-pointer algorithm to avoid ReDoS vulnerabilities and
-   * quadratic memory usage on long patterns/keys.
-   */
-  static matches(pattern, value) {
-    return _PatternMatcher.matchLinear(pattern, value);
-  }
-  /**
-   * Linear-time glob matching with O(1) extra memory.
-   */
-  static matchLinear(pattern, value) {
-    let patternIndex = 0;
-    let valueIndex = 0;
-    let starIndex = -1;
-    let backtrackValueIndex = 0;
-    while (valueIndex < value.length) {
-      const patternChar = pattern[patternIndex];
-      const valueChar = value[valueIndex];
-      if (patternChar === "*" && patternIndex < pattern.length) {
-        starIndex = patternIndex;
-        patternIndex += 1;
-        backtrackValueIndex = valueIndex;
-        continue;
-      }
-      if (patternChar === "?" || patternChar === valueChar) {
-        patternIndex += 1;
-        valueIndex += 1;
-        continue;
-      }
-      if (starIndex !== -1) {
-        patternIndex = starIndex + 1;
-        backtrackValueIndex += 1;
-        valueIndex = backtrackValueIndex;
-        continue;
+    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]);
       }
-      return false;
-    }
-    while (patternIndex < pattern.length && pattern[patternIndex] === "*") {
-      patternIndex += 1;
     }
-    return patternIndex === pattern.length;
   }
 };
 
 // src/invalidation/TagIndex.ts
+var MAX_PATTERN_RECURSION_DEPTH = 500;
 var TagIndex = class {
   tagToKeys = /* @__PURE__ */ new Map();
   keyToTags = /* @__PURE__ */ new Map();
@@ -1008,7 +1091,7 @@ var TagIndex = class {
   }
   async matchPattern(pattern) {
     const matches = /* @__PURE__ */ new Set();
-    this.collectPatternMatches(this.root, "", pattern, 0, matches, /* @__PURE__ */ new Set());
+    this.collectPatternMatches(this.root, "", pattern, 0, matches, /* @__PURE__ */ new Set(), 0);
     return [...matches];
   }
   async clear() {
@@ -1060,7 +1143,10 @@ var TagIndex = class {
       this.collectFromNode(child, `${prefix}${character}`, matches);
     }
   }
-  collectPatternMatches(node, prefix, pattern, patternIndex, matches, visited) {
+  collectPatternMatches(node, prefix, pattern, patternIndex, matches, visited, depth) {
+    if (depth > MAX_PATTERN_RECURSION_DEPTH) {
+      return;
+    }
     const stateKey = `${node.id}:${patternIndex}`;
     if (visited.has(stateKey)) {
       return;
@@ -1077,21 +1163,37 @@ var TagIndex = class {
       return;
     }
     if (patternChar === "*") {
-      this.collectPatternMatches(node, prefix, pattern, patternIndex + 1, matches, visited);
+      this.collectPatternMatches(node, prefix, pattern, patternIndex + 1, matches, visited, depth + 1);
       for (const [character, child2] of node.children) {
-        this.collectPatternMatches(child2, `${prefix}${character}`, pattern, patternIndex, matches, visited);
+        this.collectPatternMatches(child2, `${prefix}${character}`, pattern, patternIndex, matches, visited, depth + 1);
       }
       return;
     }
     if (patternChar === "?") {
       for (const [character, child2] of node.children) {
-        this.collectPatternMatches(child2, `${prefix}${character}`, pattern, patternIndex + 1, matches, visited);
+        this.collectPatternMatches(
+          child2,
+          `${prefix}${character}`,
+          pattern,
+          patternIndex + 1,
+          matches,
+          visited,
+          depth + 1
+        );
       }
       return;
     }
     const child = node.children.get(patternChar);
     if (child) {
-      this.collectPatternMatches(child, `${prefix}${patternChar}`, pattern, patternIndex + 1, matches, visited);
+      this.collectPatternMatches(
+        child,
+        `${prefix}${patternChar}`,
+        pattern,
+        patternIndex + 1,
+        matches,
+        visited,
+        depth + 1
+      );
     }
   }
   pruneKnownKeysIfNeeded() {
@@ -1234,6 +1336,7 @@ 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_MAX_PROFILE_ENTRIES = 1e5;
 var DANGEROUS_OBJECT_KEYS = /* @__PURE__ */ new Set(["__proto__", "prototype", "constructor"]);
 var DebugLogger = class {
@@ -1282,6 +1385,14 @@ var CacheStack = class extends import_node_events.EventEmitter {
     const debugEnv = process.env.DEBUG?.split(",").includes("layercache:debug") ?? false;
     this.logger = typeof options.logger === "object" ? options.logger : new DebugLogger(Boolean(options.logger) || debugEnv);
     this.tagIndex = options.tagIndex ?? new TagIndex();
+    this.keyDiscovery = new CacheKeyDiscovery({
+      layers: this.layers,
+      tagIndex: this.tagIndex,
+      shouldSkipLayer: (layer) => this.shouldSkipLayer(layer),
+      handleLayerFailure: async (layer, operation, error) => {
+        await this.handleLayerFailure(layer, operation, error);
+      }
+    });
     if (!options.tagIndex && layers.some((layer) => layer.isLocal === false)) {
       this.logger.warn?.(
         "Using the default in-memory TagIndex with a shared cache layer only tracks keys seen by this process. Use RedisTagIndex for cross-instance tag invalidation."
@@ -1309,6 +1420,7 @@ var CacheStack = class extends import_node_events.EventEmitter {
   unsubscribeInvalidation;
   logger;
   tagIndex;
+  keyDiscovery;
   fetchRateLimiter = new FetchRateLimiter();
   snapshotSerializer = new JsonSerializer();
   backgroundRefreshes = /* @__PURE__ */ new Map();
@@ -1658,15 +1770,16 @@ var CacheStack = class extends import_node_events.EventEmitter {
     await this.publishInvalidation({ scope: "keys", keys, sourceId: this.instanceId, operation: "invalidate" });
   }
   async invalidateByPattern(pattern) {
+    this.validatePattern(pattern);
     await this.awaitStartup("invalidateByPattern");
-    const keys = await this.collectKeysMatchingPattern(this.qualifyPattern(pattern));
+    const keys = await this.keyDiscovery.collectKeysMatchingPattern(this.qualifyPattern(pattern));
     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.collectKeysWithPrefix(qualifiedPrefix);
+    const keys = await this.keyDiscovery.collectKeysWithPrefix(qualifiedPrefix);
     await this.deleteKeys(keys);
     await this.publishInvalidation({ scope: "keys", keys, sourceId: this.instanceId, operation: "invalidate" });
   }
@@ -2279,50 +2392,6 @@ var CacheStack = class extends import_node_events.EventEmitter {
   shouldBroadcastL1Invalidation() {
     return this.options.broadcastL1Invalidation ?? this.options.publishSetInvalidation ?? false;
   }
-  async collectKeysWithPrefix(prefix) {
-    const matches = new Set(
-      this.tagIndex.keysForPrefix ? await this.tagIndex.keysForPrefix(prefix) : await this.tagIndex.matchPattern(`${prefix}*`)
-    );
-    await Promise.all(
-      this.layers.map(async (layer) => {
-        if (!layer.keys || this.shouldSkipLayer(layer)) {
-          return;
-        }
-        try {
-          const keys = await layer.keys();
-          for (const key of keys) {
-            if (key.startsWith(prefix)) {
-              matches.add(key);
-            }
-          }
-        } catch (error) {
-          await this.handleLayerFailure(layer, "invalidate-prefix-scan", error);
-        }
-      })
-    );
-    return [...matches];
-  }
-  async collectKeysMatchingPattern(pattern) {
-    const matches = new Set(await this.tagIndex.matchPattern(pattern));
-    await Promise.all(
-      this.layers.map(async (layer) => {
-        if (!layer.keys || this.shouldSkipLayer(layer)) {
-          return;
-        }
-        try {
-          const keys = await layer.keys();
-          for (const key of keys) {
-            if (PatternMatcher.matches(pattern, key)) {
-              matches.add(key);
-            }
-          }
-        } catch (error) {
-          await this.handleLayerFailure(layer, "invalidate-pattern-scan", error);
-        }
-      })
-    );
-    return [...matches];
-  }
   shouldCleanupGenerations() {
     return Boolean(this.options.generationCleanup);
   }
@@ -2345,7 +2414,7 @@ var CacheStack = class extends import_node_events.EventEmitter {
   }
   async cleanupGeneration(generation) {
     const prefix = `v${generation}:`;
-    const keys = await this.collectKeysWithPrefix(prefix);
+    const keys = await this.keyDiscovery.collectKeysWithPrefix(prefix);
     if (keys.length === 0) {
       return;
     }
@@ -2595,6 +2664,17 @@ var CacheStack = class extends import_node_events.EventEmitter {
     }
     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;
@@ -2759,7 +2839,18 @@ var CacheStack = class extends import_node_events.EventEmitter {
   }
 };
 function createInstanceId() {
-  return globalThis.crypto?.randomUUID?.() ?? `layercache-${Date.now()}-${Math.random().toString(36).slice(2)}`;
+  if (globalThis.crypto?.randomUUID) {
+    return globalThis.crypto.randomUUID();
+  }
+  const bytes = new Uint8Array(16);
+  if (globalThis.crypto?.getRandomValues) {
+    globalThis.crypto.getRandomValues(bytes);
+  } else {
+    for (let i = 0; i < bytes.length; i++) {
+      bytes[i] = Math.floor(Math.random() * 256);
+    }
+  }
+  return `layercache-${Array.from(bytes, (b) => b.toString(16).padStart(2, "0")).join("")}`;
 }
 
 // src/invalidation/RedisInvalidationBus.ts
@@ -2801,7 +2892,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.");
       }
@@ -2838,6 +2929,22 @@ var RedisInvalidationBus = class {
     console.error(`[layercache] ${message}`, error);
   }
 };
+var DANGEROUS_KEYS = /* @__PURE__ */ new Set(["__proto__", "prototype", "constructor"]);
+function sanitizeJsonValue2(value) {
+  if (Array.isArray(value)) {
+    return value.map(sanitizeJsonValue2);
+  }
+  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]);
+      }
+    }
+    return result;
+  }
+  return value;
+}
 
 // src/invalidation/RedisTagIndex.ts
 var RedisTagIndex = class {
@@ -2978,6 +3085,8 @@ function createCacheStatsHandler(cache) {
   return async (_request, response) => {
     response.statusCode = 200;
     response.setHeader?.("content-type", "application/json; charset=utf-8");
+    response.setHeader?.("cache-control", "no-store");
+    response.setHeader?.("x-content-type-options", "nosniff");
     response.end(JSON.stringify(cache.getStats(), null, 2));
   };
 }
@@ -3063,7 +3172,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;
   }
@@ -3114,7 +3223,7 @@ function normalizeUrl2(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;
   }
@@ -3577,8 +3686,9 @@ var RedisLayer = class {
       }
     }
     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;
   }
@@ -3978,7 +4088,7 @@ var MemcachedLayer = class {
 
 // src/serialization/MsgpackSerializer.ts
 var import_msgpack = require("@msgpack/msgpack");
-var DANGEROUS_KEYS = /* @__PURE__ */ new Set(["__proto__", "prototype", "constructor"]);
+var DANGEROUS_KEYS2 = /* @__PURE__ */ new Set(["__proto__", "prototype", "constructor"]);
 var MsgpackSerializer = class {
   serialize(value) {
     return Buffer.from((0, import_msgpack.encode)(value));
@@ -3997,7 +4107,7 @@ function sanitizeMsgpackValue(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);

package/dist/index.d.cts

@@ -1,5 +1,5 @@
-import { I as InvalidationBus, C as CacheLogger, a as InvalidationMessage, b as CacheTagIndex, c as CacheStack, d as CacheWrapOptions, e as CacheGetOptions, f as CacheLayer, g as CacheSerializer, h as CacheLayerSetManyEntry, i as CacheSingleFlightCoordinator, j as CacheSingleFlightExecutionOptions } from './edge-B_rUqDy6.cjs';
-export { k as CacheAdaptiveTtlOptions, l as CacheCircuitBreakerOptions, m as CacheDegradationOptions, n as CacheHealthCheckResult, o as CacheHitRateSnapshot, p as CacheInspectResult, q as CacheLayerLatency, r as CacheMGetEntry, s as CacheMSetEntry, t as CacheMetricsSnapshot, u as CacheMissError, v as CacheNamespace, w as CacheRateLimitOptions, x as CacheSnapshotEntry, y as CacheStackEvents, z as CacheStackOptions, A as CacheStatsSnapshot, B as CacheTtlPolicy, D as CacheTtlPolicyContext, E as CacheWarmEntry, F as CacheWarmOptions, G as CacheWarmProgress, H as CacheWriteBehindOptions, J as CacheWriteOptions, K as EvictionPolicy, L as LayerTtlMap, M as MemoryLayer, N as MemoryLayerOptions, O as MemoryLayerSnapshotEntry, P as PatternMatcher, T as TagIndex, Q as createHonoCacheMiddleware } from './edge-B_rUqDy6.cjs';
+import { I as InvalidationBus, C as CacheLogger, a as InvalidationMessage, b as CacheTagIndex, c as CacheStack, d as CacheWrapOptions, e as CacheGetOptions, f as CacheLayer, g as CacheSerializer, h as CacheLayerSetManyEntry, i as CacheSingleFlightCoordinator, j as CacheSingleFlightExecutionOptions } from './edge-P07GCO2Y.cjs';
+export { k as CacheAdaptiveTtlOptions, l as CacheCircuitBreakerOptions, m as CacheDegradationOptions, n as CacheHealthCheckResult, o as CacheHitRateSnapshot, p as CacheInspectResult, q as CacheLayerLatency, r as CacheMGetEntry, s as CacheMSetEntry, t as CacheMetricsSnapshot, u as CacheMissError, v as CacheNamespace, w as CacheRateLimitOptions, x as CacheSnapshotEntry, y as CacheStackEvents, z as CacheStackOptions, A as CacheStatsSnapshot, B as CacheTtlPolicy, D as CacheTtlPolicyContext, E as CacheWarmEntry, F as CacheWarmOptions, G as CacheWarmProgress, H as CacheWriteBehindOptions, J as CacheWriteOptions, K as EvictionPolicy, L as LayerTtlMap, M as MemoryLayer, N as MemoryLayerOptions, O as MemoryLayerSnapshotEntry, P as PatternMatcher, T as TagIndex, Q as createHonoCacheMiddleware } from './edge-P07GCO2Y.cjs';
 import Redis from 'ioredis';
 import 'node:events';
 

package/dist/index.d.ts

@@ -1,5 +1,5 @@
-import { I as InvalidationBus, C as CacheLogger, a as InvalidationMessage, b as CacheTagIndex, c as CacheStack, d as CacheWrapOptions, e as CacheGetOptions, f as CacheLayer, g as CacheSerializer, h as CacheLayerSetManyEntry, i as CacheSingleFlightCoordinator, j as CacheSingleFlightExecutionOptions } from './edge-B_rUqDy6.js';
-export { k as CacheAdaptiveTtlOptions, l as CacheCircuitBreakerOptions, m as CacheDegradationOptions, n as CacheHealthCheckResult, o as CacheHitRateSnapshot, p as CacheInspectResult, q as CacheLayerLatency, r as CacheMGetEntry, s as CacheMSetEntry, t as CacheMetricsSnapshot, u as CacheMissError, v as CacheNamespace, w as CacheRateLimitOptions, x as CacheSnapshotEntry, y as CacheStackEvents, z as CacheStackOptions, A as CacheStatsSnapshot, B as CacheTtlPolicy, D as CacheTtlPolicyContext, E as CacheWarmEntry, F as CacheWarmOptions, G as CacheWarmProgress, H as CacheWriteBehindOptions, J as CacheWriteOptions, K as EvictionPolicy, L as LayerTtlMap, M as MemoryLayer, N as MemoryLayerOptions, O as MemoryLayerSnapshotEntry, P as PatternMatcher, T as TagIndex, Q as createHonoCacheMiddleware } from './edge-B_rUqDy6.js';
+import { I as InvalidationBus, C as CacheLogger, a as InvalidationMessage, b as CacheTagIndex, c as CacheStack, d as CacheWrapOptions, e as CacheGetOptions, f as CacheLayer, g as CacheSerializer, h as CacheLayerSetManyEntry, i as CacheSingleFlightCoordinator, j as CacheSingleFlightExecutionOptions } from './edge-P07GCO2Y.js';
+export { k as CacheAdaptiveTtlOptions, l as CacheCircuitBreakerOptions, m as CacheDegradationOptions, n as CacheHealthCheckResult, o as CacheHitRateSnapshot, p as CacheInspectResult, q as CacheLayerLatency, r as CacheMGetEntry, s as CacheMSetEntry, t as CacheMetricsSnapshot, u as CacheMissError, v as CacheNamespace, w as CacheRateLimitOptions, x as CacheSnapshotEntry, y as CacheStackEvents, z as CacheStackOptions, A as CacheStatsSnapshot, B as CacheTtlPolicy, D as CacheTtlPolicyContext, E as CacheWarmEntry, F as CacheWarmOptions, G as CacheWarmProgress, H as CacheWriteBehindOptions, J as CacheWriteOptions, K as EvictionPolicy, L as LayerTtlMap, M as MemoryLayer, N as MemoryLayerOptions, O as MemoryLayerSnapshotEntry, P as PatternMatcher, T as TagIndex, Q as createHonoCacheMiddleware } from './edge-P07GCO2Y.js';
 import Redis from 'ioredis';
 import 'node:events';