@sovovs/bycli 2.1.43 → 2.1.44

package/dist/src/adapter-scheduler.d.ts

@@ -40,12 +40,14 @@ export interface AdapterSchedulerOptions {
     leaseExpiryMs?: number;
     runtimeCeiling?: number;
     releasedLeaseRetentionMs?: number;
+    startIntervalMs?: number;
 }
 export declare class AdapterScheduler {
     private readonly now;
     private readonly leaseExpiryMs;
     private readonly runtimeCeiling;
     private readonly releasedLeaseRetentionMs;
+    private readonly startIntervalMs;
     private readonly pools;
     private readonly releasedLeaseIds;
     private readonly generations;
@@ -74,6 +76,9 @@ export declare class AdapterScheduler {
         grants: number;
     };
     private schedule;
+    private rejectExpiredQueued;
+    private clearPoolTimer;
+    private armPoolTimer;
     private scheduleResources;
     private releaseAllResourcesForLease;
     private pruneReleasedLeaseIds;

package/dist/src/adapter-scheduler.js

@@ -12,6 +12,7 @@ export class AdapterScheduler {
     leaseExpiryMs;
     runtimeCeiling;
     releasedLeaseRetentionMs;
+    startIntervalMs;
     pools = new Map();
     releasedLeaseIds = new Map();
     generations = new Map();
@@ -20,10 +21,15 @@ export class AdapterScheduler {
     resourceQueue = [];
     sequence = 0;
     constructor(options = {}) {
+        const startIntervalMs = options.startIntervalMs ?? 5_000;
+        if (!Number.isInteger(startIntervalMs) || startIntervalMs < 0) {
+            throw new Error('Adapter start interval must be a non-negative integer');
+        }
         this.now = options.now ?? Date.now;
         this.leaseExpiryMs = options.leaseExpiryMs ?? 45_000;
         this.runtimeCeiling = options.runtimeCeiling ?? 3;
         this.releasedLeaseRetentionMs = options.releasedLeaseRetentionMs ?? 300_000;
+        this.startIntervalMs = startIntervalMs;
     }
     acquire(request) {
         this.validateRequest(request);
@@ -73,6 +79,7 @@ export class AdapterScheduler {
         this.releasedLeaseIds.set(lease.leaseId, this.now() + this.releasedLeaseRetentionMs);
         if (release.reason === 'auth_gate' || release.reason === 'rate_limited') {
             pool.closed = release.reason;
+            this.clearPoolTimer(pool);
             const error = this.poolClosedError(release.reason);
             for (const pending of pool.queued.splice(0)) {
                 if (pending.timer)
@@ -144,14 +151,7 @@ export class AdapterScheduler {
         const now = this.now();
         this.pruneReleasedLeaseIds(now);
         for (const pool of [...this.pools.values()]) {
-            for (const pending of [...pool.queued]) {
-                if (pending.deadline > now)
-                    continue;
-                pool.queued.splice(pool.queued.indexOf(pending), 1);
-                if (pending.timer)
-                    clearTimeout(pending.timer);
-                pending.reject(new AdapterSchedulerError('ADAPTER_QUEUE_TIMEOUT', 'Timed out waiting for an Adapter command lease'));
-            }
+            this.rejectExpiredQueued(pool, now);
             for (const lease of [...pool.running.values()]) {
                 if (lease.heartbeatDeadline > now)
                     continue;
@@ -176,6 +176,7 @@ export class AdapterScheduler {
     }
     reset() {
         for (const pool of this.pools.values()) {
+            this.clearPoolTimer(pool);
             for (const pending of pool.queued) {
                 if (pending.timer)
                     clearTimeout(pending.timer);
@@ -209,34 +210,69 @@ export class AdapterScheduler {
         };
     }
     schedule(pool) {
-        while (!pool.closed && pool.running.size < pool.maxParallel) {
-            const eligible = pool.queued
-                .filter(entry => !pool.activeSessions.has(entry.request.adapterSession)
-                && pool.running.size < pool.maxParallel)
-                .sort((a, b) => a.enqueuedAt - b.enqueuedAt || a.sequence - b.sequence)[0];
-            if (!eligible)
-                return;
-            pool.queued.splice(pool.queued.indexOf(eligible), 1);
-            if (eligible.timer)
-                clearTimeout(eligible.timer);
-            const grantedAt = this.now();
-            const lease = {
-                leaseId: crypto.randomUUID(),
-                requestId: eligible.request.requestId,
-                poolKey: pool.key,
-                contextId: eligible.request.contextId,
-                surface: 'adapter',
-                site: eligible.request.site,
-                adapterSession: eligible.request.adapterSession,
-                sessionKey: eligible.request.sessionKey,
-                generation: pool.generation,
-                grantedAt,
-                heartbeatDeadline: grantedAt + this.leaseExpiryMs,
-            };
-            pool.running.set(lease.leaseId, lease);
-            pool.activeSessions.add(lease.adapterSession);
-            eligible.resolve({ ...lease });
+        if (pool.closed)
+            return;
+        const now = this.now();
+        this.rejectExpiredQueued(pool, now);
+        if (pool.running.size >= pool.maxParallel)
+            return;
+        const eligible = pool.queued
+            .filter(entry => !pool.activeSessions.has(entry.request.adapterSession))
+            .sort((a, b) => a.enqueuedAt - b.enqueuedAt || a.sequence - b.sequence)[0];
+        if (!eligible)
+            return;
+        if (now < pool.nextGrantAt) {
+            this.armPoolTimer(pool, pool.nextGrantAt);
+            return;
         }
+        pool.queued.splice(pool.queued.indexOf(eligible), 1);
+        if (eligible.timer)
+            clearTimeout(eligible.timer);
+        const grantedAt = now;
+        const lease = {
+            leaseId: crypto.randomUUID(),
+            requestId: eligible.request.requestId,
+            poolKey: pool.key,
+            contextId: eligible.request.contextId,
+            surface: 'adapter',
+            site: eligible.request.site,
+            adapterSession: eligible.request.adapterSession,
+            sessionKey: eligible.request.sessionKey,
+            generation: pool.generation,
+            grantedAt,
+            heartbeatDeadline: grantedAt + this.leaseExpiryMs,
+        };
+        pool.nextGrantAt = grantedAt + this.startIntervalMs;
+        pool.running.set(lease.leaseId, lease);
+        pool.activeSessions.add(lease.adapterSession);
+        eligible.resolve({ ...lease });
+        this.schedule(pool);
+    }
+    rejectExpiredQueued(pool, now) {
+        for (const pending of [...pool.queued]) {
+            if (pending.deadline > now)
+                continue;
+            pool.queued.splice(pool.queued.indexOf(pending), 1);
+            if (pending.timer)
+                clearTimeout(pending.timer);
+            pending.reject(new AdapterSchedulerError('ADAPTER_QUEUE_TIMEOUT', 'Timed out waiting for an Adapter command lease'));
+        }
+    }
+    clearPoolTimer(pool) {
+        if (pool.scheduleTimer)
+            clearTimeout(pool.scheduleTimer);
+        pool.scheduleTimer = undefined;
+    }
+    armPoolTimer(pool, dueAt) {
+        if (pool.scheduleTimer)
+            return;
+        pool.scheduleTimer = setTimeout(() => {
+            pool.scheduleTimer = undefined;
+            if (this.pools.get(pool.key) !== pool)
+                return;
+            this.sweepExpired();
+        }, Math.max(0, dueAt - this.now()));
+        pool.scheduleTimer.unref?.();
     }
     scheduleResources() {
         for (const pending of [...this.resourceQueue].sort((a, b) => a.sequence - b.sequence)) {
@@ -319,6 +355,7 @@ export class AdapterScheduler {
             key,
             generation,
             maxParallel: Math.min(request.maxParallel, this.runtimeCeiling),
+            nextGrantAt: 0,
             running: new Map(),
             activeSessions: new Set(),
             queued: [],
@@ -327,8 +364,14 @@ export class AdapterScheduler {
         return pool;
     }
     removeDrainedPool(pool) {
-        if (pool.running.size === 0 && pool.queued.length === 0)
-            this.pools.delete(pool.key);
+        if (pool.running.size !== 0 || pool.queued.length !== 0)
+            return;
+        if (!pool.closed && this.now() < pool.nextGrantAt) {
+            this.armPoolTimer(pool, pool.nextGrantAt);
+            return;
+        }
+        this.clearPoolTimer(pool);
+        this.pools.delete(pool.key);
     }
     poolClosedError(reason) {
         return reason === 'auth_gate'

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sovovs/bycli",
-  "version": "2.1.43",
+  "version": "2.1.44",
   "publishConfig": {
     "access": "public"
   },