@indigoai-us/hq-cloud 6.15.25 → 6.15.26

package/dist/bandwidth.d.ts

@@ -0,0 +1,128 @@
+/**
+ * Bandwidth governor — process-wide pacing for S3 payload transfers.
+ *
+ * The desktop app spawns `hq-sync-runner` on customer machines; on slow links
+ * an unthrottled sync saturates the connection. The runner honors three env
+ * vars (set by the desktop app, all optional):
+ *
+ *   - `HQ_SYNC_MAX_BYTES_PER_SEC` — integer; total S3 payload rate cap,
+ *     uploads + downloads combined. 0 / unset / invalid ⇒ unlimited.
+ *   - `HQ_SYNC_MAX_CONCURRENCY` — integer; max simultaneous S3 object
+ *     transfers (clamps the transfer pool). 0 / unset / invalid ⇒ the
+ *     existing adaptive default.
+ *   - `HQ_SYNC_BANDWIDTH_PERCENT` — integer 1..100; adaptive mode. The
+ *     governor keeps a rolling estimate of link capacity (max observed
+ *     aggregate throughput over the last 10 minutes, measured during actual
+ *     transfers) and paces to percent/100 × that estimate, floored at
+ *     64 KiB/s so sync always progresses. When both PERCENT and
+ *     MAX_BYTES_PER_SEC are set, the smaller resulting cap wins.
+ *
+ * Only DATA-plane transfers are paced (upload bodies, download streams).
+ * Control-plane calls (list, head, delete, presign mints) are never
+ * throttled — see the wiring in object-io.ts.
+ *
+ * Mechanism: a single token bucket shared by every transfer in the process,
+ * refilled continuously at the effective rate with a one-second burst
+ * allowance. Transfers acquire tokens per chunk; when the bucket is empty the
+ * acquire sleeps for exactly the deficit, so at most one chunk is ever in
+ * flight beyond the bucket (backpressure, no extra buffering). Deliberately
+ * NOT a delay-based congestion controller — dead simple, deterministic, and
+ * testable under virtual time.
+ */
+export declare const MAX_BYTES_PER_SEC_ENV = "HQ_SYNC_MAX_BYTES_PER_SEC";
+export declare const MAX_CONCURRENCY_ENV = "HQ_SYNC_MAX_CONCURRENCY";
+export declare const BANDWIDTH_PERCENT_ENV = "HQ_SYNC_BANDWIDTH_PERCENT";
+/** Adaptive-mode floor: sync always progresses at ≥ 64 KiB/s. */
+export declare const MIN_ADAPTIVE_BYTES_PER_SEC: number;
+export interface BandwidthPolicy {
+    /** Fixed aggregate cap in bytes/sec; undefined = no fixed cap. */
+    maxBytesPerSec?: number;
+    /** Adaptive percent of observed link capacity (1..100); undefined = off. */
+    percent?: number;
+    /** Transfer-pool clamp; undefined = keep the adaptive default. */
+    maxConcurrency?: number;
+}
+/**
+ * Parse the env contract. Invalid, zero, or unset values disable the
+ * corresponding knob rather than erroring — a misconfigured desktop app must
+ * never break sync, only fail open to today's behavior.
+ */
+export declare function parseBandwidthPolicy(env?: Record<string, string | undefined>): BandwidthPolicy;
+/**
+ * Rolling link-capacity estimate: max observed aggregate throughput over the
+ * last {@link ESTIMATOR_WINDOW_MS}. Bytes are recorded into per-second
+ * buckets as transfers deliver them; capacity is the largest bucket in the
+ * window (bytes in one second = B/s). A tiny always-current accumulator —
+ * at most 600 live entries, pruned on every touch.
+ */
+export declare class ThroughputEstimator {
+    private readonly now;
+    private readonly buckets;
+    constructor(now?: () => number);
+    private prune;
+    record(bytes: number): void;
+    /** Max observed B/s in the window; undefined before any observation. */
+    capacityBps(): number | undefined;
+}
+interface ClockOpts {
+    now?: () => number;
+    sleep?: (ms: number) => Promise<void>;
+}
+/**
+ * Continuous-refill token bucket with a one-second burst allowance and a
+ * dynamic rate (re-read on every acquire, so adaptive mode retunes live).
+ * `acquire(n)` debits n tokens and sleeps for exactly the deficit when the
+ * bucket goes negative — the caller's chunk proceeds, and the NEXT chunk
+ * waits, so no more than one chunk is ever in flight beyond the bucket.
+ */
+export declare class TokenBucket {
+    private readonly rateBps;
+    private tokens;
+    private lastRefillMs;
+    private readonly now;
+    private readonly sleep;
+    constructor(rateBps: () => number | undefined, opts?: ClockOpts);
+    acquire(bytes: number): Promise<void>;
+}
+/**
+ * Process-wide governor: one bucket + one estimator shared by every transfer.
+ * Inert (all pass-throughs) when the policy carries no rate knobs.
+ */
+export declare class BandwidthGovernor {
+    readonly policy: BandwidthPolicy;
+    private readonly estimator;
+    private readonly bucket;
+    constructor(policy: BandwidthPolicy, opts?: ClockOpts);
+    /** True when any payload pacing is configured. */
+    isPacing(): boolean;
+    /**
+     * The rate the bucket refills at right now. Fixed cap, adaptive cap
+     * (percent × rolling max, floored at {@link MIN_ADAPTIVE_BYTES_PER_SEC}),
+     * or — when both are set — the smaller. Adaptive mode with no observation
+     * yet is unlimited: the first transfers measure the link.
+     */
+    effectiveRateBps(): number | undefined;
+    /**
+     * Pace `bytes` of payload through the shared bucket and feed the capacity
+     * estimator. Instant when pacing is off.
+     */
+    acquire(bytes: number): Promise<void>;
+    /**
+     * Wrap a download body so each chunk acquires tokens before it is yielded.
+     * Delivers every byte unmodified; returns the original iterable when
+     * pacing is off (zero overhead on the default path).
+     */
+    throttleBody(body: AsyncIterable<Uint8Array>): AsyncIterable<Uint8Array>;
+    /** Clamp the transfer pool size with HQ_SYNC_MAX_CONCURRENCY (if set). */
+    clampConcurrency(poolSize: number): number;
+    /** One-line human description of the effective policy for startup logs. */
+    describePolicy(): string;
+}
+export declare function getBandwidthGovernor(): BandwidthGovernor;
+/**
+ * Test seam: install a governor (or null to drop the singleton so the next
+ * get re-reads the env). Production never calls this.
+ */
+export declare function setBandwidthGovernorForTesting(governor: BandwidthGovernor | null): void;
+export {};
+//# sourceMappingURL=bandwidth.d.ts.map

package/dist/bandwidth.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bandwidth.d.ts","sourceRoot":"","sources":["../src/bandwidth.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AAEH,eAAO,MAAM,qBAAqB,8BAA8B,CAAC;AACjE,eAAO,MAAM,mBAAmB,4BAA4B,CAAC;AAC7D,eAAO,MAAM,qBAAqB,8BAA8B,CAAC;AAEjE,iEAAiE;AACjE,eAAO,MAAM,0BAA0B,QAAY,CAAC;AAOpD,MAAM,WAAW,eAAe;IAC9B,kEAAkE;IAClE,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,4EAA4E;IAC5E,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,kEAAkE;IAClE,cAAc,CAAC,EAAE,MAAM,CAAC;CACzB;AAWD;;;;GAIG;AACH,wBAAgB,oBAAoB,CAClC,GAAG,GAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,CAAe,GACpD,eAAe,CASjB;AAED;;;;;;GAMG;AACH,qBAAa,mBAAmB;IAGlB,OAAO,CAAC,QAAQ,CAAC,GAAG;IAFhC,OAAO,CAAC,QAAQ,CAAC,OAAO,CAA6B;gBAExB,GAAG,GAAE,MAAM,MAAiB;IAEzD,OAAO,CAAC,KAAK;IAOb,MAAM,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI;IAQ3B,wEAAwE;IACxE,WAAW,IAAI,MAAM,GAAG,SAAS;CAQlC;AAED,UAAU,SAAS;IACjB,GAAG,CAAC,EAAE,MAAM,MAAM,CAAC;IACnB,KAAK,CAAC,EAAE,CAAC,EAAE,EAAE,MAAM,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;CACvC;AAKD;;;;;;GAMG;AACH,qBAAa,WAAW;IAOpB,OAAO,CAAC,QAAQ,CAAC,OAAO;IAN1B,OAAO,CAAC,MAAM,CAAK;IACnB,OAAO,CAAC,YAAY,CAAS;IAC7B,OAAO,CAAC,QAAQ,CAAC,GAAG,CAAe;IACnC,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAgC;gBAGnC,OAAO,EAAE,MAAM,MAAM,GAAG,SAAS,EAClD,IAAI,GAAE,SAAc;IAOhB,OAAO,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;CAwB5C;AAED;;;GAGG;AACH,qBAAa,iBAAiB;IAC5B,QAAQ,CAAC,MAAM,EAAE,eAAe,CAAC;IACjC,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAsB;IAChD,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAc;gBAEzB,MAAM,EAAE,eAAe,EAAE,IAAI,GAAE,SAAc;IAMzD,kDAAkD;IAClD,QAAQ,IAAI,OAAO;IAOnB;;;;;OAKG;IACH,gBAAgB,IAAI,MAAM,GAAG,SAAS;IAkBtC;;;OAGG;IACG,OAAO,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAM3C;;;;OAIG;IACH,YAAY,CAAC,IAAI,EAAE,aAAa,CAAC,UAAU,CAAC,GAAG,aAAa,CAAC,UAAU,CAAC;IAWxE,0EAA0E;IAC1E,gBAAgB,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM;IAM1C,2EAA2E;IAC3E,cAAc,IAAI,MAAM;CAkBzB;AASD,wBAAgB,oBAAoB,IAAI,iBAAiB,CAKxD;AAED;;;GAGG;AACH,wBAAgB,8BAA8B,CAC5C,QAAQ,EAAE,iBAAiB,GAAG,IAAI,GACjC,IAAI,CAEN"}

package/dist/bandwidth.js

@@ -0,0 +1,254 @@
+/**
+ * Bandwidth governor — process-wide pacing for S3 payload transfers.
+ *
+ * The desktop app spawns `hq-sync-runner` on customer machines; on slow links
+ * an unthrottled sync saturates the connection. The runner honors three env
+ * vars (set by the desktop app, all optional):
+ *
+ *   - `HQ_SYNC_MAX_BYTES_PER_SEC` — integer; total S3 payload rate cap,
+ *     uploads + downloads combined. 0 / unset / invalid ⇒ unlimited.
+ *   - `HQ_SYNC_MAX_CONCURRENCY` — integer; max simultaneous S3 object
+ *     transfers (clamps the transfer pool). 0 / unset / invalid ⇒ the
+ *     existing adaptive default.
+ *   - `HQ_SYNC_BANDWIDTH_PERCENT` — integer 1..100; adaptive mode. The
+ *     governor keeps a rolling estimate of link capacity (max observed
+ *     aggregate throughput over the last 10 minutes, measured during actual
+ *     transfers) and paces to percent/100 × that estimate, floored at
+ *     64 KiB/s so sync always progresses. When both PERCENT and
+ *     MAX_BYTES_PER_SEC are set, the smaller resulting cap wins.
+ *
+ * Only DATA-plane transfers are paced (upload bodies, download streams).
+ * Control-plane calls (list, head, delete, presign mints) are never
+ * throttled — see the wiring in object-io.ts.
+ *
+ * Mechanism: a single token bucket shared by every transfer in the process,
+ * refilled continuously at the effective rate with a one-second burst
+ * allowance. Transfers acquire tokens per chunk; when the bucket is empty the
+ * acquire sleeps for exactly the deficit, so at most one chunk is ever in
+ * flight beyond the bucket (backpressure, no extra buffering). Deliberately
+ * NOT a delay-based congestion controller — dead simple, deterministic, and
+ * testable under virtual time.
+ */
+export const MAX_BYTES_PER_SEC_ENV = "HQ_SYNC_MAX_BYTES_PER_SEC";
+export const MAX_CONCURRENCY_ENV = "HQ_SYNC_MAX_CONCURRENCY";
+export const BANDWIDTH_PERCENT_ENV = "HQ_SYNC_BANDWIDTH_PERCENT";
+/** Adaptive-mode floor: sync always progresses at ≥ 64 KiB/s. */
+export const MIN_ADAPTIVE_BYTES_PER_SEC = 64 * 1024;
+/** Rolling window the link-capacity estimate looks back over. */
+const ESTIMATOR_WINDOW_MS = 10 * 60 * 1000;
+/** Estimator bucket granularity: per-second byte counts. */
+const ESTIMATOR_BUCKET_MS = 1000;
+/** Strict positive-integer env parse; anything else ⇒ undefined (feature off). */
+function parsePositiveInt(raw) {
+    if (raw === undefined || raw === "" || !/^\d+$/.test(raw.trim())) {
+        return undefined;
+    }
+    const n = Number.parseInt(raw, 10);
+    return Number.isSafeInteger(n) && n > 0 ? n : undefined;
+}
+/**
+ * Parse the env contract. Invalid, zero, or unset values disable the
+ * corresponding knob rather than erroring — a misconfigured desktop app must
+ * never break sync, only fail open to today's behavior.
+ */
+export function parseBandwidthPolicy(env = process.env) {
+    const maxBytesPerSec = parsePositiveInt(env[MAX_BYTES_PER_SEC_ENV]);
+    const maxConcurrency = parsePositiveInt(env[MAX_CONCURRENCY_ENV]);
+    const rawPercent = parsePositiveInt(env[BANDWIDTH_PERCENT_ENV]);
+    const percent = rawPercent !== undefined && rawPercent >= 1 && rawPercent <= 100
+        ? rawPercent
+        : undefined;
+    return { maxBytesPerSec, percent, maxConcurrency };
+}
+/**
+ * Rolling link-capacity estimate: max observed aggregate throughput over the
+ * last {@link ESTIMATOR_WINDOW_MS}. Bytes are recorded into per-second
+ * buckets as transfers deliver them; capacity is the largest bucket in the
+ * window (bytes in one second = B/s). A tiny always-current accumulator —
+ * at most 600 live entries, pruned on every touch.
+ */
+export class ThroughputEstimator {
+    now;
+    buckets = new Map();
+    constructor(now = Date.now) {
+        this.now = now;
+    }
+    prune(nowMs) {
+        const oldest = Math.floor((nowMs - ESTIMATOR_WINDOW_MS) / ESTIMATOR_BUCKET_MS);
+        for (const key of this.buckets.keys()) {
+            if (key < oldest)
+                this.buckets.delete(key);
+        }
+    }
+    record(bytes) {
+        if (bytes <= 0)
+            return;
+        const nowMs = this.now();
+        this.prune(nowMs);
+        const bucket = Math.floor(nowMs / ESTIMATOR_BUCKET_MS);
+        this.buckets.set(bucket, (this.buckets.get(bucket) ?? 0) + bytes);
+    }
+    /** Max observed B/s in the window; undefined before any observation. */
+    capacityBps() {
+        this.prune(this.now());
+        let max;
+        for (const bytes of this.buckets.values()) {
+            if (max === undefined || bytes > max)
+                max = bytes;
+        }
+        return max;
+    }
+}
+const realSleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+/**
+ * Continuous-refill token bucket with a one-second burst allowance and a
+ * dynamic rate (re-read on every acquire, so adaptive mode retunes live).
+ * `acquire(n)` debits n tokens and sleeps for exactly the deficit when the
+ * bucket goes negative — the caller's chunk proceeds, and the NEXT chunk
+ * waits, so no more than one chunk is ever in flight beyond the bucket.
+ */
+export class TokenBucket {
+    rateBps;
+    tokens = 0;
+    lastRefillMs;
+    now;
+    sleep;
+    constructor(rateBps, opts = {}) {
+        this.rateBps = rateBps;
+        this.now = opts.now ?? Date.now;
+        this.sleep = opts.sleep ?? realSleep;
+        this.lastRefillMs = this.now();
+    }
+    async acquire(bytes) {
+        if (bytes <= 0)
+            return;
+        const rate = this.rateBps();
+        if (rate === undefined || rate <= 0) {
+            // Unlimited: reset so a later rate change doesn't grant a stale burst.
+            this.tokens = 0;
+            this.lastRefillMs = this.now();
+            return;
+        }
+        const nowMs = this.now();
+        const burst = rate; // one second of headroom
+        const refilled = this.tokens + ((nowMs - this.lastRefillMs) / 1000) * rate;
+        this.tokens = Math.min(burst, refilled);
+        this.lastRefillMs = nowMs;
+        this.tokens -= bytes;
+        if (this.tokens < 0) {
+            const waitMs = (-this.tokens / rate) * 1000;
+            await this.sleep(waitMs);
+            // Credit the slept time back so the deficit is repaid exactly once.
+            this.tokens += (waitMs / 1000) * rate;
+            this.lastRefillMs = this.now();
+        }
+    }
+}
+/**
+ * Process-wide governor: one bucket + one estimator shared by every transfer.
+ * Inert (all pass-throughs) when the policy carries no rate knobs.
+ */
+export class BandwidthGovernor {
+    policy;
+    estimator;
+    bucket;
+    constructor(policy, opts = {}) {
+        this.policy = policy;
+        this.estimator = new ThroughputEstimator(opts.now ?? Date.now);
+        this.bucket = new TokenBucket(() => this.effectiveRateBps(), opts);
+    }
+    /** True when any payload pacing is configured. */
+    isPacing() {
+        return (this.policy.maxBytesPerSec !== undefined ||
+            this.policy.percent !== undefined);
+    }
+    /**
+     * The rate the bucket refills at right now. Fixed cap, adaptive cap
+     * (percent × rolling max, floored at {@link MIN_ADAPTIVE_BYTES_PER_SEC}),
+     * or — when both are set — the smaller. Adaptive mode with no observation
+     * yet is unlimited: the first transfers measure the link.
+     */
+    effectiveRateBps() {
+        const fixed = this.policy.maxBytesPerSec;
+        let adaptive;
+        if (this.policy.percent !== undefined) {
+            const capacity = this.estimator.capacityBps();
+            if (capacity !== undefined) {
+                adaptive = Math.max(MIN_ADAPTIVE_BYTES_PER_SEC, (capacity * this.policy.percent) / 100);
+            }
+        }
+        if (fixed !== undefined && adaptive !== undefined) {
+            return Math.min(fixed, adaptive);
+        }
+        return fixed ?? adaptive;
+    }
+    /**
+     * Pace `bytes` of payload through the shared bucket and feed the capacity
+     * estimator. Instant when pacing is off.
+     */
+    async acquire(bytes) {
+        if (!this.isPacing() || bytes <= 0)
+            return;
+        await this.bucket.acquire(bytes);
+        this.estimator.record(bytes);
+    }
+    /**
+     * Wrap a download body so each chunk acquires tokens before it is yielded.
+     * Delivers every byte unmodified; returns the original iterable when
+     * pacing is off (zero overhead on the default path).
+     */
+    throttleBody(body) {
+        if (!this.isPacing())
+            return body;
+        const acquire = (n) => this.acquire(n);
+        return (async function* () {
+            for await (const chunk of body) {
+                await acquire(chunk.byteLength);
+                yield chunk;
+            }
+        })();
+    }
+    /** Clamp the transfer pool size with HQ_SYNC_MAX_CONCURRENCY (if set). */
+    clampConcurrency(poolSize) {
+        const cap = this.policy.maxConcurrency;
+        if (cap === undefined)
+            return poolSize;
+        return Math.max(1, Math.min(poolSize, cap));
+    }
+    /** One-line human description of the effective policy for startup logs. */
+    describePolicy() {
+        const parts = [];
+        if (this.policy.maxBytesPerSec !== undefined) {
+            parts.push(`${this.policy.maxBytesPerSec} B/s cap`);
+        }
+        if (this.policy.percent !== undefined) {
+            parts.push(`adaptive ${this.policy.percent}% of observed link ` +
+                `(floor ${MIN_ADAPTIVE_BYTES_PER_SEC} B/s)`);
+        }
+        if (this.policy.maxConcurrency !== undefined) {
+            parts.push(`concurrency ${this.policy.maxConcurrency}`);
+        }
+        return parts.length > 0
+            ? `bandwidth governor: ${parts.join(", ")}`
+            : "bandwidth governor: off";
+    }
+}
+// ---------------------------------------------------------------------------
+// Process singleton — every transport instance shares ONE bucket so the cap
+// is the aggregate across all in-flight uploads + downloads.
+// ---------------------------------------------------------------------------
+let singleton;
+export function getBandwidthGovernor() {
+    if (!singleton) {
+        singleton = new BandwidthGovernor(parseBandwidthPolicy());
+    }
+    return singleton;
+}
+/**
+ * Test seam: install a governor (or null to drop the singleton so the next
+ * get re-reads the env). Production never calls this.
+ */
+export function setBandwidthGovernorForTesting(governor) {
+    singleton = governor ?? undefined;
+}
+//# sourceMappingURL=bandwidth.js.map

package/dist/bandwidth.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"bandwidth.js","sourceRoot":"","sources":["../src/bandwidth.ts"],"names":[],"mappings":"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"}

package/dist/bandwidth.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=bandwidth.test.d.ts.map

package/dist/bandwidth.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bandwidth.test.d.ts","sourceRoot":"","sources":["../src/bandwidth.test.ts"],"names":[],"mappings":""}

package/dist/bandwidth.test.js

@@ -0,0 +1,243 @@
+import { describe, expect, it } from "vitest";
+import { BANDWIDTH_PERCENT_ENV, BandwidthGovernor, MAX_BYTES_PER_SEC_ENV, MAX_CONCURRENCY_ENV, MIN_ADAPTIVE_BYTES_PER_SEC, ThroughputEstimator, TokenBucket, parseBandwidthPolicy, } from "./bandwidth.js";
+/**
+ * Virtual clock: `sleep` advances time instantly, so pacing math is asserted
+ * deterministically with zero wall-clock waits.
+ */
+function virtualClock(startMs = 0) {
+    let t = startMs;
+    return {
+        now: () => t,
+        sleep: async (ms) => {
+            t += ms;
+        },
+        advance: (ms) => {
+            t += ms;
+        },
+        time: () => t,
+    };
+}
+describe("parseBandwidthPolicy", () => {
+    it("returns all-off for an empty env", () => {
+        expect(parseBandwidthPolicy({})).toEqual({
+            maxBytesPerSec: undefined,
+            percent: undefined,
+            maxConcurrency: undefined,
+        });
+    });
+    it("parses valid positive integers", () => {
+        const policy = parseBandwidthPolicy({
+            [MAX_BYTES_PER_SEC_ENV]: "500000",
+            [MAX_CONCURRENCY_ENV]: "2",
+            [BANDWIDTH_PERCENT_ENV]: "50",
+        });
+        expect(policy).toEqual({
+            maxBytesPerSec: 500000,
+            maxConcurrency: 2,
+            percent: 50,
+        });
+    });
+    it("treats 0, negative, and non-numeric values as unset (feature off)", () => {
+        for (const bad of ["0", "-5", "abc", "1.5", "", "  ", "1e6"]) {
+            const policy = parseBandwidthPolicy({
+                [MAX_BYTES_PER_SEC_ENV]: bad,
+                [MAX_CONCURRENCY_ENV]: bad,
+                [BANDWIDTH_PERCENT_ENV]: bad,
+            });
+            expect(policy, `input ${JSON.stringify(bad)}`).toEqual({
+                maxBytesPerSec: undefined,
+                percent: undefined,
+                maxConcurrency: undefined,
+            });
+        }
+    });
+    it("rejects percent outside 1..100 but accepts the bounds", () => {
+        expect(parseBandwidthPolicy({ [BANDWIDTH_PERCENT_ENV]: "101" }).percent).toBeUndefined();
+        expect(parseBandwidthPolicy({ [BANDWIDTH_PERCENT_ENV]: "1" }).percent).toBe(1);
+        expect(parseBandwidthPolicy({ [BANDWIDTH_PERCENT_ENV]: "100" }).percent).toBe(100);
+    });
+});
+describe("TokenBucket", () => {
+    it("passes instantly when the rate is unlimited", async () => {
+        const clock = virtualClock();
+        const bucket = new TokenBucket(() => undefined, clock);
+        await bucket.acquire(10_000_000);
+        expect(clock.time()).toBe(0);
+    });
+    it("paces a sustained transfer at the configured rate (virtual time)", async () => {
+        const clock = virtualClock();
+        const rate = 100_000; // B/s
+        const bucket = new TokenBucket(() => rate, clock);
+        // 1 MB in 64 KiB chunks at 100 kB/s must take ~10 s. The one-second
+        // burst allowance shaves at most 1 s off the ideal duration.
+        const chunk = 64 * 1024;
+        const total = 1_000_000;
+        for (let sent = 0; sent < total; sent += chunk) {
+            await bucket.acquire(Math.min(chunk, total - sent));
+        }
+        const ideal = (total / rate) * 1000;
+        expect(clock.time()).toBeGreaterThanOrEqual(ideal - 1000);
+        expect(clock.time()).toBeLessThanOrEqual(ideal + 1);
+    });
+    it("grants an initial burst of at most one second of tokens", async () => {
+        const clock = virtualClock();
+        const bucket = new TokenBucket(() => 1000, clock);
+        clock.advance(60_000); // long idle must NOT accumulate 60s of tokens
+        await bucket.acquire(1000); // one second's worth: free (burst)
+        expect(clock.time()).toBe(60_000);
+        await bucket.acquire(1000); // next second's worth: must wait ~1s
+        expect(clock.time()).toBeCloseTo(61_000, 5);
+    });
+    it("handles a single acquire larger than the burst", async () => {
+        const clock = virtualClock();
+        const bucket = new TokenBucket(() => 1000, clock);
+        // Fresh bucket starts empty (no free initial burst): 5s of tokens → 5s.
+        await bucket.acquire(5000);
+        expect(clock.time()).toBeCloseTo(5000, 5);
+    });
+    it("re-reads the rate on every acquire (live retuning)", async () => {
+        const clock = virtualClock();
+        let rate = undefined;
+        const bucket = new TokenBucket(() => rate, clock);
+        await bucket.acquire(1_000_000); // unlimited: instant
+        expect(clock.time()).toBe(0);
+        rate = 1000;
+        await bucket.acquire(2000); // bucket empty → full 2s deficit at 1 kB/s
+        expect(clock.time()).toBeCloseTo(2000, 5);
+    });
+});
+describe("ThroughputEstimator", () => {
+    it("is undefined before any observation", () => {
+        const clock = virtualClock();
+        expect(new ThroughputEstimator(clock.now).capacityBps()).toBeUndefined();
+    });
+    it("reports the max per-second aggregate observed", () => {
+        const clock = virtualClock(1_000_000);
+        const est = new ThroughputEstimator(clock.now);
+        est.record(50_000);
+        est.record(30_000); // same second → aggregates to 80 kB/s
+        clock.advance(1000);
+        est.record(10_000);
+        expect(est.capacityBps()).toBe(80_000);
+    });
+    it("forgets observations older than the 10-minute window", () => {
+        const clock = virtualClock(1_000_000);
+        const est = new ThroughputEstimator(clock.now);
+        est.record(1_000_000);
+        clock.advance(9 * 60 * 1000);
+        est.record(5_000);
+        expect(est.capacityBps()).toBe(1_000_000); // still inside window
+        clock.advance(2 * 60 * 1000); // old peak now > 10 min ago
+        expect(est.capacityBps()).toBe(5_000);
+    });
+});
+describe("BandwidthGovernor.effectiveRateBps", () => {
+    it("is undefined (unlimited) with no policy", () => {
+        expect(new BandwidthGovernor({}).effectiveRateBps()).toBeUndefined();
+    });
+    it("uses the fixed cap alone", () => {
+        expect(new BandwidthGovernor({ maxBytesPerSec: 250_000 }).effectiveRateBps()).toBe(250_000);
+    });
+    it("percent mode is unlimited until the link has been observed", () => {
+        const gov = new BandwidthGovernor({ percent: 50 }, virtualClock());
+        expect(gov.effectiveRateBps()).toBeUndefined();
+    });
+    it("percent mode paces to percent × observed capacity", async () => {
+        const clock = virtualClock(1_000_000);
+        const gov = new BandwidthGovernor({ percent: 50 }, clock);
+        await gov.acquire(1_000_000); // observe ~1 MB/s in one second-bucket
+        expect(gov.effectiveRateBps()).toBe(500_000);
+    });
+    it("floors the adaptive cap at 64 KiB/s", async () => {
+        const clock = virtualClock(1_000_000);
+        const gov = new BandwidthGovernor({ percent: 1 }, clock);
+        await gov.acquire(100_000); // 1% of 100 kB/s = 1 kB/s → floored
+        expect(gov.effectiveRateBps()).toBe(MIN_ADAPTIVE_BYTES_PER_SEC);
+    });
+    it("uses the smaller of fixed and adaptive caps when both are set", async () => {
+        const clock = virtualClock(1_000_000);
+        const gov = new BandwidthGovernor({ maxBytesPerSec: 300_000, percent: 50 }, clock);
+        // No observation yet → fixed cap governs.
+        expect(gov.effectiveRateBps()).toBe(300_000);
+        await gov.acquire(1_000_000); // adaptive = 500 kB/s > fixed 300 kB/s
+        expect(gov.effectiveRateBps()).toBe(300_000);
+        const gov2 = new BandwidthGovernor({ maxBytesPerSec: 300_000, percent: 10 }, clock);
+        await gov2.acquire(1_000_000); // adaptive = 100 kB/s < fixed
+        expect(gov2.effectiveRateBps()).toBe(100_000);
+    });
+});
+describe("BandwidthGovernor.throttleBody", () => {
+    async function* chunks(sizes) {
+        for (const [i, size] of sizes.entries()) {
+            yield new Uint8Array(size).fill(i % 256);
+        }
+    }
+    async function drain(body) {
+        const parts = [];
+        for await (const c of body)
+            parts.push(Buffer.from(c));
+        return Buffer.concat(parts);
+    }
+    it("returns the original iterable when pacing is off", () => {
+        const gov = new BandwidthGovernor({ maxConcurrency: 4 });
+        const body = chunks([10]);
+        expect(gov.throttleBody(body)).toBe(body);
+    });
+    it("delivers every byte unmodified, in order", async () => {
+        const clock = virtualClock();
+        const gov = new BandwidthGovernor({ maxBytesPerSec: 1_000_000 }, clock);
+        const sizes = [1, 65_536, 3, 100_000, 0, 7];
+        const expected = await drain(chunks(sizes));
+        const actual = await drain(gov.throttleBody(chunks(sizes)));
+        expect(actual.equals(expected)).toBe(true);
+    });
+    it("respects the rate cap over a simulated transfer (virtual time)", async () => {
+        const clock = virtualClock();
+        const rate = 200_000;
+        const gov = new BandwidthGovernor({ maxBytesPerSec: rate }, clock);
+        const sizes = Array.from({ length: 31 }, () => 64 * 1024); // ~2 MB
+        const total = sizes.reduce((a, b) => a + b, 0);
+        await drain(gov.throttleBody(chunks(sizes)));
+        const ideal = (total / rate) * 1000;
+        expect(clock.time()).toBeGreaterThanOrEqual(ideal - 1000); // burst slack
+        expect(clock.time()).toBeLessThanOrEqual(ideal + 1);
+    });
+    it("aggregates concurrent streams under ONE shared cap", async () => {
+        const clock = virtualClock();
+        const rate = 100_000;
+        const gov = new BandwidthGovernor({ maxBytesPerSec: rate }, clock);
+        const sizes = Array.from({ length: 8 }, () => 50_000); // 400 kB each
+        await Promise.all([
+            drain(gov.throttleBody(chunks(sizes))),
+            drain(gov.throttleBody(chunks(sizes))),
+        ]);
+        const total = 2 * sizes.reduce((a, b) => a + b, 0); // 800 kB combined
+        const ideal = (total / rate) * 1000;
+        expect(clock.time()).toBeGreaterThanOrEqual(ideal - 1000);
+    });
+});
+describe("BandwidthGovernor.clampConcurrency", () => {
+    it("passes the pool size through when unset", () => {
+        expect(new BandwidthGovernor({}).clampConcurrency(64)).toBe(64);
+    });
+    it("clamps the pool down but never raises it", () => {
+        const gov = new BandwidthGovernor({ maxConcurrency: 2 });
+        expect(gov.clampConcurrency(64)).toBe(2);
+        expect(gov.clampConcurrency(1)).toBe(1);
+        const loose = new BandwidthGovernor({ maxConcurrency: 100 });
+        expect(loose.clampConcurrency(64)).toBe(64);
+    });
+});
+describe("BandwidthGovernor.describePolicy", () => {
+    it("reports off when nothing is configured", () => {
+        expect(new BandwidthGovernor({}).describePolicy()).toBe("bandwidth governor: off");
+    });
+    it("reports the effective policy in one line", () => {
+        expect(new BandwidthGovernor({
+            maxBytesPerSec: 500000,
+            maxConcurrency: 2,
+        }).describePolicy()).toBe("bandwidth governor: 500000 B/s cap, concurrency 2");
+        expect(new BandwidthGovernor({ percent: 40 }).describePolicy()).toBe(`bandwidth governor: adaptive 40% of observed link (floor ${MIN_ADAPTIVE_BYTES_PER_SEC} B/s)`);
+    });
+});
+//# sourceMappingURL=bandwidth.test.js.map