layercache 2.1.0 → 3.1.0

package/README.md

@@ -3,7 +3,7 @@
 </p>
 
 <p align="center">
-  <img src="./logo.png" width="520" alt="layercache logo">
+  <img src="./layercache-stampede.gif" width="930" alt="layercache stampede prevention demo">
 </p>
 
 <h1 align="center">layercache</h1>
@@ -19,12 +19,12 @@
   <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-549_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>
+  <img src="https://img.shields.io/badge/tests-598_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=20260517" alt="Coveralls"></a>
 </p>
 
 <p align="center">
-  <a href="https://layercache.flyingsquirrel.me">Website</a>&nbsp;&nbsp;|&nbsp;&nbsp;
+  <a href="https://flyingsquirrel0419.github.io/layercache">Website</a>&nbsp;&nbsp;|&nbsp;&nbsp;
   <a href="#-quick-start">Quick Start</a>&nbsp;&nbsp;|&nbsp;&nbsp;
   <a href="#-performance">Performance</a>&nbsp;&nbsp;|&nbsp;&nbsp;
   <a href="./docs/api.md">API Reference</a>&nbsp;&nbsp;|&nbsp;&nbsp;
@@ -53,6 +53,18 @@ layercache is a multi-layer cache (Memory → Redis → Disk) for Node.js. Stamp
 
 ---
 
+## What's New in 3.0
+
+- `RedisTagIndex` uses 16 known-key shards by default. Existing Redis tag indexes that still use the legacy `<prefix>:keys` set should be migrated with `npx layercache migrate-tag-index`.
+- Production CLI commands reject plaintext `redis://` URLs unless `--allow-plaintext` is passed. Prefer `rediss://` for production Redis endpoints.
+- Express and Hono implicit URL cache keys now strip sensitive query parameters before caching, and non-2xx JSON responses are not cached by default.
+- Redis-backed generation persistence is available through `RedisGenerationStore`, and `CacheStack.getGeneration()` exposes the active generation.
+- The docs site now runs on Rspress and GitHub Pages.
+
+See the [changelog](./CHANGELOG.md) and [migration guide](./docs/migration-guide.md) before upgrading an existing deployment.
+
+---
+
 ## Quick Start
 
 ```bash
@@ -250,6 +262,8 @@ const cache = new CacheStack([
 | **Namespaces** | Scoped cache views with hierarchical prefix support |
 | **Cache warming** | Pre-populate layers at startup with priority-based loading |
 | **Negative caching** | Cache misses (e.g., "user not found") for short TTLs |
+| **Stored null values** | `cacheNullValues` keeps intentional `null` values distinct from misses |
+| **Entry introspection** | `getEntry()` reports value, kind, state, key, and source layer |
 
 ### Invalidation & Freshness
 
@@ -273,9 +287,11 @@ const cache = new CacheStack([
 |---|---|
 | **Graceful degradation** | Skip failed layers temporarily, keep cache available |
 | **Circuit breaker** | Stop hammering broken upstreams after repeated failures |
-| **Fetcher rate limiting** | Scoped to global, per-key, or per-fetcher with custom buckets |
+| **Shared circuit breaker scopes** | Group failures by backend dependency with `scope: 'shared'` and `breakerKey` |
+| **Fetcher rate limiting** | Scoped to global, per-key, or per-fetcher; `queueOverflow: 'reject'` rejects saturated queues and `'bypass'` runs overflow work directly |
 | **Write policies** | `strict` (fail if any layer fails) or `best-effort` |
 | **Write-behind** | Batch writes with configurable flush interval |
+| **Bounded disk writes** | `DiskLayer.maxWriteQueueDepth` prevents unbounded serialized write buildup |
 | **Compression** | gzip / brotli in RedisLayer with configurable threshold |
 | **MessagePack** | Pluggable serializers (JSON default, MessagePack alternative) |
 | **Persistence** | Export/import snapshots to memory or disk |
@@ -363,7 +379,7 @@ layercache is built for multi-instance production environments:
 
 - **Redis single-flight** - dedup misses across instances with distributed locks
 - **Redis invalidation bus** - pub/sub-based L1 invalidation for memory consistency
-- **Redis tag index** - shared tag tracking with optional sharding
+- **Redis tag index** - shared tag tracking with 16 known-key shards by default
 - **Snapshot persistence** - export/import state between instances
 
 <details>
@@ -375,9 +391,13 @@ import {
   RedisInvalidationBus, RedisTagIndex, RedisSingleFlightCoordinator
 } from 'layercache'
 
-const redis = new Redis()
-const bus = new RedisInvalidationBus({ publisher: redis, subscriber: new Redis() })
-const tagIndex = new RedisTagIndex({ client: redis, prefix: 'myapp:tags' })
+const redis = new Redis(process.env.REDIS_URL)
+const bus = new RedisInvalidationBus({
+  publisher: redis,
+  subscriber: new Redis(process.env.REDIS_URL),
+  signingSecret: process.env.LAYERCACHE_INVALIDATION_SECRET
+})
+const tagIndex = new RedisTagIndex({ client: redis, prefix: 'myapp:tags', knownKeysShards: 16 })
 const coordinator = new RedisSingleFlightCoordinator({ client: redis })
 
 const cache = new CacheStack(

package/dist/{chunk-6X7NV5BG.js → chunk-L6L7QXYF.js}

@@ -41,9 +41,12 @@ function validateRateLimitOptions(name, options) {
   validatePositiveNumber(`${name}.maxConcurrent`, options.maxConcurrent);
   validatePositiveNumber(`${name}.intervalMs`, options.intervalMs);
   validatePositiveNumber(`${name}.maxPerInterval`, options.maxPerInterval);
-  if (options.scope && !["global", "key", "fetcher"].includes(options.scope)) {
+  if (options.scope !== void 0 && !["global", "key", "fetcher"].includes(options.scope)) {
     throw new Error(`${name}.scope must be one of "global", "key", or "fetcher".`);
   }
+  if (options.queueOverflow !== void 0 && !["reject", "bypass"].includes(options.queueOverflow)) {
+    throw new Error(`${name}.queueOverflow must be one of "reject" or "bypass".`);
+  }
   if (options.bucketKey !== void 0 && options.bucketKey.length === 0) {
     throw new Error(`${name}.bucketKey must not be empty.`);
   }
@@ -124,6 +127,12 @@ function validateCircuitBreakerOptions(options) {
   }
   validatePositiveNumber("circuitBreaker.failureThreshold", options.failureThreshold);
   validatePositiveNumber("circuitBreaker.cooldownMs", options.cooldownMs);
+  if (options.scope !== void 0 && !["key", "shared"].includes(options.scope)) {
+    throw new Error('circuitBreaker.scope must be one of "key" or "shared".');
+  }
+  if (options.breakerKey !== void 0 && options.breakerKey.length === 0) {
+    throw new Error("circuitBreaker.breakerKey must not be empty.");
+  }
 }
 function validateContextEntryOptions(name, options) {
   if (!options) {
@@ -140,16 +149,20 @@ function validateContextEntryOptions(name, options) {
 }
 
 // src/invalidation/RedisTagIndex.ts
+var DEFAULT_KNOWN_KEYS_SHARDS = 16;
 var RedisTagIndex = class {
   client;
   prefix;
   scanCount;
   knownKeysShards;
+  logger;
+  warnedLegacyKnownKeys = false;
   constructor(options) {
     this.client = options.client;
     this.prefix = options.prefix ?? "layercache:tag-index";
     this.scanCount = options.scanCount ?? 100;
     this.knownKeysShards = normalizeKnownKeysShards(options.knownKeysShards);
+    this.logger = options.logger;
   }
   /**
    * Records a key as known without changing tag assignments.
@@ -185,6 +198,9 @@ var RedisTagIndex = class {
     const existingTags = await this.client.smembers(keyTagsKey);
     const pipeline = this.client.pipeline();
     pipeline.srem(this.knownKeysKeyFor(key), key);
+    if (this.knownKeysShards > 1) {
+      pipeline.srem(this.legacyKnownKeysKey(), key);
+    }
     pipeline.del(keyTagsKey);
     for (const tag of existingTags) {
       pipeline.srem(this.tagKeysKey(tag), key);
@@ -215,28 +231,34 @@ var RedisTagIndex = class {
    * Returns known keys that start with a prefix.
    */
   async keysForPrefix(prefix) {
-    const matches = [];
-    for (const knownKeysKey of this.knownKeysKeys()) {
+    const matches = /* @__PURE__ */ new Set();
+    for (const knownKeysKey of await this.knownKeysKeysForRead()) {
       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)));
+        for (const key of keys) {
+          if (key.startsWith(prefix)) {
+            matches.add(key);
+          }
+        }
       } while (cursor !== "0");
     }
-    return matches;
+    return [...matches];
   }
   /**
    * Visits known keys that start with a prefix.
    */
   async forEachKeyForPrefix(prefix, visitor) {
-    for (const knownKeysKey of this.knownKeysKeys()) {
+    const visited = /* @__PURE__ */ new Set();
+    for (const knownKeysKey of await this.knownKeysKeysForRead()) {
       let cursor = "0";
       do {
         const [nextCursor, keys] = await this.client.sscan(knownKeysKey, cursor, "COUNT", this.scanCount);
         cursor = nextCursor;
         for (const key of keys) {
-          if (key.startsWith(prefix)) {
+          if (key.startsWith(prefix) && !visited.has(key)) {
+            visited.add(key);
             await visitor(key);
           }
         }
@@ -253,8 +275,8 @@ var RedisTagIndex = class {
    * Returns known keys matching a wildcard pattern.
    */
   async matchPattern(pattern) {
-    const matches = [];
-    for (const knownKeysKey of this.knownKeysKeys()) {
+    const matches = /* @__PURE__ */ new Set();
+    for (const knownKeysKey of await this.knownKeysKeysForRead()) {
       let cursor = "0";
       do {
         const [nextCursor, keys] = await this.client.sscan(
@@ -266,16 +288,21 @@ var RedisTagIndex = class {
           this.scanCount
         );
         cursor = nextCursor;
-        matches.push(...keys.filter((key) => PatternMatcher.matches(pattern, key)));
+        for (const key of keys) {
+          if (PatternMatcher.matches(pattern, key)) {
+            matches.add(key);
+          }
+        }
       } while (cursor !== "0");
     }
-    return matches;
+    return [...matches];
   }
   /**
    * Visits known keys matching a wildcard pattern.
    */
   async forEachKeyMatchingPattern(pattern, visitor) {
-    for (const knownKeysKey of this.knownKeysKeys()) {
+    const visited = /* @__PURE__ */ new Set();
+    for (const knownKeysKey of await this.knownKeysKeysForRead()) {
       let cursor = "0";
       do {
         const [nextCursor, keys] = await this.client.sscan(
@@ -288,7 +315,8 @@ var RedisTagIndex = class {
         );
         cursor = nextCursor;
         for (const key of keys) {
-          if (PatternMatcher.matches(pattern, key)) {
+          if (PatternMatcher.matches(pattern, key) && !visited.has(key)) {
+            visited.add(key);
             await visitor(key);
           }
         }
@@ -305,6 +333,31 @@ var RedisTagIndex = class {
     }
     await this.client.del(...indexKeys);
   }
+  async migrateLegacyKnownKeys() {
+    if (this.knownKeysShards === 1) {
+      return { migratedKeys: 0 };
+    }
+    const legacyKey = this.legacyKnownKeysKey();
+    let cursor = "0";
+    let migratedKeys = 0;
+    do {
+      const [nextCursor, keys] = await this.client.sscan(legacyKey, cursor, "COUNT", this.scanCount);
+      cursor = nextCursor;
+      if (keys.length === 0) {
+        continue;
+      }
+      const pipeline = this.client.pipeline();
+      for (const key of keys) {
+        pipeline.sadd(this.knownKeysKeyFor(key), key);
+      }
+      await pipeline.exec();
+      migratedKeys += keys.length;
+    } while (cursor !== "0");
+    if (migratedKeys > 0) {
+      await this.client.del(legacyKey);
+    }
+    return { migratedKeys };
+  }
   async scanIndexKeys() {
     const matches = [];
     let cursor = "0";
@@ -322,12 +375,40 @@ var RedisTagIndex = class {
     }
     return `${this.prefix}:keys:${simpleHash(key) % this.knownKeysShards}`;
   }
+  async knownKeysKeysForRead() {
+    if (this.knownKeysShards === 1) {
+      return [this.legacyKnownKeysKey()];
+    }
+    const shardedKeys = this.knownKeysKeys();
+    const legacyKey = this.legacyKnownKeysKey();
+    const legacyExists = await this.client.exists(legacyKey) > 0;
+    if (!legacyExists) {
+      return shardedKeys;
+    }
+    this.warnLegacyKnownKeys(legacyKey);
+    return [legacyKey, ...shardedKeys];
+  }
   knownKeysKeys() {
     if (this.knownKeysShards === 1) {
       return [`${this.prefix}:keys`];
     }
     return Array.from({ length: this.knownKeysShards }, (_, index) => `${this.prefix}:keys:${index}`);
   }
+  legacyKnownKeysKey() {
+    return `${this.prefix}:keys`;
+  }
+  warnLegacyKnownKeys(legacyKey) {
+    if (this.warnedLegacyKnownKeys) {
+      return;
+    }
+    this.warnedLegacyKnownKeys = true;
+    const message = "RedisTagIndex detected a legacy RedisTagIndex known-key set. Run `layercache migrate-tag-index` to migrate keys into the sharded layout.";
+    if (this.logger?.warn) {
+      this.logger.warn(message, { legacyKey, knownKeysShards: this.knownKeysShards });
+      return;
+    }
+    console.warn(`[layercache] ${message}`, { legacyKey, knownKeysShards: this.knownKeysShards });
+  }
   keyTagsKey(key) {
     return `${this.prefix}:key:${encodeURIComponent(key)}`;
   }
@@ -337,7 +418,7 @@ var RedisTagIndex = class {
 };
 function normalizeKnownKeysShards(value) {
   if (value === void 0) {
-    return 1;
+    return DEFAULT_KNOWN_KEYS_SHARDS;
   }
   if (!Number.isInteger(value) || value <= 0) {
     throw new Error("RedisTagIndex.knownKeysShards must be a positive integer.");

package/dist/{chunk-IVX6ABFX.js → chunk-XMUT66SH.js}

@@ -1,4 +1,5 @@
 import {
+  PatternMatcher,
   unwrapStoredValue
 } from "./chunk-KJDFYE5T.js";
 
@@ -245,30 +246,34 @@ var MemoryLayer = class {
 };
 
 // src/invalidation/TagIndex.ts
-var MAX_PATTERN_RECURSION_DEPTH = 500;
+var DEFAULT_TOUCH_REFRESH_INTERVAL_MS = 1e3;
 var TagIndex = class {
   tagToKeys = /* @__PURE__ */ new Map();
   keyToTags = /* @__PURE__ */ new Map();
   knownKeys = /* @__PURE__ */ new Map();
   maxKnownKeys;
+  touchRefreshIntervalMs;
   nextNodeId = 1;
   root = this.createTrieNode();
   constructor(options = {}) {
     this.maxKnownKeys = options.maxKnownKeys ?? 1e5;
+    this.touchRefreshIntervalMs = options.touchRefreshIntervalMs ?? DEFAULT_TOUCH_REFRESH_INTERVAL_MS;
   }
   /**
    * Records a key as known without changing tag assignments.
    */
   async touch(key) {
-    this.insertKnownKey(key);
-    this.pruneKnownKeysIfNeeded();
+    if (this.insertKnownKey(key)) {
+      this.pruneKnownKeysIfNeeded();
+    }
   }
   /**
    * Replaces the tags associated with a key and records the key as known.
    */
   async track(key, tags) {
-    this.insertKnownKey(key);
-    this.pruneKnownKeysIfNeeded();
+    if (this.insertKnownKey(key)) {
+      this.pruneKnownKeysIfNeeded();
+    }
     if (tags.length === 0) {
       return;
     }
@@ -338,9 +343,14 @@ var TagIndex = class {
    * Returns known keys matching a wildcard pattern.
    */
   async matchPattern(pattern) {
-    const matches = /* @__PURE__ */ new Set();
-    this.collectPatternMatches(this.root, "", pattern, 0, matches, /* @__PURE__ */ new Set(), 0);
-    return [...matches];
+    const literalPrefix = this.literalPrefix(pattern);
+    const node = this.findNode(literalPrefix);
+    if (!node) {
+      return [];
+    }
+    const candidates = [];
+    this.collectFromNode(node, literalPrefix, candidates);
+    return candidates.filter((key) => PatternMatcher.matches(pattern, key));
   }
   /**
    * Visits known keys matching a wildcard pattern.
@@ -370,10 +380,18 @@ var TagIndex = class {
     };
   }
   insertKnownKey(key) {
-    const isNew = !this.knownKeys.has(key);
-    this.knownKeys.set(key, Date.now());
+    const previousTouch = this.knownKeys.get(key);
+    const isNew = previousTouch === void 0;
+    const now = Date.now();
+    if (!isNew && now - previousTouch < this.touchRefreshIntervalMs) {
+      return false;
+    }
     if (!isNew) {
-      return;
+      this.knownKeys.delete(key);
+    }
+    this.knownKeys.set(key, now);
+    if (!isNew) {
+      return true;
     }
     let node = this.root;
     for (const character of key) {
@@ -385,6 +403,7 @@ var TagIndex = class {
       node = child;
     }
     node.terminal = true;
+    return true;
   }
   findNode(prefix) {
     let node = this.root;
@@ -397,85 +416,52 @@ var TagIndex = class {
     return node;
   }
   collectFromNode(node, prefix, matches) {
-    if (node.terminal) {
-      matches.push(prefix);
-    }
-    for (const [character, child] of node.children) {
-      this.collectFromNode(child, `${prefix}${character}`, matches);
+    const stack = [{ node, prefix }];
+    while (stack.length > 0) {
+      const current = stack.pop();
+      if (!current) {
+        continue;
+      }
+      if (current.node.terminal) {
+        matches.push(current.prefix);
+      }
+      const children = [...current.node.children].reverse();
+      for (const [character, child] of children) {
+        stack.push({ node: child, prefix: `${current.prefix}${character}` });
+      }
     }
   }
   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;
-    }
-    const stateKey = `${node.id}:${patternIndex}`;
-    if (visited.has(stateKey)) {
-      return;
-    }
-    visited.add(stateKey);
-    if (patternIndex === pattern.length) {
-      if (node.terminal) {
-        matches.add(prefix);
+    const stack = [{ node, prefix }];
+    while (stack.length > 0) {
+      const current = stack.pop();
+      if (!current) {
+        continue;
       }
-      return;
-    }
-    const patternChar = pattern[patternIndex];
-    if (patternChar === void 0) {
-      return;
-    }
-    if (patternChar === "*") {
-      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, depth + 1);
+      if (current.node.terminal) {
+        await visitor(current.prefix);
       }
-      return;
-    }
-    if (patternChar === "?") {
-      for (const [character, child2] of node.children) {
-        this.collectPatternMatches(
-          child2,
-          `${prefix}${character}`,
-          pattern,
-          patternIndex + 1,
-          matches,
-          visited,
-          depth + 1
-        );
+      const children = [...current.node.children].reverse();
+      for (const [character, child] of children) {
+        stack.push({ node: child, prefix: `${current.prefix}${character}` });
       }
-      return;
-    }
-    const child = node.children.get(patternChar);
-    if (child) {
-      this.collectPatternMatches(
-        child,
-        `${prefix}${patternChar}`,
-        pattern,
-        patternIndex + 1,
-        matches,
-        visited,
-        depth + 1
-      );
     }
   }
+  literalPrefix(pattern) {
+    const wildcardIndex = pattern.search(/[*?]/);
+    return wildcardIndex === -1 ? pattern : pattern.slice(0, wildcardIndex);
+  }
   pruneKnownKeysIfNeeded() {
     if (this.maxKnownKeys === void 0 || this.knownKeys.size <= this.maxKnownKeys) {
       return;
     }
-    const sorted = [...this.knownKeys.entries()].sort((a, b) => a[1] - b[1]);
     const toRemove = Math.ceil(this.maxKnownKeys * 0.1);
-    for (let i = 0; i < toRemove && i < sorted.length; i += 1) {
-      const entry = sorted[i];
-      if (entry) {
-        this.removeKey(entry[0]);
+    for (let i = 0; i < toRemove; i += 1) {
+      const oldestKey = this.knownKeys.keys().next().value;
+      if (oldestKey === void 0) {
+        break;
       }
+      this.removeKnownKey(oldestKey);
     }
   }
   removeKey(key) {
@@ -526,6 +512,41 @@ var TagIndex = class {
   }
 };
 
+// src/integrations/httpCacheKeys.ts
+var SENSITIVE_QUERY_PARAMETERS = /* @__PURE__ */ new Set([
+  "access_token",
+  "api_key",
+  "apikey",
+  "auth",
+  "authorization",
+  "code",
+  "credentials",
+  "id_token",
+  "jwt",
+  "password",
+  "private_key",
+  "refresh_token",
+  "secret",
+  "session",
+  "sessionid",
+  "session_id",
+  "token"
+]);
+function normalizeHttpCacheUrl(url) {
+  try {
+    const parsed = new URL(url, "http://localhost");
+    for (const name of [...parsed.searchParams.keys()]) {
+      if (SENSITIVE_QUERY_PARAMETERS.has(name.toLowerCase())) {
+        parsed.searchParams.delete(name);
+      }
+    }
+    parsed.searchParams.sort();
+    return parsed.pathname + parsed.search;
+  } catch {
+    return url;
+  }
+}
+
 // src/integrations/hono.ts
 function createHonoCacheMiddleware(cache, options = {}) {
   const allowedMethods = new Set((options.methods ?? ["GET"]).map((method) => method.toUpperCase()));
@@ -540,39 +561,44 @@ function createHonoCacheMiddleware(cache, options = {}) {
       return;
     }
     const rawPath = context.req.path ?? context.req.url ?? "/";
-    const key = options.keyResolver ? options.keyResolver(context.req) : `${method}:${normalizeUrl(rawPath)}`;
+    const key = options.keyResolver ? options.keyResolver(context.req) : `${method}:${normalizeHttpCacheUrl(rawPath)}`;
     const cached = await cache.get(key, void 0, options);
     if (cached !== null) {
       context.header?.("x-cache", "HIT");
       context.header?.("content-type", "application/json; charset=utf-8");
       return context.json(cached);
     }
+    let currentStatus;
+    const originalStatus = context.status?.bind(context);
+    if (originalStatus) {
+      context.status = (status) => {
+        currentStatus = status;
+        return originalStatus(status);
+      };
+    }
     const originalJson = context.json.bind(context);
     context.json = (body, status) => {
       context.header?.("x-cache", "MISS");
-      cache.set(key, body, options).catch((err) => {
-        cache.emit("error", {
-          operation: "set",
-          error: err instanceof Error ? err.message : String(err)
+      if (isSuccessfulStatus(status ?? currentStatus)) {
+        cache.set(key, body, options).catch((err) => {
+          cache.emit("error", {
+            operation: "set",
+            error: err instanceof Error ? err.message : String(err)
+          });
         });
-      });
+      }
       return originalJson(body, status);
     };
     await next();
   };
 }
-function normalizeUrl(url) {
-  try {
-    const parsed = new URL(url, "http://localhost");
-    parsed.searchParams.sort();
-    return parsed.pathname + parsed.search;
-  } catch {
-    return url;
-  }
+function isSuccessfulStatus(statusCode) {
+  return statusCode === void 0 || statusCode >= 200 && statusCode < 300;
 }
 
 export {
   MemoryLayer,
   TagIndex,
+  normalizeHttpCacheUrl,
   createHonoCacheMiddleware
 };