@prosopo/load-balancer 2.11.4 → 2.11.6

package/src/developmentProviderUrl.ts

@@ -1,55 +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.
-
-/**
- * Where a development widget looks for its provider.
- *
- * `localhost` is right when the page and the provider share a machine, and
- * wrong the moment they do not: a phone or a simulator loading the demo over
- * the LAN resolves `localhost` to itself, so the widget never reaches the
- * provider and reports the site key as unregistered. The override exists so
- * that case can be pointed at the host running the provider.
- *
- * Development only — staging and production resolve through their DNS-routed
- * endpoints and ignore this entirely.
- */
-export const DEFAULT_DEVELOPMENT_PROVIDER_URL = "https://localhost:9229";
-
-/**
- * Read the override without assuming a runtime.
- *
- * Written as a static `process.env.X` access on purpose: the frontend build
- * substitutes that exact expression for a literal, which a computed lookup
- * (`process.env[key]`) would not match. For the same reason there is no
- * `typeof process` guard — in a browser bundle the whole expression is already
- * a string by the time it runs, and guarding on a `process` that does not
- * exist there would discard it. Under plain node with the variable unset it is
- * simply undefined; where neither applies the access throws and is caught.
- */
-export const readDevelopmentProviderUrlOverride = (): string | undefined => {
-	try {
-		return process.env.PROSOPO_PROVIDER_URL_DEVELOPMENT;
-	} catch {
-		return undefined;
-	}
-};
-
-export const getDevelopmentProviderUrl = (
-	override: string | undefined = readDevelopmentProviderUrlOverride(),
-): string => {
-	const trimmed = override?.trim();
-	return trimmed
-		? trimmed.replace(/\/$/, "")
-		: DEFAULT_DEVELOPMENT_PROVIDER_URL;
-};

package/src/index.ts

@@ -1,17 +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.
-export * from "./providers.js";
-export * from "./balancer.js";
-export * from "./developmentProviderUrl.js";
-export * from "./providerUrlOverride.js";

package/src/providerUrlOverride.ts

@@ -1,44 +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.
-
-/**
- * Supplies the provider list directly instead of fetching Prosopo's.
- *
- * A self-hosted deployment has its own providers and no hosted list to
- * discover them from. Setting this replaces both halves of discovery — the
- * endpoint the widget calls and the list a verifier matches a token against —
- * with whatever it names. See `getProviderListOverride` in `balancer.ts` for
- * the accepted forms.
- *
- * Distinct from `PROSOPO_PROVIDER_URL_DEVELOPMENT`, which only applies when
- * the environment is `development`. That coupling forced self-hosters to ship
- * a development build of the widget purely to redirect it; this override is
- * environment-independent, so `production` stays correct everywhere.
- *
- * Kept in its own module, holding nothing but the read, so that parsing can
- * live next to `convertHostedProvider` in `balancer.ts` without the two
- * modules importing each other. A cycle here would be bundled into the widget
- * and this package has already lost a release to one.
- *
- * Written as a static `process.env.X` access for the same reason as the
- * development override: frontend bundlers substitute that exact expression
- * for a literal, which a computed lookup would not match.
- */
-export const readProviderListOverride = (): string | undefined => {
-	try {
-		return process.env.PROSOPO_PROVIDER_LIST;
-	} catch {
-		return undefined;
-	}
-};

package/src/providers.ts

@@ -1,352 +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, RandomProvider } from "@prosopo/types";
-import {
-	type HardcodedProvider,
-	type IpMode,
-	getProviderListOverride,
-	loadBalancer,
-} from "./balancer.js";
-import { getDevelopmentProviderUrl } from "./developmentProviderUrl.js";
-import { retryWithBackoff } from "./retry.js";
-
-// Base DNS endpoint per env — the `pronode.prosopo.io` family is latency-routed
-// (A/AAAA records across the pronode fleet). Clients hit this URL's `/healthz`
-// once to discover which specific pronodeN the DNS layer picked, then pin
-// subsequent captcha calls to that pronode so session creation and submission
-// land on the same backend.
-// Resolved per call rather than once at module load, so a development override
-// set after this module is imported is still picked up.
-const dnsEndpoints = (): Record<EnvironmentTypes, string> => ({
-	development: getDevelopmentProviderUrl(),
-	staging: "https://staging.pronode.prosopo.io",
-	production: "https://pronode.prosopo.io",
-});
-
-// Apply the `ipv4.` / `ipv6.` DNS label to a hostname. The single-stack
-// sub-zones only resolve to A or AAAA records respectively, so this pins the
-// network path before TLS negotiation. Ansible provisions the matching certs
-// for both `ipv4.{global}` and `ipv4.pronodeN.{global}`.
-const withIpModeLabel = (hostname: string, ipMode?: IpMode): string =>
-	ipMode ? `${ipMode}.${hostname}` : hostname;
-
-const applyIpModeToUrl = (url: string, ipMode?: IpMode): string => {
-	if (!ipMode) return url;
-	try {
-		const parsed = new URL(url);
-		parsed.hostname = withIpModeLabel(parsed.hostname, ipMode);
-		return parsed.toString().replace(/\/$/, "");
-	} catch {
-		return url;
-	}
-};
-
-// Cached, in-flight pin per (env, ipMode). Keyed so dual-stack and single-stack
-// callers maintain separate stickiness — they hit different /healthz endpoints
-// and shouldn't share each other's resolution.
-type CacheKey = `${EnvironmentTypes}|${IpMode | "dual"}`;
-const cacheKey = (env: EnvironmentTypes, ipMode?: IpMode): CacheKey =>
-	`${env}|${ipMode ?? "dual"}`;
-const pinPromiseCache: Map<CacheKey, Promise<string>> = new Map();
-
-// Healthz retry policy. Healthz is a prerequisite for pinning a session to a
-// specific pronode — without a pinned host the token embeds the load-balanced
-// hostname, which isn't a registered on-chain provider and gets rejected at
-// verify time. A transient blip therefore mustn't fail immediately: retry
-// with exponential-backoff + full jitter before surfacing the error.
-const HEALTHZ_MAX_ATTEMPTS = 3;
-const HEALTHZ_RETRY_BASE_DELAY_MS = 250;
-const HEALTHZ_RETRY_MAX_DELAY_MS = 2_000;
-
-let healthzMaxAttempts = HEALTHZ_MAX_ATTEMPTS;
-let healthzRetryBaseDelayMs = HEALTHZ_RETRY_BASE_DELAY_MS;
-let healthzRetryMaxDelayMs = HEALTHZ_RETRY_MAX_DELAY_MS;
-
-const fetchPinnedHost = async (baseUrl: string): Promise<string> => {
-	const res = await fetch(`${baseUrl}/healthz`, {
-		method: "GET",
-		cache: "no-store",
-		credentials: "omit",
-	});
-	if (!res.ok) {
-		throw new Error(`healthz responded with ${res.status}`);
-	}
-	const body = (await res.json()) as { host?: unknown };
-	if (typeof body.host !== "string" || body.host.length === 0) {
-		throw new Error("healthz response missing host field");
-	}
-	return body.host;
-};
-
-const fetchPinnedHostWithRetry = (baseUrl: string): Promise<string> =>
-	retryWithBackoff(() => fetchPinnedHost(baseUrl), {
-		maxAttempts: healthzMaxAttempts,
-		baseDelayMs: healthzRetryBaseDelayMs,
-		maxDelayMs: healthzRetryMaxDelayMs,
-	});
-
-const resolveBaseUrl = (env: EnvironmentTypes): string => {
-	const endpoints = dnsEndpoints();
-	return endpoints[env] ?? endpoints.development;
-};
-
-const resolvePinnedUrl = async (
-	env: EnvironmentTypes,
-	ipMode?: IpMode,
-): Promise<string> => {
-	// An overridden list needs no discovery: healthz exists to report which
-	// pronode the DNS layer picked, and an override already names the nodes.
-	// Returning early also keeps the widget off Prosopo's hostnames entirely.
-	// The pick is weighted and per-call rather than cached, so traffic spreads
-	// across a multi-provider override instead of every page in a browser
-	// session pinning to whichever node was drawn first.
-	const override = getProviderListOverride(undefined, ipMode);
-	if (override.length > 0) {
-		const chosen = pickWeightedProvider(override, Math.random);
-		if (chosen) return chosen.url;
-	}
-
-	// The base for /healthz already carries the ipv4./ipv6. label when one is
-	// requested, so DNS keeps the discovery request on the same single-stack
-	// path as the captcha calls that follow.
-	const base = applyIpModeToUrl(resolveBaseUrl(env), ipMode);
-	// Development has no global hostname to /healthz against; use the
-	// hardcoded local URL.
-	if (env === "development") return base;
-
-	const key = cacheKey(env, ipMode);
-	const cached = pinPromiseCache.get(key);
-	if (cached) return cached;
-
-	const promise = (async () => {
-		try {
-			const host = await fetchPinnedHostWithRetry(base);
-			const parsed = new URL(base);
-			// /healthz returns the bare pronodeN.prosopo.io (env.config.host).
-			// Re-apply the ipMode label so the per-pronode URL stays on the same
-			// single-stack sub-zone (`ipv4.pronode4.prosopo.io`).
-			parsed.hostname = withIpModeLabel(host, ipMode);
-			return parsed.toString().replace(/\/$/, "");
-		} catch (err) {
-			// Healthz is a prerequisite for the rest of the captcha flow — the
-			// token must embed a specific pronodeN URL for verify to accept it.
-			// Evict the cached rejection so a subsequent captcha attempt gets a
-			// fresh chance, and surface the error so the caller's own retry
-			// (`providerRetry` in @prosopo/procaptcha-common) can fall through
-			// to `getRandomProviderFromList`, which bypasses healthz entirely.
-			pinPromiseCache.delete(key);
-			throw err;
-		}
-	})();
-
-	pinPromiseCache.set(key, promise);
-	return promise;
-};
-
-// How long a loaded list is served before the next caller reloads it. The
-// hosted list advertises `cache-control: max-age=300`, so this matches what it
-// asks for. `findProvider` covers the window where a pronode is added mid-TTL.
-export const PROVIDER_LIST_TTL_MS = 5 * 60 * 1000;
-
-// Floor on how often a lookup miss may force an early reload. `providerUrl` is
-// read from the token, which a caller controls, so an unknown url must not be
-// able to turn every request into a fresh fetch of the list.
-export const PROVIDER_LIST_MISS_RELOAD_MS = 10 * 1000;
-
-interface ProviderListEntry {
-	providers: Promise<HardcodedProvider[]>;
-	loadedAt: number;
-}
-
-// Cached, in-flight provider-list load per env + ipMode. The list rarely
-// changes, so a single fetch is shared across callers rather than re-fetching
-// the provider-list JSON on every verify decision. Keyed the same way as the
-// pin cache: the `ipv4`/`ipv6` sections carry different urls to the dual-stack
-// default, so they cannot share an entry.
-const providerListCache: Map<CacheKey, ProviderListEntry> = new Map();
-
-/**
- * Returns the full (cached) list of active providers for an environment.
- * Used to look up a provider by url/address, e.g. to find the provider that
- * issued a token before forwarding a verification request to it.
- */
-export const getProviders = async (
-	env: EnvironmentTypes,
-	ipMode?: IpMode,
-): Promise<HardcodedProvider[]> => {
-	const key = cacheKey(env, ipMode);
-	const cached = providerListCache.get(key);
-	if (cached && Date.now() - cached.loadedAt < PROVIDER_LIST_TTL_MS) {
-		return cached.providers;
-	}
-
-	const providers = loadBalancer(env, ipMode).catch((err) => {
-		// Don't cache failures — a transient fetch error shouldn't poison the
-		// cache for the lifetime of the process. Only evict this entry: a
-		// later load may already have replaced it.
-		if (providerListCache.get(key)?.providers === providers) {
-			providerListCache.delete(key);
-		}
-		throw err;
-	});
-	providerListCache.set(key, { providers, loadedAt: Date.now() });
-	return providers;
-};
-
-/**
- * Finds the provider that minted a token, by exact url match.
- *
- * Exact-string rather than normalised: the single-stack sections of the list
- * carry sub-zone urls (`https://ipv4.pronode15.prosopo.io`), so the caller
- * passes the `ipMode` it derived from the token's own hostname and both sides
- * of the comparison stay in the same section.
- *
- * A miss reloads the list once before giving up, so a pronode added part-way
- * through the TTL still verifies the tokens it has already minted. That reload
- * is rate-limited, because a miss is also what an unknown url produces.
- */
-export const findProvider = async (
-	env: EnvironmentTypes,
-	providerUrl: string | undefined,
-	ipMode?: IpMode,
-): Promise<HardcodedProvider | undefined> => {
-	if (!providerUrl) return undefined;
-
-	const providers = await getProviders(env, ipMode);
-	const provider = providers.find((p) => p.url === providerUrl);
-	if (provider) return provider;
-
-	const key = cacheKey(env, ipMode);
-	const cached = providerListCache.get(key);
-	if (cached && Date.now() - cached.loadedAt < PROVIDER_LIST_MISS_RELOAD_MS) {
-		return undefined;
-	}
-	providerListCache.delete(key);
-
-	const reloaded = await getProviders(env, ipMode);
-	return reloaded.find((p) => p.url === providerUrl);
-};
-
-export const getRandomActiveProvider = async (
-	env: EnvironmentTypes,
-	ipMode?: IpMode,
-): Promise<RandomProvider> => {
-	const url = await resolvePinnedUrl(env, ipMode);
-	return {
-		providerAccount: "dns-routed",
-		provider: { url },
-	};
-};
-
-// Compare two provider URLs ignoring a trailing slash so a stored "failed" URL
-// still matches its list entry regardless of formatting.
-const sameProviderUrl = (a: string, b: string): boolean =>
-	a.replace(/\/$/, "") === b.replace(/\/$/, "");
-
-// Weighted random pick — providers advertise a capacity weight (1-100), so
-// fallback traffic is spread in proportion to capacity rather than uniformly.
-// Returns undefined only for an empty list (callers guard against that).
-const pickWeightedProvider = (
-	providers: HardcodedProvider[],
-	random: () => number,
-): HardcodedProvider | undefined => {
-	const totalWeight = providers.reduce((sum, p) => sum + p.weight, 0);
-	let threshold = random() * totalWeight;
-	let chosen: HardcodedProvider | undefined;
-	for (const provider of providers) {
-		chosen = provider;
-		threshold -= provider.weight;
-		if (threshold < 0) break;
-	}
-	return chosen;
-};
-
-/**
- * Pick a random provider directly from the provider list, bypassing the
- * DNS-routed endpoint. This is the error-fallback path: once a provider has
- * errored, retrying it re-hits the same (possibly-down) endpoint, and a fleet
- * of widgets doing that in a tight loop can accidentally DDoS the provider — so
- * instead we spread the retry across the fleet by choosing a random provider
- * from the list. `excludeUrl` (the provider that just failed) is dropped from
- * the pool when other providers remain. In development the list holds only the
- * single local provider, so this naturally degrades to retrying that provider.
- * `random` is injectable so tests can make the pick deterministic.
- */
-export const getRandomProviderFromList = async (
-	env: EnvironmentTypes,
-	ipMode?: IpMode,
-	excludeUrl?: string,
-	random: () => number = Math.random,
-): Promise<RandomProvider> => {
-	const providers = await getProviders(env);
-	if (providers.length === 0) {
-		// Nothing to choose from — fall back to the DNS-routed endpoint.
-		return getRandomActiveProvider(env, ipMode);
-	}
-
-	// Only exclude the failed provider when at least one other remains, so we
-	// never end up with an empty pool (e.g. a single-provider environment).
-	const eligible =
-		excludeUrl && providers.length > 1
-			? providers.filter(
-					(p) => !sameProviderUrl(applyIpModeToUrl(p.url, ipMode), excludeUrl),
-				)
-			: providers;
-	const pool = eligible.length > 0 ? eligible : providers;
-
-	const chosen = pickWeightedProvider(pool, random);
-	if (!chosen) {
-		return getRandomActiveProvider(env, ipMode);
-	}
-	return {
-		providerAccount: chosen.address,
-		provider: { url: applyIpModeToUrl(chosen.url, ipMode) },
-	};
-};
-
-// Test-only escape hatch so tests can isolate the healthz cache between
-// cases. Not exported from the package index — internal use only.
-export const _resetPinCache = () => {
-	pinPromiseCache.clear();
-};
-
-// Test-only escape hatch to isolate the provider-list cache between cases.
-// Not exported from the package index — internal use only.
-export const _resetProviderListCache = () => {
-	providerListCache.clear();
-};
-
-// Test-only override for the healthz retry policy — tests use it to disable
-// backoff delays (baseDelayMs: 0) and to shorten/lengthen the attempt count.
-// Not exported from the package index — internal use only.
-export const _setHealthzRetryPolicy = (opts: {
-	maxAttempts?: number;
-	baseDelayMs?: number;
-	maxDelayMs?: number;
-}) => {
-	if (opts.maxAttempts !== undefined) healthzMaxAttempts = opts.maxAttempts;
-	if (opts.baseDelayMs !== undefined)
-		healthzRetryBaseDelayMs = opts.baseDelayMs;
-	if (opts.maxDelayMs !== undefined) healthzRetryMaxDelayMs = opts.maxDelayMs;
-};
-
-// Test-only reset for the healthz retry policy — restores the defaults so an
-// override in one test doesn't leak into the next. Not exported from the
-// package index — internal use only.
-export const _resetHealthzRetryPolicy = () => {
-	healthzMaxAttempts = HEALTHZ_MAX_ATTEMPTS;
-	healthzRetryBaseDelayMs = HEALTHZ_RETRY_BASE_DELAY_MS;
-	healthzRetryMaxDelayMs = HEALTHZ_RETRY_MAX_DELAY_MS;
-};

package/src/retry.ts

@@ -1,82 +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.
-
-export type RetryOptions = {
-	// Total attempts including the first. `1` disables retries.
-	maxAttempts: number;
-	// Base delay for the first retry — attempt N waits in [0, base * 2^N].
-	baseDelayMs: number;
-	// Upper bound on the jitter window so backoff can't grow unboundedly.
-	maxDelayMs: number;
-	// Injectable for deterministic tests. Defaults to Math.random.
-	random?: () => number;
-	// Injectable for deterministic tests. Defaults to setTimeout-based sleep.
-	sleep?: (ms: number) => Promise<void>;
-};
-
-const defaultSleep = (ms: number): Promise<void> =>
-	ms > 0
-		? new Promise((resolve) => setTimeout(resolve, ms))
-		: Promise.resolve();
-
-// Full-jitter exponential backoff — attempt N picks a uniform delay in the
-// range [0, min(maxDelayMs, baseDelayMs * 2^N)]. Full jitter (rather than
-// equal jitter) desynchronises clients that all failed at the same moment,
-// so their retries don't reconverge into a thundering herd against whatever
-// they're calling. Matches the algorithm in @prosopo/procaptcha-common's
-// getRetryDelayMs so both retry paths behave the same way.
-export const getBackoffDelayMs = (
-	attempt: number,
-	baseDelayMs: number,
-	maxDelayMs: number,
-	random: () => number = Math.random,
-): number => {
-	const safeAttempt = Math.max(0, Math.floor(attempt));
-	const cap = Math.min(maxDelayMs, baseDelayMs * 2 ** safeAttempt);
-	return Math.round(random() * cap);
-};
-
-/**
- * Run `fn` up to `maxAttempts` times, sleeping with full-jitter exponential
- * backoff between attempts. Returns the first successful value. If every
- * attempt throws, throws the last error (Error-normalised).
- */
-export const retryWithBackoff = async <T>(
-	fn: () => Promise<T>,
-	opts: RetryOptions,
-): Promise<T> => {
-	const {
-		maxAttempts,
-		baseDelayMs,
-		maxDelayMs,
-		random = Math.random,
-		sleep = defaultSleep,
-	} = opts;
-	if (!Number.isInteger(maxAttempts) || maxAttempts < 1) {
-		throw new RangeError(
-			`maxAttempts must be a positive integer, got ${maxAttempts}`,
-		);
-	}
-	let lastErr: unknown;
-	for (let attempt = 0; attempt < maxAttempts; attempt++) {
-		try {
-			return await fn();
-		} catch (err) {
-			lastErr = err;
-			if (attempt >= maxAttempts - 1) break;
-			await sleep(getBackoffDelayMs(attempt, baseDelayMs, maxDelayMs, random));
-		}
-	}
-	throw lastErr instanceof Error ? lastErr : new Error(String(lastErr));
-};

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

@@ -1,76 +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 { afterEach, describe, expect, it } from "vitest";
-import {
-	DEFAULT_DEVELOPMENT_PROVIDER_URL,
-	getDevelopmentProviderUrl,
-	readDevelopmentProviderUrlOverride,
-} from "../developmentProviderUrl.js";
-
-const ENV_KEY = "PROSOPO_PROVIDER_URL_DEVELOPMENT";
-const original: string | undefined = process.env[ENV_KEY];
-
-afterEach(() => {
-	if (original === undefined) delete process.env[ENV_KEY];
-	else process.env[ENV_KEY] = original;
-});
-
-describe("the development provider url", () => {
-	it("is localhost when nothing overrides it", () => {
-		expect(getDevelopmentProviderUrl(undefined)).toBe("https://localhost:9229");
-		expect(DEFAULT_DEVELOPMENT_PROVIDER_URL).toBe("https://localhost:9229");
-	});
-
-	it("is the override when one is set", () => {
-		// The case this exists for: a phone loading the demo over the LAN cannot
-		// reach the provider via `localhost`, which resolves to the phone.
-		expect(getDevelopmentProviderUrl("https://192.0.2.10:9229")).toBe(
-			"https://192.0.2.10:9229",
-		);
-	});
-
-	it("drops a trailing slash so the url composes with /healthz", () => {
-		expect(getDevelopmentProviderUrl("https://192.0.2.10:9229/")).toBe(
-			"https://192.0.2.10:9229",
-		);
-	});
-
-	it("falls back rather than yielding an empty url", () => {
-		for (const blank of ["", "   ", undefined]) {
-			expect(getDevelopmentProviderUrl(blank)).toBe(
-				DEFAULT_DEVELOPMENT_PROVIDER_URL,
-			);
-		}
-	});
-});
-
-describe("reading the override", () => {
-	it("reads the environment variable", () => {
-		process.env[ENV_KEY] = "https://198.51.100.7:9229";
-		expect(readDevelopmentProviderUrlOverride()).toBe(
-			"https://198.51.100.7:9229",
-		);
-	});
-
-	it("is undefined when the variable is unset", () => {
-		delete process.env[ENV_KEY];
-		expect(readDevelopmentProviderUrlOverride()).toBeUndefined();
-	});
-
-	it("defaults when the variable is unset", () => {
-		delete process.env[ENV_KEY];
-		expect(getDevelopmentProviderUrl()).toBe(DEFAULT_DEVELOPMENT_PROVIDER_URL);
-	});
-});