@juspay/neurolink 10.1.2 → 10.2.0

package/dist/proxy/usageStats.js

@@ -1,98 +1,658 @@
 /**
- * Proxy Usage Statistics
- * Tracks per-account request counts, token usage, and error rates.
- * In-memory only — resets on proxy restart.
+ * Proxy usage statistics with restart- and handoff-safe persistence.
+ *
+ * Request handlers update memory synchronously. Small deltas are merged into a
+ * shared snapshot asynchronously, under a cross-process lock, so overlapping
+ * rolling workers cannot overwrite each other's counters.
  */
-const stats = {
-    startedAt: Date.now(),
-    totalAttempts: 0,
-    totalAttemptErrors: 0,
-    totalRequests: 0,
-    totalSuccess: 0,
-    totalErrors: 0,
-    totalRateLimits: 0,
-    totalTransientRateLimits: 0,
-    totalQuotaRateLimits: 0,
-    accounts: {},
-};
-export function recordAttempt(accountLabel, accountType) {
-    stats.totalAttempts++;
-    const acct = ensureAccount(accountLabel, accountType);
-    acct.attemptCount++;
-    acct.lastAttemptAt = Date.now();
+import { randomUUID } from "node:crypto";
+import { mkdir, open, readFile, readdir, rename, rm, stat, } from "node:fs/promises";
+import { basename, dirname, join } from "node:path";
+import { AsyncMutex } from "../utils/asyncMutex.js";
+import { writeJsonSnapshotAtomically } from "./snapshotPersistence.js";
+const SNAPSHOT_SCHEMA_VERSION = 1;
+const DEFAULT_FLUSH_INTERVAL_MS = 1_000;
+const DEFAULT_LOCK_TIMEOUT_MS = 2_000;
+const DEFAULT_STALE_LOCK_MS = 30_000;
+const LOCK_RETRY_MS = 25;
+const MAX_CORRUPT_SNAPSHOTS = 3;
+class InvalidProxyStatsSnapshotError extends Error {
 }
-export function recordFinalSuccess(accountLabel, accountType) {
-    stats.totalRequests++;
-    stats.totalSuccess++;
-    if (accountLabel && accountType) {
-        const acct = ensureAccount(accountLabel, accountType);
-        acct.successCount++;
+function emptyStats(startedAt) {
+    return {
+        startedAt,
+        totalAttempts: 0,
+        totalAttemptErrors: 0,
+        totalRequests: 0,
+        totalSuccess: 0,
+        totalErrors: 0,
+        totalRateLimits: 0,
+        totalTransientRateLimits: 0,
+        totalQuotaRateLimits: 0,
+        accounts: {},
+    };
+}
+function cloneAccount(account) {
+    return { ...account };
+}
+function cloneStats(value) {
+    return {
+        ...value,
+        accounts: Object.fromEntries(Object.entries(value.accounts).map(([label, account]) => [
+            label,
+            cloneAccount(account),
+        ])),
+    };
+}
+function mergeAccountStats(left, right) {
+    if (!left) {
+        return cloneAccount(right);
     }
+    return {
+        label: right.label || left.label,
+        type: right.type || left.type,
+        attemptCount: left.attemptCount + right.attemptCount,
+        attemptErrorCount: left.attemptErrorCount + right.attemptErrorCount,
+        successCount: left.successCount + right.successCount,
+        errorCount: left.errorCount + right.errorCount,
+        rateLimitCount: left.rateLimitCount + right.rateLimitCount,
+        transientRateLimitCount: left.transientRateLimitCount + right.transientRateLimitCount,
+        quotaRateLimitCount: left.quotaRateLimitCount + right.quotaRateLimitCount,
+        lastAttemptAt: Math.max(left.lastAttemptAt, right.lastAttemptAt),
+        ...(left.lastErrorAt || right.lastErrorAt
+            ? {
+                lastErrorAt: Math.max(left.lastErrorAt ?? 0, right.lastErrorAt ?? 0),
+            }
+            : {}),
+    };
 }
-export function recordAttemptError(accountLabel, accountType, status, rateLimitKind) {
-    const acct = ensureAccount(accountLabel, accountType);
-    stats.totalAttemptErrors++;
-    acct.attemptErrorCount++;
-    acct.lastErrorAt = Date.now();
-    if (status === 429) {
-        stats.totalRateLimits++;
-        acct.rateLimitCount++;
+function mergeStats(left, right) {
+    const accounts = Object.fromEntries(Object.entries(left.accounts).map(([label, account]) => [
+        label,
+        cloneAccount(account),
+    ]));
+    for (const [label, account] of Object.entries(right.accounts)) {
+        accounts[label] = mergeAccountStats(accounts[label], account);
+    }
+    return {
+        startedAt: Math.min(left.startedAt, right.startedAt),
+        totalAttempts: left.totalAttempts + right.totalAttempts,
+        totalAttemptErrors: left.totalAttemptErrors + right.totalAttemptErrors,
+        totalRequests: left.totalRequests + right.totalRequests,
+        totalSuccess: left.totalSuccess + right.totalSuccess,
+        totalErrors: left.totalErrors + right.totalErrors,
+        totalRateLimits: left.totalRateLimits + right.totalRateLimits,
+        totalTransientRateLimits: left.totalTransientRateLimits + right.totalTransientRateLimits,
+        totalQuotaRateLimits: left.totalQuotaRateLimits + right.totalQuotaRateLimits,
+        accounts,
+    };
+}
+function finiteNonNegativeInteger(value) {
+    return typeof value === "number" && Number.isSafeInteger(value) && value >= 0;
+}
+function validAccountStats(value) {
+    if (!value || typeof value !== "object") {
+        return false;
+    }
+    const candidate = value;
+    return (typeof candidate.label === "string" &&
+        typeof candidate.type === "string" &&
+        finiteNonNegativeInteger(candidate.attemptCount) &&
+        finiteNonNegativeInteger(candidate.attemptErrorCount) &&
+        finiteNonNegativeInteger(candidate.successCount) &&
+        finiteNonNegativeInteger(candidate.errorCount) &&
+        finiteNonNegativeInteger(candidate.rateLimitCount) &&
+        finiteNonNegativeInteger(candidate.transientRateLimitCount) &&
+        finiteNonNegativeInteger(candidate.quotaRateLimitCount) &&
+        finiteNonNegativeInteger(candidate.lastAttemptAt) &&
+        (candidate.lastErrorAt === undefined ||
+            finiteNonNegativeInteger(candidate.lastErrorAt)));
+}
+function validStats(value) {
+    if (!value || typeof value !== "object") {
+        return false;
+    }
+    const candidate = value;
+    const counters = [
+        candidate.startedAt,
+        candidate.totalAttempts,
+        candidate.totalAttemptErrors,
+        candidate.totalRequests,
+        candidate.totalSuccess,
+        candidate.totalErrors,
+        candidate.totalRateLimits,
+        candidate.totalTransientRateLimits,
+        candidate.totalQuotaRateLimits,
+    ];
+    if (!counters.every(finiteNonNegativeInteger) ||
+        !candidate.accounts ||
+        typeof candidate.accounts !== "object") {
+        return false;
+    }
+    return Object.entries(candidate.accounts).every(([label, account]) => validAccountStats(account) && label === account.label);
+}
+function validSnapshot(value) {
+    if (!value || typeof value !== "object") {
+        return false;
+    }
+    const candidate = value;
+    return (candidate.schemaVersion === SNAPSHOT_SCHEMA_VERSION &&
+        finiteNonNegativeInteger(candidate.revision) &&
+        finiteNonNegativeInteger(candidate.updatedAt) &&
+        validStats(candidate.stats));
+}
+function isMissingFileError(error) {
+    return error?.code === "ENOENT";
+}
+function isCorruptSnapshotError(error) {
+    return (error instanceof SyntaxError ||
+        error instanceof InvalidProxyStatsSnapshotError);
+}
+function processIsRunning(pid) {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch (error) {
+        return error.code === "EPERM";
+    }
+}
+async function sleep(ms) {
+    await new Promise((resolve) => setTimeout(resolve, ms));
+}
+async function readLockOwner(lockPath) {
+    try {
+        const parsed = JSON.parse(await readFile(lockPath, "utf8"));
+        if (!parsed || typeof parsed !== "object") {
+            return null;
+        }
+        const candidate = parsed;
+        if (typeof candidate.token !== "string" ||
+            !finiteNonNegativeInteger(candidate.pid) ||
+            candidate.pid === 0 ||
+            !finiteNonNegativeInteger(candidate.acquiredAt)) {
+            return null;
+        }
+        return candidate;
+    }
+    catch {
+        return null;
+    }
+}
+async function removeAbandonedLock(lockPath, staleLockMs, now) {
+    const owner = await readLockOwner(lockPath);
+    try {
+        const lockStat = await stat(lockPath);
+        const oldEnough = now - lockStat.mtimeMs >= staleLockMs;
+        const ownerIsRunning = owner ? processIsRunning(owner.pid) : false;
+        if (owner && ownerIsRunning && !oldEnough) {
+            return false;
+        }
+        if ((owner && !ownerIsRunning) || oldEnough) {
+            await rm(lockPath, { force: true });
+            return true;
+        }
+    }
+    catch (error) {
+        return isMissingFileError(error);
+    }
+    return false;
+}
+async function acquireFileLock(lockPath, timeoutMs, staleLockMs, now) {
+    await mkdir(dirname(lockPath), { recursive: true, mode: 0o700 });
+    const deadline = Date.now() + timeoutMs;
+    while (true) {
+        const owner = {
+            token: randomUUID(),
+            pid: process.pid,
+            acquiredAt: now(),
+        };
+        let handle;
+        try {
+            handle = await open(lockPath, "wx", 0o600);
+            await handle.writeFile(JSON.stringify(owner));
+            const acquiredHandle = handle;
+            return async () => {
+                await acquiredHandle.close().catch(() => undefined);
+                const current = await readLockOwner(lockPath);
+                if (current?.token === owner.token) {
+                    await rm(lockPath, { force: true }).catch(() => undefined);
+                }
+            };
+        }
+        catch (error) {
+            if (handle) {
+                await handle.close().catch(() => undefined);
+                await rm(lockPath, { force: true }).catch(() => undefined);
+            }
+            if (error.code !== "EEXIST") {
+                throw error;
+            }
+        }
+        if (await removeAbandonedLock(lockPath, staleLockMs, now())) {
+            continue;
+        }
+        if (Date.now() >= deadline) {
+            throw new Error(`Timed out acquiring proxy stats lock ${lockPath}`);
+        }
+        await sleep(LOCK_RETRY_MS);
+    }
+}
+export class ProxyUsageStatsStore {
+    now;
+    flushIntervalMs;
+    lockTimeoutMs;
+    staleLockMs;
+    filePath;
+    stats;
+    pending;
+    pendingMutations = 0;
+    inFlightMutations = 0;
+    revision = 0;
+    flushTimer = null;
+    flushMutex = new AsyncMutex();
+    lastFlushedAt;
+    lastReconciledAt;
+    lastRecoveryAt;
+    lastError;
+    constructor(options = {}) {
+        this.now = options.now ?? Date.now;
+        this.flushIntervalMs = options.flushIntervalMs ?? DEFAULT_FLUSH_INTERVAL_MS;
+        this.lockTimeoutMs = options.lockTimeoutMs ?? DEFAULT_LOCK_TIMEOUT_MS;
+        this.staleLockMs = options.staleLockMs ?? DEFAULT_STALE_LOCK_MS;
+        this.filePath = options.filePath;
+        const startedAt = this.now();
+        this.stats = emptyStats(startedAt);
+        this.pending = emptyStats(startedAt);
+    }
+    async initialize(filePath = this.filePath ?? "") {
+        this.cancelFlushTimer();
+        this.filePath = filePath || undefined;
+        const startedAt = this.now();
+        this.stats = emptyStats(startedAt);
+        this.pending = emptyStats(startedAt);
+        this.pendingMutations = 0;
+        this.inFlightMutations = 0;
+        this.revision = 0;
+        this.lastFlushedAt = undefined;
+        this.lastReconciledAt = undefined;
+        this.lastRecoveryAt = undefined;
+        this.lastError = undefined;
+        if (!this.filePath) {
+            return;
+        }
+        try {
+            const snapshot = await this.readSnapshot();
+            if (snapshot) {
+                this.stats = cloneStats(snapshot.stats);
+                this.pending = emptyStats(this.now());
+                this.revision = snapshot.revision;
+                this.lastFlushedAt = snapshot.updatedAt;
+            }
+            this.lastReconciledAt = this.now();
+        }
+        catch (error) {
+            if (isCorruptSnapshotError(error)) {
+                try {
+                    const recoveredSnapshot = await this.recoverCorruptSnapshot();
+                    if (recoveredSnapshot) {
+                        this.applySnapshot(recoveredSnapshot);
+                    }
+                    this.lastReconciledAt = this.now();
+                }
+                catch (recoveryError) {
+                    this.lastError = this.describeError(recoveryError);
+                }
+            }
+            else {
+                this.lastError = this.describeError(error);
+            }
+        }
+    }
+    recordAttempt(accountLabel, accountType) {
+        const attemptedAt = this.now();
+        this.applyAttempt(this.stats, accountLabel, accountType, attemptedAt);
+        this.applyAttempt(this.pending, accountLabel, accountType, attemptedAt);
+        this.markMutation();
+    }
+    recordFinalSuccess(accountLabel, accountType) {
+        this.applyFinalSuccess(this.stats, accountLabel, accountType);
+        this.applyFinalSuccess(this.pending, accountLabel, accountType);
+        this.markMutation();
+    }
+    recordAttemptError(accountLabel, accountType, status, rateLimitKind) {
+        const failedAt = this.now();
+        this.applyAttemptError(this.stats, accountLabel, accountType, status, rateLimitKind, failedAt);
+        this.applyAttemptError(this.pending, accountLabel, accountType, status, rateLimitKind, failedAt);
+        this.markMutation();
+    }
+    recordFinalError(_status, accountLabel, accountType) {
+        const failedAt = this.now();
+        this.applyFinalError(this.stats, accountLabel, accountType, failedAt);
+        this.applyFinalError(this.pending, accountLabel, accountType, failedAt);
+        this.markMutation();
+    }
+    getStats() {
+        return cloneStats(this.stats);
+    }
+    getAccountStats(label) {
+        const account = this.stats.accounts[label];
+        return account ? cloneAccount(account) : undefined;
+    }
+    getPersistenceStatus() {
+        return {
+            enabled: !!this.filePath,
+            filePath: this.filePath ?? null,
+            revision: this.revision,
+            pendingMutations: this.pendingMutations,
+            inFlightMutations: this.inFlightMutations,
+            unpersistedMutations: this.pendingMutations + this.inFlightMutations,
+            lastFlushedAt: this.lastFlushedAt ?? null,
+            lastReconciledAt: this.lastReconciledAt ?? null,
+            lastRecoveryAt: this.lastRecoveryAt ?? null,
+            lastError: this.lastError ?? null,
+        };
+    }
+    async flush() {
+        if (!this.filePath ||
+            (this.pendingMutations === 0 && this.inFlightMutations === 0)) {
+            return;
+        }
+        this.cancelFlushTimer();
+        await this.flushMutex.runExclusive(async () => {
+            if (!this.filePath || this.pendingMutations === 0) {
+                return;
+            }
+            const delta = this.pending;
+            const deltaMutations = this.pendingMutations;
+            this.pending = emptyStats(this.now());
+            this.pendingMutations = 0;
+            this.inFlightMutations = deltaMutations;
+            const lockPath = `${this.filePath}.lock`;
+            let releaseLock;
+            try {
+                releaseLock = await acquireFileLock(lockPath, this.lockTimeoutMs, this.staleLockMs, this.now);
+                let existing;
+                try {
+                    existing = await this.readSnapshot();
+                }
+                catch (error) {
+                    if (!isCorruptSnapshotError(error)) {
+                        throw error;
+                    }
+                    await this.quarantineCorruptSnapshot();
+                    existing = null;
+                }
+                const persisted = existing?.stats ?? emptyStats(delta.startedAt);
+                const merged = mergeStats(persisted, delta);
+                const revision = (existing?.revision ?? 0) + 1;
+                const updatedAt = this.now();
+                await writeJsonSnapshotAtomically(this.filePath, {
+                    schemaVersion: SNAPSHOT_SCHEMA_VERSION,
+                    revision,
+                    updatedAt,
+                    stats: merged,
+                }, 0o600);
+                this.revision = revision;
+                this.lastFlushedAt = updatedAt;
+                this.lastReconciledAt = updatedAt;
+                this.lastError = undefined;
+                this.stats = mergeStats(merged, this.pending);
+                this.inFlightMutations = 0;
+            }
+            catch (error) {
+                this.pending = mergeStats(delta, this.pending);
+                this.pendingMutations += deltaMutations;
+                this.inFlightMutations = 0;
+                this.lastError = this.describeError(error);
+                this.scheduleFlush();
+            }
+            finally {
+                await releaseLock?.();
+            }
+        });
+    }
+    async reconcile() {
+        if (!this.filePath) {
+            return this.getStats();
+        }
+        return this.flushMutex.runExclusive(async () => {
+            try {
+                const snapshot = await this.readSnapshot();
+                if (snapshot) {
+                    this.stats = mergeStats(snapshot.stats, this.pending);
+                    this.revision = snapshot.revision;
+                    this.lastFlushedAt = snapshot.updatedAt;
+                }
+                this.lastReconciledAt = this.now();
+                this.lastError = undefined;
+            }
+            catch (error) {
+                this.lastError = this.describeError(error);
+            }
+            return this.getStats();
+        });
+    }
+    resetMemory() {
+        this.cancelFlushTimer();
+        const startedAt = this.now();
+        this.stats = emptyStats(startedAt);
+        this.pending = emptyStats(startedAt);
+        this.pendingMutations = 0;
+        this.inFlightMutations = 0;
+        this.revision = 0;
+        this.lastFlushedAt = undefined;
+        this.lastReconciledAt = undefined;
+        this.lastRecoveryAt = undefined;
+        this.lastError = undefined;
+    }
+    async resetForTests() {
+        await this.flushMutex.runExclusive(async () => {
+            this.resetMemory();
+            this.filePath = undefined;
+        });
+    }
+    markMutation() {
+        this.pendingMutations += 1;
+        this.scheduleFlush();
+    }
+    applyAttempt(target, accountLabel, accountType, attemptedAt) {
+        target.totalAttempts += 1;
+        const account = this.ensureAccount(target, accountLabel, accountType);
+        account.attemptCount += 1;
+        account.lastAttemptAt = attemptedAt;
+    }
+    applyFinalSuccess(target, accountLabel, accountType) {
+        target.totalRequests += 1;
+        target.totalSuccess += 1;
+        if (accountLabel && accountType) {
+            this.ensureAccount(target, accountLabel, accountType).successCount += 1;
+        }
+    }
+    applyAttemptError(target, accountLabel, accountType, status, rateLimitKind, failedAt) {
+        const account = this.ensureAccount(target, accountLabel, accountType);
+        target.totalAttemptErrors += 1;
+        account.attemptErrorCount += 1;
+        account.lastErrorAt = failedAt;
+        if (status !== 429) {
+            return;
+        }
+        target.totalRateLimits += 1;
+        account.rateLimitCount += 1;
         if (rateLimitKind === "transient") {
-            stats.totalTransientRateLimits++;
-            acct.transientRateLimitCount++;
+            target.totalTransientRateLimits += 1;
+            account.transientRateLimitCount += 1;
         }
         else if (rateLimitKind === "quota") {
-            stats.totalQuotaRateLimits++;
-            acct.quotaRateLimitCount++;
+            target.totalQuotaRateLimits += 1;
+            account.quotaRateLimitCount += 1;
+        }
+    }
+    applyFinalError(target, accountLabel, accountType, failedAt) {
+        target.totalRequests += 1;
+        target.totalErrors += 1;
+        if (accountLabel && accountType) {
+            const account = this.ensureAccount(target, accountLabel, accountType);
+            account.errorCount += 1;
+            account.lastErrorAt = failedAt;
+        }
+    }
+    ensureAccount(target, label, type) {
+        if (!target.accounts[label]) {
+            target.accounts[label] = {
+                label,
+                type,
+                attemptCount: 0,
+                attemptErrorCount: 0,
+                successCount: 0,
+                errorCount: 0,
+                rateLimitCount: 0,
+                transientRateLimitCount: 0,
+                quotaRateLimitCount: 0,
+                lastAttemptAt: 0,
+            };
+        }
+        return target.accounts[label];
+    }
+    scheduleFlush() {
+        if (!this.filePath || this.flushTimer) {
+            return;
+        }
+        this.flushTimer = setTimeout(() => {
+            this.flushTimer = null;
+            void this.flush().catch((error) => {
+                this.lastError = this.describeError(error);
+                this.scheduleFlush();
+            });
+        }, this.flushIntervalMs);
+        this.flushTimer.unref?.();
+    }
+    cancelFlushTimer() {
+        if (this.flushTimer) {
+            clearTimeout(this.flushTimer);
+            this.flushTimer = null;
+        }
+    }
+    async readSnapshot() {
+        if (!this.filePath) {
+            return null;
+        }
+        let raw;
+        try {
+            raw = await readFile(this.filePath, "utf8");
+        }
+        catch (error) {
+            if (isMissingFileError(error)) {
+                return null;
+            }
+            throw error;
+        }
+        const parsed = JSON.parse(raw);
+        if (!validSnapshot(parsed)) {
+            throw new InvalidProxyStatsSnapshotError(`Invalid proxy stats snapshot ${this.filePath}`);
+        }
+        return parsed;
+    }
+    applySnapshot(snapshot) {
+        this.stats = cloneStats(snapshot.stats);
+        this.pending = emptyStats(this.now());
+        this.revision = snapshot.revision;
+        this.lastFlushedAt = snapshot.updatedAt;
+    }
+    async recoverCorruptSnapshot() {
+        if (!this.filePath) {
+            return null;
+        }
+        const releaseLock = await acquireFileLock(`${this.filePath}.lock`, this.lockTimeoutMs, this.staleLockMs, this.now);
+        try {
+            try {
+                return await this.readSnapshot();
+            }
+            catch (error) {
+                if (!isCorruptSnapshotError(error)) {
+                    throw error;
+                }
+                await this.quarantineCorruptSnapshot();
+                return null;
+            }
+        }
+        finally {
+            await releaseLock();
+        }
+    }
+    async quarantineCorruptSnapshot() {
+        if (!this.filePath) {
+            return;
+        }
+        const recoveredAt = this.now();
+        const quarantinePath = `${this.filePath}.corrupt.${recoveredAt}.${randomUUID()}`;
+        try {
+            await rename(this.filePath, quarantinePath);
+        }
+        catch (error) {
+            if (!isMissingFileError(error)) {
+                throw error;
+            }
+            return;
         }
+        this.lastRecoveryAt = recoveredAt;
+        this.lastError = undefined;
+        await this.pruneCorruptSnapshots();
     }
+    async pruneCorruptSnapshots() {
+        if (!this.filePath) {
+            return;
+        }
+        const directory = dirname(this.filePath);
+        const prefix = `${basename(this.filePath)}.corrupt.`;
+        const quarantined = (await readdir(directory))
+            .filter((entry) => entry.startsWith(prefix))
+            .sort()
+            .reverse();
+        await Promise.all(quarantined
+            .slice(MAX_CORRUPT_SNAPSHOTS)
+            .map((entry) => rm(join(directory, entry), { force: true })));
+    }
+    describeError(error) {
+        return (error instanceof Error ? error.message : String(error)).slice(0, 1_000);
+    }
+}
+const defaultStore = new ProxyUsageStatsStore();
+export async function initUsageStats(filePath) {
+    await defaultStore.initialize(filePath);
+}
+export function recordAttempt(accountLabel, accountType) {
+    defaultStore.recordAttempt(accountLabel, accountType);
+}
+export function recordFinalSuccess(accountLabel, accountType) {
+    defaultStore.recordFinalSuccess(accountLabel, accountType);
+}
+export function recordAttemptError(accountLabel, accountType, status, rateLimitKind) {
+    defaultStore.recordAttemptError(accountLabel, accountType, status, rateLimitKind);
 }
 export function recordFinalError(_status, accountLabel, accountType) {
-    stats.totalRequests++;
-    stats.totalErrors++;
-    if (accountLabel && accountType) {
-        const acct = ensureAccount(accountLabel, accountType);
-        acct.errorCount++;
-        acct.lastErrorAt = Date.now();
-    }
+    defaultStore.recordFinalError(_status, accountLabel, accountType);
 }
 export function getStats() {
-    const accounts = {};
-    for (const [label, account] of Object.entries(stats.accounts)) {
-        accounts[label] = { ...account };
-    }
-    return { ...stats, accounts };
+    return defaultStore.getStats();
+}
+export async function getReconciledStats() {
+    return defaultStore.reconcile();
 }
 export function getAccountStats(label) {
-    const account = stats.accounts[label];
-    return account ? { ...account } : undefined;
+    return defaultStore.getAccountStats(label);
 }
+export function getUsageStatsPersistenceStatus() {
+    return defaultStore.getPersistenceStatus();
+}
+export async function flushUsageStats() {
+    await defaultStore.flush();
+}
+/** Reset process-local counters while intentionally preserving durable state. */
 export function resetStats() {
-    stats.startedAt = Date.now();
-    stats.totalAttempts = 0;
-    stats.totalAttemptErrors = 0;
-    stats.totalRequests = 0;
-    stats.totalSuccess = 0;
-    stats.totalErrors = 0;
-    stats.totalRateLimits = 0;
-    stats.totalTransientRateLimits = 0;
-    stats.totalQuotaRateLimits = 0;
-    stats.accounts = {};
-}
-function ensureAccount(label, type) {
-    if (!stats.accounts[label]) {
-        stats.accounts[label] = {
-            label,
-            type,
-            attemptCount: 0,
-            attemptErrorCount: 0,
-            successCount: 0,
-            errorCount: 0,
-            rateLimitCount: 0,
-            transientRateLimitCount: 0,
-            quotaRateLimitCount: 0,
-            lastAttemptAt: 0,
-        };
-    }
-    return stats.accounts[label];
+    defaultStore.resetMemory();
+}
+/** Disconnect persistence and clear singleton state between isolated tests. */
+export async function resetUsageStatsForTests() {
+    await defaultStore.resetForTests();
 }