@bendyline/gezel-inference 1.0.6 → 1.0.7

package/dist/cache/controller.d.ts

@@ -203,6 +203,7 @@ export declare class SessionCacheController {
      * call manually via `reconcileProvider`.
      */
     reconcileProvider(providerName: string): Promise<void>;
+    private reconcileState;
     /** Stop the background reconcile timer. Call on shutdown. */
     stop(): void;
     /**
@@ -213,5 +214,6 @@ export declare class SessionCacheController {
      * boundary.
      */
     private enforceBudget;
+    private evictOverBudget;
     private reconcileAll;
 }

package/dist/cache/controller.js

@@ -314,6 +314,23 @@ export class SessionCacheController {
         const state = this.providers.get(providerName);
         if (!state)
             return;
+        if (state.reconciliation)
+            return state.reconciliation;
+        const work = this.reconcileState(providerName, state);
+        state.reconciliation = work;
+        try {
+            await work;
+        }
+        finally {
+            if (state.reconciliation === work)
+                state.reconciliation = undefined;
+        }
+    }
+    async reconcileState(providerName, state) {
+        // A slow snapshot must not be rediscovered and queued for eviction every tick.
+        await state.eviction;
+        if (this.providers.get(providerName) !== state)
+            return;
         let usage;
         try {
             usage = await state.adapter.reportUsage();
@@ -322,6 +339,8 @@ export class SessionCacheController {
             this.logger.warn?.(`[cache] reportUsage failed for ${providerName}: ${err}`);
             return;
         }
+        if (this.providers.get(providerName) !== state)
+            return;
         // Replace the entries map — adapter's view wins. We preserve
         // eviction priority across the rebuild (operator pinning shouldn't
         // be lost on reconcile).
@@ -358,6 +377,23 @@ export class SessionCacheController {
         const state = this.providers.get(providerName);
         if (!state)
             return;
+        if (state.eviction)
+            return state.eviction;
+        const work = this.evictOverBudget(providerName, state);
+        if (!work)
+            return;
+        state.eviction = work;
+        try {
+            await work;
+        }
+        finally {
+            if (state.eviction === work)
+                state.eviction = undefined;
+        }
+        if (this.providers.get(providerName) === state)
+            await this.enforceBudget(providerName);
+    }
+    evictOverBudget(providerName, state) {
         let totalBytes = 0;
         for (const entry of state.entries.values())
             totalBytes += entry.bytes;
@@ -386,12 +422,9 @@ export class SessionCacheController {
             state.entries.delete(id);
         this.logger.info?.(`[cache] evicted ${toEvict.length} session(s) from ${providerName} ` +
             `(now ${(totalBytes / (1024 * 1024)).toFixed(1)} MB / ${(state.budgetBytes / (1024 * 1024)).toFixed(0)} MB)`);
-        try {
-            await state.adapter.evict(toEvict);
-        }
-        catch (err) {
+        return state.adapter.evict(toEvict).catch((err) => {
             this.logger.warn?.(`[cache] adapter.evict failed for ${providerName}: ${err}`);
-        }
+        });
     }
     async reconcileAll() {
         for (const name of this.providers.keys()) {