safe-memory-layer 1.0.0

package/dist/index.js

@@ -0,0 +1,938 @@
+// src/utils/timer.ts
+function createTimer(fn, delay) {
+  let cancelled = false;
+  let timerId;
+  const wrappedFn = () => {
+    if (cancelled) return;
+    timerId = void 0;
+    try {
+      fn();
+    } catch {
+    }
+  };
+  timerId = setTimeout(wrappedFn, delay);
+  return {
+    cancel: () => {
+      cancelled = true;
+      if (timerId !== void 0) {
+        clearTimeout(timerId);
+        timerId = void 0;
+      }
+    },
+    get cancelled() {
+      return cancelled;
+    }
+  };
+}
+function createInterval(fn, interval) {
+  let cancelled = false;
+  let timerId;
+  const wrappedFn = () => {
+    if (cancelled) return;
+    try {
+      fn();
+    } catch {
+    }
+  };
+  timerId = setInterval(wrappedFn, interval);
+  return {
+    cancel: () => {
+      cancelled = true;
+      if (timerId !== void 0) {
+        clearInterval(timerId);
+        timerId = void 0;
+      }
+    },
+    get cancelled() {
+      return cancelled;
+    }
+  };
+}
+
+// src/Scheduler.ts
+var Scheduler = class {
+  /** The cleanup interval timer handle. */
+  #timer = null;
+  /** The interval in milliseconds between cleanup runs. */
+  #interval;
+  /** The cleanup function to call on each interval. */
+  #cleanupFn;
+  /** The onEmpty callback, called when cleanup finds the store empty. */
+  #onEmpty;
+  /** Whether the scheduler is currently running. */
+  #running = false;
+  /**
+   * Creates a new Scheduler.
+   *
+   * @param cleanupFn - Function to call for cleanup. Should return count of removed entries.
+   * @param interval - Interval in milliseconds between cleanup runs.
+   * @param onEmpty - Optional callback when cleanup finds the store empty.
+   */
+  constructor(cleanupFn, interval, onEmpty) {
+    this.#cleanupFn = cleanupFn;
+    this.#interval = interval;
+    this.#onEmpty = onEmpty;
+  }
+  /**
+   * Starts the scheduler if it's not already running.
+   * Does nothing if already started.
+   */
+  start() {
+    if (this.#running || this.#timer !== null) return;
+    this.#running = true;
+    this.#timer = createInterval(() => {
+      this.#tick();
+    }, this.#interval);
+  }
+  /**
+   * Stops the scheduler if running.
+   * Safe to call multiple times.
+   */
+  stop() {
+    this.#running = false;
+    if (this.#timer !== null) {
+      this.#timer.cancel();
+      this.#timer = null;
+    }
+  }
+  /**
+   * Restarts the scheduler (stops then starts).
+   */
+  restart() {
+    this.stop();
+    this.start();
+  }
+  /**
+   * Whether the scheduler is currently running.
+   */
+  get running() {
+    return this.#running;
+  }
+  /**
+   * Performs a single cleanup tick.
+   * Stops the scheduler if the store is empty.
+   */
+  #tick() {
+    const removed = this.#cleanupFn();
+    if (removed === 0) {
+      this.stop();
+      this.#onEmpty?.();
+    }
+  }
+  /**
+   * Disposes the scheduler, stopping it and releasing all references.
+   */
+  dispose() {
+    this.stop();
+  }
+};
+
+// src/Entry.ts
+function createEntry(key, value, options = {}, now = Date.now()) {
+  const ttl = options.ttl;
+  const expiresAt = ttl !== void 0 ? now + ttl : void 0;
+  return {
+    value,
+    key,
+    expiresAt,
+    lastAccessed: now,
+    createdAt: now
+  };
+}
+function isExpired(entry, now = Date.now()) {
+  return entry.expiresAt !== void 0 && now >= entry.expiresAt;
+}
+var lruCounter = 0;
+function touchEntry(entry, now = Date.now()) {
+  entry.lastAccessed = now * 1e4 + lruCounter++ % 1e4;
+}
+function getRemainingTTL(entry, now = Date.now()) {
+  if (entry.expiresAt === void 0) return void 0;
+  const remaining = entry.expiresAt - now;
+  return remaining > 0 ? remaining : 0;
+}
+
+// src/Stats.ts
+var Stats = class {
+  /** Total number of entries that have expired. */
+  #expired = 0;
+  /** Total number of entries that have been deleted. */
+  #deleted = 0;
+  /** Total number of cleanup cycles completed. */
+  #cleaned = 0;
+  /** Timestamp when the store was created. */
+  #createdAt;
+  /** Current number of entries in the store. */
+  #entries = 0;
+  /**
+   * Creates a new Stats instance.
+   *
+   * @param createdAt - Timestamp when the store was created.
+   */
+  constructor(createdAt) {
+    this.#createdAt = createdAt;
+  }
+  /**
+   * Increments the expired counter.
+   */
+  incrementExpired() {
+    this.#expired++;
+  }
+  /**
+   * Increments the deleted counter.
+   */
+  incrementDeleted() {
+    this.#deleted++;
+  }
+  /**
+   * Increments the cleaned counter.
+   */
+  incrementCleaned() {
+    this.#cleaned++;
+  }
+  /**
+   * Sets the current number of entries.
+   *
+   * @param count - The current entry count.
+   */
+  setEntries(count) {
+    this.#entries = count;
+  }
+  /**
+   * Returns the current statistics snapshot.
+   *
+   * @param currentEntries - Current number of entries (overrides internal count).
+   * @returns A snapshot of the current statistics.
+   */
+  snapshot(currentEntries) {
+    const uptime = Date.now() - this.#createdAt;
+    const entries = currentEntries ?? this.#entries;
+    return {
+      entries,
+      expired: this.#expired,
+      deleted: this.#deleted,
+      cleaned: this.#cleaned,
+      uptime,
+      memoryEstimate: this.estimateMemory(entries)
+    };
+  }
+  /**
+   * Creates a cleanup stats object.
+   *
+   * @param removed - Number of entries removed.
+   * @param totalBefore - Total entries before cleanup.
+   * @param totalAfter - Total entries after cleanup.
+   * @param duration - Duration of cleanup in ms.
+   * @returns A CleanupStats object.
+   */
+  createCleanupStats(removed, totalBefore, totalAfter, duration) {
+    return {
+      removed,
+      totalBefore,
+      totalAfter,
+      duration
+    };
+  }
+  /**
+   * Estimates memory usage based on entry count.
+   * This is a rough approximation for monitoring purposes.
+   *
+   * @param entryCount - Number of entries.
+   * @returns Estimated memory usage in bytes.
+   */
+  estimateMemory(entryCount) {
+    return entryCount * 200;
+  }
+  /**
+   * Resets all statistics.
+   */
+  reset() {
+    this.#expired = 0;
+    this.#deleted = 0;
+    this.#cleaned = 0;
+    this.#entries = 0;
+  }
+};
+
+// src/Events.ts
+var EventEmitter = class {
+  /** Registered event listeners. */
+  #listeners = {};
+  /**
+   * Registers a listener for the expire event.
+   *
+   * @param callback - Function to call when an entry expires.
+   */
+  onExpire(callback) {
+    this.#listeners.expire ??= [];
+    this.#listeners.expire.push(callback);
+  }
+  /**
+   * Registers a listener for the delete event.
+   *
+   * @param callback - Function to call when an entry is deleted.
+   */
+  onDelete(callback) {
+    this.#listeners.delete ??= [];
+    this.#listeners.delete.push(callback);
+  }
+  /**
+   * Registers a listener for the cleanup event.
+   *
+   * @param callback - Function to call after cleanup completes.
+   */
+  onCleanup(callback) {
+    this.#listeners.cleanup ??= [];
+    this.#listeners.cleanup.push(callback);
+  }
+  /**
+   * Emits an expire event to all registered listeners.
+   * Errors in callbacks are isolated and logged.
+   *
+   * @param key - The key of the expired entry.
+   * @param value - The value of the expired entry.
+   */
+  emitExpire(key, value) {
+    const listeners = this.#listeners.expire;
+    if (listeners === void 0 || listeners.length === 0) return;
+    for (const callback of listeners) {
+      try {
+        callback(key, value);
+      } catch {
+      }
+    }
+  }
+  /**
+   * Emits a delete event to all registered listeners.
+   * Errors in callbacks are isolated and logged.
+   *
+   * @param key - The key of the deleted entry.
+   * @param value - The value of the deleted entry.
+   */
+  emitDelete(key, value) {
+    const listeners = this.#listeners.delete;
+    if (listeners === void 0 || listeners.length === 0) return;
+    for (const callback of listeners) {
+      try {
+        callback(key, value);
+      } catch {
+      }
+    }
+  }
+  /**
+   * Emits a cleanup event to all registered listeners.
+   * Errors in callbacks are isolated and logged.
+   *
+   * @param stats - The cleanup statistics.
+   */
+  emitCleanup(stats) {
+    const listeners = this.#listeners.cleanup;
+    if (listeners === void 0 || listeners.length === 0) return;
+    for (const callback of listeners) {
+      try {
+        callback(stats);
+      } catch {
+      }
+    }
+  }
+  /**
+   * Removes all event listeners.
+   */
+  removeAllListeners() {
+    this.#listeners = {};
+  }
+  /**
+   * Disposes the event emitter, removing all listeners.
+   */
+  dispose() {
+    this.removeAllListeners();
+  }
+};
+
+// src/utils/featureDetection.ts
+function detectFeatures() {
+  return {
+    finalizationRegistry: typeof globalThis.FinalizationRegistry !== "undefined"
+  };
+}
+var cachedFeatures;
+function getFeatures() {
+  if (cachedFeatures === void 0) {
+    cachedFeatures = detectFeatures();
+  }
+  return cachedFeatures;
+}
+function createSafeFinalizationRegistry(cleanup) {
+  const features = getFeatures();
+  if (features.finalizationRegistry) {
+    try {
+      return new FinalizationRegistry(cleanup);
+    } catch {
+      return null;
+    }
+  }
+  return null;
+}
+
+// src/MemoryStore.ts
+var DEFAULT_CLEANUP_INTERVAL = 1e4;
+var DEFAULT_AUTO_DISPOSE_DELAY = 6e4;
+var MemoryStore = class {
+  /** Internal map of entries. */
+  #map = /* @__PURE__ */ new Map();
+  /** Store configuration options. */
+  #options;
+  /** Statistics tracker. */
+  #stats;
+  /** Event emitter for store events. */
+  #events;
+  /** Cleanup scheduler. */
+  #scheduler;
+  /** Auto-dispose timer handle. */
+  #autoDisposeTimer = null;
+  /** Whether the store has been disposed. */
+  #disposed = false;
+  /** Timestamp when the store was created. */
+  #createdAt;
+  /** Timestamp when the store became empty (for auto-dispose). */
+  #emptySince = null;
+  // Used for auto-dispose timing
+  /**
+   * Creates a new MemoryStore instance.
+   *
+   * @param options - Configuration options for the store.
+   *
+   * @example
+   * ```ts
+   * const store = new MemoryStore({
+   *   defaultTTL: 60000,
+   *   cleanupInterval: 5000,
+   *   autoCleanup: true,
+   *   maxEntries: 1000,
+   *   maxEntriesStrategy: "LRU"
+   * });
+   * ```
+   */
+  constructor(options = {}) {
+    const opts = options;
+    this.#options = {
+      defaultTTL: opts.defaultTTL,
+      cleanupInterval: opts.cleanupInterval ?? DEFAULT_CLEANUP_INTERVAL,
+      autoCleanup: opts.autoCleanup ?? true,
+      autoDispose: opts.autoDispose ?? false,
+      autoDisposeDelay: opts.autoDisposeDelay ?? DEFAULT_AUTO_DISPOSE_DELAY,
+      maxEntries: opts.maxEntries,
+      maxEntriesStrategy: opts.maxEntriesStrategy ?? "reject",
+      onExpire: opts.onExpire,
+      onDelete: opts.onDelete,
+      onCleanup: opts.onCleanup
+    };
+    this.#createdAt = Date.now();
+    this.#stats = new Stats(this.#createdAt);
+    this.#events = new EventEmitter();
+    if (this.#options.onExpire !== void 0) {
+      this.#events.onExpire(this.#options.onExpire);
+    }
+    if (this.#options.onDelete !== void 0) {
+      this.#events.onDelete(this.#options.onDelete);
+    }
+    if (this.#options.onCleanup !== void 0) {
+      this.#events.onCleanup(this.#options.onCleanup);
+    }
+    this.#scheduler = new Scheduler(
+      () => this.#runCleanup(),
+      this.#options.cleanupInterval,
+      () => this.#onSchedulerEmpty()
+    );
+    if (this.#options.autoCleanup) {
+      this.#scheduler.start();
+    }
+    this.#setupFinalizationRegistry();
+  }
+  /**
+   * Sets up FinalizationRegistry for weak reference tracking.
+   * This is used only for monitoring, not for core functionality.
+   */
+  #setupFinalizationRegistry() {
+    const registry = createSafeFinalizationRegistry(() => {
+    });
+    if (registry !== null) {
+      this._registry = registry;
+    }
+  }
+  /**
+   * Stores a value with the given key.
+   *
+   * @param key - The key to store the value under.
+   * @param value - The value to store.
+   * @param options - Optional settings (e.g., TTL).
+   * @returns True if the value was stored, false if rejected (e.g., max entries reached).
+   *
+   * @example
+   * ```ts
+   * store.set("token", token, { ttl: 60000 });
+   * ```
+   */
+  set(key, value, options = {}) {
+    this.#checkDisposed();
+    this.#clearAutoDisposeTimer();
+    if (this.#options.maxEntries !== void 0 && !this.#map.has(key)) {
+      if (this.#map.size >= this.#options.maxEntries) {
+        const strategy = this.#options.maxEntriesStrategy;
+        if (strategy === "reject") {
+          return false;
+        }
+        if (strategy === "FIFO") {
+          const firstKey = this.#map.keys().next().value;
+          if (firstKey !== void 0) {
+            this.delete(firstKey);
+          }
+        } else if (strategy === "LRU") {
+          let lruKey;
+          let lruTime = Infinity;
+          for (const [k, entry2] of this.#map) {
+            if (entry2.lastAccessed < lruTime) {
+              lruTime = entry2.lastAccessed;
+              lruKey = k;
+            }
+          }
+          if (lruKey !== void 0) {
+            this.delete(lruKey);
+          }
+        }
+      }
+    }
+    const now = Date.now();
+    const ttl = options.ttl ?? this.#options.defaultTTL;
+    const entry = createEntry(
+      key,
+      value,
+      ttl !== void 0 ? { ttl } : {},
+      now
+    );
+    this.#map.set(key, entry);
+    if (!this.#scheduler.running) {
+      this.#scheduler.start();
+    }
+    return true;
+  }
+  /**
+   * Retrieves a value by key.
+   *
+   * @param key - The key to look up.
+   * @returns The value if found and not expired, undefined otherwise.
+   *
+   * @example
+   * ```ts
+   * const user = store.get("user:123");
+   * ```
+   */
+  get(key) {
+    this.#checkDisposed();
+    const entry = this.#map.get(key);
+    if (entry === void 0) return void 0;
+    if (isExpired(entry)) {
+      this.#map.delete(key);
+      this.#stats.incrementExpired();
+      this.#events.emitExpire(entry.key, entry.value);
+      return void 0;
+    }
+    touchEntry(entry);
+    return entry.value;
+  }
+  /**
+   * Checks if a key exists in the store and is not expired.
+   *
+   * @param key - The key to check.
+   * @returns True if the key exists and is not expired.
+   */
+  has(key) {
+    this.#checkDisposed();
+    const entry = this.#map.get(key);
+    if (entry === void 0) return false;
+    if (isExpired(entry)) {
+      this.#map.delete(key);
+      this.#stats.incrementExpired();
+      this.#events.emitExpire(entry.key, entry.value);
+      return false;
+    }
+    return true;
+  }
+  /**
+   * Deletes a value by key.
+   *
+   * @param key - The key to delete.
+   * @returns True if the key was present, false otherwise.
+   */
+  delete(key) {
+    this.#checkDisposed();
+    const entry = this.#map.get(key);
+    if (entry === void 0) return false;
+    this.#map.delete(key);
+    this.#stats.incrementDeleted();
+    this.#events.emitDelete(entry.key, entry.value);
+    if (this.#map.size === 0) {
+      this.#onEmpty();
+    }
+    return true;
+  }
+  /**
+   * Removes all entries from the store.
+   */
+  clear() {
+    this.#checkDisposed();
+    for (const entry of this.#map.values()) {
+      this.#events.emitDelete(entry.key, entry.value);
+      this.#stats.incrementDeleted();
+    }
+    this.#map.clear();
+    this.#onEmpty();
+  }
+  /**
+   * Returns the number of entries in the store.
+   * Excludes expired entries.
+   */
+  get size() {
+    if (this.#disposed) return 0;
+    let count = 0;
+    const now = Date.now();
+    for (const entry of this.#map.values()) {
+      if (!isExpired(entry, now)) {
+        count++;
+      }
+    }
+    return count;
+  }
+  /**
+   * Returns an iterator of all keys.
+   */
+  keys() {
+    this.#checkDisposed();
+    return this.#map.keys();
+  }
+  /**
+   * Returns an iterator of all values.
+   */
+  values() {
+    this.#checkDisposed();
+    return this.#getNonExpiredValues();
+  }
+  /**
+   * Returns an iterator of all [key, value] pairs.
+   */
+  entries() {
+    this.#checkDisposed();
+    return this.#getNonExpiredEntries();
+  }
+  /**
+   * Returns an iterator for the store (for...of support).
+   */
+  [Symbol.iterator]() {
+    return this.entries();
+  }
+  /**
+   * Returns an iterator of non-expired values.
+   */
+  *#getNonExpiredValues() {
+    const now = Date.now();
+    for (const entry of this.#map.values()) {
+      if (!isExpired(entry, now)) {
+        yield entry.value;
+      }
+    }
+  }
+  /**
+   * Returns an iterator of non-expired entries.
+   */
+  *#getNonExpiredEntries() {
+    const now = Date.now();
+    for (const entry of this.#map.values()) {
+      if (!isExpired(entry, now)) {
+        yield [entry.key, entry.value];
+      }
+    }
+  }
+  /**
+   * Runs a cleanup cycle, removing all expired entries.
+   *
+   * @returns The number of entries removed.
+   */
+  cleanup() {
+    this.#checkDisposed();
+    return this.#runCleanup();
+  }
+  /**
+   * Runs the cleanup cycle.
+   * This is called by the scheduler and can be called manually.
+   *
+   * @returns The number of entries removed.
+   */
+  #runCleanup() {
+    const startTime = Date.now();
+    const totalBefore = this.#map.size;
+    let removed = 0;
+    const now = Date.now();
+    for (const [entryKey, entry] of this.#map) {
+      if (isExpired(entry, now)) {
+        this.#map.delete(entryKey);
+        this.#stats.incrementExpired();
+        this.#events.emitExpire(entry.key, entry.value);
+        removed++;
+      }
+    }
+    if (this.#map.size === 0 && this.#emptySince !== null) ;
+    const totalAfter = this.#map.size;
+    const duration = Date.now() - startTime;
+    this.#stats.incrementCleaned();
+    const cleanupStats = this.#stats.createCleanupStats(
+      removed,
+      totalBefore,
+      totalAfter,
+      duration
+    );
+    this.#events.emitCleanup(cleanupStats);
+    if (this.#map.size === 0) {
+      this.#onEmpty();
+    }
+    return removed;
+  }
+  /**
+   * Compacts the store by removing expired entries.
+   * Alias for cleanup().
+   */
+  compact() {
+    return this.cleanup();
+  }
+  /**
+   * Returns statistics about the store.
+   *
+   * @returns A snapshot of the current statistics.
+   */
+  stats() {
+    this.#checkDisposed();
+    return this.#stats.snapshot(this.#map.size);
+  }
+  /**
+   * Disposes the store, stopping all timers and releasing references.
+   * After disposal, the store cannot be used.
+   */
+  dispose() {
+    if (this.#disposed) return;
+    this.#disposed = true;
+    this.#scheduler.dispose();
+    this.#clearAutoDisposeTimer();
+    this.#map.clear();
+    this.#events.dispose();
+    delete this._registry;
+  }
+  /**
+   * Checks if the store has been disposed.
+   */
+  get disposed() {
+    return this.#disposed;
+  }
+  /**
+   * Called when the store becomes empty.
+   */
+  #onEmpty() {
+    this.#emptySince = Date.now();
+    if (this.#options.autoDispose) {
+      this.#startAutoDisposeTimer();
+    }
+  }
+  /**
+   * Starts the auto-dispose timer.
+   */
+  #startAutoDisposeTimer() {
+    this.#clearAutoDisposeTimer();
+    this.#autoDisposeTimer = createTimer(() => {
+      if (this.#map.size === 0 && !this.#disposed) {
+        this.dispose();
+      }
+    }, this.#options.autoDisposeDelay);
+  }
+  /**
+   * Clears the auto-dispose timer.
+   */
+  #clearAutoDisposeTimer() {
+    if (this.#autoDisposeTimer !== null) {
+      this.#autoDisposeTimer.cancel();
+      this.#autoDisposeTimer = null;
+    }
+    this.#emptySince = null;
+  }
+  /**
+   * Called when the scheduler finds the store empty.
+   */
+  #onSchedulerEmpty() {
+  }
+  /**
+   * Checks if the store has been disposed and throws if so.
+   */
+  #checkDisposed() {
+    if (this.#disposed) {
+      throw new Error("MemoryStore has been disposed");
+    }
+  }
+};
+
+// src/WeakMemoryStore.ts
+var WeakMemoryStore = class {
+  /** Internal WeakMap for storage. */
+  #map = /* @__PURE__ */ new WeakMap();
+  /** Store configuration options. */
+  #options;
+  /** Statistics tracker. */
+  #deleted = 0;
+  /** Timestamp when the store was created. */
+  #createdAt;
+  /** Whether the store has been disposed. */
+  #disposed = false;
+  /**
+   * Creates a new WeakMemoryStore instance.
+   *
+   * @param options - Configuration options for the store.
+   *
+   * @example
+   * ```ts
+   * const store = new WeakMemoryStore({
+   *   onDelete: (value) => console.log("Deleted:", value)
+   * });
+   * ```
+   */
+  constructor(options = {}) {
+    this.#options = options;
+    this.#createdAt = Date.now();
+  }
+  /**
+   * Stores a value with the given object key.
+   *
+   * @param key - The object key to store the value under. Must be an object.
+   * @param value - The value to store.
+   * @returns True if the value was stored.
+   *
+   * @example
+   * ```ts
+   * const obj = { id: 1 };
+   * weakStore.set(obj, { name: "Alice" });
+   * ```
+   */
+  set(key, value) {
+    this.#checkDisposed();
+    if (typeof key !== "object" || key === null) {
+      throw new TypeError("WeakMemoryStore keys must be objects");
+    }
+    this.#map.set(key, value);
+    return true;
+  }
+  /**
+   * Retrieves a value by object key.
+   *
+   * @param key - The object key to look up.
+   * @returns The value if found, undefined otherwise.
+   *
+   * @example
+   * ```ts
+   * const user = weakStore.get(obj);
+   * ```
+   */
+  get(key) {
+    this.#checkDisposed();
+    if (typeof key !== "object" || key === null) {
+      return void 0;
+    }
+    return this.#map.get(key);
+  }
+  /**
+   * Checks if a key exists in the store.
+   *
+   * @param key - The object key to check.
+   * @returns True if the key exists.
+   */
+  has(key) {
+    this.#checkDisposed();
+    if (typeof key !== "object" || key === null) {
+      return false;
+    }
+    return this.#map.has(key);
+  }
+  /**
+   * Deletes a value by object key.
+   *
+   * @param key - The object key to delete.
+   * @returns True if the key was present, false otherwise.
+   */
+  delete(key) {
+    this.#checkDisposed();
+    if (typeof key !== "object" || key === null) {
+      return false;
+    }
+    const value = this.#map.get(key);
+    if (value === void 0) return false;
+    this.#map.delete(key);
+    this.#deleted++;
+    if (this.#options.onDelete !== void 0) {
+      try {
+        this.#options.onDelete(value);
+      } catch {
+      }
+    }
+    return true;
+  }
+  /**
+   * Removes all entries from the store.
+   * Note: This does not prevent garbage collection of the keys.
+   */
+  clear() {
+    this.#checkDisposed();
+    this.#map = /* @__PURE__ */ new WeakMap();
+    this.#deleted++;
+  }
+  /**
+   * Returns the number of deleted entries.
+   * Note: Cannot return current size (WeakMap limitation).
+   */
+  get deleted() {
+    return this.#deleted;
+  }
+  /**
+   * Returns statistics about the store.
+   * Note: entries count is not available for WeakMap.
+   *
+   * @returns A snapshot of the current statistics.
+   */
+  stats() {
+    this.#checkDisposed();
+    return {
+      deleted: this.#deleted,
+      uptime: Date.now() - this.#createdAt
+    };
+  }
+  /**
+   * Disposes the store, releasing the WeakMap reference.
+   * After disposal, the store cannot be used.
+   */
+  dispose() {
+    if (this.#disposed) return;
+    this.#disposed = true;
+    this.#map = /* @__PURE__ */ new WeakMap();
+  }
+  /**
+   * Checks if the store has been disposed.
+   */
+  get disposed() {
+    return this.#disposed;
+  }
+  /**
+   * Checks if the store has been disposed and throws if so.
+   */
+  #checkDisposed() {
+    if (this.#disposed) {
+      throw new Error("WeakMemoryStore has been disposed");
+    }
+  }
+};
+
+export { EventEmitter, MemoryStore, Scheduler, Stats, WeakMemoryStore, createEntry, createInterval, createSafeFinalizationRegistry, createTimer, detectFeatures, getFeatures, getRemainingTTL, isExpired, touchEntry };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map