layercache 1.2.8 → 1.2.9

package/README.md

@@ -15,8 +15,8 @@
   <a href="./LICENSE"><img src="https://img.shields.io/badge/license-Apache_2.0-green" alt="license"></a>
   <a href="https://www.typescriptlang.org/"><img src="https://img.shields.io/badge/TypeScript-first-3178C6?logo=typescript&logoColor=white" alt="TypeScript"></a>
   <img src="https://img.shields.io/badge/Node.js-%E2%89%A5_20-339933?logo=nodedotjs&logoColor=white" alt="Node.js >= 20">
-  <img src="https://img.shields.io/badge/tests-397_passing-brightgreen" alt="tests">
-  <a href="https://coveralls.io/github/flyingsquirrel0419/layercache?branch=main"><img src="https://coveralls.io/repos/github/flyingsquirrel0419/layercache/badge.svg?branch=main&t=20260409" alt="Coveralls"></a>
+  <img src="https://img.shields.io/badge/tests-411_passing-brightgreen" alt="tests">
+  <a href="https://coveralls.io/github/flyingsquirrel0419/layercache?branch=main"><img src="https://coveralls.io/repos/github/flyingsquirrel0419/layercache/badge.svg?branch=main&t=20260410" alt="Coveralls"></a>
 </p>
 
 <p align="center">

package/dist/cli.cjs

@@ -465,6 +465,11 @@ function parseArgs(argv) {
     const token = rest[index];
     const value = rest[index + 1];
     if (token === "--redis") {
+      if (!value || value.startsWith("--")) {
+        process.stderr.write("Error: --redis requires a value (e.g. redis://localhost:6379)\n");
+        process.exitCode = 1;
+        return parsed;
+      }
       parsed.redisUrl = value;
       index += 1;
     } else if (token === "--pattern") {
@@ -484,6 +489,7 @@ function parseArgs(argv) {
   return parsed;
 }
 var BATCH_DELETE_SIZE = 500;
+var SCAN_MAX_KEYS = 1e6;
 async function batchDelete(redis, keys) {
   for (let i = 0; i < keys.length; i += BATCH_DELETE_SIZE) {
     const batch = keys.slice(i, i + BATCH_DELETE_SIZE);
@@ -497,6 +503,13 @@ async function scanKeys(redis, pattern) {
     const [nextCursor, batch] = await redis.scan(cursor, "MATCH", pattern, "COUNT", 100);
     cursor = nextCursor;
     keys.push(...batch);
+    if (keys.length >= SCAN_MAX_KEYS) {
+      process.stderr.write(
+        `Warning: stopped scanning after ${SCAN_MAX_KEYS} keys. Use a more specific --pattern to narrow results.
+`
+      );
+      return keys;
+    }
   } while (cursor !== "0");
   return keys;
 }
@@ -539,7 +552,7 @@ function maskRedisUrl(url) {
     return url.replace(/:([^@/]+)@/, ":***@");
   }
 }
-if (process.argv[1]?.includes("cli.")) {
+if (process.argv[1]?.endsWith("cli.cjs") || process.argv[1]?.endsWith("cli.js")) {
   void main();
 }
 // Annotate the CommonJS export names for ESM import in node:

package/dist/cli.js

@@ -123,6 +123,11 @@ function parseArgs(argv) {
     const token = rest[index];
     const value = rest[index + 1];
     if (token === "--redis") {
+      if (!value || value.startsWith("--")) {
+        process.stderr.write("Error: --redis requires a value (e.g. redis://localhost:6379)\n");
+        process.exitCode = 1;
+        return parsed;
+      }
       parsed.redisUrl = value;
       index += 1;
     } else if (token === "--pattern") {
@@ -142,6 +147,7 @@ function parseArgs(argv) {
   return parsed;
 }
 var BATCH_DELETE_SIZE = 500;
+var SCAN_MAX_KEYS = 1e6;
 async function batchDelete(redis, keys) {
   for (let i = 0; i < keys.length; i += BATCH_DELETE_SIZE) {
     const batch = keys.slice(i, i + BATCH_DELETE_SIZE);
@@ -155,6 +161,13 @@ async function scanKeys(redis, pattern) {
     const [nextCursor, batch] = await redis.scan(cursor, "MATCH", pattern, "COUNT", 100);
     cursor = nextCursor;
     keys.push(...batch);
+    if (keys.length >= SCAN_MAX_KEYS) {
+      process.stderr.write(
+        `Warning: stopped scanning after ${SCAN_MAX_KEYS} keys. Use a more specific --pattern to narrow results.
+`
+      );
+      return keys;
+    }
   } while (cursor !== "0");
   return keys;
 }
@@ -197,7 +210,7 @@ function maskRedisUrl(url) {
     return url.replace(/:([^@/]+)@/, ":***@");
   }
 }
-if (process.argv[1]?.includes("cli.")) {
+if (process.argv[1]?.endsWith("cli.cjs") || process.argv[1]?.endsWith("cli.js")) {
   void main();
 }
 export {

package/dist/{edge-DBs8Ko5W.d.cts → edge-BXWTKlI1.d.cts}

@@ -556,6 +556,7 @@ declare class CacheStack extends EventEmitter {
     private readonly layerWriter;
     private readonly snapshots;
     private readonly backgroundRefreshes;
+    private readonly backgroundRefreshAbort;
     private readonly layerDegradedUntil;
     private readonly maintenance;
     private readonly ttlResolver;

package/dist/{edge-DBs8Ko5W.d.ts → edge-BXWTKlI1.d.ts}

@@ -556,6 +556,7 @@ declare class CacheStack extends EventEmitter {
     private readonly layerWriter;
     private readonly snapshots;
     private readonly backgroundRefreshes;
+    private readonly backgroundRefreshAbort;
     private readonly layerDegradedUntil;
     private readonly maintenance;
     private readonly ttlResolver;

package/dist/edge.d.cts

@@ -1,2 +1,2 @@
-export { e as CacheGetOptions, f as CacheLayer, h as CacheLayerSetManyEntry, t as CacheMetricsSnapshot, w as CacheRateLimitOptions, B as CacheTtlPolicy, D as CacheTtlPolicyContext, J as CacheWriteOptions, K as EvictionPolicy, M as MemoryLayer, N as MemoryLayerOptions, O as MemoryLayerSnapshotEntry, P as PatternMatcher, T as TagIndex, Q as createHonoCacheMiddleware } from './edge-DBs8Ko5W.cjs';
+export { e as CacheGetOptions, f as CacheLayer, h as CacheLayerSetManyEntry, t as CacheMetricsSnapshot, w as CacheRateLimitOptions, B as CacheTtlPolicy, D as CacheTtlPolicyContext, J as CacheWriteOptions, K as EvictionPolicy, M as MemoryLayer, N as MemoryLayerOptions, O as MemoryLayerSnapshotEntry, P as PatternMatcher, T as TagIndex, Q as createHonoCacheMiddleware } from './edge-BXWTKlI1.cjs';
 import 'node:events';

package/dist/edge.d.ts

@@ -1,2 +1,2 @@
-export { e as CacheGetOptions, f as CacheLayer, h as CacheLayerSetManyEntry, t as CacheMetricsSnapshot, w as CacheRateLimitOptions, B as CacheTtlPolicy, D as CacheTtlPolicyContext, J as CacheWriteOptions, K as EvictionPolicy, M as MemoryLayer, N as MemoryLayerOptions, O as MemoryLayerSnapshotEntry, P as PatternMatcher, T as TagIndex, Q as createHonoCacheMiddleware } from './edge-DBs8Ko5W.js';
+export { e as CacheGetOptions, f as CacheLayer, h as CacheLayerSetManyEntry, t as CacheMetricsSnapshot, w as CacheRateLimitOptions, B as CacheTtlPolicy, D as CacheTtlPolicyContext, J as CacheWriteOptions, K as EvictionPolicy, M as MemoryLayer, N as MemoryLayerOptions, O as MemoryLayerSnapshotEntry, P as PatternMatcher, T as TagIndex, Q as createHonoCacheMiddleware } from './edge-BXWTKlI1.js';
 import 'node:events';

package/dist/index.cjs

@@ -528,7 +528,7 @@ function normalizeForSerialization(value) {
 }
 function serializeKeyPart(value) {
   if (typeof value === "string") {
-    return `s:${value}`;
+    return `s:${value.replace(/%/g, "%25").replace(/:/g, "%3A")}`;
   }
   if (typeof value === "number") {
     return `n:${value}`;
@@ -917,6 +917,7 @@ var CacheStackLayerWriter = class {
     }
     const results = await Promise.allSettled(operations.map((operation) => operation()));
     const failures = results.filter((result) => result.status === "rejected");
+    const degraded = results.filter((result) => result.status === "fulfilled");
     if (failures.length === 0) {
       return;
     }
@@ -1095,6 +1096,7 @@ function planFreshReadPolicies({
 }
 
 // src/internal/CacheStackSnapshotManager.ts
+var import_node_crypto = require("crypto");
 var import_node_fs = require("fs");
 var import_node_path = __toESM(require("path"), 1);
 
@@ -1194,6 +1196,42 @@ async function readUtf8HandleWithLimit(handle, byteLimit) {
   return Buffer.concat(chunks).toString("utf8");
 }
 
+// src/internal/StructuredDataSanitizer.ts
+var DANGEROUS_KEYS = /* @__PURE__ */ new Set(["__proto__", "prototype", "constructor"]);
+function sanitizeStructuredData(value, options) {
+  return sanitizeValue(value, 0, { count: 0 }, options);
+}
+function sanitizeValue(value, depth, state, options) {
+  state.count += 1;
+  if (state.count > options.maxNodes) {
+    throw new Error(`${options.label} exceeds max node count of ${options.maxNodes}.`);
+  }
+  if (depth > options.maxDepth) {
+    throw new Error(`${options.label} exceeds max depth of ${options.maxDepth}.`);
+  }
+  if (Array.isArray(value)) {
+    const sanitized2 = [];
+    for (const entry of value) {
+      sanitized2.push(sanitizeValue(entry, depth + 1, state, options));
+    }
+    return sanitized2;
+  }
+  if (!isPlainObject(value)) {
+    return value;
+  }
+  const sanitized = options.createObject?.() ?? {};
+  for (const [key, entry] of Object.entries(value)) {
+    if (DANGEROUS_KEYS.has(key)) {
+      continue;
+    }
+    sanitized[key] = sanitizeValue(entry, depth + 1, state, options);
+  }
+  return sanitized;
+}
+function isPlainObject(value) {
+  return Object.prototype.toString.call(value) === "[object Object]";
+}
+
 // src/internal/CacheStackSnapshotManager.ts
 var DEFAULT_SNAPSHOT_IMPORT_BATCH_SIZE = 50;
 var CacheStackSnapshotManager = class {
@@ -1218,7 +1256,16 @@ var CacheStackSnapshotManager = class {
       const batch = normalizedEntries.slice(index, index + DEFAULT_SNAPSHOT_IMPORT_BATCH_SIZE);
       await Promise.all(
         batch.map(async (entry) => {
-          await Promise.all(this.options.layers.map((layer) => layer.set(entry.key, entry.value, entry.ttl)));
+          await Promise.all(
+            this.options.layers.map(async (layer) => {
+              if (this.options.shouldSkipLayer(layer)) return;
+              try {
+                await layer.set(entry.key, entry.value, entry.ttl);
+              } catch (error) {
+                await this.options.handleLayerFailure(layer, "write", error);
+              }
+            })
+          );
           await this.options.tagIndex.touch(entry.key);
         })
       );
@@ -1228,7 +1275,7 @@ var CacheStackSnapshotManager = class {
     const targetPath = await validateSnapshotFilePath(filePath, "write", snapshotBaseDir);
     const tempPath = import_node_path.default.join(
       import_node_path.default.dirname(targetPath),
-      `.layercache-${process.pid}-${Date.now()}-${Math.random().toString(36).slice(2)}.tmp`
+      `.layercache-${process.pid}-${Date.now()}-${(0, import_node_crypto.randomBytes)(8).toString("hex")}.tmp`
     );
     let handle;
     try {
@@ -1328,7 +1375,13 @@ var CacheStackSnapshotManager = class {
     });
   }
   sanitizeSnapshotValue(value) {
-    return this.options.snapshotSerializer.deserialize(this.options.snapshotSerializer.serialize(value));
+    const roundTripped = this.options.snapshotSerializer.deserialize(this.options.snapshotSerializer.serialize(value));
+    return sanitizeStructuredData(roundTripped, {
+      label: "Snapshot value",
+      maxDepth: 64,
+      maxNodes: 1e4,
+      createObject: () => /* @__PURE__ */ Object.create(null)
+    });
   }
 };
 
@@ -1708,7 +1761,13 @@ var FetchRateLimiter = class {
           this.pendingBuckets.add(next.bucketKey);
         }
         this.cleanupBucket(next.bucketKey, bucket, next.options.intervalMs);
-        this.drain();
+        if (!this.drainTimer) {
+          this.drainTimer = setTimeout(() => {
+            this.drainTimer = void 0;
+            this.drain();
+          }, 0);
+          this.drainTimer.unref?.();
+        }
       });
     }
   }
@@ -1750,6 +1809,9 @@ var FetchRateLimiter = class {
     }
     if (this.buckets.size >= MAX_BUCKETS) {
       this.evictIdleBuckets();
+      if (this.buckets.size >= MAX_BUCKETS) {
+        throw new Error(`FetchRateLimiter bucket limit (${MAX_BUCKETS}) exceeded.`);
+      }
     }
     const bucket = { active: 0, startedAt: [] };
     this.buckets.set(bucketKey, bucket);
@@ -2228,38 +2290,6 @@ var TagIndex = class {
   }
 };
 
-// src/internal/StructuredDataSanitizer.ts
-var DANGEROUS_KEYS = /* @__PURE__ */ new Set(["__proto__", "prototype", "constructor"]);
-function sanitizeStructuredData(value, options) {
-  return sanitizeValue(value, 0, { count: 0 }, options);
-}
-function sanitizeValue(value, depth, state, options) {
-  state.count += 1;
-  if (state.count > options.maxNodes) {
-    throw new Error(`${options.label} exceeds max node count of ${options.maxNodes}.`);
-  }
-  if (depth > options.maxDepth) {
-    throw new Error(`${options.label} exceeds max depth of ${options.maxDepth}.`);
-  }
-  if (Array.isArray(value)) {
-    return value.map((entry) => sanitizeValue(entry, depth + 1, state, options));
-  }
-  if (!isPlainObject(value)) {
-    return value;
-  }
-  const sanitized = options.createObject?.() ?? {};
-  for (const [key, entry] of Object.entries(value)) {
-    if (DANGEROUS_KEYS.has(key)) {
-      continue;
-    }
-    sanitized[key] = sanitizeValue(entry, depth + 1, state, options);
-  }
-  return sanitized;
-}
-function isPlainObject(value) {
-  return Object.prototype.toString.call(value) === "[object Object]";
-}
-
 // src/serialization/JsonSerializer.ts
 var JsonSerializer = class {
   serialize(value) {
@@ -2424,6 +2454,8 @@ var CacheStack = class extends import_node_events.EventEmitter {
       tagIndex: this.tagIndex,
       snapshotSerializer: this.snapshotSerializer,
       readLayerEntry: this.readLayerEntry.bind(this),
+      shouldSkipLayer: (layer) => this.shouldSkipLayer(layer),
+      handleLayerFailure: async (layer, operation, error) => this.handleLayerFailure(layer, operation, error),
       qualifyKey: this.qualifyKey.bind(this),
       stripQualifiedKey: this.stripQualifiedKey.bind(this),
       validateCacheKey,
@@ -2448,6 +2480,7 @@ var CacheStack = class extends import_node_events.EventEmitter {
   layerWriter;
   snapshots;
   backgroundRefreshes = /* @__PURE__ */ new Map();
+  backgroundRefreshAbort = /* @__PURE__ */ new Map();
   layerDegradedUntil = /* @__PURE__ */ new Map();
   maintenance = new CacheStackMaintenance();
   ttlResolver;
@@ -2692,7 +2725,7 @@ var CacheStack = class extends import_node_events.EventEmitter {
       }
       for (let layerIndex = 0; layerIndex < this.layers.length; layerIndex += 1) {
         const layer = this.layers[layerIndex];
-        if (!layer) continue;
+        if (!layer || this.shouldSkipLayer(layer)) continue;
         const keys = [...pending];
         if (keys.length === 0) {
           break;
@@ -2709,6 +2742,9 @@ var CacheStack = class extends import_node_events.EventEmitter {
             await layer.delete(key);
             continue;
           }
+          if (resolved.state === "stale-while-revalidate" || resolved.state === "stale-if-error") {
+            this.metricsCollector.increment("staleHits", indexesByKey.get(key)?.length ?? 1);
+          }
           await this.tagIndex.touch(key);
           await this.backfill(key, stored, layerIndex - 1);
           resultsByKey.set(key, resolved.value);
@@ -2964,7 +3000,25 @@ var CacheStack = class extends import_node_events.EventEmitter {
         await this.unsubscribeInvalidation?.();
         await this.flushWriteBehindQueue();
         await this.maintenance.waitForGenerationCleanup();
-        await Promise.allSettled([...this.backgroundRefreshes.values()]);
+        for (const key of this.backgroundRefreshAbort.keys()) {
+          this.backgroundRefreshAbort.set(key, true);
+        }
+        await Promise.allSettled(
+          [...this.backgroundRefreshes.values()].map((promise) => {
+            let timer;
+            return Promise.race([
+              promise,
+              new Promise((resolve2) => {
+                timer = setTimeout(resolve2, 5e3);
+                timer.unref?.();
+              })
+            ]).finally(() => {
+              if (timer) clearTimeout(timer);
+            });
+          })
+        );
+        this.backgroundRefreshes.clear();
+        this.backgroundRefreshAbort.clear();
         this.maintenance.disposeWriteBehindTimer();
         this.fetchRateLimiter.dispose();
         await Promise.allSettled(this.layers.map((layer) => layer.dispose?.() ?? Promise.resolve()));
@@ -3231,15 +3285,19 @@ var CacheStack = class extends import_node_events.EventEmitter {
     }
     const clearEpoch = this.maintenance.currentClearEpoch();
     const keyEpoch = this.maintenance.currentKeyEpoch(key);
+    this.backgroundRefreshAbort.set(key, false);
     const refresh = (async () => {
       this.metricsCollector.increment("refreshes");
       try {
+        if (this.backgroundRefreshAbort.get(key)) return;
         await this.runBackgroundRefresh(key, fetcher, options, clearEpoch, keyEpoch);
       } catch (error) {
+        if (this.backgroundRefreshAbort.get(key)) return;
         this.metricsCollector.increment("refreshErrors");
         this.logger.debug?.("refresh-error", { key, error: this.formatError(error) });
       } finally {
         this.backgroundRefreshes.delete(key);
+        this.backgroundRefreshAbort.delete(key);
       }
     })();
     this.backgroundRefreshes.set(key, refresh);
@@ -3342,7 +3400,7 @@ var CacheStack = class extends import_node_events.EventEmitter {
           timer.unref?.();
         })
       ]);
-      if (result && typeof result === "object" && "kind" in result) {
+      if (result !== null && result !== void 0 && typeof result === "object" && "kind" in result) {
         if (result.kind === "error") {
           throw result.error;
         }
@@ -3360,7 +3418,7 @@ var CacheStack = class extends import_node_events.EventEmitter {
   }
   async observeOperation(name, attributes, execute) {
     const id = this.nextOperationId;
-    this.nextOperationId += 1;
+    this.nextOperationId = (this.nextOperationId + 1) % Number.MAX_SAFE_INTEGER;
     this.emit("operation-start", { id, name, attributes });
     try {
       const result = await execute();
@@ -3596,6 +3654,7 @@ var RedisInvalidationBus = class {
   logger;
   handlers = /* @__PURE__ */ new Set();
   sharedListener;
+  subscribePromise;
   constructor(options) {
     this.publisher = options.publisher;
     this.subscriber = options.subscriber ?? options.publisher.duplicate();
@@ -3603,15 +3662,27 @@ var RedisInvalidationBus = class {
     this.logger = options.logger;
   }
   async subscribe(handler) {
-    if (this.handlers.size === 0) {
-      const listener = (_channel, payload) => {
-        void this.dispatchToHandlers(payload);
-      };
-      this.sharedListener = listener;
-      this.subscriber.on("message", listener);
-      await this.subscriber.subscribe(this.channel);
+    const previousPromise = this.subscribePromise;
+    let resolveThis;
+    this.subscribePromise = new Promise((resolve2) => {
+      resolveThis = resolve2;
+    });
+    if (previousPromise) {
+      await previousPromise;
+    }
+    try {
+      if (this.handlers.size === 0) {
+        const listener = (_channel, payload) => {
+          void this.dispatchToHandlers(payload);
+        };
+        this.sharedListener = listener;
+        this.subscriber.on("message", listener);
+        await this.subscriber.subscribe(this.channel);
+      }
+      this.handlers.add(handler);
+    } finally {
+      resolveThis();
     }
-    this.handlers.add(handler);
     return async () => {
       this.handlers.delete(handler);
       if (this.handlers.size === 0 && this.sharedListener) {
@@ -4037,10 +4108,21 @@ function normalizeUrl2(url) {
 }
 
 // src/integrations/opentelemetry.ts
+var MAX_SPANS = 1e4;
 function createOpenTelemetryPlugin(cache, tracer) {
   const spans = /* @__PURE__ */ new Map();
   const onStart = (event) => {
-    spans.set(event.id, tracer.startSpan(event.name, { attributes: event.attributes }));
+    try {
+      if (spans.size >= MAX_SPANS) {
+        const oldest = spans.keys().next().value;
+        if (oldest !== void 0) {
+          spans.get(oldest)?.end();
+          spans.delete(oldest);
+        }
+      }
+      spans.set(event.id, tracer.startSpan(event.name, { attributes: event.attributes }));
+    } catch {
+    }
   };
   const onEnd = (event) => {
     const span = spans.get(event.id);
@@ -4048,12 +4130,15 @@ function createOpenTelemetryPlugin(cache, tracer) {
       return;
     }
     spans.delete(event.id);
-    span.setAttribute?.("layercache.success", event.success);
-    if (event.result) {
-      span.setAttribute?.("layercache.result", event.result);
-    }
-    if (event.error !== void 0) {
-      span.recordException?.(event.error);
+    try {
+      span.setAttribute?.("layercache.success", event.success);
+      if (event.result) {
+        span.setAttribute?.("layercache.result", event.result);
+      }
+      if (event.error !== void 0) {
+        span.recordException?.(event.error);
+      }
+    } catch {
     }
     span.end();
   };
@@ -4619,7 +4704,7 @@ var RedisLayer = class {
 };
 
 // src/layers/DiskLayer.ts
-var import_node_crypto = require("crypto");
+var import_node_crypto2 = require("crypto");
 var import_node_fs2 = require("fs");
 var import_node_path2 = require("path");
 var FILE_SCAN_CONCURRENCY = 32;
@@ -4672,7 +4757,7 @@ var DiskLayer = class {
       };
       const payload = this.serializer.serialize(entry);
       const targetPath = this.keyToPath(key);
-      const tempPath = `${targetPath}.${process.pid}.${Date.now()}.${Math.random().toString(36).slice(2)}.tmp`;
+      const tempPath = `${targetPath}.${process.pid}.${Date.now()}.${(0, import_node_crypto2.randomBytes)(8).toString("hex")}.tmp`;
       try {
         await import_node_fs2.promises.writeFile(tempPath, payload);
         await import_node_fs2.promises.rename(tempPath, targetPath);
@@ -4772,7 +4857,7 @@ var DiskLayer = class {
   async dispose() {
   }
   keyToPath(key) {
-    const hash = (0, import_node_crypto.createHash)("sha256").update(key).digest("hex");
+    const hash = (0, import_node_crypto2.createHash)("sha256").update(key).digest("hex");
     return (0, import_node_path2.join)(this.directory, `${hash}.lc`);
   }
   resolveDirectory(directory) {
@@ -5050,7 +5135,7 @@ var MsgpackSerializer = class {
 };
 
 // src/singleflight/RedisSingleFlightCoordinator.ts
-var import_node_crypto2 = require("crypto");
+var import_node_crypto3 = require("crypto");
 var RELEASE_SCRIPT = `
 if redis.call("get", KEYS[1]) == ARGV[1] then
   return redis.call("del", KEYS[1])
@@ -5072,7 +5157,7 @@ var RedisSingleFlightCoordinator = class {
   }
   async execute(key, options, worker, waiter) {
     const lockKey = `${this.prefix}:${encodeURIComponent(key)}`;
-    const token = (0, import_node_crypto2.randomUUID)();
+    const token = (0, import_node_crypto3.randomUUID)();
     const acquired = await this.client.set(lockKey, token, "PX", options.leaseMs, "NX");
     if (acquired === "OK") {
       const renewTimer = this.startLeaseRenewal(lockKey, token, options);

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-DBs8Ko5W.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-DBs8Ko5W.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-BXWTKlI1.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-BXWTKlI1.cjs';
 import Redis from 'ioredis';
 import 'node:events';
 
@@ -23,6 +23,7 @@ declare class RedisInvalidationBus implements InvalidationBus {
     private readonly logger?;
     private readonly handlers;
     private sharedListener?;
+    private subscribePromise;
     constructor(options: RedisInvalidationBusOptions);
     subscribe(handler: (message: InvalidationMessage) => Promise<void> | void): Promise<() => Promise<void>>;
     publish(message: InvalidationMessage): Promise<void>;

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-DBs8Ko5W.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-DBs8Ko5W.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-BXWTKlI1.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-BXWTKlI1.js';
 import Redis from 'ioredis';
 import 'node:events';
 
@@ -23,6 +23,7 @@ declare class RedisInvalidationBus implements InvalidationBus {
     private readonly logger?;
     private readonly handlers;
     private sharedListener?;
+    private subscribePromise;
     constructor(options: RedisInvalidationBusOptions);
     subscribe(handler: (message: InvalidationMessage) => Promise<void> | void): Promise<() => Promise<void>>;
     publish(message: InvalidationMessage): Promise<void>;