actly 1.1.5 → 1.3.0

package/dist/policies/timeout.d.ts

@@ -1,50 +1,6 @@
 import type { PolicyApplier, TimeoutOptions } from '../types/index.js';
-/**
- * Thrown when a per-attempt `timeout` deadline fires.
- *
- * Carries the configured `ms` so callers can log/alert precisely:
- *
- * ```ts
- * if (!result.ok && result.error instanceof TimeoutError) {
- *   console.log(`attempt timed out after ${result.error.ms}ms`)
- * }
- * ```
- */
-export declare class TimeoutError extends Error {
-    readonly ms: number;
-    constructor(ms: number);
-}
-/**
- * Thrown when the operation-wide `totalTimeout` budget fires.
- *
- * Distinct from `TimeoutError` (per-attempt) so callers can `instanceof`-check
- * which deadline fired:
- *
- * ```ts
- * if (result.error instanceof TotalTimeoutError) {
- *   // whole operation budget exhausted
- * } else if (result.error instanceof TimeoutError) {
- *   // last attempt's per-attempt deadline fired
- * }
- * ```
- */
-export declare class TotalTimeoutError extends Error {
-    readonly ms: number;
-    constructor(ms: number);
-}
-/**
- * Per-attempt timeout. Races `fn` against a deadline that resets on retry.
- *
- * Place this INSIDE `retryPolicy` (closer to `fn`) so each attempt has its
- * own clock.
- */
+import { TimeoutError, TotalTimeoutError } from '../errors.js';
+export { TimeoutError, TotalTimeoutError };
 export declare function timeoutPolicy<T>(opts: TimeoutOptions): PolicyApplier<T>;
-/**
- * Operation-wide timeout. Races the ENTIRE chain (all retry attempts +
- * delays) against a hard budget that does NOT reset.
- *
- * Place this as the OUTERMOST policy so the clock starts before any other
- * policy runs and stops regardless of what the inner chain is doing.
- */
 export declare function totalTimeoutPolicy<T>(opts: TimeoutOptions): PolicyApplier<T>;
 //# sourceMappingURL=timeout.d.ts.map

package/dist/policies/timeout.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"timeout.d.ts","sourceRoot":"","sources":["../../src/policies/timeout.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAS,aAAa,EAAiB,cAAc,EAAE,MAAM,mBAAmB,CAAA;AAK5F;;;;;;;;;;GAUG;AACH,qBAAa,YAAa,SAAQ,KAAK;IACrC,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAA;gBAEP,EAAE,EAAE,MAAM;CAKvB;AAED;;;;;;;;;;;;;GAaG;AACH,qBAAa,iBAAkB,SAAQ,KAAK;IAC1C,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAA;gBAEP,EAAE,EAAE,MAAM;CAKvB;AAgFD;;;;;GAKG;AACH,wBAAgB,aAAa,CAAC,CAAC,EAAE,IAAI,EAAE,cAAc,GAAG,aAAa,CAAC,CAAC,CAAC,CAEvE;AAED;;;;;;GAMG;AACH,wBAAgB,kBAAkB,CAAC,CAAC,EAAE,IAAI,EAAE,cAAc,GAAG,aAAa,CAAC,CAAC,CAAC,CAE5E"}
+{"version":3,"file":"timeout.d.ts","sourceRoot":"","sources":["../../src/policies/timeout.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAS,aAAa,EAAiB,cAAc,EAAE,MAAM,mBAAmB,CAAA;AAG5F,OAAO,EAAE,YAAY,EAAE,iBAAiB,EAAE,MAAM,cAAc,CAAA;AAI9D,OAAO,EAAE,YAAY,EAAE,iBAAiB,EAAE,CAAA;AAyG1C,wBAAgB,aAAa,CAAC,CAAC,EAAE,IAAI,EAAE,cAAc,GAAG,aAAa,CAAC,CAAC,CAAC,CAEvE;AAMD,wBAAgB,kBAAkB,CAAC,CAAC,EAAE,IAAI,EAAE,cAAc,GAAG,aAAa,CAAC,CAAC,CAAC,CAE5E"}

package/dist/policies/timeout.js

@@ -1,121 +1,65 @@
 import { linkSignal } from '../utils/abort.js';
-// ─── Errors ───────────────────────────────────────────────────────────────────
-/**
- * Thrown when a per-attempt `timeout` deadline fires.
- *
- * Carries the configured `ms` so callers can log/alert precisely:
- *
- * ```ts
- * if (!result.ok && result.error instanceof TimeoutError) {
- *   console.log(`attempt timed out after ${result.error.ms}ms`)
- * }
- * ```
- */
-export class TimeoutError extends Error {
-    ms;
-    constructor(ms) {
-        super(`ACT timed out after ${ms}ms`);
-        this.name = 'TimeoutError';
-        this.ms = ms;
-    }
-}
-/**
- * Thrown when the operation-wide `totalTimeout` budget fires.
- *
- * Distinct from `TimeoutError` (per-attempt) so callers can `instanceof`-check
- * which deadline fired:
- *
- * ```ts
- * if (result.error instanceof TotalTimeoutError) {
- *   // whole operation budget exhausted
- * } else if (result.error instanceof TimeoutError) {
- *   // last attempt's per-attempt deadline fired
- * }
- * ```
- */
-export class TotalTimeoutError extends Error {
-    ms;
-    constructor(ms) {
-        super(`ACT total timeout exceeded after ${ms}ms`);
-        this.name = 'TotalTimeoutError';
-        this.ms = ms;
-    }
-}
-// ─── Policy ───────────────────────────────────────────────────────────────────
-/**
- * Build a timeout policy that throws `ErrorCtor` on deadline.
- *
- * # Cancellation contract
- *
- * Each invocation:
- *   1. Creates a fresh `AbortController` for this attempt.
- *   2. Arms a `setTimeout` that aborts the controller with a fresh `ErrorCtor(ms)`.
- *   3. Links the parent signal: if the parent aborts (e.g. `totalTimeout` or
- *      caller cancellation), the child aborts with the parent's reason.
- *   4. Races `fn(childSignal)` against the abort event.
- *
- * The race is critical: it ensures `act()` returns promptly even if `fn`
- * ignores the signal. The underlying `fn` may keep running in the background
- * (resource leak), but the caller is unblocked. This is the best JavaScript
- * can do without cooperation from `fn`.
- *
- * If `fn` cooperates (passes `signal` to `fetch`, `AbortController`, etc.),
- * the underlying work is cancelled properly — no leak.
- *
- * # Error attribution
- *
- * If the per-attempt timer fires, we throw `ErrorCtor(ms)` regardless of
- * what `fn` does. If the parent signal fires first, we throw the parent's
- * reason (could be `TotalTimeoutError`, an `AbortError`, or anything else).
- */
-function makeTimeoutPolicy(opts, ErrorCtor) {
-    return (fn, _ctx) => async (parentSignal) => {
+import { safeCall } from '../utils/safeCall.js';
+import { TimeoutError, TotalTimeoutError } from '../errors.js';
+export { TimeoutError, TotalTimeoutError };
+function makeTimeoutPolicy(opts, errorCtor, kind) {
+    const strategy = opts.strategy ?? 'race';
+    return (fn, ctx) => async (parentSignal) => {
         const controller = new AbortController();
-        const timerError = new ErrorCtor(opts.ms);
-        // Arm the per-attempt timer. The error object is allocated once so the
-        // stack trace points here (the policy frame), not at setTimeout's
-        // internal callback.
-        const timer = setTimeout(() => controller.abort(timerError), opts.ms);
-        // Link parent -> child. If parent is already aborted, child aborts
-        // synchronously with parent's reason.
-        linkSignal(parentSignal, controller);
+        const timerError = new errorCtor(opts.ms, { key: ctx.key });
+        const obs = ctx.observability;
+        let timedOut = false;
+        const timer = setTimeout(() => {
+            timedOut = true;
+            if (obs) {
+                safeCall(obs.hooks.onTimeout, {
+                    type: 'timeout', key: ctx.key, traceId: obs.traceId,
+                    timestamp: Date.now(), kind, ms: opts.ms,
+                });
+            }
+            controller.abort(timerError);
+        }, opts.ms);
+        const unlink = linkSignal(parentSignal, controller);
         try {
-            // Race fn against the abort event. If fn settles first, we get its
-            // result/error. If the signal aborts first, we reject with reason.
-            //
-            // We do NOT use AbortSignal.timeout() here because we need to throw
-            // our own ErrorCtor, not a DOMException named "TimeoutError".
+            if (strategy === 'cooperative') {
+                if (parentSignal.aborted) {
+                    throw parentSignal.reason;
+                }
+                try {
+                    const value = await fn(controller.signal);
+                    return value;
+                }
+                catch (err) {
+                    if (timedOut)
+                        throw timerError;
+                    throw err;
+                }
+            }
             return await new Promise((resolve, reject) => {
                 if (controller.signal.aborted) {
                     reject(controller.signal.reason);
                     return;
                 }
-                controller.signal.addEventListener('abort', () => reject(controller.signal.reason), { once: true });
-                Promise.resolve(fn(controller.signal)).then((value) => resolve(value), (error) => reject(error));
+                const onAbort = () => reject(controller.signal.reason);
+                controller.signal.addEventListener('abort', onAbort, { once: true });
+                Promise.resolve(fn(controller.signal)).then((value) => {
+                    controller.signal.removeEventListener('abort', onAbort);
+                    resolve(value);
+                }, (error) => {
+                    controller.signal.removeEventListener('abort', onAbort);
+                    reject(error);
+                });
             });
         }
         finally {
             clearTimeout(timer);
+            unlink();
         }
     };
 }
-/**
- * Per-attempt timeout. Races `fn` against a deadline that resets on retry.
- *
- * Place this INSIDE `retryPolicy` (closer to `fn`) so each attempt has its
- * own clock.
- */
 export function timeoutPolicy(opts) {
-    return makeTimeoutPolicy(opts, TimeoutError);
+    return makeTimeoutPolicy(opts, TimeoutError, 'per-attempt');
 }
-/**
- * Operation-wide timeout. Races the ENTIRE chain (all retry attempts +
- * delays) against a hard budget that does NOT reset.
- *
- * Place this as the OUTERMOST policy so the clock starts before any other
- * policy runs and stops regardless of what the inner chain is doing.
- */
 export function totalTimeoutPolicy(opts) {
-    return makeTimeoutPolicy(opts, TotalTimeoutError);
+    return makeTimeoutPolicy(opts, TotalTimeoutError, 'total');
 }
-//# sourceMappingURL=timeout.js.map

package/dist/stores/base.cjs

@@ -1,20 +1,10 @@
 "use strict";
-// ─── Store interfaces ─────────────────────────────────────────────────────────
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.isSyncStore = isSyncStore;
 exports.isAsyncStore = isAsyncStore;
-// ─── Type guards ──────────────────────────────────────────────────────────────
-/**
- * Narrows `AnyStateStore` to `SyncStateStore` via the `_sync` discriminant.
- * Used by `execute()` and `cachePolicy` to branch between sync and async paths.
- */
 function isSyncStore(store) {
     return store._sync === true;
 }
-/**
- * Narrows `AnyStateStore` to `AsyncStateStore` via the `_sync` discriminant.
- * Provided for symmetry; prefer `isSyncStore` for the common guard pattern.
- */
 function isAsyncStore(store) {
     return store._sync === false;
 }

package/dist/stores/base.d.ts

@@ -1,88 +1,25 @@
-/**
- * Synchronous key-value store. All operations complete in the same tick.
- *
- * # Why synchronous?
- *
- * `dedupePolicy` must read an in-flight Promise from the store and, if absent,
- * write a new one — all within a single synchronous frame. If `get()` were
- * async, two concurrent callers could both observe a miss before either
- * write lands, defeating deduplication entirely. There is no lock primitive
- * in JavaScript that can paper over this: the constraint is structural, not
- * implementation-level.
- *
- * # The `_sync` discriminant
- *
- * `_sync: true` is a runtime tag that lets `execute()` enforce the dedupe
- * constraint for plain-JS callers who bypass TypeScript. It is NOT part of
- * the semantic contract and MUST NOT be used for anything beyond that guard.
- * Implementations must set it as a `readonly` literal (`true as const`).
- *
- * # Lifecycle
- *
- * Implementations that hold background resources (timers, connections) should
- * expose a `destroy()` method as a convention. See `InMemoryStore` for the
- * reference pattern.
- */
 export interface SyncStateStore {
-    /** Runtime discriminant. Must be `true as const`. */
     readonly _sync: true;
     get<T>(key: string): T | undefined;
     set<T>(key: string, value: T, ttlMs?: number): void;
     delete(key: string): void;
     has(key: string): boolean;
-    /**
-     * Remove all entries synchronously.
-     * After `clear()` returns, `size()` returns 0.
-     */
+    deleteIfExists?(key: string): boolean;
     clear(): void;
-    /**
-     * Return the count of live (non-expired) entries.
-     * Side-effect free: does not mutate the store. Implementations MAY evict
-     * expired entries opportunistically during this call, but MUST NOT have
-     * observable side effects beyond internal cleanup.
-     */
     size(): number;
+    destroy?(): void;
 }
-/**
- * Asynchronous key-value store. All operations return Promises.
- *
- * # Policy compatibility
- *
- * Compatible with `cachePolicy` only. Passing an `AsyncStateStore` to a
- * policy chain that includes `dedupePolicy` is a TypeScript error and a
- * runtime error — `execute()` throws at chain-build time. See
- * `SyncStateStore` for why dedupe requires synchronous access.
- *
- * # TTL semantics
- *
- * The store is responsible for honouring `ttlMs`. Actly passes it as a hint.
- * Implementations may delegate to a native TTL mechanism (e.g. Redis EXPIRE).
- *
- * # The `_sync` discriminant
- *
- * `_sync: false` mirrors the discriminant on `SyncStateStore`. Must be set
- * as a `readonly` literal (`false as const`).
- */
 export interface AsyncStateStore {
-    /** Runtime discriminant. Must be `false as const`. */
     readonly _sync: false;
     get<T>(key: string): Promise<T | undefined>;
     set<T>(key: string, value: T, ttlMs?: number): Promise<void>;
     delete(key: string): Promise<void>;
     has(key: string): Promise<boolean>;
-    /** Remove all entries managed by this store. */
+    deleteIfExists?(key: string): Promise<boolean>;
     clear(): Promise<void>;
-    /** Return the count of live (non-expired) entries. */
     size(): Promise<number>;
+    destroy?(): void | Promise<void>;
 }
-/**
- * Narrows `AnyStateStore` to `SyncStateStore` via the `_sync` discriminant.
- * Used by `execute()` and `cachePolicy` to branch between sync and async paths.
- */
 export declare function isSyncStore(store: SyncStateStore | AsyncStateStore): store is SyncStateStore;
-/**
- * Narrows `AnyStateStore` to `AsyncStateStore` via the `_sync` discriminant.
- * Provided for symmetry; prefer `isSyncStore` for the common guard pattern.
- */
 export declare function isAsyncStore(store: SyncStateStore | AsyncStateStore): store is AsyncStateStore;
 //# sourceMappingURL=base.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"base.d.ts","sourceRoot":"","sources":["../../src/stores/base.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,MAAM,WAAW,cAAc;IAC7B,qDAAqD;IACrD,QAAQ,CAAC,KAAK,EAAE,IAAI,CAAA;IAEpB,GAAG,CAAC,CAAC,EAAE,GAAG,EAAE,MAAM,GAAG,CAAC,GAAG,SAAS,CAAA;IAClC,GAAG,CAAC,CAAC,EAAE,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,CAAC,EAAE,KAAK,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;IACnD,MAAM,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI,CAAA;IACzB,GAAG,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAA;IAEzB;;;OAGG;IACH,KAAK,IAAI,IAAI,CAAA;IAEb;;;;;OAKG;IACH,IAAI,IAAI,MAAM,CAAA;CACf;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,MAAM,WAAW,eAAe;IAC9B,sDAAsD;IACtD,QAAQ,CAAC,KAAK,EAAE,KAAK,CAAA;IAErB,GAAG,CAAC,CAAC,EAAE,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,CAAC,GAAG,SAAS,CAAC,CAAA;IAC3C,GAAG,CAAC,CAAC,EAAE,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,CAAC,EAAE,KAAK,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAA;IAC5D,MAAM,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAA;IAClC,GAAG,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAAA;IAElC,gDAAgD;IAChD,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC,CAAA;IAEtB,sDAAsD;IACtD,IAAI,IAAI,OAAO,CAAC,MAAM,CAAC,CAAA;CACxB;AAID;;;GAGG;AACH,wBAAgB,WAAW,CACzB,KAAK,EAAE,cAAc,GAAG,eAAe,GACtC,KAAK,IAAI,cAAc,CAEzB;AAED;;;GAGG;AACH,wBAAgB,YAAY,CAC1B,KAAK,EAAE,cAAc,GAAG,eAAe,GACtC,KAAK,IAAI,eAAe,CAE1B"}
+{"version":3,"file":"base.d.ts","sourceRoot":"","sources":["../../src/stores/base.ts"],"names":[],"mappings":"AAiBA,MAAM,WAAW,cAAc;IAE7B,QAAQ,CAAC,KAAK,EAAE,IAAI,CAAA;IAEpB,GAAG,CAAC,CAAC,EAAE,GAAG,EAAE,MAAM,GAAG,CAAC,GAAG,SAAS,CAAA;IAClC,GAAG,CAAC,CAAC,EAAE,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,CAAC,EAAE,KAAK,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;IACnD,MAAM,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI,CAAA;IACzB,GAAG,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAA;IASzB,cAAc,CAAC,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAA;IAGrC,KAAK,IAAI,IAAI,CAAA;IAMb,IAAI,IAAI,MAAM,CAAA;IAOd,OAAO,CAAC,IAAI,IAAI,CAAA;CACjB;AAcD,MAAM,WAAW,eAAe;IAE9B,QAAQ,CAAC,KAAK,EAAE,KAAK,CAAA;IAErB,GAAG,CAAC,CAAC,EAAE,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,CAAC,GAAG,SAAS,CAAC,CAAA;IAC3C,GAAG,CAAC,CAAC,EAAE,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,CAAC,EAAE,KAAK,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAA;IAC5D,MAAM,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAA;IAClC,GAAG,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAAA;IAMlC,cAAc,CAAC,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAAA;IAG9C,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC,CAAA;IAGtB,IAAI,IAAI,OAAO,CAAC,MAAM,CAAC,CAAA;IAMvB,OAAO,CAAC,IAAI,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAA;CACjC;AAQD,wBAAgB,WAAW,CACzB,KAAK,EAAE,cAAc,GAAG,eAAe,GACtC,KAAK,IAAI,cAAc,CAEzB;AAMD,wBAAgB,YAAY,CAC1B,KAAK,EAAE,cAAc,GAAG,eAAe,GACtC,KAAK,IAAI,eAAe,CAE1B"}

package/dist/stores/base.js

@@ -1,17 +1,6 @@
-// ─── Store interfaces ─────────────────────────────────────────────────────────
-// ─── Type guards ──────────────────────────────────────────────────────────────
-/**
- * Narrows `AnyStateStore` to `SyncStateStore` via the `_sync` discriminant.
- * Used by `execute()` and `cachePolicy` to branch between sync and async paths.
- */
 export function isSyncStore(store) {
     return store._sync === true;
 }
-/**
- * Narrows `AnyStateStore` to `AsyncStateStore` via the `_sync` discriminant.
- * Provided for symmetry; prefer `isSyncStore` for the common guard pattern.
- */
 export function isAsyncStore(store) {
     return store._sync === false;
 }
-//# sourceMappingURL=base.js.map

package/dist/stores/memory.cjs

@@ -1,140 +1,200 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.InMemoryStore = void 0;
+exports.createDefaultStore = createDefaultStore;
+const limits_js_1 = require("../utils/limits.js");
 function isUnrefable(t) {
     return typeof t.unref === 'function';
 }
-// ─── Implementation ───────────────────────────────────────────────────────────
-/**
- * Reference `SyncStateStore` implementation backed by a `Map`.
- *
- * # LRU semantics
- *
- * `Map` iteration order is insertion order, so we implement LRU by
- * `delete` + `set` on every access — the most-recently-touched key ends up
- * at the end of the iteration, and the oldest is `entries.keys().next().value`.
- *
- * # 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;
-    entries = new Map();
+    static finalizer;
+    static {
+        if (typeof FinalizationRegistry === 'function') {
+            InMemoryStore.finalizer = new FinalizationRegistry((timer) => {
+                try {
+                    clearInterval(timer);
+                }
+                catch { }
+            });
+        }
+    }
+    map = new Map();
     maxSize;
+    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) {
-        const entry = this.entries.get(key);
-        if (!entry)
+        const node = this.map.get(key);
+        if (!node)
             return undefined;
-        if (entry.expiresAt !== null && Date.now() > entry.expiresAt) {
-            this.entries.delete(key);
+        if (node.expiresAt !== null && Date.now() > node.expiresAt) {
+            this.removeNode(node);
+            this.map.delete(key);
             return undefined;
         }
-        // LRU refresh: move to most-recent position.
-        // delete + set is the canonical pattern for reordering a Map.
-        this.entries.delete(key);
-        this.entries.set(key, entry);
-        return entry.value;
+        this.moveToTail(node);
+        return node.value;
     }
     set(key, value, ttlMs) {
-        // Evict if at capacity AND adding a new key (updates don't grow size).
-        if (!this.entries.has(key) && this.entries.size >= this.maxSize) {
-            const oldest = this.entries.keys().next().value;
-            if (oldest !== undefined)
-                this.entries.delete(oldest);
-        }
-        const expiresAt = ttlMs != null && ttlMs > 0 ? Date.now() + ttlMs : null;
-        // delete + set ensures the key is moved to the most-recent position
-        // even on update, keeping LRU order consistent.
-        this.entries.delete(key);
-        this.entries.set(key, { value, expiresAt });
+        const existing = this.map.get(key);
+        const now = Date.now();
+        if (existing) {
+            existing.value = value;
+            existing.expiresAt = ttlMs != null && Number.isFinite(ttlMs) && ttlMs > 0 ? now + ttlMs : null;
+            existing.insertedAt = now;
+            this.moveToTail(existing);
+            return;
+        }
+        while (this.map.size >= this.maxSize && this.head) {
+            const evict = this.head;
+            this.removeNode(evict);
+            this.map.delete(evict.key);
+        }
+        const node = {
+            key,
+            value,
+            expiresAt: ttlMs != null && Number.isFinite(ttlMs) && ttlMs > 0 ? now + ttlMs : null,
+            insertedAt: now,
+        };
+        this.map.set(key, node);
+        this.appendTail(node);
     }
     delete(key) {
-        this.entries.delete(key);
+        const node = this.map.get(key);
+        if (!node)
+            return;
+        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 entry = this.entries.get(key);
-        if (!entry)
+        const node = this.map.get(key);
+        if (!node)
             return false;
-        if (entry.expiresAt !== null && Date.now() > entry.expiresAt) {
-            this.entries.delete(key);
+        if (node.expiresAt !== null && Date.now() > node.expiresAt) {
+            this.removeNode(node);
+            this.map.delete(key);
             return false;
         }
         return true;
     }
     clear() {
-        this.entries.clear();
+        this.map.clear();
+        this.head = undefined;
+        this.tail = undefined;
     }
-    /**
-     * Return the count of live (non-expired) entries.
-     *
-     * Pure query — does NOT touch LRU order. Expired entries discovered during
-     * the scan are evicted opportunistically (they were already invisible to
-     * `get()`, so eviction has no observable effect beyond memory reclamation).
-     *
-     * Two-pass to avoid mutating the Map during iteration (spec-safe).
-     */
     size() {
-        const now = Date.now();
-        const expired = [];
-        let count = 0;
-        for (const [key, entry] of this.entries) {
-            if (entry.expiresAt !== null && entry.expiresAt <= now) {
-                expired.push(key);
-            }
-            else {
-                count++;
-            }
-        }
-        for (const key of expired)
-            this.entries.delete(key);
-        return count;
+        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;
     }
-    /**
-     * Sweep all entries and remove those past their expiry time.
-     * Called by the autoCleanup interval; not part of the public contract.
-     */
-    _sweep() {
-        const now = Date.now();
-        const expired = [];
-        for (const [key, entry] of this.entries) {
-            if (entry.expiresAt !== null && now > entry.expiresAt) {
-                expired.push(key);
+    appendTail(node) {
+        if (this.tail) {
+            this.tail.next = node;
+            node.prev = this.tail;
+            node.next = undefined;
+        }
+        else {
+            this.head = node;
+        }
+        this.tail = 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 = undefined;
+        node.next = undefined;
+    }
+    moveToTail(node) {
+        if (this.tail === node)
+            return;
+        this.removeNode(node);
+        this.appendTail(node);
+    }
+    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);
+                }
+            }
+        }
+        catch {
         }
-        for (const key of expired)
-            this.entries.delete(key);
     }
 }
 exports.InMemoryStore = InMemoryStore;
+function createDefaultStore() {
+    return new InMemoryStore({
+        maxSize: limits_js_1.LIMITS.DEFAULT_STORE_MAX_SIZE,
+        autoCleanup: true,
+        cleanupIntervalMs: limits_js_1.LIMITS.DEFAULT_STORE_CLEANUP_INTERVAL_MS,
+    });
+}