@gravito/stasis 3.2.0 → 3.2.1

package/dist/index.cjs

@@ -1,1886 +0,0 @@
-var __defProp = Object.defineProperty;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-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,
-      configurable: true,
-      set: (newValue) => all[name] = () => newValue
-    });
-};
-
-// src/index.ts
-var exports_src = {};
-__export(exports_src, {
-  ttlToExpiresAt: () => ttlToExpiresAt,
-  sleep: () => sleep,
-  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(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
-class LockTimeoutError extends Error {
-  name = "LockTimeoutError";
-}
-function sleep(ms) {
-  return new Promise((resolve) => setTimeout(resolve, ms));
-}
-
-// src/store.ts
-function isTaggableStore(store) {
-  return typeof store.flushTags === "function" && typeof store.tagKey === "function" && typeof store.tagIndexAdd === "function" && typeof store.tagIndexRemove === "function";
-}
-
-// src/types.ts
-function normalizeCacheKey(key) {
-  if (!key) {
-    throw new Error("Cache key cannot be empty.");
-  }
-  return key;
-}
-function ttlToExpiresAt(ttl, now = Date.now()) {
-  if (ttl === undefined) {
-    return;
-  }
-  if (ttl === null) {
-    return null;
-  }
-  if (ttl instanceof Date) {
-    return ttl.getTime();
-  }
-  if (typeof ttl === "number") {
-    if (ttl <= 0) {
-      return now;
-    }
-    return now + ttl * 1000;
-  }
-  return;
-}
-function isExpired(expiresAt, now = Date.now()) {
-  if (expiresAt === null) {
-    return false;
-  }
-  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
-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
-    };
-  }
-  getFlexibleStats() {
-    return {
-      refreshCount: this.flexibleStats.refreshCount,
-      refreshFailures: this.flexibleStats.refreshFailures,
-      avgRefreshTime: this.flexibleStats.refreshCount > 0 ? this.flexibleStats.totalTime / this.flexibleStats.refreshCount : 0
-    };
-  }
-  emit(event, payload = {}) {
-    return emitCacheEvent(event, payload, this.options.events, this.eventEmitterConfig);
-  }
-  key(key) {
-    const normalized = normalizeCacheKey(key);
-    const prefix = this.options.prefix ?? "";
-    return prefix ? `${prefix}${normalized}` : normalized;
-  }
-  flexibleFreshUntilKey(fullKey) {
-    return `__gravito:flexible:freshUntil:${fullKey}`;
-  }
-  async putMetaKey(metaKey, value, ttl) {
-    await this.store.put(metaKey, value, ttl);
-  }
-  async forgetMetaKey(metaKey) {
-    await this.store.forget(metaKey);
-  }
-  async get(key, defaultValue) {
-    const fullKey = this.key(key);
-    const raw = await this.store.get(fullKey);
-    if (raw !== null) {
-      const e2 = this.emit("hit", { key: fullKey });
-      if (e2) {
-        await e2;
-      }
-      return this.decompress(raw);
-    }
-    const e = this.emit("miss", { key: fullKey });
-    if (e) {
-      await e;
-    }
-    if (defaultValue === undefined) {
-      return null;
-    }
-    if (typeof defaultValue === "function") {
-      return defaultValue();
-    }
-    return defaultValue;
-  }
-  async has(key) {
-    return await this.get(key) !== null;
-  }
-  async missing(key) {
-    return !await this.has(key);
-  }
-  async put(key, value, ttl) {
-    const fullKey = this.key(key);
-    const data = await this.compress(value);
-    await this.store.put(fullKey, data, ttl);
-    const e = this.emit("write", { key: fullKey });
-    if (e) {
-      await e;
-    }
-  }
-  async set(key, value, ttl) {
-    const resolved = ttl ?? this.options.defaultTtl;
-    await this.put(key, value, resolved);
-  }
-  async add(key, value, ttl) {
-    const fullKey = this.key(key);
-    const resolved = ttl ?? this.options.defaultTtl;
-    const ok = await this.store.add(fullKey, value, resolved);
-    if (ok) {
-      const e = this.emit("write", { key: fullKey });
-      if (e) {
-        await e;
-      }
-    }
-    return ok;
-  }
-  async forever(key, value) {
-    await this.put(key, value, null);
-  }
-  async remember(key, ttl, callback) {
-    const fullKey = this.key(key);
-    if (this.coalesceSemaphore.has(fullKey)) {
-      return this.coalesceSemaphore.get(fullKey);
-    }
-    const promise = (async () => {
-      try {
-        const existing = await this.get(key);
-        if (existing !== null) {
-          return existing;
-        }
-        const value = await callback();
-        await this.put(key, value, ttl);
-        return value;
-      } finally {
-        this.coalesceSemaphore.delete(fullKey);
-      }
-    })();
-    this.coalesceSemaphore.set(fullKey, promise);
-    return promise;
-  }
-  async rememberForever(key, callback) {
-    return this.remember(key, null, callback);
-  }
-  async many(keys) {
-    const out = {};
-    for (const key of keys) {
-      out[String(key)] = await this.get(key);
-    }
-    return out;
-  }
-  async putMany(values, ttl) {
-    await Promise.all(Object.entries(values).map(([k, v]) => this.put(k, v, ttl)));
-  }
-  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) * 1000;
-    const staleMillis = Math.max(0, staleSeconds) * 1000;
-    const [freshUntil, cachedValue] = await Promise.all([
-      this.store.get(metaKey),
-      this.store.get(fullKey)
-    ]);
-    if (freshUntil !== null && cachedValue !== null) {
-      if (now <= freshUntil) {
-        const e2 = this.emit("hit", { key: fullKey });
-        if (e2) {
-          await e2;
-        }
-        return cachedValue;
-      }
-      if (now <= freshUntil + staleMillis) {
-        const e2 = this.emit("hit", { key: fullKey });
-        if (e2) {
-          await e2;
-        }
-        this.refreshFlexible(fullKey, metaKey, ttlSeconds, staleSeconds, callback);
-        return cachedValue;
-      }
-    }
-    const e = this.emit("miss", { key: fullKey });
-    if (e) {
-      await e;
-    }
-    const value = await callback();
-    const totalTtl = ttlSeconds + staleSeconds;
-    await this.put(fullKey, value, totalTtl);
-    await this.putMetaKey(metaKey, now + ttlMillis, totalTtl);
-    return value;
-  }
-  async refreshFlexible(fullKey, metaKey, ttlSeconds, staleSeconds, callback) {
-    if (this.refreshSemaphore.has(fullKey)) {
-      return;
-    }
-    const refreshPromise = this.doRefresh(fullKey, metaKey, ttlSeconds, staleSeconds, callback);
-    this.refreshSemaphore.set(fullKey, refreshPromise);
-    try {
-      await refreshPromise;
-    } finally {
-      this.refreshSemaphore.delete(fullKey);
-    }
-  }
-  async doRefresh(fullKey, metaKey, ttlSeconds, staleSeconds, callback) {
-    if (!this.store.lock) {
-      return;
-    }
-    const lock = this.store.lock(`flexible:${metaKey}`, Math.max(1, ttlSeconds));
-    if (!lock || !await lock.acquire()) {
-      return;
-    }
-    const startTime = Date.now();
-    try {
-      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++) {
-        try {
-          value = await Promise.race([
-            Promise.resolve(callback()),
-            new Promise((_, reject) => setTimeout(() => reject(new Error("Refresh timeout")), timeoutMillis))
-          ]);
-          break;
-        } catch (err) {
-          lastError = err;
-          if (attempt < maxRetries) {
-            await sleep(retryDelay);
-          }
-        }
-      }
-      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) * 1000, totalTtl);
-      this.flexibleStats.refreshCount++;
-      this.flexibleStats.totalTime += Date.now() - startTime;
-    } catch {
-      this.flexibleStats.refreshFailures++;
-    } finally {
-      await lock.release();
-    }
-  }
-  async pull(key, defaultValue) {
-    const value = await this.get(key, defaultValue);
-    await this.forget(key);
-    return value;
-  }
-  async forget(key) {
-    const fullKey = this.key(key);
-    const metaKey = this.flexibleFreshUntilKey(fullKey);
-    const ok = await this.store.forget(fullKey);
-    await this.forgetMetaKey(metaKey);
-    if (ok) {
-      const e = this.emit("forget", { key: fullKey });
-      if (e) {
-        await e;
-      }
-    }
-    return ok;
-  }
-  async delete(key) {
-    return this.forget(key);
-  }
-  async flush() {
-    await this.store.flush();
-    const e = this.emit("flush");
-    if (e) {
-      await e;
-    }
-  }
-  async clear() {
-    return this.flush();
-  }
-  increment(key, value) {
-    return this.store.increment(this.key(key), value);
-  }
-  decrement(key, value) {
-    return this.store.decrement(this.key(key), value);
-  }
-  lock(name, seconds) {
-    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);
-  }
-  getStore() {
-    return this.store;
-  }
-  async compress(value) {
-    const opts = this.options.compression;
-    if (!opts?.enabled || value === null || value === undefined) {
-      return value;
-    }
-    const json = JSON.stringify(value);
-    if (json.length < (opts.minSize ?? 1024)) {
-      return value;
-    }
-    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: Buffer.from(compressed).toString("base64")
-    };
-  }
-  async decompress(value) {
-    if (value !== null && typeof value === "object" && "__gravito_compressed" in value && value.__gravito_compressed === true) {
-      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 {
-        return decompressed;
-      }
-    }
-    return value;
-  }
-}
-
-// src/RateLimiter.ts
-class RateLimiter {
-  store;
-  constructor(store) {
-    this.store = store;
-  }
-  async attempt(key, maxAttempts, decaySeconds) {
-    const current = await this.store.get(key);
-    const now = Math.floor(Date.now() / 1000);
-    if (current === null) {
-      await this.store.put(key, 1, decaySeconds);
-      return {
-        allowed: true,
-        remaining: maxAttempts - 1,
-        reset: now + decaySeconds
-      };
-    }
-    if (current >= maxAttempts) {
-      const retryAfter = await this.availableIn(key, decaySeconds);
-      return {
-        allowed: false,
-        remaining: 0,
-        reset: now + retryAfter,
-        retryAfter
-      };
-    }
-    const next = await this.store.increment(key);
-    return {
-      allowed: true,
-      remaining: maxAttempts - next,
-      reset: now + decaySeconds
-    };
-  }
-  async availableIn(key, decaySeconds) {
-    if (typeof this.store.ttl === "function") {
-      const remaining = await this.store.ttl(key);
-      if (remaining !== null) {
-        return remaining;
-      }
-    }
-    return decaySeconds;
-  }
-  async getInfo(key, maxAttempts, decaySeconds) {
-    const current = await this.store.get(key);
-    const now = Math.floor(Date.now() / 1000);
-    if (current === null) {
-      return {
-        limit: maxAttempts,
-        remaining: maxAttempts,
-        reset: now + decaySeconds
-      };
-    }
-    const remaining = Math.max(0, maxAttempts - current);
-    const retryAfter = remaining === 0 ? await this.availableIn(key, decaySeconds) : undefined;
-    return {
-      limit: maxAttempts,
-      remaining,
-      reset: now + (retryAfter ?? decaySeconds),
-      retryAfter
-    };
-  }
-  async clear(key) {
-    await this.store.forget(key);
-  }
-}
-
-// src/CacheManager.ts
-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;
-  }
-  limiter(name) {
-    return new RateLimiter(this.store(name).getStore());
-  }
-  store(name) {
-    const storeName = name ?? this.config.default ?? "memory";
-    const existing = this.stores.get(storeName);
-    if (existing) {
-      return existing;
-    }
-    const repo = new CacheRepository(this.storeFactory(storeName), {
-      prefix: this.config.prefix,
-      defaultTtl: this.config.defaultTtl,
-      events: this.events,
-      eventsMode: this.eventOptions?.mode,
-      throwOnEventError: this.eventOptions?.throwOnError,
-      onEventError: this.eventOptions?.onError
-    });
-    this.stores.set(storeName, repo);
-    return repo;
-  }
-  get(key, defaultValue) {
-    return this.store().get(key, defaultValue);
-  }
-  has(key) {
-    return this.store().has(key);
-  }
-  missing(key) {
-    return this.store().missing(key);
-  }
-  put(key, value, ttl) {
-    return this.store().put(key, value, ttl);
-  }
-  set(key, value, ttl) {
-    return this.store().set(key, value, ttl);
-  }
-  add(key, value, ttl) {
-    return this.store().add(key, value, ttl);
-  }
-  forever(key, value) {
-    return this.store().forever(key, value);
-  }
-  remember(key, ttl, callback) {
-    return this.store().remember(key, ttl, callback);
-  }
-  rememberForever(key, callback) {
-    return this.store().rememberForever(key, callback);
-  }
-  many(keys) {
-    return this.store().many(keys);
-  }
-  putMany(values, ttl) {
-    return this.store().putMany(values, ttl);
-  }
-  flexible(key, ttlSeconds, staleSeconds, callback) {
-    return this.store().flexible(key, ttlSeconds, staleSeconds, callback);
-  }
-  pull(key, defaultValue) {
-    return this.store().pull(key, defaultValue);
-  }
-  forget(key) {
-    return this.store().forget(key);
-  }
-  delete(key) {
-    return this.store().delete(key);
-  }
-  flush() {
-    return this.store().flush();
-  }
-  clear() {
-    return this.store().clear();
-  }
-  increment(key, value) {
-    return this.store().increment(key, value);
-  }
-  decrement(key, value) {
-    return this.store().decrement(key, value);
-  }
-  lock(name, seconds) {
-    return this.store().lock(name, seconds);
-  }
-  tags(tags) {
-    return this.store().tags(tags);
-  }
-}
-
-// src/prediction/AccessPredictor.ts
-class MarkovPredictor {
-  transitions = new Map;
-  lastKey = null;
-  maxNodes;
-  maxEdgesPerNode;
-  constructor(options = {}) {
-    this.maxNodes = options.maxNodes ?? 1000;
-    this.maxEdgesPerNode = options.maxEdgesPerNode ?? 10;
-  }
-  record(key) {
-    if (this.lastKey && this.lastKey !== key) {
-      if (!this.transitions.has(this.lastKey)) {
-        if (this.transitions.size >= this.maxNodes) {
-          this.transitions.clear();
-        }
-        this.transitions.set(this.lastKey, new Map);
-      }
-      const edges = this.transitions.get(this.lastKey);
-      const count = edges.get(key) ?? 0;
-      edges.set(key, count + 1);
-      if (edges.size > this.maxEdgesPerNode) {
-        let minKey = "";
-        let minCount = Infinity;
-        for (const [k, c] of edges) {
-          if (c < minCount) {
-            minCount = c;
-            minKey = k;
-          }
-        }
-        if (minKey) {
-          edges.delete(minKey);
-        }
-      }
-    }
-    this.lastKey = key;
-  }
-  predict(key) {
-    const edges = this.transitions.get(key);
-    if (!edges) {
-      return [];
-    }
-    return Array.from(edges.entries()).sort((a, b) => b[1] - a[1]).map((entry) => entry[0]);
-  }
-  reset() {
-    this.transitions.clear();
-    this.lastKey = null;
-  }
-}
-
-// src/stores/CircuitBreakerStore.ts
-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 ?? 60000,
-      fallback: options.fallback
-    };
-  }
-  async execute(operation, fallbackResult = null) {
-    if (this.state === "OPEN") {
-      if (Date.now() - this.lastErrorTime > this.options.resetTimeout) {
-        this.state = "HALF_OPEN";
-      } else {
-        return this.handleFallback(operation, fallbackResult);
-      }
-    }
-    try {
-      const result = await operation(this.primary);
-      this.onSuccess();
-      return result;
-    } catch (_error) {
-      this.onFailure();
-      return this.handleFallback(operation, fallbackResult);
-    }
-  }
-  onSuccess() {
-    this.failures = 0;
-    this.state = "CLOSED";
-  }
-  onFailure() {
-    this.failures++;
-    this.lastErrorTime = Date.now();
-    if (this.failures >= this.options.maxFailures) {
-      this.state = "OPEN";
-    }
-  }
-  async handleFallback(operation, fallbackResult) {
-    if (this.options.fallback) {
-      try {
-        return await operation(this.options.fallback);
-      } catch {}
-    }
-    return fallbackResult;
-  }
-  async get(key) {
-    return this.execute((s) => s.get(key));
-  }
-  async put(key, value, ttl) {
-    return this.execute((s) => s.put(key, value, ttl));
-  }
-  async add(key, value, ttl) {
-    return this.execute((s) => s.add(key, value, ttl), false);
-  }
-  async forget(key) {
-    return this.execute((s) => s.forget(key), false);
-  }
-  async flush() {
-    return this.execute((s) => s.flush());
-  }
-  async increment(key, value) {
-    return this.execute((s) => s.increment(key, value), 0);
-  }
-  async decrement(key, value) {
-    return this.execute((s) => s.decrement(key, value), 0);
-  }
-  async ttl(key) {
-    return this.execute(async (s) => s.ttl ? s.ttl(key) : null);
-  }
-  getState() {
-    return this.state;
-  }
-}
-
-// src/stores/FileStore.ts
-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 ?? 60000);
-    }
-  }
-  startCleanupDaemon(interval) {
-    this.cleanupTimer = setInterval(() => {
-      this.cleanExpiredFiles().catch(() => {});
-    }, interval);
-    if (this.cleanupTimer.unref) {
-      this.cleanupTimer.unref();
-    }
-  }
-  async cleanExpiredFiles() {
-    await this.ensureDir();
-    let cleaned = 0;
-    const validFiles = [];
-    const scanDir = async (dir) => {
-      const entries = await import_core.runtimeReadDir(this.runtime, dir);
-      for (const entry of entries) {
-        const fullPath = import_node_path.join(dir, entry.name);
-        if (entry.isDirectory) {
-          await scanDir(fullPath);
-          try {
-            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 import_core.runtimeReadText(this.runtime, fullPath);
-            const data = JSON.parse(raw);
-            if (isExpired(data.expiresAt)) {
-              await import_core.runtimeRemoveRecursive(this.runtime, fullPath);
-              cleaned++;
-            } else if (this.options.maxFiles) {
-              const stats = await import_core.runtimeStatFull(this.runtime, fullPath);
-              validFiles.push({ path: fullPath, mtime: stats.mtimeMs });
-            }
-          } catch {}
-        }
-      }
-    };
-    await scanDir(this.options.directory);
-    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 import_core.runtimeRemoveRecursive(this.runtime, f.path);
-          cleaned++;
-        } catch {}
-      }));
-    }
-    return cleaned;
-  }
-  async destroy() {
-    if (this.cleanupTimer) {
-      clearInterval(this.cleanupTimer);
-      this.cleanupTimer = null;
-    }
-  }
-  async ensureDir() {
-    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 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 = await this.filePathForKey(normalized);
-    try {
-      const raw = await import_core.runtimeReadText(this.runtime, file);
-      const data = JSON.parse(raw);
-      if (isExpired(data.expiresAt)) {
-        await this.forget(normalized);
-        return null;
-      }
-      return data.value;
-    } catch {
-      return null;
-    }
-  }
-  async put(key, value, ttl) {
-    const normalized = normalizeCacheKey(key);
-    await this.ensureDir();
-    const expiresAt = ttlToExpiresAt(ttl);
-    if (expiresAt !== null && expiresAt !== undefined && expiresAt <= Date.now()) {
-      await this.forget(normalized);
-      return;
-    }
-    const file = await this.filePathForKey(normalized);
-    if (this.options.useSubdirectories) {
-      await import_core.runtimeMkdir(this.runtime, import_node_path.dirname(file), { recursive: true });
-    }
-    const tempFile = `${file}.tmp.${Date.now()}.${crypto.randomUUID()}`;
-    const payload = { expiresAt: expiresAt ?? null, value };
-    try {
-      await this.runtime.writeFile(tempFile, JSON.stringify(payload));
-      await import_core.runtimeRename(this.runtime, tempFile, file);
-    } catch (error) {
-      await import_core.runtimeRemoveRecursive(this.runtime, tempFile).catch(() => {});
-      throw error;
-    }
-  }
-  async add(key, value, ttl) {
-    const normalized = normalizeCacheKey(key);
-    const existing = await this.get(normalized);
-    if (existing !== null) {
-      return false;
-    }
-    await this.put(normalized, value, ttl);
-    return true;
-  }
-  async forget(key) {
-    const normalized = normalizeCacheKey(key);
-    await this.ensureDir();
-    const file = await this.filePathForKey(normalized);
-    try {
-      await import_core.runtimeRemoveRecursive(this.runtime, file);
-      return true;
-    } catch {
-      return false;
-    }
-  }
-  async flush() {
-    await this.ensureDir();
-    await import_core.runtimeRemoveRecursive(this.runtime, this.options.directory);
-    await this.ensureDir();
-  }
-  async increment(key, value = 1) {
-    const normalized = normalizeCacheKey(key);
-    const current = await this.get(normalized);
-    const next = (current ?? 0) + value;
-    await this.put(normalized, next, null);
-    return next;
-  }
-  async decrement(key, value = 1) {
-    return this.increment(key, -value);
-  }
-  async ttl(key) {
-    const normalized = normalizeCacheKey(key);
-    const file = await this.filePathForKey(normalized);
-    try {
-      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()) / 1000);
-      return remaining > 0 ? remaining : null;
-    } catch {
-      return null;
-    }
-  }
-  lock(name, seconds = 10) {
-    const normalizedName = normalizeCacheKey(name);
-    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);
-        return true;
-      } catch {
-        return false;
-      }
-    };
-    const tryAcquire = async () => {
-      await this.ensureDir();
-      try {
-        const lockData = {
-          owner,
-          expiresAt: Date.now() + ttlMillis,
-          pid: process.pid
-        };
-        await import_core.runtimeWriteFileExclusive(runtime, lockFile, JSON.stringify(lockData));
-        return true;
-      } catch {
-        try {
-          const raw = await import_core.runtimeReadText(runtime, lockFile);
-          const data = JSON.parse(raw);
-          const isExpiredLock = !data.expiresAt || Date.now() > data.expiresAt;
-          const isProcessDead = data.pid && !isProcessAlive(data.pid);
-          if (isExpiredLock || isProcessDead) {
-            await import_core.runtimeRemoveRecursive(runtime, lockFile);
-          }
-        } catch {}
-        return false;
-      }
-    };
-    return {
-      async acquire() {
-        return tryAcquire();
-      },
-      async release() {
-        try {
-          const raw = await import_core.runtimeReadText(runtime, lockFile);
-          const data = JSON.parse(raw);
-          if (data.owner === owner) {
-            await import_core.runtimeRemoveRecursive(runtime, lockFile);
-          }
-        } catch {}
-      },
-      async block(secondsToWait, callback, options) {
-        const deadline = Date.now() + Math.max(0, secondsToWait) * 1000;
-        const sleepMillis = options?.sleepMillis ?? 150;
-        while (Date.now() <= deadline) {
-          if (await this.acquire()) {
-            try {
-              return await callback();
-            } finally {
-              await this.release();
-            }
-          }
-          await sleep(sleepMillis);
-        }
-        throw new LockTimeoutError(`Failed to acquire lock '${name}' within ${secondsToWait} seconds.`);
-      }
-    };
-  }
-}
-function hashKey(key) {
-  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/utils/LRUCache.ts
-class LRUCache {
-  maxSize;
-  onEvict;
-  map = new Map;
-  head = null;
-  tail = null;
-  constructor(maxSize, onEvict) {
-    this.maxSize = maxSize;
-    this.onEvict = onEvict;
-  }
-  get size() {
-    return this.map.size;
-  }
-  has(key) {
-    return this.map.has(key);
-  }
-  get(key) {
-    const node = this.map.get(key);
-    if (!node) {
-      return;
-    }
-    this.moveToHead(node);
-    return node.value;
-  }
-  peek(key) {
-    const node = this.map.get(key);
-    return node?.value;
-  }
-  set(key, value) {
-    const existingNode = this.map.get(key);
-    if (existingNode) {
-      existingNode.value = value;
-      this.moveToHead(existingNode);
-      return;
-    }
-    if (this.maxSize > 0 && this.map.size >= this.maxSize) {
-      this.evict();
-    }
-    const newNode = {
-      key,
-      value,
-      prev: null,
-      next: this.head
-    };
-    if (this.head) {
-      this.head.prev = newNode;
-    }
-    this.head = newNode;
-    if (!this.tail) {
-      this.tail = newNode;
-    }
-    this.map.set(key, newNode);
-  }
-  delete(key) {
-    const node = this.map.get(key);
-    if (!node) {
-      return false;
-    }
-    this.removeNode(node);
-    this.map.delete(key);
-    return true;
-  }
-  clear() {
-    this.map.clear();
-    this.head = null;
-    this.tail = null;
-  }
-  moveToHead(node) {
-    if (node === this.head) {
-      return;
-    }
-    if (node.prev) {
-      node.prev.next = node.next;
-    }
-    if (node.next) {
-      node.next.prev = node.prev;
-    }
-    if (node === this.tail) {
-      this.tail = node.prev;
-    }
-    node.prev = null;
-    node.next = this.head;
-    if (this.head) {
-      this.head.prev = node;
-    }
-    this.head = node;
-  }
-  removeNode(node) {
-    if (node.prev) {
-      node.prev.next = node.next;
-    } else {
-      this.head = node.next;
-    }
-    if (node.next) {
-      node.next.prev = node.prev;
-    } else {
-      this.tail = node.prev;
-    }
-    node.prev = null;
-    node.next = null;
-  }
-  evict() {
-    if (!this.tail) {
-      return;
-    }
-    const node = this.tail;
-    if (this.onEvict) {
-      this.onEvict(node.key, node.value);
-    }
-    this.removeNode(node);
-    this.map.delete(node.key);
-  }
-}
-
-// src/stores/MemoryStore.ts
-class MemoryStore {
-  entries;
-  locks = new Map;
-  stats = { hits: 0, misses: 0, evictions: 0 };
-  tagToKeys = new Map;
-  keyToTags = new Map;
-  constructor(options = {}) {
-    this.entries = new LRUCache(options.maxItems ?? 0, (key) => {
-      this.tagIndexRemove(key);
-      this.stats.evictions++;
-    });
-  }
-  getStats() {
-    const total = this.stats.hits + this.stats.misses;
-    return {
-      hits: this.stats.hits,
-      misses: this.stats.misses,
-      hitRate: total > 0 ? this.stats.hits / total : 0,
-      size: this.entries.size,
-      evictions: this.stats.evictions
-    };
-  }
-  cleanupExpired(key, now = Date.now()) {
-    const entry = this.entries.peek(key);
-    if (!entry) {
-      return;
-    }
-    if (isExpired(entry.expiresAt, now)) {
-      this.forget(key);
-    }
-  }
-  async get(key) {
-    const normalized = normalizeCacheKey(key);
-    const entry = this.entries.get(normalized);
-    if (!entry) {
-      this.stats.misses++;
-      return null;
-    }
-    if (isExpired(entry.expiresAt)) {
-      await this.forget(normalized);
-      this.stats.misses++;
-      return null;
-    }
-    this.stats.hits++;
-    return entry.value;
-  }
-  async put(key, value, ttl) {
-    const normalized = normalizeCacheKey(key);
-    const expiresAt = ttlToExpiresAt(ttl);
-    if (expiresAt !== null && expiresAt !== undefined && expiresAt <= Date.now()) {
-      await this.forget(normalized);
-      return;
-    }
-    this.entries.set(normalized, { value, expiresAt: expiresAt ?? null });
-  }
-  async add(key, value, ttl) {
-    const normalized = normalizeCacheKey(key);
-    this.cleanupExpired(normalized);
-    if (this.entries.has(normalized)) {
-      return false;
-    }
-    await this.put(normalized, value, ttl);
-    return true;
-  }
-  async forget(key) {
-    const normalized = normalizeCacheKey(key);
-    const existed = this.entries.delete(normalized);
-    this.tagIndexRemove(normalized);
-    return existed;
-  }
-  async flush() {
-    this.entries.clear();
-    this.tagToKeys.clear();
-    this.keyToTags.clear();
-  }
-  async increment(key, value = 1) {
-    const normalized = normalizeCacheKey(key);
-    const current = await this.get(normalized);
-    const next = (current ?? 0) + value;
-    await this.put(normalized, next, null);
-    return next;
-  }
-  async decrement(key, value = 1) {
-    return this.increment(key, -value);
-  }
-  async ttl(key) {
-    const normalized = normalizeCacheKey(key);
-    const entry = this.entries.peek(normalized);
-    if (!entry || entry.expiresAt === null) {
-      return null;
-    }
-    const now = Date.now();
-    if (isExpired(entry.expiresAt, now)) {
-      await this.forget(normalized);
-      return null;
-    }
-    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) * 1000;
-    const locks = this.locks;
-    const acquire = async () => {
-      const now = Date.now();
-      const existing = locks.get(lockKey);
-      if (existing && existing.expiresAt > now) {
-        return { ok: false };
-      }
-      const owner2 = crypto.randomUUID();
-      locks.set(lockKey, { owner: owner2, expiresAt: now + ttlMillis });
-      return { ok: true, owner: owner2 };
-    };
-    let owner;
-    return {
-      async acquire() {
-        const result = await acquire();
-        if (!result.ok) {
-          return false;
-        }
-        owner = result.owner;
-        return true;
-      },
-      async release() {
-        if (!owner) {
-          return;
-        }
-        const existing = locks.get(lockKey);
-        if (existing?.owner === owner) {
-          locks.delete(lockKey);
-        }
-        owner = undefined;
-      },
-      async block(secondsToWait, callback, options) {
-        const deadline = Date.now() + Math.max(0, secondsToWait) * 1000;
-        const sleepMillis = options?.sleepMillis ?? 150;
-        while (Date.now() <= deadline) {
-          if (await this.acquire()) {
-            try {
-              return await callback();
-            } finally {
-              await this.release();
-            }
-          }
-          await sleep(sleepMillis);
-        }
-        throw new LockTimeoutError(`Failed to acquire lock '${name}' within ${secondsToWait} seconds.`);
-      }
-    };
-  }
-  tagKey(key, tags) {
-    const normalizedKey = normalizeCacheKey(key);
-    const normalizedTags = [...tags].map(String).filter(Boolean).sort();
-    if (normalizedTags.length === 0) {
-      return normalizedKey;
-    }
-    return `tags:${normalizedTags.join("|")}:${normalizedKey}`;
-  }
-  tagIndexAdd(tags, taggedKey) {
-    const normalizedTags = [...tags].map(String).filter(Boolean);
-    if (normalizedTags.length === 0) {
-      return;
-    }
-    for (const tag of normalizedTags) {
-      let keys = this.tagToKeys.get(tag);
-      if (!keys) {
-        keys = new Set;
-        this.tagToKeys.set(tag, keys);
-      }
-      keys.add(taggedKey);
-    }
-    let tagSet = this.keyToTags.get(taggedKey);
-    if (!tagSet) {
-      tagSet = new Set;
-      this.keyToTags.set(taggedKey, tagSet);
-    }
-    for (const tag of normalizedTags) {
-      tagSet.add(tag);
-    }
-  }
-  tagIndexRemove(taggedKey) {
-    const tags = this.keyToTags.get(taggedKey);
-    if (!tags) {
-      return;
-    }
-    for (const tag of tags) {
-      const keys = this.tagToKeys.get(tag);
-      if (!keys) {
-        continue;
-      }
-      keys.delete(taggedKey);
-      if (keys.size === 0) {
-        this.tagToKeys.delete(tag);
-      }
-    }
-    this.keyToTags.delete(taggedKey);
-  }
-  async flushTags(tags) {
-    const normalizedTags = [...tags].map(String).filter(Boolean);
-    if (normalizedTags.length === 0) {
-      return;
-    }
-    const keysToDelete = new Set;
-    for (const tag of normalizedTags) {
-      const keys = this.tagToKeys.get(tag);
-      if (!keys) {
-        continue;
-      }
-      for (const k of keys) {
-        keysToDelete.add(k);
-      }
-    }
-    for (const key of keysToDelete) {
-      await this.forget(key);
-    }
-  }
-}
-
-// src/stores/NullStore.ts
-class NullStore {
-  async get(_key) {
-    return null;
-  }
-  async put(_key, _value, _ttl) {}
-  async add(_key, _value, _ttl) {
-    return false;
-  }
-  async forget(_key) {
-    return false;
-  }
-  async flush() {}
-  async increment(_key, _value = 1) {
-    return 0;
-  }
-  async decrement(_key, _value = 1) {
-    return 0;
-  }
-}
-
-// src/stores/PredictiveStore.ts
-class PredictiveStore {
-  store;
-  predictor;
-  constructor(store, options = {}) {
-    this.store = store;
-    this.predictor = options.predictor ?? new MarkovPredictor;
-  }
-  async get(key) {
-    this.predictor.record(key);
-    const candidates = this.predictor.predict(key);
-    if (candidates.length > 0) {
-      Promise.all(candidates.map((k) => this.store.get(k).catch(() => {})));
-    }
-    return this.store.get(key);
-  }
-  async put(key, value, ttl) {
-    return this.store.put(key, value, ttl);
-  }
-  async add(key, value, ttl) {
-    return this.store.add(key, value, ttl);
-  }
-  async forget(key) {
-    return this.store.forget(key);
-  }
-  async flush() {
-    if (typeof this.predictor.reset === "function") {
-      this.predictor.reset();
-    }
-    return this.store.flush();
-  }
-  async increment(key, value) {
-    return this.store.increment(key, value);
-  }
-  async decrement(key, value) {
-    return this.store.decrement(key, value);
-  }
-  lock(name, seconds) {
-    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_plasma = require("@gravito/plasma");
-class RedisStore {
-  connectionName;
-  constructor(options = {}) {
-    this.connectionName = options.connection;
-  }
-  get client() {
-    return import_plasma.Redis.connection(this.connectionName);
-  }
-  async get(key) {
-    const normalized = normalizeCacheKey(key);
-    const value = await this.client.get(normalized);
-    if (value === null) {
-      return null;
-    }
-    try {
-      return JSON.parse(value);
-    } catch {
-      return value;
-    }
-  }
-  async put(key, value, ttl) {
-    const normalized = normalizeCacheKey(key);
-    const serialized = JSON.stringify(value);
-    const expiresAt = ttlToExpiresAt(ttl);
-    const options = {};
-    if (expiresAt) {
-      const ttlMs = Math.max(1, expiresAt - Date.now());
-      options.px = ttlMs;
-    }
-    await this.client.set(normalized, serialized, options);
-  }
-  async add(key, value, ttl) {
-    const normalized = normalizeCacheKey(key);
-    const serialized = JSON.stringify(value);
-    const expiresAt = ttlToExpiresAt(ttl);
-    const options = { nx: true };
-    if (expiresAt) {
-      const ttlMs = Math.max(1, expiresAt - Date.now());
-      options.px = ttlMs;
-    }
-    const result = await this.client.set(normalized, serialized, options);
-    return result === "OK";
-  }
-  async forget(key) {
-    const normalized = normalizeCacheKey(key);
-    const luaScript = `
-      local key = KEYS[1]
-      local tag_prefix = ARGV[1]
-      local tags = redis.call('SMEMBERS', key .. ':tags')
-      local del_result = redis.call('DEL', key)
-      for _, tag in ipairs(tags) do
-        redis.call('SREM', tag_prefix .. tag, key)
-      end
-      redis.call('DEL', key .. ':tags')
-      return del_result
-    `;
-    const client = this.client;
-    const result = await client.eval(luaScript, 1, normalized, "tag:");
-    return result > 0;
-  }
-  async flush() {
-    await this.client.flushdb();
-  }
-  async increment(key, value = 1) {
-    const normalized = normalizeCacheKey(key);
-    if (value === 1) {
-      return await this.client.incr(normalized);
-    }
-    return await this.client.incrby(normalized, value);
-  }
-  async decrement(key, value = 1) {
-    const normalized = normalizeCacheKey(key);
-    if (value === 1) {
-      return await this.client.decr(normalized);
-    }
-    return await this.client.decrby(normalized, value);
-  }
-  tagKey(key, _tags) {
-    return key;
-  }
-  async tagIndexAdd(tags, taggedKey) {
-    if (tags.length === 0) {
-      return;
-    }
-    const pipeline = this.client.pipeline();
-    pipeline.sadd(`${taggedKey}:tags`, ...tags);
-    for (const tag of tags) {
-      const tagSetKey = `tag:${tag}`;
-      pipeline.sadd(tagSetKey, taggedKey);
-    }
-    await pipeline.exec();
-  }
-  async tagIndexRemove(taggedKey) {
-    const luaScript = `
-      local key = KEYS[1]
-      local tag_prefix = ARGV[1]
-      local tags = redis.call('SMEMBERS', key .. ':tags')
-      for _, tag in ipairs(tags) do
-        redis.call('SREM', tag_prefix .. tag, key)
-      end
-      redis.call('DEL', key .. ':tags')
-    `;
-    const client = this.client;
-    await client.eval(luaScript, 1, taggedKey, "tag:");
-  }
-  async flushTags(tags) {
-    if (tags.length === 0) {
-      return;
-    }
-    const tagKeys = tags.map((tag) => `tag:${tag}`);
-    const pipeline = this.client.pipeline();
-    for (const tagKey of tagKeys) {
-      pipeline.smembers(tagKey);
-    }
-    const results = await pipeline.exec();
-    const keysToDelete = new Set;
-    for (const [err, keys] of results) {
-      if (!err && Array.isArray(keys)) {
-        for (const k of keys) {
-          keysToDelete.add(k);
-        }
-      }
-    }
-    if (keysToDelete.size > 0) {
-      await this.client.del(...Array.from(keysToDelete));
-    }
-    await this.client.del(...tagKeys);
-  }
-  async ttl(key) {
-    const normalized = normalizeCacheKey(key);
-    const result = await this.client.ttl(normalized);
-    return result < 0 ? null : result;
-  }
-  lock(name, seconds = 10) {
-    const lockKey = `lock:${normalizeCacheKey(name)}`;
-    const owner = crypto.randomUUID();
-    const ttlMs = Math.max(1, seconds) * 1000;
-    const client = this.client;
-    return {
-      async acquire() {
-        const result = await client.set(lockKey, owner, { nx: true, px: ttlMs });
-        return result === "OK";
-      },
-      async release() {
-        const luaScript = `
-          local current = redis.call('GET', KEYS[1])
-          if current == ARGV[1] then
-            return redis.call('DEL', KEYS[1])
-          else
-            return 0
-          end
-        `;
-        const evalClient = client;
-        await evalClient.eval(luaScript, 1, lockKey, owner);
-      },
-      async extend(extensionSeconds) {
-        const luaScript = `
-          local current = redis.call('GET', KEYS[1])
-          if current == ARGV[1] then
-            return redis.call('EXPIRE', KEYS[1], ARGV[2])
-          else
-            return 0
-          end
-        `;
-        const evalClient = client;
-        const result = await evalClient.eval(luaScript, 1, lockKey, owner, extensionSeconds.toString());
-        return result === 1;
-      },
-      async getRemainingTime() {
-        return await client.ttl(lockKey);
-      },
-      async block(secondsToWait, callback, options) {
-        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) * 1000;
-        let attempt = 0;
-        while (Date.now() <= deadline && attempt < maxRetries) {
-          if (signal?.aborted) {
-            throw new Error(`Lock acquisition for '${name}' was aborted`);
-          }
-          if (await this.acquire()) {
-            try {
-              return await callback();
-            } finally {
-              await this.release();
-            }
-          }
-          attempt++;
-          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.`);
-      }
-    };
-  }
-}
-
-// src/stores/TieredStore.ts
-class TieredStore {
-  local;
-  remote;
-  constructor(local, remote) {
-    this.local = local;
-    this.remote = remote;
-  }
-  async get(key) {
-    const localValue = await this.local.get(key);
-    if (localValue !== null) {
-      return localValue;
-    }
-    const remoteValue = await this.remote.get(key);
-    if (remoteValue !== null) {
-      const ttl = this.remote.ttl ? await this.remote.ttl(key) : null;
-      await this.local.put(key, remoteValue, ttl);
-    }
-    return remoteValue;
-  }
-  async put(key, value, ttl) {
-    await Promise.all([this.local.put(key, value, ttl), this.remote.put(key, value, ttl)]);
-  }
-  async add(key, value, ttl) {
-    const ok = await this.remote.add(key, value, ttl);
-    if (ok) {
-      await this.local.put(key, value, ttl);
-    }
-    return ok;
-  }
-  async forget(key) {
-    const [localOk, remoteOk] = await Promise.all([this.local.forget(key), this.remote.forget(key)]);
-    return localOk || remoteOk;
-  }
-  async flush() {
-    await Promise.all([this.local.flush(), this.remote.flush()]);
-  }
-  async increment(key, value = 1) {
-    const next = await this.remote.increment(key, value);
-    const ttl = this.remote.ttl ? await this.remote.ttl(key) : null;
-    await this.local.put(key, next, ttl);
-    return next;
-  }
-  async decrement(key, value = 1) {
-    return this.increment(key, -value);
-  }
-  async ttl(key) {
-    if (this.remote.ttl) {
-      return this.remote.ttl(key);
-    }
-    return this.local.ttl ? this.local.ttl(key) : null;
-  }
-}
-
-// src/index.ts
-class MemoryCacheProvider {
-  store = new MemoryStore;
-  async get(key) {
-    return this.store.get(key);
-  }
-  async set(key, value, ttl = 60) {
-    await this.store.put(key, value, ttl);
-  }
-  async delete(key) {
-    await this.store.forget(key);
-  }
-  async clear() {
-    await this.store.flush();
-  }
-}
-function resolveStoreConfig(core, options) {
-  if (options) {
-    return options;
-  }
-  if (core.config.has("cache")) {
-    return core.config.get("cache");
-  }
-  return {};
-}
-function createStoreFactory(config) {
-  const stores = config.stores ?? {};
-  const defaultSeconds = typeof config.defaultTtl === "number" ? config.defaultTtl : 60;
-  return (name) => {
-    const storeConfig = stores[name];
-    const hasExplicitStores = Object.keys(stores).length > 0;
-    if (!storeConfig) {
-      if (name === "memory") {
-        return new MemoryStore;
-      }
-      if (name === "null") {
-        return new NullStore;
-      }
-      if (hasExplicitStores) {
-        throw new Error(`Cache store '${name}' is not defined.`);
-      }
-      return new MemoryStore;
-    }
-    if (storeConfig.driver === "memory") {
-      return new MemoryStore({ maxItems: storeConfig.maxItems });
-    }
-    if (storeConfig.driver === "file") {
-      return new FileStore({ directory: storeConfig.directory });
-    }
-    if (storeConfig.driver === "redis") {
-      return new RedisStore({ connection: storeConfig.connection, prefix: storeConfig.prefix });
-    }
-    if (storeConfig.driver === "null") {
-      return new NullStore;
-    }
-    if (storeConfig.driver === "custom") {
-      return storeConfig.store;
-    }
-    if (storeConfig.driver === "provider") {
-      const provider = storeConfig.provider;
-      if (!provider) {
-        throw new Error(`Cache store '${name}' is missing a provider.`);
-      }
-      return {
-        get: (key) => provider.get(key),
-        put: (key, value, ttl) => provider.set(key, value, typeof ttl === "number" ? ttl : defaultSeconds),
-        add: async (key, value, ttl) => {
-          const existing = await provider.get(key);
-          if (existing !== null) {
-            return false;
-          }
-          await provider.set(key, value, typeof ttl === "number" ? ttl : defaultSeconds);
-          return true;
-        },
-        forget: async (key) => {
-          await provider.delete(key);
-          return true;
-        },
-        flush: () => provider.clear(),
-        increment: async (key, value = 1) => {
-          const current = await provider.get(key);
-          const next = (current ?? 0) + value;
-          await provider.set(key, next, defaultSeconds);
-          return next;
-        },
-        decrement: async (key, value = 1) => {
-          const current = await provider.get(key);
-          const next = (current ?? 0) - value;
-          await provider.set(key, next, defaultSeconds);
-          return next;
-        }
-      };
-    }
-    if (storeConfig.driver === "tiered") {
-      const factory = createStoreFactory(config);
-      return new TieredStore(factory(storeConfig.local), factory(storeConfig.remote));
-    }
-    if (storeConfig.driver === "predictive") {
-      const factory = createStoreFactory(config);
-      return new PredictiveStore(factory(storeConfig.inner), {
-        predictor: new MarkovPredictor({ maxNodes: storeConfig.maxNodes })
-      });
-    }
-    if (storeConfig.driver === "circuit-breaker") {
-      const factory = createStoreFactory(config);
-      const primary = factory(storeConfig.primary);
-      const fallback = storeConfig.fallback ? factory(storeConfig.fallback) : undefined;
-      return new CircuitBreakerStore(primary, {
-        maxFailures: storeConfig.maxFailures,
-        resetTimeout: storeConfig.resetTimeout,
-        fallback
-      });
-    }
-    throw new Error(`Unsupported cache driver '${storeConfig.driver}'.`);
-  };
-}
-
-class OrbitStasis {
-  options;
-  manager;
-  constructor(options) {
-    this.options = options;
-  }
-  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 : undefined) ?? 60;
-    const prefix = resolvedConfig.prefix ?? "";
-    const logger = core.logger;
-    logger.info(`[OrbitCache] Initializing Cache (Exposed as: ${exposeAs})`);
-    const events = {
-      hit: (key) => core.hooks.doAction("cache:hit", { key }),
-      miss: (key) => core.hooks.doAction("cache:miss", { key }),
-      write: (key) => core.hooks.doAction("cache:write", { key }),
-      forget: (key) => core.hooks.doAction("cache:forget", { key }),
-      flush: () => core.hooks.doAction("cache:flush", {})
-    };
-    const onEventError = resolvedConfig.onEventError ?? ((error, event, payload) => {
-      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 } } : 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);
-      return await next();
-    });
-    core.container.instance(exposeAs, manager);
-    core.hooks.doAction("cache:init", manager);
-  }
-  getCache() {
-    if (!this.manager) {
-      throw new Error("OrbitCache not installed yet.");
-    }
-    return this.manager;
-  }
-}
-function orbitCache(core, options = {}) {
-  const orbit = new OrbitStasis(options);
-  orbit.install(core);
-  return orbit.getCache();
-}
-var OrbitCache = OrbitStasis;
-
-//# debugId=66831AF7E477960E64756E2164756E21