@prosopo/provider 4.15.17 → 5.0.1

package/dist/cjs/api/startProviderApi.cjs

@@ -1,6 +1,7 @@
 const require_runtime = require("../_virtual/_rolldown/runtime.cjs");
 const require_metrics = require("./metrics.cjs");
 const require_blacklistRequestInspector = require("./blacklistRequestInspector.cjs");
+const require_bundlePool = require("../tasks/detection/bundlePool.cjs");
 const require_block = require("./block.cjs");
 const require_captcha = require("./captcha.cjs");
 const require_verify = require("./verify.cjs");
@@ -15,15 +16,15 @@ const require_ipInfoMiddleware = require("./ipInfoMiddleware.cjs");
 const require_robotsMiddleware = require("./robotsMiddleware.cjs");
 let _prosopo_logger = require("@prosopo/logger");
 let _prosopo_types = require("@prosopo/types");
-let node_https = require("node:https");
-node_https = require_runtime.__toESM(node_https, 1);
 let node_fs = require("node:fs");
 node_fs = require_runtime.__toESM(node_fs, 1);
+let node_path = require("node:path");
+node_path = require_runtime.__toESM(node_path, 1);
+let node_https = require("node:https");
+node_https = require_runtime.__toESM(node_https, 1);
 let _prosopo_api_express_router = require("@prosopo/api-express-router");
 let express = require("express");
 express = require_runtime.__toESM(express, 1);
-let node_path = require("node:path");
-node_path = require_runtime.__toESM(node_path, 1);
 let node_url = require("node:url");
 let _prosopo_locale = require("@prosopo/locale");
 let _prosopo_user_access_policy_api = require("@prosopo/user-access-policy/api");
@@ -32,6 +33,12 @@ cors = require_runtime.__toESM(cors, 1);
 let express_rate_limit = require("express-rate-limit");
 express_rate_limit = require_runtime.__toESM(express_rate_limit, 1);
 //#region src/api/startProviderApi.ts
+/**
+* Body-size ceiling for the detector-pool push. ~830 KB/bundle × 100 bundles
+* ≈ 86 MB encoded; 128 MB leaves headroom without approaching the 512 MiB V8
+* string limit that ultimately bounds a single-body push at ~620 bundles.
+*/
+var DETECTOR_POOL_BODY_LIMIT = "128mb";
 var __dirname$1 = node_path.default.dirname((0, node_url.fileURLToPath)(require("url").pathToFileURL(__filename).href));
 var certPath = node_path.default.resolve(__dirname$1, "../../../../certs");
 var keyPath = node_path.default.join(certPath, "server.key");
@@ -48,7 +55,7 @@ var isTlsAvailable = () => {
 * @returns Array of ClientApiPaths excluding verify and spam routes
 */
 var getClientApiPathsExpectingProsopoHeaders = () => {
-	return Object.values(_prosopo_types.ClientApiPaths).filter((path) => path.indexOf("verify") === -1 && path.indexOf("spam") === -1);
+	return Object.values(_prosopo_types.ClientApiPaths).filter((path) => path.indexOf("verify") === -1 && path.indexOf("spam") === -1 && path.indexOf("detector/assign") === -1);
 };
 /**
 * Extract authenticated user address from JWT for rate limiting
@@ -69,6 +76,19 @@ var getUserFromJWT = (req) => {
 	}
 };
 /**
+* `.listen()` returns before the socket is bound, so a bind failure such as
+* EADDRINUSE arrives later as an 'error' event — an uncaught exception unless
+* something is waiting on it. Settle on whichever event comes first so the
+* caller gets a rejection it can handle.
+*/
+var awaitListening = (server) => new Promise((resolve, reject) => {
+	server.once("error", reject);
+	server.once("listening", () => {
+		server.removeListener("error", reject);
+		resolve();
+	});
+});
+/**
 * Start the Prosopo Provider API server
 *
 * This function creates and configures an Express server with all necessary middleware
@@ -95,6 +115,17 @@ var getUserFromJWT = (req) => {
 */
 async function startProviderApi(env, admin = false, port) {
 	env.logger.info(() => ({ msg: "Starting Prosopo API" }));
+	const detectorPoolDir = process.env.PROSOPO_DETECTOR_POOL_DIR ?? "/app/data/detector-pool";
+	require_bundlePool.initDetectorBundlePool(detectorPoolDir, {
+		info: (msg, data) => env.logger.info(() => ({
+			msg,
+			data
+		})),
+		warn: (msg, data) => env.logger.warn(() => ({
+			msg,
+			data
+		}))
+	}, process.env.PROSOPO_DETECTOR_POOL_RELEASE);
 	const apiApp = (0, express.default)();
 	const apiPort = port || env.config.server?.port;
 	const apiEndpointAdapter = (0, _prosopo_api_express_router.createApiExpressDefaultEndpointAdapter)((0, _prosopo_logger.parseLogLevel)(env.config.logLevel));
@@ -129,6 +160,7 @@ async function startProviderApi(env, admin = false, port) {
 		],
 		maxAge: 86400
 	}));
+	apiApp.use(_prosopo_types.AdminApiPaths.ReplaceDetectorPool, express.default.json({ limit: DETECTOR_POOL_BODY_LIMIT }));
 	apiApp.use(express.default.json({ limit: "1mb" }));
 	apiApp.use(require_public.publicRouter(env));
 	apiApp.use(require_metrics.metricsMiddleware());
@@ -204,22 +236,24 @@ async function startProviderApi(env, admin = false, port) {
 			key: node_fs.default.readFileSync(keyPath),
 			cert: node_fs.default.readFileSync(crtPath)
 		};
-		return node_https.default.createServer(httpsOptions, apiApp).listen(apiPort, () => {
-			env.logger.info(() => ({
-				data: {
-					apiPort,
-					protocol: "https"
-				},
-				msg: "Prosopo app listening with HTTPS"
-			}));
-		});
-	}
-	return apiApp.listen(apiPort, () => {
+		const httpsServer = node_https.default.createServer(httpsOptions, apiApp).listen(apiPort);
+		await awaitListening(httpsServer);
 		env.logger.info(() => ({
-			data: { apiPort },
-			msg: "Prosopo app listening"
+			data: {
+				apiPort,
+				protocol: "https"
+			},
+			msg: "Prosopo app listening with HTTPS"
 		}));
-	});
+		return httpsServer;
+	}
+	const server = apiApp.listen(apiPort);
+	await awaitListening(server);
+	env.logger.info(() => ({
+		data: { apiPort },
+		msg: "Prosopo app listening"
+	}));
+	return server;
 }
 //#endregion
 exports.getClientApiPathsExpectingProsopoHeaders = getClientApiPathsExpectingProsopoHeaders;

package/dist/cjs/api/verify.cjs

@@ -317,7 +317,7 @@ function prosopoVerifyRouter(env) {
 			}
 			const dappPair = env.keyring.addFromAddress(dapp);
 			(0, _prosopo_api_express_router.verifySignature)(dappSignature, timestamp.toString(), dappPair);
-			const { verified, score } = await tasks.puzzleCaptchaManager.serverVerifyPuzzleCaptchaSolution(dapp, challenge, clientRecord.settings.verifiedTimeout, env, ip, userAccessRulesStorage, email, clientRecord.settings.spamEmailDomainCheckEnabled, clientRecord.settings.trafficFilter, clientRecord.settings.storeMetadata);
+			const { verified, score } = await tasks.puzzleCaptchaManager.serverVerifyPuzzleCaptchaSolution(dapp, challenge, clientRecord.settings.verifiedTimeout, env, ip, userAccessRulesStorage, email, clientRecord.settings.spamEmailDomainCheckEnabled, clientRecord.settings.spamFilter, clientRecord.settings.trafficFilter, clientRecord.settings.storeMetadata);
 			const verificationResponse = tasks.puzzleCaptchaManager.getVerificationResponse(verified, clientRecord, req.i18n.t, score);
 			return res.json(verificationResponse);
 		} catch (err) {

package/dist/cjs/tasks/captchaManager.cjs

@@ -1,5 +1,6 @@
 const require_compositeIpAddress = require("../compositeIpAddress.cjs");
 const require_blacklistRequestInspector = require("../api/blacklistRequestInspector.cjs");
+const require_bundlePool = require("./detection/bundlePool.cjs");
 const require_checkTrafficFilter = require("./spam/checkTrafficFilter.cjs");
 const require_enrichDnsEvent = require("./dnsEvent/enrichDnsEvent.cjs");
 const require_checkSpamEmail = require("./spam/checkSpamEmail.cjs");
@@ -59,19 +60,24 @@ var CaptchaManager = class CaptchaManager {
 		this.scheduleMongoSessionUpdate(sessionId, updates, streamToCentral);
 	}
 	/**
-	* Decrypt with the active detector keys and strip the throwaway
-	* `timestamp` field. Returns `undefined` when no key decrypts.
+	* Decrypt with the session's detector pool bundle and strip the throwaway
+	* `timestamp` field. Returns `undefined` when no bundle is resolved or
+	* decryption fails.
 	*/
-	async decryptSimdReadingsForAttach(simdReadingsCiphertext) {
-		const decryptKeys = [...await this.getDetectorKeys(), process.env.BOT_DECRYPTION_KEY];
-		const decrypted = await this.decryptSimdReadings(simdReadingsCiphertext, decryptKeys);
+	async decryptSimdReadingsForAttach(simdReadingsCiphertext, bundle) {
+		const decrypted = await this.decryptSimdReadings(simdReadingsCiphertext, bundle);
 		if (!decrypted) return void 0;
 		const { timestamp: _ignored, ...readings } = decrypted;
 		return readings;
 	}
-	/** Decrypt + first-hop-wins attach. No-op on decrypt failure. */
+	/**
+	* Decrypt + first-hop-wins attach. Resolves the session's detector pool
+	* bundle (promoted onto the session record at frictionless time) to decrypt.
+	* No-op on decrypt failure / no bundle.
+	*/
 	async decryptAndAttachSimdReadingsIfAbsent(sessionId, simdReadingsCiphertext, stage) {
-		const readings = await this.decryptSimdReadingsForAttach(simdReadingsCiphertext);
+		const bundle = await this.resolveBundleBySessionId(sessionId);
+		const readings = await this.decryptSimdReadingsForAttach(simdReadingsCiphertext, bundle);
 		if (!readings) return;
 		await this.recordSessionSimdReadingsIfAbsentWithCache(sessionId, readings, stage);
 	}
@@ -271,62 +277,81 @@ var CaptchaManager = class CaptchaManager {
 	async getPrioritisedAccessPolicies(userAccessRulesStorage, clientId, userScope, options) {
 		return require_blacklistRequestInspector.getPrioritisedAccessRule(userAccessRulesStorage, userScope, clientId, options);
 	}
-	async getDetectorKeys() {
-		return await this.db.getDetectorKeys();
+	/**
+	* Resolve a detector pool bundle's decryption material from a `bundleId`
+	* (in-memory pool lookup). Returns undefined when the id is absent or the
+	* bundle is no longer in the pool.
+	*/
+	resolveBundleById(bundleId) {
+		const bundle = bundleId ? require_bundlePool.getDetectorBundlePool()?.get(bundleId) : void 0;
+		return bundle ? {
+			key: bundle.privateKey,
+			innerConfig: bundle.innerConfig
+		} : void 0;
+	}
+	/**
+	* Resolve the detector pool bundle for a session via its short-lived
+	* `detectorSessionId → bundleId` Redis binding (used at the frictionless hop,
+	* before the binding is promoted onto the durable session record). Returns
+	* the bundleId too so the caller can promote it onto the session.
+	*/
+	async resolveBundleByDetectorSession(detectorSessionId) {
+		if (!detectorSessionId || !this.writeQueue) return void 0;
+		const bundleId = await this.writeQueue.getDetectorBundle(detectorSessionId);
+		const decrypt = this.resolveBundleById(bundleId);
+		return bundleId && decrypt ? {
+			...decrypt,
+			bundleId
+		} : void 0;
+	}
+	/**
+	* Resolve the detector pool bundle for a session via the `bundleId` promoted
+	* onto its durable session record (used at later hops — SIMD attach,
+	* PoW/puzzle/image solution submit — after the Redis binding has expired).
+	* Cache-first (Redis), Mongo fallback.
+	*/
+	async resolveBundleBySessionId(sessionId) {
+		if (!sessionId) return void 0;
+		const cached = this.writeQueue ? await this.writeQueue.getCachedSession(sessionId) : void 0;
+		const bundleId = (typeof cached?.bundleId === "string" ? cached.bundleId : void 0) ?? (await this.db.getSessionRecordBySessionId(sessionId))?.bundleId;
+		return this.resolveBundleById(bundleId);
 	}
 	/**
 	* Decrypt the catcher's WASM SIMD CPU fingerprint readings via the
 	* obfuscated `decodeSimd.js` bundle (source lives in the private
-	* @prosopo/catcher repo). Mirrors `decryptBehavioralData`: tries each
-	* detector key in turn (loaded by the caller, with the env-var key as
-	* fallback). Returns null when no key works so the caller can drop
-	* the field rather than fail the whole request.
+	* @prosopo/catcher repo). The detector lives only in provider-served pool
+	* bundles, so decryption uses that session's single bundle (RSA key + inner
+	* cipher) — there is no key pool. Returns null when no bundle is resolved or
+	* decryption fails, so the caller can drop the field rather than fail the
+	* whole request.
 	*/
-	async decryptSimdReadings(encryptedData, decryptKeys) {
-		const decryptSimdReadings = (await Promise.resolve().then(() => require("./detection/decodeSimd.cjs"))).default;
-		const validKeys = decryptKeys.filter((k) => k);
-		if (validKeys.length === 0) {
-			this.logger?.error(() => ({ msg: "No decryption keys provided for SIMD readings" }));
+	async decryptSimdReadings(encryptedData, bundle) {
+		if (!bundle) {
+			this.logger?.warn(() => ({ msg: "No detector bundle resolved for SIMD readings — dropping field" }));
 			return null;
 		}
-		for (const [keyIndex, key] of validKeys.entries()) try {
-			return await decryptSimdReadings(encryptedData, key);
+		const decryptSimdReadings = (await Promise.resolve().then(() => require("./detection/decodeSimd.cjs"))).default;
+		try {
+			return await decryptSimdReadings(encryptedData, bundle.key, bundle.innerConfig);
 		} catch (err) {
-			this.logger?.debug(() => ({
-				msg: "Failed to decrypt SIMD readings with key, trying next",
-				data: {
-					keyIndex: keyIndex + 1,
-					totalKeys: validKeys.length,
-					err
-				}
+			this.logger?.warn(() => ({
+				msg: "Failed to decrypt SIMD readings with the session's bundle",
+				data: { err }
 			}));
+			return null;
 		}
-		this.logger?.warn(() => ({
-			msg: "Failed to decrypt SIMD readings with all available keys",
-			data: { totalKeysAttempted: validKeys.length }
-		}));
-		return null;
 	}
-	async decryptBehavioralData(encryptedData, decryptKeys) {
-		const decryptBehavioralData = (await Promise.resolve().then(() => require("./detection/decodeBehavior.cjs"))).default;
-		const validKeys = decryptKeys.filter((k) => k);
-		if (validKeys.length === 0) {
-			this.logger?.error(() => ({ msg: "No decryption keys provided for behavioral data" }));
+	async decryptBehavioralData(encryptedData, bundle) {
+		if (!bundle) {
+			this.logger?.warn(() => ({ msg: "No detector bundle resolved for behavioral data — dropping field" }));
 			return null;
 		}
-		for (const [keyIndex, key] of validKeys.entries()) try {
-			this.logger?.debug(() => ({
-				msg: "Attempting to decrypt behavioral data",
-				data: {
-					keyIndex: keyIndex + 1,
-					totalKeys: validKeys.length
-				}
-			}));
-			const result = await decryptBehavioralData(encryptedData, key);
+		const decryptBehavioralData = (await Promise.resolve().then(() => require("./detection/decodeBehavior.cjs"))).default;
+		try {
+			const result = await decryptBehavioralData(encryptedData, bundle.key, bundle.innerConfig);
 			this.logger?.info(() => ({
 				msg: "Behavioral data decrypted successfully",
 				data: {
-					keyIndex: keyIndex + 1,
 					c1Length: result.collector1?.length || 0,
 					c2Length: result.collector2?.length || 0,
 					c3Length: result.collector3?.length || 0,
@@ -335,20 +360,12 @@ var CaptchaManager = class CaptchaManager {
 			}));
 			return result;
 		} catch (error) {
-			this.logger?.debug(() => ({
-				msg: "Failed to decrypt with key, trying next",
-				data: {
-					keyIndex: keyIndex + 1,
-					totalKeys: validKeys.length,
-					err: error
-				}
+			this.logger?.warn(() => ({
+				msg: "Failed to decrypt behavioral data with the session's bundle",
+				data: { err: error }
 			}));
+			return null;
 		}
-		this.logger?.error(() => ({
-			msg: "Failed to decrypt behavioral data with all available keys",
-			data: { totalKeysAttempted: validKeys.length }
-		}));
-		return null;
 	}
 	/**
 	* Checks if a user should be hard blocked based on access policies

package/dist/cjs/tasks/client/clientTasks.cjs

@@ -2,23 +2,10 @@ const require_validateAddress = require("../../api/validateAddress.cjs");
 let _prosopo_common = require("@prosopo/common");
 let _prosopo_database = require("@prosopo/database");
 let _prosopo_types = require("@prosopo/types");
-let node_crypto = require("node:crypto");
+require("node:crypto");
 let _prosopo_util = require("@prosopo/util");
 //#region src/tasks/client/clientTasks.ts
 var SAMPLE_SIZE = 75;
-var isValidPrivateKey = (privateKeyString) => {
-	const privateKey = Buffer.from(privateKeyString, "base64").toString("ascii");
-	try {
-		(0, node_crypto.createPrivateKey)({
-			key: privateKey,
-			format: "pem",
-			type: "pkcs8"
-		});
-		return true;
-	} catch (error) {
-		return false;
-	}
-};
 var ClientTaskManager = class {
 	constructor(config, logger, db) {
 		this.config = config;
@@ -196,21 +183,6 @@ var ClientTaskManager = class {
 		}
 		await this.providerDB.removeClientRecords(accounts);
 	}
-	async updateDetectorKey(detectorKey) {
-		if (!isValidPrivateKey(detectorKey)) throw new _prosopo_common.ProsopoApiError("INVALID_DETECTOR_KEY", {
-			context: { detectorKey },
-			logger: this.logger
-		});
-		await this.providerDB.storeDetectorKey(detectorKey);
-		return await this.providerDB.getDetectorKeys();
-	}
-	async removeDetectorKey(detectorKey, expirationInSeconds) {
-		if (!isValidPrivateKey(detectorKey)) throw new _prosopo_common.ProsopoApiError("INVALID_DETECTOR_KEY", {
-			context: { detectorKey },
-			logger: this.logger
-		});
-		await this.providerDB.removeDetectorKey(detectorKey, expirationInSeconds);
-	}
 	async updateDecisionMachine(scope, runtime, source, dappAccount, language, name, version, captchaType, kind) {
 		if (scope === _prosopo_types.DecisionMachineScope.Dapp && !dappAccount) throw new _prosopo_common.ProsopoApiError("API.BAD_REQUEST", {
 			context: {

package/dist/cjs/tasks/detection/bundlePool.cjs

@@ -0,0 +1,220 @@
+let node_crypto = require("node:crypto");
+let node_fs = require("node:fs");
+let node_path = require("node:path");
+//#region src/tasks/detection/bundlePool.ts
+/**
+* Detector bundle pool (provider side).
+*
+* Loads a pool of precomputed, obfuscated detector bundles from disk and caches
+* them in memory — the Node analogue of the Rust "bumblebee" `bundle_manager`.
+* Each bundle is a `{id}.js` (served to the browser) paired with a `{id}.json`
+* (`{ privateKey, innerConfig }`, kept server-side) produced by the catcher
+* `bundle:pool` build script.
+*
+* A bundle is assigned per detector session by {@link DetectorBundlePool.pickRandom},
+* served by id, and resolved again at decryption time so the provider uses the
+* single correct keypair + inner config rather than brute-forcing a key pool.
+* The session→bundle binding lives in Redis (short TTL); this module only holds
+* the immutable pool.
+*/
+/**
+* Default on-disk location of the pool inside the provider container. Backed by
+* a host volume (see docker-compose.provider.yml) so a pushed pool survives
+* container restarts — nothing is baked into the image, which matters because
+* `prosopo/provider` is a public Docker Hub image and each bundle ships with its
+* own RSA private key.
+*/
+var DEFAULT_DETECTOR_POOL_DIR = "/app/data/detector-pool";
+/**
+* In-memory pool of detector bundles. Immutable after {@link loadFromDir} except
+* via {@link replace} (used by the admin "emergency push" endpoint to hot-swap
+* the pool without a redeploy).
+*/
+var DetectorBundlePool = class {
+	constructor() {
+		this.bundles = /* @__PURE__ */ new Map();
+		this.ids = [];
+	}
+	/**
+	* Load every `{id}.js`/`{id}.json` pair from `dir` into memory. A `.js`
+	* without a readable, well-formed `.json` sibling is skipped (logged). Safe
+	* to call on a missing directory (yields an empty pool).
+	*/
+	loadFromDir(dir, logger = {}, expectedRelease) {
+		const next = /* @__PURE__ */ new Map();
+		if (!(0, node_fs.existsSync)(dir)) {
+			logger.warn?.("bundle pool directory does not exist", { dir });
+			this.bundles = next;
+			this.ids = [];
+			return;
+		}
+		let mismatched = 0;
+		let unstamped = 0;
+		for (const entry of (0, node_fs.readdirSync)(dir)) {
+			if ((0, node_path.extname)(entry) !== ".js") continue;
+			const bundleId = entry.slice(0, -3);
+			const jsPath = (0, node_path.join)(dir, entry);
+			const jsonPath = (0, node_path.join)(dir, `${bundleId}.json`);
+			try {
+				const js = (0, node_fs.readFileSync)(jsPath, "utf8");
+				const secrets = JSON.parse((0, node_fs.readFileSync)(jsonPath, "utf8"));
+				if (typeof secrets.privateKey !== "string" || typeof secrets.innerConfig !== "string") {
+					logger.warn?.("bundle pool entry has malformed secrets", { bundleId });
+					continue;
+				}
+				const release = typeof secrets.release === "string" ? secrets.release : void 0;
+				if (expectedRelease && release && release !== expectedRelease) {
+					mismatched++;
+					continue;
+				}
+				if (expectedRelease && !release) unstamped++;
+				next.set(bundleId, {
+					js,
+					privateKey: secrets.privateKey,
+					innerConfig: secrets.innerConfig,
+					...release && { release }
+				});
+			} catch (error) {
+				logger.warn?.("failed to load bundle pool entry", {
+					bundleId,
+					error: error instanceof Error ? error.message : String(error)
+				});
+			}
+		}
+		if (mismatched > 0) logger.warn?.("skipped bundle pool entries built for another release", {
+			skipped: mismatched,
+			expectedRelease
+		});
+		if (unstamped > 0) logger.warn?.("bundle pool entries have no release stamp", {
+			count: unstamped,
+			expectedRelease
+		});
+		this.replace(next);
+		logger.info?.("bundle pool loaded", {
+			count: this.ids.length,
+			dir
+		});
+	}
+	/** Hot-swap the entire pool (used by the admin replace-pool endpoint). */
+	replace(bundles) {
+		this.bundles = bundles;
+		this.ids = [...bundles.keys()].sort();
+	}
+	/** Number of loaded bundles. */
+	size() {
+		return this.ids.length;
+	}
+	/**
+	* Pick a uniformly-random bundle. Throws if the pool is empty — the caller
+	* must surface this as a hard failure (no bundle ⇒ no valid payload can be
+	* produced).
+	*/
+	pickRandom() {
+		if (this.ids.length === 0) throw new Error("detector bundle pool is empty");
+		const bundleId = this.ids[(0, node_crypto.randomInt)(this.ids.length)];
+		const bundle = bundleId !== void 0 ? this.bundles.get(bundleId) : void 0;
+		if (bundleId === void 0 || !bundle) throw new Error("detector bundle pool selection failed");
+		return {
+			bundleId,
+			bundle
+		};
+	}
+	/** Resolve a bundle by id, or `undefined` if it is not (or no longer) in the pool. */
+	get(bundleId) {
+		return this.bundles.get(bundleId);
+	}
+};
+/** Process-global pool singleton (mirrors bumblebee's OnceCell). */
+var globalPool = null;
+/** Where {@link initDetectorBundlePool} last loaded from — the persist target. */
+var globalPoolDir = DEFAULT_DETECTOR_POOL_DIR;
+/** Initialise the global pool from `dir`. Idempotent (reloads on each call). */
+function initDetectorBundlePool(dir, logger = {}, expectedRelease) {
+	const pool = new DetectorBundlePool();
+	pool.loadFromDir(dir, logger, expectedRelease);
+	globalPool = pool;
+	globalPoolDir = dir;
+	return pool;
+}
+/**
+* Write a pool to `dir` in the same `{id}.js` / `{id}.json` layout
+* {@link DetectorBundlePool.loadFromDir} reads, so a pushed pool is picked up
+* again on the next boot instead of vanishing with the process.
+*
+* Writes *into* `dir` and never replaces the directory itself. In the provider
+* container `dir` is a bind-mount point, and removing or renaming over a mount
+* point from inside the container fails with EBUSY ("Device or resource busy")
+* — which is exactly what an earlier stage-into-a-sibling-and-rename version of
+* this function did on every push.
+*
+* Each file is still written to a temp name and renamed into place, so a reader
+* never observes a partially-written bundle; renames within one directory are
+* atomic and don't touch the mount. Bundles no longer in the pool are then
+* pruned, giving replace semantics rather than an ever-growing merge.
+*
+* Throws on failure — the caller decides whether an unpersisted push is
+* acceptable.
+*/
+function persistDetectorBundlePool(bundles, dir = globalPoolDir) {
+	(0, node_fs.mkdirSync)(dir, { recursive: true });
+	const written = /* @__PURE__ */ new Set();
+	for (const [bundleId, bundle] of bundles) {
+		const jsName = `${bundleId}.js`;
+		const jsonName = `${bundleId}.json`;
+		const jsTmp = (0, node_path.join)(dir, `.${jsName}.tmp`);
+		(0, node_fs.writeFileSync)(jsTmp, bundle.js, "utf8");
+		(0, node_fs.renameSync)(jsTmp, (0, node_path.join)(dir, jsName));
+		const jsonTmp = (0, node_path.join)(dir, `.${jsonName}.tmp`);
+		(0, node_fs.writeFileSync)(jsonTmp, JSON.stringify({
+			privateKey: bundle.privateKey,
+			innerConfig: bundle.innerConfig,
+			...bundle.release && { release: bundle.release }
+		}), {
+			encoding: "utf8",
+			mode: 384
+		});
+		(0, node_fs.renameSync)(jsonTmp, (0, node_path.join)(dir, jsonName));
+		written.add(jsName);
+		written.add(jsonName);
+	}
+	for (const entry of (0, node_fs.readdirSync)(dir)) if (((0, node_path.extname)(entry) === ".js" || (0, node_path.extname)(entry) === ".json") && !written.has(entry)) (0, node_fs.rmSync)((0, node_path.join)(dir, entry), { force: true });
+}
+/** Get the global pool, or `null` if {@link initDetectorBundlePool} was never called. */
+function getDetectorBundlePool() {
+	return globalPool;
+}
+/**
+* Hot-swap the global pool's contents (admin "emergency push" channel) and
+* write it to the pool directory so it survives a restart. Creates the global
+* pool if it does not exist yet.
+*
+* The in-memory swap happens first and is never rolled back: a running provider
+* serving the new pool is the point of the push, and it is strictly better than
+* a provider serving the old one. A failed persist is reported so the caller can
+* warn — the pool is live but will be lost on the next restart.
+*/
+function replaceDetectorBundlePool(bundles, logger = {}) {
+	if (!globalPool) globalPool = new DetectorBundlePool();
+	globalPool.replace(bundles);
+	let persisted = false;
+	try {
+		persistDetectorBundlePool(bundles);
+		persisted = true;
+	} catch (error) {
+		logger.warn?.("failed to persist detector bundle pool to disk", {
+			dir: globalPoolDir,
+			error: error instanceof Error ? error.message : String(error)
+		});
+	}
+	return {
+		count: globalPool.size(),
+		persisted
+	};
+}
+//#endregion
+exports.DEFAULT_DETECTOR_POOL_DIR = DEFAULT_DETECTOR_POOL_DIR;
+exports.DetectorBundlePool = DetectorBundlePool;
+exports.getDetectorBundlePool = getDetectorBundlePool;
+exports.initDetectorBundlePool = initDetectorBundlePool;
+exports.persistDetectorBundlePool = persistDetectorBundlePool;
+exports.replaceDetectorBundlePool = replaceDetectorBundlePool;