layercache 1.2.1 → 1.2.2

package/dist/index.cjs

@@ -400,11 +400,12 @@ var CircuitBreakerManager = class {
 
 // src/internal/FetchRateLimiter.ts
 var FetchRateLimiter = class {
-  active = 0;
   queue = [];
-  startedAt = [];
+  buckets = /* @__PURE__ */ new Map();
+  fetcherBuckets = /* @__PURE__ */ new WeakMap();
+  nextFetcherBucketId = 0;
   drainTimer;
-  async schedule(options, task) {
+  async schedule(options, context, task) {
     if (!options) {
       return task();
     }
@@ -412,8 +413,14 @@ var FetchRateLimiter = class {
     if (!normalized) {
       return task();
     }
-    return new Promise((resolve, reject) => {
-      this.queue.push({ options: normalized, task, resolve, reject });
+    return new Promise((resolve2, reject) => {
+      this.queue.push({
+        bucketKey: this.resolveBucketKey(normalized, context),
+        options: normalized,
+        task,
+        resolve: resolve2,
+        reject
+      });
       this.drain();
     });
   }
@@ -427,64 +434,110 @@ var FetchRateLimiter = class {
     return {
       maxConcurrent,
       intervalMs,
-      maxPerInterval
+      maxPerInterval,
+      scope: options.scope ?? "global",
+      bucketKey: options.bucketKey
     };
   }
+  resolveBucketKey(options, context) {
+    if (options.bucketKey) {
+      return `custom:${options.bucketKey}`;
+    }
+    if (options.scope === "key") {
+      return `key:${context.key}`;
+    }
+    if (options.scope === "fetcher") {
+      const existing = this.fetcherBuckets.get(context.fetcher);
+      if (existing) {
+        return existing;
+      }
+      const bucket = `fetcher:${this.nextFetcherBucketId}`;
+      this.nextFetcherBucketId += 1;
+      this.fetcherBuckets.set(context.fetcher, bucket);
+      return bucket;
+    }
+    return "global";
+  }
   drain() {
     if (this.drainTimer) {
       clearTimeout(this.drainTimer);
       this.drainTimer = void 0;
     }
     while (this.queue.length > 0) {
-      const next = this.queue[0];
-      if (!next) {
+      let nextIndex = -1;
+      let nextWaitMs = Number.POSITIVE_INFINITY;
+      for (let index = 0; index < this.queue.length; index += 1) {
+        const next2 = this.queue[index];
+        if (!next2) {
+          continue;
+        }
+        const waitMs = this.waitTime(next2.bucketKey, next2.options);
+        if (waitMs <= 0) {
+          nextIndex = index;
+          break;
+        }
+        nextWaitMs = Math.min(nextWaitMs, waitMs);
+      }
+      if (nextIndex < 0) {
+        if (Number.isFinite(nextWaitMs)) {
+          this.drainTimer = setTimeout(() => {
+            this.drainTimer = void 0;
+            this.drain();
+          }, nextWaitMs);
+          this.drainTimer.unref?.();
+        }
         return;
       }
-      const waitMs = this.waitTime(next.options);
-      if (waitMs > 0) {
-        this.drainTimer = setTimeout(() => {
-          this.drainTimer = void 0;
-          this.drain();
-        }, waitMs);
-        this.drainTimer.unref?.();
+      const next = this.queue.splice(nextIndex, 1)[0];
+      if (!next) {
         return;
       }
-      this.queue.shift();
-      this.active += 1;
-      this.startedAt.push(Date.now());
+      const bucket = this.bucketState(next.bucketKey);
+      bucket.active += 1;
+      bucket.startedAt.push(Date.now());
       void next.task().then(next.resolve, next.reject).finally(() => {
-        this.active -= 1;
+        bucket.active -= 1;
         this.drain();
       });
     }
   }
-  waitTime(options) {
+  waitTime(bucketKey, options) {
+    const bucket = this.bucketState(bucketKey);
     const now = Date.now();
-    if (options.maxConcurrent && this.active >= options.maxConcurrent) {
+    if (options.maxConcurrent && bucket.active >= options.maxConcurrent) {
       return 1;
     }
     if (!options.intervalMs || !options.maxPerInterval) {
       return 0;
     }
-    this.prune(now, options.intervalMs);
-    if (this.startedAt.length < options.maxPerInterval) {
+    this.prune(bucket, now, options.intervalMs);
+    if (bucket.startedAt.length < options.maxPerInterval) {
       return 0;
     }
-    const oldest = this.startedAt[0];
+    const oldest = bucket.startedAt[0];
     if (!oldest) {
       return 0;
     }
     return Math.max(1, options.intervalMs - (now - oldest));
   }
-  prune(now, intervalMs) {
-    while (this.startedAt.length > 0) {
-      const startedAt = this.startedAt[0];
+  prune(bucket, now, intervalMs) {
+    while (bucket.startedAt.length > 0) {
+      const startedAt = bucket.startedAt[0];
       if (startedAt === void 0 || now - startedAt < intervalMs) {
         break;
       }
-      this.startedAt.shift();
+      bucket.startedAt.shift();
     }
   }
+  bucketState(bucketKey) {
+    const existing = this.buckets.get(bucketKey);
+    if (existing) {
+      return existing;
+    }
+    const bucket = { active: 0, startedAt: [] };
+    this.buckets.set(bucketKey, bucket);
+    return bucket;
+  }
 };
 
 // src/internal/MetricsCollector.ts
@@ -1590,6 +1643,7 @@ var CacheStack = class extends import_node_events.EventEmitter {
     try {
       fetched = await this.fetchRateLimiter.schedule(
         options?.fetcherRateLimit ?? this.options.fetcherRateLimit,
+        { key, fetcher },
         fetcher
       );
       this.circuitBreakerManager.recordSuccess(key);
@@ -1847,7 +1901,8 @@ var CacheStack = class extends import_node_events.EventEmitter {
     return {
       leaseMs: this.options.singleFlightLeaseMs ?? DEFAULT_SINGLE_FLIGHT_LEASE_MS,
       waitTimeoutMs: this.options.singleFlightTimeoutMs ?? DEFAULT_SINGLE_FLIGHT_TIMEOUT_MS,
-      pollIntervalMs: this.options.singleFlightPollMs ?? DEFAULT_SINGLE_FLIGHT_POLL_MS
+      pollIntervalMs: this.options.singleFlightPollMs ?? DEFAULT_SINGLE_FLIGHT_POLL_MS,
+      renewIntervalMs: this.options.singleFlightRenewIntervalMs
     };
   }
   async deleteKeys(keys) {
@@ -1907,7 +1962,7 @@ var CacheStack = class extends import_node_events.EventEmitter {
     return String(error);
   }
   sleep(ms) {
-    return new Promise((resolve) => setTimeout(resolve, ms));
+    return new Promise((resolve2) => setTimeout(resolve2, ms));
   }
   shouldBroadcastL1Invalidation() {
     return this.options.broadcastL1Invalidation ?? this.options.publishSetInvalidation ?? true;
@@ -2052,6 +2107,8 @@ var CacheStack = class extends import_node_events.EventEmitter {
     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.validateRateLimitOptions("fetcherRateLimit", this.options.fetcherRateLimit);
     this.validateAdaptiveTtlOptions(this.options.adaptiveTtl);
     this.validateCircuitBreakerOptions(this.options.circuitBreaker);
     if (this.options.generation !== void 0) {
@@ -2071,6 +2128,7 @@ var CacheStack = class extends import_node_events.EventEmitter {
     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) {
@@ -2095,6 +2153,20 @@ var CacheStack = class extends import_node_events.EventEmitter {
       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.`);
@@ -2323,19 +2395,21 @@ var RedisTagIndex = class {
   client;
   prefix;
   scanCount;
+  knownKeysShards;
   constructor(options) {
     this.client = options.client;
     this.prefix = options.prefix ?? "layercache:tag-index";
     this.scanCount = options.scanCount ?? 100;
+    this.knownKeysShards = normalizeKnownKeysShards(options.knownKeysShards);
   }
   async touch(key) {
-    await this.client.sadd(this.knownKeysKey(), key);
+    await this.client.sadd(this.knownKeysKeyFor(key), key);
   }
   async track(key, tags) {
     const keyTagsKey = this.keyTagsKey(key);
     const existingTags = await this.client.smembers(keyTagsKey);
     const pipeline = this.client.pipeline();
-    pipeline.sadd(this.knownKeysKey(), key);
+    pipeline.sadd(this.knownKeysKeyFor(key), key);
     for (const tag of existingTags) {
       pipeline.srem(this.tagKeysKey(tag), key);
     }
@@ -2352,7 +2426,7 @@ var RedisTagIndex = class {
     const keyTagsKey = this.keyTagsKey(key);
     const existingTags = await this.client.smembers(keyTagsKey);
     const pipeline = this.client.pipeline();
-    pipeline.srem(this.knownKeysKey(), key);
+    pipeline.srem(this.knownKeysKeyFor(key), key);
     pipeline.del(keyTagsKey);
     for (const tag of existingTags) {
       pipeline.srem(this.tagKeysKey(tag), key);
@@ -2364,12 +2438,14 @@ var RedisTagIndex = class {
   }
   async keysForPrefix(prefix) {
     const matches = [];
-    let cursor = "0";
-    do {
-      const [nextCursor, keys] = await this.client.sscan(this.knownKeysKey(), cursor, "COUNT", this.scanCount);
-      cursor = nextCursor;
-      matches.push(...keys.filter((key) => key.startsWith(prefix)));
-    } while (cursor !== "0");
+    for (const knownKeysKey of this.knownKeysKeys()) {
+      let cursor = "0";
+      do {
+        const [nextCursor, keys] = await this.client.sscan(knownKeysKey, cursor, "COUNT", this.scanCount);
+        cursor = nextCursor;
+        matches.push(...keys.filter((key) => key.startsWith(prefix)));
+      } while (cursor !== "0");
+    }
     return matches;
   }
   async tagsForKey(key) {
@@ -2377,19 +2453,21 @@ var RedisTagIndex = class {
   }
   async matchPattern(pattern) {
     const matches = [];
-    let cursor = "0";
-    do {
-      const [nextCursor, keys] = await this.client.sscan(
-        this.knownKeysKey(),
-        cursor,
-        "MATCH",
-        pattern,
-        "COUNT",
-        this.scanCount
-      );
-      cursor = nextCursor;
-      matches.push(...keys.filter((key) => PatternMatcher.matches(pattern, key)));
-    } while (cursor !== "0");
+    for (const knownKeysKey of this.knownKeysKeys()) {
+      let cursor = "0";
+      do {
+        const [nextCursor, keys] = await this.client.sscan(
+          knownKeysKey,
+          cursor,
+          "MATCH",
+          pattern,
+          "COUNT",
+          this.scanCount
+        );
+        cursor = nextCursor;
+        matches.push(...keys.filter((key) => PatternMatcher.matches(pattern, key)));
+      } while (cursor !== "0");
+    }
     return matches;
   }
   async clear() {
@@ -2410,8 +2488,17 @@ var RedisTagIndex = class {
     } while (cursor !== "0");
     return matches;
   }
-  knownKeysKey() {
-    return `${this.prefix}:keys`;
+  knownKeysKeyFor(key) {
+    if (this.knownKeysShards === 1) {
+      return `${this.prefix}:keys`;
+    }
+    return `${this.prefix}:keys:${simpleHash(key) % this.knownKeysShards}`;
+  }
+  knownKeysKeys() {
+    if (this.knownKeysShards === 1) {
+      return [`${this.prefix}:keys`];
+    }
+    return Array.from({ length: this.knownKeysShards }, (_, index) => `${this.prefix}:keys:${index}`);
   }
   keyTagsKey(key) {
     return `${this.prefix}:key:${encodeURIComponent(key)}`;
@@ -2420,6 +2507,22 @@ var RedisTagIndex = class {
     return `${this.prefix}:tag:${encodeURIComponent(tag)}`;
   }
 };
+function normalizeKnownKeysShards(value) {
+  if (value === void 0) {
+    return 1;
+  }
+  if (!Number.isInteger(value) || value <= 0) {
+    throw new Error("RedisTagIndex.knownKeysShards must be a positive integer.");
+  }
+  return value;
+}
+function simpleHash(value) {
+  let hash = 0;
+  for (let index = 0; index < value.length; index += 1) {
+    hash = hash * 31 + value.charCodeAt(index) >>> 0;
+  }
+  return hash;
+}
 
 // src/http/createCacheStatsHandler.ts
 function createCacheStatsHandler(cache) {
@@ -2818,15 +2921,35 @@ var import_node_util = require("util");
 var import_node_zlib = require("zlib");
 
 // src/serialization/JsonSerializer.ts
+var DANGEROUS_JSON_KEYS = /* @__PURE__ */ new Set(["__proto__", "prototype", "constructor"]);
 var JsonSerializer = class {
   serialize(value) {
     return JSON.stringify(value);
   }
   deserialize(payload) {
     const normalized = Buffer.isBuffer(payload) ? payload.toString("utf8") : payload;
-    return JSON.parse(normalized);
+    return sanitizeJsonValue(JSON.parse(normalized));
   }
 };
+function sanitizeJsonValue(value) {
+  if (Array.isArray(value)) {
+    return value.map((entry) => sanitizeJsonValue(entry));
+  }
+  if (!isPlainObject(value)) {
+    return value;
+  }
+  const sanitized = {};
+  for (const [key, entry] of Object.entries(value)) {
+    if (DANGEROUS_JSON_KEYS.has(key)) {
+      continue;
+    }
+    sanitized[key] = sanitizeJsonValue(entry);
+  }
+  return sanitized;
+}
+function isPlainObject(value) {
+  return Object.prototype.toString.call(value) === "[object Object]";
+}
 
 // src/layers/RedisLayer.ts
 var BATCH_DELETE_SIZE = 500;
@@ -3083,11 +3206,11 @@ var DiskLayer = class {
   maxFiles;
   writeQueue = Promise.resolve();
   constructor(options) {
-    this.directory = options.directory;
+    this.directory = this.resolveDirectory(options.directory);
     this.defaultTtl = options.ttl;
     this.name = options.name ?? "disk";
     this.serializer = options.serializer ?? new JsonSerializer();
-    this.maxFiles = options.maxFiles;
+    this.maxFiles = this.normalizeMaxFiles(options.maxFiles);
   }
   async get(key) {
     return unwrapStoredValue(await this.getEntry(key));
@@ -3102,7 +3225,7 @@ var DiskLayer = class {
     }
     let entry;
     try {
-      entry = this.serializer.deserialize(raw);
+      entry = this.deserializeEntry(raw);
     } catch {
       await this.safeDelete(filePath);
       return null;
@@ -3153,8 +3276,9 @@ var DiskLayer = class {
     }
     let entry;
     try {
-      entry = this.serializer.deserialize(raw);
+      entry = this.deserializeEntry(raw);
     } catch {
+      await this.safeDelete(filePath);
       return null;
     }
     if (entry.expiresAt === null) {
@@ -3211,7 +3335,7 @@ var DiskLayer = class {
         }
         let entry;
         try {
-          entry = this.serializer.deserialize(raw);
+          entry = this.deserializeEntry(raw);
         } catch {
           await this.safeDelete(filePath);
           return;
@@ -3243,6 +3367,31 @@ var DiskLayer = class {
     const hash = (0, import_node_crypto.createHash)("sha256").update(key).digest("hex");
     return (0, import_node_path.join)(this.directory, `${hash}.lc`);
   }
+  resolveDirectory(directory) {
+    if (typeof directory !== "string" || directory.trim().length === 0) {
+      throw new Error("DiskLayer.directory must be a non-empty path.");
+    }
+    if (directory.includes("\0")) {
+      throw new Error("DiskLayer.directory must not contain null bytes.");
+    }
+    return (0, import_node_path.resolve)(directory);
+  }
+  normalizeMaxFiles(maxFiles) {
+    if (maxFiles === void 0) {
+      return void 0;
+    }
+    if (!Number.isInteger(maxFiles) || maxFiles <= 0) {
+      throw new Error("DiskLayer.maxFiles must be a positive integer.");
+    }
+    return maxFiles;
+  }
+  deserializeEntry(raw) {
+    const entry = this.serializer.deserialize(raw);
+    if (!isDiskEntry(entry)) {
+      throw new Error("Invalid disk cache entry.");
+    }
+    return entry;
+  }
   async safeDelete(filePath) {
     try {
       await import_node_fs.promises.unlink(filePath);
@@ -3287,6 +3436,14 @@ var DiskLayer = class {
     await Promise.all(toEvict.map(({ filePath }) => this.safeDelete(filePath)));
   }
 };
+function isDiskEntry(value) {
+  if (!value || typeof value !== "object") {
+    return false;
+  }
+  const candidate = value;
+  const validExpiry = candidate.expiresAt === null || typeof candidate.expiresAt === "number";
+  return typeof candidate.key === "string" && validExpiry && "value" in candidate;
+}
 
 // src/layers/MemcachedLayer.ts
 var MemcachedLayer = class {
@@ -3366,6 +3523,12 @@ if redis.call("get", KEYS[1]) == ARGV[1] then
 end
 return 0
 `;
+var RENEW_SCRIPT = `
+if redis.call("get", KEYS[1]) == ARGV[1] then
+  return redis.call("pexpire", KEYS[1], ARGV[2])
+end
+return 0
+`;
 var RedisSingleFlightCoordinator = class {
   client;
   prefix;
@@ -3378,14 +3541,29 @@ var RedisSingleFlightCoordinator = class {
     const token = (0, import_node_crypto2.randomUUID)();
     const acquired = await this.client.set(lockKey, token, "PX", options.leaseMs, "NX");
     if (acquired === "OK") {
+      const renewTimer = this.startLeaseRenewal(lockKey, token, options);
       try {
         return await worker();
       } finally {
+        if (renewTimer) {
+          clearInterval(renewTimer);
+        }
         await this.client.eval(RELEASE_SCRIPT, 1, lockKey, token);
       }
     }
     return waiter();
   }
+  startLeaseRenewal(lockKey, token, options) {
+    const renewIntervalMs = options.renewIntervalMs ?? Math.max(100, Math.floor(options.leaseMs / 2));
+    if (renewIntervalMs <= 0 || renewIntervalMs >= options.leaseMs) {
+      return void 0;
+    }
+    const timer = setInterval(() => {
+      void this.client.eval(RENEW_SCRIPT, 1, lockKey, token, String(options.leaseMs)).catch(() => void 0);
+    }, renewIntervalMs);
+    timer.unref?.();
+    return timer;
+  }
 };
 
 // src/metrics/PrometheusExporter.ts

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-C1sBhTfv.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-C1sBhTfv.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-DLpdQN0W.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-DLpdQN0W.cjs';
 import Redis from 'ioredis';
 import 'node:events';
 
@@ -35,11 +35,13 @@ interface RedisTagIndexOptions {
     client: Redis;
     prefix?: string;
     scanCount?: number;
+    knownKeysShards?: number;
 }
 declare class RedisTagIndex implements CacheTagIndex {
     private readonly client;
     private readonly prefix;
     private readonly scanCount;
+    private readonly knownKeysShards;
     constructor(options: RedisTagIndexOptions);
     touch(key: string): Promise<void>;
     track(key: string, tags: string[]): Promise<void>;
@@ -50,7 +52,8 @@ declare class RedisTagIndex implements CacheTagIndex {
     matchPattern(pattern: string): Promise<string[]>;
     clear(): Promise<void>;
     private scanIndexKeys;
-    private knownKeysKey;
+    private knownKeysKeyFor;
+    private knownKeysKeys;
     private keyTagsKey;
     private tagKeysKey;
 }
@@ -274,6 +277,9 @@ declare class DiskLayer implements CacheLayer {
     ping(): Promise<boolean>;
     dispose(): Promise<void>;
     private keyToPath;
+    private resolveDirectory;
+    private normalizeMaxFiles;
+    private deserializeEntry;
     private safeDelete;
     private enqueueWrite;
     /**
@@ -362,6 +368,7 @@ declare class RedisSingleFlightCoordinator implements CacheSingleFlightCoordinat
     private readonly prefix;
     constructor(options: RedisSingleFlightCoordinatorOptions);
     execute<T>(key: string, options: CacheSingleFlightExecutionOptions, worker: () => Promise<T>, waiter: () => Promise<T>): Promise<T>;
+    private startLeaseRenewal;
 }
 
 declare class StampedeGuard {

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-C1sBhTfv.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-C1sBhTfv.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-DLpdQN0W.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-DLpdQN0W.js';
 import Redis from 'ioredis';
 import 'node:events';
 
@@ -35,11 +35,13 @@ interface RedisTagIndexOptions {
     client: Redis;
     prefix?: string;
     scanCount?: number;
+    knownKeysShards?: number;
 }
 declare class RedisTagIndex implements CacheTagIndex {
     private readonly client;
     private readonly prefix;
     private readonly scanCount;
+    private readonly knownKeysShards;
     constructor(options: RedisTagIndexOptions);
     touch(key: string): Promise<void>;
     track(key: string, tags: string[]): Promise<void>;
@@ -50,7 +52,8 @@ declare class RedisTagIndex implements CacheTagIndex {
     matchPattern(pattern: string): Promise<string[]>;
     clear(): Promise<void>;
     private scanIndexKeys;
-    private knownKeysKey;
+    private knownKeysKeyFor;
+    private knownKeysKeys;
     private keyTagsKey;
     private tagKeysKey;
 }
@@ -274,6 +277,9 @@ declare class DiskLayer implements CacheLayer {
     ping(): Promise<boolean>;
     dispose(): Promise<void>;
     private keyToPath;
+    private resolveDirectory;
+    private normalizeMaxFiles;
+    private deserializeEntry;
     private safeDelete;
     private enqueueWrite;
     /**
@@ -362,6 +368,7 @@ declare class RedisSingleFlightCoordinator implements CacheSingleFlightCoordinat
     private readonly prefix;
     constructor(options: RedisSingleFlightCoordinatorOptions);
     execute<T>(key: string, options: CacheSingleFlightExecutionOptions, worker: () => Promise<T>, waiter: () => Promise<T>): Promise<T>;
+    private startLeaseRenewal;
 }
 
 declare class StampedeGuard {