@prosopo/load-balancer 2.11.4 → 2.11.5

package/src/tests/providers.unit.test.ts

@@ -1,538 +0,0 @@
-// Copyright 2021-2026 Prosopo (UK) Ltd.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-import type { EnvironmentTypes } from "@prosopo/types";
-import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
-import type { HardcodedProvider, IpMode } from "../balancer.js";
-import {
-	PROVIDER_LIST_MISS_RELOAD_MS,
-	PROVIDER_LIST_TTL_MS,
-	_resetHealthzRetryPolicy,
-	_resetPinCache,
-	_resetProviderListCache,
-	_setHealthzRetryPolicy,
-	findProvider,
-	getProviders,
-	getRandomActiveProvider,
-	getRandomProviderFromList,
-} from "../providers.js";
-
-// Mock the underlying load balancer so getProviders' caching/failure semantics
-// can be exercised without real network calls. getRandomActiveProvider tests
-// don't use loadBalancer, so this mock leaves them unaffected.
-const loadBalancer = vi.fn();
-// Defaults to "no override" so these cases exercise the normal healthz
-// discovery path; the override's own behaviour is covered in
-// providerUrlOverride.unit.test.ts.
-const getProviderListOverride = vi.fn<() => HardcodedProvider[]>(() => []);
-vi.mock("../balancer.js", () => ({
-	loadBalancer: (...args: unknown[]) => loadBalancer(...args),
-	getProviderListOverride: (...args: unknown[]) =>
-		getProviderListOverride(...(args as [])),
-}));
-
-const originalFetch = globalThis.fetch;
-
-const mockHealthzFetch = (host: string, ok = true, status = 200) => {
-	const mocked = vi.fn(async () => ({
-		ok,
-		status,
-		json: async () => ({ ok: true, host }),
-	}));
-	// biome-ignore lint/suspicious/noExplicitAny: minimal Response stub for the unit test
-	globalThis.fetch = mocked as any;
-	return mocked;
-};
-
-// The provider-list cache ages off Date.now(), so drive it from the test
-// rather than sleeping. Nothing else in this package reads the clock.
-const originalDateNow = Date.now;
-const CLOCK_START = 1_700_000_000_000;
-let clock = CLOCK_START;
-const advanceClock = (ms: number) => {
-	clock += ms;
-};
-
-beforeEach(() => {
-	_resetPinCache();
-	clock = CLOCK_START;
-	Date.now = () => clock;
-	// Keep the retry policy but drop backoff to zero so failure-path tests
-	// don't sit waiting on real timers.
-	_setHealthzRetryPolicy({ baseDelayMs: 0, maxDelayMs: 0 });
-});
-
-afterEach(() => {
-	globalThis.fetch = originalFetch;
-	Date.now = originalDateNow;
-	_resetHealthzRetryPolicy();
-});
-
-describe("getRandomActiveProvider (dual stack)", () => {
-	it("uses the local URL directly in development (no healthz round-trip)", async () => {
-		const mocked = mockHealthzFetch("ignored");
-		const result = await getRandomActiveProvider("development");
-		expect(result.provider.url).toBe("https://localhost:9229");
-		expect(mocked).not.toHaveBeenCalled();
-	});
-
-	it("pins to the host returned by /healthz in production", async () => {
-		mockHealthzFetch("pronode7.prosopo.io");
-		const result = await getRandomActiveProvider("production");
-		expect(result.provider.url).toBe("https://pronode7.prosopo.io");
-	});
-
-	it("pins to the host returned by /healthz in staging", async () => {
-		mockHealthzFetch("staging-pronode2.prosopo.io");
-		const result = await getRandomActiveProvider("staging");
-		expect(result.provider.url).toBe("https://staging-pronode2.prosopo.io");
-	});
-
-	it("caches the pinned URL for repeat callers in the same env + ipMode", async () => {
-		const mocked = mockHealthzFetch("pronode3.prosopo.io");
-		await getRandomActiveProvider("production");
-		await getRandomActiveProvider("production");
-		await getRandomActiveProvider("production");
-		expect(mocked).toHaveBeenCalledTimes(1);
-	});
-
-	it("throws after all healthz retries are exhausted (does not fall back to LB hostname)", async () => {
-		const mocked = mockHealthzFetch("ignored", false, 503);
-		await expect(getRandomActiveProvider("production")).rejects.toThrow(
-			/healthz responded with 503/,
-		);
-		// 3 attempts total = initial + 2 retries.
-		expect(mocked).toHaveBeenCalledTimes(3);
-	});
-
-	it("throws when the healthz body is malformed after retries", async () => {
-		const mocked = vi.fn(async () => ({
-			ok: true,
-			status: 200,
-			json: async () => ({ ok: true }),
-		}));
-		// biome-ignore lint/suspicious/noExplicitAny: minimal Response stub for the unit test
-		globalThis.fetch = mocked as any;
-		await expect(getRandomActiveProvider("production")).rejects.toThrow(
-			/missing host field/,
-		);
-		expect(mocked).toHaveBeenCalledTimes(3);
-	});
-
-	it("retries a transient healthz failure and pins on the eventual success", async () => {
-		let call = 0;
-		const mocked = vi.fn(async () => {
-			call++;
-			if (call === 1) {
-				return { ok: false, status: 503, json: async () => ({}) };
-			}
-			return {
-				ok: true,
-				status: 200,
-				json: async () => ({ ok: true, host: "pronode8.prosopo.io" }),
-			};
-		});
-		// biome-ignore lint/suspicious/noExplicitAny: minimal Response stub for the unit test
-		globalThis.fetch = mocked as any;
-		const result = await getRandomActiveProvider("production");
-		expect(result.provider.url).toBe("https://pronode8.prosopo.io");
-		expect(mocked).toHaveBeenCalledTimes(2);
-	});
-
-	it("evicts a failed pin so the next captcha attempt retries healthz fresh", async () => {
-		let call = 0;
-		const mocked = vi.fn(async () => {
-			call++;
-			if (call <= 3) {
-				return { ok: false, status: 502, json: async () => ({}) };
-			}
-			return {
-				ok: true,
-				status: 200,
-				json: async () => ({ ok: true, host: "pronode9.prosopo.io" }),
-			};
-		});
-		// biome-ignore lint/suspicious/noExplicitAny: minimal Response stub for the unit test
-		globalThis.fetch = mocked as any;
-		await expect(getRandomActiveProvider("production")).rejects.toThrow();
-		// First call failed 3 times; a fresh call must be able to retry — not
-		// return the poisoned cached rejection.
-		const result = await getRandomActiveProvider("production");
-		expect(result.provider.url).toBe("https://pronode9.prosopo.io");
-		expect(mocked).toHaveBeenCalledTimes(4);
-	});
-});
-
-describe("getRandomActiveProvider (single stack ipMode)", () => {
-	it("hits ipv4.pronode.prosopo.io/healthz and pins to ipv4.pronodeN", async () => {
-		const mocked = mockHealthzFetch("pronode4.prosopo.io");
-		const result = await getRandomActiveProvider("production", "ipv4");
-		expect(result.provider.url).toBe("https://ipv4.pronode4.prosopo.io");
-		expect(mocked).toHaveBeenCalledWith(
-			"https://ipv4.pronode.prosopo.io/healthz",
-			expect.any(Object),
-		);
-	});
-
-	it("hits ipv6 staging /healthz and pins to ipv6.staging-pronodeN", async () => {
-		const mocked = mockHealthzFetch("staging-pronode2.prosopo.io");
-		const result = await getRandomActiveProvider("staging", "ipv6");
-		expect(result.provider.url).toBe(
-			"https://ipv6.staging-pronode2.prosopo.io",
-		);
-		expect(mocked).toHaveBeenCalledWith(
-			"https://ipv6.staging.pronode.prosopo.io/healthz",
-			expect.any(Object),
-		);
-	});
-
-	it("throws for ipv4 mode when /healthz fails (no fallback to ipv4.pronode.prosopo.io)", async () => {
-		mockHealthzFetch("ignored", false, 500);
-		await expect(getRandomActiveProvider("production", "ipv4")).rejects.toThrow(
-			/healthz responded with 500/,
-		);
-	});
-
-	it("keeps the dual-stack cache and the ipv4 cache separate", async () => {
-		const mocked = mockHealthzFetch("pronode9.prosopo.io");
-		await getRandomActiveProvider("production");
-		await getRandomActiveProvider("production", "ipv4");
-		await getRandomActiveProvider("production");
-		await getRandomActiveProvider("production", "ipv4");
-		// One healthz per (env, ipMode) combination.
-		expect(mocked).toHaveBeenCalledTimes(2);
-	});
-});
-
-describe("getProviders", () => {
-	beforeEach(() => {
-		_resetProviderListCache();
-		loadBalancer.mockReset();
-	});
-
-	it("loads the provider list once and serves repeat callers from cache", async () => {
-		const providers = [
-			{ address: "5xyz", url: "https://p1", datasetId: "0x0" },
-		];
-		loadBalancer.mockResolvedValue(providers);
-
-		const first = await getProviders("production");
-		const second = await getProviders("production");
-
-		expect(first).toBe(providers);
-		expect(second).toBe(providers);
-		expect(loadBalancer).toHaveBeenCalledTimes(1);
-	});
-
-	it("dedupes concurrent in-flight loads into a single call", async () => {
-		const providers = [
-			{ address: "5xyz", url: "https://p1", datasetId: "0x0" },
-		];
-		loadBalancer.mockResolvedValue(providers);
-
-		const [a, b] = await Promise.all([
-			getProviders("production"),
-			getProviders("production"),
-		]);
-
-		expect(a).toBe(providers);
-		expect(b).toBe(providers);
-		expect(loadBalancer).toHaveBeenCalledTimes(1);
-	});
-
-	it("does not cache failures — a rejected load is retried on the next call", async () => {
-		const providers = [
-			{ address: "5xyz", url: "https://p1", datasetId: "0x0" },
-		];
-		loadBalancer
-			.mockRejectedValueOnce(new Error("transient"))
-			.mockResolvedValueOnce(providers);
-
-		await expect(getProviders("production")).rejects.toThrow("transient");
-		// The failure must have cleared the cache, so the next call retries.
-		const retry = await getProviders("production");
-		expect(retry).toBe(providers);
-		expect(loadBalancer).toHaveBeenCalledTimes(2);
-	});
-
-	it("keeps a separate entry per ipMode and passes it to loadBalancer", async () => {
-		const dual: HardcodedProvider[] = [
-			{ address: "5xyz", url: "https://p1", datasetId: "0x0", weight: 1 },
-		];
-		const v4: HardcodedProvider[] = [
-			{ address: "5xyz", url: "https://ipv4.p1", datasetId: "0x0", weight: 1 },
-		];
-		loadBalancer.mockImplementation(
-			async (_env: EnvironmentTypes, ipMode?: IpMode) =>
-				ipMode === "ipv4" ? v4 : dual,
-		);
-
-		expect(await getProviders("production")).toBe(dual);
-		expect(await getProviders("production", "ipv4")).toBe(v4);
-		// Both are now cached independently.
-		expect(await getProviders("production")).toBe(dual);
-		expect(await getProviders("production", "ipv4")).toBe(v4);
-
-		expect(loadBalancer).toHaveBeenCalledTimes(2);
-		expect(loadBalancer).toHaveBeenCalledWith("production", undefined);
-		expect(loadBalancer).toHaveBeenCalledWith("production", "ipv4");
-	});
-
-	it("reloads once the cached list is older than the TTL", async () => {
-		const first: HardcodedProvider[] = [
-			{ address: "5A", url: "https://p1", datasetId: "0x0", weight: 1 },
-		];
-		const second: HardcodedProvider[] = [
-			{ address: "5B", url: "https://p2", datasetId: "0x0", weight: 1 },
-		];
-		loadBalancer.mockResolvedValueOnce(first).mockResolvedValueOnce(second);
-
-		expect(await getProviders("production")).toBe(first);
-		advanceClock(PROVIDER_LIST_TTL_MS - 1);
-		expect(await getProviders("production")).toBe(first);
-		advanceClock(1);
-		expect(await getProviders("production")).toBe(second);
-		expect(loadBalancer).toHaveBeenCalledTimes(2);
-	});
-});
-
-describe("findProvider", () => {
-	const providers: HardcodedProvider[] = [
-		{ address: "5A", url: "https://pronode1.io", datasetId: "0x0", weight: 1 },
-		{ address: "5B", url: "https://pronode2.io", datasetId: "0x0", weight: 1 },
-	];
-
-	beforeEach(() => {
-		_resetProviderListCache();
-		loadBalancer.mockReset();
-	});
-
-	it("matches the issuing provider by exact url", async () => {
-		loadBalancer.mockResolvedValue(providers);
-
-		const found = await findProvider("production", "https://pronode2.io");
-
-		expect(found?.address).toBe("5B");
-		expect(loadBalancer).toHaveBeenCalledTimes(1);
-	});
-
-	it("serves a hit from cache without reloading the list", async () => {
-		loadBalancer.mockResolvedValue(providers);
-
-		await findProvider("production", "https://pronode1.io");
-		await findProvider("production", "https://pronode1.io");
-		await findProvider("production", "https://pronode1.io");
-
-		expect(loadBalancer).toHaveBeenCalledTimes(1);
-	});
-
-	it("looks in the ipMode section the token was minted against", async () => {
-		const v4: HardcodedProvider[] = [
-			{
-				address: "5A",
-				url: "https://ipv4.pronode1.io",
-				datasetId: "0x0",
-				weight: 1,
-			},
-		];
-		loadBalancer.mockImplementation(
-			async (_env: EnvironmentTypes, ipMode?: IpMode) =>
-				ipMode === "ipv4" ? v4 : providers,
-		);
-
-		const found = await findProvider(
-			"production",
-			"https://ipv4.pronode1.io",
-			"ipv4",
-		);
-
-		expect(found?.address).toBe("5A");
-	});
-
-	it("reloads on a miss so a provider added mid-TTL still verifies", async () => {
-		const added: HardcodedProvider[] = [
-			...providers,
-			{
-				address: "5C",
-				url: "https://pronode3.io",
-				datasetId: "0x0",
-				weight: 1,
-			},
-		];
-		loadBalancer.mockResolvedValueOnce(providers).mockResolvedValueOnce(added);
-
-		// Warm the cache with the list that predates pronode3.
-		await findProvider("production", "https://pronode1.io");
-		advanceClock(PROVIDER_LIST_MISS_RELOAD_MS);
-
-		const found = await findProvider("production", "https://pronode3.io");
-
-		expect(found?.address).toBe("5C");
-		expect(loadBalancer).toHaveBeenCalledTimes(2);
-	});
-
-	it("rate-limits the reload so an unknown url can't refetch per request", async () => {
-		loadBalancer.mockResolvedValue(providers);
-
-		await findProvider("production", "https://pronode1.io");
-		advanceClock(PROVIDER_LIST_MISS_RELOAD_MS);
-		// First miss after the floor is allowed to reload...
-		expect(await findProvider("production", "https://attacker.io")).toBe(
-			undefined,
-		);
-		// ...the ones immediately behind it are not.
-		expect(await findProvider("production", "https://attacker.io")).toBe(
-			undefined,
-		);
-		expect(await findProvider("production", "https://attacker.io")).toBe(
-			undefined,
-		);
-
-		expect(loadBalancer).toHaveBeenCalledTimes(2);
-	});
-
-	it("returns undefined for a token with no providerUrl without loading", async () => {
-		loadBalancer.mockResolvedValue(providers);
-
-		expect(await findProvider("production", undefined)).toBe(undefined);
-		expect(loadBalancer).not.toHaveBeenCalled();
-	});
-});
-
-describe("getRandomProviderFromList", () => {
-	const providerList: HardcodedProvider[] = [
-		{
-			address: "5A",
-			url: "https://provider-a.io",
-			datasetId: "0x0",
-			weight: 1,
-		},
-		{
-			address: "5B",
-			url: "https://provider-b.io",
-			datasetId: "0x0",
-			weight: 1,
-		},
-		{
-			address: "5C",
-			url: "https://provider-c.io",
-			datasetId: "0x0",
-			weight: 1,
-		},
-	];
-
-	beforeEach(() => {
-		_resetProviderListCache();
-		_resetPinCache();
-		loadBalancer.mockReset();
-	});
-
-	it("picks a provider from the list (not the DNS-routed endpoint)", async () => {
-		loadBalancer.mockResolvedValue(providerList);
-		// random just above 1/3 lands in the second bucket (uniform weights).
-		const result = await getRandomProviderFromList(
-			"production",
-			undefined,
-			undefined,
-			() => 0.4,
-		);
-		expect(result.provider.url).toBe("https://provider-b.io");
-		expect(result.providerAccount).toBe("5B");
-	});
-
-	it("excludes the provider that just failed when others remain", async () => {
-		loadBalancer.mockResolvedValue(providerList);
-		// random=0 would normally pick the first entry; excluding provider-a
-		// shifts the pool so index 0 is provider-b.
-		const result = await getRandomProviderFromList(
-			"production",
-			undefined,
-			"https://provider-a.io",
-			() => 0,
-		);
-		expect(result.provider.url).not.toBe("https://provider-a.io");
-		expect(result.provider.url).toBe("https://provider-b.io");
-	});
-
-	it("ignores a trailing slash when matching the excluded url", async () => {
-		loadBalancer.mockResolvedValue(providerList);
-		const result = await getRandomProviderFromList(
-			"production",
-			undefined,
-			"https://provider-a.io/",
-			() => 0,
-		);
-		expect(result.provider.url).toBe("https://provider-b.io");
-	});
-
-	it("still returns the only provider in development even if it is excluded", async () => {
-		const single: HardcodedProvider[] = [
-			{
-				address: "5Local",
-				url: "https://localhost:9229",
-				datasetId: "0x0",
-				weight: 1,
-			},
-		];
-		loadBalancer.mockResolvedValue(single);
-		const result = await getRandomProviderFromList(
-			"development",
-			undefined,
-			"https://localhost:9229",
-			() => 0,
-		);
-		expect(result.provider.url).toBe("https://localhost:9229");
-	});
-
-	it("applies the ipv4 label to the chosen provider url", async () => {
-		loadBalancer.mockResolvedValue(providerList);
-		const result = await getRandomProviderFromList(
-			"production",
-			"ipv4",
-			undefined,
-			() => 0,
-		);
-		expect(result.provider.url).toBe("https://ipv4.provider-a.io");
-	});
-
-	it("weights the pick by provider weight", async () => {
-		const weighted: HardcodedProvider[] = [
-			{ address: "5A", url: "https://a.io", datasetId: "0x0", weight: 1 },
-			{ address: "5B", url: "https://b.io", datasetId: "0x0", weight: 99 },
-		];
-		loadBalancer.mockResolvedValue(weighted);
-		// threshold = 0.5 * 100 = 50 → after subtracting weight 1 (still 49),
-		// lands on the heavy second provider.
-		const result = await getRandomProviderFromList(
-			"production",
-			undefined,
-			undefined,
-			() => 0.5,
-		);
-		expect(result.provider.url).toBe("https://b.io");
-	});
-
-	it("falls back to the DNS-routed endpoint when the list is empty", async () => {
-		loadBalancer.mockResolvedValue([]);
-		const result = await getRandomProviderFromList(
-			"development",
-			undefined,
-			undefined,
-			() => 0,
-		);
-		// Development resolves the local URL without a healthz round-trip.
-		expect(result.provider.url).toBe("https://localhost:9229");
-		expect(result.providerAccount).toBe("dns-routed");
-	});
-});

package/src/tests/retry.unit.test.ts

@@ -1,167 +0,0 @@
-// Copyright 2021-2026 Prosopo (UK) Ltd.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-import { describe, expect, it, vi } from "vitest";
-import { getBackoffDelayMs, retryWithBackoff } from "../retry.js";
-
-const noopSleep = (_ms: number): Promise<void> => Promise.resolve();
-
-describe("getBackoffDelayMs", () => {
-	it("scales the delay cap exponentially with the attempt index", () => {
-		// random=1 → returns the full cap so the exponent is observable.
-		expect(getBackoffDelayMs(0, 100, 10_000, () => 1)).toBe(100);
-		expect(getBackoffDelayMs(1, 100, 10_000, () => 1)).toBe(200);
-		expect(getBackoffDelayMs(2, 100, 10_000, () => 1)).toBe(400);
-		expect(getBackoffDelayMs(3, 100, 10_000, () => 1)).toBe(800);
-	});
-
-	it("caps the delay at maxDelayMs even for large attempt indices", () => {
-		expect(getBackoffDelayMs(10, 100, 1_000, () => 1)).toBe(1_000);
-		expect(getBackoffDelayMs(20, 100, 1_000, () => 1)).toBe(1_000);
-	});
-
-	it("clamps negative or fractional attempt indices to zero", () => {
-		expect(getBackoffDelayMs(-5, 100, 10_000, () => 1)).toBe(100);
-		expect(getBackoffDelayMs(0.9, 100, 10_000, () => 1)).toBe(100);
-	});
-
-	it("uses full jitter — random=0 yields 0, random=1 yields the cap", () => {
-		expect(getBackoffDelayMs(2, 100, 10_000, () => 0)).toBe(0);
-		expect(getBackoffDelayMs(2, 100, 10_000, () => 0.5)).toBe(200);
-		expect(getBackoffDelayMs(2, 100, 10_000, () => 1)).toBe(400);
-	});
-});
-
-describe("retryWithBackoff", () => {
-	it("returns the value on the first successful attempt without sleeping", async () => {
-		const sleep = vi.fn(noopSleep);
-		const fn = vi.fn(async () => "ok");
-		const result = await retryWithBackoff(fn, {
-			maxAttempts: 3,
-			baseDelayMs: 100,
-			maxDelayMs: 1_000,
-			sleep,
-		});
-		expect(result).toBe("ok");
-		expect(fn).toHaveBeenCalledTimes(1);
-		expect(sleep).not.toHaveBeenCalled();
-	});
-
-	it("retries on failure and returns on the eventual success", async () => {
-		const sleep = vi.fn(noopSleep);
-		let call = 0;
-		const fn = vi.fn(async () => {
-			call++;
-			if (call < 3) throw new Error(`transient ${call}`);
-			return "ok";
-		});
-		const result = await retryWithBackoff(fn, {
-			maxAttempts: 5,
-			baseDelayMs: 100,
-			maxDelayMs: 1_000,
-			random: () => 0.5,
-			sleep,
-		});
-		expect(result).toBe("ok");
-		expect(fn).toHaveBeenCalledTimes(3);
-		// Sleeps only between attempts, so N-1 sleeps for N-attempts-until-success.
-		expect(sleep).toHaveBeenCalledTimes(2);
-	});
-
-	it("throws the final error after maxAttempts exhausted", async () => {
-		const sleep = vi.fn(noopSleep);
-		let call = 0;
-		const fn = vi.fn(async () => {
-			call++;
-			throw new Error(`fail ${call}`);
-		});
-		await expect(
-			retryWithBackoff(fn, {
-				maxAttempts: 3,
-				baseDelayMs: 100,
-				maxDelayMs: 1_000,
-				sleep,
-			}),
-		).rejects.toThrow("fail 3");
-		expect(fn).toHaveBeenCalledTimes(3);
-		// Sleeps after attempts 1 and 2, but not after the final attempt.
-		expect(sleep).toHaveBeenCalledTimes(2);
-	});
-
-	it("normalises non-Error throws into an Error before rethrowing", async () => {
-		const fn = vi.fn(async () => {
-			throw "string thrown";
-		});
-		await expect(
-			retryWithBackoff(fn, {
-				maxAttempts: 2,
-				baseDelayMs: 0,
-				maxDelayMs: 0,
-				sleep: noopSleep,
-			}),
-		).rejects.toThrow("string thrown");
-	});
-
-	it("passes exponentially-growing delays to sleep", async () => {
-		const sleep = vi.fn(noopSleep);
-		const fn = vi.fn(async () => {
-			throw new Error("boom");
-		});
-		await expect(
-			retryWithBackoff(fn, {
-				maxAttempts: 4,
-				baseDelayMs: 100,
-				maxDelayMs: 10_000,
-				random: () => 1,
-				sleep,
-			}),
-		).rejects.toThrow("boom");
-		// random=1 → delays equal the cap: 100, 200, 400.
-		const delays = sleep.mock.calls.map(([ms]) => ms);
-		expect(delays).toEqual([100, 200, 400]);
-	});
-
-	it("does not retry when maxAttempts is 1 (retry disabled)", async () => {
-		const sleep = vi.fn(noopSleep);
-		const fn = vi.fn(async () => {
-			throw new Error("nope");
-		});
-		await expect(
-			retryWithBackoff(fn, {
-				maxAttempts: 1,
-				baseDelayMs: 100,
-				maxDelayMs: 1_000,
-				sleep,
-			}),
-		).rejects.toThrow("nope");
-		expect(fn).toHaveBeenCalledTimes(1);
-		expect(sleep).not.toHaveBeenCalled();
-	});
-
-	it.each([0, -1, 1.5, Number.NaN])(
-		"rejects maxAttempts %s without calling fn",
-		async (maxAttempts) => {
-			const fn = vi.fn(async () => "ok");
-			await expect(
-				retryWithBackoff(fn, {
-					maxAttempts,
-					baseDelayMs: 100,
-					maxDelayMs: 1_000,
-					sleep: noopSleep,
-				}),
-			).rejects.toThrow(/maxAttempts must be a positive integer/);
-			expect(fn).not.toHaveBeenCalled();
-		},
-	);
-});