actly 1.2.0 → 1.3.0

package/dist/stores/memory.cjs

@@ -6,47 +6,55 @@ const limits_js_1 = require("../utils/limits.js");
 function isUnrefable(t) {
     return typeof t.unref === 'function';
 }
-// ─── Implementation ───────────────────────────────────────────────────────────
-/**
- * Reference `SyncStateStore` implementation backed by a `Map` + doubly-linked
- * list for LRU.
- *
- * # Properties
- *
- *  - `size()` is O(1) — tracked via a counter instead of full scan.
- *  - LRU reordering uses an explicit doubly-linked list, avoiding the
- *    `delete + set` Map churn that was 2 Map operations per `get()`.
- *  - Default `maxSize` is bounded (`LIMITS.DEFAULT_STORE_MAX_SIZE`) when
- *    used as the module-level default — prevents unbounded memory growth
- *    in long-running servers.
- *
- * # Expiry
- *
- * Lazy on `get()` / `has()`: expired entries are deleted when touched.
- * Background sweep (optional) reclaims entries that are never re-read.
- */
 class InMemoryStore {
     _sync = true;
+    static finalizer;
+    static {
+        if (typeof FinalizationRegistry === 'function') {
+            InMemoryStore.finalizer = new FinalizationRegistry((timer) => {
+                try {
+                    clearInterval(timer);
+                }
+                catch { }
+            });
+        }
+    }
     map = new Map();
     maxSize;
-    head; // least recently used
-    tail; // most recently used
+    head;
+    tail;
     cleanupTimer;
+    memoryListener;
     constructor(options = {}) {
-        const { autoCleanup = false, cleanupIntervalMs = 30_000, maxSize = Number.POSITIVE_INFINITY, } = options;
+        const { autoCleanup = false, cleanupIntervalMs = 30_000, maxSize = limits_js_1.LIMITS.DEFAULT_STORE_MAX_SIZE, memoryPressureCleanup = false, } = options;
         if (!Number.isFinite(maxSize) || maxSize <= 0) {
-            // Infinity is allowed (unbounded); any other non-positive finite value
-            // is a programmer error.
             if (maxSize !== Number.POSITIVE_INFINITY) {
                 throw new RangeError(`Actly: InMemoryStore maxSize must be a positive finite number or Infinity, got ${maxSize}`);
             }
         }
+        if (maxSize !== Number.POSITIVE_INFINITY && !Number.isInteger(maxSize)) {
+            throw new RangeError(`Actly: InMemoryStore maxSize must be a positive integer or Infinity, got ${maxSize}`);
+        }
         this.maxSize = maxSize;
         if (autoCleanup) {
-            const timer = setInterval(() => this._sweep(), cleanupIntervalMs);
+            const timer = setInterval(() => this.sweep(), cleanupIntervalMs);
             if (isUnrefable(timer))
                 timer.unref();
             this.cleanupTimer = timer;
+            InMemoryStore.finalizer?.register(this, timer, this);
+        }
+        if (memoryPressureCleanup) {
+            const processOn = process.on;
+            if (typeof processOn === 'function') {
+                const memoryListener = () => {
+                    try {
+                        this.sweep();
+                    }
+                    catch { }
+                };
+                processOn.call(process, 'memory', memoryListener);
+                this.memoryListener = memoryListener;
+            }
         }
     }
     get(key) {
@@ -54,55 +62,50 @@ class InMemoryStore {
         if (!node)
             return undefined;
         if (node.expiresAt !== null && Date.now() > node.expiresAt) {
-            this._removeNode(node);
+            this.removeNode(node);
             this.map.delete(key);
             return undefined;
         }
-        // LRU refresh: move to tail (most-recent).
-        this._moveToTail(node);
+        this.moveToTail(node);
         return node.value;
     }
     set(key, value, ttlMs) {
         const existing = this.map.get(key);
         const now = Date.now();
         if (existing) {
-            // Update in place — don't grow size, don't evict.
             existing.value = value;
-            existing.expiresAt = ttlMs != null && ttlMs > 0 ? now + ttlMs : null;
+            existing.expiresAt = ttlMs != null && Number.isFinite(ttlMs) && ttlMs > 0 ? now + ttlMs : null;
             existing.insertedAt = now;
-            this._moveToTail(existing);
+            this.moveToTail(existing);
             return;
         }
-        // New key — evict if at capacity.
         while (this.map.size >= this.maxSize && this.head) {
             const evict = this.head;
-            this._removeNode(evict);
+            this.removeNode(evict);
             this.map.delete(evict.key);
         }
         const node = {
             key,
             value,
-            expiresAt: ttlMs != null && ttlMs > 0 ? now + ttlMs : null,
+            expiresAt: ttlMs != null && Number.isFinite(ttlMs) && ttlMs > 0 ? now + ttlMs : null,
             insertedAt: now,
         };
         this.map.set(key, node);
-        this._appendTail(node);
+        this.appendTail(node);
     }
     delete(key) {
         const node = this.map.get(key);
         if (!node)
             return;
-        this._removeNode(node);
+        this.removeNode(node);
         this.map.delete(key);
     }
     has(key) {
-        // Inline the expiry check to avoid the LRU side-effect of get().
-        // `has()` should be a pure query, not a touch.
         const node = this.map.get(key);
         if (!node)
             return false;
         if (node.expiresAt !== null && Date.now() > node.expiresAt) {
-            this._removeNode(node);
+            this.removeNode(node);
             this.map.delete(key);
             return false;
         }
@@ -113,45 +116,38 @@ class InMemoryStore {
         this.head = undefined;
         this.tail = undefined;
     }
-    /**
-     * Return the count of live (non-expired) entries.
-     *
-     * O(1) — returns the Map size directly. Expired-but-not-yet-
-     * evicted entries are counted; they're reclaimed lazily on next access
-     * or by the background sweep. This is intentional: a fully-accurate
-     * count would require an O(n) scan, defeating the purpose.
-     *
-     * Pure query — does NOT touch LRU order.
-     */
     size() {
         return this.map.size;
     }
-    /**
-     * Stop the background cleanup timer and release internal state.
-     * Safe to call multiple times — subsequent calls are no-ops.
-     */
     destroy() {
         if (this.cleanupTimer !== undefined) {
             clearInterval(this.cleanupTimer);
             this.cleanupTimer = undefined;
+            InMemoryStore.finalizer?.unregister(this);
+        }
+        if (this.memoryListener) {
+            const processOff = process.off;
+            if (typeof processOff === 'function') {
+                processOff.call(process, 'memory', this.memoryListener);
+            }
+            this.memoryListener = undefined;
         }
+        this.map.clear();
+        this.head = undefined;
+        this.tail = undefined;
     }
-    // ─── LRU list operations ──────────────────────────────────────────────────
-    //
-    // All operations are O(1). The list runs head (LRU) → tail (MRU).
-    _appendTail(node) {
+    appendTail(node) {
         if (this.tail) {
             this.tail.next = node;
             node.prev = this.tail;
             node.next = undefined;
         }
         else {
-            // Empty list — node is both head and tail.
             this.head = node;
         }
         this.tail = node;
     }
-    _removeNode(node) {
+    removeNode(node) {
         if (node.prev) {
             node.prev.next = node.next;
         }
@@ -167,43 +163,34 @@ class InMemoryStore {
         node.prev = undefined;
         node.next = undefined;
     }
-    _moveToTail(node) {
+    moveToTail(node) {
         if (this.tail === node)
-            return; // already MRU
-        this._removeNode(node);
-        this._appendTail(node);
+            return;
+        this.removeNode(node);
+        this.appendTail(node);
     }
-    /**
-     * Sweep all entries and remove those past their expiry time.
-     * Called by the autoCleanup interval; not part of the public contract.
-     *
-     * Two-pass to avoid mutating the Map during iteration (spec-safe).
-     */
-    _sweep() {
-        const now = Date.now();
-        const expired = [];
-        for (const [key, node] of this.map) {
-            if (node.expiresAt !== null && now > node.expiresAt) {
-                expired.push(key);
+    sweep() {
+        try {
+            const now = Date.now();
+            const expired = [];
+            for (const [key, node] of this.map) {
+                if (node.expiresAt !== null && now > node.expiresAt) {
+                    expired.push(key);
+                }
             }
-        }
-        for (const key of expired) {
-            const node = this.map.get(key);
-            if (node) {
-                this._removeNode(node);
-                this.map.delete(key);
+            for (const key of expired) {
+                const node = this.map.get(key);
+                if (node) {
+                    this.removeNode(node);
+                    this.map.delete(key);
+                }
             }
         }
+        catch {
+        }
     }
 }
 exports.InMemoryStore = InMemoryStore;
-/**
- * Factory for the default module-level store.
- *
- * Bounded by `LIMITS.DEFAULT_STORE_MAX_SIZE` with background sweep —
- * prevents unbounded memory growth in long-running servers without
- * requiring callers to opt in.
- */
 function createDefaultStore() {
     return new InMemoryStore({
         maxSize: limits_js_1.LIMITS.DEFAULT_STORE_MAX_SIZE,

package/dist/stores/memory.d.ts

@@ -1,98 +1,31 @@
 import type { SyncStateStore } from './base.js';
 export interface InMemoryStoreOptions {
-    /**
-     * Periodically sweep and remove expired entries in the background.
-     *
-     * Disabled by default for explicit-store users. The DEFAULT module-level
-     * store (used when you call `act()` without `withStore()`) enables this
-     * automatically — see `core/act.ts`.
-     */
     autoCleanup?: boolean;
-    /**
-     * Interval between background sweeps in milliseconds.
-     * Defaults to 30 000 (30 seconds). Ignored when `autoCleanup` is false.
-     */
     cleanupIntervalMs?: number;
-    /**
-     * Maximum number of live entries the store will hold.
-     *
-     * When `set()` would exceed this limit, the least-recently-used entry is
-     * evicted before the new one is inserted (LRU semantics). Updates to an
-     * existing key do not trigger eviction.
-     *
-     * Defaults to `Infinity` (unbounded). Set a finite value for long-running
-     * caches with high-cardinality keys to bound memory usage.
-     *
-     * The LRU order is updated on `get()` and `set()` — both move the accessed
-     * key to the most-recent position. Implementation uses a doubly-linked
-     * list for O(1) reordering (no `delete + set` Map churn).
-     */
     maxSize?: number;
+    memoryPressureCleanup?: boolean;
 }
-/**
- * Reference `SyncStateStore` implementation backed by a `Map` + doubly-linked
- * list for LRU.
- *
- * # Properties
- *
- *  - `size()` is O(1) — tracked via a counter instead of full scan.
- *  - LRU reordering uses an explicit doubly-linked list, avoiding the
- *    `delete + set` Map churn that was 2 Map operations per `get()`.
- *  - Default `maxSize` is bounded (`LIMITS.DEFAULT_STORE_MAX_SIZE`) when
- *    used as the module-level default — prevents unbounded memory growth
- *    in long-running servers.
- *
- * # Expiry
- *
- * Lazy on `get()` / `has()`: expired entries are deleted when touched.
- * Background sweep (optional) reclaims entries that are never re-read.
- */
 export declare class InMemoryStore implements SyncStateStore {
     readonly _sync: true;
+    private static finalizer;
     private readonly map;
     private readonly maxSize;
     private head?;
     private tail?;
     private cleanupTimer;
+    private memoryListener;
     constructor(options?: InMemoryStoreOptions);
     get<T>(key: string): T | undefined;
     set<T>(key: string, value: T, ttlMs?: number): void;
     delete(key: string): void;
     has(key: string): boolean;
     clear(): void;
-    /**
-     * Return the count of live (non-expired) entries.
-     *
-     * O(1) — returns the Map size directly. Expired-but-not-yet-
-     * evicted entries are counted; they're reclaimed lazily on next access
-     * or by the background sweep. This is intentional: a fully-accurate
-     * count would require an O(n) scan, defeating the purpose.
-     *
-     * Pure query — does NOT touch LRU order.
-     */
     size(): number;
-    /**
-     * Stop the background cleanup timer and release internal state.
-     * Safe to call multiple times — subsequent calls are no-ops.
-     */
     destroy(): void;
-    private _appendTail;
-    private _removeNode;
-    private _moveToTail;
-    /**
-     * Sweep all entries and remove those past their expiry time.
-     * Called by the autoCleanup interval; not part of the public contract.
-     *
-     * Two-pass to avoid mutating the Map during iteration (spec-safe).
-     */
-    private _sweep;
+    private appendTail;
+    private removeNode;
+    private moveToTail;
+    private sweep;
 }
-/**
- * Factory for the default module-level store.
- *
- * Bounded by `LIMITS.DEFAULT_STORE_MAX_SIZE` with background sweep —
- * prevents unbounded memory growth in long-running servers without
- * requiring callers to opt in.
- */
 export declare function createDefaultStore(): InMemoryStore;
 //# sourceMappingURL=memory.d.ts.map

package/dist/stores/memory.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"memory.d.ts","sourceRoot":"","sources":["../../src/stores/memory.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,WAAW,CAAA;AAkC/C,MAAM,WAAW,oBAAoB;IACnC;;;;;;OAMG;IACH,WAAW,CAAC,EAAE,OAAO,CAAA;IAErB;;;OAGG;IACH,iBAAiB,CAAC,EAAE,MAAM,CAAA;IAE1B;;;;;;;;;;;;;OAaG;IACH,OAAO,CAAC,EAAE,MAAM,CAAA;CACjB;AAID;;;;;;;;;;;;;;;;;GAiBG;AACH,qBAAa,aAAc,YAAW,cAAc;IAClD,QAAQ,CAAC,KAAK,EAAG,IAAI,CAAS;IAE9B,OAAO,CAAC,QAAQ,CAAC,GAAG,CAA6B;IACjD,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAQ;IAChC,OAAO,CAAC,IAAI,CAAC,CAAS;IACtB,OAAO,CAAC,IAAI,CAAC,CAAS;IACtB,OAAO,CAAC,YAAY,CAA4C;gBAEpD,OAAO,GAAE,oBAAyB;IA0B9C,GAAG,CAAC,CAAC,EAAE,GAAG,EAAE,MAAM,GAAG,CAAC,GAAG,SAAS;IAgBlC,GAAG,CAAC,CAAC,EAAE,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,CAAC,EAAE,KAAK,CAAC,EAAE,MAAM,GAAG,IAAI;IA8BnD,MAAM,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI;IAOzB,GAAG,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO;IAazB,KAAK,IAAI,IAAI;IAMb;;;;;;;;;OASG;IACH,IAAI,IAAI,MAAM;IAId;;;OAGG;IACH,OAAO,IAAI,IAAI;IAWf,OAAO,CAAC,WAAW;IAYnB,OAAO,CAAC,WAAW;IAenB,OAAO,CAAC,WAAW;IAMnB;;;;;OAKG;IACH,OAAO,CAAC,MAAM;CAgBf;AAED;;;;;;GAMG;AACH,wBAAgB,kBAAkB,IAAI,aAAa,CAMlD"}
+{"version":3,"file":"memory.d.ts","sourceRoot":"","sources":["../../src/stores/memory.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,WAAW,CAAA;AAgC/C,MAAM,WAAW,oBAAoB;IAKnC,WAAW,CAAC,EAAE,OAAO,CAAA;IAGrB,iBAAiB,CAAC,EAAE,MAAM,CAAA;IAU1B,OAAO,CAAC,EAAE,MAAM,CAAA;IAQhB,qBAAqB,CAAC,EAAE,OAAO,CAAA;CAChC;AAcD,qBAAa,aAAc,YAAW,cAAc;IAClD,QAAQ,CAAC,KAAK,EAAG,IAAI,CAAS;IAS9B,OAAO,CAAC,MAAM,CAAC,SAAS,CAAkE;IAS1F,OAAO,CAAC,QAAQ,CAAC,GAAG,CAA6B;IACjD,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAQ;IAChC,OAAO,CAAC,IAAI,CAAC,CAAS;IACtB,OAAO,CAAC,IAAI,CAAC,CAAS;IACtB,OAAO,CAAC,YAAY,CAA4C;IAChE,OAAO,CAAC,cAAc,CAA4C;gBAEtD,OAAO,GAAE,oBAAyB;IAkD9C,GAAG,CAAC,CAAC,EAAE,GAAG,EAAE,MAAM,GAAG,CAAC,GAAG,SAAS;IAclC,GAAG,CAAC,CAAC,EAAE,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,CAAC,EAAE,KAAK,CAAC,EAAE,MAAM,GAAG,IAAI;IA+BnD,MAAM,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI;IAOzB,GAAG,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO;IAYzB,KAAK,IAAI,IAAI;IAYb,IAAI,IAAI,MAAM;IAUd,OAAO,IAAI,IAAI;IAyBf,OAAO,CAAC,UAAU;IAWlB,OAAO,CAAC,UAAU;IAelB,OAAO,CAAC,UAAU;IAWlB,OAAO,CAAC,KAAK;CAoBd;AAOD,wBAAgB,kBAAkB,IAAI,aAAa,CAMlD"}

package/dist/stores/memory.js

@@ -2,47 +2,55 @@ import { LIMITS } from '../utils/limits.js';
 function isUnrefable(t) {
     return typeof t.unref === 'function';
 }
-// ─── Implementation ───────────────────────────────────────────────────────────
-/**
- * Reference `SyncStateStore` implementation backed by a `Map` + doubly-linked
- * list for LRU.
- *
- * # Properties
- *
- *  - `size()` is O(1) — tracked via a counter instead of full scan.
- *  - LRU reordering uses an explicit doubly-linked list, avoiding the
- *    `delete + set` Map churn that was 2 Map operations per `get()`.
- *  - Default `maxSize` is bounded (`LIMITS.DEFAULT_STORE_MAX_SIZE`) when
- *    used as the module-level default — prevents unbounded memory growth
- *    in long-running servers.
- *
- * # Expiry
- *
- * Lazy on `get()` / `has()`: expired entries are deleted when touched.
- * Background sweep (optional) reclaims entries that are never re-read.
- */
 export class InMemoryStore {
     _sync = true;
+    static finalizer;
+    static {
+        if (typeof FinalizationRegistry === 'function') {
+            InMemoryStore.finalizer = new FinalizationRegistry((timer) => {
+                try {
+                    clearInterval(timer);
+                }
+                catch { }
+            });
+        }
+    }
     map = new Map();
     maxSize;
-    head; // least recently used
-    tail; // most recently used
+    head;
+    tail;
     cleanupTimer;
+    memoryListener;
     constructor(options = {}) {
-        const { autoCleanup = false, cleanupIntervalMs = 30_000, maxSize = Number.POSITIVE_INFINITY, } = options;
+        const { autoCleanup = false, cleanupIntervalMs = 30_000, maxSize = LIMITS.DEFAULT_STORE_MAX_SIZE, memoryPressureCleanup = false, } = options;
         if (!Number.isFinite(maxSize) || maxSize <= 0) {
-            // Infinity is allowed (unbounded); any other non-positive finite value
-            // is a programmer error.
             if (maxSize !== Number.POSITIVE_INFINITY) {
                 throw new RangeError(`Actly: InMemoryStore maxSize must be a positive finite number or Infinity, got ${maxSize}`);
             }
         }
+        if (maxSize !== Number.POSITIVE_INFINITY && !Number.isInteger(maxSize)) {
+            throw new RangeError(`Actly: InMemoryStore maxSize must be a positive integer or Infinity, got ${maxSize}`);
+        }
         this.maxSize = maxSize;
         if (autoCleanup) {
-            const timer = setInterval(() => this._sweep(), cleanupIntervalMs);
+            const timer = setInterval(() => this.sweep(), cleanupIntervalMs);
             if (isUnrefable(timer))
                 timer.unref();
             this.cleanupTimer = timer;
+            InMemoryStore.finalizer?.register(this, timer, this);
+        }
+        if (memoryPressureCleanup) {
+            const processOn = process.on;
+            if (typeof processOn === 'function') {
+                const memoryListener = () => {
+                    try {
+                        this.sweep();
+                    }
+                    catch { }
+                };
+                processOn.call(process, 'memory', memoryListener);
+                this.memoryListener = memoryListener;
+            }
         }
     }
     get(key) {
@@ -50,55 +58,50 @@ export class InMemoryStore {
         if (!node)
             return undefined;
         if (node.expiresAt !== null && Date.now() > node.expiresAt) {
-            this._removeNode(node);
+            this.removeNode(node);
             this.map.delete(key);
             return undefined;
         }
-        // LRU refresh: move to tail (most-recent).
-        this._moveToTail(node);
+        this.moveToTail(node);
         return node.value;
     }
     set(key, value, ttlMs) {
         const existing = this.map.get(key);
         const now = Date.now();
         if (existing) {
-            // Update in place — don't grow size, don't evict.
             existing.value = value;
-            existing.expiresAt = ttlMs != null && ttlMs > 0 ? now + ttlMs : null;
+            existing.expiresAt = ttlMs != null && Number.isFinite(ttlMs) && ttlMs > 0 ? now + ttlMs : null;
             existing.insertedAt = now;
-            this._moveToTail(existing);
+            this.moveToTail(existing);
             return;
         }
-        // New key — evict if at capacity.
         while (this.map.size >= this.maxSize && this.head) {
             const evict = this.head;
-            this._removeNode(evict);
+            this.removeNode(evict);
             this.map.delete(evict.key);
         }
         const node = {
             key,
             value,
-            expiresAt: ttlMs != null && ttlMs > 0 ? now + ttlMs : null,
+            expiresAt: ttlMs != null && Number.isFinite(ttlMs) && ttlMs > 0 ? now + ttlMs : null,
             insertedAt: now,
         };
         this.map.set(key, node);
-        this._appendTail(node);
+        this.appendTail(node);
     }
     delete(key) {
         const node = this.map.get(key);
         if (!node)
             return;
-        this._removeNode(node);
+        this.removeNode(node);
         this.map.delete(key);
     }
     has(key) {
-        // Inline the expiry check to avoid the LRU side-effect of get().
-        // `has()` should be a pure query, not a touch.
         const node = this.map.get(key);
         if (!node)
             return false;
         if (node.expiresAt !== null && Date.now() > node.expiresAt) {
-            this._removeNode(node);
+            this.removeNode(node);
             this.map.delete(key);
             return false;
         }
@@ -109,45 +112,38 @@ export class InMemoryStore {
         this.head = undefined;
         this.tail = undefined;
     }
-    /**
-     * Return the count of live (non-expired) entries.
-     *
-     * O(1) — returns the Map size directly. Expired-but-not-yet-
-     * evicted entries are counted; they're reclaimed lazily on next access
-     * or by the background sweep. This is intentional: a fully-accurate
-     * count would require an O(n) scan, defeating the purpose.
-     *
-     * Pure query — does NOT touch LRU order.
-     */
     size() {
         return this.map.size;
     }
-    /**
-     * Stop the background cleanup timer and release internal state.
-     * Safe to call multiple times — subsequent calls are no-ops.
-     */
     destroy() {
         if (this.cleanupTimer !== undefined) {
             clearInterval(this.cleanupTimer);
             this.cleanupTimer = undefined;
+            InMemoryStore.finalizer?.unregister(this);
+        }
+        if (this.memoryListener) {
+            const processOff = process.off;
+            if (typeof processOff === 'function') {
+                processOff.call(process, 'memory', this.memoryListener);
+            }
+            this.memoryListener = undefined;
         }
+        this.map.clear();
+        this.head = undefined;
+        this.tail = undefined;
     }
-    // ─── LRU list operations ──────────────────────────────────────────────────
-    //
-    // All operations are O(1). The list runs head (LRU) → tail (MRU).
-    _appendTail(node) {
+    appendTail(node) {
         if (this.tail) {
             this.tail.next = node;
             node.prev = this.tail;
             node.next = undefined;
         }
         else {
-            // Empty list — node is both head and tail.
             this.head = node;
         }
         this.tail = node;
     }
-    _removeNode(node) {
+    removeNode(node) {
         if (node.prev) {
             node.prev.next = node.next;
         }
@@ -163,42 +159,33 @@ export class InMemoryStore {
         node.prev = undefined;
         node.next = undefined;
     }
-    _moveToTail(node) {
+    moveToTail(node) {
         if (this.tail === node)
-            return; // already MRU
-        this._removeNode(node);
-        this._appendTail(node);
+            return;
+        this.removeNode(node);
+        this.appendTail(node);
     }
-    /**
-     * Sweep all entries and remove those past their expiry time.
-     * Called by the autoCleanup interval; not part of the public contract.
-     *
-     * Two-pass to avoid mutating the Map during iteration (spec-safe).
-     */
-    _sweep() {
-        const now = Date.now();
-        const expired = [];
-        for (const [key, node] of this.map) {
-            if (node.expiresAt !== null && now > node.expiresAt) {
-                expired.push(key);
+    sweep() {
+        try {
+            const now = Date.now();
+            const expired = [];
+            for (const [key, node] of this.map) {
+                if (node.expiresAt !== null && now > node.expiresAt) {
+                    expired.push(key);
+                }
             }
-        }
-        for (const key of expired) {
-            const node = this.map.get(key);
-            if (node) {
-                this._removeNode(node);
-                this.map.delete(key);
+            for (const key of expired) {
+                const node = this.map.get(key);
+                if (node) {
+                    this.removeNode(node);
+                    this.map.delete(key);
+                }
             }
         }
+        catch {
+        }
     }
 }
-/**
- * Factory for the default module-level store.
- *
- * Bounded by `LIMITS.DEFAULT_STORE_MAX_SIZE` with background sweep —
- * prevents unbounded memory growth in long-running servers without
- * requiring callers to opt in.
- */
 export function createDefaultStore() {
     return new InMemoryStore({
         maxSize: LIMITS.DEFAULT_STORE_MAX_SIZE,
@@ -206,4 +193,3 @@ export function createDefaultStore() {
         cleanupIntervalMs: LIMITS.DEFAULT_STORE_CLEANUP_INTERVAL_MS,
     });
 }
-//# sourceMappingURL=memory.js.map