@nodellmcache/tiered 1.0.0

package/CHANGELOG.md

@@ -0,0 +1,12 @@
+# @nodellmcache/tiered
+
+## 1.0.0
+
+### Minor Changes
+
+- Initial release of `@nodellmcache/tiered`: a `TieredAdapter` that composes several `StorageAdapter`s (fastest first, e.g. memory + Redis) into one. Read-through walks tiers fastest-first and promotes a slower-tier hit back into the faster tiers; writes/deletes/clear go to every tier; expired entries are skipped; `stats()` aggregates across tiers. It is itself a `StorageAdapter`, so it drops into any cache manager.
+
+### Patch Changes
+
+- Updated dependencies [a2633d8]
+  - @nodellmcache/core@1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 NodeLLMCache contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,40 @@
+# @nodellmcache/tiered
+
+Multi-tier storage adapter for [NodeLLMCache](https://github.com/mdmax007/node-llm-cache). Compose several `StorageAdapter`s into one, fastest first, with read-through promotion and write-through. The classic setup is L1 in-process memory plus L2 Redis: microsecond hits when hot, a shared durable tier when not.
+
+## Install
+
+```bash
+npm install @nodellmcache/tiered @nodellmcache/core
+```
+
+## Quick start
+
+```ts
+import { PromptCache } from '@nodellmcache/prompt-cache'
+import { TieredAdapter } from '@nodellmcache/tiered'
+import { MemoryAdapter } from '@nodellmcache/memory'
+import { RedisAdapter } from '@nodellmcache/redis'
+
+const adapter = new TieredAdapter({
+  tiers: [
+    new MemoryAdapter({ maxSize: 64 * 1024 * 1024 }), // L1: fast, local
+    new RedisAdapter({ host: 'localhost', port: 6379 }), // L2: shared, durable
+  ],
+})
+
+const cache = new PromptCache({ adapter })
+```
+
+## Behavior
+
+- **Read-through with promotion** — `get` walks the tiers fastest-first. On a hit in a slower tier, the entry is back-filled into the faster tiers that missed, so the next read is quick.
+- **Write-through** — `set`, `delete`, and `clear` apply to every tier.
+- **Expiry** — expired entries are skipped while walking tiers.
+- **`stats()`** — `entryCount` is the max across tiers (writes are mirrored), `sizeBytes` and `evictions` are summed across tiers that report them.
+
+Tiers are just `StorageAdapter`s, so any combination works (memory + Redis, Redis + Postgres, three tiers, etc.). It is a `StorageAdapter` itself, so it drops into any cache manager.
+
+## License
+
+MIT

package/dist/index.cjs

@@ -0,0 +1,86 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  TieredAdapter: () => TieredAdapter
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/TieredAdapter.ts
+var import_core = require("@nodellmcache/core");
+var TieredAdapter = class {
+  tiers;
+  constructor(options) {
+    if (!options.tiers || options.tiers.length === 0) {
+      throw new import_core.ValidationError("TieredAdapter requires at least one tier");
+    }
+    this.tiers = options.tiers;
+  }
+  async get(key) {
+    for (let i = 0; i < this.tiers.length; i++) {
+      const entry = await this.tiers[i].get(key);
+      if (entry && !import_core.TTLManager.isExpired(entry)) {
+        for (let j = 0; j < i; j++) {
+          await this.tiers[j].set(key, entry);
+        }
+        return entry;
+      }
+    }
+    return null;
+  }
+  async set(key, entry, ttl) {
+    await Promise.all(this.tiers.map((tier) => tier.set(key, entry, ttl)));
+  }
+  async delete(key) {
+    await Promise.all(this.tiers.map((tier) => tier.delete(key)));
+  }
+  async clear() {
+    await Promise.all(this.tiers.map((tier) => tier.clear()));
+  }
+  async has(key) {
+    for (const tier of this.tiers) {
+      if (await tier.has(key)) return true;
+    }
+    return false;
+  }
+  /**
+   * Aggregate stats across tiers. `entryCount` is the max across tiers (the most
+   * complete tier, since writes are mirrored); `sizeBytes` and `evictions` are
+   * summed across the tiers that report them.
+   */
+  async stats() {
+    const all = await Promise.all(this.tiers.map((tier) => tier.stats()));
+    let entryCount = 0;
+    let sizeBytes;
+    let evictions;
+    for (const s of all) {
+      entryCount = Math.max(entryCount, s.entryCount);
+      if (s.sizeBytes !== void 0) sizeBytes = (sizeBytes ?? 0) + s.sizeBytes;
+      if (s.evictions !== void 0) evictions = (evictions ?? 0) + s.evictions;
+    }
+    return { entryCount, sizeBytes, evictions };
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  TieredAdapter
+});
+//# sourceMappingURL=index.cjs.map

package/dist/index.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/index.ts","../src/TieredAdapter.ts"],"sourcesContent":["export { TieredAdapter, type TieredAdapterOptions } from './TieredAdapter.js'\n","import { TTLManager, ValidationError } from '@nodellmcache/core'\nimport type { AdapterStats, CacheEntry, StorageAdapter } from '@nodellmcache/core'\n\nexport interface TieredAdapterOptions<T> {\n  /**\n   * Storage tiers ordered fastest to slowest, e.g. `[memory, redis]`. Reads walk\n   * the tiers in order; writes go to all of them.\n   */\n  tiers: StorageAdapter<T>[]\n}\n\n/**\n * Composes several {@link StorageAdapter}s into one multi-tier cache.\n *\n * - **Read-through with promotion**: `get` checks tiers fastest-first and, on a\n *   hit in a slower tier, back-fills the faster tiers so the next read is quick.\n * - **Write-through**: `set`, `delete`, and `clear` apply to every tier.\n *\n * A typical setup is L1 in-process memory plus L2 Redis: microsecond hits when\n * hot, a shared durable tier when not.\n */\nexport class TieredAdapter<T = unknown> implements StorageAdapter<T> {\n  private readonly tiers: StorageAdapter<T>[]\n\n  constructor(options: TieredAdapterOptions<T>) {\n    if (!options.tiers || options.tiers.length === 0) {\n      throw new ValidationError('TieredAdapter requires at least one tier')\n    }\n    this.tiers = options.tiers\n  }\n\n  async get(key: string): Promise<CacheEntry<T> | null> {\n    for (let i = 0; i < this.tiers.length; i++) {\n      const entry = await this.tiers[i]!.get(key)\n      if (entry && !TTLManager.isExpired(entry)) {\n        // Promote into the faster tiers that missed.\n        for (let j = 0; j < i; j++) {\n          await this.tiers[j]!.set(key, entry)\n        }\n        return entry\n      }\n    }\n    return null\n  }\n\n  async set(key: string, entry: CacheEntry<T>, ttl?: number): Promise<void> {\n    await Promise.all(this.tiers.map((tier) => tier.set(key, entry, ttl)))\n  }\n\n  async delete(key: string): Promise<void> {\n    await Promise.all(this.tiers.map((tier) => tier.delete(key)))\n  }\n\n  async clear(): Promise<void> {\n    await Promise.all(this.tiers.map((tier) => tier.clear()))\n  }\n\n  async has(key: string): Promise<boolean> {\n    for (const tier of this.tiers) {\n      if (await tier.has(key)) return true\n    }\n    return false\n  }\n\n  /**\n   * Aggregate stats across tiers. `entryCount` is the max across tiers (the most\n   * complete tier, since writes are mirrored); `sizeBytes` and `evictions` are\n   * summed across the tiers that report them.\n   */\n  async stats(): Promise<AdapterStats> {\n    const all = await Promise.all(this.tiers.map((tier) => tier.stats()))\n    let entryCount = 0\n    let sizeBytes: number | undefined\n    let evictions: number | undefined\n    for (const s of all) {\n      entryCount = Math.max(entryCount, s.entryCount)\n      if (s.sizeBytes !== undefined) sizeBytes = (sizeBytes ?? 0) + s.sizeBytes\n      if (s.evictions !== undefined) evictions = (evictions ?? 0) + s.evictions\n    }\n    return { entryCount, sizeBytes, evictions }\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;;;ACAA,kBAA4C;AAqBrC,IAAM,gBAAN,MAA8D;AAAA,EAClD;AAAA,EAEjB,YAAY,SAAkC;AAC5C,QAAI,CAAC,QAAQ,SAAS,QAAQ,MAAM,WAAW,GAAG;AAChD,YAAM,IAAI,4BAAgB,0CAA0C;AAAA,IACtE;AACA,SAAK,QAAQ,QAAQ;AAAA,EACvB;AAAA,EAEA,MAAM,IAAI,KAA4C;AACpD,aAAS,IAAI,GAAG,IAAI,KAAK,MAAM,QAAQ,KAAK;AAC1C,YAAM,QAAQ,MAAM,KAAK,MAAM,CAAC,EAAG,IAAI,GAAG;AAC1C,UAAI,SAAS,CAAC,uBAAW,UAAU,KAAK,GAAG;AAEzC,iBAAS,IAAI,GAAG,IAAI,GAAG,KAAK;AAC1B,gBAAM,KAAK,MAAM,CAAC,EAAG,IAAI,KAAK,KAAK;AAAA,QACrC;AACA,eAAO;AAAA,MACT;AAAA,IACF;AACA,WAAO;AAAA,EACT;AAAA,EAEA,MAAM,IAAI,KAAa,OAAsB,KAA6B;AACxE,UAAM,QAAQ,IAAI,KAAK,MAAM,IAAI,CAAC,SAAS,KAAK,IAAI,KAAK,OAAO,GAAG,CAAC,CAAC;AAAA,EACvE;AAAA,EAEA,MAAM,OAAO,KAA4B;AACvC,UAAM,QAAQ,IAAI,KAAK,MAAM,IAAI,CAAC,SAAS,KAAK,OAAO,GAAG,CAAC,CAAC;AAAA,EAC9D;AAAA,EAEA,MAAM,QAAuB;AAC3B,UAAM,QAAQ,IAAI,KAAK,MAAM,IAAI,CAAC,SAAS,KAAK,MAAM,CAAC,CAAC;AAAA,EAC1D;AAAA,EAEA,MAAM,IAAI,KAA+B;AACvC,eAAW,QAAQ,KAAK,OAAO;AAC7B,UAAI,MAAM,KAAK,IAAI,GAAG,EAAG,QAAO;AAAA,IAClC;AACA,WAAO;AAAA,EACT;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAOA,MAAM,QAA+B;AACnC,UAAM,MAAM,MAAM,QAAQ,IAAI,KAAK,MAAM,IAAI,CAAC,SAAS,KAAK,MAAM,CAAC,CAAC;AACpE,QAAI,aAAa;AACjB,QAAI;AACJ,QAAI;AACJ,eAAW,KAAK,KAAK;AACnB,mBAAa,KAAK,IAAI,YAAY,EAAE,UAAU;AAC9C,UAAI,EAAE,cAAc,OAAW,cAAa,aAAa,KAAK,EAAE;AAChE,UAAI,EAAE,cAAc,OAAW,cAAa,aAAa,KAAK,EAAE;AAAA,IAClE;AACA,WAAO,EAAE,YAAY,WAAW,UAAU;AAAA,EAC5C;AACF;","names":[]}

package/dist/index.d.cts

@@ -0,0 +1,36 @@
+import { StorageAdapter, CacheEntry, AdapterStats } from '@nodellmcache/core';
+
+interface TieredAdapterOptions<T> {
+    /**
+     * Storage tiers ordered fastest to slowest, e.g. `[memory, redis]`. Reads walk
+     * the tiers in order; writes go to all of them.
+     */
+    tiers: StorageAdapter<T>[];
+}
+/**
+ * Composes several {@link StorageAdapter}s into one multi-tier cache.
+ *
+ * - **Read-through with promotion**: `get` checks tiers fastest-first and, on a
+ *   hit in a slower tier, back-fills the faster tiers so the next read is quick.
+ * - **Write-through**: `set`, `delete`, and `clear` apply to every tier.
+ *
+ * A typical setup is L1 in-process memory plus L2 Redis: microsecond hits when
+ * hot, a shared durable tier when not.
+ */
+declare class TieredAdapter<T = unknown> implements StorageAdapter<T> {
+    private readonly tiers;
+    constructor(options: TieredAdapterOptions<T>);
+    get(key: string): Promise<CacheEntry<T> | null>;
+    set(key: string, entry: CacheEntry<T>, ttl?: number): Promise<void>;
+    delete(key: string): Promise<void>;
+    clear(): Promise<void>;
+    has(key: string): Promise<boolean>;
+    /**
+     * Aggregate stats across tiers. `entryCount` is the max across tiers (the most
+     * complete tier, since writes are mirrored); `sizeBytes` and `evictions` are
+     * summed across the tiers that report them.
+     */
+    stats(): Promise<AdapterStats>;
+}
+
+export { TieredAdapter, type TieredAdapterOptions };

package/dist/index.d.ts

@@ -0,0 +1,36 @@
+import { StorageAdapter, CacheEntry, AdapterStats } from '@nodellmcache/core';
+
+interface TieredAdapterOptions<T> {
+    /**
+     * Storage tiers ordered fastest to slowest, e.g. `[memory, redis]`. Reads walk
+     * the tiers in order; writes go to all of them.
+     */
+    tiers: StorageAdapter<T>[];
+}
+/**
+ * Composes several {@link StorageAdapter}s into one multi-tier cache.
+ *
+ * - **Read-through with promotion**: `get` checks tiers fastest-first and, on a
+ *   hit in a slower tier, back-fills the faster tiers so the next read is quick.
+ * - **Write-through**: `set`, `delete`, and `clear` apply to every tier.
+ *
+ * A typical setup is L1 in-process memory plus L2 Redis: microsecond hits when
+ * hot, a shared durable tier when not.
+ */
+declare class TieredAdapter<T = unknown> implements StorageAdapter<T> {
+    private readonly tiers;
+    constructor(options: TieredAdapterOptions<T>);
+    get(key: string): Promise<CacheEntry<T> | null>;
+    set(key: string, entry: CacheEntry<T>, ttl?: number): Promise<void>;
+    delete(key: string): Promise<void>;
+    clear(): Promise<void>;
+    has(key: string): Promise<boolean>;
+    /**
+     * Aggregate stats across tiers. `entryCount` is the max across tiers (the most
+     * complete tier, since writes are mirrored); `sizeBytes` and `evictions` are
+     * summed across the tiers that report them.
+     */
+    stats(): Promise<AdapterStats>;
+}
+
+export { TieredAdapter, type TieredAdapterOptions };

package/dist/index.mjs

@@ -0,0 +1,59 @@
+// src/TieredAdapter.ts
+import { TTLManager, ValidationError } from "@nodellmcache/core";
+var TieredAdapter = class {
+  tiers;
+  constructor(options) {
+    if (!options.tiers || options.tiers.length === 0) {
+      throw new ValidationError("TieredAdapter requires at least one tier");
+    }
+    this.tiers = options.tiers;
+  }
+  async get(key) {
+    for (let i = 0; i < this.tiers.length; i++) {
+      const entry = await this.tiers[i].get(key);
+      if (entry && !TTLManager.isExpired(entry)) {
+        for (let j = 0; j < i; j++) {
+          await this.tiers[j].set(key, entry);
+        }
+        return entry;
+      }
+    }
+    return null;
+  }
+  async set(key, entry, ttl) {
+    await Promise.all(this.tiers.map((tier) => tier.set(key, entry, ttl)));
+  }
+  async delete(key) {
+    await Promise.all(this.tiers.map((tier) => tier.delete(key)));
+  }
+  async clear() {
+    await Promise.all(this.tiers.map((tier) => tier.clear()));
+  }
+  async has(key) {
+    for (const tier of this.tiers) {
+      if (await tier.has(key)) return true;
+    }
+    return false;
+  }
+  /**
+   * Aggregate stats across tiers. `entryCount` is the max across tiers (the most
+   * complete tier, since writes are mirrored); `sizeBytes` and `evictions` are
+   * summed across the tiers that report them.
+   */
+  async stats() {
+    const all = await Promise.all(this.tiers.map((tier) => tier.stats()));
+    let entryCount = 0;
+    let sizeBytes;
+    let evictions;
+    for (const s of all) {
+      entryCount = Math.max(entryCount, s.entryCount);
+      if (s.sizeBytes !== void 0) sizeBytes = (sizeBytes ?? 0) + s.sizeBytes;
+      if (s.evictions !== void 0) evictions = (evictions ?? 0) + s.evictions;
+    }
+    return { entryCount, sizeBytes, evictions };
+  }
+};
+export {
+  TieredAdapter
+};
+//# sourceMappingURL=index.mjs.map

package/dist/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/TieredAdapter.ts"],"sourcesContent":["import { TTLManager, ValidationError } from '@nodellmcache/core'\nimport type { AdapterStats, CacheEntry, StorageAdapter } from '@nodellmcache/core'\n\nexport interface TieredAdapterOptions<T> {\n  /**\n   * Storage tiers ordered fastest to slowest, e.g. `[memory, redis]`. Reads walk\n   * the tiers in order; writes go to all of them.\n   */\n  tiers: StorageAdapter<T>[]\n}\n\n/**\n * Composes several {@link StorageAdapter}s into one multi-tier cache.\n *\n * - **Read-through with promotion**: `get` checks tiers fastest-first and, on a\n *   hit in a slower tier, back-fills the faster tiers so the next read is quick.\n * - **Write-through**: `set`, `delete`, and `clear` apply to every tier.\n *\n * A typical setup is L1 in-process memory plus L2 Redis: microsecond hits when\n * hot, a shared durable tier when not.\n */\nexport class TieredAdapter<T = unknown> implements StorageAdapter<T> {\n  private readonly tiers: StorageAdapter<T>[]\n\n  constructor(options: TieredAdapterOptions<T>) {\n    if (!options.tiers || options.tiers.length === 0) {\n      throw new ValidationError('TieredAdapter requires at least one tier')\n    }\n    this.tiers = options.tiers\n  }\n\n  async get(key: string): Promise<CacheEntry<T> | null> {\n    for (let i = 0; i < this.tiers.length; i++) {\n      const entry = await this.tiers[i]!.get(key)\n      if (entry && !TTLManager.isExpired(entry)) {\n        // Promote into the faster tiers that missed.\n        for (let j = 0; j < i; j++) {\n          await this.tiers[j]!.set(key, entry)\n        }\n        return entry\n      }\n    }\n    return null\n  }\n\n  async set(key: string, entry: CacheEntry<T>, ttl?: number): Promise<void> {\n    await Promise.all(this.tiers.map((tier) => tier.set(key, entry, ttl)))\n  }\n\n  async delete(key: string): Promise<void> {\n    await Promise.all(this.tiers.map((tier) => tier.delete(key)))\n  }\n\n  async clear(): Promise<void> {\n    await Promise.all(this.tiers.map((tier) => tier.clear()))\n  }\n\n  async has(key: string): Promise<boolean> {\n    for (const tier of this.tiers) {\n      if (await tier.has(key)) return true\n    }\n    return false\n  }\n\n  /**\n   * Aggregate stats across tiers. `entryCount` is the max across tiers (the most\n   * complete tier, since writes are mirrored); `sizeBytes` and `evictions` are\n   * summed across the tiers that report them.\n   */\n  async stats(): Promise<AdapterStats> {\n    const all = await Promise.all(this.tiers.map((tier) => tier.stats()))\n    let entryCount = 0\n    let sizeBytes: number | undefined\n    let evictions: number | undefined\n    for (const s of all) {\n      entryCount = Math.max(entryCount, s.entryCount)\n      if (s.sizeBytes !== undefined) sizeBytes = (sizeBytes ?? 0) + s.sizeBytes\n      if (s.evictions !== undefined) evictions = (evictions ?? 0) + s.evictions\n    }\n    return { entryCount, sizeBytes, evictions }\n  }\n}\n"],"mappings":";AAAA,SAAS,YAAY,uBAAuB;AAqBrC,IAAM,gBAAN,MAA8D;AAAA,EAClD;AAAA,EAEjB,YAAY,SAAkC;AAC5C,QAAI,CAAC,QAAQ,SAAS,QAAQ,MAAM,WAAW,GAAG;AAChD,YAAM,IAAI,gBAAgB,0CAA0C;AAAA,IACtE;AACA,SAAK,QAAQ,QAAQ;AAAA,EACvB;AAAA,EAEA,MAAM,IAAI,KAA4C;AACpD,aAAS,IAAI,GAAG,IAAI,KAAK,MAAM,QAAQ,KAAK;AAC1C,YAAM,QAAQ,MAAM,KAAK,MAAM,CAAC,EAAG,IAAI,GAAG;AAC1C,UAAI,SAAS,CAAC,WAAW,UAAU,KAAK,GAAG;AAEzC,iBAAS,IAAI,GAAG,IAAI,GAAG,KAAK;AAC1B,gBAAM,KAAK,MAAM,CAAC,EAAG,IAAI,KAAK,KAAK;AAAA,QACrC;AACA,eAAO;AAAA,MACT;AAAA,IACF;AACA,WAAO;AAAA,EACT;AAAA,EAEA,MAAM,IAAI,KAAa,OAAsB,KAA6B;AACxE,UAAM,QAAQ,IAAI,KAAK,MAAM,IAAI,CAAC,SAAS,KAAK,IAAI,KAAK,OAAO,GAAG,CAAC,CAAC;AAAA,EACvE;AAAA,EAEA,MAAM,OAAO,KAA4B;AACvC,UAAM,QAAQ,IAAI,KAAK,MAAM,IAAI,CAAC,SAAS,KAAK,OAAO,GAAG,CAAC,CAAC;AAAA,EAC9D;AAAA,EAEA,MAAM,QAAuB;AAC3B,UAAM,QAAQ,IAAI,KAAK,MAAM,IAAI,CAAC,SAAS,KAAK,MAAM,CAAC,CAAC;AAAA,EAC1D;AAAA,EAEA,MAAM,IAAI,KAA+B;AACvC,eAAW,QAAQ,KAAK,OAAO;AAC7B,UAAI,MAAM,KAAK,IAAI,GAAG,EAAG,QAAO;AAAA,IAClC;AACA,WAAO;AAAA,EACT;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAOA,MAAM,QAA+B;AACnC,UAAM,MAAM,MAAM,QAAQ,IAAI,KAAK,MAAM,IAAI,CAAC,SAAS,KAAK,MAAM,CAAC,CAAC;AACpE,QAAI,aAAa;AACjB,QAAI;AACJ,QAAI;AACJ,eAAW,KAAK,KAAK;AACnB,mBAAa,KAAK,IAAI,YAAY,EAAE,UAAU;AAC9C,UAAI,EAAE,cAAc,OAAW,cAAa,aAAa,KAAK,EAAE;AAChE,UAAI,EAAE,cAAc,OAAW,cAAa,aAAa,KAAK,EAAE;AAAA,IAClE;AACA,WAAO,EAAE,YAAY,WAAW,UAAU;AAAA,EAC5C;AACF;","names":[]}

package/package.json

@@ -0,0 +1,61 @@
+{
+  "name": "@nodellmcache/tiered",
+  "version": "1.0.0",
+  "description": "Multi-tier (L1/L2) storage adapter for NodeLLMCache with read-through and write-through",
+  "keywords": [
+    "llm",
+    "cache",
+    "tiered",
+    "multi-tier",
+    "l1",
+    "l2",
+    "nodejs"
+  ],
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/mdmax007/node-llm-cache.git",
+    "directory": "packages/tiered"
+  },
+  "homepage": "https://github.com/mdmax007/node-llm-cache/tree/main/packages/tiered#readme",
+  "bugs": "https://github.com/mdmax007/node-llm-cache/issues",
+  "type": "module",
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.cjs"
+    }
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "CHANGELOG.md"
+  ],
+  "peerDependencies": {
+    "@nodellmcache/core": "^1.0.0"
+  },
+  "devDependencies": {
+    "@types/node": "^20.0.0",
+    "tsup": "^8.0.0",
+    "typescript": "^5.5.0",
+    "vitest": "^2.0.0",
+    "@vitest/coverage-v8": "^2.0.0",
+    "@nodellmcache/core": "1.0.0",
+    "@nodellmcache/memory": "1.0.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "tsup",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "test:coverage": "vitest run --coverage",
+    "typecheck": "tsc --noEmit",
+    "lint": "echo \"no lint configured\""
+  }
+}