@juspay/neurolink 12.32.2 → 12.32.3

package/dist/proxy/accountCooldown.js

@@ -60,22 +60,27 @@ function sanitizePersistedCooldown(accountKey, entry) {
         `${hours(ceiling)}h — the stored wait exceeded what "${entry.reason}" can mean`);
     return { ...entry, coolingUntil: latest };
 }
+/**
+ * Read the cooldown file as it is now. A missing file is empty; any other
+ * failure (unreadable, corrupt) returns `fallback`, so a write never discards
+ * entries just because one read failed.
+ */
+async function readCooldownsFromDisk(fallback) {
+    try {
+        const parsed = JSON.parse(await readFile(getCooldownFilePath(), "utf8"));
+        return Object.fromEntries(Object.entries(parsed)
+            .filter((entry) => isPersistedCooldown(entry[1]))
+            .map(([key, entry]) => [key, sanitizePersistedCooldown(key, entry)]));
+    }
+    catch (error) {
+        return error.code === "ENOENT" ? {} : fallback;
+    }
+}
 async function ensureAccountCooldownsLoaded() {
     if (!cacheLoaded) {
         if (!cacheLoadPromise) {
             cacheLoadPromise = (async () => {
-                try {
-                    const parsed = JSON.parse(await readFile(getCooldownFilePath(), "utf8"));
-                    memoryCache = Object.fromEntries(Object.entries(parsed)
-                        .filter((entry) => isPersistedCooldown(entry[1]))
-                        .map(([key, entry]) => [
-                        key,
-                        sanitizePersistedCooldown(key, entry),
-                    ]));
-                }
-                catch {
-                    memoryCache = {};
-                }
+                memoryCache = await readCooldownsFromDisk({});
                 cacheLoaded = true;
             })().finally(() => {
                 cacheLoadPromise = null;
@@ -91,14 +96,18 @@ export async function loadAccountCooldowns() {
 export async function saveAccountCooldown(accountKey, coolingUntil, reason) {
     await mutationMutex.runExclusive(async () => {
         await ensureAccountCooldownsLoaded();
-        const current = memoryCache[accountKey];
+        // Another worker (a draining one during a rolling restart) may have written
+        // the file since this one loaded it, so the change folds onto the file as
+        // it is now rather than onto this worker's copy.
+        const onDisk = await readCooldownsFromDisk(memoryCache);
+        memoryCache = onDisk;
+        const current = onDisk[accountKey];
         if (current && current.coolingUntil > coolingUntil) {
             return;
         }
-        memoryCache[accountKey] = {
-            coolingUntil,
-            reason,
-            updatedAt: Date.now(),
+        memoryCache = {
+            ...onDisk,
+            [accountKey]: { coolingUntil, reason, updatedAt: Date.now() },
         };
         await writeJsonSnapshotAtomically(getCooldownFilePath(), memoryCache);
     });
@@ -106,7 +115,11 @@ export async function saveAccountCooldown(accountKey, coolingUntil, reason) {
 export async function clearAccountCooldown(accountKey, expectedCoolingUntil) {
     await mutationMutex.runExclusive(async () => {
         await ensureAccountCooldownsLoaded();
-        const current = memoryCache[accountKey];
+        // Compare against the file, not this worker's copy: another worker may
+        // have extended this cooldown since, and that one must survive.
+        const onDisk = await readCooldownsFromDisk(memoryCache);
+        memoryCache = onDisk;
+        const current = onDisk[accountKey];
         if (!current) {
             return;
         }
@@ -114,7 +127,9 @@ export async function clearAccountCooldown(accountKey, expectedCoolingUntil) {
             current.coolingUntil !== expectedCoolingUntil) {
             return;
         }
-        delete memoryCache[accountKey];
+        const next = { ...onDisk };
+        delete next[accountKey];
+        memoryCache = next;
         await writeJsonSnapshotAtomically(getCooldownFilePath(), memoryCache);
     });
 }

package/dist/proxy/accountQuota.js

@@ -308,8 +308,8 @@ const FLUSH_INTERVAL_MS = 5_000; // write to disk at most every 5 seconds
 let memoryCache = {};
 let cacheLoaded = false;
 let cacheLoadPromise = null;
-let dirty = false;
-let cacheVersion = 0;
+/** Accounts this worker changed since its last flush. */
+let dirtyKeys = new Set();
 let flushTimer = null;
 const stateMutex = new AsyncMutex();
 const flushMutex = new AsyncMutex();
@@ -332,38 +332,86 @@ export function initAccountQuota(quotaFilePath) {
     memoryCache = {};
     cacheLoaded = false;
     cacheLoadPromise = null;
-    dirty = false;
-    cacheVersion = 0;
+    dirtyKeys = new Set();
 }
 function getQuotaFilePath() {
     return customQuotaFilePath ?? join(homedir(), ".neurolink", QUOTA_FILE);
 }
-/** Flush the in-memory cache to disk (async, non-blocking). */
+/**
+ * Read the quota file as it is now. A missing file is empty; any other failure
+ * (unreadable, corrupt) returns `fallback`, so a flush never discards entries
+ * just because one read failed.
+ */
+async function readQuotasFromDisk(filePath, fallback) {
+    try {
+        const parsed = JSON.parse(await fs.readFile(filePath, "utf-8"));
+        if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+            return fallback;
+        }
+        return parsed;
+    }
+    catch (error) {
+        return error.code === "ENOENT" ? {} : fallback;
+    }
+}
+/** Fold two snapshots of one account so the more recently updated one wins,
+ *  whichever worker wrote it. */
+function foldNewerQuota(onDisk, ours) {
+    if (!onDisk) {
+        return ours;
+    }
+    return onDisk.lastUpdated > ours.lastUpdated
+        ? mergeQuotaSnapshot(ours, onDisk)
+        : mergeQuotaSnapshot(onDisk, ours);
+}
+/** Flush this worker's changed accounts to disk (async, non-blocking). */
 async function flushToDisk() {
     await flushMutex.runExclusive(async () => {
-        let snapshot;
-        let snapshotVersion = 0;
+        let changed;
+        let fallback = {};
         let filePath = "";
         await stateMutex.runExclusive(async () => {
-            if (!dirty) {
+            if (dirtyKeys.size === 0) {
                 return;
             }
-            snapshot = Object.fromEntries(Object.entries(memoryCache).map(([key, quota]) => [key, { ...quota }]));
-            snapshotVersion = cacheVersion;
+            changed = Object.fromEntries([...dirtyKeys].map((key) => [key, { ...memoryCache[key] }]));
+            fallback = Object.fromEntries(Object.entries(memoryCache).map(([key, quota]) => [key, { ...quota }]));
+            dirtyKeys = new Set();
             filePath = getQuotaFilePath();
         });
-        if (!snapshot) {
+        const flushing = changed;
+        if (!flushing) {
             return;
         }
         try {
-            await writeJsonSnapshotAtomically(filePath, snapshot, 0o600);
+            // Another worker (a draining one during a rolling restart) may have
+            // written the file since this one loaded it: fold only this worker's
+            // changes onto the file as it is now, never rewrite it from this copy.
+            const onDisk = await readQuotasFromDisk(filePath, fallback);
+            const merged = { ...onDisk };
+            for (const [key, quota] of Object.entries(flushing)) {
+                merged[key] = foldNewerQuota(onDisk[key], quota);
+            }
+            await writeJsonSnapshotAtomically(filePath, merged, 0o600);
             await stateMutex.runExclusive(async () => {
-                if (cacheVersion === snapshotVersion) {
-                    dirty = false;
+                if (getQuotaFilePath() !== filePath) {
+                    return;
                 }
+                // Adopt what other workers wrote, keeping changes saved meanwhile.
+                memoryCache = {
+                    ...merged,
+                    ...Object.fromEntries([...dirtyKeys].map((key) => [key, memoryCache[key]])),
+                };
             });
         }
         catch {
+            await stateMutex.runExclusive(async () => {
+                if (getQuotaFilePath() === filePath) {
+                    for (const key of Object.keys(flushing)) {
+                        dirtyKeys.add(key);
+                    }
+                }
+            });
             // Non-fatal — quota is best-effort telemetry
         }
     });
@@ -394,13 +442,7 @@ async function ensureAccountQuotasLoaded() {
     if (!cacheLoaded) {
         if (!cacheLoadPromise) {
             cacheLoadPromise = (async () => {
-                try {
-                    const raw = await fs.readFile(getQuotaFilePath(), "utf-8");
-                    memoryCache = JSON.parse(raw);
-                }
-                catch {
-                    memoryCache = {};
-                }
+                memoryCache = await readQuotasFromDisk(getQuotaFilePath(), {});
                 cacheLoaded = true;
             })().finally(() => {
                 cacheLoadPromise = null;
@@ -436,8 +478,7 @@ export async function saveAccountQuota(accountKey, quota) {
         // A header capture reports only the windows the served request touched, so
         // it must fold onto the existing snapshot rather than replace it.
         memoryCache[accountKey] = mergeQuotaSnapshot(memoryCache[accountKey], quota);
-        dirty = true;
-        cacheVersion += 1;
+        dirtyKeys.add(accountKey);
     });
     scheduleFlush();
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@juspay/neurolink",
-  "version": "12.32.2",
+  "version": "12.32.3",
   "packageManager": "pnpm@10.15.1",
   "description": "The pipe layer of an AI nervous system: one interface connecting provider neurons to your application, across three inference types — generate, stream and decide. `decide` returns typed, calibrated judgements from a non-generative model (~400ms, ~$0.00002/call) for routing, tool selection and context budgeting. MCP-native (4 transports), voice TTS/STT/realtime, RAG, agents, memory, compaction, 9 observability exporters. OpenAI · Anthropic · Gemini · Bedrock · Azure · Ollama · TypeSafe Jev and more.",
   "author": {