@askalf/dario 3.4.6 → 3.5.0

package/dist/analytics.js

@@ -0,0 +1,198 @@
+/**
+ * Token analytics — per-request billing tracking, utilization trends,
+ * window exhaustion predictions, cost estimation.
+ *
+ * In-memory rolling window; exposed via the /analytics endpoint when
+ * pool mode is active.
+ */
+// Anthropic pricing (per 1M tokens, USD). Not authoritative — used for
+// rough burn-rate display in the /analytics summary.
+const PRICING = {
+    'claude-opus-4-6': { input: 15, output: 75, cacheRead: 1.5, cacheCreate: 18.75 },
+    'claude-sonnet-4-6': { input: 3, output: 15, cacheRead: 0.3, cacheCreate: 3.75 },
+    'claude-haiku-4-5': { input: 0.8, output: 4, cacheRead: 0.08, cacheCreate: 1 },
+};
+function estimateCost(record) {
+    const p = PRICING[record.model] ?? PRICING['claude-sonnet-4-6'];
+    return ((record.inputTokens * p.input) +
+        (record.outputTokens * p.output) +
+        (record.cacheReadTokens * p.cacheRead) +
+        (record.cacheCreateTokens * p.cacheCreate)) / 1_000_000;
+}
+export class Analytics {
+    records = [];
+    maxRecords;
+    constructor(maxRecords = 10_000) {
+        this.maxRecords = maxRecords;
+    }
+    record(r) {
+        this.records.push(r);
+        if (this.records.length > this.maxRecords) {
+            this.records = this.records.slice(-this.maxRecords);
+        }
+    }
+    /** Parse usage from a non-streaming Anthropic response body. */
+    static parseUsage(body) {
+        const u = body.usage;
+        const content = body.content;
+        const thinkingChars = content
+            ?.filter(b => b.type === 'thinking')
+            .reduce((s, b) => s + (b.thinking?.length ?? 0), 0) ?? 0;
+        const thinkingTokens = Math.round(thinkingChars / 4);
+        return {
+            inputTokens: u?.input_tokens ?? 0,
+            outputTokens: u?.output_tokens ?? 0,
+            cacheReadTokens: u?.cache_read_input_tokens ?? 0,
+            cacheCreateTokens: u?.cache_creation_input_tokens ?? 0,
+            thinkingTokens,
+            model: body.model ?? 'unknown',
+        };
+    }
+    summary(windowMinutes = 60) {
+        const cutoff = Date.now() - windowMinutes * 60_000;
+        const recent = this.records.filter(r => r.timestamp >= cutoff);
+        const allTime = this.records;
+        return {
+            window: {
+                minutes: windowMinutes,
+                requests: recent.length,
+                ...this.computeStats(recent),
+            },
+            allTime: {
+                requests: allTime.length,
+                ...this.computeStats(allTime),
+            },
+            perAccount: this.perAccountStats(recent),
+            perModel: this.perModelStats(recent),
+            utilization: this.utilizationTrend(recent),
+            predictions: this.predict(recent),
+        };
+    }
+    computeStats(records) {
+        if (records.length === 0) {
+            return {
+                totalInputTokens: 0, totalOutputTokens: 0, totalThinkingTokens: 0,
+                estimatedCost: 0, avgLatencyMs: 0, errorRate: 0,
+                claimBreakdown: {},
+            };
+        }
+        const totalInput = records.reduce((s, r) => s + r.inputTokens, 0);
+        const totalOutput = records.reduce((s, r) => s + r.outputTokens, 0);
+        const totalThinking = records.reduce((s, r) => s + r.thinkingTokens, 0);
+        const cost = records.reduce((s, r) => s + estimateCost(r), 0);
+        const avgLatency = records.reduce((s, r) => s + r.latencyMs, 0) / records.length;
+        const errors = records.filter(r => r.status >= 400).length;
+        const claims = {};
+        for (const r of records) {
+            claims[r.claim] = (claims[r.claim] ?? 0) + 1;
+        }
+        return {
+            totalInputTokens: totalInput,
+            totalOutputTokens: totalOutput,
+            totalThinkingTokens: totalThinking,
+            estimatedCost: Math.round(cost * 10000) / 10000,
+            avgLatencyMs: Math.round(avgLatency),
+            errorRate: Math.round((errors / records.length) * 10000) / 10000,
+            claimBreakdown: claims,
+        };
+    }
+    perAccountStats(records) {
+        const grouped = {};
+        for (const r of records) {
+            (grouped[r.account] ??= []).push(r);
+        }
+        const result = {};
+        for (const [account, recs] of Object.entries(grouped)) {
+            const last = recs[recs.length - 1];
+            result[account] = {
+                requests: recs.length,
+                inputTokens: recs.reduce((s, r) => s + r.inputTokens, 0),
+                outputTokens: recs.reduce((s, r) => s + r.outputTokens, 0),
+                estimatedCost: Math.round(recs.reduce((s, r) => s + estimateCost(r), 0) * 10000) / 10000,
+                currentUtil5h: last.util5h,
+                currentUtil7d: last.util7d,
+                lastClaim: last.claim,
+            };
+        }
+        return result;
+    }
+    perModelStats(records) {
+        const grouped = {};
+        for (const r of records) {
+            (grouped[r.model] ??= []).push(r);
+        }
+        const result = {};
+        for (const [model, recs] of Object.entries(grouped)) {
+            result[model] = {
+                requests: recs.length,
+                avgInputTokens: Math.round(recs.reduce((s, r) => s + r.inputTokens, 0) / recs.length),
+                avgOutputTokens: Math.round(recs.reduce((s, r) => s + r.outputTokens, 0) / recs.length),
+                avgThinkingTokens: Math.round(recs.reduce((s, r) => s + r.thinkingTokens, 0) / recs.length),
+                estimatedCost: Math.round(recs.reduce((s, r) => s + estimateCost(r), 0) * 10000) / 10000,
+            };
+        }
+        return result;
+    }
+    utilizationTrend(records) {
+        if (records.length === 0)
+            return [];
+        const bucketMs = 5 * 60_000;
+        const buckets = new Map();
+        for (const r of records) {
+            const key = Math.floor(r.timestamp / bucketMs) * bucketMs;
+            const existing = buckets.get(key);
+            if (existing) {
+                existing.push(r);
+            }
+            else {
+                buckets.set(key, [r]);
+            }
+        }
+        return [...buckets.entries()]
+            .sort(([a], [b]) => a - b)
+            .map(([ts, recs]) => ({
+            timestamp: ts,
+            avgUtil5h: Math.round(recs.reduce((s, r) => s + r.util5h, 0) / recs.length * 100) / 100,
+            avgUtil7d: Math.round(recs.reduce((s, r) => s + r.util7d, 0) / recs.length * 100) / 100,
+            requests: recs.length,
+        }));
+    }
+    predict(records) {
+        if (records.length < 3) {
+            return { estimatedExhaustionMinutes: null, tokenBurnRate: 0, costBurnRate: 0 };
+        }
+        const sorted = [...records].sort((a, b) => a.timestamp - b.timestamp);
+        const first = sorted[0];
+        const last = sorted[sorted.length - 1];
+        const durationMin = (last.timestamp - first.timestamp) / 60_000;
+        if (durationMin < 1) {
+            return { estimatedExhaustionMinutes: null, tokenBurnRate: 0, costBurnRate: 0 };
+        }
+        const totalTokens = sorted.reduce((s, r) => s + r.inputTokens + r.outputTokens, 0);
+        const totalCost = sorted.reduce((s, r) => s + estimateCost(r), 0);
+        const tokenBurnRate = totalTokens / durationMin;
+        const costBurnRate = (totalCost / durationMin) * 60;
+        const currentUtil = last.util5h;
+        if (currentUtil >= 0.95) {
+            return {
+                estimatedExhaustionMinutes: 0,
+                tokenBurnRate: Math.round(tokenBurnRate),
+                costBurnRate: Math.round(costBurnRate * 100) / 100,
+            };
+        }
+        const utilGrowthRate = (last.util5h - first.util5h) / durationMin;
+        if (utilGrowthRate <= 0) {
+            return {
+                estimatedExhaustionMinutes: null,
+                tokenBurnRate: Math.round(tokenBurnRate),
+                costBurnRate: Math.round(costBurnRate * 100) / 100,
+            };
+        }
+        const minutesToExhaustion = (1.0 - currentUtil) / utilGrowthRate;
+        return {
+            estimatedExhaustionMinutes: Math.round(minutesToExhaustion),
+            tokenBurnRate: Math.round(tokenBurnRate),
+            costBurnRate: Math.round(costBurnRate * 100) / 100,
+        };
+    }
+}

package/dist/cli.js

@@ -37,6 +37,7 @@ import { join } from 'node:path';
 import { homedir } from 'node:os';
 import { startAutoOAuthFlow, getStatus, refreshTokens, loadCredentials } from './oauth.js';
 import { startProxy, sanitizeError } from './proxy.js';
+import { listAccountAliases, loadAllAccounts, addAccountViaOAuth, removeAccount } from './accounts.js';
 const args = process.argv.slice(2);
 const command = args[0] ?? 'proxy';
 async function login() {
@@ -142,6 +143,114 @@ async function proxy() {
     const model = modelArg ? modelArg.split('=')[1] : undefined;
     await startProxy({ port, host, verbose, model, passthrough, preserveTools });
 }
+async function accounts() {
+    const sub = args[1];
+    if (!sub || sub === 'list') {
+        const aliases = await listAccountAliases();
+        console.log('');
+        console.log('  dario — Accounts');
+        console.log('  ────────────────');
+        console.log('');
+        if (aliases.length === 0) {
+            console.log('  No multi-account pool configured.');
+            console.log('');
+            console.log('  Pool mode activates automatically when ~/.dario/accounts/');
+            console.log('  has 2+ entries. Add the first with:');
+            console.log('    dario accounts add <alias>');
+            console.log('');
+            console.log('  Single-account dario (the default) keeps working as-is');
+            console.log('  with ~/.dario/credentials.json — you do not need to');
+            console.log('  migrate unless you want pool routing across accounts.');
+            console.log('');
+            return;
+        }
+        const loaded = await loadAllAccounts();
+        const now = Date.now();
+        console.log(`  ${aliases.length} account${aliases.length === 1 ? '' : 's'} configured`);
+        if (aliases.length === 1) {
+            console.log('  (Pool mode needs 2+ accounts — single-account mode until another is added.)');
+        }
+        console.log('');
+        for (const a of loaded) {
+            const msLeft = Math.max(0, a.expiresAt - now);
+            const hours = Math.floor(msLeft / 3600000);
+            const mins = Math.floor((msLeft % 3600000) / 60000);
+            const expiry = msLeft > 0 ? `${hours}h ${mins}m` : 'expired';
+            console.log(`    ${a.alias.padEnd(20)} token expires in ${expiry}`);
+        }
+        console.log('');
+        return;
+    }
+    if (sub === 'add') {
+        const alias = args[2];
+        if (!alias) {
+            console.error('');
+            console.error('  Usage: dario accounts add <alias>');
+            console.error('');
+            console.error('  <alias> is any label you want for the account (e.g. "work", "personal").');
+            console.error('');
+            process.exit(1);
+        }
+        if (!/^[a-zA-Z0-9._-]+$/.test(alias)) {
+            console.error('[dario] Invalid alias. Use letters, numbers, dot, underscore, dash only.');
+            process.exit(1);
+        }
+        const existing = await listAccountAliases();
+        if (existing.includes(alias)) {
+            console.error(`[dario] Account "${alias}" already exists. Remove it first with \`dario accounts remove ${alias}\`.`);
+            process.exit(1);
+        }
+        console.log('');
+        console.log(`  Adding account "${alias}" to the pool...`);
+        console.log('');
+        try {
+            const creds = await addAccountViaOAuth(alias);
+            const minutes = Math.round((creds.expiresAt - Date.now()) / 60000);
+            console.log('');
+            console.log(`  Account "${alias}" added.`);
+            console.log(`  Token expires in ${minutes} minutes (auto-refreshes in the background).`);
+            const total = (await listAccountAliases()).length;
+            if (total >= 2) {
+                console.log('');
+                console.log('  Pool mode is now active. Restart `dario proxy` to pick up the new account.');
+            }
+            else {
+                console.log('');
+                console.log('  Add at least one more account to activate pool routing:');
+                console.log('    dario accounts add <another-alias>');
+            }
+            console.log('');
+        }
+        catch (err) {
+            console.error('');
+            console.error(`  Failed to add account: ${sanitizeError(err)}`);
+            console.error('');
+            process.exit(1);
+        }
+        return;
+    }
+    if (sub === 'remove' || sub === 'rm') {
+        const alias = args[2];
+        if (!alias) {
+            console.error('');
+            console.error('  Usage: dario accounts remove <alias>');
+            console.error('');
+            process.exit(1);
+        }
+        const ok = await removeAccount(alias);
+        if (ok) {
+            console.log(`[dario] Account "${alias}" removed.`);
+        }
+        else {
+            console.error(`[dario] No account "${alias}" found.`);
+            process.exit(1);
+        }
+        return;
+    }
+    console.error(`[dario] Unknown accounts subcommand: ${sub}`);
+    console.error('Usage: dario accounts [list|add <alias>|remove <alias>]');
+    process.exit(1);
+}
 async function help() {
     console.log(`
   dario — Use your Claude subscription as an API.
@@ -152,6 +261,9 @@ async function help() {
     dario status             Check authentication status
     dario refresh            Force token refresh
     dario logout             Remove saved credentials
+    dario accounts list      List accounts in the multi-account pool
+    dario accounts add NAME  Add a new account to the pool (runs OAuth flow)
+    dario accounts remove N  Remove an account from the pool
 
   Proxy options:
     --model=MODEL            Force a model for all requests
@@ -206,6 +318,7 @@ const commands = {
     proxy,
     refresh,
     logout,
+    accounts,
     help,
     version,
     '--help': help,

package/dist/index.d.ts

@@ -7,3 +7,9 @@
 export { startAutoOAuthFlow, refreshTokens, getAccessToken, getStatus, loadCredentials } from './oauth.js';
 export type { OAuthTokens, CredentialsFile } from './oauth.js';
 export { startProxy, sanitizeError } from './proxy.js';
+export { AccountPool, parseRateLimits } from './pool.js';
+export type { PoolAccount, PoolStatus, RateLimitSnapshot, AccountIdentity } from './pool.js';
+export { listAccountAliases, loadAccount, loadAllAccounts, saveAccount, removeAccount, refreshAccountToken, addAccountViaOAuth, getAccountsDir, } from './accounts.js';
+export type { AccountCredentials } from './accounts.js';
+export { Analytics } from './analytics.js';
+export type { RequestRecord, AnalyticsSummary } from './analytics.js';

package/dist/index.js

@@ -6,3 +6,9 @@
  */
 export { startAutoOAuthFlow, refreshTokens, getAccessToken, getStatus, loadCredentials } from './oauth.js';
 export { startProxy, sanitizeError } from './proxy.js';
+// Multi-account pool API (pool activates automatically when ~/.dario/accounts/
+// contains 2+ accounts; see README for the progression from single-account
+// mode to pool mode).
+export { AccountPool, parseRateLimits } from './pool.js';
+export { listAccountAliases, loadAccount, loadAllAccounts, saveAccount, removeAccount, refreshAccountToken, addAccountViaOAuth, getAccountsDir, } from './accounts.js';
+export { Analytics } from './analytics.js';

package/dist/pool.d.ts

@@ -0,0 +1,68 @@
+export interface AccountIdentity {
+    deviceId: string;
+    accountUuid: string;
+    sessionId: string;
+}
+export interface RateLimitSnapshot {
+    status: string;
+    util5h: number;
+    util7d: number;
+    overageUtil: number;
+    claim: string;
+    reset: number;
+    fallbackPct: number;
+    updatedAt: number;
+}
+export declare const EMPTY_SNAPSHOT: RateLimitSnapshot;
+export interface PoolAccount {
+    alias: string;
+    accessToken: string;
+    refreshToken: string;
+    expiresAt: number;
+    identity: AccountIdentity;
+    rateLimit: RateLimitSnapshot;
+    requestCount: number;
+}
+export interface PoolStatus {
+    accounts: number;
+    healthy: number;
+    exhausted: number;
+    totalHeadroom: number;
+    bestAccount: string;
+    queued: number;
+}
+/** Parse an Anthropic response's rate-limit headers into a snapshot. */
+export declare function parseRateLimits(headers: Headers): RateLimitSnapshot;
+export declare class AccountPool {
+    private accounts;
+    private queue;
+    private queueMaxSize;
+    private queueTimeoutMs;
+    private drainTimer;
+    add(alias: string, opts: {
+        accessToken: string;
+        refreshToken: string;
+        expiresAt: number;
+        deviceId: string;
+        accountUuid: string;
+    }): void;
+    remove(alias: string): boolean;
+    get size(): number;
+    /** Select the best account for the next request. */
+    select(): PoolAccount | null;
+    /** Select the next-best account, excluding the given alias. */
+    selectExcluding(excludeAlias: string): PoolAccount | null;
+    updateRateLimits(alias: string, snapshot: RateLimitSnapshot): void;
+    markRejected(alias: string, snapshot: RateLimitSnapshot): void;
+    updateTokens(alias: string, accessToken: string, refreshToken: string, expiresAt: number): void;
+    get(alias: string): PoolAccount | undefined;
+    all(): PoolAccount[];
+    status(): PoolStatus;
+    /**
+     * Wait for an available account. If all accounts are exhausted, queues
+     * the request and resolves when an account becomes available via
+     * updateRateLimits reducing utilization below threshold.
+     */
+    waitForAccount(): Promise<PoolAccount>;
+    private drainQueue;
+}

package/dist/pool.js

@@ -0,0 +1,212 @@
+/**
+ * Account pool — rate limit tracking, headroom routing, failover.
+ *
+ * Activated automatically when `~/.dario/accounts/` contains 2+ accounts.
+ * Single-account dario (`~/.dario/credentials.json`) keeps the same code
+ * path it has always had; the pool only runs when there are multiple
+ * accounts to distribute against.
+ */
+import { randomUUID } from 'node:crypto';
+export const EMPTY_SNAPSHOT = {
+    status: 'unknown',
+    util5h: 0,
+    util7d: 0,
+    overageUtil: 0,
+    claim: 'unknown',
+    reset: 0,
+    fallbackPct: 0,
+    updatedAt: 0,
+};
+/** Parse an Anthropic response's rate-limit headers into a snapshot. */
+export function parseRateLimits(headers) {
+    const get = (key) => headers.get(`anthropic-ratelimit-unified-${key}`) ?? '';
+    return {
+        status: get('status') || 'unknown',
+        util5h: parseFloat(get('5h-utilization')) || 0,
+        util7d: parseFloat(get('7d-utilization')) || 0,
+        overageUtil: parseFloat(get('overage-utilization')) || 0,
+        claim: get('representative-claim') || 'unknown',
+        reset: parseInt(get('reset')) || 0,
+        fallbackPct: parseFloat(get('fallback-percentage')) || 0,
+        updatedAt: Date.now(),
+    };
+}
+export class AccountPool {
+    accounts = new Map();
+    queue = [];
+    queueMaxSize = 50;
+    queueTimeoutMs = 60_000;
+    drainTimer = null;
+    add(alias, opts) {
+        const existing = this.accounts.get(alias);
+        this.accounts.set(alias, {
+            alias,
+            accessToken: opts.accessToken,
+            refreshToken: opts.refreshToken,
+            expiresAt: opts.expiresAt,
+            identity: existing?.identity ?? {
+                deviceId: opts.deviceId,
+                accountUuid: opts.accountUuid,
+                sessionId: randomUUID(),
+            },
+            rateLimit: existing?.rateLimit ?? { ...EMPTY_SNAPSHOT },
+            requestCount: existing?.requestCount ?? 0,
+        });
+    }
+    remove(alias) {
+        return this.accounts.delete(alias);
+    }
+    get size() {
+        return this.accounts.size;
+    }
+    /** Select the best account for the next request. */
+    select() {
+        if (this.accounts.size === 0)
+            return null;
+        const now = Date.now();
+        const all = [...this.accounts.values()];
+        const eligible = all.filter(a => a.rateLimit.status !== 'rejected' &&
+            a.expiresAt > now + 30_000);
+        if (eligible.length > 0) {
+            return eligible.reduce((best, curr) => {
+                const bestHeadroom = 1 - Math.max(best.rateLimit.util5h, best.rateLimit.util7d);
+                const currHeadroom = 1 - Math.max(curr.rateLimit.util5h, curr.rateLimit.util7d);
+                return currHeadroom > bestHeadroom ? curr : best;
+            });
+        }
+        // All accounts exhausted — return the one with the earliest reset
+        const withReset = all.filter(a => a.rateLimit.reset > 0);
+        if (withReset.length > 0) {
+            return withReset.reduce((a, b) => a.rateLimit.reset < b.rateLimit.reset ? a : b);
+        }
+        // No rate-limit data at all — least-used first
+        return all.reduce((a, b) => a.requestCount < b.requestCount ? a : b);
+    }
+    /** Select the next-best account, excluding the given alias. */
+    selectExcluding(excludeAlias) {
+        if (this.accounts.size <= 1)
+            return null;
+        const now = Date.now();
+        const candidates = [...this.accounts.values()].filter(a => a.alias !== excludeAlias);
+        const eligible = candidates.filter(a => a.rateLimit.status !== 'rejected' &&
+            a.expiresAt > now + 30_000);
+        if (eligible.length > 0) {
+            return eligible.reduce((best, curr) => {
+                const bestHeadroom = 1 - Math.max(best.rateLimit.util5h, best.rateLimit.util7d);
+                const currHeadroom = 1 - Math.max(curr.rateLimit.util5h, curr.rateLimit.util7d);
+                return currHeadroom > bestHeadroom ? curr : best;
+            });
+        }
+        if (candidates.length > 0) {
+            return candidates.reduce((a, b) => a.requestCount < b.requestCount ? a : b);
+        }
+        return null;
+    }
+    updateRateLimits(alias, snapshot) {
+        const account = this.accounts.get(alias);
+        if (!account)
+            return;
+        account.rateLimit = snapshot;
+        account.requestCount++;
+    }
+    markRejected(alias, snapshot) {
+        const account = this.accounts.get(alias);
+        if (!account)
+            return;
+        account.rateLimit = { ...snapshot, status: 'rejected' };
+    }
+    updateTokens(alias, accessToken, refreshToken, expiresAt) {
+        const account = this.accounts.get(alias);
+        if (!account)
+            return;
+        account.accessToken = accessToken;
+        account.refreshToken = refreshToken;
+        account.expiresAt = expiresAt;
+    }
+    get(alias) {
+        return this.accounts.get(alias);
+    }
+    all() {
+        return [...this.accounts.values()];
+    }
+    status() {
+        const all = this.all();
+        const now = Date.now();
+        const healthy = all.filter(a => a.rateLimit.status !== 'rejected' &&
+            a.expiresAt > now + 30_000);
+        const headrooms = all.map(a => 1 - Math.max(a.rateLimit.util5h, a.rateLimit.util7d));
+        const avgHeadroom = headrooms.length > 0 ? headrooms.reduce((a, b) => a + b, 0) / headrooms.length : 0;
+        const best = this.select();
+        return {
+            accounts: all.length,
+            healthy: healthy.length,
+            exhausted: all.length - healthy.length,
+            totalHeadroom: Math.round(avgHeadroom * 100),
+            bestAccount: best?.alias ?? 'none',
+            queued: this.queue.length,
+        };
+    }
+    /**
+     * Wait for an available account. If all accounts are exhausted, queues
+     * the request and resolves when an account becomes available via
+     * updateRateLimits reducing utilization below threshold.
+     */
+    async waitForAccount() {
+        const immediate = this.select();
+        if (immediate) {
+            const headroom = 1 - Math.max(immediate.rateLimit.util5h, immediate.rateLimit.util7d);
+            if (headroom > 0.02)
+                return immediate;
+        }
+        if (this.queue.length >= this.queueMaxSize) {
+            throw new Error('Queue full — all accounts exhausted');
+        }
+        if (!this.drainTimer) {
+            this.drainTimer = setInterval(() => this.drainQueue(), 5_000);
+            this.drainTimer.unref();
+        }
+        return new Promise((resolve, reject) => {
+            const entry = { resolve, reject, enqueuedAt: Date.now() };
+            this.queue.push(entry);
+            setTimeout(() => {
+                const idx = this.queue.indexOf(entry);
+                if (idx >= 0) {
+                    this.queue.splice(idx, 1);
+                    reject(new Error('Queue timeout — no accounts available within 60s'));
+                }
+            }, this.queueTimeoutMs);
+        });
+    }
+    drainQueue() {
+        if (this.queue.length === 0) {
+            if (this.drainTimer) {
+                clearInterval(this.drainTimer);
+                this.drainTimer = null;
+            }
+            return;
+        }
+        const now = Date.now();
+        this.queue = this.queue.filter(entry => {
+            if (now - entry.enqueuedAt > this.queueTimeoutMs) {
+                entry.reject(new Error('Queue timeout — no accounts available within 60s'));
+                return false;
+            }
+            return true;
+        });
+        while (this.queue.length > 0) {
+            const account = this.select();
+            if (!account)
+                break;
+            const headroom = 1 - Math.max(account.rateLimit.util5h, account.rateLimit.util7d);
+            if (headroom <= 0.02)
+                break;
+            const entry = this.queue.shift();
+            if (entry)
+                entry.resolve(account);
+        }
+        if (this.queue.length === 0 && this.drainTimer) {
+            clearInterval(this.drainTimer);
+            this.drainTimer = null;
+        }
+    }
+}