auditor-lambda 0.3.32 → 0.3.34

package/dist/orchestrator/reviewPackets.js

@@ -2,8 +2,19 @@ import { createHash } from "node:crypto";
 import { LENS_ORDER } from "./unitBuilder.js";
 const DEFAULT_MAX_TASKS_PER_PACKET = 0;
 const DEFAULT_TARGET_PACKET_LINES = 8000;
-const ESTIMATED_TOKENS_PER_LINE = 4;
-const ESTIMATED_PACKET_PROMPT_TOKENS = 900;
+export const ESTIMATED_TOKENS_PER_LINE = 4;
+export const ESTIMATED_PACKET_PROMPT_TOKENS = 900;
+export function estimateTaskGroupTokens(tasks) {
+    let totalLines = 0;
+    for (const task of tasks) {
+        if (task.file_line_counts) {
+            for (const count of Object.values(task.file_line_counts)) {
+                totalLines += count;
+            }
+        }
+    }
+    return ESTIMATED_PACKET_PROMPT_TOKENS + totalLines * ESTIMATED_TOKENS_PER_LINE;
+}
 const PACKET_EXPANSION_MIN_CONFIDENCE = 0.65;
 const HIGH_FAN_DEGREE_THRESHOLD = 12;
 const HIGH_FAN_EXPANSION_CONFIDENCE = 0.99;

package/dist/quota/compositeQuotaSource.d.ts

@@ -0,0 +1,7 @@
+import type { QuotaSource, QuotaUsageSnapshot } from "./quotaSource.js";
+export declare class CompositeQuotaSource implements QuotaSource {
+    readonly name = "composite";
+    private sources;
+    constructor(sources: QuotaSource[]);
+    queryCurrentUsage(providerModelKey: string): Promise<QuotaUsageSnapshot | null>;
+}

package/dist/quota/compositeQuotaSource.js

@@ -0,0 +1,20 @@
+export class CompositeQuotaSource {
+    name = "composite";
+    sources;
+    constructor(sources) {
+        this.sources = sources;
+    }
+    async queryCurrentUsage(providerModelKey) {
+        for (const source of this.sources) {
+            try {
+                const snapshot = await source.queryCurrentUsage(providerModelKey);
+                if (snapshot)
+                    return snapshot;
+            }
+            catch {
+                // Skip failing sources, try next
+            }
+        }
+        return null;
+    }
+}

package/dist/quota/errorParsers/claudeCodeErrorParser.d.ts

@@ -0,0 +1,6 @@
+import type { RateLimitDetectionResult } from "../errorParsing.js";
+import type { ErrorParser } from "./genericErrorParser.js";
+export declare class ClaudeCodeErrorParser implements ErrorParser {
+    readonly name = "claude-code";
+    parse(text: string): RateLimitDetectionResult;
+}

package/dist/quota/errorParsers/claudeCodeErrorParser.js

@@ -0,0 +1,39 @@
+export class ClaudeCodeErrorParser {
+    name = "claude-code";
+    parse(text) {
+        for (const line of text.split("\n")) {
+            const trimmed = line.trim();
+            if (!trimmed.startsWith("{"))
+                continue;
+            try {
+                const obj = JSON.parse(trimmed);
+                const level = obj["level"];
+                const type = obj["type"];
+                const message = obj["message"] ?? "";
+                const statusCode = obj["status_code"];
+                if (statusCode === 429 ||
+                    type === "rate_limit_error" ||
+                    (level === "error" && /\brate.?limit/i.test(message))) {
+                    const retryAfter = obj["retry_after"];
+                    const retryAfterMs = obj["retry_after_ms"];
+                    let extractedMs = null;
+                    if (retryAfterMs != null && retryAfterMs > 0) {
+                        extractedMs = retryAfterMs;
+                    }
+                    else if (retryAfter != null && retryAfter > 0) {
+                        extractedMs = retryAfter < 600 ? retryAfter * 1000 : retryAfter;
+                    }
+                    return {
+                        isRateLimited: true,
+                        retryAfterMs: extractedMs,
+                        rawMatch: `claude-code-stderr:${statusCode ?? type ?? "rate_limit"}`,
+                    };
+                }
+            }
+            catch {
+                // Not valid JSON, skip
+            }
+        }
+        return { isRateLimited: false, retryAfterMs: null, rawMatch: null };
+    }
+}

package/dist/quota/errorParsers/genericErrorParser.d.ts

@@ -0,0 +1,9 @@
+import type { RateLimitDetectionResult } from "../errorParsing.js";
+export interface ErrorParser {
+    readonly name: string;
+    parse(text: string): RateLimitDetectionResult;
+}
+export declare class GenericErrorParser implements ErrorParser {
+    readonly name = "generic";
+    parse(text: string): RateLimitDetectionResult;
+}

package/dist/quota/errorParsers/genericErrorParser.js

@@ -0,0 +1,7 @@
+import { detectRateLimitError } from "../errorParsing.js";
+export class GenericErrorParser {
+    name = "generic";
+    parse(text) {
+        return detectRateLimitError(text);
+    }
+}

package/dist/quota/errorParsers/index.d.ts

@@ -0,0 +1,5 @@
+export type { ErrorParser } from "./genericErrorParser.js";
+export { GenericErrorParser } from "./genericErrorParser.js";
+export { ClaudeCodeErrorParser } from "./claudeCodeErrorParser.js";
+import type { ErrorParser } from "./genericErrorParser.js";
+export declare function getErrorParserForProvider(providerName: string): ErrorParser;

package/dist/quota/errorParsers/index.js

@@ -0,0 +1,12 @@
+export { GenericErrorParser } from "./genericErrorParser.js";
+export { ClaudeCodeErrorParser } from "./claudeCodeErrorParser.js";
+import { GenericErrorParser } from "./genericErrorParser.js";
+import { ClaudeCodeErrorParser } from "./claudeCodeErrorParser.js";
+const PROVIDER_PARSERS = {
+    "claude-code": () => new ClaudeCodeErrorParser(),
+};
+const genericParser = new GenericErrorParser();
+export function getErrorParserForProvider(providerName) {
+    const factory = PROVIDER_PARSERS[providerName];
+    return factory ? factory() : genericParser;
+}

package/dist/quota/errorParsing.d.ts

@@ -0,0 +1,7 @@
+export interface RateLimitDetectionResult {
+    isRateLimited: boolean;
+    retryAfterMs: number | null;
+    rawMatch: string | null;
+}
+export declare function detectRateLimitError(text: string): RateLimitDetectionResult;
+export declare function computeCooldownUntil(retryAfterMs: number | null, defaultMs?: number): string;

package/dist/quota/errorParsing.js

@@ -0,0 +1,69 @@
+const RATE_LIMIT_PATTERNS = [
+    /\b429\b/i,
+    /\btoo many requests\b/i,
+    /\brate.?limit/i,
+    /\boverloaded\b/i,
+    /\bresource.?exhausted\b/i,
+    /\bquota.?exceeded\b/i,
+];
+function tryParseJson(text) {
+    const jsonStart = text.indexOf("{");
+    if (jsonStart === -1)
+        return null;
+    try {
+        return JSON.parse(text.slice(jsonStart));
+    }
+    catch {
+        return null;
+    }
+}
+function extractRetryAfterMs(obj) {
+    const headers = obj["headers"];
+    const retryAfter = headers?.["retry-after"] ??
+        headers?.["Retry-After"] ??
+        obj["retry_after"] ??
+        obj["retry_after_ms"];
+    if (retryAfter == null)
+        return null;
+    const val = typeof retryAfter === "string" ? Number(retryAfter) : retryAfter;
+    if (!Number.isFinite(val) || val <= 0)
+        return null;
+    // If the value looks like seconds (< 600), convert to ms
+    return val < 600 ? val * 1000 : val;
+}
+function detectFromJson(text) {
+    const obj = tryParseJson(text);
+    if (!obj)
+        return null;
+    const status = obj["status"];
+    const type = obj["type"];
+    const errorObj = obj["error"];
+    const errorType = errorObj?.["type"];
+    const isRateLimited = status === 429 ||
+        type === "rate_limit_error" ||
+        errorType === "rate_limit_error";
+    if (!isRateLimited)
+        return null;
+    return {
+        isRateLimited: true,
+        retryAfterMs: extractRetryAfterMs(obj),
+        rawMatch: `json:${status === 429 ? "status=429" : `type=${type ?? errorType}`}`,
+    };
+}
+export function detectRateLimitError(text) {
+    const jsonResult = detectFromJson(text);
+    if (jsonResult)
+        return jsonResult;
+    for (const pattern of RATE_LIMIT_PATTERNS) {
+        const match = pattern.exec(text);
+        if (match) {
+            return { isRateLimited: true, retryAfterMs: null, rawMatch: match[0] };
+        }
+    }
+    return { isRateLimited: false, retryAfterMs: null, rawMatch: null };
+}
+const DEFAULT_COOLDOWN_MS = 60_000;
+export function computeCooldownUntil(retryAfterMs, defaultMs = DEFAULT_COOLDOWN_MS) {
+    const ms = retryAfterMs != null && retryAfterMs > 0 ? retryAfterMs : defaultMs;
+    return new Date(Date.now() + ms).toISOString();
+}

package/dist/quota/fileLock.d.ts

@@ -0,0 +1,6 @@
+export declare class FileLockTimeoutError extends Error {
+    constructor(lockPath: string);
+}
+export declare function acquireLock(lockPath: string, timeoutMs?: number): Promise<void>;
+export declare function releaseLock(lockPath: string): Promise<void>;
+export declare function withFileLock<T>(lockPath: string, fn: () => Promise<T>, timeoutMs?: number): Promise<T>;

package/dist/quota/fileLock.js

@@ -0,0 +1,64 @@
+import { open, unlink, stat } from "node:fs/promises";
+const STALE_LOCK_MS = 30_000;
+const RETRY_INTERVAL_MS = 50;
+const DEFAULT_TIMEOUT_MS = 10_000;
+export class FileLockTimeoutError extends Error {
+    constructor(lockPath) {
+        super(`Timed out acquiring lock: ${lockPath}`);
+        this.name = "FileLockTimeoutError";
+    }
+}
+async function isLockStale(lockPath) {
+    try {
+        const info = await stat(lockPath);
+        return Date.now() - info.mtimeMs > STALE_LOCK_MS;
+    }
+    catch {
+        return false;
+    }
+}
+export async function acquireLock(lockPath, timeoutMs = DEFAULT_TIMEOUT_MS) {
+    const deadline = Date.now() + timeoutMs;
+    while (true) {
+        try {
+            const fd = await open(lockPath, "wx");
+            await fd.close();
+            return;
+        }
+        catch (err) {
+            if (err.code !== "EEXIST")
+                throw err;
+        }
+        if (await isLockStale(lockPath)) {
+            try {
+                await unlink(lockPath);
+                continue;
+            }
+            catch {
+                // Another process may have already cleaned it up
+            }
+        }
+        if (Date.now() >= deadline) {
+            throw new FileLockTimeoutError(lockPath);
+        }
+        await new Promise((r) => setTimeout(r, RETRY_INTERVAL_MS));
+    }
+}
+export async function releaseLock(lockPath) {
+    try {
+        await unlink(lockPath);
+    }
+    catch (err) {
+        if (err.code !== "ENOENT")
+            throw err;
+    }
+}
+export async function withFileLock(lockPath, fn, timeoutMs) {
+    await acquireLock(lockPath, timeoutMs);
+    try {
+        return await fn();
+    }
+    finally {
+        await releaseLock(lockPath);
+    }
+}

package/dist/quota/index.d.ts

@@ -1,9 +1,19 @@
 export { resolveLimits, lookupKnownModel, classifyProvider } from "./limits.js";
 export type { LimitResolutionResult, ResolveLimitsOptions, ProviderType } from "./limits.js";
 export { detectHostActiveSubagentLimit, resolveHostActiveSubagentLimit, } from "./hostLimits.js";
-export { readQuotaState, writeQuotaState, computeMaxSafeConcurrency, recordWaveOutcome, getQuotaStatePath, decayWeight, applyDecayToEntry, } from "./state.js";
+export { readQuotaState, writeQuotaState, computeMaxSafeConcurrency, recordWaveOutcome, getQuotaStatePath, decayWeight, applyDecayToEntry, computeBackoffCooldownMs, computeBackoffFailureWeight, computeRampUpConcurrency, } from "./state.js";
 export { scheduleWave, buildProviderModelKey } from "./scheduler.js";
 export type { ScheduleWaveOptions } from "./scheduler.js";
+export { detectRateLimitError, computeCooldownUntil } from "./errorParsing.js";
+export { acquireLock, releaseLock, withFileLock, FileLockTimeoutError } from "./fileLock.js";
+export { runSlidingWindow } from "./slidingWindow.js";
+export type { SlidingWindowResult } from "./slidingWindow.js";
+export type { RateLimitDetectionResult } from "./errorParsing.js";
 export { probeProvider } from "./probe.js";
 export type { ProbeResult } from "./probe.js";
+export type { QuotaSource, QuotaUsageSnapshot } from "./quotaSource.js";
+export type { ErrorParser } from "./errorParsers/index.js";
+export { GenericErrorParser, ClaudeCodeErrorParser, getErrorParserForProvider } from "./errorParsers/index.js";
+export { LearnedQuotaSource } from "./learnedQuotaSource.js";
+export { CompositeQuotaSource } from "./compositeQuotaSource.js";
 export type { ResolvedLimits, LimitSource, LimitConfidence, HostConcurrencyLimit, HostConcurrencyLimitSource, QuotaState, QuotaStateEntry, ConcurrencyBucket, WaveSchedule, DispatchQuota, ObservedWaveOutcome, } from "./types.js";

package/dist/quota/index.js

@@ -1,5 +1,11 @@
 export { resolveLimits, lookupKnownModel, classifyProvider } from "./limits.js";
 export { detectHostActiveSubagentLimit, resolveHostActiveSubagentLimit, } from "./hostLimits.js";
-export { readQuotaState, writeQuotaState, computeMaxSafeConcurrency, recordWaveOutcome, getQuotaStatePath, decayWeight, applyDecayToEntry, } from "./state.js";
+export { readQuotaState, writeQuotaState, computeMaxSafeConcurrency, recordWaveOutcome, getQuotaStatePath, decayWeight, applyDecayToEntry, computeBackoffCooldownMs, computeBackoffFailureWeight, computeRampUpConcurrency, } from "./state.js";
 export { scheduleWave, buildProviderModelKey } from "./scheduler.js";
+export { detectRateLimitError, computeCooldownUntil } from "./errorParsing.js";
+export { acquireLock, releaseLock, withFileLock, FileLockTimeoutError } from "./fileLock.js";
+export { runSlidingWindow } from "./slidingWindow.js";
 export { probeProvider } from "./probe.js";
+export { GenericErrorParser, ClaudeCodeErrorParser, getErrorParserForProvider } from "./errorParsers/index.js";
+export { LearnedQuotaSource } from "./learnedQuotaSource.js";
+export { CompositeQuotaSource } from "./compositeQuotaSource.js";

package/dist/quota/learnedQuotaSource.d.ts

@@ -0,0 +1,7 @@
+import type { QuotaSource, QuotaUsageSnapshot } from "./quotaSource.js";
+export declare class LearnedQuotaSource implements QuotaSource {
+    readonly name = "learned";
+    private halfLifeHours;
+    constructor(halfLifeHours?: number);
+    queryCurrentUsage(providerModelKey: string): Promise<QuotaUsageSnapshot | null>;
+}

package/dist/quota/learnedQuotaSource.js

@@ -0,0 +1,25 @@
+import { readQuotaState, computeMaxSafeConcurrency } from "./state.js";
+export class LearnedQuotaSource {
+    name = "learned";
+    halfLifeHours;
+    constructor(halfLifeHours = 24) {
+        this.halfLifeHours = halfLifeHours;
+    }
+    async queryCurrentUsage(providerModelKey) {
+        const state = await readQuotaState();
+        const entry = state.entries[providerModelKey];
+        if (!entry)
+            return null;
+        const maxSafe = computeMaxSafeConcurrency(entry, this.halfLifeHours);
+        const isInCooldown = entry.cooldown_until != null &&
+            new Date(entry.cooldown_until).getTime() > Date.now();
+        return {
+            remaining_pct: isInCooldown ? 0 : null,
+            reset_at: isInCooldown ? entry.cooldown_until : null,
+            requests_remaining: maxSafe,
+            tokens_remaining: null,
+            captured_at: entry.updated_at,
+            source: "learned",
+        };
+    }
+}

package/dist/quota/probe.d.ts

@@ -5,9 +5,6 @@ export interface ProbeResult {
 /**
  * Probe a provider to discover its rate limits.
  *
- * Only subprocess-template supports direct probing since it is the only
- * provider where the auditor controls the API call. IDE providers
- * (claude-code, opencode) select the model internally; their limits come
- * from known-model metadata or learned behavior.
+ * @deprecated Phase 3A replaces this with the QuotaSource abstraction.
  */
 export declare function probeProvider(providerName: string, probeMode?: "auto" | "never" | "force"): Promise<ProbeResult>;

package/dist/quota/probe.js

@@ -1,10 +1,7 @@
 /**
  * Probe a provider to discover its rate limits.
  *
- * Only subprocess-template supports direct probing since it is the only
- * provider where the auditor controls the API call. IDE providers
- * (claude-code, opencode) select the model internally; their limits come
- * from known-model metadata or learned behavior.
+ * @deprecated Phase 3A replaces this with the QuotaSource abstraction.
  */
 export async function probeProvider(providerName, probeMode = "auto") {
     if (probeMode === "never") {

package/dist/quota/quotaSource.d.ts

@@ -0,0 +1,12 @@
+export interface QuotaUsageSnapshot {
+    remaining_pct: number | null;
+    reset_at: string | null;
+    requests_remaining: number | null;
+    tokens_remaining: number | null;
+    captured_at: string;
+    source: string;
+}
+export interface QuotaSource {
+    readonly name: string;
+    queryCurrentUsage(providerModelKey: string): Promise<QuotaUsageSnapshot | null>;
+}

package/dist/quota/quotaSource.js

@@ -0,0 +1 @@
+export {};

package/dist/quota/scheduler.d.ts

@@ -1,14 +1,18 @@
 import type { ResolvedProviderName, SessionConfig } from "../types/sessionConfig.js";
 import type { HostConcurrencyLimit, QuotaStateEntry, WaveSchedule } from "./types.js";
+import type { QuotaUsageSnapshot } from "./quotaSource.js";
 export interface ScheduleWaveOptions {
     providerName: ResolvedProviderName;
     sessionConfig: SessionConfig;
     hostModel: string | null;
     requestedConcurrency: number;
-    /** Average estimated tokens per packet/worker. Used for TPM budget. */
+    /** Per-slot estimated tokens (one entry per worker slot). Used for TPM budget. */
+    estimatedSlotTokens?: number[];
+    /** @deprecated Use estimatedSlotTokens instead. Average tokens per slot — used as fallback. */
     estimatedPacketTokens?: number;
     quotaStateEntry?: QuotaStateEntry | null;
     hostConcurrencyLimit?: HostConcurrencyLimit | null;
+    quotaSourceSnapshot?: QuotaUsageSnapshot | null;
 }
 export declare function scheduleWave(options: ScheduleWaveOptions): WaveSchedule;
 /** Build the state key used for indexing quota-state.json entries. */

package/dist/quota/scheduler.js

@@ -1,7 +1,20 @@
 import { classifyProvider, resolveLimits } from "./limits.js";
-import { computeMaxSafeConcurrency } from "./state.js";
+import { computeMaxSafeConcurrency, computeRampUpConcurrency } from "./state.js";
+function sumTopN(sorted, n) {
+    let sum = 0;
+    for (let i = 0; i < Math.min(n, sorted.length); i++)
+        sum += sorted[i];
+    return sum;
+}
 export function scheduleWave(options) {
-    const { providerName, sessionConfig, hostModel, requestedConcurrency, estimatedPacketTokens = 0, quotaStateEntry = null, hostConcurrencyLimit = null, } = options;
+    const { providerName, sessionConfig, hostModel, requestedConcurrency, estimatedSlotTokens, estimatedPacketTokens = 0, quotaStateEntry = null, hostConcurrencyLimit = null, quotaSourceSnapshot = null, } = options;
+    // Descending sort so sumTopN picks the largest slots
+    const slotsSorted = estimatedSlotTokens
+        ? [...estimatedSlotTokens].sort((a, b) => b - a)
+        : null;
+    const avgTokens = slotsSorted && slotsSorted.length > 0
+        ? Math.floor(slotsSorted.reduce((a, b) => a + b, 0) / slotsSorted.length)
+        : estimatedPacketTokens;
     const quota = sessionConfig.quota ?? {};
     const applyHostConcurrencyLimit = (waveSize) => {
         if (hostConcurrencyLimit === null)
@@ -19,7 +32,7 @@ export function scheduleWave(options) {
         };
         return {
             wave_size: waveSize,
-            estimated_wave_tokens: waveSize * estimatedPacketTokens,
+            estimated_wave_tokens: slotsSorted ? sumTopN(slotsSorted, waveSize) : waveSize * avgTokens,
             cooldown_until: null,
             confidence: "high",
             source: "default",
@@ -48,12 +61,25 @@ export function scheduleWave(options) {
             waveSize = Math.min(waveSize, rpmCap);
         }
         // Cap by input tokens-per-minute
-        if (limits.input_tokens_per_minute != null && estimatedPacketTokens > 0) {
-            const tpmCap = Math.max(1, Math.floor((limits.input_tokens_per_minute * safetyMargin) / estimatedPacketTokens));
-            waveSize = Math.min(waveSize, tpmCap);
+        if (limits.input_tokens_per_minute != null && avgTokens > 0) {
+            const tpmBudget = limits.input_tokens_per_minute * safetyMargin;
+            if (slotsSorted && slotsSorted.length > 0) {
+                let candidateSize = waveSize;
+                while (candidateSize > 1 && sumTopN(slotsSorted, candidateSize) > tpmBudget) {
+                    candidateSize--;
+                }
+                waveSize = Math.max(1, candidateSize);
+            }
+            else {
+                const tpmCap = Math.max(1, Math.floor(tpmBudget / avgTokens));
+                waveSize = Math.min(waveSize, tpmCap);
+            }
         }
         if (quotaStateEntry) {
-            const learnedCap = computeMaxSafeConcurrency(quotaStateEntry, halfLifeHours);
+            const rampUp = quota.ramp_up_enabled !== false;
+            const learnedCap = rampUp
+                ? computeRampUpConcurrency(quotaStateEntry, halfLifeHours)
+                : computeMaxSafeConcurrency(quotaStateEntry, halfLifeHours);
             waveSize = Math.min(waveSize, learnedCap);
         }
         else {
@@ -61,22 +87,38 @@ export function scheduleWave(options) {
             const fallbackCap = providerType === "local"
                 ? quota.unknown_local_concurrency
                 : (quota.unknown_hosted_concurrency ?? 1);
-            if (typeof fallbackCap === "number" && Number.isFinite(fallbackCap)) {
+            if (fallbackCap === "unlimited") {
+                // no cap — "unlimited" intentionally skips clamping
+            }
+            else if (typeof fallbackCap === "number" && Number.isFinite(fallbackCap)) {
                 waveSize = Math.min(waveSize, Math.max(1, Math.floor(fallbackCap)));
             }
         }
     }
+    // Apply real-time quota source data if available
+    if (quotaSourceSnapshot && !cooldownUntil) {
+        if (quotaSourceSnapshot.remaining_pct != null && quotaSourceSnapshot.remaining_pct < 0.1) {
+            waveSize = 1;
+            if (quotaSourceSnapshot.reset_at) {
+                cooldownUntil = quotaSourceSnapshot.reset_at;
+            }
+        }
+        else if (quotaSourceSnapshot.remaining_pct != null && quotaSourceSnapshot.remaining_pct < 0.3) {
+            waveSize = Math.min(waveSize, Math.max(1, Math.floor(waveSize * 0.5)));
+        }
+    }
     waveSize = applyHostConcurrencyLimit(waveSize);
     waveSize = Math.max(1, waveSize);
     return {
         wave_size: waveSize,
-        estimated_wave_tokens: waveSize * estimatedPacketTokens,
+        estimated_wave_tokens: slotsSorted ? sumTopN(slotsSorted, waveSize) : waveSize * avgTokens,
         cooldown_until: cooldownUntil,
         confidence,
         source,
         resolved_limits: limits,
         host_concurrency_limit: hostConcurrencyLimit,
         model: hostModel,
+        quota_source_snapshot: quotaSourceSnapshot,
     };
 }
 /** Build the state key used for indexing quota-state.json entries. */

package/dist/quota/slidingWindow.d.ts

@@ -0,0 +1,4 @@
+export interface SlidingWindowResult<T> {
+    results: PromiseSettledResult<T>[];
+}
+export declare function runSlidingWindow<T>(tasks: Array<() => Promise<T>>, concurrency: number, onComplete?: (index: number, result: PromiseSettledResult<T>) => void): Promise<SlidingWindowResult<T>>;

package/dist/quota/slidingWindow.js

@@ -0,0 +1,28 @@
+export async function runSlidingWindow(tasks, concurrency, onComplete) {
+    const results = new Array(tasks.length);
+    let nextIndex = 0;
+    async function runOne(index) {
+        let result;
+        try {
+            const value = await tasks[index]();
+            result = { status: "fulfilled", value };
+        }
+        catch (reason) {
+            result = { status: "rejected", reason };
+        }
+        results[index] = result;
+        onComplete?.(index, result);
+        if (nextIndex < tasks.length) {
+            const next = nextIndex++;
+            await runOne(next);
+        }
+    }
+    const initialBatch = Math.min(concurrency, tasks.length);
+    const runners = [];
+    for (let i = 0; i < initialBatch; i++) {
+        const idx = nextIndex++;
+        runners.push(runOne(idx));
+    }
+    await Promise.all(runners);
+    return { results };
+}

package/dist/quota/state.d.ts

@@ -9,4 +9,7 @@ export declare function writeQuotaState(state: QuotaState): Promise<void>;
  * exceeds failure evidence, with a minimum of 1.
  */
 export declare function computeMaxSafeConcurrency(entry: QuotaStateEntry, halfLifeHours: number, maxToCheck?: number): number;
+export declare function computeRampUpConcurrency(entry: QuotaStateEntry, halfLifeHours: number, maxToCheck?: number): number;
+export declare function computeBackoffCooldownMs(consecutive429Count: number): number;
+export declare function computeBackoffFailureWeight(consecutive429Count: number): number;
 export declare function recordWaveOutcome(providerModelKey: string, outcome: ObservedWaveOutcome, halfLifeHours: number): Promise<void>;