@gravito/stasis 3.1.1 → 3.2.0

package/dist/index.cjs

@@ -1,63 +1,112 @@
-"use strict";
-var __create = Object.create;
 var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __moduleCache = /* @__PURE__ */ new WeakMap;
+var __toCommonJS = (from) => {
+  var entry = __moduleCache.get(from), desc;
+  if (entry)
+    return entry;
+  entry = __defProp({}, "__esModule", { value: true });
+  if (from && typeof from === "object" || typeof from === "function")
+    __getOwnPropNames(from).map((key) => !__hasOwnProp.call(entry, key) && __defProp(entry, key, {
+      get: () => from[key],
+      enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+    }));
+  __moduleCache.set(from, entry);
+  return entry;
+};
 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;
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: (newValue) => all[name] = () => newValue
+    });
 };
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
 // src/index.ts
-var index_exports = {};
-__export(index_exports, {
-  CacheManager: () => CacheManager,
-  CacheRepository: () => CacheRepository,
-  CircuitBreakerStore: () => CircuitBreakerStore,
-  FileStore: () => FileStore,
-  LockTimeoutError: () => LockTimeoutError,
-  MarkovPredictor: () => MarkovPredictor,
-  MemoryCacheProvider: () => MemoryCacheProvider,
-  MemoryStore: () => MemoryStore,
-  NullStore: () => NullStore,
-  OrbitCache: () => OrbitCache,
-  OrbitStasis: () => OrbitStasis,
-  PredictiveStore: () => PredictiveStore,
-  RateLimiter: () => RateLimiter,
-  RedisStore: () => RedisStore,
-  TieredStore: () => TieredStore,
-  default: () => orbitCache,
-  isExpired: () => isExpired,
-  isTaggableStore: () => isTaggableStore,
-  normalizeCacheKey: () => normalizeCacheKey,
+var exports_src = {};
+__export(exports_src, {
+  ttlToExpiresAt: () => ttlToExpiresAt,
   sleep: () => sleep,
-  ttlToExpiresAt: () => ttlToExpiresAt
+  normalizeCacheKey: () => normalizeCacheKey,
+  isTaggableStore: () => isTaggableStore,
+  isExpired: () => isExpired,
+  default: () => orbitCache,
+  TieredStore: () => TieredStore,
+  RedisStore: () => RedisStore,
+  RateLimiter: () => RateLimiter,
+  PredictiveStore: () => PredictiveStore,
+  OrbitStasis: () => OrbitStasis,
+  OrbitCache: () => OrbitCache,
+  NullStore: () => NullStore,
+  MemoryStore: () => MemoryStore,
+  MemoryCacheProvider: () => MemoryCacheProvider,
+  MarkovPredictor: () => MarkovPredictor,
+  LockTimeoutError: () => LockTimeoutError,
+  FileStore: () => FileStore,
+  CircuitBreakerStore: () => CircuitBreakerStore,
+  CacheRepository: () => CacheRepository,
+  CacheManager: () => CacheManager
 });
-module.exports = __toCommonJS(index_exports);
+module.exports = __toCommonJS(exports_src);
+
+// src/cache-events.ts
+function emitCacheEvent(event, payload, events, config) {
+  const { mode, throwOnError, onError } = config;
+  if (mode === "off") {
+    return;
+  }
+  const fn = events?.[event];
+  if (!fn) {
+    return;
+  }
+  const invoke = () => {
+    if (event === "flush") {
+      return fn();
+    }
+    const key = payload.key ?? "";
+    return fn(key);
+  };
+  const reportError = (error) => {
+    try {
+      onError?.(error, event, payload);
+    } catch {}
+  };
+  if (mode === "sync") {
+    try {
+      return Promise.resolve(invoke()).catch((error) => {
+        reportError(error);
+        if (throwOnError) {
+          throw error;
+        }
+      });
+    } catch (error) {
+      reportError(error);
+      if (throwOnError) {
+        throw error;
+      }
+    }
+    return;
+  }
+  queueMicrotask(() => {
+    try {
+      const result = invoke();
+      if (result && typeof result.catch === "function") {
+        result.catch(reportError);
+      }
+    } catch (error) {
+      reportError(error);
+    }
+  });
+}
 
 // src/locks.ts
-var LockTimeoutError = class extends Error {
+class LockTimeoutError extends Error {
   name = "LockTimeoutError";
-};
+}
 function sleep(ms) {
   return new Promise((resolve) => setTimeout(resolve, ms));
 }
@@ -75,8 +124,8 @@ function normalizeCacheKey(key) {
   return key;
 }
 function ttlToExpiresAt(ttl, now = Date.now()) {
-  if (ttl === void 0) {
-    return void 0;
+  if (ttl === undefined) {
+    return;
   }
   if (ttl === null) {
     return null;
@@ -88,42 +137,87 @@ function ttlToExpiresAt(ttl, now = Date.now()) {
     if (ttl <= 0) {
       return now;
     }
-    return now + ttl * 1e3;
+    return now + ttl * 1000;
   }
-  return void 0;
+  return;
 }
 function isExpired(expiresAt, now = Date.now()) {
   if (expiresAt === null) {
     return false;
   }
-  if (expiresAt === void 0) {
+  if (expiresAt === undefined) {
     return false;
   }
   return now >= expiresAt;
 }
 
+// src/tagged-store.ts
+class TaggedStore {
+  store;
+  tags;
+  constructor(store, tags) {
+    this.store = store;
+    this.tags = tags;
+  }
+  tagged(key) {
+    return this.store.tagKey(normalizeCacheKey(key), this.tags);
+  }
+  async get(key) {
+    return this.store.get(this.tagged(key));
+  }
+  async put(key, value, ttl) {
+    const taggedKey = this.tagged(key);
+    await this.store.put(taggedKey, value, ttl);
+    this.store.tagIndexAdd(this.tags, taggedKey);
+  }
+  async add(key, value, ttl) {
+    const taggedKey = this.tagged(key);
+    const ok = await this.store.add(taggedKey, value, ttl);
+    if (ok) {
+      this.store.tagIndexAdd(this.tags, taggedKey);
+    }
+    return ok;
+  }
+  async forget(key) {
+    return this.store.forget(this.tagged(key));
+  }
+  async flush() {
+    return this.store.flushTags(this.tags);
+  }
+  async increment(key, value) {
+    const taggedKey = this.tagged(key);
+    const next = await this.store.increment(taggedKey, value);
+    this.store.tagIndexAdd(this.tags, taggedKey);
+    return next;
+  }
+  async decrement(key, value) {
+    const taggedKey = this.tagged(key);
+    const next = await this.store.decrement(taggedKey, value);
+    this.store.tagIndexAdd(this.tags, taggedKey);
+    return next;
+  }
+  lock(name, seconds) {
+    return this.store.lock ? this.store.lock(this.tagged(name), seconds) : undefined;
+  }
+}
+
 // src/CacheRepository.ts
-var CacheRepository = class _CacheRepository {
+class CacheRepository {
+  store;
+  options;
+  refreshSemaphore = new Map;
+  coalesceSemaphore = new Map;
+  flexibleStats = { refreshCount: 0, refreshFailures: 0, totalTime: 0 };
+  eventEmitterConfig;
   constructor(store, options = {}) {
     this.store = store;
     this.options = options;
+    this.eventEmitterConfig = {
+      mode: options.eventsMode ?? "async",
+      throwOnError: options.throwOnEventError,
+      onError: options.onEventError
+    };
   }
-  refreshSemaphore = /* @__PURE__ */ new Map();
-  coalesceSemaphore = /* @__PURE__ */ new Map();
-  flexibleStats = { refreshCount: 0, refreshFailures: 0, totalTime: 0 };
-  /**
-   * Retrieve statistics about flexible cache operations.
-   *
-   * Useful for monitoring the health and performance of background refreshes.
-   *
-   * @returns Current statistics for background refresh operations.
-   *
-   * @example
-   * ```typescript
-   * const stats = cache.getFlexibleStats();
-   * console.log(`Refreshed ${stats.refreshCount} times`);
-   * ```
-   */
   getFlexibleStats() {
     return {
       refreshCount: this.flexibleStats.refreshCount,
@@ -132,53 +226,7 @@ var CacheRepository = class _CacheRepository {
     };
   }
   emit(event, payload = {}) {
-    const mode = this.options.eventsMode ?? "async";
-    if (mode === "off") {
-      return;
-    }
-    const fn = this.options.events?.[event];
-    if (!fn) {
-      return;
-    }
-    const invoke = () => {
-      if (event === "flush") {
-        return fn();
-      }
-      const key = payload.key ?? "";
-      return fn(key);
-    };
-    const reportError = (error) => {
-      try {
-        this.options.onEventError?.(error, event, payload);
-      } catch {
-      }
-    };
-    if (mode === "sync") {
-      try {
-        return Promise.resolve(invoke()).catch((error) => {
-          reportError(error);
-          if (this.options.throwOnEventError) {
-            throw error;
-          }
-        });
-      } catch (error) {
-        reportError(error);
-        if (this.options.throwOnEventError) {
-          throw error;
-        }
-      }
-      return;
-    }
-    queueMicrotask(() => {
-      try {
-        const result = invoke();
-        if (result && typeof result.catch === "function") {
-          void result.catch(reportError);
-        }
-      } catch (error) {
-        reportError(error);
-      }
-    });
+    return emitCacheEvent(event, payload, this.options.events, this.eventEmitterConfig);
   }
   key(key) {
     const normalized = normalizeCacheKey(key);
@@ -194,23 +242,6 @@ var CacheRepository = class _CacheRepository {
   async forgetMetaKey(metaKey) {
     await this.store.forget(metaKey);
   }
-  /**
-   * Retrieve an item from the cache by its key.
-   *
-   * Fetches the value from the underlying store. If not found, returns the
-   * provided default value or executes the factory function.
-   *
-   * @param key - The unique cache key.
-   * @param defaultValue - A default value or factory function to use if the key is not found.
-   * @returns The cached value, or the default value if not found.
-   * @throws {Error} If the underlying store fails to retrieve the value.
-   *
-   * @example
-   * ```typescript
-   * const user = await cache.get('user:1', { name: 'Guest' });
-   * const settings = await cache.get('settings', () => fetchSettings());
-   * ```
-   */
   async get(key, defaultValue) {
     const fullKey = this.key(key);
     const raw = await this.store.get(fullKey);
@@ -225,7 +256,7 @@ var CacheRepository = class _CacheRepository {
     if (e) {
       await e;
     }
-    if (defaultValue === void 0) {
+    if (defaultValue === undefined) {
       return null;
     }
     if (typeof defaultValue === "function") {
@@ -233,59 +264,12 @@ var CacheRepository = class _CacheRepository {
     }
     return defaultValue;
   }
-  /**
-   * Determine if an item exists in the cache.
-   *
-   * Checks for the presence of a key without necessarily returning its value.
-   *
-   * @param key - The cache key.
-   * @returns True if the item exists, false otherwise.
-   * @throws {Error} If the underlying store fails to check existence.
-   *
-   * @example
-   * ```typescript
-   * if (await cache.has('session:active')) {
-   *   // ...
-   * }
-   * ```
-   */
   async has(key) {
     return await this.get(key) !== null;
   }
-  /**
-   * Determine if an item is missing from the cache.
-   *
-   * Inverse of `has()`, used for cleaner conditional logic.
-   *
-   * @param key - The cache key.
-   * @returns True if the item is missing, false otherwise.
-   * @throws {Error} If the underlying store fails to check existence.
-   *
-   * @example
-   * ```typescript
-   * if (await cache.missing('config:loaded')) {
-   *   await loadConfig();
-   * }
-   * ```
-   */
   async missing(key) {
     return !await this.has(key);
   }
-  /**
-   * Store an item in the cache for a specific duration.
-   *
-   * Persists the value in the underlying store with the given TTL.
-   *
-   * @param key - Unique cache key.
-   * @param value - Value to store.
-   * @param ttl - Expiration duration.
-   * @throws {Error} If the underlying store fails to persist the value or serialization fails.
-   *
-   * @example
-   * ```typescript
-   * await cache.put('token', 'xyz123', 3600);
-   * ```
-   */
   async put(key, value, ttl) {
     const fullKey = this.key(key);
     const data = await this.compress(value);
@@ -295,41 +279,10 @@ var CacheRepository = class _CacheRepository {
       await e;
     }
   }
-  /**
-   * Store an item in the cache for a specific duration.
-   *
-   * Uses the repository's default TTL if none is provided.
-   *
-   * @param key - The unique cache key.
-   * @param value - The value to store.
-   * @param ttl - Optional time-to-live.
-   * @throws {Error} If the underlying store fails to persist the value.
-   *
-   * @example
-   * ```typescript
-   * await cache.set('theme', 'dark');
-   * ```
-   */
   async set(key, value, ttl) {
     const resolved = ttl ?? this.options.defaultTtl;
     await this.put(key, value, resolved);
   }
-  /**
-   * Store an item in the cache only if the key does not already exist.
-   *
-   * Atomic operation to prevent overwriting existing data.
-   *
-   * @param key - The unique cache key.
-   * @param value - The value to store.
-   * @param ttl - Optional time-to-live.
-   * @returns True if the item was added, false otherwise.
-   * @throws {Error} If the underlying store fails the atomic operation.
-   *
-   * @example
-   * ```typescript
-   * const added = await cache.add('lock:process', true, 60);
-   * ```
-   */
   async add(key, value, ttl) {
     const fullKey = this.key(key);
     const resolved = ttl ?? this.options.defaultTtl;
@@ -342,40 +295,9 @@ var CacheRepository = class _CacheRepository {
     }
     return ok;
   }
-  /**
-   * Store an item in the cache indefinitely.
-   *
-   * Sets the TTL to null, indicating the value should not expire automatically.
-   *
-   * @param key - The unique cache key.
-   * @param value - The value to store.
-   * @throws {Error} If the underlying store fails to persist the value.
-   *
-   * @example
-   * ```typescript
-   * await cache.forever('system:id', 'node-01');
-   * ```
-   */
   async forever(key, value) {
     await this.put(key, value, null);
   }
-  /**
-   * Get an item from the cache, or execute the given callback and store the result.
-   *
-   * Implements the "Cache-Aside" pattern, ensuring the callback is only executed
-   * on a cache miss.
-   *
-   * @param key - The unique cache key.
-   * @param ttl - Time-to-live.
-   * @param callback - The callback to execute if the key is not found.
-   * @returns The cached value or the result of the callback.
-   * @throws {Error} If the callback or the underlying store fails.
-   *
-   * @example
-   * ```typescript
-   * const data = await cache.remember('users:all', 300, () => db.users.findMany());
-   * ```
-   */
   async remember(key, ttl, callback) {
     const fullKey = this.key(key);
     if (this.coalesceSemaphore.has(fullKey)) {
@@ -397,38 +319,9 @@ var CacheRepository = class _CacheRepository {
     this.coalesceSemaphore.set(fullKey, promise);
     return promise;
   }
-  /**
-   * Get an item from the cache, or execute the given callback and store the result indefinitely.
-   *
-   * Similar to `remember()`, but the value is stored without an expiration time.
-   *
-   * @param key - The unique cache key.
-   * @param callback - The callback to execute if the key is not found.
-   * @returns The cached value or the result of the callback.
-   * @throws {Error} If the callback or the underlying store fails.
-   *
-   * @example
-   * ```typescript
-   * const config = await cache.rememberForever('app:config', () => loadConfig());
-   * ```
-   */
   async rememberForever(key, callback) {
     return this.remember(key, null, callback);
   }
-  /**
-   * Retrieve multiple items from the cache by their keys.
-   *
-   * Efficiently fetches multiple values, returning a map of keys to values.
-   *
-   * @param keys - An array of unique cache keys.
-   * @returns An object where keys are the original keys and values are the cached values.
-   * @throws {Error} If the underlying store fails to retrieve values.
-   *
-   * @example
-   * ```typescript
-   * const results = await cache.many(['user:1', 'user:2']);
-   * ```
-   */
   async many(keys) {
     const out = {};
     for (const key of keys) {
@@ -436,47 +329,15 @@ var CacheRepository = class _CacheRepository {
     }
     return out;
   }
-  /**
-   * Store multiple items in the cache for a specific duration.
-   *
-   * Persists multiple key-value pairs in a single operation if supported by the store.
-   *
-   * @param values - An object where keys are the unique cache keys and values are the values to store.
-   * @param ttl - Time-to-live.
-   * @throws {Error} If the underlying store fails to persist values.
-   *
-   * @example
-   * ```typescript
-   * await cache.putMany({ 'a': 1, 'b': 2 }, 60);
-   * ```
-   */
   async putMany(values, ttl) {
     await Promise.all(Object.entries(values).map(([k, v]) => this.put(k, v, ttl)));
   }
-  /**
-   * Laravel-like flexible cache (stale-while-revalidate).
-   *
-   * Serves stale content while revalidating the cache in the background. This
-   * minimizes latency for users by avoiding synchronous revalidation.
-   *
-   * @param key - The unique cache key.
-   * @param ttlSeconds - How long the value is considered fresh.
-   * @param staleSeconds - How long the stale value may be served while a refresh happens.
-   * @param callback - The callback to execute to refresh the cache.
-   * @returns The fresh or stale cached value.
-   * @throws {Error} If the callback fails on a cache miss.
-   *
-   * @example
-   * ```typescript
-   * const value = await cache.flexible('stats', 60, 30, () => fetchStats());
-   * ```
-   */
   async flexible(key, ttlSeconds, staleSeconds, callback) {
     const fullKey = this.key(key);
     const metaKey = this.flexibleFreshUntilKey(fullKey);
     const now = Date.now();
-    const ttlMillis = Math.max(0, ttlSeconds) * 1e3;
-    const staleMillis = Math.max(0, staleSeconds) * 1e3;
+    const ttlMillis = Math.max(0, ttlSeconds) * 1000;
+    const staleMillis = Math.max(0, staleSeconds) * 1000;
     const [freshUntil, cachedValue] = await Promise.all([
       this.store.get(metaKey),
       this.store.get(fullKey)
@@ -494,7 +355,7 @@ var CacheRepository = class _CacheRepository {
         if (e2) {
           await e2;
         }
-        void this.refreshFlexible(fullKey, metaKey, ttlSeconds, staleSeconds, callback);
+        this.refreshFlexible(fullKey, metaKey, ttlSeconds, staleSeconds, callback);
         return cachedValue;
       }
     }
@@ -530,18 +391,16 @@ var CacheRepository = class _CacheRepository {
     }
     const startTime = Date.now();
     try {
-      const timeoutMillis = this.options.refreshTimeout ?? 3e4;
+      const timeoutMillis = this.options.refreshTimeout ?? 30000;
       const maxRetries = this.options.maxRetries ?? 0;
       const retryDelay = this.options.retryDelay ?? 50;
       let lastError;
       let value;
-      for (let attempt = 0; attempt <= maxRetries; attempt++) {
+      for (let attempt = 0;attempt <= maxRetries; attempt++) {
         try {
           value = await Promise.race([
             Promise.resolve(callback()),
-            new Promise(
-              (_, reject) => setTimeout(() => reject(new Error("Refresh timeout")), timeoutMillis)
-            )
+            new Promise((_, reject) => setTimeout(() => reject(new Error("Refresh timeout")), timeoutMillis))
           ]);
           break;
         } catch (err) {
@@ -551,13 +410,13 @@ var CacheRepository = class _CacheRepository {
           }
         }
       }
-      if (value === void 0 && lastError) {
+      if (value === undefined && lastError) {
         throw lastError;
       }
       const totalTtl = ttlSeconds + staleSeconds;
       const now = Date.now();
       await this.put(fullKey, value, totalTtl);
-      await this.putMetaKey(metaKey, now + Math.max(0, ttlSeconds) * 1e3, totalTtl);
+      await this.putMetaKey(metaKey, now + Math.max(0, ttlSeconds) * 1000, totalTtl);
       this.flexibleStats.refreshCount++;
       this.flexibleStats.totalTime += Date.now() - startTime;
     } catch {
@@ -566,41 +425,11 @@ var CacheRepository = class _CacheRepository {
       await lock.release();
     }
   }
-  /**
-   * Retrieve an item from the cache and delete it.
-   *
-   * Atomic-like operation to fetch and immediately remove a value, often used
-   * for one-time tokens or flash messages.
-   *
-   * @param key - The unique cache key.
-   * @param defaultValue - A default value to use if the key is not found.
-   * @returns The cached value, or the default value if not found.
-   * @throws {Error} If the underlying store fails to retrieve or forget the value.
-   *
-   * @example
-   * ```typescript
-   * const message = await cache.pull('flash:status');
-   * ```
-   */
   async pull(key, defaultValue) {
     const value = await this.get(key, defaultValue);
     await this.forget(key);
     return value;
   }
-  /**
-   * Remove an item from the cache by its key.
-   *
-   * Deletes the value and any associated metadata from the underlying store.
-   *
-   * @param key - The cache key to remove.
-   * @returns True if the item existed and was removed.
-   * @throws {Error} If the underlying store fails to remove the value.
-   *
-   * @example
-   * ```typescript
-   * const deleted = await cache.forget('user:session');
-   * ```
-   */
   async forget(key) {
     const fullKey = this.key(key);
     const metaKey = this.flexibleFreshUntilKey(fullKey);
@@ -614,36 +443,9 @@ var CacheRepository = class _CacheRepository {
     }
     return ok;
   }
-  /**
-   * Alias for `forget`.
-   *
-   * Provides compatibility with standard `Map`-like or `Storage` APIs.
-   *
-   * @param key - The cache key to remove.
-   * @returns True if the item existed and was removed.
-   * @throws {Error} If the underlying store fails to remove the value.
-   *
-   * @example
-   * ```typescript
-   * await cache.delete('temp:data');
-   * ```
-   */
   async delete(key) {
     return this.forget(key);
   }
-  /**
-   * Remove all items from the cache storage.
-   *
-   * Clears the entire underlying store. Use with caution as this affects all
-   * keys regardless of prefix.
-   *
-   * @throws {Error} If the underlying store fails to flush.
-   *
-   * @example
-   * ```typescript
-   * await cache.flush();
-   * ```
-   */
   async flush() {
     await this.store.flush();
     const e = this.emit("flush");
@@ -651,148 +453,52 @@ var CacheRepository = class _CacheRepository {
       await e;
     }
   }
-  /**
-   * Alias for `flush`.
-   *
-   * Provides compatibility with standard `Map`-like or `Storage` APIs.
-   *
-   * @throws {Error} If the underlying store fails to clear.
-   *
-   * @example
-   * ```typescript
-   * await cache.clear();
-   * ```
-   */
   async clear() {
     return this.flush();
   }
-  /**
-   * Increment the value of a numeric item in the cache.
-   *
-   * Atomically increases the value of a key. If the key does not exist, it is
-   * typically initialized to 0 before incrementing.
-   *
-   * @param key - The cache key.
-   * @param value - The amount to increment by.
-   * @returns The new value.
-   * @throws {Error} If the underlying store fails the atomic increment.
-   *
-   * @example
-   * ```typescript
-   * const count = await cache.increment('page:views');
-   * ```
-   */
   increment(key, value) {
     return this.store.increment(this.key(key), value);
   }
-  /**
-   * Decrement the value of a numeric item in the cache.
-   *
-   * Atomically decreases the value of a key.
-   *
-   * @param key - The cache key.
-   * @param value - The amount to decrement by.
-   * @returns The new value.
-   * @throws {Error} If the underlying store fails the atomic decrement.
-   *
-   * @example
-   * ```typescript
-   * const remaining = await cache.decrement('stock:count');
-   * ```
-   */
   decrement(key, value) {
     return this.store.decrement(this.key(key), value);
   }
-  /**
-   * Get a distributed lock instance for the given name.
-   *
-   * Provides a mechanism for exclusive access to resources across multiple
-   * processes or servers.
-   *
-   * @param name - The lock name.
-   * @param seconds - Optional default duration for the lock in seconds.
-   * @returns A `CacheLock` instance if supported, otherwise undefined.
-   *
-   * @example
-   * ```typescript
-   * const lock = cache.lock('process:heavy', 10);
-   * if (await lock.acquire()) {
-   *   try {
-   *     // ...
-   *   } finally {
-   *     await lock.release();
-   *   }
-   * }
-   * ```
-   */
   lock(name, seconds) {
-    return this.store.lock ? this.store.lock(this.key(name), seconds) : void 0;
-  }
-  /**
-   * Create a new repository instance with the given tags.
-   *
-   * Enables grouping of cache entries for collective operations like flushing
-   * all keys associated with specific tags.
-   *
-   * @param tags - An array of tag names.
-   * @returns A new `CacheRepository` instance that uses the given tags.
-   * @throws {Error} If the underlying store does not support tagging.
-   *
-   * @example
-   * ```typescript
-   * await cache.tags(['users', 'profiles']).put('user:1', data, 3600);
-   * await cache.tags(['users']).flush();
-   * ```
-   */
+    return this.store.lock ? this.store.lock(this.key(name), seconds) : undefined;
+  }
   tags(tags) {
     if (!isTaggableStore(this.store)) {
       throw new Error("This cache store does not support tags.");
     }
-    return new _CacheRepository(new TaggedStore(this.store, tags), this.options);
-  }
-  /**
-   * Retrieve the underlying cache store.
-   *
-   * Provides direct access to the low-level store implementation for advanced
-   * use cases or debugging.
-   *
-   * @returns The low-level cache store instance.
-   *
-   * @example
-   * ```typescript
-   * const store = cache.getStore();
-   * ```
-   */
+    return new CacheRepository(new TaggedStore(this.store, tags), this.options);
+  }
   getStore() {
     return this.store;
   }
-  /**
-   * Compress a value before storage if compression is enabled and thresholds are met.
-   */
   async compress(value) {
     const opts = this.options.compression;
-    if (!opts?.enabled || value === null || value === void 0) {
+    if (!opts?.enabled || value === null || value === undefined) {
       return value;
     }
     const json = JSON.stringify(value);
     if (json.length < (opts.minSize ?? 1024)) {
       return value;
     }
-    const { gzipSync } = await import("zlib");
-    const compressed = gzipSync(Buffer.from(json), { level: opts.level ?? 6 });
+    const { getCompressionAdapter } = await import("@gravito/core");
+    const adapter = getCompressionAdapter();
+    const input = new TextEncoder().encode(json);
+    const compressed = adapter.gzipSync(input, { level: opts.level ?? 6 });
     return {
       __gravito_compressed: true,
-      data: compressed.toString("base64")
+      data: Buffer.from(compressed).toString("base64")
     };
   }
-  /**
-   * Decompress a value after retrieval if it was previously compressed.
-   */
   async decompress(value) {
     if (value !== null && typeof value === "object" && "__gravito_compressed" in value && value.__gravito_compressed === true) {
-      const { gunzipSync } = await import("zlib");
-      const buffer = Buffer.from(value.data, "base64");
-      const decompressed = gunzipSync(buffer).toString();
+      const { getCompressionAdapter } = await import("@gravito/core");
+      const adapter = getCompressionAdapter();
+      const buffer = new Uint8Array(Buffer.from(value.data, "base64"));
+      const decompressedBytes = adapter.gunzipSync(buffer);
+      const decompressed = new TextDecoder().decode(decompressedBytes);
       try {
         return JSON.parse(decompressed);
       } catch {
@@ -801,93 +507,17 @@ var CacheRepository = class _CacheRepository {
     }
     return value;
   }
-};
-var TaggedStore = class {
-  constructor(store, tags) {
-    this.store = store;
-    this.tags = tags;
-  }
-  tagged(key) {
-    return this.store.tagKey(normalizeCacheKey(key), this.tags);
-  }
-  async get(key) {
-    return this.store.get(this.tagged(key));
-  }
-  async put(key, value, ttl) {
-    const taggedKey = this.tagged(key);
-    await this.store.put(taggedKey, value, ttl);
-    this.store.tagIndexAdd(this.tags, taggedKey);
-  }
-  async add(key, value, ttl) {
-    const taggedKey = this.tagged(key);
-    const ok = await this.store.add(taggedKey, value, ttl);
-    if (ok) {
-      this.store.tagIndexAdd(this.tags, taggedKey);
-    }
-    return ok;
-  }
-  async forget(key) {
-    return this.store.forget(this.tagged(key));
-  }
-  async flush() {
-    return this.store.flushTags(this.tags);
-  }
-  async increment(key, value) {
-    const taggedKey = this.tagged(key);
-    const next = await this.store.increment(taggedKey, value);
-    this.store.tagIndexAdd(this.tags, taggedKey);
-    return next;
-  }
-  async decrement(key, value) {
-    const taggedKey = this.tagged(key);
-    const next = await this.store.decrement(taggedKey, value);
-    this.store.tagIndexAdd(this.tags, taggedKey);
-    return next;
-  }
-  lock(name, seconds) {
-    return this.store.lock ? this.store.lock(this.tagged(name), seconds) : void 0;
-  }
-};
+}
 
 // src/RateLimiter.ts
-var RateLimiter = class {
-  /**
-   * Creates a new RateLimiter instance.
-   *
-   * @param store - Cache backend used to persist attempt counts.
-   *
-   * @example
-   * ```typescript
-   * const limiter = new RateLimiter(new MemoryStore());
-   * ```
-   */
+class RateLimiter {
+  store;
   constructor(store) {
     this.store = store;
   }
-  /**
-   * Attempt to consume a slot in the rate limit window.
-   *
-   * This method checks the current attempt count for the given key. If the
-   * count is below the limit, it increments the count and allows the request.
-   * Otherwise, it returns a rejected status with retry information.
-   *
-   * @param key - The unique identifier for the rate limit (e.g., IP address or user ID).
-   * @param maxAttempts - Maximum number of attempts allowed within the decay period.
-   * @param decaySeconds - Duration of the rate limit window in seconds.
-   * @returns A response indicating if the attempt was successful and the remaining capacity.
-   * @throws {Error} If the underlying cache store fails to read or write data.
-   *
-   * @example
-   * ```typescript
-   * const response = await limiter.attempt('api-client:123', 100, 3600);
-   * if (response.allowed) {
-   *   // Proceed with request
-   * }
-   * ```
-   */
   async attempt(key, maxAttempts, decaySeconds) {
     const current = await this.store.get(key);
-    const now = Math.floor(Date.now() / 1e3);
+    const now = Math.floor(Date.now() / 1000);
     if (current === null) {
       await this.store.put(key, 1, decaySeconds);
       return {
@@ -912,18 +542,6 @@ var RateLimiter = class {
       reset: now + decaySeconds
     };
   }
-  /**
-   * Calculate the number of seconds until the rate limit resets.
-   *
-   * This helper method attempts to retrieve the TTL from the store. If the
-   * store does not support TTL inspection, it falls back to the provided
-   * decay period.
-   *
-   * @param key - Unique identifier for the rate limit.
-   * @param decaySeconds - Default decay period to use as a fallback.
-   * @returns Number of seconds until the key expires.
-   * @throws {Error} If the store fails to retrieve TTL metadata.
-   */
   async availableIn(key, decaySeconds) {
     if (typeof this.store.ttl === "function") {
       const remaining = await this.store.ttl(key);
@@ -933,27 +551,9 @@ var RateLimiter = class {
     }
     return decaySeconds;
   }
-  /**
-   * Get detailed information about the current rate limit status without consuming an attempt.
-   *
-   * Useful for returning rate limit headers (e.g., X-RateLimit-Limit) in
-   * middleware or for pre-flight checks.
-   *
-   * @param key - The unique identifier for the rate limit.
-   * @param maxAttempts - Maximum number of attempts allowed.
-   * @param decaySeconds - Duration of the rate limit window in seconds.
-   * @returns Current status including limit, remaining attempts, and reset time.
-   * @throws {Error} If the underlying cache store fails to retrieve data.
-   *
-   * @example
-   * ```typescript
-   * const info = await limiter.getInfo('user:42', 60, 60);
-   * console.log(`Remaining: ${info.remaining}/${info.limit}`);
-   * ```
-   */
   async getInfo(key, maxAttempts, decaySeconds) {
     const current = await this.store.get(key);
-    const now = Math.floor(Date.now() / 1e3);
+    const now = Math.floor(Date.now() / 1000);
     if (current === null) {
       return {
         limit: maxAttempts,
@@ -962,7 +562,7 @@ var RateLimiter = class {
       };
     }
     const remaining = Math.max(0, maxAttempts - current);
-    const retryAfter = remaining === 0 ? await this.availableIn(key, decaySeconds) : void 0;
+    const retryAfter = remaining === 0 ? await this.availableIn(key, decaySeconds) : undefined;
     return {
       limit: maxAttempts,
       remaining,
@@ -970,82 +570,27 @@ var RateLimiter = class {
       retryAfter
     };
   }
-  /**
-   * Reset the rate limit counter for a specific key.
-   *
-   * Use this to manually clear a block, for example after a successful
-   * login or when an administrator manually unblocks a user.
-   *
-   * @param key - The unique identifier to clear.
-   * @throws {Error} If the store fails to delete the key.
-   *
-   * @example
-   * ```typescript
-   * await limiter.clear('login-attempts:user@example.com');
-   * ```
-   */
   async clear(key) {
     await this.store.forget(key);
   }
-};
+}
 
 // src/CacheManager.ts
-var CacheManager = class {
-  /**
-   * Initialize a new CacheManager instance.
-   *
-   * @param storeFactory - Factory function to create low-level store instances by name.
-   * @param config - Configuration manifest for stores and global defaults.
-   * @param events - Optional event handlers for cache lifecycle hooks.
-   * @param eventOptions - Configuration for how events are dispatched and handled.
-   */
+class CacheManager {
+  storeFactory;
+  config;
+  events;
+  eventOptions;
+  stores = new Map;
   constructor(storeFactory, config = {}, events, eventOptions) {
     this.storeFactory = storeFactory;
     this.config = config;
     this.events = events;
     this.eventOptions = eventOptions;
   }
-  /**
-   * Internal registry of initialized cache repositories.
-   */
-  stores = /* @__PURE__ */ new Map();
-  /**
-   * Get a rate limiter instance for a specific store.
-   *
-   * Provides a specialized interface for throttling actions based on cache keys,
-   * leveraging the underlying storage for persistence.
-   *
-   * @param name - Store name (defaults to the configured default store).
-   * @returns A RateLimiter instance bound to the requested store.
-   * @throws {Error} If the requested store cannot be initialized.
-   *
-   * @example
-   * ```typescript
-   * const limiter = cache.limiter('redis');
-   * if (await limiter.tooManyAttempts('login:1', 5)) {
-   *   throw new Error('Too many attempts');
-   * }
-   * ```
-   */
   limiter(name) {
     return new RateLimiter(this.store(name).getStore());
   }
-  /**
-   * Resolve a named cache repository.
-   *
-   * Lazily initializes and caches the repository instance for the given store name.
-   * If no name is provided, it falls back to the default store.
-   *
-   * @param name - Store name to retrieve.
-   * @returns Initialized CacheRepository instance.
-   * @throws {Error} If the store factory fails to create the underlying store or the driver is unsupported.
-   *
-   * @example
-   * ```typescript
-   * const redis = cache.store('redis');
-   * await redis.put('key', 'value', 60);
-   * ```
-   */
   store(name) {
     const storeName = name ?? this.config.default ?? "memory";
     const existing = this.stores.get(storeName);
@@ -1063,381 +608,79 @@ var CacheManager = class {
     this.stores.set(storeName, repo);
     return repo;
   }
-  // Laravel-like proxy methods (default store)
-  /**
-   * Retrieve an item from the default cache store.
-   *
-   * If the key is missing, the provided default value or the result of the
-   * default value closure will be returned.
-   *
-   * @param key - Unique cache key.
-   * @param defaultValue - Fallback value or factory to execute on cache miss.
-   * @returns Cached value or the resolved default.
-   * @throws {Error} If the underlying store driver encounters a read error or connection failure.
-   *
-   * @example
-   * ```typescript
-   * const value = await cache.get('user:1', { name: 'Guest' });
-   * ```
-   */
   get(key, defaultValue) {
     return this.store().get(key, defaultValue);
   }
-  /**
-   * Determine if an item exists in the default cache store.
-   *
-   * @param key - The unique cache key.
-   * @returns True if the key exists and has not expired.
-   * @throws {Error} If the underlying store driver encounters a connection error.
-   *
-   * @example
-   * ```typescript
-   * if (await cache.has('session:active')) {
-   *   // ...
-   * }
-   * ```
-   */
   has(key) {
     return this.store().has(key);
   }
-  /**
-   * Determine if an item is missing from the default cache store.
-   *
-   * @param key - The unique cache key.
-   * @returns True if the key does not exist or has expired.
-   * @throws {Error} If the underlying store driver encounters a connection error.
-   *
-   * @example
-   * ```typescript
-   * if (await cache.missing('config:loaded')) {
-   *   await loadConfig();
-   * }
-   * ```
-   */
   missing(key) {
     return this.store().missing(key);
   }
-  /**
-   * Store an item in the default cache store for a specific duration.
-   *
-   * @param key - The unique cache key.
-   * @param value - The data to be cached.
-   * @param ttl - Expiration time in seconds or a specific Date.
-   * @returns A promise that resolves when the write is complete.
-   * @throws {Error} If the value cannot be serialized or the store is read-only.
-   *
-   * @example
-   * ```typescript
-   * await cache.put('key', 'value', 60); // 60 seconds
-   * ```
-   */
   put(key, value, ttl) {
     return this.store().put(key, value, ttl);
   }
-  /**
-   * Store an item in the default cache store (alias for put).
-   *
-   * @param key - The unique cache key.
-   * @param value - The data to be cached.
-   * @param ttl - Optional expiration time.
-   * @returns A promise that resolves when the write is complete.
-   * @throws {Error} If the underlying store driver encounters a write error.
-   *
-   * @example
-   * ```typescript
-   * await cache.set('theme', 'dark');
-   * ```
-   */
   set(key, value, ttl) {
     return this.store().set(key, value, ttl);
   }
-  /**
-   * Store an item in the default cache store only if it does not already exist.
-   *
-   * @param key - The unique cache key.
-   * @param value - The data to be cached.
-   * @param ttl - Optional expiration time.
-   * @returns True if the item was added, false if it already existed.
-   * @throws {Error} If the underlying store driver encounters a write error.
-   *
-   * @example
-   * ```typescript
-   * const added = await cache.add('lock:process', true, 30);
-   * ```
-   */
   add(key, value, ttl) {
     return this.store().add(key, value, ttl);
   }
-  /**
-   * Store an item in the default cache store indefinitely.
-   *
-   * @param key - The unique cache key.
-   * @param value - The data to be cached.
-   * @returns A promise that resolves when the write is complete.
-   * @throws {Error} If the underlying store driver encounters a write error.
-   *
-   * @example
-   * ```typescript
-   * await cache.forever('system:version', '1.0.0');
-   * ```
-   */
   forever(key, value) {
     return this.store().forever(key, value);
   }
-  /**
-   * Get an item from the cache, or execute the callback and store the result.
-   *
-   * Ensures the value is cached after the first miss. This provides an atomic-like
-   * "get or set" flow to prevent multiple concurrent fetches of the same data.
-   *
-   * @param key - Unique cache key.
-   * @param ttl - Duration to cache the result if a miss occurs.
-   * @param callback - Logic to execute to fetch fresh data.
-   * @returns Cached or freshly fetched value.
-   * @throws {Error} If the callback fails or the store write operation errors.
-   *
-   * @example
-   * ```typescript
-   * const user = await cache.remember('user:1', 60, async () => {
-   *   return await db.findUser(1);
-   * });
-   * ```
-   */
   remember(key, ttl, callback) {
     return this.store().remember(key, ttl, callback);
   }
-  /**
-   * Get an item from the cache, or execute the callback and store the result forever.
-   *
-   * @param key - The unique cache key.
-   * @param callback - The closure to execute to fetch the fresh data.
-   * @returns The cached or freshly fetched value.
-   * @throws {Error} If the callback throws or the store write fails.
-   *
-   * @example
-   * ```typescript
-   * const settings = await cache.rememberForever('global:settings', () => {
-   *   return fetchSettingsFromApi();
-   * });
-   * ```
-   */
   rememberForever(key, callback) {
     return this.store().rememberForever(key, callback);
   }
-  /**
-   * Retrieve multiple items from the default cache store by their keys.
-   *
-   * @param keys - An array of unique cache keys.
-   * @returns An object mapping keys to their cached values (or null if missing).
-   * @throws {Error} If the underlying store driver encounters a read error.
-   *
-   * @example
-   * ```typescript
-   * const values = await cache.many(['key1', 'key2']);
-   * ```
-   */
   many(keys) {
     return this.store().many(keys);
   }
-  /**
-   * Store multiple items in the default cache store for a specific duration.
-   *
-   * @param values - An object mapping keys to the values to be stored.
-   * @param ttl - Expiration time in seconds or a specific Date.
-   * @returns A promise that resolves when all writes are complete.
-   * @throws {Error} If the underlying store driver encounters a write error.
-   *
-   * @example
-   * ```typescript
-   * await cache.putMany({ a: 1, b: 2 }, 60);
-   * ```
-   */
   putMany(values, ttl) {
     return this.store().putMany(values, ttl);
   }
-  /**
-   * Get an item from the cache, allowing stale data while refreshing in background.
-   *
-   * Implements the Stale-While-Revalidate pattern to minimize latency for
-   * frequently accessed but expensive data.
-   *
-   * @param key - The unique cache key.
-   * @param ttlSeconds - How long the value is considered fresh.
-   * @param staleSeconds - How long to serve stale data while refreshing.
-   * @param callback - The closure to execute to refresh the data.
-   * @returns The cached (possibly stale) or freshly fetched value.
-   * @throws {Error} If the callback throws during an initial fetch.
-   *
-   * @example
-   * ```typescript
-   * const data = await cache.flexible('stats', 60, 30, () => fetchStats());
-   * ```
-   */
   flexible(key, ttlSeconds, staleSeconds, callback) {
     return this.store().flexible(key, ttlSeconds, staleSeconds, callback);
   }
-  /**
-   * Retrieve an item from the default cache store and then delete it.
-   *
-   * Useful for one-time notifications or temporary tokens.
-   *
-   * @param key - The unique cache key.
-   * @param defaultValue - Fallback value if the key is missing.
-   * @returns The cached value before deletion, or the default.
-   * @throws {Error} If the underlying store driver encounters a read or delete error.
-   *
-   * @example
-   * ```typescript
-   * const token = await cache.pull('temp_token');
-   * ```
-   */
   pull(key, defaultValue) {
     return this.store().pull(key, defaultValue);
   }
-  /**
-   * Remove an item from the default cache store.
-   *
-   * @param key - The unique cache key.
-   * @returns True if the item was removed, false otherwise.
-   * @throws {Error} If the underlying store driver encounters a delete error.
-   *
-   * @example
-   * ```typescript
-   * await cache.forget('user:1');
-   * ```
-   */
   forget(key) {
     return this.store().forget(key);
   }
-  /**
-   * Remove an item from the default cache store (alias for forget).
-   *
-   * @param key - The unique cache key.
-   * @returns True if the item was removed, false otherwise.
-   * @throws {Error} If the underlying store driver encounters a delete error.
-   *
-   * @example
-   * ```typescript
-   * await cache.delete('old_key');
-   * ```
-   */
   delete(key) {
     return this.store().delete(key);
   }
-  /**
-   * Remove all items from the default cache store.
-   *
-   * @returns A promise that resolves when the flush is complete.
-   * @throws {Error} If the underlying store driver encounters a flush error.
-   *
-   * @example
-   * ```typescript
-   * await cache.flush();
-   * ```
-   */
   flush() {
     return this.store().flush();
   }
-  /**
-   * Clear the entire default cache store (alias for flush).
-   *
-   * @returns A promise that resolves when the clear is complete.
-   * @throws {Error} If the underlying store driver encounters a clear error.
-   *
-   * @example
-   * ```typescript
-   * await cache.clear();
-   * ```
-   */
   clear() {
     return this.store().clear();
   }
-  /**
-   * Increment the value of an integer item in the default cache store.
-   *
-   * @param key - Unique cache key.
-   * @param value - Amount to add.
-   * @returns New value after incrementing.
-   * @throws {Error} If existing value is not a number or the store is read-only.
-   *
-   * @example
-   * ```typescript
-   * const count = await cache.increment('page_views');
-   * ```
-   */
   increment(key, value) {
     return this.store().increment(key, value);
   }
-  /**
-   * Decrement the value of an integer item in the default cache store.
-   *
-   * @param key - Unique cache key.
-   * @param value - Amount to subtract.
-   * @returns New value after decrementing.
-   * @throws {Error} If existing value is not a number or the store is read-only.
-   *
-   * @example
-   * ```typescript
-   * const remaining = await cache.decrement('stock:1');
-   * ```
-   */
   decrement(key, value) {
     return this.store().decrement(key, value);
   }
-  /**
-   * Get a distributed lock instance from the default cache store.
-   *
-   * @param name - The unique name of the lock.
-   * @param seconds - The duration the lock should be held for.
-   * @returns A CacheLock instance.
-   * @throws {Error} If the underlying store does not support locking.
-   *
-   * @example
-   * ```typescript
-   * const lock = cache.lock('process_data', 10);
-   * if (await lock.get()) {
-   *   // ...
-   *   await lock.release();
-   * }
-   * ```
-   */
   lock(name, seconds) {
     return this.store().lock(name, seconds);
   }
-  /**
-   * Access a tagged cache section for grouped operations.
-   *
-   * Tags allow you to clear groups of cache entries simultaneously.
-   * Note: This is only supported by specific drivers like 'memory'.
-   *
-   * @param tags - An array of tag names.
-   * @returns A tagged cache repository instance.
-   * @throws {Error} If the underlying store driver does not support tags.
-   *
-   * @example
-   * ```typescript
-   * await cache.tags(['users', 'profiles']).put('user:1', data, 60);
-   * await cache.tags(['users']).flush(); // Clears all 'users' tagged entries
-   * ```
-   */
   tags(tags) {
     return this.store().tags(tags);
   }
-};
+}
 
 // src/prediction/AccessPredictor.ts
-var MarkovPredictor = class {
-  transitions = /* @__PURE__ */ new Map();
+class MarkovPredictor {
+  transitions = new Map;
   lastKey = null;
   maxNodes;
   maxEdgesPerNode;
-  /**
-   * Initialize a new MarkovPredictor.
-   *
-   * @param options - Limits for internal transition graph to manage memory.
-   */
   constructor(options = {}) {
-    this.maxNodes = options.maxNodes ?? 1e3;
+    this.maxNodes = options.maxNodes ?? 1000;
     this.maxEdgesPerNode = options.maxEdgesPerNode ?? 10;
   }
   record(key) {
@@ -1446,7 +689,7 @@ var MarkovPredictor = class {
         if (this.transitions.size >= this.maxNodes) {
           this.transitions.clear();
         }
-        this.transitions.set(this.lastKey, /* @__PURE__ */ new Map());
+        this.transitions.set(this.lastKey, new Map);
       }
       const edges = this.transitions.get(this.lastKey);
       const count = edges.get(key) ?? 0;
@@ -1478,22 +721,23 @@ var MarkovPredictor = class {
     this.transitions.clear();
     this.lastKey = null;
   }
-};
+}
 
 // src/stores/CircuitBreakerStore.ts
-var CircuitBreakerStore = class {
+class CircuitBreakerStore {
+  primary;
+  state = "CLOSED";
+  failures = 0;
+  lastErrorTime = 0;
+  options;
   constructor(primary, options = {}) {
     this.primary = primary;
     this.options = {
       maxFailures: options.maxFailures ?? 5,
-      resetTimeout: options.resetTimeout ?? 6e4,
+      resetTimeout: options.resetTimeout ?? 60000,
       fallback: options.fallback
     };
   }
-  state = "CLOSED";
-  failures = 0;
-  lastErrorTime = 0;
-  options;
   async execute(operation, fallbackResult = null) {
     if (this.state === "OPEN") {
       if (Date.now() - this.lastErrorTime > this.options.resetTimeout) {
@@ -1526,8 +770,7 @@ var CircuitBreakerStore = class {
     if (this.options.fallback) {
       try {
         return await operation(this.options.fallback);
-      } catch {
-      }
+      } catch {}
     }
     return fallbackResult;
   }
@@ -1555,102 +798,62 @@ var CircuitBreakerStore = class {
   async ttl(key) {
     return this.execute(async (s) => s.ttl ? s.ttl(key) : null);
   }
-  /**
-   * Returns current state for monitoring.
-   *
-   * @returns Current state of the circuit breaker.
-   *
-   * @example
-   * ```typescript
-   * const state = store.getState();
-   * if (state === 'OPEN') {
-   *   console.warn('Primary cache is unavailable');
-   * }
-   * ```
-   */
   getState() {
     return this.state;
   }
-};
+}
 
 // src/stores/FileStore.ts
-var import_node_crypto = require("crypto");
-var import_promises = require("fs/promises");
-var import_node_path = require("path");
-var FileStore = class {
-  /**
-   * Initializes a new instance of the FileStore.
-   *
-   * @param options - Configuration settings for the store.
-   */
+var import_node_path = require("node:path");
+var import_core = require("@gravito/core");
+var import_ffi = require("@gravito/core/ffi");
+class FileStore {
+  options;
+  cleanupTimer = null;
+  runtime = import_core.getRuntimeAdapter();
   constructor(options) {
     this.options = options;
     if (options.enableCleanup !== false) {
-      this.startCleanupDaemon(options.cleanupInterval ?? 6e4);
+      this.startCleanupDaemon(options.cleanupInterval ?? 60000);
     }
   }
-  cleanupTimer = null;
-  /**
-   * Starts the background process for periodic cache maintenance.
-   *
-   * @param interval - Time between cleanup cycles in milliseconds.
-   * @internal
-   */
   startCleanupDaemon(interval) {
     this.cleanupTimer = setInterval(() => {
-      this.cleanExpiredFiles().catch(() => {
-      });
+      this.cleanExpiredFiles().catch(() => {});
     }, interval);
     if (this.cleanupTimer.unref) {
       this.cleanupTimer.unref();
     }
   }
-  /**
-   * Scans the cache directory to remove expired files and enforce capacity limits.
-   *
-   * This method performs a recursive scan of the storage directory. It deletes
-   * files that have passed their expiration time and, if `maxFiles` is configured,
-   * evicts the oldest files to stay within the limit.
-   *
-   * @returns The total number of files removed during this operation.
-   * @throws {Error} If the directory cannot be read or files cannot be deleted.
-   *
-   * @example
-   * ```typescript
-   * const removedCount = await store.cleanExpiredFiles();
-   * console.log(`Cleaned up ${removedCount} files.`);
-   * ```
-   */
   async cleanExpiredFiles() {
     await this.ensureDir();
     let cleaned = 0;
     const validFiles = [];
     const scanDir = async (dir) => {
-      const entries = await (0, import_promises.readdir)(dir, { withFileTypes: true });
+      const entries = await import_core.runtimeReadDir(this.runtime, dir);
       for (const entry of entries) {
-        const fullPath = (0, import_node_path.join)(dir, entry.name);
-        if (entry.isDirectory()) {
+        const fullPath = import_node_path.join(dir, entry.name);
+        if (entry.isDirectory) {
           await scanDir(fullPath);
           try {
-            await (0, import_promises.rm)(fullPath, { recursive: false });
-          } catch {
-          }
-        } else if (entry.isFile()) {
+            const { rmdir } = await import("node:fs/promises");
+            await rmdir(fullPath);
+          } catch {}
+        } else if (entry.isFile) {
           if (!entry.name.endsWith(".json") || entry.name.startsWith(".lock-")) {
             continue;
           }
           try {
-            const raw = await (0, import_promises.readFile)(fullPath, "utf8");
+            const raw = await import_core.runtimeReadText(this.runtime, fullPath);
             const data = JSON.parse(raw);
             if (isExpired(data.expiresAt)) {
-              await (0, import_promises.rm)(fullPath, { force: true });
+              await import_core.runtimeRemoveRecursive(this.runtime, fullPath);
               cleaned++;
             } else if (this.options.maxFiles) {
-              const stats = await (0, import_promises.stat)(fullPath);
+              const stats = await import_core.runtimeStatFull(this.runtime, fullPath);
               validFiles.push({ path: fullPath, mtime: stats.mtimeMs });
             }
-          } catch {
-          }
+          } catch {}
         }
       }
     };
@@ -1658,80 +861,39 @@ var FileStore = class {
     if (this.options.maxFiles && validFiles.length > this.options.maxFiles) {
       validFiles.sort((a, b) => a.mtime - b.mtime);
       const toRemove = validFiles.slice(0, validFiles.length - this.options.maxFiles);
-      await Promise.all(
-        toRemove.map(async (f) => {
-          try {
-            await (0, import_promises.rm)(f.path, { force: true });
-            cleaned++;
-          } catch {
-          }
-        })
-      );
+      await Promise.all(toRemove.map(async (f) => {
+        try {
+          await import_core.runtimeRemoveRecursive(this.runtime, f.path);
+          cleaned++;
+        } catch {}
+      }));
     }
     return cleaned;
   }
-  /**
-   * Stops the cleanup daemon and releases associated resources.
-   *
-   * Should be called when the store is no longer needed to prevent memory leaks
-   * and allow the process to exit gracefully.
-   *
-   * @example
-   * ```typescript
-   * await store.destroy();
-   * ```
-   */
   async destroy() {
     if (this.cleanupTimer) {
       clearInterval(this.cleanupTimer);
       this.cleanupTimer = null;
     }
   }
-  /**
-   * Ensures that the base storage directory exists.
-   *
-   * @throws {Error} If the directory cannot be created due to permissions or path conflicts.
-   * @internal
-   */
   async ensureDir() {
-    await (0, import_promises.mkdir)(this.options.directory, { recursive: true });
-  }
-  /**
-   * Resolves the filesystem path for a given cache key.
-   *
-   * @param key - Normalized cache key.
-   * @returns Absolute path to the JSON file representing the key.
-   * @internal
-   */
-  filePathForKey(key) {
+    await import_core.runtimeMkdir(this.runtime, this.options.directory, { recursive: true });
+  }
+  async filePathForKey(key) {
     const hashed = hashKey(key);
     if (this.options.useSubdirectories) {
       const d1 = hashed.substring(0, 2);
       const d2 = hashed.substring(2, 4);
-      return (0, import_node_path.join)(this.options.directory, d1, d2, `${hashed}.json`);
-    }
-    return (0, import_node_path.join)(this.options.directory, `${hashed}.json`);
-  }
-  /**
-   * Retrieves an item from the cache by its key.
-   *
-   * If the item exists but has expired, it will be deleted and `null` will be returned.
-   *
-   * @param key - The unique identifier for the cache item.
-   * @returns The cached value, or `null` if not found or expired.
-   * @throws {Error} If the file exists but cannot be read or parsed.
-   *
-   * @example
-   * ```typescript
-   * const value = await store.get<string>('my-key');
-   * ```
-   */
+      return import_node_path.join(this.options.directory, d1, d2, `${hashed}.json`);
+    }
+    return import_node_path.join(this.options.directory, `${hashed}.json`);
+  }
   async get(key) {
     const normalized = normalizeCacheKey(key);
     await this.ensureDir();
-    const file = this.filePathForKey(normalized);
+    const file = await this.filePathForKey(normalized);
     try {
-      const raw = await (0, import_promises.readFile)(file, "utf8");
+      const raw = await import_core.runtimeReadText(this.runtime, file);
       const data = JSON.parse(raw);
       if (isExpired(data.expiresAt)) {
         await this.forget(normalized);
@@ -1742,58 +904,28 @@ var FileStore = class {
       return null;
     }
   }
-  /**
-   * Stores an item in the cache with a specified expiration time.
-   *
-   * Uses an atomic write strategy (write to temp file then rename) to ensure
-   * data integrity even if the process crashes during the write operation.
-   *
-   * @param key - The unique identifier for the cache item.
-   * @param value - The data to be cached.
-   * @param ttl - Time-to-live in seconds or a Date object for absolute expiration.
-   * @throws {Error} If the file system is not writable or disk is full.
-   *
-   * @example
-   * ```typescript
-   * await store.put('settings', { theme: 'dark' }, 86400);
-   * ```
-   */
   async put(key, value, ttl) {
     const normalized = normalizeCacheKey(key);
     await this.ensureDir();
     const expiresAt = ttlToExpiresAt(ttl);
-    if (expiresAt !== null && expiresAt !== void 0 && expiresAt <= Date.now()) {
+    if (expiresAt !== null && expiresAt !== undefined && expiresAt <= Date.now()) {
       await this.forget(normalized);
       return;
     }
-    const file = this.filePathForKey(normalized);
+    const file = await this.filePathForKey(normalized);
     if (this.options.useSubdirectories) {
-      await (0, import_promises.mkdir)((0, import_node_path.dirname)(file), { recursive: true });
+      await import_core.runtimeMkdir(this.runtime, import_node_path.dirname(file), { recursive: true });
     }
-    const tempFile = `${file}.tmp.${Date.now()}.${(0, import_node_crypto.randomUUID)()}`;
+    const tempFile = `${file}.tmp.${Date.now()}.${crypto.randomUUID()}`;
     const payload = { expiresAt: expiresAt ?? null, value };
     try {
-      await (0, import_promises.writeFile)(tempFile, JSON.stringify(payload), "utf8");
-      await (0, import_promises.rename)(tempFile, file);
+      await this.runtime.writeFile(tempFile, JSON.stringify(payload));
+      await import_core.runtimeRename(this.runtime, tempFile, file);
     } catch (error) {
-      await (0, import_promises.rm)(tempFile, { force: true }).catch(() => {
-      });
+      await import_core.runtimeRemoveRecursive(this.runtime, tempFile).catch(() => {});
       throw error;
     }
   }
-  /**
-   * Stores an item in the cache only if it does not already exist.
-   *
-   * @param key - The unique identifier for the cache item.
-   * @param value - The data to be cached.
-   * @param ttl - Time-to-live in seconds or a Date object.
-   * @returns `true` if the item was stored, `false` if it already existed.
-   *
-   * @example
-   * ```typescript
-   * const success = await store.add('unique-task', { status: 'pending' }, 60);
-   * ```
-   */
   async add(key, value, ttl) {
     const normalized = normalizeCacheKey(key);
     const existing = await this.get(normalized);
@@ -1803,61 +935,22 @@ var FileStore = class {
     await this.put(normalized, value, ttl);
     return true;
   }
-  /**
-   * Removes an item from the cache by its key.
-   *
-   * @param key - The unique identifier for the cache item.
-   * @returns `true` if the file was deleted or didn't exist, `false` on failure.
-   *
-   * @example
-   * ```typescript
-   * await store.forget('my-key');
-   * ```
-   */
   async forget(key) {
     const normalized = normalizeCacheKey(key);
     await this.ensureDir();
-    const file = this.filePathForKey(normalized);
+    const file = await this.filePathForKey(normalized);
     try {
-      await (0, import_promises.rm)(file, { force: true });
+      await import_core.runtimeRemoveRecursive(this.runtime, file);
       return true;
     } catch {
       return false;
     }
   }
-  /**
-   * Removes all items from the cache directory.
-   *
-   * This operation deletes the entire cache directory and recreates it.
-   * Use with caution as it is destructive and non-reversible.
-   *
-   * @throws {Error} If the directory cannot be removed or recreated.
-   *
-   * @example
-   * ```typescript
-   * await store.flush();
-   * ```
-   */
   async flush() {
     await this.ensureDir();
-    await (0, import_promises.rm)(this.options.directory, { recursive: true, force: true });
+    await import_core.runtimeRemoveRecursive(this.runtime, this.options.directory);
     await this.ensureDir();
   }
-  /**
-   * Increments the value of an integer item in the cache.
-   *
-   * If the key does not exist, it is initialized to 0 before incrementing.
-   *
-   * @param key - The unique identifier for the cache item.
-   * @param value - The amount to increment by.
-   * @returns The new value after incrementing.
-   * @throws {Error} If the existing value is not a number.
-   *
-   * @example
-   * ```typescript
-   * const newCount = await store.increment('page-views');
-   * ```
-   */
   async increment(key, value = 1) {
     const normalized = normalizeCacheKey(key);
     const current = await this.get(normalized);
@@ -1865,77 +958,30 @@ var FileStore = class {
     await this.put(normalized, next, null);
     return next;
   }
-  /**
-   * Decrements the value of an integer item in the cache.
-   *
-   * If the key does not exist, it is initialized to 0 before decrementing.
-   *
-   * @param key - The unique identifier for the cache item.
-   * @param value - The amount to decrement by.
-   * @returns The new value after decrementing.
-   * @throws {Error} If the existing value is not a number.
-   *
-   * @example
-   * ```typescript
-   * const newCount = await store.decrement('stock-level');
-   * ```
-   */
   async decrement(key, value = 1) {
     return this.increment(key, -value);
   }
-  /**
-   * Retrieves the remaining time-to-live for a cache item in seconds.
-   *
-   * @param key - The unique identifier for the cache item.
-   * @returns The seconds remaining until expiration, or `null` if it never expires or doesn't exist.
-   *
-   * @example
-   * ```typescript
-   * const secondsLeft = await store.ttl('session:123');
-   * ```
-   */
   async ttl(key) {
     const normalized = normalizeCacheKey(key);
-    const file = this.filePathForKey(normalized);
+    const file = await this.filePathForKey(normalized);
     try {
-      const raw = await (0, import_promises.readFile)(file, "utf8");
+      const raw = await import_core.runtimeReadText(this.runtime, file);
       const data = JSON.parse(raw);
       if (data.expiresAt === null) {
         return null;
       }
-      const remaining = Math.ceil((data.expiresAt - Date.now()) / 1e3);
+      const remaining = Math.ceil((data.expiresAt - Date.now()) / 1000);
       return remaining > 0 ? remaining : null;
     } catch {
       return null;
     }
   }
-  /**
-   * Creates a distributed lock instance based on the filesystem.
-   *
-   * Locks are implemented using atomic file creation (`wx` flag). They include
-   * protection against stale locks by checking process IDs and expiration times.
-   *
-   * @param name - The unique name of the lock.
-   * @param seconds - The duration in seconds for which the lock should be held.
-   * @returns A `CacheLock` instance for managing the lock lifecycle.
-   *
-   * @example
-   * ```typescript
-   * const lock = store.lock('process-report', 60);
-   * if (await lock.acquire()) {
-   *   try {
-   *     // Critical section
-   *   } finally {
-   *     await lock.release();
-   *   }
-   * }
-   * ```
-   */
   lock(name, seconds = 10) {
     const normalizedName = normalizeCacheKey(name);
-    const lockFile = (0, import_node_path.join)(this.options.directory, `.lock-${hashKey(normalizedName)}`);
-    const ttlMillis = Math.max(1, seconds) * 1e3;
-    const owner = (0, import_node_crypto.randomUUID)();
+    const lockFile = import_node_path.join(this.options.directory, `.lock-${syncHashKey(normalizedName)}`);
+    const ttlMillis = Math.max(1, seconds) * 1000;
+    const owner = crypto.randomUUID();
+    const runtime = this.runtime;
     const isProcessAlive = (pid) => {
       try {
         process.kill(pid, 0);
@@ -1947,62 +993,41 @@ var FileStore = class {
     const tryAcquire = async () => {
       await this.ensureDir();
       try {
-        const handle = await (0, import_promises.open)(lockFile, "wx");
         const lockData = {
           owner,
           expiresAt: Date.now() + ttlMillis,
           pid: process.pid
         };
-        await handle.writeFile(JSON.stringify(lockData), "utf8");
-        await handle.close();
+        await import_core.runtimeWriteFileExclusive(runtime, lockFile, JSON.stringify(lockData));
         return true;
       } catch {
         try {
-          const raw = await (0, import_promises.readFile)(lockFile, "utf8");
+          const raw = await import_core.runtimeReadText(runtime, lockFile);
           const data = JSON.parse(raw);
-          const isExpired2 = !data.expiresAt || Date.now() > data.expiresAt;
+          const isExpiredLock = !data.expiresAt || Date.now() > data.expiresAt;
           const isProcessDead = data.pid && !isProcessAlive(data.pid);
-          if (isExpired2 || isProcessDead) {
-            await (0, import_promises.rm)(lockFile, { force: true });
+          if (isExpiredLock || isProcessDead) {
+            await import_core.runtimeRemoveRecursive(runtime, lockFile);
           }
-        } catch {
-        }
+        } catch {}
         return false;
       }
     };
     return {
-      /**
-       * Attempts to acquire the lock immediately.
-       *
-       * @returns `true` if the lock was successfully acquired, `false` otherwise.
-       */
       async acquire() {
         return tryAcquire();
       },
-      /**
-       * Releases the lock if it is owned by the current instance.
-       */
       async release() {
         try {
-          const raw = await (0, import_promises.readFile)(lockFile, "utf8");
+          const raw = await import_core.runtimeReadText(runtime, lockFile);
           const data = JSON.parse(raw);
           if (data.owner === owner) {
-            await (0, import_promises.rm)(lockFile, { force: true });
+            await import_core.runtimeRemoveRecursive(runtime, lockFile);
           }
-        } catch {
-        }
+        } catch {}
       },
-      /**
-       * Executes a callback within the lock, waiting if necessary.
-       *
-       * @param secondsToWait - Maximum time to wait for the lock in seconds.
-       * @param callback - The function to execute once the lock is acquired.
-       * @param options - Polling configuration.
-       * @returns The result of the callback.
-       * @throws {LockTimeoutError} If the lock cannot be acquired within the wait time.
-       */
       async block(secondsToWait, callback, options) {
-        const deadline = Date.now() + Math.max(0, secondsToWait) * 1e3;
+        const deadline = Date.now() + Math.max(0, secondsToWait) * 1000;
         const sleepMillis = options?.sleepMillis ?? 150;
         while (Date.now() <= deadline) {
           if (await this.acquire()) {
@@ -2014,94 +1039,52 @@ var FileStore = class {
           }
           await sleep(sleepMillis);
         }
-        throw new LockTimeoutError(
-          `Failed to acquire lock '${name}' within ${secondsToWait} seconds.`
-        );
+        throw new LockTimeoutError(`Failed to acquire lock '${name}' within ${secondsToWait} seconds.`);
       }
     };
   }
-};
+}
 function hashKey(key) {
-  return (0, import_node_crypto.createHash)("sha256").update(key).digest("hex");
+  return import_ffi.NativeHasher.sha256(key);
+}
+function syncHashKey(key) {
+  let hash = 5381;
+  for (let i = 0;i < key.length; i++) {
+    hash = (hash << 5) + hash ^ key.charCodeAt(i);
+    hash = hash >>> 0;
+  }
+  return hash.toString(16).padStart(8, "0");
 }
-
-// src/stores/MemoryStore.ts
-var import_node_crypto2 = require("crypto");
 
 // src/utils/LRUCache.ts
-var LRUCache = class {
-  /**
-   * Creates a new LRU cache instance.
-   *
-   * @param maxSize - The maximum number of items allowed in the cache. Set to 0 for unlimited.
-   * @param onEvict - Optional callback triggered when an item is evicted due to capacity limits.
-   */
+class LRUCache {
+  maxSize;
+  onEvict;
+  map = new Map;
+  head = null;
+  tail = null;
   constructor(maxSize, onEvict) {
     this.maxSize = maxSize;
     this.onEvict = onEvict;
   }
-  map = /* @__PURE__ */ new Map();
-  head = null;
-  tail = null;
-  /**
-   * The current number of items stored in the cache.
-   */
   get size() {
     return this.map.size;
   }
-  /**
-   * Checks if a key exists in the cache without updating its access order.
-   *
-   * @param key - The identifier to look for.
-   * @returns True if the key exists, false otherwise.
-   */
   has(key) {
     return this.map.has(key);
   }
-  /**
-   * Retrieves an item from the cache and marks it as most recently used.
-   *
-   * @param key - The identifier of the item to retrieve.
-   * @returns The cached value, or undefined if not found.
-   *
-   * @example
-   * ```typescript
-   * const value = cache.get('my-key');
-   * ```
-   */
   get(key) {
     const node = this.map.get(key);
     if (!node) {
-      return void 0;
+      return;
     }
     this.moveToHead(node);
     return node.value;
   }
-  /**
-   * Retrieves an item from the cache without updating its access order.
-   *
-   * Useful for inspecting the cache without affecting eviction priority.
-   *
-   * @param key - The identifier of the item to peek.
-   * @returns The cached value, or undefined if not found.
-   */
   peek(key) {
     const node = this.map.get(key);
     return node?.value;
   }
-  /**
-   * Adds or updates an item in the cache, marking it as most recently used.
-   *
-   * If the cache is at capacity, the least recently used item will be evicted.
-   *
-   * @param key - The identifier for the item.
-   * @param value - The data to store.
-   *
-   * @example
-   * ```typescript
-   * cache.set('user:1', { name: 'Alice' });
-   * ```
-   */
   set(key, value) {
     const existingNode = this.map.get(key);
     if (existingNode) {
@@ -2127,12 +1110,6 @@ var LRUCache = class {
     }
     this.map.set(key, newNode);
   }
-  /**
-   * Removes an item from the cache.
-   *
-   * @param key - The identifier of the item to remove.
-   * @returns True if the item was found and removed, false otherwise.
-   */
   delete(key) {
     const node = this.map.get(key);
     if (!node) {
@@ -2142,19 +1119,11 @@ var LRUCache = class {
     this.map.delete(key);
     return true;
   }
-  /**
-   * Removes all items from the cache.
-   */
   clear() {
     this.map.clear();
     this.head = null;
     this.tail = null;
   }
-  /**
-   * Moves a node to the head of the linked list (most recently used).
-   *
-   * @param node - The node to promote.
-   */
   moveToHead(node) {
     if (node === this.head) {
       return;
@@ -2175,11 +1144,6 @@ var LRUCache = class {
     }
     this.head = node;
   }
-  /**
-   * Removes a node from the linked list.
-   *
-   * @param node - The node to remove.
-   */
   removeNode(node) {
     if (node.prev) {
       node.prev.next = node.next;
@@ -2194,11 +1158,6 @@ var LRUCache = class {
     node.prev = null;
     node.next = null;
   }
-  /**
-   * Evicts the least recently used item (the tail of the list).
-   *
-   * Triggers the `onEvict` callback if provided.
-   */
   evict() {
     if (!this.tail) {
       return;
@@ -2210,37 +1169,21 @@ var LRUCache = class {
     this.removeNode(node);
     this.map.delete(node.key);
   }
-};
+}
 
 // src/stores/MemoryStore.ts
-var MemoryStore = class {
+class MemoryStore {
   entries;
-  locks = /* @__PURE__ */ new Map();
+  locks = new Map;
   stats = { hits: 0, misses: 0, evictions: 0 };
-  tagToKeys = /* @__PURE__ */ new Map();
-  keyToTags = /* @__PURE__ */ new Map();
-  /**
-   * Creates a new MemoryStore instance.
-   *
-   * @param options - Configuration for capacity and eviction.
-   */
+  tagToKeys = new Map;
+  keyToTags = new Map;
   constructor(options = {}) {
     this.entries = new LRUCache(options.maxItems ?? 0, (key) => {
       this.tagIndexRemove(key);
       this.stats.evictions++;
     });
   }
-  /**
-   * Retrieves current performance metrics.
-   *
-   * @returns A snapshot of hits, misses, size, and eviction counts.
-   *
-   * @example
-   * ```typescript
-   * const stats = store.getStats();
-   * console.log(`Cache hit rate: ${stats.hitRate * 100}%`);
-   * ```
-   */
   getStats() {
     const total = this.stats.hits + this.stats.misses;
     return {
@@ -2257,22 +1200,9 @@ var MemoryStore = class {
       return;
     }
     if (isExpired(entry.expiresAt, now)) {
-      void this.forget(key);
-    }
-  }
-  /**
-   * Retrieves an item from the cache by its key.
-   *
-   * If the item is expired, it will be automatically removed and `null` will be returned.
-   *
-   * @param key - The unique identifier for the cached item.
-   * @returns The cached value, or `null` if not found or expired.
-   *
-   * @example
-   * ```typescript
-   * const value = await store.get('my-key');
-   * ```
-   */
+      this.forget(key);
+    }
+  }
   async get(key) {
     const normalized = normalizeCacheKey(key);
     const entry = this.entries.get(normalized);
@@ -2288,42 +1218,15 @@ var MemoryStore = class {
     this.stats.hits++;
     return entry.value;
   }
-  /**
-   * Stores an item in the cache with a specific TTL.
-   *
-   * If the key already exists, it will be overwritten.
-   *
-   * @param key - The unique identifier for the item.
-   * @param value - The data to store.
-   * @param ttl - Time-to-live in seconds, or a Date object for absolute expiration.
-   *
-   * @example
-   * ```typescript
-   * await store.put('settings', { theme: 'dark' }, 3600);
-   * ```
-   */
   async put(key, value, ttl) {
     const normalized = normalizeCacheKey(key);
     const expiresAt = ttlToExpiresAt(ttl);
-    if (expiresAt !== null && expiresAt !== void 0 && expiresAt <= Date.now()) {
+    if (expiresAt !== null && expiresAt !== undefined && expiresAt <= Date.now()) {
       await this.forget(normalized);
       return;
     }
     this.entries.set(normalized, { value, expiresAt: expiresAt ?? null });
   }
-  /**
-   * Stores an item only if it does not already exist in the cache.
-   *
-   * @param key - The unique identifier for the item.
-   * @param value - The data to store.
-   * @param ttl - Time-to-live in seconds or absolute expiration.
-   * @returns `true` if the item was added, `false` if it already existed.
-   *
-   * @example
-   * ```typescript
-   * const added = await store.add('unique-task', data, 60);
-   * ```
-   */
   async add(key, value, ttl) {
     const normalized = normalizeCacheKey(key);
     this.cleanupExpired(normalized);
@@ -2333,50 +1236,17 @@ var MemoryStore = class {
     await this.put(normalized, value, ttl);
     return true;
   }
-  /**
-   * Removes an item from the cache.
-   *
-   * @param key - The unique identifier for the item to remove.
-   * @returns `true` if the item existed and was removed, `false` otherwise.
-   *
-   * @example
-   * ```typescript
-   * await store.forget('user:session');
-   * ```
-   */
   async forget(key) {
     const normalized = normalizeCacheKey(key);
     const existed = this.entries.delete(normalized);
     this.tagIndexRemove(normalized);
     return existed;
   }
-  /**
-   * Removes all items from the cache and resets all internal indexes.
-   *
-   * @example
-   * ```typescript
-   * await store.flush();
-   * ```
-   */
   async flush() {
     this.entries.clear();
     this.tagToKeys.clear();
     this.keyToTags.clear();
   }
-  /**
-   * Increments the value of an item in the cache.
-   *
-   * If the key does not exist, it starts from 0.
-   *
-   * @param key - The identifier for the numeric value.
-   * @param value - The amount to increment by (defaults to 1).
-   * @returns The new incremented value.
-   *
-   * @example
-   * ```typescript
-   * const count = await store.increment('page_views');
-   * ```
-   */
   async increment(key, value = 1) {
     const normalized = normalizeCacheKey(key);
     const current = await this.get(normalized);
@@ -2384,32 +1254,9 @@ var MemoryStore = class {
     await this.put(normalized, next, null);
     return next;
   }
-  /**
-   * Decrements the value of an item in the cache.
-   *
-   * @param key - The identifier for the numeric value.
-   * @param value - The amount to decrement by (defaults to 1).
-   * @returns The new decremented value.
-   *
-   * @example
-   * ```typescript
-   * const remaining = await store.decrement('stock_count', 5);
-   * ```
-   */
   async decrement(key, value = 1) {
     return this.increment(key, -value);
   }
-  /**
-   * Gets the remaining time-to-live for a cached item.
-   *
-   * @param key - The identifier for the cached item.
-   * @returns Remaining seconds, or `null` if the item has no expiration or does not exist.
-   *
-   * @example
-   * ```typescript
-   * const secondsLeft = await store.ttl('token');
-   * ```
-   */
   async ttl(key) {
     const normalized = normalizeCacheKey(key);
     const entry = this.entries.peek(normalized);
@@ -2421,30 +1268,11 @@ var MemoryStore = class {
       await this.forget(normalized);
       return null;
     }
-    return Math.max(0, Math.ceil((entry.expiresAt - now) / 1e3));
-  }
-  /**
-   * Creates a lock instance for managing exclusive access to a resource.
-   *
-   * @param name - The name of the lock.
-   * @param seconds - The duration the lock should be held (defaults to 10).
-   * @returns A `CacheLock` instance.
-   *
-   * @example
-   * ```typescript
-   * const lock = store.lock('process-report', 30);
-   * if (await lock.acquire()) {
-   *   try {
-   *     // Critical section
-   *   } finally {
-   *     await lock.release();
-   *   }
-   * }
-   * ```
-   */
+    return Math.max(0, Math.ceil((entry.expiresAt - now) / 1000));
+  }
   lock(name, seconds = 10) {
     const lockKey = `lock:${normalizeCacheKey(name)}`;
-    const ttlMillis = Math.max(1, seconds) * 1e3;
+    const ttlMillis = Math.max(1, seconds) * 1000;
     const locks = this.locks;
     const acquire = async () => {
       const now = Date.now();
@@ -2452,17 +1280,12 @@ var MemoryStore = class {
       if (existing && existing.expiresAt > now) {
         return { ok: false };
       }
-      const owner2 = (0, import_node_crypto2.randomUUID)();
+      const owner2 = crypto.randomUUID();
       locks.set(lockKey, { owner: owner2, expiresAt: now + ttlMillis });
       return { ok: true, owner: owner2 };
     };
     let owner;
     return {
-      /**
-       * Attempts to acquire the lock.
-       *
-       * @returns `true` if acquired, `false` if already held by another process.
-       */
       async acquire() {
         const result = await acquire();
         if (!result.ok) {
@@ -2471,9 +1294,6 @@ var MemoryStore = class {
         owner = result.owner;
         return true;
       },
-      /**
-       * Releases the lock if it is held by the current owner.
-       */
       async release() {
         if (!owner) {
           return;
@@ -2482,26 +1302,10 @@ var MemoryStore = class {
         if (existing?.owner === owner) {
           locks.delete(lockKey);
         }
-        owner = void 0;
+        owner = undefined;
       },
-      /**
-       * Attempts to acquire the lock and execute a callback, waiting if necessary.
-       *
-       * @param secondsToWait - How long to wait for the lock before timing out.
-       * @param callback - The logic to execute while holding the lock.
-       * @param options - Polling configuration.
-       * @returns The result of the callback.
-       * @throws {LockTimeoutError} If the lock cannot be acquired within the wait time.
-       *
-       * @example
-       * ```typescript
-       * await lock.block(5, async () => {
-       *   // This code runs exclusively
-       * });
-       * ```
-       */
       async block(secondsToWait, callback, options) {
-        const deadline = Date.now() + Math.max(0, secondsToWait) * 1e3;
+        const deadline = Date.now() + Math.max(0, secondsToWait) * 1000;
         const sleepMillis = options?.sleepMillis ?? 150;
         while (Date.now() <= deadline) {
           if (await this.acquire()) {
@@ -2513,21 +1317,10 @@ var MemoryStore = class {
           }
           await sleep(sleepMillis);
         }
-        throw new LockTimeoutError(
-          `Failed to acquire lock '${name}' within ${secondsToWait} seconds.`
-        );
+        throw new LockTimeoutError(`Failed to acquire lock '${name}' within ${secondsToWait} seconds.`);
       }
     };
   }
-  /**
-   * Generates a tagged key for storage.
-   *
-   * Used internally to prefix keys with their associated tags.
-   *
-   * @param key - The original cache key.
-   * @param tags - List of tags to associate with the key.
-   * @returns A formatted string containing tags and the key.
-   */
   tagKey(key, tags) {
     const normalizedKey = normalizeCacheKey(key);
     const normalizedTags = [...tags].map(String).filter(Boolean).sort();
@@ -2536,12 +1329,6 @@ var MemoryStore = class {
     }
     return `tags:${normalizedTags.join("|")}:${normalizedKey}`;
   }
-  /**
-   * Indexes a tagged key for bulk invalidation.
-   *
-   * @param tags - The tags to index.
-   * @param taggedKey - The full key (including tag prefix) to store.
-   */
   tagIndexAdd(tags, taggedKey) {
     const normalizedTags = [...tags].map(String).filter(Boolean);
     if (normalizedTags.length === 0) {
@@ -2550,25 +1337,20 @@ var MemoryStore = class {
     for (const tag of normalizedTags) {
       let keys = this.tagToKeys.get(tag);
       if (!keys) {
-        keys = /* @__PURE__ */ new Set();
+        keys = new Set;
         this.tagToKeys.set(tag, keys);
       }
       keys.add(taggedKey);
     }
     let tagSet = this.keyToTags.get(taggedKey);
     if (!tagSet) {
-      tagSet = /* @__PURE__ */ new Set();
+      tagSet = new Set;
       this.keyToTags.set(taggedKey, tagSet);
     }
     for (const tag of normalizedTags) {
       tagSet.add(tag);
     }
   }
-  /**
-   * Removes a key from the tag indexes.
-   *
-   * @param taggedKey - The key to remove from all tag sets.
-   */
   tagIndexRemove(taggedKey) {
     const tags = this.keyToTags.get(taggedKey);
     if (!tags) {
@@ -2586,22 +1368,12 @@ var MemoryStore = class {
     }
     this.keyToTags.delete(taggedKey);
   }
-  /**
-   * Invalidates all cache entries associated with any of the given tags.
-   *
-   * @param tags - The tags to flush.
-   *
-   * @example
-   * ```typescript
-   * await store.flushTags(['users', 'profiles']);
-   * ```
-   */
   async flushTags(tags) {
     const normalizedTags = [...tags].map(String).filter(Boolean);
     if (normalizedTags.length === 0) {
       return;
     }
-    const keysToDelete = /* @__PURE__ */ new Set();
+    const keysToDelete = new Set;
     for (const tag of normalizedTags) {
       const keys = this.tagToKeys.get(tag);
       if (!keys) {
@@ -2615,131 +1387,42 @@ var MemoryStore = class {
       await this.forget(key);
     }
   }
-};
+}
 
 // src/stores/NullStore.ts
-var NullStore = class {
-  /**
-   * Simulates a cache miss for any given key.
-   *
-   * @param _key - Identifier for the cached item.
-   * @returns Always `null` regardless of requested key.
-   *
-   * @example
-   * ```typescript
-   * const value = await store.get('my-key');
-   * ```
-   */
+class NullStore {
   async get(_key) {
     return null;
   }
-  /**
-   * Discards the provided value instead of storing it.
-   *
-   * @param _key - The identifier for the item.
-   * @param _value - The data to be cached.
-   * @param _ttl - Time-to-live in seconds.
-   * @returns Resolves immediately after discarding the data.
-   *
-   * @example
-   * ```typescript
-   * await store.put('user:1', { id: 1 }, 3600);
-   * ```
-   */
-  async put(_key, _value, _ttl) {
-  }
-  /**
-   * Simulates a failed attempt to add an item to the cache.
-   *
-   * Since NullStore does not store data, this method always indicates that
-   * the item was not added.
-   *
-   * @param _key - The identifier for the item.
-   * @param _value - The data to be cached.
-   * @param _ttl - Time-to-live in seconds.
-   * @returns Always returns `false`.
-   *
-   * @example
-   * ```typescript
-   * const added = await store.add('key', 'value', 60); // false
-   * ```
-   */
+  async put(_key, _value, _ttl) {}
   async add(_key, _value, _ttl) {
     return false;
   }
-  /**
-   * Simulates a failed attempt to remove an item from the cache.
-   *
-   * Since no data is ever stored, there is nothing to remove.
-   *
-   * @param _key - The identifier for the item to remove.
-   * @returns Always returns `false`.
-   *
-   * @example
-   * ```typescript
-   * const forgotten = await store.forget('key'); // false
-   * ```
-   */
   async forget(_key) {
     return false;
   }
-  /**
-   * Performs a no-op flush operation.
-   *
-   * @returns Resolves immediately as there is no data to clear.
-   *
-   * @example
-   * ```typescript
-   * await store.flush();
-   * ```
-   */
-  async flush() {
-  }
-  /**
-   * Simulates an increment operation on a non-existent key.
-   *
-   * @param _key - The identifier for the numeric item.
-   * @param _value - The amount to increment by.
-   * @returns Always returns `0`.
-   *
-   * @example
-   * ```typescript
-   * const newValue = await store.increment('counter', 1); // 0
-   * ```
-   */
+  async flush() {}
   async increment(_key, _value = 1) {
     return 0;
   }
-  /**
-   * Simulates a decrement operation on a non-existent key.
-   *
-   * @param _key - The identifier for the numeric item.
-   * @param _value - The amount to decrement by.
-   * @returns Always returns `0`.
-   *
-   * @example
-   * ```typescript
-   * const newValue = await store.decrement('counter', 1); // 0
-   * ```
-   */
   async decrement(_key, _value = 1) {
     return 0;
   }
-};
+}
 
 // src/stores/PredictiveStore.ts
-var PredictiveStore = class {
+class PredictiveStore {
+  store;
+  predictor;
   constructor(store, options = {}) {
     this.store = store;
-    this.predictor = options.predictor ?? new MarkovPredictor();
+    this.predictor = options.predictor ?? new MarkovPredictor;
   }
-  predictor;
   async get(key) {
     this.predictor.record(key);
     const candidates = this.predictor.predict(key);
     if (candidates.length > 0) {
-      void Promise.all(candidates.map((k) => this.store.get(k).catch(() => {
-      })));
+      Promise.all(candidates.map((k) => this.store.get(k).catch(() => {})));
     }
     return this.store.get(key);
   }
@@ -2765,41 +1448,23 @@ var PredictiveStore = class {
     return this.store.decrement(key, value);
   }
   lock(name, seconds) {
-    return this.store.lock ? this.store.lock(name, seconds) : void 0;
+    return this.store.lock ? this.store.lock(name, seconds) : undefined;
   }
   async ttl(key) {
     return this.store.ttl ? this.store.ttl(key) : null;
   }
-};
+}
 
 // src/stores/RedisStore.ts
-var import_node_crypto3 = require("crypto");
 var import_plasma = require("@gravito/plasma");
-var RedisStore = class {
+class RedisStore {
   connectionName;
-  /**
-   * Initialize a new RedisStore instance.
-   *
-   * @param options - Redis connection and prefix settings.
-   *
-   * @example
-   * ```typescript
-   * const store = new RedisStore({ prefix: 'app:' });
-   * ```
-   */
   constructor(options = {}) {
     this.connectionName = options.connection;
   }
   get client() {
     return import_plasma.Redis.connection(this.connectionName);
   }
-  /**
-   * Retrieve an item from Redis.
-   *
-   * @param key - Unique cache key identifier.
-   * @returns Parsed JSON value or null if missing/expired.
-   * @throws {Error} If Redis connection fails or read errors occur.
-   */
   async get(key) {
     const normalized = normalizeCacheKey(key);
     const value = await this.client.get(normalized);
@@ -2812,14 +1477,6 @@ var RedisStore = class {
       return value;
     }
   }
-  /**
-   * Store an item in Redis.
-   *
-   * @param key - Unique cache key identifier.
-   * @param value - Value to serialize and store.
-   * @param ttl - Expiration duration.
-   * @throws {Error} If Redis connection fails or write errors occur.
-   */
   async put(key, value, ttl) {
     const normalized = normalizeCacheKey(key);
     const serialized = JSON.stringify(value);
@@ -2870,14 +1527,6 @@ var RedisStore = class {
     }
     return await this.client.incrby(normalized, value);
   }
-  /**
-   * Decrement a numeric value in Redis.
-   *
-   * @param key - Unique cache key identifier.
-   * @param value - Amount to subtract.
-   * @returns Updated numeric value.
-   * @throws {Error} If key is not numeric or Redis errors occur.
-   */
   async decrement(key, value = 1) {
     const normalized = normalizeCacheKey(key);
     if (value === 1) {
@@ -2885,9 +1534,6 @@ var RedisStore = class {
     }
     return await this.client.decrby(normalized, value);
   }
-  // ============================================================================
-  // Tags
-  // ============================================================================
   tagKey(key, _tags) {
     return key;
   }
@@ -2926,7 +1572,7 @@ var RedisStore = class {
       pipeline.smembers(tagKey);
     }
     const results = await pipeline.exec();
-    const keysToDelete = /* @__PURE__ */ new Set();
+    const keysToDelete = new Set;
     for (const [err, keys] of results) {
       if (!err && Array.isArray(keys)) {
         for (const k of keys) {
@@ -2939,9 +1585,6 @@ var RedisStore = class {
     }
     await this.client.del(...tagKeys);
   }
-  // ============================================================================
-  // Locks
-  // ============================================================================
   async ttl(key) {
     const normalized = normalizeCacheKey(key);
     const result = await this.client.ttl(normalized);
@@ -2949,8 +1592,8 @@ var RedisStore = class {
   }
   lock(name, seconds = 10) {
     const lockKey = `lock:${normalizeCacheKey(name)}`;
-    const owner = (0, import_node_crypto3.randomUUID)();
-    const ttlMs = Math.max(1, seconds) * 1e3;
+    const owner = crypto.randomUUID();
+    const ttlMs = Math.max(1, seconds) * 1000;
     const client = this.client;
     return {
       async acquire() {
@@ -2979,13 +1622,7 @@ var RedisStore = class {
           end
         `;
         const evalClient = client;
-        const result = await evalClient.eval(
-          luaScript,
-          1,
-          lockKey,
-          owner,
-          extensionSeconds.toString()
-        );
+        const result = await evalClient.eval(luaScript, 1, lockKey, owner, extensionSeconds.toString());
         return result === 1;
       },
       async getRemainingTime() {
@@ -2995,7 +1632,7 @@ var RedisStore = class {
         const retryInterval = options?.retryInterval ?? options?.sleepMillis ?? 100;
         const maxRetries = options?.maxRetries ?? Number.POSITIVE_INFINITY;
         const signal = options?.signal;
-        const deadline = Date.now() + Math.max(0, secondsToWait) * 1e3;
+        const deadline = Date.now() + Math.max(0, secondsToWait) * 1000;
         let attempt = 0;
         while (Date.now() <= deadline && attempt < maxRetries) {
           if (signal?.aborted) {
@@ -3009,25 +1646,19 @@ var RedisStore = class {
             }
           }
           attempt++;
-          const delay = Math.min(retryInterval * 1.5 ** Math.min(attempt, 10), 1e3);
+          const delay = Math.min(retryInterval * 1.5 ** Math.min(attempt, 10), 1000);
           await sleep(delay);
         }
-        throw new LockTimeoutError(
-          `Failed to acquire lock '${name}' within ${secondsToWait} seconds.`
-        );
+        throw new LockTimeoutError(`Failed to acquire lock '${name}' within ${secondsToWait} seconds.`);
       }
     };
   }
-};
+}
 
 // src/stores/TieredStore.ts
-var TieredStore = class {
-  /**
-   * Initializes a new TieredStore.
-   *
-   * @param local - The L1 cache store (usually MemoryStore).
-   * @param remote - The L2 cache store (usually RedisStore or FileStore).
-   */
+class TieredStore {
+  local;
+  remote;
   constructor(local, remote) {
     this.local = local;
     this.remote = remote;
@@ -3076,11 +1707,11 @@ var TieredStore = class {
     }
     return this.local.ttl ? this.local.ttl(key) : null;
   }
-};
+}
 
 // src/index.ts
-var MemoryCacheProvider = class {
-  store = new MemoryStore();
+class MemoryCacheProvider {
+  store = new MemoryStore;
   async get(key) {
     return this.store.get(key);
   }
@@ -3093,7 +1724,7 @@ var MemoryCacheProvider = class {
   async clear() {
     await this.store.flush();
   }
-};
+}
 function resolveStoreConfig(core, options) {
   if (options) {
     return options;
@@ -3111,15 +1742,15 @@ function createStoreFactory(config) {
     const hasExplicitStores = Object.keys(stores).length > 0;
     if (!storeConfig) {
       if (name === "memory") {
-        return new MemoryStore();
+        return new MemoryStore;
       }
       if (name === "null") {
-        return new NullStore();
+        return new NullStore;
       }
       if (hasExplicitStores) {
         throw new Error(`Cache store '${name}' is not defined.`);
       }
-      return new MemoryStore();
+      return new MemoryStore;
     }
     if (storeConfig.driver === "memory") {
       return new MemoryStore({ maxItems: storeConfig.maxItems });
@@ -3131,7 +1762,7 @@ function createStoreFactory(config) {
       return new RedisStore({ connection: storeConfig.connection, prefix: storeConfig.prefix });
     }
     if (storeConfig.driver === "null") {
-      return new NullStore();
+      return new NullStore;
     }
     if (storeConfig.driver === "custom") {
       return storeConfig.store;
@@ -3184,7 +1815,7 @@ function createStoreFactory(config) {
     if (storeConfig.driver === "circuit-breaker") {
       const factory = createStoreFactory(config);
       const primary = factory(storeConfig.primary);
-      const fallback = storeConfig.fallback ? factory(storeConfig.fallback) : void 0;
+      const fallback = storeConfig.fallback ? factory(storeConfig.fallback) : undefined;
       return new CircuitBreakerStore(primary, {
         maxFailures: storeConfig.maxFailures,
         resetTimeout: storeConfig.resetTimeout,
@@ -3194,16 +1825,18 @@ function createStoreFactory(config) {
     throw new Error(`Unsupported cache driver '${storeConfig.driver}'.`);
   };
 }
-var OrbitStasis = class {
+
+class OrbitStasis {
+  options;
+  manager;
   constructor(options) {
     this.options = options;
   }
-  manager;
   install(core) {
     const resolvedConfig = resolveStoreConfig(core, this.options);
     const exposeAs = resolvedConfig.exposeAs ?? "cache";
     const defaultStore = resolvedConfig.default ?? (resolvedConfig.provider ? "default" : "memory");
-    const defaultTtl = resolvedConfig.defaultTtl ?? (typeof resolvedConfig.defaultTTL === "number" ? resolvedConfig.defaultTTL : void 0) ?? 60;
+    const defaultTtl = resolvedConfig.defaultTtl ?? (typeof resolvedConfig.defaultTTL === "number" ? resolvedConfig.defaultTTL : undefined) ?? 60;
     const prefix = resolvedConfig.prefix ?? "";
     const logger = core.logger;
     logger.info(`[OrbitCache] Initializing Cache (Exposed as: ${exposeAs})`);
@@ -3218,21 +1851,16 @@ var OrbitStasis = class {
       const key = payload.key ? ` (key: ${payload.key})` : "";
       logger.error(`[OrbitCache] cache event '${event}' failed${key}`, error);
     });
-    const stores = resolvedConfig.stores ?? (resolvedConfig.provider ? { default: { driver: "provider", provider: resolvedConfig.provider } } : void 0);
-    const manager = new CacheManager(
-      createStoreFactory({ ...resolvedConfig, stores }),
-      {
-        default: defaultStore,
-        prefix,
-        defaultTtl
-      },
-      events,
-      {
-        mode: resolvedConfig.eventsMode ?? "async",
-        throwOnError: resolvedConfig.throwOnEventError,
-        onError: onEventError
-      }
-    );
+    const stores = resolvedConfig.stores ?? (resolvedConfig.provider ? { default: { driver: "provider", provider: resolvedConfig.provider } } : undefined);
+    const manager = new CacheManager(createStoreFactory({ ...resolvedConfig, stores }), {
+      default: defaultStore,
+      prefix,
+      defaultTtl
+    }, events, {
+      mode: resolvedConfig.eventsMode ?? "async",
+      throwOnError: resolvedConfig.throwOnEventError,
+      onError: onEventError
+    });
     this.manager = manager;
     core.adapter.use("*", async (c, next) => {
       c.set(exposeAs, manager);
@@ -3247,33 +1875,12 @@ var OrbitStasis = class {
     }
     return this.manager;
   }
-};
+}
 function orbitCache(core, options = {}) {
   const orbit = new OrbitStasis(options);
   orbit.install(core);
   return orbit.getCache();
 }
 var OrbitCache = OrbitStasis;
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  CacheManager,
-  CacheRepository,
-  CircuitBreakerStore,
-  FileStore,
-  LockTimeoutError,
-  MarkovPredictor,
-  MemoryCacheProvider,
-  MemoryStore,
-  NullStore,
-  OrbitCache,
-  OrbitStasis,
-  PredictiveStore,
-  RateLimiter,
-  RedisStore,
-  TieredStore,
-  isExpired,
-  isTaggableStore,
-  normalizeCacheKey,
-  sleep,
-  ttlToExpiresAt
-});
+
+//# debugId=66831AF7E477960E64756E2164756E21