@warlock.js/cache 5.19.1 → 5.21.0

package/esm/list/memory-cache-list.mjs

@@ -7,13 +7,14 @@
 * driver overrides `list()` to return a native-command accessor instead.
 *
 * **Role.** Fallback list accessor bound to a driver + key. Every mutation
-* fetches the array, transforms it in memory, and writes it back.
+* runs through `driver.update()`, so it is serialized in-process and keeps the
+* entry's remaining TTL.
 *
 * **Responsibility.**
 * - Owns: translating list operations into array mutations + driver writes.
-* - Does NOT own: concurrency control (callers should wrap in a distributed
-*   lock when multi-process writers are possible), TTL preservation across
-*   ops (writes use driver defaults), or tagging of list entries.
+* - Does NOT own: cross-process concurrency control (callers should wrap in a
+*   distributed lock when multi-process writers are possible), or tagging of
+*   list entries.
 *
 * @example
 * // Never constructed directly — obtained via driver.list():
@@ -33,53 +34,48 @@ var MemoryCacheList = class {
 		return Array.isArray(current) ? [...current] : [];
 	}
 	/**
-	* Persist the backing array. Removes the entry when empty to keep the
-	* store clean.
+	* Serialized read-modify-write through `driver.update()`. No ttl is passed,
+	* so the driver keeps the entry's remaining TTL. An empty list removes the
+	* entry to keep the store clean.
 	*/
-	async write(items) {
-		if (items.length === 0) {
-			await this.driver.remove(this.key);
-			return;
-		}
-		await this.driver.set(this.key, items);
+	async mutate(mutation) {
+		let result;
+		await this.driver.update(this.key, (current) => {
+			const items = Array.isArray(current) ? [...current] : [];
+			result = mutation(items);
+			return items.length === 0 ? null : items;
+		});
+		return result;
 	}
 	/**
 	* {@inheritdoc}
 	*/
-	async push(...items) {
-		const current = await this.read();
-		current.push(...items);
-		await this.write(current);
-		return current.length;
+	push(...items) {
+		return this.mutate((current) => {
+			current.push(...items);
+			return current.length;
+		});
 	}
 	/**
 	* {@inheritdoc}
 	*/
-	async unshift(...items) {
-		const current = await this.read();
-		current.unshift(...items);
-		await this.write(current);
-		return current.length;
+	unshift(...items) {
+		return this.mutate((current) => {
+			current.unshift(...items);
+			return current.length;
+		});
 	}
 	/**
 	* {@inheritdoc}
 	*/
-	async pop() {
-		const current = await this.read();
-		if (current.length === 0) return null;
-		const value = current.pop();
-		await this.write(current);
-		return value;
+	pop() {
+		return this.mutate((current) => current.length === 0 ? null : current.pop());
 	}
 	/**
 	* {@inheritdoc}
 	*/
-	async shift() {
-		const current = await this.read();
-		if (current.length === 0) return null;
-		const value = current.shift();
-		await this.write(current);
-		return value;
+	shift() {
+		return this.mutate((current) => current.length === 0 ? null : current.shift());
 	}
 	/**
 	* {@inheritdoc}
@@ -100,11 +96,17 @@ var MemoryCacheList = class {
 		return (await this.read()).length;
 	}
 	/**
-	* {@inheritdoc}
+	* Keep the inclusive range `[start, end]` like Redis LTRIM; negative
+	* indexes count from the end.
 	*/
 	async trim(start, end) {
-		const trimmed = (await this.read()).slice(start, end + 1);
-		await this.write(trimmed);
+		await this.mutate((current) => {
+			const length = current.length;
+			const from = start < 0 ? Math.max(length + start, 0) : start;
+			const to = end < 0 ? length + end : end;
+			const kept = current.slice(from, to + 1);
+			current.splice(0, current.length, ...kept);
+		});
 	}
 	/**
 	* {@inheritdoc}

package/esm/list/memory-cache-list.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"memory-cache-list.mjs","names":[],"sources":["../../../../../../../cache/src/list/memory-cache-list.ts"],"sourcesContent":["import type { CacheDriver, CacheKey, CacheListAccessor } from \"../types\";\n\n/**\n * Generic array-backed {@link CacheListAccessor}.\n *\n * Stores the full list as a single cache entry and performs read-mutate-write\n * for every operation. Correct for any driver, but O(n) per op. The Redis\n * driver overrides `list()` to return a native-command accessor instead.\n *\n * **Role.** Fallback list accessor bound to a driver + key. Every mutation\n * fetches the array, transforms it in memory, and writes it back.\n *\n * **Responsibility.**\n * - Owns: translating list operations into array mutations + driver writes.\n * - Does NOT own: concurrency control (callers should wrap in a distributed\n *   lock when multi-process writers are possible), TTL preservation across\n *   ops (writes use driver defaults), or tagging of list entries.\n *\n * @example\n * // Never constructed directly — obtained via driver.list():\n * const list = cache.list<Event>(\"recent-events\");\n * await list.push(event);\n */\nexport class MemoryCacheList<T> implements CacheListAccessor<T> {\n  public constructor(\n    private readonly driver: CacheDriver<any, any>,\n    private readonly key: CacheKey,\n  ) {}\n\n  /**\n   * Read the backing array from the driver. Returns an empty array on miss.\n   */\n  private async read(): Promise<T[]> {\n    const current = (await this.driver.get(this.key)) as T[] | null;\n    return Array.isArray(current) ? [...current] : [];\n  }\n\n  /**\n   * Persist the backing array. Removes the entry when empty to keep the\n   * store clean.\n   */\n  private async write(items: T[]): Promise<void> {\n    if (items.length === 0) {\n      await this.driver.remove(this.key);\n      return;\n    }\n\n    await this.driver.set(this.key, items);\n  }\n\n  /**\n   * {@inheritdoc}\n   */\n  public async push(...items: T[]): Promise<number> {\n    const current = await this.read();\n    current.push(...items);\n    await this.write(current);\n\n    return current.length;\n  }\n\n  /**\n   * {@inheritdoc}\n   */\n  public async unshift(...items: T[]): Promise<number> {\n    const current = await this.read();\n    current.unshift(...items);\n    await this.write(current);\n\n    return current.length;\n  }\n\n  /**\n   * {@inheritdoc}\n   */\n  public async pop(): Promise<T | null> {\n    const current = await this.read();\n\n    if (current.length === 0) {\n      return null;\n    }\n\n    const value = current.pop() as T;\n    await this.write(current);\n\n    return value;\n  }\n\n  /**\n   * {@inheritdoc}\n   */\n  public async shift(): Promise<T | null> {\n    const current = await this.read();\n\n    if (current.length === 0) {\n      return null;\n    }\n\n    const value = current.shift() as T;\n    await this.write(current);\n\n    return value;\n  }\n\n  /**\n   * {@inheritdoc}\n   */\n  public async slice(start?: number, end?: number): Promise<T[]> {\n    const current = await this.read();\n    return current.slice(start, end);\n  }\n\n  /**\n   * {@inheritdoc}\n   */\n  public async all(): Promise<T[]> {\n    return this.read();\n  }\n\n  /**\n   * {@inheritdoc}\n   */\n  public async length(): Promise<number> {\n    const current = await this.read();\n    return current.length;\n  }\n\n  /**\n   * {@inheritdoc}\n   */\n  public async trim(start: number, end: number): Promise<void> {\n    const current = await this.read();\n    const trimmed = current.slice(start, end + 1);\n    await this.write(trimmed);\n  }\n\n  /**\n   * {@inheritdoc}\n   */\n  public async clear(): Promise<void> {\n    await this.driver.remove(this.key);\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;AAuBA,IAAa,kBAAb,MAAgE;CAC9D,AAAO,YACL,AAAiB,QACjB,AAAiB,KACjB;EAFiB;EACA;CAChB;;;;CAKH,MAAc,OAAqB;EACjC,MAAM,UAAW,MAAM,KAAK,OAAO,IAAI,KAAK,GAAG;EAC/C,OAAO,MAAM,QAAQ,OAAO,IAAI,CAAC,GAAG,OAAO,IAAI,CAAC;CAClD;;;;;CAMA,MAAc,MAAM,OAA2B;EAC7C,IAAI,MAAM,WAAW,GAAG;GACtB,MAAM,KAAK,OAAO,OAAO,KAAK,GAAG;GACjC;EACF;EAEA,MAAM,KAAK,OAAO,IAAI,KAAK,KAAK,KAAK;CACvC;;;;CAKA,MAAa,KAAK,GAAG,OAA6B;EAChD,MAAM,UAAU,MAAM,KAAK,KAAK;EAChC,QAAQ,KAAK,GAAG,KAAK;EACrB,MAAM,KAAK,MAAM,OAAO;EAExB,OAAO,QAAQ;CACjB;;;;CAKA,MAAa,QAAQ,GAAG,OAA6B;EACnD,MAAM,UAAU,MAAM,KAAK,KAAK;EAChC,QAAQ,QAAQ,GAAG,KAAK;EACxB,MAAM,KAAK,MAAM,OAAO;EAExB,OAAO,QAAQ;CACjB;;;;CAKA,MAAa,MAAyB;EACpC,MAAM,UAAU,MAAM,KAAK,KAAK;EAEhC,IAAI,QAAQ,WAAW,GACrB,OAAO;EAGT,MAAM,QAAQ,QAAQ,IAAI;EAC1B,MAAM,KAAK,MAAM,OAAO;EAExB,OAAO;CACT;;;;CAKA,MAAa,QAA2B;EACtC,MAAM,UAAU,MAAM,KAAK,KAAK;EAEhC,IAAI,QAAQ,WAAW,GACrB,OAAO;EAGT,MAAM,QAAQ,QAAQ,MAAM;EAC5B,MAAM,KAAK,MAAM,OAAO;EAExB,OAAO;CACT;;;;CAKA,MAAa,MAAM,OAAgB,KAA4B;EAE7D,QAAO,MADe,KAAK,KAAK,EAClB,CAAC,MAAM,OAAO,GAAG;CACjC;;;;CAKA,MAAa,MAAoB;EAC/B,OAAO,KAAK,KAAK;CACnB;;;;CAKA,MAAa,SAA0B;EAErC,QAAO,MADe,KAAK,KAAK,EAClB,CAAC;CACjB;;;;CAKA,MAAa,KAAK,OAAe,KAA4B;EAE3D,MAAM,WAAU,MADM,KAAK,KAAK,EACT,CAAC,MAAM,OAAO,MAAM,CAAC;EAC5C,MAAM,KAAK,MAAM,OAAO;CAC1B;;;;CAKA,MAAa,QAAuB;EAClC,MAAM,KAAK,OAAO,OAAO,KAAK,GAAG;CACnC;AACF"}
+{"version":3,"file":"memory-cache-list.mjs","names":[],"sources":["../../../../../../../cache/src/list/memory-cache-list.ts"],"sourcesContent":["import type { CacheDriver, CacheKey, CacheListAccessor } from \"../types\";\n\n/**\n * Generic array-backed {@link CacheListAccessor}.\n *\n * Stores the full list as a single cache entry and performs read-mutate-write\n * for every operation. Correct for any driver, but O(n) per op. The Redis\n * driver overrides `list()` to return a native-command accessor instead.\n *\n * **Role.** Fallback list accessor bound to a driver + key. Every mutation\n * runs through `driver.update()`, so it is serialized in-process and keeps the\n * entry's remaining TTL.\n *\n * **Responsibility.**\n * - Owns: translating list operations into array mutations + driver writes.\n * - Does NOT own: cross-process concurrency control (callers should wrap in a\n *   distributed lock when multi-process writers are possible), or tagging of\n *   list entries.\n *\n * @example\n * // Never constructed directly — obtained via driver.list():\n * const list = cache.list<Event>(\"recent-events\");\n * await list.push(event);\n */\nexport class MemoryCacheList<T> implements CacheListAccessor<T> {\n  public constructor(\n    private readonly driver: CacheDriver<any, any>,\n    private readonly key: CacheKey,\n  ) {}\n\n  /**\n   * Read the backing array from the driver. Returns an empty array on miss.\n   */\n  private async read(): Promise<T[]> {\n    const current = (await this.driver.get(this.key)) as T[] | null;\n    return Array.isArray(current) ? [...current] : [];\n  }\n\n  /**\n   * Serialized read-modify-write through `driver.update()`. No ttl is passed,\n   * so the driver keeps the entry's remaining TTL. An empty list removes the\n   * entry to keep the store clean.\n   */\n  private async mutate<R>(mutation: (items: T[]) => R): Promise<R> {\n    let result!: R;\n\n    await this.driver.update<T[]>(this.key, current => {\n      const items = Array.isArray(current) ? [...current] : [];\n\n      result = mutation(items);\n\n      return items.length === 0 ? null : items;\n    });\n\n    return result;\n  }\n\n  /**\n   * {@inheritdoc}\n   */\n  public push(...items: T[]): Promise<number> {\n    return this.mutate(current => {\n      current.push(...items);\n\n      return current.length;\n    });\n  }\n\n  /**\n   * {@inheritdoc}\n   */\n  public unshift(...items: T[]): Promise<number> {\n    return this.mutate(current => {\n      current.unshift(...items);\n\n      return current.length;\n    });\n  }\n\n  /**\n   * {@inheritdoc}\n   */\n  public pop(): Promise<T | null> {\n    return this.mutate(current => (current.length === 0 ? null : (current.pop() as T)));\n  }\n\n  /**\n   * {@inheritdoc}\n   */\n  public shift(): Promise<T | null> {\n    return this.mutate(current => (current.length === 0 ? null : (current.shift() as T)));\n  }\n\n  /**\n   * {@inheritdoc}\n   */\n  public async slice(start?: number, end?: number): Promise<T[]> {\n    const current = await this.read();\n    return current.slice(start, end);\n  }\n\n  /**\n   * {@inheritdoc}\n   */\n  public async all(): Promise<T[]> {\n    return this.read();\n  }\n\n  /**\n   * {@inheritdoc}\n   */\n  public async length(): Promise<number> {\n    const current = await this.read();\n    return current.length;\n  }\n\n  /**\n   * Keep the inclusive range `[start, end]` like Redis LTRIM; negative\n   * indexes count from the end.\n   */\n  public async trim(start: number, end: number): Promise<void> {\n    await this.mutate(current => {\n      const length = current.length;\n      const from = start < 0 ? Math.max(length + start, 0) : start;\n      const to = end < 0 ? length + end : end;\n      const kept = current.slice(from, to + 1);\n\n      current.splice(0, current.length, ...kept);\n    });\n  }\n\n  /**\n   * {@inheritdoc}\n   */\n  public async clear(): Promise<void> {\n    await this.driver.remove(this.key);\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;AAwBA,IAAa,kBAAb,MAAgE;CAC9D,AAAO,YACL,AAAiB,QACjB,AAAiB,KACjB;EAFiB;EACA;CAChB;;;;CAKH,MAAc,OAAqB;EACjC,MAAM,UAAW,MAAM,KAAK,OAAO,IAAI,KAAK,GAAG;EAC/C,OAAO,MAAM,QAAQ,OAAO,IAAI,CAAC,GAAG,OAAO,IAAI,CAAC;CAClD;;;;;;CAOA,MAAc,OAAU,UAAyC;EAC/D,IAAI;EAEJ,MAAM,KAAK,OAAO,OAAY,KAAK,MAAK,YAAW;GACjD,MAAM,QAAQ,MAAM,QAAQ,OAAO,IAAI,CAAC,GAAG,OAAO,IAAI,CAAC;GAEvD,SAAS,SAAS,KAAK;GAEvB,OAAO,MAAM,WAAW,IAAI,OAAO;EACrC,CAAC;EAED,OAAO;CACT;;;;CAKA,AAAO,KAAK,GAAG,OAA6B;EAC1C,OAAO,KAAK,QAAO,YAAW;GAC5B,QAAQ,KAAK,GAAG,KAAK;GAErB,OAAO,QAAQ;EACjB,CAAC;CACH;;;;CAKA,AAAO,QAAQ,GAAG,OAA6B;EAC7C,OAAO,KAAK,QAAO,YAAW;GAC5B,QAAQ,QAAQ,GAAG,KAAK;GAExB,OAAO,QAAQ;EACjB,CAAC;CACH;;;;CAKA,AAAO,MAAyB;EAC9B,OAAO,KAAK,QAAO,YAAY,QAAQ,WAAW,IAAI,OAAQ,QAAQ,IAAI,CAAQ;CACpF;;;;CAKA,AAAO,QAA2B;EAChC,OAAO,KAAK,QAAO,YAAY,QAAQ,WAAW,IAAI,OAAQ,QAAQ,MAAM,CAAQ;CACtF;;;;CAKA,MAAa,MAAM,OAAgB,KAA4B;EAE7D,QAAO,MADe,KAAK,KAAK,EAClB,CAAC,MAAM,OAAO,GAAG;CACjC;;;;CAKA,MAAa,MAAoB;EAC/B,OAAO,KAAK,KAAK;CACnB;;;;CAKA,MAAa,SAA0B;EAErC,QAAO,MADe,KAAK,KAAK,EAClB,CAAC;CACjB;;;;;CAMA,MAAa,KAAK,OAAe,KAA4B;EAC3D,MAAM,KAAK,QAAO,YAAW;GAC3B,MAAM,SAAS,QAAQ;GACvB,MAAM,OAAO,QAAQ,IAAI,KAAK,IAAI,SAAS,OAAO,CAAC,IAAI;GACvD,MAAM,KAAK,MAAM,IAAI,SAAS,MAAM;GACpC,MAAM,OAAO,QAAQ,MAAM,MAAM,KAAK,CAAC;GAEvC,QAAQ,OAAO,GAAG,QAAQ,QAAQ,GAAG,IAAI;EAC3C,CAAC;CACH;;;;CAKA,MAAa,QAAuB;EAClC,MAAM,KAAK,OAAO,OAAO,KAAK,GAAG;CACnC;AACF"}

package/esm/scoped-cache.d.mts

@@ -144,9 +144,10 @@ declare class ScopedCache implements ScopedCacheContract {
    */
   decrement(key: CacheKey, value?: number): Promise<number>;
   /**
-   * Atomic read-modify-write. Falls back to the scope's `ttl` when the caller
-   * doesn't provide one; the source still keeps the existing entry's TTL on
-   * an update unless `options.ttl` is explicitly set.
+   * Atomic read-modify-write. An explicit `options.ttl` always wins. Otherwise
+   * the scope's default `ttl` is applied only when the key does not exist yet;
+   * for an existing key no ttl is passed so the source preserves the entry's
+   * remaining TTL.
    */
   update<T = any>(key: CacheKey, fn: (current: T | null) => T | null | Promise<T | null>, options?: {
     ttl?: CacheTtl;
@@ -158,6 +159,11 @@ declare class ScopedCache implements ScopedCacheContract {
   merge<T extends Record<string, any> = Record<string, any>>(key: CacheKey, partial: Partial<T>, options?: {
     ttl?: CacheTtl;
   }): Promise<T>;
+  /**
+   * Resolve the ttl options for update/merge: explicit ttl, else the scope
+   * default only for keys that don't exist yet, else nothing (keep remaining).
+   */
+  private writeOptions;
   /**
    * Return a list accessor bound to the scoped key. The accessor itself
    * does its own read-mutate-write under the prefixed entry.

package/esm/scoped-cache.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"scoped-cache.d.mts","names":[],"sources":["../../../../../../cache/src/scoped-cache.ts"],"mappings":"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"}
+{"version":3,"file":"scoped-cache.d.mts","names":[],"sources":["../../../../../../cache/src/scoped-cache.ts"],"mappings":"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"}

package/esm/scoped-cache.mjs

@@ -174,19 +174,31 @@ var ScopedCache = class ScopedCache {
 		return this.source.decrement(this.scopedKey(key), value);
 	}
 	/**
-	* Atomic read-modify-write. Falls back to the scope's `ttl` when the caller
-	* doesn't provide one; the source still keeps the existing entry's TTL on
-	* an update unless `options.ttl` is explicitly set.
+	* Atomic read-modify-write. An explicit `options.ttl` always wins. Otherwise
+	* the scope's default `ttl` is applied only when the key does not exist yet;
+	* for an existing key no ttl is passed so the source preserves the entry's
+	* remaining TTL.
 	*/
-	update(key, fn, options) {
-		return this.source.update(this.scopedKey(key), fn, { ttl: options?.ttl ?? this.defaults.ttl });
+	async update(key, fn, options) {
+		const scopedKey = this.scopedKey(key);
+		return this.source.update(scopedKey, fn, await this.writeOptions(scopedKey, options));
 	}
 	/**
 	* Shallow-merge a partial object into the scoped entry. Same TTL semantics
 	* as {@link update}.
 	*/
-	merge(key, partial, options) {
-		return this.source.merge(this.scopedKey(key), partial, { ttl: options?.ttl ?? this.defaults.ttl });
+	async merge(key, partial, options) {
+		const scopedKey = this.scopedKey(key);
+		return this.source.merge(scopedKey, partial, await this.writeOptions(scopedKey, options));
+	}
+	/**
+	* Resolve the ttl options for update/merge: explicit ttl, else the scope
+	* default only for keys that don't exist yet, else nothing (keep remaining).
+	*/
+	async writeOptions(scopedKey, options) {
+		if (options?.ttl !== void 0) return { ttl: options.ttl };
+		if (this.defaults.ttl === void 0) return {};
+		return await this.source.has(scopedKey) ? {} : { ttl: this.defaults.ttl };
 	}
 	/**
 	* Return a list accessor bound to the scoped key. The accessor itself

package/esm/scoped-cache.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"scoped-cache.mjs","names":[],"sources":["../../../../../../cache/src/scoped-cache.ts"],"sourcesContent":["import { TaggedScopedCache } from \"./tagged-scoped-cache\";\nimport type {\n  CacheDriver,\n  CacheKey,\n  CacheListAccessor,\n  CacheNamespaceOptions,\n  CacheSetOptions,\n  CacheSimilarHit,\n  CacheSimilarOptions,\n  CacheSwrOptions,\n  CacheTtl,\n  LockOptions,\n  LockOutcome,\n  RememberOptions,\n  ScopedCacheContract,\n  TaggedScopedCacheContract,\n} from \"./types\";\nimport {\n  mergeTagSets,\n  normalizeToOptions,\n  normalizeToRememberOptions,\n  parseCacheKey,\n  parseTtl,\n} from \"./utils\";\n\n/**\n * Scoped view over a cache source. Returned by `cache.namespace(prefix, options?)`.\n *\n * **Role.** A `ScopedCache` is a stateless wrapper that prepends a fixed\n * prefix to every key and applies optional default `ttl` / `tags` to every\n * write. Stores nothing itself — every call forwards to the underlying\n * `source` (typically the `CacheManager`, but any `CacheDriver` works).\n *\n * **Responsibility.**\n * - Owns: prefix-prepending of keys, normalization of nested-scope prefixes,\n *   merging scope defaults into write options (`ttl`, `tags`), filtering\n *   `similar()` hits to its own scope, and exposing `.clear()` as a sugar\n *   for `removeNamespace(prefix)`.\n * - Does NOT own: actual storage, connection lifecycle, event listeners,\n *   driver selection, or tag-index bookkeeping (delegated to the source's\n *   tagged-cache machinery).\n *\n * Per-call options always win over scope defaults; tags merge additively\n * across (scope defaults + per-call) layers. Nested scopes inherit and may\n * override the parent's defaults — see {@link ScopedCache.namespace}.\n *\n * @example\n * const chat = cache.namespace(`chats.${id}`, { ttl: \"30d\" });\n *\n * await chat.set(\"messages.10\", msg);          // 30d default\n * await chat.set(\"draft\", d, { ttl: \"1h\" });   // per-call override\n * await chat.namespace(\"typing\", { ttl: \"5s\" }).set(\"user.42\", true);\n * await chat.clear();\n */\nexport class ScopedCache implements ScopedCacheContract {\n  /**\n   * Fully-qualified prefix prepended to every key handled by this scope.\n   * Normalized through {@link parseCacheKey} on construction so colon-form\n   * input (`\"chats:10\"`) and trailing dots compose cleanly with nested scopes.\n   */\n  public readonly prefix: string;\n\n  /**\n   * Underlying cache source. Public-readonly so co-located helpers\n   * (`TaggedScopedCache`) can delegate without ceremony — not part of the\n   * stable consumer API.\n   *\n   * @internal\n   */\n  public readonly source: CacheDriver<any, any>;\n\n  /**\n   * Defaults applied to every write through this scope. Per-call options\n   * override `ttl`; `tags` merge additively across layers.\n   *\n   * @internal\n   */\n  public readonly defaults: CacheNamespaceOptions;\n\n  /**\n   * Build a scope. Constructed via `cache.namespace(prefix, options)` —\n   * users never call this directly.\n   */\n  public constructor(\n    source: CacheDriver<any, any>,\n    prefix: string,\n    defaults: CacheNamespaceOptions = {},\n  ) {\n    this.source = source;\n    this.prefix = parseCacheKey(prefix);\n    this.defaults = {\n      ttl: defaults.ttl,\n      tags: defaults.tags && defaults.tags.length > 0 ? [...defaults.tags] : undefined,\n    };\n  }\n\n  /**\n   * Build a nested scope. The child's prefix is `parent.child`; child options\n   * override the parent's `ttl` and union into `tags`.\n   *\n   * @example\n   * const chat = cache.namespace(\"chats.10\", { ttl: \"30d\" });\n   * const typing = chat.namespace(\"typing\", { ttl: \"5s\" });\n   * // typing.prefix === \"chats.10.typing\"\n   */\n  public namespace(prefix: string, options: CacheNamespaceOptions = {}): ScopedCacheContract {\n    const childPrefix = `${this.prefix}.${parseCacheKey(prefix)}`;\n\n    return new ScopedCache(this.source, childPrefix, {\n      ttl: options.ttl ?? this.defaults.ttl,\n      tags: mergeTagSets(this.defaults.tags, options.tags),\n    });\n  }\n\n  /**\n   * Return a one-shot tagged write handle. The handle's tags merge additively\n   * with scope-level defaults — final tag list per write is the union of\n   * (scope tags + handle tags + per-call tags), deduped.\n   */\n  public tags(tags: string[]): TaggedScopedCacheContract {\n    return new TaggedScopedCache(this, tags);\n  }\n\n  /**\n   * Wipe every entry under this scope's prefix. Sugar over\n   * `source.removeNamespace(prefix)` — siblings outside the scope are\n   * untouched.\n   */\n  public clear(): Promise<void> {\n    return this.source.removeNamespace(this.prefix);\n  }\n\n  /**\n   * Read the value at the scoped key. Forwards to the source after prefixing.\n   */\n  public get<T = any>(key: CacheKey): Promise<T | null> {\n    return this.source.get<T>(this.scopedKey(key));\n  }\n\n  /**\n   * Check presence of the scoped key without fetching the value.\n   */\n  public has(key: CacheKey): Promise<boolean> {\n    return this.source.has(this.scopedKey(key));\n  }\n\n  /**\n   * Batch-read scoped keys. Each input key is prefixed before forwarding.\n   */\n  public many(keys: CacheKey[]): Promise<any[]> {\n    return this.source.many(keys.map((key) => this.scopedKey(key)));\n  }\n\n  /**\n   * Read-and-remove. Returns the value or `null`; the entry is gone after.\n   */\n  public pull<T = any>(key: CacheKey): Promise<T | null> {\n    return this.source.pull<T>(this.scopedKey(key));\n  }\n\n  /**\n   * Write the scoped key. Per-call `ttl`/`tags` win over scope defaults;\n   * `expiresAt` is preserved as-is (absolute deadlines are never overridden\n   * by the scope's relative-ttl default).\n   */\n  public set(\n    key: CacheKey,\n    value: any,\n    ttlOrOptions?: CacheTtl | CacheSetOptions,\n  ): Promise<any> {\n    return this.source.set(this.scopedKey(key), value, this.mergeSetOptions(ttlOrOptions));\n  }\n\n  /**\n   * Batch-write under the scope. Caller's positional `ttl` wins; otherwise\n   * the scope default is parsed to seconds (since `setMany` accepts only a\n   * numeric ttl).\n   */\n  public setMany(items: Record<string, any>, ttl?: number): Promise<void> {\n    const scoped: Record<string, any> = {};\n\n    for (const [key, value] of Object.entries(items)) {\n      scoped[this.scopedKey(key)] = value;\n    }\n\n    return this.source.setMany(scoped, ttl ?? this.scopeTtlSeconds());\n  }\n\n  /**\n   * Atomic create-or-skip on the scoped key. Throws when the underlying\n   * source has no `setNX` (driver-specific — Redis-only today).\n   */\n  public setNX(key: CacheKey, value: any, ttl?: number): Promise<boolean> {\n    if (!this.source.setNX) {\n      throw new Error(\n        `setNX is not supported by the underlying cache source: ${this.source.name}`,\n      );\n    }\n\n    return this.source.setNX(this.scopedKey(key), value, ttl ?? this.scopeTtlSeconds());\n  }\n\n  /**\n   * Permanent write (no expiration). Bypasses the scope's `ttl` default —\n   * `forever` always means forever, regardless of scope policy.\n   */\n  public forever<T = any>(key: CacheKey, value: T): Promise<T> {\n    return this.source.forever<T>(this.scopedKey(key), value);\n  }\n\n  /**\n   * Remove a single scoped key.\n   */\n  public remove(key: CacheKey): Promise<void> {\n    return this.source.remove(this.scopedKey(key));\n  }\n\n  /**\n   * Read-or-compute. Cache-miss writes pick up the scope's default `ttl`\n   * and `tags` unless the caller passed an options object that overrides.\n   */\n  public remember<T = any>(\n    key: CacheKey,\n    ttlOrOptions: CacheTtl | RememberOptions,\n    callback: () => Promise<T>,\n  ): Promise<T> {\n    return this.source.remember<T>(\n      this.scopedKey(key),\n      this.mergeRememberOptions(ttlOrOptions),\n      callback,\n    );\n  }\n\n  /**\n   * Stale-while-revalidate on the scoped key. Scope-level `tags` merge\n   * additively with `options.tags`; `freshTtl`/`staleTtl` always come from\n   * the caller (no scope-default precedence — the SWR shape is too\n   * specific to the call site to inherit).\n   */\n  public swr<T = any>(\n    key: CacheKey,\n    options: CacheSwrOptions,\n    callback: () => Promise<T>,\n  ): Promise<T> {\n    const merged: CacheSwrOptions = {\n      ...options,\n      tags: mergeTagSets(this.defaults.tags, options.tags),\n    };\n\n    return this.source.swr<T>(this.scopedKey(key), merged, callback);\n  }\n\n  /**\n   * Atomic counter increment on the scoped key. TTL is preserved by the\n   * underlying driver — scope ttl is only applied on first write via `set`.\n   */\n  public increment(key: CacheKey, value?: number): Promise<number> {\n    return this.source.increment(this.scopedKey(key), value);\n  }\n\n  /**\n   * Atomic counter decrement on the scoped key. See {@link increment} for\n   * TTL semantics.\n   */\n  public decrement(key: CacheKey, value?: number): Promise<number> {\n    return this.source.decrement(this.scopedKey(key), value);\n  }\n\n  /**\n   * Atomic read-modify-write. Falls back to the scope's `ttl` when the caller\n   * doesn't provide one; the source still keeps the existing entry's TTL on\n   * an update unless `options.ttl` is explicitly set.\n   */\n  public update<T = any>(\n    key: CacheKey,\n    fn: (current: T | null) => T | null | Promise<T | null>,\n    options?: { ttl?: CacheTtl },\n  ): Promise<T | null> {\n    return this.source.update<T>(this.scopedKey(key), fn, {\n      ttl: options?.ttl ?? this.defaults.ttl,\n    });\n  }\n\n  /**\n   * Shallow-merge a partial object into the scoped entry. Same TTL semantics\n   * as {@link update}.\n   */\n  public merge<T extends Record<string, any> = Record<string, any>>(\n    key: CacheKey,\n    partial: Partial<T>,\n    options?: { ttl?: CacheTtl },\n  ): Promise<T> {\n    return this.source.merge<T>(this.scopedKey(key), partial, {\n      ttl: options?.ttl ?? this.defaults.ttl,\n    });\n  }\n\n  /**\n   * Return a list accessor bound to the scoped key. The accessor itself\n   * does its own read-mutate-write under the prefixed entry.\n   */\n  public list<T = any>(key: CacheKey): CacheListAccessor<T> {\n    return this.source.list<T>(this.scopedKey(key));\n  }\n\n  /**\n   * Acquire a distributed lock on the scoped key. Caller's TTL wins; when\n   * the options form omits `ttl`, the scope default fills in.\n   */\n  public lock<T>(\n    key: CacheKey,\n    ttlOrOptions: CacheTtl | Omit<LockOptions, \"driver\">,\n    fn: () => Promise<T>,\n  ): Promise<LockOutcome<T>> {\n    if (typeof ttlOrOptions === \"object\" && ttlOrOptions !== null) {\n      const merged: Omit<LockOptions, \"driver\"> = {\n        ...ttlOrOptions,\n        ttl: ttlOrOptions.ttl ?? this.defaults.ttl ?? ttlOrOptions.ttl,\n      };\n\n      // The third coalesce is intentional — when both caller and scope omit\n      // the TTL, we still pass the original (undefined) through so the source\n      // raises its own validation error rather than us swallowing it silently.\n      return this.source.lock<T>(this.scopedKey(key), merged, fn);\n    }\n\n    return this.source.lock<T>(this.scopedKey(key), ttlOrOptions, fn);\n  }\n\n  /**\n   * Similarity retrieval, scope-isolated. Hits whose keys fall outside this\n   * scope are filtered out before the result is returned. `topK` applies to\n   * the underlying retrieval — when the scope contains fewer than `topK`\n   * matches but other scopes do, the caller will see fewer hits than `topK`.\n   */\n  public async similar<T = any>(\n    vector: number[],\n    options: CacheSimilarOptions,\n  ): Promise<CacheSimilarHit<T>[]> {\n    const hits = await this.source.similar<T>(vector, options);\n    const parsedPrefix = this.source.parseKey(this.prefix);\n\n    return hits.filter(\n      (hit) => hit.key === parsedPrefix || hit.key.startsWith(parsedPrefix + \".\"),\n    );\n  }\n\n  /**\n   * Build the source-side key by prepending the scope prefix. Object keys\n   * are normalized via {@link parseCacheKey} first so they compose with the\n   * prefix as plain dot-strings.\n   */\n  protected scopedKey(key: CacheKey): string {\n    const keyString = typeof key === \"string\" ? key : parseCacheKey(key);\n\n    if (!keyString) {\n      return this.prefix;\n    }\n\n    return `${this.prefix}.${keyString}`;\n  }\n\n  /**\n   * Coerce the polymorphic 3rd `set` argument into a {@link CacheSetOptions}\n   * with scope defaults filled in. Per-call values always win; tags merge\n   * additively. `expiresAt` is preserved without injecting the scope's `ttl`\n   * default (absolute deadlines override relative ones).\n   */\n  protected mergeSetOptions(\n    input?: CacheTtl | CacheSetOptions,\n  ): CacheSetOptions | undefined {\n    const options = normalizeToOptions(input);\n    const ttl =\n      options.ttl ?? (options.expiresAt === undefined ? this.defaults.ttl : undefined);\n    const tags = mergeTagSets(this.defaults.tags, options.tags);\n\n    const merged: CacheSetOptions = { ...options };\n\n    if (ttl !== undefined) {\n      merged.ttl = ttl;\n    }\n\n    if (tags !== undefined) {\n      merged.tags = tags;\n    }\n\n    return merged;\n  }\n\n  /**\n   * Same merge as {@link mergeSetOptions} but for the `remember()` shape\n   * ({@link RememberOptions} — no `expiresAt`).\n   */\n  protected mergeRememberOptions(\n    input: CacheTtl | RememberOptions,\n  ): CacheTtl | RememberOptions {\n    const options = normalizeToRememberOptions(input);\n    const ttl = options.ttl ?? this.defaults.ttl;\n    const tags = mergeTagSets(this.defaults.tags, options.tags);\n\n    const merged: RememberOptions = { ...options };\n\n    if (ttl !== undefined) {\n      merged.ttl = ttl;\n    }\n\n    if (tags !== undefined) {\n      merged.tags = tags;\n    }\n\n    return merged;\n  }\n\n  /**\n   * Convert the scope's default `ttl` (which may be a duration string) into\n   * seconds, for the few methods (`setMany`, `setNX`) that accept only a\n   * numeric ttl.\n   */\n  protected scopeTtlSeconds(): number | undefined {\n    if (this.defaults.ttl === undefined) {\n      return undefined;\n    }\n\n    return parseTtl(this.defaults.ttl);\n  }\n}\n"],"mappings":"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"}
+{"version":3,"file":"scoped-cache.mjs","names":[],"sources":["../../../../../../cache/src/scoped-cache.ts"],"sourcesContent":["import { TaggedScopedCache } from \"./tagged-scoped-cache\";\nimport type {\n  CacheDriver,\n  CacheKey,\n  CacheListAccessor,\n  CacheNamespaceOptions,\n  CacheSetOptions,\n  CacheSimilarHit,\n  CacheSimilarOptions,\n  CacheSwrOptions,\n  CacheTtl,\n  LockOptions,\n  LockOutcome,\n  RememberOptions,\n  ScopedCacheContract,\n  TaggedScopedCacheContract,\n} from \"./types\";\nimport {\n  mergeTagSets,\n  normalizeToOptions,\n  normalizeToRememberOptions,\n  parseCacheKey,\n  parseTtl,\n} from \"./utils\";\n\n/**\n * Scoped view over a cache source. Returned by `cache.namespace(prefix, options?)`.\n *\n * **Role.** A `ScopedCache` is a stateless wrapper that prepends a fixed\n * prefix to every key and applies optional default `ttl` / `tags` to every\n * write. Stores nothing itself — every call forwards to the underlying\n * `source` (typically the `CacheManager`, but any `CacheDriver` works).\n *\n * **Responsibility.**\n * - Owns: prefix-prepending of keys, normalization of nested-scope prefixes,\n *   merging scope defaults into write options (`ttl`, `tags`), filtering\n *   `similar()` hits to its own scope, and exposing `.clear()` as a sugar\n *   for `removeNamespace(prefix)`.\n * - Does NOT own: actual storage, connection lifecycle, event listeners,\n *   driver selection, or tag-index bookkeeping (delegated to the source's\n *   tagged-cache machinery).\n *\n * Per-call options always win over scope defaults; tags merge additively\n * across (scope defaults + per-call) layers. Nested scopes inherit and may\n * override the parent's defaults — see {@link ScopedCache.namespace}.\n *\n * @example\n * const chat = cache.namespace(`chats.${id}`, { ttl: \"30d\" });\n *\n * await chat.set(\"messages.10\", msg);          // 30d default\n * await chat.set(\"draft\", d, { ttl: \"1h\" });   // per-call override\n * await chat.namespace(\"typing\", { ttl: \"5s\" }).set(\"user.42\", true);\n * await chat.clear();\n */\nexport class ScopedCache implements ScopedCacheContract {\n  /**\n   * Fully-qualified prefix prepended to every key handled by this scope.\n   * Normalized through {@link parseCacheKey} on construction so colon-form\n   * input (`\"chats:10\"`) and trailing dots compose cleanly with nested scopes.\n   */\n  public readonly prefix: string;\n\n  /**\n   * Underlying cache source. Public-readonly so co-located helpers\n   * (`TaggedScopedCache`) can delegate without ceremony — not part of the\n   * stable consumer API.\n   *\n   * @internal\n   */\n  public readonly source: CacheDriver<any, any>;\n\n  /**\n   * Defaults applied to every write through this scope. Per-call options\n   * override `ttl`; `tags` merge additively across layers.\n   *\n   * @internal\n   */\n  public readonly defaults: CacheNamespaceOptions;\n\n  /**\n   * Build a scope. Constructed via `cache.namespace(prefix, options)` —\n   * users never call this directly.\n   */\n  public constructor(\n    source: CacheDriver<any, any>,\n    prefix: string,\n    defaults: CacheNamespaceOptions = {},\n  ) {\n    this.source = source;\n    this.prefix = parseCacheKey(prefix);\n    this.defaults = {\n      ttl: defaults.ttl,\n      tags: defaults.tags && defaults.tags.length > 0 ? [...defaults.tags] : undefined,\n    };\n  }\n\n  /**\n   * Build a nested scope. The child's prefix is `parent.child`; child options\n   * override the parent's `ttl` and union into `tags`.\n   *\n   * @example\n   * const chat = cache.namespace(\"chats.10\", { ttl: \"30d\" });\n   * const typing = chat.namespace(\"typing\", { ttl: \"5s\" });\n   * // typing.prefix === \"chats.10.typing\"\n   */\n  public namespace(prefix: string, options: CacheNamespaceOptions = {}): ScopedCacheContract {\n    const childPrefix = `${this.prefix}.${parseCacheKey(prefix)}`;\n\n    return new ScopedCache(this.source, childPrefix, {\n      ttl: options.ttl ?? this.defaults.ttl,\n      tags: mergeTagSets(this.defaults.tags, options.tags),\n    });\n  }\n\n  /**\n   * Return a one-shot tagged write handle. The handle's tags merge additively\n   * with scope-level defaults — final tag list per write is the union of\n   * (scope tags + handle tags + per-call tags), deduped.\n   */\n  public tags(tags: string[]): TaggedScopedCacheContract {\n    return new TaggedScopedCache(this, tags);\n  }\n\n  /**\n   * Wipe every entry under this scope's prefix. Sugar over\n   * `source.removeNamespace(prefix)` — siblings outside the scope are\n   * untouched.\n   */\n  public clear(): Promise<void> {\n    return this.source.removeNamespace(this.prefix);\n  }\n\n  /**\n   * Read the value at the scoped key. Forwards to the source after prefixing.\n   */\n  public get<T = any>(key: CacheKey): Promise<T | null> {\n    return this.source.get<T>(this.scopedKey(key));\n  }\n\n  /**\n   * Check presence of the scoped key without fetching the value.\n   */\n  public has(key: CacheKey): Promise<boolean> {\n    return this.source.has(this.scopedKey(key));\n  }\n\n  /**\n   * Batch-read scoped keys. Each input key is prefixed before forwarding.\n   */\n  public many(keys: CacheKey[]): Promise<any[]> {\n    return this.source.many(keys.map((key) => this.scopedKey(key)));\n  }\n\n  /**\n   * Read-and-remove. Returns the value or `null`; the entry is gone after.\n   */\n  public pull<T = any>(key: CacheKey): Promise<T | null> {\n    return this.source.pull<T>(this.scopedKey(key));\n  }\n\n  /**\n   * Write the scoped key. Per-call `ttl`/`tags` win over scope defaults;\n   * `expiresAt` is preserved as-is (absolute deadlines are never overridden\n   * by the scope's relative-ttl default).\n   */\n  public set(\n    key: CacheKey,\n    value: any,\n    ttlOrOptions?: CacheTtl | CacheSetOptions,\n  ): Promise<any> {\n    return this.source.set(this.scopedKey(key), value, this.mergeSetOptions(ttlOrOptions));\n  }\n\n  /**\n   * Batch-write under the scope. Caller's positional `ttl` wins; otherwise\n   * the scope default is parsed to seconds (since `setMany` accepts only a\n   * numeric ttl).\n   */\n  public setMany(items: Record<string, any>, ttl?: number): Promise<void> {\n    const scoped: Record<string, any> = {};\n\n    for (const [key, value] of Object.entries(items)) {\n      scoped[this.scopedKey(key)] = value;\n    }\n\n    return this.source.setMany(scoped, ttl ?? this.scopeTtlSeconds());\n  }\n\n  /**\n   * Atomic create-or-skip on the scoped key. Throws when the underlying\n   * source has no `setNX` (driver-specific — Redis-only today).\n   */\n  public setNX(key: CacheKey, value: any, ttl?: number): Promise<boolean> {\n    if (!this.source.setNX) {\n      throw new Error(\n        `setNX is not supported by the underlying cache source: ${this.source.name}`,\n      );\n    }\n\n    return this.source.setNX(this.scopedKey(key), value, ttl ?? this.scopeTtlSeconds());\n  }\n\n  /**\n   * Permanent write (no expiration). Bypasses the scope's `ttl` default —\n   * `forever` always means forever, regardless of scope policy.\n   */\n  public forever<T = any>(key: CacheKey, value: T): Promise<T> {\n    return this.source.forever<T>(this.scopedKey(key), value);\n  }\n\n  /**\n   * Remove a single scoped key.\n   */\n  public remove(key: CacheKey): Promise<void> {\n    return this.source.remove(this.scopedKey(key));\n  }\n\n  /**\n   * Read-or-compute. Cache-miss writes pick up the scope's default `ttl`\n   * and `tags` unless the caller passed an options object that overrides.\n   */\n  public remember<T = any>(\n    key: CacheKey,\n    ttlOrOptions: CacheTtl | RememberOptions,\n    callback: () => Promise<T>,\n  ): Promise<T> {\n    return this.source.remember<T>(\n      this.scopedKey(key),\n      this.mergeRememberOptions(ttlOrOptions),\n      callback,\n    );\n  }\n\n  /**\n   * Stale-while-revalidate on the scoped key. Scope-level `tags` merge\n   * additively with `options.tags`; `freshTtl`/`staleTtl` always come from\n   * the caller (no scope-default precedence — the SWR shape is too\n   * specific to the call site to inherit).\n   */\n  public swr<T = any>(\n    key: CacheKey,\n    options: CacheSwrOptions,\n    callback: () => Promise<T>,\n  ): Promise<T> {\n    const merged: CacheSwrOptions = {\n      ...options,\n      tags: mergeTagSets(this.defaults.tags, options.tags),\n    };\n\n    return this.source.swr<T>(this.scopedKey(key), merged, callback);\n  }\n\n  /**\n   * Atomic counter increment on the scoped key. TTL is preserved by the\n   * underlying driver — scope ttl is only applied on first write via `set`.\n   */\n  public increment(key: CacheKey, value?: number): Promise<number> {\n    return this.source.increment(this.scopedKey(key), value);\n  }\n\n  /**\n   * Atomic counter decrement on the scoped key. See {@link increment} for\n   * TTL semantics.\n   */\n  public decrement(key: CacheKey, value?: number): Promise<number> {\n    return this.source.decrement(this.scopedKey(key), value);\n  }\n\n  /**\n   * Atomic read-modify-write. An explicit `options.ttl` always wins. Otherwise\n   * the scope's default `ttl` is applied only when the key does not exist yet;\n   * for an existing key no ttl is passed so the source preserves the entry's\n   * remaining TTL.\n   */\n  public async update<T = any>(\n    key: CacheKey,\n    fn: (current: T | null) => T | null | Promise<T | null>,\n    options?: { ttl?: CacheTtl },\n  ): Promise<T | null> {\n    const scopedKey = this.scopedKey(key);\n\n    return this.source.update<T>(scopedKey, fn, await this.writeOptions(scopedKey, options));\n  }\n\n  /**\n   * Shallow-merge a partial object into the scoped entry. Same TTL semantics\n   * as {@link update}.\n   */\n  public async merge<T extends Record<string, any> = Record<string, any>>(\n    key: CacheKey,\n    partial: Partial<T>,\n    options?: { ttl?: CacheTtl },\n  ): Promise<T> {\n    const scopedKey = this.scopedKey(key);\n\n    return this.source.merge<T>(scopedKey, partial, await this.writeOptions(scopedKey, options));\n  }\n\n  /**\n   * Resolve the ttl options for update/merge: explicit ttl, else the scope\n   * default only for keys that don't exist yet, else nothing (keep remaining).\n   */\n  private async writeOptions(\n    scopedKey: CacheKey,\n    options?: { ttl?: CacheTtl },\n  ): Promise<{ ttl?: CacheTtl }> {\n    if (options?.ttl !== undefined) {\n      return { ttl: options.ttl };\n    }\n\n    if (this.defaults.ttl === undefined) {\n      return {};\n    }\n\n    return (await this.source.has(scopedKey)) ? {} : { ttl: this.defaults.ttl };\n  }\n\n  /**\n   * Return a list accessor bound to the scoped key. The accessor itself\n   * does its own read-mutate-write under the prefixed entry.\n   */\n  public list<T = any>(key: CacheKey): CacheListAccessor<T> {\n    return this.source.list<T>(this.scopedKey(key));\n  }\n\n  /**\n   * Acquire a distributed lock on the scoped key. Caller's TTL wins; when\n   * the options form omits `ttl`, the scope default fills in.\n   */\n  public lock<T>(\n    key: CacheKey,\n    ttlOrOptions: CacheTtl | Omit<LockOptions, \"driver\">,\n    fn: () => Promise<T>,\n  ): Promise<LockOutcome<T>> {\n    if (typeof ttlOrOptions === \"object\" && ttlOrOptions !== null) {\n      const merged: Omit<LockOptions, \"driver\"> = {\n        ...ttlOrOptions,\n        ttl: ttlOrOptions.ttl ?? this.defaults.ttl ?? ttlOrOptions.ttl,\n      };\n\n      // The third coalesce is intentional — when both caller and scope omit\n      // the TTL, we still pass the original (undefined) through so the source\n      // raises its own validation error rather than us swallowing it silently.\n      return this.source.lock<T>(this.scopedKey(key), merged, fn);\n    }\n\n    return this.source.lock<T>(this.scopedKey(key), ttlOrOptions, fn);\n  }\n\n  /**\n   * Similarity retrieval, scope-isolated. Hits whose keys fall outside this\n   * scope are filtered out before the result is returned. `topK` applies to\n   * the underlying retrieval — when the scope contains fewer than `topK`\n   * matches but other scopes do, the caller will see fewer hits than `topK`.\n   */\n  public async similar<T = any>(\n    vector: number[],\n    options: CacheSimilarOptions,\n  ): Promise<CacheSimilarHit<T>[]> {\n    const hits = await this.source.similar<T>(vector, options);\n    const parsedPrefix = this.source.parseKey(this.prefix);\n\n    return hits.filter(\n      (hit) => hit.key === parsedPrefix || hit.key.startsWith(parsedPrefix + \".\"),\n    );\n  }\n\n  /**\n   * Build the source-side key by prepending the scope prefix. Object keys\n   * are normalized via {@link parseCacheKey} first so they compose with the\n   * prefix as plain dot-strings.\n   */\n  protected scopedKey(key: CacheKey): string {\n    const keyString = typeof key === \"string\" ? key : parseCacheKey(key);\n\n    if (!keyString) {\n      return this.prefix;\n    }\n\n    return `${this.prefix}.${keyString}`;\n  }\n\n  /**\n   * Coerce the polymorphic 3rd `set` argument into a {@link CacheSetOptions}\n   * with scope defaults filled in. Per-call values always win; tags merge\n   * additively. `expiresAt` is preserved without injecting the scope's `ttl`\n   * default (absolute deadlines override relative ones).\n   */\n  protected mergeSetOptions(\n    input?: CacheTtl | CacheSetOptions,\n  ): CacheSetOptions | undefined {\n    const options = normalizeToOptions(input);\n    const ttl =\n      options.ttl ?? (options.expiresAt === undefined ? this.defaults.ttl : undefined);\n    const tags = mergeTagSets(this.defaults.tags, options.tags);\n\n    const merged: CacheSetOptions = { ...options };\n\n    if (ttl !== undefined) {\n      merged.ttl = ttl;\n    }\n\n    if (tags !== undefined) {\n      merged.tags = tags;\n    }\n\n    return merged;\n  }\n\n  /**\n   * Same merge as {@link mergeSetOptions} but for the `remember()` shape\n   * ({@link RememberOptions} — no `expiresAt`).\n   */\n  protected mergeRememberOptions(\n    input: CacheTtl | RememberOptions,\n  ): CacheTtl | RememberOptions {\n    const options = normalizeToRememberOptions(input);\n    const ttl = options.ttl ?? this.defaults.ttl;\n    const tags = mergeTagSets(this.defaults.tags, options.tags);\n\n    const merged: RememberOptions = { ...options };\n\n    if (ttl !== undefined) {\n      merged.ttl = ttl;\n    }\n\n    if (tags !== undefined) {\n      merged.tags = tags;\n    }\n\n    return merged;\n  }\n\n  /**\n   * Convert the scope's default `ttl` (which may be a duration string) into\n   * seconds, for the few methods (`setMany`, `setNX`) that accept only a\n   * numeric ttl.\n   */\n  protected scopeTtlSeconds(): number | undefined {\n    if (this.defaults.ttl === undefined) {\n      return undefined;\n    }\n\n    return parseTtl(this.defaults.ttl);\n  }\n}\n"],"mappings":"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"}

package/esm/tagged-cache.d.mts

@@ -36,6 +36,22 @@ declare class TaggedCache implements TaggedCacheDriver {
    * stable consumer API.
    */
   storeTagRelationship(key: CacheKey): Promise<void>;
+  /**
+   * Upper bound on member-existence checks per tagged write, so pruning stays
+   * O(1) per write no matter how large an index grows.
+   */
+  protected static readonly PRUNE_CHECKS_PER_WRITE = 20;
+  /**
+   * Drop index members whose entry no longer exists (expired, evicted, or
+   * removed outside a tagged handle). Checks a random window of at most
+   * {@link PRUNE_CHECKS_PER_WRITE} members, so a long-lived index converges
+   * to its live members without any write paying for a full scan.
+   */
+  protected pruneTag(tagKey: string, justWritten: string): Promise<void>;
+  protected addToTag(tagKey: string, members: string[]): Promise<void>;
+  protected membersOf(tagKey: string): Promise<string[]>;
+  protected removeFromTag(tagKey: string, members: string[]): Promise<void>;
+  protected legacyMembers(tagKey: string): Promise<string[]>;
   /**
    * The form a key takes inside a tag index: normalized but un-prefixed.
    *
@@ -67,6 +83,10 @@ declare class TaggedCache implements TaggedCacheDriver {
    * Invalidate (clear) all keys associated with the current tags
    */
   invalidate(): Promise<void>;
+  /**
+   * Remove `indexedKey` from every tag of this handle.
+   */
+  protected detachFromTags(indexedKey: string): Promise<void>;
   /**
    * Flush all keys associated with the current tags
    * @deprecated Use invalidate() instead for better semantics

package/esm/tagged-cache.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"tagged-cache.d.mts","names":[],"sources":["../../../../../../cache/src/tagged-cache.ts"],"mappings":";;;;;AAaA;;cAAa,WAAA,YAAuB,iBAAA;EAShB;;;EAAA,UALR,SAAA;EAsC6B;;;EAAA,UAjC7B,MAAA,EAAQ,WAAA;EAgEe;;;cA3Dd,IAAA,YAAgB,MAAA,EAAQ,WAAA;EAiFxC;;;EAAA,UAzEO,MAAA,CAAO,GAAA;EA2FmB;;;EAAA,UApFpB,cAAA,CAAe,GAAA,EAAK,QAAA,GAAW,OAAA;EA+Hd;;;;;;;;;EAlHpB,oBAAA,CAAqB,GAAA,EAAK,QAAA,GAAW,OAAA;EAmLtB;;;;;;;;;;EAAA,UA3JlB,UAAA,CAAW,GAAA,EAAK,QAAA;EApDiB;;;EAAA,UA2D3B,aAAA,IAAiB,OAAA,CAAQ,GAAA;EA5CzB;;;EA8DH,GAAA,CACX,GAAA,EAAK,QAAA,EACL,KAAA,OACA,YAAA,GAAe,QAAA,GAAW,eAAA,GACzB,OAAA;EArDU;;;EAgEA,GAAA,CAAI,GAAA,EAAK,QAAA,GAAW,OAAA;EAxCvB;;;EA+CG,MAAA,CAAO,GAAA,EAAK,QAAA,GAAW,OAAA;EAxCH;;;EA0DpB,UAAA,IAAc,OAAA;EAvCzB;;;;EAyDW,KAAA,IAAS,OAAA;EAtDnB;;;EA6DU,GAAA,CAAI,GAAA,EAAK,QAAA,GAAW,OAAA;EAlDA;;;EAyDpB,QAAA,CACX,GAAA,EAAK,QAAA,EACL,GAAA,UACA,QAAA,QAAgB,OAAA,QACf,OAAA;EAtDiC;;;EAsEvB,IAAA,CAAK,GAAA,EAAK,QAAA,GAAW,OAAA;EAlCZ;;;EA+CT,OAAA,CAAQ,GAAA,EAAK,QAAA,EAAU,KAAA,QAAa,OAAA;EAxChB;;;EA+CpB,SAAA,CAAU,GAAA,EAAK,QAAA,EAAU,KAAA,YAAoB,OAAA;EAtCxD;;;EAwDW,SAAA,CAAU,GAAA,EAAK,QAAA,EAAU,KAAA,YAAoB,OAAA;AAAA"}
+{"version":3,"file":"tagged-cache.d.mts","names":[],"sources":["../../../../../../cache/src/tagged-cache.ts"],"mappings":";;;;;AAaA;;cAAa,WAAA,YAAuB,iBAAA;EAShB;;;EAAA,UALR,SAAA;EAsC6B;;;EAAA,UAjC7B,MAAA,EAAQ,WAAA;EAqGyB;;;cAhGxB,IAAA,YAAgB,MAAA,EAAQ,WAAA;EAqJF;;;EAAA,UA7I/B,MAAA,CAAO,GAAA;EA+JW;;;EAAA,UAxJZ,cAAA,CAAe,GAAA,EAAK,QAAA,GAAW,OAAA;EA2KtB;;;;;;;;;EA9JZ,oBAAA,CAAqB,GAAA,EAAK,QAAA,GAAW,OAAA;EA2O3B;;;;EAAA,0BA5NG,sBAAA;EAkPgC;;;;;;EAAA,UA1O1C,QAAA,CAAS,MAAA,UAAgB,WAAA,WAAsB,OAAA;EAAA,UAgC/C,QAAA,CAAS,MAAA,UAAgB,OAAA,aAAoB,OAAA;EAAA,UAa7C,SAAA,CAAU,MAAA,WAAiB,OAAA;EAAA,UAQ3B,aAAA,CAAc,MAAA,UAAgB,OAAA,aAAoB,OAAA;EAAA,UAoBlD,aAAA,CAAc,MAAA,WAAiB,OAAA;EA5H5B;;;;;;;;;;EAAA,UA8IT,UAAA,CAAW,GAAA,EAAK,QAAA;EAlHQ;;;EAAA,UAyHlB,aAAA,IAAiB,OAAA,CAAQ,GAAA;EAlGhB;;;EAiHZ,GAAA,CACX,GAAA,EAAK,QAAA,EACL,KAAA,OACA,YAAA,GAAe,QAAA,GAAW,eAAA,GACzB,OAAA;EArFsB;;;EAgGZ,GAAA,CAAI,GAAA,EAAK,QAAA,GAAW,OAAA;EAnFP;;;EA0Fb,MAAA,CAAO,GAAA,EAAK,QAAA,GAAW,OAAA;EAlFU;;;EA+FjC,UAAA,IAAc,OAAA;EA3EoB;;;EAAA,UA+F/B,cAAA,CAAe,UAAA,WAAqB,OAAA;EAtEpC;;;;EAgFH,KAAA,IAAS,OAAA;EAhEpB;;;EAuEW,GAAA,CAAI,GAAA,EAAK,QAAA,GAAW,OAAA;EArE/B;;;EA4EW,QAAA,CACX,GAAA,EAAK,QAAA,EACL,GAAA,UACA,QAAA,QAAgB,OAAA,QACf,OAAA;EApEc;;;EAoFJ,IAAA,CAAK,GAAA,EAAK,QAAA,GAAW,OAAA;EA7Ed;;;EA4FP,OAAA,CAAQ,GAAA,EAAK,QAAA,EAAU,KAAA,QAAa,OAAA;EA3DjC;;;EAkEH,SAAA,CAAU,GAAA,EAAK,QAAA,EAAU,KAAA,YAAoB,OAAA;EAxDpC;;;EAqET,SAAA,CAAU,GAAA,EAAK,QAAA,EAAU,KAAA,YAAoB,OAAA;AAAA"}

package/esm/tagged-cache.mjs

@@ -5,7 +5,7 @@ import { parseCacheKey } from "./utils.mjs";
 * Tagged Cache Wrapper
 * Wraps a cache driver to automatically manage tag relationships
 */
-var TaggedCache = class {
+var TaggedCache = class TaggedCache {
 	/**
 	* Constructor
 	*/
@@ -38,13 +38,52 @@ var TaggedCache = class {
 		const indexedKey = this.indexedKey(key);
 		for (const tag of this.cacheTags) {
 			const tagKey = this.tagKey(tag);
-			const keys = await this.driver.get(tagKey) || [];
-			if (!keys.includes(indexedKey)) {
-				keys.push(indexedKey);
-				await this.driver.set(tagKey, keys, Infinity);
-			}
+			await this.addToTag(tagKey, [indexedKey]);
+			await this.pruneTag(tagKey, indexedKey);
 		}
 	}
+	static {
+		this.PRUNE_CHECKS_PER_WRITE = 20;
+	}
+	/**
+	* Drop index members whose entry no longer exists (expired, evicted, or
+	* removed outside a tagged handle). Checks a random window of at most
+	* {@link PRUNE_CHECKS_PER_WRITE} members, so a long-lived index converges
+	* to its live members without any write paying for a full scan.
+	*/
+	async pruneTag(tagKey, justWritten) {
+		const members = (await this.membersOf(tagKey)).filter((member) => member !== justWritten);
+		if (members.length === 0) return;
+		const limit = TaggedCache.PRUNE_CHECKS_PER_WRITE;
+		const start = members.length > limit ? Math.floor(Math.random() * members.length) : 0;
+		const window = Array.from({ length: Math.min(limit, members.length) }, (_, index) => members[(start + index) % members.length]);
+		const missing = [];
+		for (const member of window) if (!await this.driver.has(member)) missing.push(member);
+		if (missing.length > 0) await this.removeFromTag(tagKey, missing);
+	}
+	async addToTag(tagKey, members) {
+		if (typeof this.driver.tagAdd === "function") return this.driver.tagAdd(tagKey, members);
+		const current = await this.legacyMembers(tagKey);
+		const merged = [...new Set([...current, ...members])];
+		if (merged.length !== current.length) await this.driver.set(tagKey, merged, Infinity);
+	}
+	async membersOf(tagKey) {
+		if (typeof this.driver.tagMembers === "function") return this.driver.tagMembers(tagKey);
+		return this.legacyMembers(tagKey);
+	}
+	async removeFromTag(tagKey, members) {
+		if (typeof this.driver.tagRemove === "function") return this.driver.tagRemove(tagKey, members);
+		const dropped = new Set(members);
+		const current = await this.legacyMembers(tagKey);
+		const kept = current.filter((member) => !dropped.has(member));
+		if (kept.length === current.length) return;
+		if (kept.length === 0) await this.driver.remove(tagKey);
+		else await this.driver.set(tagKey, kept, Infinity);
+	}
+	async legacyMembers(tagKey) {
+		const value = await this.driver.get(tagKey);
+		return Array.isArray(value) ? value.filter((member) => typeof member === "string") : [];
+	}
 	/**
 	* The form a key takes inside a tag index: normalized but un-prefixed.
 	*
@@ -63,11 +102,7 @@ var TaggedCache = class {
 	*/
 	async getTaggedKeys() {
 		const allKeys = /* @__PURE__ */ new Set();
-		for (const tag of this.cacheTags) {
-			const tagKey = this.tagKey(tag);
-			const keys = await this.driver.get(tagKey) || [];
-			for (const key of keys) allKeys.add(key);
-		}
+		for (const tag of this.cacheTags) for (const key of await this.membersOf(this.tagKey(tag))) allKeys.add(key);
 		return allKeys;
 	}
 	/**
@@ -90,19 +125,24 @@ var TaggedCache = class {
 	async remove(key) {
 		const indexedKey = this.indexedKey(key);
 		await this.driver.remove(key);
+		await this.detachFromTags(indexedKey);
+	}
+	/**
+	* Invalidate (clear) all keys associated with the current tags
+	*/
+	async invalidate() {
 		for (const tag of this.cacheTags) {
 			const tagKey = this.tagKey(tag);
-			const updatedKeys = (await this.driver.get(tagKey) || []).filter((k) => k !== indexedKey);
-			await this.driver.set(tagKey, updatedKeys, Infinity);
+			const members = await this.membersOf(tagKey);
+			for (const member of members) await this.driver.remove(member);
+			await this.removeFromTag(tagKey, members);
 		}
 	}
 	/**
-	* Invalidate (clear) all keys associated with the current tags
+	* Remove `indexedKey` from every tag of this handle.
 	*/
-	async invalidate() {
-		const keysToRemove = await this.getTaggedKeys();
-		for (const key of keysToRemove) await this.driver.remove(key);
-		for (const tag of this.cacheTags) await this.driver.remove(this.tagKey(tag));
+	async detachFromTags(indexedKey) {
+		for (const tag of this.cacheTags) await this.removeFromTag(this.tagKey(tag), [indexedKey]);
 	}
 	/**
 	* Flush all keys associated with the current tags
@@ -131,8 +171,8 @@ var TaggedCache = class {
 	* {@inheritdoc}
 	*/
 	async pull(key) {
-		const value = await this.get(key);
-		if (value !== null) await this.remove(key);
+		const value = await this.driver.pull(key);
+		if (value !== null) await this.detachFromTags(this.indexedKey(key));
 		return value;
 	}
 	/**
@@ -145,10 +185,8 @@ var TaggedCache = class {
 	* {@inheritdoc}
 	*/
 	async increment(key, value = 1) {
-		const current = await this.get(key) || 0;
-		if (typeof current !== "number") throw new Error(`Cannot increment non-numeric value for key: ${this.driver.parseKey(key)}`);
-		const newValue = current + value;
-		await this.set(key, newValue);
+		const newValue = await this.driver.increment(key, value);
+		await this.storeTaggedKey(key);
 		return newValue;
 	}
 	/**

package/esm/tagged-cache.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"tagged-cache.mjs","names":[],"sources":["../../../../../../cache/src/tagged-cache.ts"],"sourcesContent":["import type {\r\n  CacheDriver,\r\n  CacheKey,\r\n  CacheSetOptions,\r\n  CacheTtl,\r\n  TaggedCacheDriver,\r\n} from \"./types\";\r\nimport { parseCacheKey } from \"./utils\";\r\n\r\n/**\r\n * Tagged Cache Wrapper\r\n * Wraps a cache driver to automatically manage tag relationships\r\n */\r\nexport class TaggedCache implements TaggedCacheDriver {\r\n  /**\r\n   * The tags associated with this tagged cache instance\r\n   */\r\n  protected cacheTags: string[];\r\n\r\n  /**\r\n   * The underlying cache driver\r\n   */\r\n  protected driver: CacheDriver<any, any>;\r\n\r\n  /**\r\n   * Constructor\r\n   */\r\n  public constructor(tags: string[], driver: CacheDriver<any, any>) {\r\n    this.cacheTags = tags;\r\n    this.driver = driver;\r\n  }\r\n\r\n  /**\r\n   * Get the tag key prefix for storing tag-key relationships\r\n   */\r\n  protected tagKey(tag: string): string {\r\n    return `cache:tags:${tag}`;\r\n  }\r\n\r\n  /**\r\n   * Store tag-key relationship\r\n   */\r\n  protected async storeTaggedKey(key: CacheKey): Promise<void> {\r\n    await this.storeTagRelationship(key);\r\n  }\r\n\r\n  /**\r\n   * Public alias of the tag-index writer. Called by `BaseCacheDriver.applyTags`\r\n   * when tags are passed inline through `CacheSetOptions.tags`.\r\n   *\r\n   * Takes the caller's key, never the driver-parsed one — see {@link indexedKey}.\r\n   *\r\n   * @internal — public for cross-class use within this package; not part of the\r\n   * stable consumer API.\r\n   */\r\n  public async storeTagRelationship(key: CacheKey): Promise<void> {\r\n    const indexedKey = this.indexedKey(key);\r\n\r\n    for (const tag of this.cacheTags) {\r\n      const tagKey = this.tagKey(tag);\r\n      const keys = (await this.driver.get(tagKey)) || [];\r\n\r\n      if (!keys.includes(indexedKey)) {\r\n        keys.push(indexedKey);\r\n        await this.driver.set(tagKey, keys, Infinity);\r\n      }\r\n    }\r\n  }\r\n\r\n  /**\r\n   * The form a key takes inside a tag index: normalized but un-prefixed.\r\n   *\r\n   * The index is read back and deleted through `driver.remove(key)`, which\r\n   * applies `globalPrefix` itself — so the index must hold the key *before*\r\n   * the prefix, or invalidation would prefix it twice and delete nothing.\r\n   * With a function prefix, the current prefix is re-applied at invalidation\r\n   * time; the tag index key is resolved under that same prefix, so the two\r\n   * agree as long as the prefix is stable for a given request/tenant.\r\n   */\r\n  protected indexedKey(key: CacheKey): string {\r\n    return parseCacheKey(key);\r\n  }\r\n\r\n  /**\r\n   * Get all keys associated with tags\r\n   */\r\n  protected async getTaggedKeys(): Promise<Set<string>> {\r\n    const allKeys = new Set<string>();\r\n\r\n    for (const tag of this.cacheTags) {\r\n      const tagKey = this.tagKey(tag);\r\n      const keys = (await this.driver.get(tagKey)) || [];\r\n\r\n      for (const key of keys) {\r\n        allKeys.add(key);\r\n      }\r\n    }\r\n\r\n    return allKeys;\r\n  }\r\n\r\n  /**\r\n   * {@inheritdoc}\r\n   */\r\n  public async set(\r\n    key: CacheKey,\r\n    value: any,\r\n    ttlOrOptions?: CacheTtl | CacheSetOptions,\r\n  ): Promise<any> {\r\n    await this.driver.set(key, value, ttlOrOptions);\r\n\r\n    await this.storeTaggedKey(key);\r\n\r\n    return value;\r\n  }\r\n\r\n  /**\r\n   * {@inheritdoc}\r\n   */\r\n  public async get(key: CacheKey): Promise<any | null> {\r\n    return this.driver.get(key);\r\n  }\r\n\r\n  /**\r\n   * {@inheritdoc}\r\n   */\r\n  public async remove(key: CacheKey): Promise<void> {\r\n    const indexedKey = this.indexedKey(key);\r\n\r\n    // Remove the value\r\n    await this.driver.remove(key);\r\n\r\n    // Remove from all tag relationships\r\n    for (const tag of this.cacheTags) {\r\n      const tagKey = this.tagKey(tag);\r\n      const keys = (await this.driver.get(tagKey)) || [];\r\n      const updatedKeys = keys.filter((k: string) => k !== indexedKey);\r\n      await this.driver.set(tagKey, updatedKeys, Infinity);\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Invalidate (clear) all keys associated with the current tags\r\n   */\r\n  public async invalidate(): Promise<void> {\r\n    const keysToRemove = await this.getTaggedKeys();\r\n\r\n    // Remove all tagged keys — indexed un-prefixed, so `remove()` prefixes once\r\n    for (const key of keysToRemove) {\r\n      await this.driver.remove(key);\r\n    }\r\n\r\n    // Clear tag relationship keys\r\n    for (const tag of this.cacheTags) {\r\n      await this.driver.remove(this.tagKey(tag));\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Flush all keys associated with the current tags\r\n   * @deprecated Use invalidate() instead for better semantics\r\n   */\r\n  public async flush(): Promise<void> {\r\n    return this.invalidate();\r\n  }\r\n\r\n  /**\r\n   * {@inheritdoc}\r\n   */\r\n  public async has(key: CacheKey): Promise<boolean> {\r\n    return this.driver.has(key);\r\n  }\r\n\r\n  /**\r\n   * {@inheritdoc}\r\n   */\r\n  public async remember(\r\n    key: CacheKey,\r\n    ttl: number,\r\n    callback: () => Promise<any>,\r\n  ): Promise<any> {\r\n    const value = await this.get(key);\r\n\r\n    if (value !== null) {\r\n      return value;\r\n    }\r\n\r\n    const result = await callback();\r\n    await this.set(key, result, ttl);\r\n\r\n    return result;\r\n  }\r\n\r\n  /**\r\n   * {@inheritdoc}\r\n   */\r\n  public async pull(key: CacheKey): Promise<any | null> {\r\n    const value = await this.get(key);\r\n\r\n    if (value !== null) {\r\n      await this.remove(key);\r\n    }\r\n\r\n    return value;\r\n  }\r\n\r\n  /**\r\n   * {@inheritdoc}\r\n   */\r\n  public async forever(key: CacheKey, value: any): Promise<any> {\r\n    return this.set(key, value, Infinity);\r\n  }\r\n\r\n  /**\r\n   * {@inheritdoc}\r\n   */\r\n  public async increment(key: CacheKey, value: number = 1): Promise<number> {\r\n    const current = (await this.get(key)) || 0;\r\n\r\n    if (typeof current !== \"number\") {\r\n      throw new Error(\r\n        `Cannot increment non-numeric value for key: ${this.driver.parseKey(key)}`,\r\n      );\r\n    }\r\n\r\n    const newValue = current + value;\r\n    await this.set(key, newValue);\r\n\r\n    return newValue;\r\n  }\r\n\r\n  /**\r\n   * {@inheritdoc}\r\n   */\r\n  public async decrement(key: CacheKey, value: number = 1): Promise<number> {\r\n    return this.increment(key, -value);\r\n  }\r\n}\r\n"],"mappings":"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"}
+{"version":3,"file":"tagged-cache.mjs","names":[],"sources":["../../../../../../cache/src/tagged-cache.ts"],"sourcesContent":["import type {\r\n  CacheDriver,\r\n  CacheKey,\r\n  CacheSetOptions,\r\n  CacheTtl,\r\n  TaggedCacheDriver,\r\n} from \"./types\";\r\nimport { parseCacheKey } from \"./utils\";\r\n\r\n/**\r\n * Tagged Cache Wrapper\r\n * Wraps a cache driver to automatically manage tag relationships\r\n */\r\nexport class TaggedCache implements TaggedCacheDriver {\r\n  /**\r\n   * The tags associated with this tagged cache instance\r\n   */\r\n  protected cacheTags: string[];\r\n\r\n  /**\r\n   * The underlying cache driver\r\n   */\r\n  protected driver: CacheDriver<any, any>;\r\n\r\n  /**\r\n   * Constructor\r\n   */\r\n  public constructor(tags: string[], driver: CacheDriver<any, any>) {\r\n    this.cacheTags = tags;\r\n    this.driver = driver;\r\n  }\r\n\r\n  /**\r\n   * Get the tag key prefix for storing tag-key relationships\r\n   */\r\n  protected tagKey(tag: string): string {\r\n    return `cache:tags:${tag}`;\r\n  }\r\n\r\n  /**\r\n   * Store tag-key relationship\r\n   */\r\n  protected async storeTaggedKey(key: CacheKey): Promise<void> {\r\n    await this.storeTagRelationship(key);\r\n  }\r\n\r\n  /**\r\n   * Public alias of the tag-index writer. Called by `BaseCacheDriver.applyTags`\r\n   * when tags are passed inline through `CacheSetOptions.tags`.\r\n   *\r\n   * Takes the caller's key, never the driver-parsed one — see {@link indexedKey}.\r\n   *\r\n   * @internal — public for cross-class use within this package; not part of the\r\n   * stable consumer API.\r\n   */\r\n  public async storeTagRelationship(key: CacheKey): Promise<void> {\r\n    const indexedKey = this.indexedKey(key);\r\n\r\n    for (const tag of this.cacheTags) {\r\n      const tagKey = this.tagKey(tag);\r\n\r\n      await this.addToTag(tagKey, [indexedKey]);\r\n      await this.pruneTag(tagKey, indexedKey);\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Upper bound on member-existence checks per tagged write, so pruning stays\r\n   * O(1) per write no matter how large an index grows.\r\n   */\r\n  protected static readonly PRUNE_CHECKS_PER_WRITE = 20;\r\n\r\n  /**\r\n   * Drop index members whose entry no longer exists (expired, evicted, or\r\n   * removed outside a tagged handle). Checks a random window of at most\r\n   * {@link PRUNE_CHECKS_PER_WRITE} members, so a long-lived index converges\r\n   * to its live members without any write paying for a full scan.\r\n   */\r\n  protected async pruneTag(tagKey: string, justWritten: string): Promise<void> {\r\n    const members = (await this.membersOf(tagKey)).filter((member) => member !== justWritten);\r\n\r\n    if (members.length === 0) {\r\n      return;\r\n    }\r\n\r\n    const limit = TaggedCache.PRUNE_CHECKS_PER_WRITE;\r\n    const start = members.length > limit ? Math.floor(Math.random() * members.length) : 0;\r\n    const window = Array.from(\r\n      { length: Math.min(limit, members.length) },\r\n      (_, index) => members[(start + index) % members.length]!,\n    );\r\n\r\n    const missing: string[] = [];\r\n\r\n    for (const member of window) {\r\n      if (!(await this.driver.has(member))) {\r\n        missing.push(member);\r\n      }\r\n    }\r\n\r\n    if (missing.length > 0) {\r\n      await this.removeFromTag(tagKey, missing);\r\n    }\r\n  }\r\n\r\n  // ------------------------------------------------------------\r\n  // Tag-index access: the driver's primitives when it has them, else\r\n  // the legacy get/set array (third-party drivers without primitives).\r\n  // ------------------------------------------------------------\r\n\r\n  protected async addToTag(tagKey: string, members: string[]): Promise<void> {\r\n    if (typeof this.driver.tagAdd === \"function\") {\r\n      return this.driver.tagAdd(tagKey, members);\r\n    }\r\n\r\n    const current = await this.legacyMembers(tagKey);\r\n    const merged = [...new Set([...current, ...members])];\r\n\r\n    if (merged.length !== current.length) {\r\n      await this.driver.set(tagKey, merged, Infinity);\r\n    }\r\n  }\r\n\r\n  protected async membersOf(tagKey: string): Promise<string[]> {\r\n    if (typeof this.driver.tagMembers === \"function\") {\r\n      return this.driver.tagMembers(tagKey);\r\n    }\r\n\r\n    return this.legacyMembers(tagKey);\r\n  }\r\n\r\n  protected async removeFromTag(tagKey: string, members: string[]): Promise<void> {\r\n    if (typeof this.driver.tagRemove === \"function\") {\r\n      return this.driver.tagRemove(tagKey, members);\r\n    }\r\n\r\n    const dropped = new Set(members);\r\n    const current = await this.legacyMembers(tagKey);\r\n    const kept = current.filter((member) => !dropped.has(member));\r\n\r\n    if (kept.length === current.length) {\r\n      return;\r\n    }\r\n\r\n    if (kept.length === 0) {\r\n      await this.driver.remove(tagKey);\r\n    } else {\r\n      await this.driver.set(tagKey, kept, Infinity);\r\n    }\r\n  }\r\n\r\n  protected async legacyMembers(tagKey: string): Promise<string[]> {\r\n    const value = await this.driver.get(tagKey);\r\n\r\n    return Array.isArray(value)\r\n      ? value.filter((member): member is string => typeof member === \"string\")\r\n      : [];\r\n  }\r\n\r\n  /**\r\n   * The form a key takes inside a tag index: normalized but un-prefixed.\r\n   *\r\n   * The index is read back and deleted through `driver.remove(key)`, which\r\n   * applies `globalPrefix` itself — so the index must hold the key *before*\r\n   * the prefix, or invalidation would prefix it twice and delete nothing.\r\n   * With a function prefix, the current prefix is re-applied at invalidation\r\n   * time; the tag index key is resolved under that same prefix, so the two\r\n   * agree as long as the prefix is stable for a given request/tenant.\r\n   */\r\n  protected indexedKey(key: CacheKey): string {\r\n    return parseCacheKey(key);\r\n  }\r\n\r\n  /**\r\n   * Get all keys associated with tags\r\n   */\r\n  protected async getTaggedKeys(): Promise<Set<string>> {\r\n    const allKeys = new Set<string>();\r\n\r\n    for (const tag of this.cacheTags) {\r\n      for (const key of await this.membersOf(this.tagKey(tag))) {\r\n        allKeys.add(key);\r\n      }\r\n    }\r\n\r\n    return allKeys;\r\n  }\r\n\r\n  /**\r\n   * {@inheritdoc}\r\n   */\r\n  public async set(\r\n    key: CacheKey,\r\n    value: any,\r\n    ttlOrOptions?: CacheTtl | CacheSetOptions,\r\n  ): Promise<any> {\r\n    await this.driver.set(key, value, ttlOrOptions);\r\n\r\n    await this.storeTaggedKey(key);\r\n\r\n    return value;\r\n  }\r\n\r\n  /**\r\n   * {@inheritdoc}\r\n   */\r\n  public async get(key: CacheKey): Promise<any | null> {\r\n    return this.driver.get(key);\r\n  }\r\n\r\n  /**\r\n   * {@inheritdoc}\r\n   */\r\n  public async remove(key: CacheKey): Promise<void> {\r\n    const indexedKey = this.indexedKey(key);\r\n\r\n    // Remove the value\r\n    await this.driver.remove(key);\r\n\r\n    // Remove from all tag relationships\r\n    await this.detachFromTags(indexedKey);\r\n  }\r\n\r\n  /**\r\n   * Invalidate (clear) all keys associated with the current tags\r\n   */\r\n  public async invalidate(): Promise<void> {\r\n    for (const tag of this.cacheTags) {\r\n      const tagKey = this.tagKey(tag);\r\n      const members = await this.membersOf(tagKey);\r\n\r\n      // Remove the tagged entries — indexed un-prefixed, so `remove()` prefixes once\r\n      for (const member of members) {\r\n        await this.driver.remove(member);\r\n      }\r\n\r\n      // Remove exactly the members read above rather than dropping the whole\r\n      // index: a key tagged concurrently (after the read) keeps its entry in\r\n      // the index, so a later invalidate still reaches it.\r\n      await this.removeFromTag(tagKey, members);\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Remove `indexedKey` from every tag of this handle.\r\n   */\r\n  protected async detachFromTags(indexedKey: string): Promise<void> {\r\n    for (const tag of this.cacheTags) {\r\n      await this.removeFromTag(this.tagKey(tag), [indexedKey]);\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Flush all keys associated with the current tags\r\n   * @deprecated Use invalidate() instead for better semantics\r\n   */\r\n  public async flush(): Promise<void> {\r\n    return this.invalidate();\r\n  }\r\n\r\n  /**\r\n   * {@inheritdoc}\r\n   */\r\n  public async has(key: CacheKey): Promise<boolean> {\r\n    return this.driver.has(key);\r\n  }\r\n\r\n  /**\r\n   * {@inheritdoc}\r\n   */\r\n  public async remember(\r\n    key: CacheKey,\r\n    ttl: number,\r\n    callback: () => Promise<any>,\r\n  ): Promise<any> {\r\n    const value = await this.get(key);\r\n\r\n    if (value !== null) {\r\n      return value;\r\n    }\r\n\r\n    const result = await callback();\r\n    await this.set(key, result, ttl);\r\n\r\n    return result;\r\n  }\r\n\r\n  /**\r\n   * {@inheritdoc}\r\n   */\r\n  public async pull(key: CacheKey): Promise<any | null> {\r\n    // The driver's own `pull` (atomic on redis / pg / in-process drivers)\r\n    // hands the value out once; then the key leaves this handle's tags.\r\n    const value = await this.driver.pull(key);\r\n\r\n    if (value !== null) {\r\n      await this.detachFromTags(this.indexedKey(key));\r\n    }\r\n\r\n    return value;\r\n  }\r\n\r\n  /**\r\n   * {@inheritdoc}\r\n   */\r\n  public async forever(key: CacheKey, value: any): Promise<any> {\r\n    return this.set(key, value, Infinity);\r\n  }\r\n\r\n  /**\r\n   * {@inheritdoc}\r\n   */\r\n  public async increment(key: CacheKey, value: number = 1): Promise<number> {\r\n    // The driver's atomic increment (INCRBY / pg upsert / synchronous\r\n    // in-process), then record the tag relationship.\r\n    const newValue = await this.driver.increment(key, value);\r\n\r\n    await this.storeTaggedKey(key);\r\n\r\n    return newValue;\r\n  }\r\n\r\n  /**\r\n   * {@inheritdoc}\r\n   */\r\n  public async decrement(key: CacheKey, value: number = 1): Promise<number> {\r\n    return this.increment(key, -value);\r\n  }\r\n}\r\n"],"mappings":"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"}

package/esm/tagged-scoped-cache.d.mts

@@ -61,14 +61,18 @@ declare class TaggedScopedCache implements TaggedScopedCacheContract {
    */
   has(key: CacheKey): Promise<boolean>;
   /**
-   * Remove the scoped key. The tag-index entry will eventually be cleaned up
-   * by `invalidate()`; we don't proactively rewrite it here for cost reasons.
+   * Remove the scoped key and take it out of every tag index this handle
+   * writes to (scope tags + handle tags).
    */
   remove(key: CacheKey): Promise<void>;
   /**
-   * Read-and-remove the scoped key.
+   * Read-and-remove the scoped key, then take it out of this handle's tags.
    */
   pull<T = any>(key: CacheKey): Promise<T | null>;
+  /**
+   * Remove the un-prefixed scoped key from every tag index of this handle.
+   */
+  protected detachFromTags(key: CacheKey): Promise<void>;
   /**
    * Permanent write with handle tags applied. Bypasses both the scope's and
    * the caller's TTL (forever means forever) — only tags get injected.

package/esm/tagged-scoped-cache.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"tagged-scoped-cache.d.mts","names":[],"sources":["../../../../../../cache/src/tagged-scoped-cache.ts"],"mappings":";;;;;;AA4CA;;;;;;;;;;;;;;;;;;;;;;;;;;cAAa,iBAAA,YAA6B,yBAAA;EAgHb;;;;;EAAA,mBA1GR,KAAA,EAAO,WAAA;EAyHuB;;;;EAAA,mBAnH9B,UAAA;EAZqB;;;;cAkBrB,KAAA,EAAO,WAAA,EAAa,UAAA;EAZb;;;;EAqBnB,GAAA,CACL,GAAA,EAAK,QAAA,EACL,KAAA,OACA,YAAA,GAAe,QAAA,GAAW,eAAA,GACzB,OAAA;EAboC;;;EAsBhC,GAAA,UAAa,GAAA,EAAK,QAAA,GAAW,OAAA,CAAQ,CAAA;EAX1C;;;EAkBK,GAAA,CAAI,GAAA,EAAK,QAAA,GAAW,OAAA;EAhBxB;;;;EAwBI,MAAA,CAAO,GAAA,EAAK,QAAA,GAAW,OAAA;EAfM;;;EAsB7B,IAAA,UAAc,GAAA,EAAK,QAAA,GAAW,OAAA,CAAQ,CAAA;EAflC;;;;EAuBJ,OAAA,UAAiB,GAAA,EAAK,QAAA,EAAU,KAAA,EAAO,CAAA,GAAI,OAAA,CAAQ,CAAA;EAf5B;;;;;EA2BjB,KAAA,CAAM,GAAA,EAAK,QAAA,EAAU,KAAA,OAAY,GAAA,YAAe,OAAA;EApBhB;;;EAgDtC,QAAA,UACL,GAAA,EAAK,QAAA,EACL,YAAA,EAAc,QAAA,GAAW,eAAA,EACzB,QAAA,QAAgB,OAAA,CAAQ,CAAA,IACvB,OAAA,CAAQ,CAAA;EA5Ca;;;;EAyDjB,SAAA,CAAU,GAAA,EAAK,QAAA,EAAU,KAAA,YAAiB,OAAA;EA7CpC;;;EAoDN,SAAA,CAAU,GAAA,EAAK,QAAA,EAAU,KAAA,YAAiB,OAAA;EApDH;;;;;EA6DjC,UAAA,IAAc,OAAA;EA/BX;;;;;EAAA,UA8CN,cAAA,CAAe,GAAA,EAAK,QAAA;AAAA"}
+{"version":3,"file":"tagged-scoped-cache.d.mts","names":[],"sources":["../../../../../../cache/src/tagged-scoped-cache.ts"],"mappings":";;;;;;AA4CA;;;;;;;;;;;;;;;;;;;;;;;;;;cAAa,iBAAA,YAA6B,yBAAA;EAwIjC;;;;;EAAA,mBAlIY,KAAA,EAAO,WAAA;EAqIvB;;;;EAAA,mBA/HgB,UAAA;EA4JQ;;;;cAtJR,KAAA,EAAO,WAAA,EAAa,UAAA;EAlBC;;;;EA2BjC,GAAA,CACL,GAAA,EAAK,QAAA,EACL,KAAA,OACA,YAAA,GAAe,QAAA,GAAW,eAAA,GACzB,OAAA;EAbuB;;;EAsBnB,GAAA,UAAa,GAAA,EAAK,QAAA,GAAW,OAAA,CAAQ,CAAA;EAZrC;;;EAmBA,GAAA,CAAI,GAAA,EAAK,QAAA,GAAW,OAAA;EAjBC;;;;EAyBf,MAAA,CAAO,GAAA,EAAK,QAAA,GAAW,OAAA;EAfX;;;EAuBZ,IAAA,UAAc,GAAA,EAAK,QAAA,GAAW,OAAA,CAAQ,CAAA;EAhB5C;;;EAAA,UA6BS,cAAA,CAAe,GAAA,EAAK,QAAA,GAAW,OAAA;EArBlC;;;;EAwCN,OAAA,UAAiB,GAAA,EAAK,QAAA,EAAU,KAAA,EAAO,CAAA,GAAI,OAAA,CAAQ,CAAA;EAhCxC;;;;;EA4CL,KAAA,CAAM,GAAA,EAAK,QAAA,EAAU,KAAA,OAAY,GAAA,YAAe,OAAA;EA/BzB;;;EA2D7B,QAAA,UACL,GAAA,EAAK,QAAA,EACL,YAAA,EAAc,QAAA,GAAW,eAAA,EACzB,QAAA,QAAgB,OAAA,CAAQ,CAAA,IACvB,OAAA,CAAQ,CAAA;EA5CI;;;;EAyDR,SAAA,CAAU,GAAA,EAAK,QAAA,EAAU,KAAA,YAAiB,OAAA;EAzDC;;;EAgE3C,SAAA,CAAU,GAAA,EAAK,QAAA,EAAU,KAAA,YAAiB,OAAA;EApD9B;;;;;EA6DN,UAAA,IAAc,OAAA;EAhCpB;;;;;EAAA,UA+CG,cAAA,CAAe,GAAA,EAAK,QAAA;AAAA"}