@prosopo/load-balancer 2.10.15 → 2.10.17

package/dist/cjs/retry.cjs

@@ -1,30 +1,26 @@
-"use strict";
-Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const defaultSleep = (ms) => ms > 0 ? new Promise((resolve) => setTimeout(resolve, ms)) : Promise.resolve();
-const getBackoffDelayMs = (attempt, baseDelayMs, maxDelayMs, random = Math.random) => {
-  const safeAttempt = Math.max(0, Math.floor(attempt));
-  const cap = Math.min(maxDelayMs, baseDelayMs * 2 ** safeAttempt);
-  return Math.round(random() * cap);
+//#region src/retry.ts
+var defaultSleep = (ms) => ms > 0 ? new Promise((resolve) => setTimeout(resolve, ms)) : Promise.resolve();
+var getBackoffDelayMs = (attempt, baseDelayMs, maxDelayMs, random = Math.random) => {
+	const cap = Math.min(maxDelayMs, baseDelayMs * 2 ** Math.max(0, Math.floor(attempt)));
+	return Math.round(random() * cap);
 };
-const retryWithBackoff = async (fn, opts) => {
-  const {
-    maxAttempts,
-    baseDelayMs,
-    maxDelayMs,
-    random = Math.random,
-    sleep = defaultSleep
-  } = opts;
-  let lastErr;
-  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));
+/**
+* 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).
+*/
+var retryWithBackoff = async (fn, opts) => {
+	const { maxAttempts, baseDelayMs, maxDelayMs, random = Math.random, sleep = defaultSleep } = opts;
+	let lastErr;
+	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));
 };
+//#endregion
 exports.getBackoffDelayMs = getBackoffDelayMs;
 exports.retryWithBackoff = retryWithBackoff;

package/dist/index.js

@@ -1,16 +1,4 @@
-import { _resetHealthzRetryPolicy, _resetPinCache, _resetProviderListCache, _setHealthzRetryPolicy, getProviders, getRandomActiveProvider, getRandomProviderFromList } from "./providers.js";
+import "./_virtual/_rolldown/runtime.js";
 import { convertHostedProvider, getLoadBalancerUrl, getProviderHostname, loadBalancer, stripIpModeLabel } from "./balancer.js";
-export {
-  _resetHealthzRetryPolicy,
-  _resetPinCache,
-  _resetProviderListCache,
-  _setHealthzRetryPolicy,
-  convertHostedProvider,
-  getLoadBalancerUrl,
-  getProviderHostname,
-  getProviders,
-  getRandomActiveProvider,
-  getRandomProviderFromList,
-  loadBalancer,
-  stripIpModeLabel
-};
+import { _resetHealthzRetryPolicy, _resetPinCache, _resetProviderListCache, _setHealthzRetryPolicy, getProviders, getRandomActiveProvider, getRandomProviderFromList } from "./providers.js";
+export { _resetHealthzRetryPolicy, _resetPinCache, _resetProviderListCache, _setHealthzRetryPolicy, convertHostedProvider, getLoadBalancerUrl, getProviderHostname, getProviders, getRandomActiveProvider, getRandomProviderFromList, loadBalancer, stripIpModeLabel };

package/dist/providers.js

@@ -1,141 +1,138 @@
 import { loadBalancer } from "./balancer.js";
 import { retryWithBackoff } from "./retry.js";
-const DNS_ENDPOINT = {
-  development: "https://localhost:9229",
-  staging: "https://staging.pronode.prosopo.io",
-  production: "https://pronode.prosopo.io"
+//#region src/providers.ts
+var DNS_ENDPOINT = {
+	development: "https://localhost:9229",
+	staging: "https://staging.pronode.prosopo.io",
+	production: "https://pronode.prosopo.io"
 };
-const withIpModeLabel = (hostname, ipMode) => ipMode ? `${ipMode}.${hostname}` : hostname;
-const applyIpModeToUrl = (url, ipMode) => {
-  if (!ipMode) return url;
-  try {
-    const parsed = new URL(url);
-    parsed.hostname = withIpModeLabel(parsed.hostname, ipMode);
-    return parsed.toString().replace(/\/$/, "");
-  } catch {
-    return url;
-  }
+var withIpModeLabel = (hostname, ipMode) => ipMode ? `${ipMode}.${hostname}` : hostname;
+var applyIpModeToUrl = (url, ipMode) => {
+	if (!ipMode) return url;
+	try {
+		const parsed = new URL(url);
+		parsed.hostname = withIpModeLabel(parsed.hostname, ipMode);
+		return parsed.toString().replace(/\/$/, "");
+	} catch {
+		return url;
+	}
 };
-const cacheKey = (env, ipMode) => `${env}|${ipMode ?? "dual"}`;
-const pinPromiseCache = /* @__PURE__ */ new Map();
-const HEALTHZ_MAX_ATTEMPTS = 3;
-const HEALTHZ_RETRY_BASE_DELAY_MS = 250;
-const HEALTHZ_RETRY_MAX_DELAY_MS = 2e3;
-let healthzMaxAttempts = HEALTHZ_MAX_ATTEMPTS;
-let healthzRetryBaseDelayMs = HEALTHZ_RETRY_BASE_DELAY_MS;
-let healthzRetryMaxDelayMs = HEALTHZ_RETRY_MAX_DELAY_MS;
-const fetchPinnedHost = async (baseUrl) => {
-  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();
-  if (typeof body.host !== "string" || body.host.length === 0) {
-    throw new Error("healthz response missing host field");
-  }
-  return body.host;
+var cacheKey = (env, ipMode) => `${env}|${ipMode ?? "dual"}`;
+var pinPromiseCache = /* @__PURE__ */ new Map();
+var HEALTHZ_MAX_ATTEMPTS = 3;
+var HEALTHZ_RETRY_BASE_DELAY_MS = 250;
+var HEALTHZ_RETRY_MAX_DELAY_MS = 2e3;
+var healthzMaxAttempts = HEALTHZ_MAX_ATTEMPTS;
+var healthzRetryBaseDelayMs = HEALTHZ_RETRY_BASE_DELAY_MS;
+var healthzRetryMaxDelayMs = HEALTHZ_RETRY_MAX_DELAY_MS;
+var fetchPinnedHost = async (baseUrl) => {
+	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();
+	if (typeof body.host !== "string" || body.host.length === 0) throw new Error("healthz response missing host field");
+	return body.host;
 };
-const fetchPinnedHostWithRetry = (baseUrl) => retryWithBackoff(() => fetchPinnedHost(baseUrl), {
-  maxAttempts: healthzMaxAttempts,
-  baseDelayMs: healthzRetryBaseDelayMs,
-  maxDelayMs: healthzRetryMaxDelayMs
+var fetchPinnedHostWithRetry = (baseUrl) => retryWithBackoff(() => fetchPinnedHost(baseUrl), {
+	maxAttempts: healthzMaxAttempts,
+	baseDelayMs: healthzRetryBaseDelayMs,
+	maxDelayMs: healthzRetryMaxDelayMs
 });
-const resolveBaseUrl = (env) => DNS_ENDPOINT[env] ?? DNS_ENDPOINT.development;
-const resolvePinnedUrl = async (env, ipMode) => {
-  const base = applyIpModeToUrl(resolveBaseUrl(env), ipMode);
-  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);
-      parsed.hostname = withIpModeLabel(host, ipMode);
-      return parsed.toString().replace(/\/$/, "");
-    } catch (err) {
-      pinPromiseCache.delete(key);
-      throw err;
-    }
-  })();
-  pinPromiseCache.set(key, promise);
-  return promise;
+var resolveBaseUrl = (env) => DNS_ENDPOINT[env] ?? DNS_ENDPOINT.development;
+var resolvePinnedUrl = async (env, ipMode) => {
+	const base = applyIpModeToUrl(resolveBaseUrl(env), ipMode);
+	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);
+			parsed.hostname = withIpModeLabel(host, ipMode);
+			return parsed.toString().replace(/\/$/, "");
+		} catch (err) {
+			pinPromiseCache.delete(key);
+			throw err;
+		}
+	})();
+	pinPromiseCache.set(key, promise);
+	return promise;
 };
-const providerListPromiseCache = /* @__PURE__ */ new Map();
-const getProviders = async (env) => {
-  const cached = providerListPromiseCache.get(env);
-  if (cached) return cached;
-  const promise = loadBalancer(env).catch((err) => {
-    providerListPromiseCache.delete(env);
-    throw err;
-  });
-  providerListPromiseCache.set(env, promise);
-  return promise;
+var providerListPromiseCache = /* @__PURE__ */ 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.
+*/
+var getProviders = async (env) => {
+	const cached = providerListPromiseCache.get(env);
+	if (cached) return cached;
+	const promise = loadBalancer(env).catch((err) => {
+		providerListPromiseCache.delete(env);
+		throw err;
+	});
+	providerListPromiseCache.set(env, promise);
+	return promise;
 };
-const getRandomActiveProvider = async (env, ipMode) => {
-  const url = await resolvePinnedUrl(env, ipMode);
-  return {
-    providerAccount: "dns-routed",
-    provider: { url }
-  };
+var getRandomActiveProvider = async (env, ipMode) => {
+	return {
+		providerAccount: "dns-routed",
+		provider: { url: await resolvePinnedUrl(env, ipMode) }
+	};
 };
-const sameProviderUrl = (a, b) => a.replace(/\/$/, "") === b.replace(/\/$/, "");
-const pickWeightedProvider = (providers, random) => {
-  const totalWeight = providers.reduce((sum, p) => sum + p.weight, 0);
-  let threshold = random() * totalWeight;
-  let chosen;
-  for (const provider of providers) {
-    chosen = provider;
-    threshold -= provider.weight;
-    if (threshold < 0) break;
-  }
-  return chosen;
+var sameProviderUrl = (a, b) => a.replace(/\/$/, "") === b.replace(/\/$/, "");
+var pickWeightedProvider = (providers, random) => {
+	const totalWeight = providers.reduce((sum, p) => sum + p.weight, 0);
+	let threshold = random() * totalWeight;
+	let chosen;
+	for (const provider of providers) {
+		chosen = provider;
+		threshold -= provider.weight;
+		if (threshold < 0) break;
+	}
+	return chosen;
 };
-const getRandomProviderFromList = async (env, ipMode, excludeUrl, random = Math.random) => {
-  const providers = await getProviders(env);
-  if (providers.length === 0) {
-    return getRandomActiveProvider(env, ipMode);
-  }
-  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) }
-  };
+/**
+* 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.
+*/
+var getRandomProviderFromList = async (env, ipMode, excludeUrl, random = Math.random) => {
+	const providers = await getProviders(env);
+	if (providers.length === 0) return getRandomActiveProvider(env, ipMode);
+	const eligible = excludeUrl && providers.length > 1 ? providers.filter((p) => !sameProviderUrl(applyIpModeToUrl(p.url, ipMode), excludeUrl)) : providers;
+	const chosen = pickWeightedProvider(eligible.length > 0 ? eligible : providers, random);
+	if (!chosen) return getRandomActiveProvider(env, ipMode);
+	return {
+		providerAccount: chosen.address,
+		provider: { url: applyIpModeToUrl(chosen.url, ipMode) }
+	};
 };
-const _resetPinCache = () => {
-  pinPromiseCache.clear();
+var _resetPinCache = () => {
+	pinPromiseCache.clear();
 };
-const _resetProviderListCache = () => {
-  providerListPromiseCache.clear();
+var _resetProviderListCache = () => {
+	providerListPromiseCache.clear();
 };
-const _setHealthzRetryPolicy = (opts) => {
-  if (opts.maxAttempts !== void 0) healthzMaxAttempts = opts.maxAttempts;
-  if (opts.baseDelayMs !== void 0)
-    healthzRetryBaseDelayMs = opts.baseDelayMs;
-  if (opts.maxDelayMs !== void 0) healthzRetryMaxDelayMs = opts.maxDelayMs;
+var _setHealthzRetryPolicy = (opts) => {
+	if (opts.maxAttempts !== void 0) healthzMaxAttempts = opts.maxAttempts;
+	if (opts.baseDelayMs !== void 0) healthzRetryBaseDelayMs = opts.baseDelayMs;
+	if (opts.maxDelayMs !== void 0) healthzRetryMaxDelayMs = opts.maxDelayMs;
 };
-const _resetHealthzRetryPolicy = () => {
-  healthzMaxAttempts = HEALTHZ_MAX_ATTEMPTS;
-  healthzRetryBaseDelayMs = HEALTHZ_RETRY_BASE_DELAY_MS;
-  healthzRetryMaxDelayMs = HEALTHZ_RETRY_MAX_DELAY_MS;
-};
-export {
-  _resetHealthzRetryPolicy,
-  _resetPinCache,
-  _resetProviderListCache,
-  _setHealthzRetryPolicy,
-  getProviders,
-  getRandomActiveProvider,
-  getRandomProviderFromList
+var _resetHealthzRetryPolicy = () => {
+	healthzMaxAttempts = HEALTHZ_MAX_ATTEMPTS;
+	healthzRetryBaseDelayMs = HEALTHZ_RETRY_BASE_DELAY_MS;
+	healthzRetryMaxDelayMs = HEALTHZ_RETRY_MAX_DELAY_MS;
 };
+//#endregion
+export { _resetHealthzRetryPolicy, _resetPinCache, _resetProviderListCache, _setHealthzRetryPolicy, getProviders, getRandomActiveProvider, getRandomProviderFromList };

package/dist/retry.js

@@ -1,30 +1,25 @@
-const defaultSleep = (ms) => ms > 0 ? new Promise((resolve) => setTimeout(resolve, ms)) : Promise.resolve();
-const getBackoffDelayMs = (attempt, baseDelayMs, maxDelayMs, random = Math.random) => {
-  const safeAttempt = Math.max(0, Math.floor(attempt));
-  const cap = Math.min(maxDelayMs, baseDelayMs * 2 ** safeAttempt);
-  return Math.round(random() * cap);
+//#region src/retry.ts
+var defaultSleep = (ms) => ms > 0 ? new Promise((resolve) => setTimeout(resolve, ms)) : Promise.resolve();
+var getBackoffDelayMs = (attempt, baseDelayMs, maxDelayMs, random = Math.random) => {
+	const cap = Math.min(maxDelayMs, baseDelayMs * 2 ** Math.max(0, Math.floor(attempt)));
+	return Math.round(random() * cap);
 };
-const retryWithBackoff = async (fn, opts) => {
-  const {
-    maxAttempts,
-    baseDelayMs,
-    maxDelayMs,
-    random = Math.random,
-    sleep = defaultSleep
-  } = opts;
-  let lastErr;
-  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));
-};
-export {
-  getBackoffDelayMs,
-  retryWithBackoff
+/**
+* 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).
+*/
+var retryWithBackoff = async (fn, opts) => {
+	const { maxAttempts, baseDelayMs, maxDelayMs, random = Math.random, sleep = defaultSleep } = opts;
+	let lastErr;
+	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));
 };
+//#endregion
+export { getBackoffDelayMs, retryWithBackoff };

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@prosopo/load-balancer",
-	"version": "2.10.15",
+	"version": "2.10.17",
 	"description": "Provider load balancer",
 	"main": "dist/index.js",
 	"types": "dist/index.d.ts",
@@ -37,14 +37,14 @@
 	},
 	"homepage": "https://github.com/prosopo/captcha#readme",
 	"dependencies": {
-		"@prosopo/common": "3.1.47",
-		"@prosopo/types": "4.9.12",
+		"@prosopo/common": "3.1.48",
+		"@prosopo/types": "5.0.0",
 		"zod": "3.23.8"
 	},
 	"devDependencies": {
-		"@prosopo/config": "3.3.4",
+		"@prosopo/config": "3.3.6",
 		"@types/node": "22.10.2",
-		"@vitest/coverage-v8": "3.2.4",
+		"@vitest/coverage-v8": "4.1.10",
 		"concurrently": "9.0.1",
 		"del-cli": "6.0.0",
 		"dotenv": "17.2.1",
@@ -52,8 +52,8 @@
 		"tslib": "2.7.0",
 		"tsx": "4.20.3",
 		"typescript": "5.6.2",
-		"vite": "6.4.1",
-		"vitest": "3.2.4"
+		"vite": "8.1.5",
+		"vitest": "4.1.10"
 	},
 	"sideEffects": false
 }