layercache 1.2.3 → 1.2.5

package/README.md

@@ -1,92 +1,99 @@
-# layercache
+<p align="center">
+  <img src="./logo.png" width="520" alt="layercache logo">
+</p>
+
+<h1 align="center">layercache</h1>
+
+<p align="center">
+  <strong>Production-ready multi-layer caching for Node.js</strong><br>
+  <em>Memory, Redis, persistence, invalidation, observability, and resilience in one API.</em>
+</p>
+
+<p align="center">
+  <a href="https://www.npmjs.com/package/layercache"><img src="https://img.shields.io/npm/v/layercache" alt="npm version"></a>
+  <a href="https://www.npmjs.com/package/layercache"><img src="https://img.shields.io/npm/dw/layercache" alt="npm downloads"></a>
+  <a href="./LICENSE"><img src="https://img.shields.io/npm/l/layercache" alt="license"></a>
+  <a href="https://www.typescriptlang.org/"><img src="https://img.shields.io/badge/TypeScript-first-blue" alt="TypeScript"></a>
+  <a href="https://github.com/flyingsquirrel0419/layercache"><img src="https://img.shields.io/badge/tests-180%20passing-brightgreen" alt="tests"></a>
+</p>
+
+<p align="center">
+  <a href="#installation">Installation</a> ·
+  <a href="#quick-start">Quick Start</a> ·
+  <a href="#core-api">Core API</a> ·
+  <a href="#invalidation--freshness">Invalidation</a> ·
+  <a href="#integrations--tooling">Integrations</a> ·
+  <a href="#contributing">Contributing</a>
+</p>
 
-**Production-ready multi-layer caching for Node.js — memory, Redis, persistence, invalidation, and resilience in one API.**
+---
 
-[![npm version](https://img.shields.io/npm/v/layercache)](https://www.npmjs.com/package/layercache)
-[![npm downloads](https://img.shields.io/npm/dw/layercache)](https://www.npmjs.com/package/layercache)
-[![license](https://img.shields.io/npm/l/layercache)](LICENSE)
-[![TypeScript](https://img.shields.io/badge/TypeScript-first-blue)](https://www.typescriptlang.org/)
-[![test coverage](https://img.shields.io/badge/tests-180%20passing-brightgreen)](https://github.com/flyingsquirrel0419/layercache)
+## At a glance
 
-```
+- **Fast read path** — combine memory L1, Redis L2, disk, or custom layers behind one API with automatic backfill.
+- **Stampede control** — prevent duplicate miss storms with in-process dedupe and optional distributed single-flight.
+- **Strong invalidation model** — support tags, batched tags, wildcards, prefixes, and generation-based cache rotation.
+- **Built for production failure modes** — serve stale safely, refresh ahead, degrade gracefully, trip circuit breakers, and throttle fetchers.
+- **Operational visibility included** — expose metrics, stats, health checks, OpenTelemetry spans, and an admin CLI.
+- **Fits real Node stacks** — integrate directly with Express, Fastify, Hono, GraphQL, tRPC, and NestJS.
+
+Most Node.js services hit the same wall:
+
+| Approach | Tradeoff |
+|---|---|
+| Memory-only cache | Fast, but every instance has a different view of data |
+| Redis-only cache | Shared, but every request pays a network round-trip |
+| Hand-rolled hybrid cache | Possible, but you rebuild stampede prevention, invalidation, TTL policy, and observability yourself |
+
+`layercache` gives you a single API for layered caching and handles the hard parts for you: read-through fetches, backfill, stale serving, distributed invalidation, rate limiting, persistence, and operational introspection.
+
+On a hit, `layercache` serves the fastest available layer and backfills anything above it. On a miss, the fetcher runs once, even under heavy concurrency.
+
+## Performance profile
+
+```text
 L1 hit  ~0.01 ms  ← served from memory, zero network
 L2 hit  ~0.5  ms  ← served from Redis, backfilled to memory
 miss    ~20   ms  ← fetcher runs once, all layers filled
 ```
 
----
+## Why teams use it
 
-## Why layercache?
+- **Predictable cache behavior** — layered reads, automatic backfill, negative caching, refresh-ahead, and stale serving.
+- **Reliable invalidation** — tags, batched tags, wildcards, prefixes, and generation-based rotation.
+- **Production safeguards** — rate limiting, circuit breakers, graceful degradation, compression limits, serializer hardening, and snapshot path validation.
+- **Operational visibility** — metrics, health checks, OpenTelemetry spans, stats endpoints, and an admin CLI.
+- **Works with your stack** — Express, Fastify, Hono, GraphQL, tRPC, NestJS, CLI, and custom cache layers.
 
-Most Node.js services end up with the same problem:
+## Feature map
 
-- **Memory-only** → fast, but not shared across servers
-- **Redis-only** → shared, but every read pays a network round-trip
-- **Hand-rolled layers** → works, but you rewrite stampede prevention, backfill logic, and tag invalidation in every project
+### Core caching
 
-layercache solves all three. You declare your layers once and call `get`. Everything else is handled.
+- Layered reads with automatic backfill
+- Stampede prevention and optional distributed single-flight
+- Bulk reads and writes with layer-level `getMany()` / `setMany()` fast paths
+- `wrap()`, namespaces, cache warming, `getOrThrow()`, and `inspect()`
 
-It is designed for production services that need predictable cache behavior under load: stampede prevention, cross-instance invalidation, layered TTL control, operational metrics, and safer persistence defaults.
+### Invalidation and freshness
 
-```ts
-const user = await cache.get('user:123', () => db.findUser(123))
-//                                         ↑ only called on a full miss
-```
+- Tag invalidation, batched tag invalidation, wildcard invalidation, and prefix invalidation
+- Generation-based invalidation with optional stale-generation cleanup
+- Sliding TTL, adaptive TTL, refresh-ahead, stale-while-revalidate, and stale-if-error
+- Per-layer TTL overrides, TTL policies, negative caching, and TTL jitter
 
-On a hit, the value is returned from the fastest layer that has it, and automatically backfilled into any faster layers that didn't. On a miss, the fetcher runs exactly once — even under 100 concurrent requests for the same key.
+### Operations and resilience
 
----
+- Graceful degradation, circuit breakers, scoped fetcher rate limiting, and write-behind
+- Persistence to memory snapshots or disk snapshots
+- Compression, serializer fallback chains, and MessagePack support
+- Health checks, per-layer metrics, latency tracking, and event hooks
 
-## Features
-
-- **Layered reads & automatic backfill** — hits in slower layers propagate up
-- **Cache stampede prevention** — mutex-based deduplication per key
-- **Tag-based invalidation** — `set('user:123:posts', posts, { tags: ['user:123'] })` then `invalidateByTag('user:123')`
-- **Batch tag invalidation** — `invalidateByTags(['tenant:a', 'users'], 'all')` for OR/AND invalidation in one call
-- **Pattern invalidation** — `invalidateByPattern('user:*')`
-- **Prefix invalidation** — efficient `invalidateByPrefix('user:123:')` for hierarchical keys
-- **Generation-based invalidation** — `generation` prefixes keys with `vN:` and `bumpGeneration()` rotates the namespace instantly, with optional stale-generation cleanup
-- **Per-layer TTL overrides** — different TTLs for memory vs. Redis in one call
-- **TTL policies** — align TTLs to time boundaries (`until-midnight`, `next-hour`, `{ alignTo }`, or a function)
-- **Negative caching** — cache known misses for a short TTL to protect the database
-- **Stale strategies** — `staleWhileRevalidate` and `staleIfError` as opt-in read behavior
-- **TTL jitter** — spread expirations to avoid synchronized stampedes
-- **Sliding & adaptive TTL** — extend TTL on every read or ramp it up for hot keys
-- **Refresh-ahead** — trigger background refresh when TTL drops below a threshold
-- **Fetcher rate limiting** — cap concurrent fetchers or requests per interval
-- **Best-effort writes** — tolerate partial layer write failures when desired
-- **Write-behind mode** — write local layers immediately and flush slower remote layers asynchronously
-- **Bulk reads** — `mget` uses layer-level `getMany()` when available
-- **Bulk writes** — `mset` uses layer-level `setMany()` when available
-- **Distributed tag index** — `RedisTagIndex` keeps tag state consistent across multiple servers
-- **Optional distributed single-flight** — plug in a coordinator to dedupe misses across instances
-- **Cross-server L1 invalidation** — Redis pub/sub bus flushes stale memory on other instances when you write or delete
-- **`wrap()` decorator API** — turn any async function into a cached version with auto-generated keys
-- **Cache warming** — pre-populate layers with a prioritised list of entries at startup
-- **Namespaces** — scope a `CacheStack` to a key prefix for multi-tenant or module isolation
-- **Event hooks** — `EventEmitter`-based events for hits, misses, stale serves, errors, and more
-- **Graceful degradation** — skip a failing layer for a configurable retry window
-- **Circuit breaker** — per-key or global; opens after N failures, recovers after cooldown
-- **Compression** — transparent async gzip/brotli in `RedisLayer` (non-blocking) with a byte threshold
-- **Serializer fallback chains** — transparently read legacy payloads (for example JSON) and rewrite them with the primary serializer
-- **Metrics & stats** — per-layer hit/miss counters, **per-layer latency tracking**, circuit-breaker trips, degraded operations; HTTP stats handler
-- **Health checks** — `cache.healthCheck()` returns per-layer health and latency
-- **Persistence** — `exportState` / `importState` for in-process snapshots; `persistToFile` / `restoreFromFile` for disk
-- **Admin CLI** — `layercache stats | keys | inspect | invalidate` against any Redis URL
-- **Framework integrations** — Express middleware, Fastify plugin, Hono middleware, tRPC middleware, GraphQL resolver wrapper
-- **OpenTelemetry plugin** — instrument `get` / `set` / invalidation flows with spans
-- **MessagePack serializer** — drop-in replacement for lower Redis memory usage
-- **NestJS module** — `CacheStackModule.forRoot(...)` and `forRootAsync(...)` with `@InjectCacheStack()`
-- **`getOrThrow()`** — throws `CacheMissError` instead of returning `null`, for strict use cases
-- **`inspect()`** — debug a key: see which layers hold it, remaining TTLs, tags, and staleness state
-- **MemoryLayer cleanup hooks** — periodic TTL cleanup and `onEvict` callbacks
-- **Conditional caching** — `shouldCache` predicate to skip caching specific fetcher results
-- **Nested namespaces** — `namespace('a').namespace('b')` for composable key prefixes with namespace-scoped metrics
-- **Custom layers** — implement the 5-method `CacheLayer` interface to plug in Memcached, DynamoDB, or anything else
-- **Edge-safe entry point** — `layercache/edge` exports the non-Node helpers for Worker-style runtimes
-- **ESM + CJS** — works with both module systems, Node.js ≥ 20
+### Integrations and tooling
 
----
+- Express, Fastify, Hono, GraphQL, tRPC, and NestJS integrations
+- Redis-backed distributed tag index and invalidation bus support
+- Admin CLI for stats, key inspection, and invalidation
+- Edge-safe entry point for Worker-style runtimes
 
 ## Installation
 
@@ -105,16 +112,11 @@ import { CacheStack, MemoryLayer, RedisLayer } from 'layercache'
 import Redis from 'ioredis'
 
 const cache = new CacheStack([
-  new MemoryLayer({ ttl: 60,   maxSize: 1_000 }),   // L1 — local memory
-  new RedisLayer({ client: new Redis(), ttl: 3600 }) // L2 — Redis
+  new MemoryLayer({ ttl: 60, maxSize: 1_000 }),
+  new RedisLayer({ client: new Redis(), ttl: 3600 })
 ])
 
-// Fetch pattern — cache miss runs the fetcher, hit skips it entirely
 const user = await cache.get<User>('user:123', () => db.findUser(123))
-
-// Manual set / delete
-await cache.set('user:123', user)
-await cache.delete('user:123')
 ```
 
 Memory-only setup (no Redis required):
@@ -171,6 +173,8 @@ await cache.set('user:123', user, {
 })
 ```
 
+## Invalidation & freshness
+
 ### `cache.invalidateByTag(tag): Promise<void>`
 
 Deletes every key that was stored with this tag across all layers. In multi-instance deployments, this is only complete when every instance shares the same tag index implementation (for example `RedisTagIndex`).
@@ -199,6 +203,8 @@ Glob-style deletion against the tracked key set, plus any layer that can enumera
 await cache.invalidateByPattern('user:*') // deletes user:1, user:2, …
 ```
 
+Patterns must be non-empty, at most 1024 characters long, and free of control characters.
+
 For multi-instance deployments, prefer a shared `RedisTagIndex`. Without it, pattern invalidation still scans real layer keys when available, but that fallback only helps on layers that implement `keys()`, and tag tracking itself remains process-local.
 
 ### `cache.invalidateByPrefix(prefix): Promise<void>`
@@ -316,6 +322,8 @@ await cache.warm(
 
 Returns a scoped view with the same full API (`get`, `set`, `delete`, `clear`, `mget`, `wrap`, `warm`, `invalidateByTag`, `invalidateByPattern`, `getMetrics`). `clear()` only touches `prefix:*` keys, and namespace metrics are serialized per `CacheStack` instance so unrelated caches do not block each other while metrics are collected.
 
+Namespace prefixes must be non-empty, at most 256 characters long, and free of control characters.
+
 ```ts
 const users = cache.namespace('users')
 const posts = cache.namespace('posts')
@@ -708,6 +716,8 @@ http.createServer(statsHandler).listen(9090)
 // GET / → JSON stats
 ```
 
+The built-in handler returns JSON with `Cache-Control: no-store` and `X-Content-Type-Options: nosniff` headers.
+
 Or use the Fastify plugin:
 
 ```ts
@@ -763,9 +773,11 @@ cache.on('error', ({ event, context }) => logger.error(event, context))
 
 ---
 
-## Framework integrations
+## Integrations & tooling
 
-### Express
+### Framework integrations
+
+#### Express
 
 ```ts
 import { CacheStack, MemoryLayer, createExpressCacheMiddleware } from 'layercache'
@@ -785,7 +797,7 @@ app.get('/api/user/:id', createExpressCacheMiddleware(cache, {
 }), handler)
 ```
 
-### tRPC
+#### tRPC
 
 ```ts
 import { createTrpcCacheMiddleware } from 'layercache/integrations/trpc'
@@ -795,7 +807,7 @@ const cacheMiddleware = createTrpcCacheMiddleware(cache, 'trpc', { ttl: 60 })
 export const cachedProcedure = t.procedure.use(cacheMiddleware)
 ```
 
-### GraphQL
+#### GraphQL
 
 ```ts
 import { cacheGraphqlResolver } from 'layercache/integrations/graphql'
@@ -812,7 +824,7 @@ const resolvers = {
 
 ---
 
-## Admin CLI
+### Admin CLI
 
 Inspect and manage a Redis-backed cache without writing code.
 
@@ -1046,15 +1058,20 @@ new CacheStack([...], {
 
 ## Contributing
 
+Contributions are welcome, whether that means bug fixes, documentation improvements, performance work, new adapters, or issue reports.
+
 ```bash
 git clone https://github.com/flyingsquirrel0419/layercache
 cd layercache
 npm install
+npm run lint
 npm test          # vitest
 npm run build:all # esm + cjs + nestjs package
 ```
 
-PRs and issues welcome.
+- Read the [contribution guide](./CONTRIBUTING.md) before opening a PR.
+- Participation in the project is covered by the [Code of Conduct](./CODE_OF_CONDUCT.md).
+- If you are filing an issue, include reproduction steps, expected behavior, and runtime details when relevant.
 
 ---
 

package/dist/{chunk-KOYGHLVP.js → chunk-JC26W3KK.js}

@@ -185,6 +185,7 @@ var MemoryLayer = class {
 };
 
 // src/invalidation/TagIndex.ts
+var MAX_PATTERN_RECURSION_DEPTH = 500;
 var TagIndex = class {
   tagToKeys = /* @__PURE__ */ new Map();
   keyToTags = /* @__PURE__ */ new Map();
@@ -239,7 +240,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() {
@@ -291,7 +292,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;
@@ -308,21 +312,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() {
@@ -423,7 +443,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;
   }

package/dist/cli.cjs

@@ -281,10 +281,7 @@ async function main(argv = process.argv.slice(2)) {
   }
   const redisUrl = validateRedisUrl(args.redisUrl);
   if (!redisUrl) {
-    process.stderr.write(
-      `Error: invalid Redis URL "${maskRedisUrl(args.redisUrl)}". Expected format: redis://[user:password@]host[:port][/db]
-`
-    );
+    process.stderr.write("Error: invalid Redis URL. Expected format: redis://[user:password@]host[:port][/db]\n");
     process.exitCode = 1;
     return;
   }
@@ -296,7 +293,7 @@ async function main(argv = process.argv.slice(2)) {
   try {
     await redis.connect().catch((error) => {
       const message = error instanceof Error ? error.message : String(error);
-      throw new Error(`Failed to connect to Redis at "${maskRedisUrl(redisUrl)}": ${message}`);
+      throw new Error(`Failed to connect to Redis: ${message}`);
     });
     if (args.command === "stats") {
       const keys = await scanKeys(redis, args.pattern ?? "*");
@@ -451,17 +448,6 @@ function summarizeInspectableValue(value) {
   }
   return value;
 }
-function maskRedisUrl(url) {
-  try {
-    const parsed = new URL(url);
-    if (parsed.password) {
-      parsed.password = "***";
-    }
-    return parsed.toString();
-  } catch {
-    return url.replace(/:([^@/]+)@/, ":***@");
-  }
-}
 if (process.argv[1]?.includes("cli.")) {
   void main();
 }

package/dist/cli.js

@@ -19,10 +19,7 @@ async function main(argv = process.argv.slice(2)) {
   }
   const redisUrl = validateRedisUrl(args.redisUrl);
   if (!redisUrl) {
-    process.stderr.write(
-      `Error: invalid Redis URL "${maskRedisUrl(args.redisUrl)}". Expected format: redis://[user:password@]host[:port][/db]
-`
-    );
+    process.stderr.write("Error: invalid Redis URL. Expected format: redis://[user:password@]host[:port][/db]\n");
     process.exitCode = 1;
     return;
   }
@@ -34,7 +31,7 @@ async function main(argv = process.argv.slice(2)) {
   try {
     await redis.connect().catch((error) => {
       const message = error instanceof Error ? error.message : String(error);
-      throw new Error(`Failed to connect to Redis at "${maskRedisUrl(redisUrl)}": ${message}`);
+      throw new Error(`Failed to connect to Redis: ${message}`);
     });
     if (args.command === "stats") {
       const keys = await scanKeys(redis, args.pattern ?? "*");
@@ -189,17 +186,6 @@ function summarizeInspectableValue(value) {
   }
   return value;
 }
-function maskRedisUrl(url) {
-  try {
-    const parsed = new URL(url);
-    if (parsed.password) {
-      parsed.password = "***";
-    }
-    return parsed.toString();
-  } catch {
-    return url.replace(/:([^@/]+)@/, ":***@");
-  }
-}
 if (process.argv[1]?.includes("cli.")) {
   void main();
 }

package/dist/{edge-B_rUqDy6.d.cts → edge-P07GCO2Y.d.cts}

@@ -518,6 +518,7 @@ declare class CacheStack extends EventEmitter {
     private unsubscribeInvalidation?;
     private readonly logger;
     private readonly tagIndex;
+    private readonly keyDiscovery;
     private readonly fetchRateLimiter;
     private readonly snapshotSerializer;
     private readonly backgroundRefreshes;
@@ -640,8 +641,6 @@ declare class CacheStack extends EventEmitter {
     private sleep;
     private withTimeout;
     private shouldBroadcastL1Invalidation;
-    private collectKeysWithPrefix;
-    private collectKeysMatchingPattern;
     private shouldCleanupGenerations;
     private generationCleanupBatchSize;
     private scheduleGenerationCleanup;
@@ -664,6 +663,7 @@ declare class CacheStack extends EventEmitter {
     private validateRateLimitOptions;
     private validateNonNegativeNumber;
     private validateCacheKey;
+    private validatePattern;
     private validateTtlPolicy;
     private assertActive;
     private awaitStartup;

package/dist/{edge-B_rUqDy6.d.ts → edge-P07GCO2Y.d.ts}

@@ -518,6 +518,7 @@ declare class CacheStack extends EventEmitter {
     private unsubscribeInvalidation?;
     private readonly logger;
     private readonly tagIndex;
+    private readonly keyDiscovery;
     private readonly fetchRateLimiter;
     private readonly snapshotSerializer;
     private readonly backgroundRefreshes;
@@ -640,8 +641,6 @@ declare class CacheStack extends EventEmitter {
     private sleep;
     private withTimeout;
     private shouldBroadcastL1Invalidation;
-    private collectKeysWithPrefix;
-    private collectKeysMatchingPattern;
     private shouldCleanupGenerations;
     private generationCleanupBatchSize;
     private scheduleGenerationCleanup;
@@ -664,6 +663,7 @@ declare class CacheStack extends EventEmitter {
     private validateRateLimitOptions;
     private validateNonNegativeNumber;
     private validateCacheKey;
+    private validatePattern;
     private validateTtlPolicy;
     private assertActive;
     private awaitStartup;

package/dist/edge.cjs

@@ -295,6 +295,7 @@ var PatternMatcher = class _PatternMatcher {
 };
 
 // src/invalidation/TagIndex.ts
+var MAX_PATTERN_RECURSION_DEPTH = 500;
 var TagIndex = class {
   tagToKeys = /* @__PURE__ */ new Map();
   keyToTags = /* @__PURE__ */ new Map();
@@ -349,7 +350,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() {
@@ -401,7 +402,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;
@@ -418,21 +422,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() {
@@ -533,7 +553,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;
   }

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-B_rUqDy6.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-P07GCO2Y.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-B_rUqDy6.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-P07GCO2Y.js';
 import 'node:events';

package/dist/edge.js

@@ -2,7 +2,7 @@ import {
   MemoryLayer,
   TagIndex,
   createHonoCacheMiddleware
-} from "./chunk-KOYGHLVP.js";
+} from "./chunk-JC26W3KK.js";
 import {
   PatternMatcher
 } from "./chunk-7V7XAB74.js";