@qntx/nostr 0.6.0 → 0.8.0

package/dist/pool-As20OGxB.mjs

@@ -1,2166 +0,0 @@
-import { g as NostrError, h as MessageError, l as normalizeURL, v as WasmVerifyPoisonedError } from "./util-LfQirgDk.mjs";
-import { n as verifyEvent } from "./verifier-t5WoWbtY.mjs";
-import { n as canonicalizeFilters, r as filterFingerprint, t as canonicalizeFilter } from "./filter-BQl3GlHt.mjs";
-import { n as createSubscriptionId, r as encodeClientMessage, s as parseRelayMessage, t as assertSubscriptionId } from "./message-DcY6Fi9o.mjs";
-import { t as NoSignerError } from "./error-B__OMBRY.mjs";
-import { t as invokeSafely } from "./report-CHld4uWj.mjs";
-import { isAuthRequired, makeAuthEvent } from "./nips/nip42.mjs";
-import { n as raceSignal, r as throwIfAborted, t as abortReason } from "./abort-Ba8tDrOI.mjs";
-import { Nip77Error, runNegSession } from "./nips/nip77.mjs";
-//#region src/relay/error.ts
-/** Base class for relay errors; carries the relay URL when known. */
-var RelayError = class extends NostrError {
-	name = "RelayError";
-	url;
-	constructor(message, url, options) {
-		super(url !== void 0 && url !== "" ? `${message} (${url})` : message, options);
-		this.url = url;
-	}
-};
-/** A relay connection attempt or socket failed. */
-var RelayConnectionError = class extends RelayError {
-	name = "RelayConnectionError";
-};
-/** A relay answered an EVENT with `ok: false`. */
-var RelayPublishError = class extends RelayError {
-	name = "RelayPublishError";
-};
-/** A subscription was closed by the relay (`CLOSED`) or the socket dropped. */
-var RelayClosedError = class extends RelayError {
-	name = "RelayClosedError";
-};
-/** A relay operation exceeded its deadline. */
-var RelayTimeoutError = class extends RelayError {
-	name = "RelayTimeoutError";
-};
-/**
-* A relay was suspended for delivering more events that fail id/signature verification than its
-* {@link PoolOptions.invalidEventPolicy} allows. Carries `until`, the epoch-ms time when the relay
-* may connect again.
-*/
-var RelaySuspendedError = class extends RelayError {
-	name = "RelaySuspendedError";
-	/** Epoch milliseconds when the suspension lifts. */
-	until;
-	constructor(url, until) {
-		super("relay suspended for delivering invalid events", url);
-		this.until = until;
-	}
-};
-//#endregion
-//#region src/relay/websocket.ts
-let impl;
-try {
-	if (globalThis.WebSocket !== void 0) impl = globalThis.WebSocket;
-} catch {}
-/** Inject a WebSocket implementation (required on Node unless undici/global is present). */
-function useWebSocketImplementation(websocketImplementation) {
-	impl = websocketImplementation;
-}
-function getWebSocketImplementation() {
-	if (!impl) throw new RelayConnectionError("No WebSocket implementation available; call useWebSocketImplementation() or run in a browser");
-	return impl;
-}
-//#endregion
-//#region src/relay/url.ts
-/**
-* True for `ws:` / `http:` URLs that are not `.onion`. Local-network `ws://` is still insecure;
-* allow those via a trusted set.
-*/
-function isInsecureRelayUrl(url) {
-	try {
-		const parsed = new URL(url);
-		if (parsed.hostname.endsWith(".onion")) return false;
-		return parsed.protocol === "ws:" || parsed.protocol === "http:";
-	} catch {
-		return false;
-	}
-}
-//#endregion
-//#region src/relay/neg-session.ts
-function createNegSession() {
-	return {
-		queue: [],
-		waiter: void 0,
-		error: void 0
-	};
-}
-function pushNegMsg(session, hex) {
-	if (session.waiter) {
-		const { waiter } = session;
-		session.waiter = void 0;
-		waiter.resolve(hex);
-	} else session.queue.push(hex);
-}
-function failNegSession(session, err) {
-	session.error = err;
-	if (session.waiter) {
-		const { waiter } = session;
-		session.waiter = void 0;
-		waiter.reject(err);
-	}
-}
-function failNegErr(session, reason) {
-	failNegSession(session, new Nip77Error(reason));
-}
-/** Wire queue/timeout/abort around `runNegSession`. Not a second session class. */
-async function runWiredNegSession(opts) {
-	const { session, storage, filter, id, timeoutMs, signal, send, url } = opts;
-	const deadline = Date.now() + timeoutMs;
-	const timedOut = () => new RelayTimeoutError("negentropy timed out", url);
-	const remainingMs = () => deadline - Date.now();
-	const next = async () => {
-		if (session.error !== void 0) throw session.error;
-		if (remainingMs() <= 0) throw timedOut();
-		const queued = session.queue.shift();
-		if (queued !== void 0) return queued;
-		return new Promise((resolve, reject) => {
-			const timer = setTimeout(() => {
-				session.waiter = void 0;
-				reject(timedOut());
-			}, remainingMs());
-			const fail = (err) => {
-				clearTimeout(timer);
-				session.waiter = void 0;
-				reject(err);
-			};
-			const onAbort = () => {
-				if (signal) fail(abortReason(signal));
-			};
-			session.waiter = {
-				resolve: (hex) => {
-					clearTimeout(timer);
-					signal?.removeEventListener("abort", onAbort);
-					resolve(hex);
-				},
-				reject: (err) => fail(err)
-			};
-			signal?.addEventListener("abort", onAbort, { once: true });
-		});
-	};
-	return runNegSession({
-		storage,
-		openingSend: (hex) => {
-			send([
-				"NEG-OPEN",
-				id,
-				filter,
-				hex
-			]);
-		},
-		msgSend: (hex) => {
-			send([
-				"NEG-MSG",
-				id,
-				hex
-			]);
-		},
-		next
-	});
-}
-const PING_DUMMY_FILTER = {
-	ids: ["a".repeat(64)],
-	limit: 0
-};
-/** Browser WebSocket and `ws` both use 1 for OPEN. */
-const WS_OPEN = 1;
-/** Node `ws` delivers `pong` on the EventEmitter, not via addEventListener. */
-function canNativePing(ws) {
-	return typeof ws.ping === "function" && (typeof ws.once === "function" || typeof ws.on === "function");
-}
-/** REQ-dummy or native ping/pong keepalive. Does not import class Relay. */
-var PingLoop = class {
-	#opts;
-	#timer;
-	#waiters = /* @__PURE__ */ new Map();
-	#gen = 0;
-	#nativePing;
-	constructor(opts) {
-		this.#opts = opts;
-	}
-	start() {
-		this.stop();
-		this.#timer = setInterval(() => {
-			this.#pingpong();
-		}, this.#opts.pingIntervalMs);
-	}
-	stop() {
-		if (this.#timer !== void 0) {
-			clearInterval(this.#timer);
-			this.#timer = void 0;
-		}
-		this.#abortCurrentPing();
-	}
-	hasWaiter(id) {
-		return this.#waiters.has(id);
-	}
-	finishDummyPing(id) {
-		const waiter = this.#waiters.get(id);
-		if (!waiter) return false;
-		this.#waiters.delete(id);
-		waiter.resolve(true);
-		try {
-			this.#opts.send(["CLOSE", id]);
-		} catch {}
-		return true;
-	}
-	#abortCurrentPing() {
-		this.#gen += 1;
-		const native = this.#nativePing;
-		this.#nativePing = void 0;
-		native?.abort();
-		for (const waiter of this.#waiters.values()) waiter.resolve(false);
-		this.#waiters.clear();
-	}
-	async #pingpong() {
-		const ws = this.#opts.getWs();
-		if (!ws || ws.readyState !== WS_OPEN) return;
-		if (this.#nativePing !== void 0 || this.#waiters.size > 0) return;
-		const gen = this.#gen;
-		const ping = canNativePing(ws) ? this.#waitForNativePing(ws) : this.#waitForDummyPing();
-		const ok = await new Promise((resolve) => {
-			let settled = false;
-			const done = (alive) => {
-				if (settled) return;
-				settled = true;
-				clearTimeout(timer);
-				resolve(alive);
-			};
-			const timer = setTimeout(() => {
-				if (this.#nativePing !== void 0 || this.#waiters.size > 0) done(false);
-			}, this.#opts.pingTimeoutMs);
-			(async () => {
-				done(await ping);
-			})();
-		});
-		if (gen !== this.#gen) return;
-		if (!ok) {
-			this.#abortCurrentPing();
-			this.#opts.closeWs();
-		}
-	}
-	async #waitForNativePing(ws) {
-		return new Promise((resolve) => {
-			let settled = false;
-			const finish = (alive) => {
-				if (settled) return;
-				settled = true;
-				this.#nativePing = void 0;
-				ws.off?.("pong", onPong);
-				resolve(alive);
-			};
-			const onPong = () => finish(true);
-			this.#nativePing = { abort: () => finish(false) };
-			if (typeof ws.on === "function" && typeof ws.off === "function") ws.on("pong", onPong);
-			else if (typeof ws.once === "function") ws.once("pong", onPong);
-			else ws.on?.("pong", onPong);
-			try {
-				if (typeof ws.ping === "function") ws.ping();
-				else finish(false);
-			} catch {
-				finish(false);
-			}
-		});
-	}
-	async #waitForDummyPing() {
-		return new Promise((resolve) => {
-			const id = this.#opts.nextSubId("__ping__");
-			this.#waiters.set(id, { resolve });
-			try {
-				this.#opts.send([
-					"REQ",
-					id,
-					PING_DUMMY_FILTER
-				]);
-			} catch {
-				this.#waiters.delete(id);
-				resolve(false);
-			}
-		});
-	}
-};
-//#endregion
-//#region src/relay/subscription.ts
-var Subscription = class {
-	id;
-	filters;
-	handlers;
-	closeOnEose;
-	eosed = false;
-	closed = false;
-	/** True after one CLOSED `auth-required:` retry. */
-	authRetried = false;
-	/** Inclusive NIP-01 `since` watermark from verified EVENTs. */
-	lastCreatedAt;
-	/** Event ids at `lastCreatedAt` (same-second reconnect dedup). Not all seen ids. */
-	idsAtWatermark = /* @__PURE__ */ new Set();
-	#sendClose;
-	#abort;
-	constructor(filters, opts, sendClose) {
-		this.#sendClose = sendClose;
-		this.id = createSubscriptionId(opts.id);
-		this.filters = filters;
-		this.closeOnEose = opts.closeOnEose === true;
-		this.handlers = {
-			onevent: opts.onevent,
-			oneose: opts.oneose,
-			onclose: opts.onclose,
-			alreadyHaveEvent: opts.alreadyHaveEvent,
-			receivedEvent: opts.receivedEvent
-		};
-		if (opts.signal) {
-			if (opts.signal.aborted) this.close("aborted");
-			else {
-				const onAbort = () => this.close("aborted");
-				opts.signal.addEventListener("abort", onAbort, { once: true });
-				this.#abort = () => opts.signal?.removeEventListener("abort", onAbort);
-			}
-		}
-	}
-	close(reason = "closed by client") {
-		if (this.closed) return;
-		this.closed = true;
-		this.#abort?.();
-		this.#sendClose(this.id);
-		invokeSafely(() => this.handlers.onclose?.(reason));
-	}
-	/** Advance the reconnect watermark after a verified EVENT. */
-	noteVerified(event) {
-		if (this.lastCreatedAt === void 0 || event.created_at > this.lastCreatedAt) {
-			this.lastCreatedAt = event.created_at;
-			this.idsAtWatermark.clear();
-			this.idsAtWatermark.add(event.id);
-			return;
-		}
-		if (event.created_at === this.lastCreatedAt) this.idsAtWatermark.add(event.id);
-	}
-	/**
-	* Filters for re-REQ. Original `filters` stay unchanged. NIP-01 `since` is inclusive — never
-	* `lastCreatedAt + 1`.
-	*/
-	replayFilters() {
-		const since = this.lastCreatedAt;
-		if (since === void 0) return this.filters;
-		return this.filters.map((f) => ({
-			...f,
-			since: f.since === void 0 ? since : Math.max(f.since, since)
-		}));
-	}
-};
-/** AsyncIterable wrapper over a subscription's events until EOSE or close. */
-function subscriptionToAsyncIterable(start, opts) {
-	const queue = [];
-	let done = false;
-	let error;
-	let wake;
-	let closer;
-	let localClose = false;
-	const notify = () => {
-		wake?.();
-		wake = void 0;
-	};
-	const waitForWake = async () => new Promise((resolve) => {
-		wake = resolve;
-	});
-	const closeLocal = (reason) => {
-		localClose = true;
-		closer?.close(reason);
-		done = true;
-		notify();
-	};
-	closer = start({
-		onevent(event) {
-			queue.push(event);
-			notify();
-		},
-		oneose() {
-			if (opts?.includeEose === false) closeLocal("eose");
-		},
-		onclose(reason) {
-			if (opts?.signal?.aborted === true) localClose = true;
-			if (!localClose && reason) error = new RelayClosedError(reason);
-			done = true;
-			notify();
-		}
-	});
-	if (opts?.signal) {
-		if (opts.signal.aborted) closeLocal("aborted");
-		else opts.signal.addEventListener("abort", () => closeLocal("aborted"), { once: true });
-	}
-	return {
-		close(reason) {
-			closeLocal(reason ?? "closed by client");
-		},
-		[Symbol.asyncIterator]() {
-			return {
-				async next() {
-					while (true) {
-						const value = queue.shift();
-						if (value !== void 0) return {
-							value,
-							done: false
-						};
-						if (error !== void 0) throw error;
-						if (done) return {
-							value: void 0,
-							done: true
-						};
-						await waitForWake();
-					}
-				},
-				async return() {
-					closeLocal("iterator returned");
-					return {
-						value: void 0,
-						done: true
-					};
-				}
-			};
-		}
-	};
-}
-//#endregion
-//#region src/relay/subscribe.ts
-function openExclusive(ctx, filters, opts) {
-	const sub = new Subscription(filters, opts, (id) => {
-		ctx.subs.delete(id);
-		try {
-			if (ctx.connected()) ctx.send(["CLOSE", id]);
-		} catch {}
-	});
-	ctx.subs.set(sub.id, sub);
-	if (ctx.connected()) ctx.send([
-		"REQ",
-		sub.id,
-		...filters
-	]);
-	else if (ctx.enableReconnect()) ctx.scheduleReconnect();
-	if (opts.eoseTimeoutMs !== void 0) ctx.armEoseTimeout(sub, opts.eoseTimeoutMs);
-	return sub;
-}
-function subscribeLive(ctx, filters, opts) {
-	const fp = filterFingerprint(filters);
-	let group = ctx.liveByFp.get(fp);
-	if (group?.sub.eosed === true) group = void 0;
-	let created = false;
-	if (!group) {
-		created = true;
-		const slot = { group: void 0 };
-		const wire = new Subscription(filters, { id: opts.id }, () => {
-			const g = slot.group;
-			if (g) endLiveGroup(ctx, g, {
-				sendClose: true,
-				reason: "closed by client"
-			});
-		});
-		group = {
-			fp,
-			sub: wire,
-			attachments: /* @__PURE__ */ new Set()
-		};
-		slot.group = group;
-		ctx.liveByFp.set(fp, group);
-		ctx.liveBySubId.set(wire.id, group);
-		ctx.subs.set(wire.id, wire);
-	}
-	const slot = { handle: void 0 };
-	const attached = group;
-	const handle = new Subscription(filters, {
-		...opts,
-		id: group.sub.id
-	}, () => {
-		const current = slot.handle;
-		if (!current) return;
-		detachLive(ctx, attached, current);
-	});
-	slot.handle = handle;
-	if (handle.closed) {
-		if (created && group.attachments.size === 0) forgetLiveGroup(ctx, group);
-		return handle;
-	}
-	group.attachments.add(handle);
-	if (created) {
-		if (ctx.connected()) ctx.send([
-			"REQ",
-			group.sub.id,
-			...filters
-		]);
-		else if (ctx.enableReconnect()) ctx.scheduleReconnect();
-	}
-	if (opts.eoseTimeoutMs !== void 0) ctx.armEoseTimeout(handle, opts.eoseTimeoutMs);
-	return handle;
-}
-function forgetLiveGroup(ctx, group) {
-	if (ctx.liveByFp.get(group.fp) === group) ctx.liveByFp.delete(group.fp);
-	ctx.liveBySubId.delete(group.sub.id);
-	ctx.subs.delete(group.sub.id);
-	group.sub.closed = true;
-}
-function detachLive(ctx, group, handle) {
-	if (!group.attachments.delete(handle)) return;
-	if (group.attachments.size > 0) return;
-	endLiveGroup(ctx, group, {
-		sendClose: true,
-		reason: "closed by client"
-	});
-}
-function endLiveGroup(ctx, group, opts) {
-	const { id } = group.sub;
-	const remaining = [...group.attachments];
-	group.attachments.clear();
-	forgetLiveGroup(ctx, group);
-	if (opts.sendClose) try {
-		if (ctx.connected()) ctx.send(["CLOSE", id]);
-	} catch {}
-	for (const att of remaining) invokeSafely(() => {
-		att.close(opts.reason);
-	});
-}
-function deliverLiveEvent(ctx, group, event) {
-	const { sub } = group;
-	const attachments = [...group.attachments];
-	for (const att of attachments) invokeSafely(() => {
-		att.handlers.receivedEvent?.(event.id);
-	});
-	if (sub.idsAtWatermark.has(event.id)) return;
-	const recipients = [];
-	for (const att of attachments) {
-		if (att.closed) continue;
-		let skip = false;
-		invokeSafely(() => {
-			skip = Boolean(att.handlers.alreadyHaveEvent?.(event.id));
-		});
-		if (!skip) recipients.push(att);
-	}
-	if (recipients.length === 0) return;
-	if (!ctx.acceptEvent(event)) return;
-	sub.noteVerified(event);
-	for (const att of recipients) att.noteVerified(event);
-	for (const att of recipients) invokeSafely(() => {
-		att.handlers.onevent?.(event);
-	});
-}
-function deliverLiveEose(group) {
-	const attachments = [...group.attachments];
-	for (const att of attachments) {
-		if (att.closed || att.eosed) continue;
-		att.eosed = true;
-		invokeSafely(() => {
-			att.handlers.oneose?.();
-		});
-	}
-}
-function closeAllSubscriptions(ctx, reason) {
-	const groups = [...ctx.liveBySubId.values()];
-	for (const group of groups) invokeSafely(() => {
-		endLiveGroup(ctx, group, {
-			sendClose: false,
-			reason
-		});
-	});
-	for (const sub of ctx.subs.values()) if (!sub.closed) {
-		sub.closed = true;
-		invokeSafely(() => {
-			sub.handlers.onclose?.(reason);
-		});
-	}
-	ctx.subs.clear();
-	ctx.liveByFp.clear();
-	ctx.liveBySubId.clear();
-}
-function dropSubscription(ctx, sub, reason) {
-	const group = ctx.liveBySubId.get(sub.id);
-	if (group) {
-		endLiveGroup(ctx, group, {
-			sendClose: false,
-			reason
-		});
-		return;
-	}
-	ctx.subs.delete(sub.id);
-	sub.closed = true;
-	invokeSafely(() => {
-		sub.handlers.onclose?.(reason);
-	});
-}
-function onSubEvent(ctx, subId, event) {
-	const sub = ctx.subs.get(subId);
-	if (!sub || sub.closed) return;
-	const group = ctx.liveBySubId.get(subId);
-	if (group) {
-		deliverLiveEvent(ctx, group, event);
-		return;
-	}
-	invokeSafely(() => {
-		sub.handlers.receivedEvent?.(event.id);
-	});
-	if (sub.idsAtWatermark.has(event.id)) return;
-	let have = false;
-	invokeSafely(() => {
-		have = Boolean(sub.handlers.alreadyHaveEvent?.(event.id));
-	});
-	if (have) return;
-	if (!ctx.acceptEvent(event)) return;
-	sub.noteVerified(event);
-	invokeSafely(() => {
-		sub.handlers.onevent?.(event);
-	});
-}
-function onSubEose(ctx, subId) {
-	const sub = ctx.subs.get(subId);
-	if (!sub || sub.closed) return;
-	if (sub.eosed) return;
-	sub.eosed = true;
-	const group = ctx.liveBySubId.get(subId);
-	if (group) deliverLiveEose(group);
-	else {
-		invokeSafely(() => {
-			sub.handlers.oneose?.();
-		});
-		if (sub.closeOnEose) sub.close("eose");
-	}
-}
-function resubscribeAll(ctx) {
-	for (const sub of ctx.subs.values()) {
-		if (sub.closed) continue;
-		sub.eosed = false;
-		sub.authRetried = false;
-		const group = ctx.liveBySubId.get(sub.id);
-		if (group) for (const att of group.attachments) att.eosed = false;
-		try {
-			ctx.send([
-				"REQ",
-				sub.id,
-				...sub.replayFilters()
-			]);
-		} catch {
-			return false;
-		}
-	}
-	return true;
-}
-function streamFilters(subscribe, filters, opts) {
-	return subscriptionToAsyncIterable((handlers) => subscribe(filters, {
-		...handlers,
-		id: opts?.id,
-		signal: opts?.signal
-	}), { signal: opts?.signal });
-}
-async function fetchFilters(subscribe, filters, opts) {
-	throwIfAborted(opts.signal);
-	const events = [];
-	const seen = /* @__PURE__ */ new Set();
-	let end = { type: "timeout" };
-	await new Promise((resolve, reject) => {
-		let settled = false;
-		const done = (err) => {
-			if (settled) return;
-			settled = true;
-			clearTimeout(timer);
-			let reason = "aborted";
-			if (err instanceof Error) reason = err.message;
-			else if (err === void 0) reason = "fetch complete";
-			sub.close(reason);
-			if (err === void 0) resolve();
-			else reject(err);
-		};
-		const timer = setTimeout(() => {
-			end = { type: "timeout" };
-			done();
-		}, opts.timeoutMs);
-		const sub = subscribe(filters, {
-			id: opts.id,
-			signal: opts.signal,
-			closeOnEose: true,
-			onevent(event) {
-				if (seen.has(event.id)) return;
-				seen.add(event.id);
-				events.push(event);
-			},
-			oneose() {
-				end = { type: "eose" };
-				done();
-			},
-			onclose(reason) {
-				if (settled) return;
-				if (opts.signal?.aborted === true) {
-					done(abortReason(opts.signal));
-					return;
-				}
-				end = {
-					type: "closed",
-					reason
-				};
-				done();
-			}
-		});
-		opts.signal?.addEventListener("abort", () => done(opts.signal ? abortReason(opts.signal) : void 0), { once: true });
-	});
-	return {
-		events,
-		end
-	};
-}
-function armEoseTimeout(sub, eoseTimeoutMs) {
-	const timer = setTimeout(() => {
-		if (sub.eosed || sub.closed) return;
-		sub.eosed = true;
-		invokeSafely(() => {
-			sub.handlers.oneose?.();
-		});
-	}, eoseTimeoutMs);
-	const prevClose = sub.handlers.onclose;
-	sub.handlers.onclose = (reason) => {
-		clearTimeout(timer);
-		prevClose?.(reason);
-	};
-	const prevEose = sub.handlers.oneose;
-	sub.handlers.oneose = () => {
-		clearTimeout(timer);
-		prevEose?.();
-	};
-}
-//#endregion
-//#region src/relay/relay.ts
-/** Relay lifecycle states. */
-const RelayStatus = {
-	Initialized: "initialized",
-	Connecting: "connecting",
-	Connected: "connected",
-	Disconnected: "disconnected",
-	Closed: "closed"
-};
-const DEFAULT_BACKOFF = [
-	1e3,
-	2e3,
-	5e3,
-	1e4,
-	2e4,
-	3e4,
-	6e4
-];
-const noop = () => {};
-/**
-* Single-relay NIP-01 client. Connection lifecycle, REQ/CLOSE, EVENT publish ACK, AUTH, COUNT,
-* NIP-77, optional reconnect.
-*/
-var Relay = class Relay {
-	url;
-	#ws;
-	#connected = false;
-	#gen = 0;
-	#status = RelayStatus.Initialized;
-	#connecting;
-	#connectFinish;
-	#connectTimer;
-	#socketHandlers;
-	#subs = /* @__PURE__ */ new Map();
-	#liveByFp = /* @__PURE__ */ new Map();
-	#liveBySubId = /* @__PURE__ */ new Map();
-	#live;
-	#publishes = /* @__PURE__ */ new Map();
-	#counts = /* @__PURE__ */ new Map();
-	#neg = /* @__PURE__ */ new Map();
-	#WS;
-	#verify;
-	#verifyDead = false;
-	#publishTimeoutMs;
-	#connectTimeoutMs;
-	#enableReconnect;
-	#backoff;
-	#serial = 0;
-	#challenge;
-	#authedChallenge;
-	/** Challenge value already answered on this connection; duplicates are not re-signed. */
-	#answeredChallenge;
-	/** Settled OK verdict for `#answeredChallenge`; set only once the relay replies. */
-	#answeredResult;
-	#authPromise;
-	#authSigner;
-	#intentionalClose = false;
-	#reconnectAttempts = 0;
-	#reconnectTimer;
-	#skipReconnect = false;
-	/** Collapses error+close pairs into a single terminal/reconnect action. */
-	#deathHandled = false;
-	#enablePing;
-	#ping;
-	onnotice;
-	onclose;
-	/** Fired when the relay sends a NIP-42 AUTH challenge. */
-	onauth;
-	/** Fired after a successful reconnect (not the initial connect). */
-	onreconnect;
-	/**
-	* Fired when a delivered EVENT fails id/signature verification, just before the event is dropped.
-	* A poisoned verifier dropping events does not fire it.
-	*/
-	oninvalidevent;
-	constructor(url, opts = {}) {
-		this.url = normalizeURL(url);
-		this.#WS = opts.websocketImplementation ?? getWebSocketImplementation();
-		this.#verify = opts.verifyEvent ?? verifyEvent;
-		this.#publishTimeoutMs = opts.publishTimeoutMs ?? 4400;
-		this.#connectTimeoutMs = opts.connectTimeoutMs ?? 5e3;
-		this.#enableReconnect = opts.enableReconnect ?? false;
-		this.#backoff = opts.reconnectBackoffMs ?? DEFAULT_BACKOFF;
-		this.#enablePing = opts.enablePing ?? false;
-		this.#authSigner = opts.authSigner;
-		this.#ping = new PingLoop({
-			send: (message) => this.#send(message),
-			nextSubId: (prefix) => this.nextSubId(prefix),
-			getWs: () => this.#ws,
-			closeWs: () => {
-				const ws = this.#ws;
-				if (ws && ws.readyState === this.#WS.OPEN) try {
-					ws.close();
-				} catch {}
-			},
-			pingIntervalMs: opts.pingIntervalMs ?? 29e3,
-			pingTimeoutMs: opts.pingTimeoutMs ?? 2e4
-		});
-		this.#live = {
-			liveByFp: this.#liveByFp,
-			liveBySubId: this.#liveBySubId,
-			subs: this.#subs,
-			connected: () => this.#connected,
-			enableReconnect: () => this.#enableReconnect,
-			send: (message) => this.#send(message),
-			scheduleReconnect: () => this.#scheduleReconnect(),
-			acceptEvent: (event) => this.#acceptEvent(event),
-			armEoseTimeout
-		};
-	}
-	/** Latest NIP-42 challenge, if any. */
-	get challenge() {
-		return this.#challenge;
-	}
-	get connected() {
-		return this.#connected;
-	}
-	get status() {
-		return this.#status;
-	}
-	get generation() {
-		return this.#gen;
-	}
-	get reconnectEnabled() {
-		return this.#enableReconnect;
-	}
-	/** User subscriptions only; dummy ping REQs are not counted. */
-	get subscriptionCount() {
-		return this.#subs.size;
-	}
-	/** One-shot requests still awaiting a relay reply (EVENT ACK, COUNT, NEG). */
-	get inFlightCount() {
-		return this.#publishes.size + this.#counts.size + this.#neg.size;
-	}
-	static async connect(url, opts) {
-		const relay = new Relay(url, opts);
-		await relay.connect({ signal: opts?.signal });
-		return relay;
-	}
-	async connect(opts) {
-		if (this.#connected) return;
-		if (this.#connecting) {
-			await raceSignal(this.#connecting, opts?.signal);
-			return;
-		}
-		throwIfAborted(opts?.signal);
-		const gen = ++this.#gen;
-		this.#intentionalClose = false;
-		this.#skipReconnect = false;
-		this.#deathHandled = false;
-		this.#clearReconnectTimer();
-		this.#status = RelayStatus.Connecting;
-		const timeoutMs = opts?.timeoutMs ?? this.#connectTimeoutMs;
-		const isReconnect = this.#reconnectAttempts > 0;
-		let resolveConnect = noop;
-		let rejectConnect = noop;
-		let settled = false;
-		let ws;
-		const connecting = new Promise((resolve, reject) => {
-			resolveConnect = resolve;
-			rejectConnect = reject;
-		});
-		const release = () => {
-			if (ws === void 0) return;
-			try {
-				ws.removeEventListener("open", handlers.onOpen);
-				ws.removeEventListener("error", handlers.onError);
-				ws.removeEventListener("close", handlers.onClose);
-				ws.removeEventListener("message", handlers.onMessage);
-			} catch {}
-			if (this.#socketHandlers === handlers) this.#socketHandlers = void 0;
-			try {
-				if (ws.readyState !== this.#WS.CLOSED && ws.readyState !== this.#WS.CLOSING) ws.close();
-			} catch {}
-			if (this.#ws === ws) this.#ws = void 0;
-		};
-		const finish = (err) => {
-			if (settled) return;
-			settled = true;
-			clearTimeout(timer);
-			if (this.#connectTimer === timer) this.#connectTimer = void 0;
-			if (this.#connectFinish === finish) this.#connectFinish = void 0;
-			if (this.#connecting === connecting) this.#connecting = void 0;
-			if (err === void 0) resolveConnect();
-			else rejectConnect(err);
-		};
-		this.#connecting = connecting;
-		this.#connectFinish = finish;
-		const timer = setTimeout(() => {
-			if (gen !== this.#gen) {
-				release();
-				return;
-			}
-			if (!isReconnect && !this.#enableReconnect) this.#skipReconnect = true;
-			release();
-			finish(new RelayTimeoutError("connection timed out", this.url));
-			if (gen === this.#gen) this.#handleSocketDeath("connection timed out", {
-				fromConnectAttempt: true,
-				gen
-			});
-		}, timeoutMs);
-		this.#connectTimer = timer;
-		try {
-			ws = new this.#WS(this.url);
-		} catch (error) {
-			if (!isReconnect && !this.#enableReconnect) this.#skipReconnect = true;
-			finish(error);
-			if (gen === this.#gen) this.#handleSocketDeath("connection failed", {
-				fromConnectAttempt: true,
-				gen
-			});
-			await raceSignal(connecting, opts?.signal);
-			return;
-		}
-		this.#ws = ws;
-		const onOpen = () => {
-			if (gen !== this.#gen) {
-				release();
-				return;
-			}
-			this.#connected = true;
-			this.#status = RelayStatus.Connected;
-			this.#deathHandled = false;
-			const wasReconnect = this.#reconnectAttempts > 0;
-			this.#challenge = void 0;
-			this.#authPromise = void 0;
-			this.#authedChallenge = void 0;
-			this.#answeredChallenge = void 0;
-			this.#answeredResult = void 0;
-			if (!resubscribeAll(this.#live)) {
-				this.#connected = false;
-				this.#status = RelayStatus.Disconnected;
-				if (!isReconnect && !this.#enableReconnect) this.#skipReconnect = true;
-				release();
-				finish(new RelayConnectionError("connection failed", this.url));
-				if (this.#enableReconnect && !this.#intentionalClose && !this.#skipReconnect && this.#subs.size > 0) this.#scheduleReconnect();
-				return;
-			}
-			this.#reconnectAttempts = 0;
-			if (this.#enablePing) this.#ping.start();
-			else this.#ping.stop();
-			if (wasReconnect) invokeSafely(() => this.onreconnect?.());
-			finish();
-		};
-		const onError = () => {
-			if (gen !== this.#gen) {
-				release();
-				return;
-			}
-			this.#connected = false;
-			const fromConnectAttempt = !settled;
-			if (!settled && !isReconnect && !this.#enableReconnect) this.#skipReconnect = true;
-			release();
-			finish(new RelayConnectionError("connection failed", this.url));
-			if (gen === this.#gen) this.#handleSocketDeath("connection failed", {
-				fromConnectAttempt,
-				gen
-			});
-		};
-		const onClose = () => {
-			if (gen !== this.#gen) {
-				release();
-				return;
-			}
-			this.#connected = false;
-			const fromConnectAttempt = !settled;
-			if (!settled && !isReconnect && !this.#enableReconnect) this.#skipReconnect = true;
-			release();
-			if (fromConnectAttempt) finish(new RelayConnectionError("websocket closed", this.url));
-			if (gen === this.#gen) this.#handleSocketDeath("websocket closed", {
-				fromConnectAttempt,
-				gen
-			});
-		};
-		const onMessage = (ev) => {
-			if (gen !== this.#gen) return;
-			const data = typeof ev === "object" && ev !== null && "data" in ev ? ev.data : ev;
-			this.#onMessage(String(data));
-		};
-		const handlers = {
-			onOpen,
-			onError,
-			onClose,
-			onMessage,
-			ws
-		};
-		this.#socketHandlers = handlers;
-		ws.addEventListener("open", onOpen);
-		ws.addEventListener("error", onError);
-		ws.addEventListener("close", onClose);
-		ws.addEventListener("message", onMessage);
-		await raceSignal(connecting, opts?.signal);
-	}
-	#detachSocketHandlers() {
-		const h = this.#socketHandlers;
-		if (!h) return;
-		try {
-			h.ws.removeEventListener("open", h.onOpen);
-			h.ws.removeEventListener("error", h.onError);
-			h.ws.removeEventListener("close", h.onClose);
-			h.ws.removeEventListener("message", h.onMessage);
-		} catch {}
-		this.#socketHandlers = void 0;
-	}
-	/** Graceful shutdown: disables reconnect and closes all subscriptions. */
-	close() {
-		this.#gen += 1;
-		this.#status = RelayStatus.Closed;
-		this.#intentionalClose = true;
-		this.#skipReconnect = true;
-		this.#clearReconnectTimer();
-		if (this.#connectTimer !== void 0) {
-			clearTimeout(this.#connectTimer);
-			this.#connectTimer = void 0;
-		}
-		this.#ping.stop();
-		this.#connectFinish?.(new RelayClosedError("relay closed", this.url));
-		try {
-			closeAllSubscriptions(this.#live, "relay closed");
-		} finally {
-			this.#rejectPublishes(new RelayClosedError("relay closed", this.url));
-			this.#rejectCounts(new RelayClosedError("relay closed", this.url));
-			this.#rejectNeg(new RelayClosedError("relay closed", this.url));
-			this.#detachSocketHandlers();
-			this.#teardownSocket();
-			this.#connected = false;
-			invokeSafely(() => this.onclose?.());
-		}
-	}
-	/**
-	* Sever the socket while keeping every subscription: unlike {@link close}, open REQ state is
-	* preserved and reconnect stays suppressed — the next {@link connect} re-subscribes all of them.
-	* {@link Pool} uses this to suspend a relay without tearing down its live subscriptions.
-	*/
-	disconnect() {
-		this.#gen += 1;
-		this.#status = RelayStatus.Disconnected;
-		this.#intentionalClose = true;
-		this.#skipReconnect = true;
-		this.#clearReconnectTimer();
-		if (this.#connectTimer !== void 0) {
-			clearTimeout(this.#connectTimer);
-			this.#connectTimer = void 0;
-		}
-		this.#ping.stop();
-		this.#connectFinish?.(new RelayClosedError("relay disconnected", this.url));
-		this.#rejectPublishes(new RelayClosedError("relay disconnected", this.url));
-		this.#rejectCounts(new RelayClosedError("relay disconnected", this.url));
-		this.#rejectNeg(new RelayClosedError("relay disconnected", this.url));
-		this.#detachSocketHandlers();
-		this.#teardownSocket();
-		this.#connected = false;
-	}
-	#teardownSocket() {
-		try {
-			this.#ws?.close();
-		} catch {}
-		this.#ws = void 0;
-	}
-	#clearReconnectTimer() {
-		if (this.#reconnectTimer !== void 0) {
-			clearTimeout(this.#reconnectTimer);
-			this.#reconnectTimer = void 0;
-		}
-	}
-	#rejectPublishes(err) {
-		for (const [, waiter] of this.#publishes) {
-			clearTimeout(waiter.timer);
-			waiter.reject(err);
-		}
-		this.#publishes.clear();
-	}
-	#rejectCounts(err) {
-		for (const [, waiter] of this.#counts) {
-			clearTimeout(waiter.timer);
-			waiter.reject(err);
-		}
-		this.#counts.clear();
-	}
-	#rejectNeg(err) {
-		for (const session of this.#neg.values()) failNegSession(session, err);
-		this.#neg.clear();
-	}
-	/** Unexpected socket death. Keep subscriptions if reconnecting. */
-	#handleSocketDeath(reason, opts) {
-		if (opts.gen !== this.#gen) return;
-		if (this.#deathHandled) return;
-		this.#deathHandled = true;
-		this.#ping.stop();
-		this.#detachSocketHandlers();
-		this.#connected = false;
-		this.#ws = void 0;
-		this.#rejectPublishes(new RelayClosedError(reason, this.url));
-		this.#rejectCounts(new RelayClosedError(reason, this.url));
-		this.#rejectNeg(new RelayClosedError(reason, this.url));
-		if (this.#enableReconnect && !this.#intentionalClose && !this.#skipReconnect && this.#subs.size > 0) {
-			this.#status = RelayStatus.Disconnected;
-			this.#scheduleReconnect();
-			return;
-		}
-		if (!this.#intentionalClose) this.#status = RelayStatus.Disconnected;
-		if (opts.fromConnectAttempt !== true || this.#subs.size > 0) {
-			closeAllSubscriptions(this.#live, reason);
-			if (!this.#intentionalClose) invokeSafely(() => this.onclose?.());
-		}
-		this.#status = RelayStatus.Closed;
-	}
-	#scheduleReconnect() {
-		if (this.#reconnectTimer !== void 0) return;
-		if (this.#connected) return;
-		const delay = this.#backoff[Math.min(this.#reconnectAttempts, this.#backoff.length - 1)] ?? 6e4;
-		this.#reconnectAttempts += 1;
-		this.#reconnectTimer = setTimeout(() => {
-			this.#reconnectTimer = void 0;
-			if (this.#intentionalClose || this.#connected) return;
-			(async () => {
-				try {
-					await this.connect();
-				} catch {
-					if (this.#enableReconnect && !this.#intentionalClose && !this.#skipReconnect && this.#subs.size > 0 && !this.#connected) this.#scheduleReconnect();
-				}
-			})();
-		}, delay);
-	}
-	#send(message) {
-		if (!this.#ws || !this.#connected) throw new RelayClosedError("not connected", this.url);
-		const raw = typeof message === "string" ? message : encodeClientMessage(message);
-		this.#ws.send(raw);
-	}
-	#onMessage(raw) {
-		let msg;
-		try {
-			msg = parseRelayMessage(raw);
-		} catch {
-			return;
-		}
-		switch (msg[0]) {
-			case "EVENT": {
-				const [, subId, event] = msg;
-				if (this.#ping.hasWaiter(subId)) return;
-				onSubEvent(this.#live, subId, event);
-				break;
-			}
-			case "EOSE": {
-				const [, subId] = msg;
-				if (this.#ping.finishDummyPing(subId)) return;
-				onSubEose(this.#live, subId);
-				break;
-			}
-			case "CLOSED": {
-				const [, subId, reason] = msg;
-				if (this.#ping.finishDummyPing(subId)) return;
-				const countWaiter = this.#counts.get(subId);
-				if (countWaiter) {
-					if (isAuthRequired(reason) && this.#authSigner && !countWaiter.authRetried) {
-						countWaiter.authRetried = true;
-						this.#authThenRecount(subId, countWaiter, reason);
-						return;
-					}
-					countWaiter.reject(new RelayClosedError(reason || "COUNT closed", this.url));
-					return;
-				}
-				const sub = this.#subs.get(subId);
-				if (!sub) return;
-				if (isAuthRequired(reason) && this.#authSigner && !sub.authRetried) {
-					sub.authRetried = true;
-					this.#authThenResubscribe(sub, reason);
-					return;
-				}
-				dropSubscription(this.#live, sub, reason);
-				break;
-			}
-			case "OK": {
-				const [, eventId, ok, message] = msg;
-				const waiter = this.#publishes.get(eventId);
-				if (!waiter) return;
-				if (!ok && isAuthRequired(message) && waiter.event !== void 0 && waiter.authRetried !== true && this.#authSigner) {
-					waiter.authRetried = true;
-					this.#authThenRepublish(waiter, eventId, message);
-					return;
-				}
-				clearTimeout(waiter.timer);
-				this.#publishes.delete(eventId);
-				waiter.resolve({
-					ok,
-					message
-				});
-				break;
-			}
-			case "COUNT": {
-				const [, countId, payload] = msg;
-				const waiter = this.#counts.get(countId);
-				if (!waiter) return;
-				waiter.resolve(payload);
-				break;
-			}
-			case "NEG-MSG": {
-				const [, negId, hex] = msg;
-				const session = this.#neg.get(negId);
-				if (!session) return;
-				pushNegMsg(session, hex);
-				break;
-			}
-			case "NEG-ERR": {
-				const [, negId, reason] = msg;
-				const session = this.#neg.get(negId);
-				if (!session) return;
-				failNegErr(session, reason);
-				break;
-			}
-			case "NOTICE": {
-				const [, notice] = msg;
-				invokeSafely(() => this.onnotice?.(notice));
-				break;
-			}
-			case "AUTH": {
-				const [, authChallenge] = msg;
-				if (authChallenge !== this.#challenge) {
-					this.#authPromise = void 0;
-					this.#authedChallenge = void 0;
-					this.#answeredChallenge = void 0;
-					this.#answeredResult = void 0;
-				}
-				this.#challenge = authChallenge;
-				invokeSafely(() => this.onauth?.(authChallenge));
-				break;
-			}
-		}
-	}
-	/** Low-level REQ with callbacks. Survives reconnect when enableReconnect is on. */
-	subscribe(filters, opts = {}) {
-		if (filters.length === 0) throw new MessageError("REQ requires at least one filter");
-		if (!this.#connected && !this.#enableReconnect) throw new RelayClosedError("not connected", this.url);
-		const canonical = canonicalizeFilters(filters);
-		if (opts.closeOnEose === true) return openExclusive(this.#live, canonical, opts);
-		return subscribeLive(this.#live, canonical, opts);
-	}
-	#acceptEvent(event) {
-		if (this.#verifyDead) return false;
-		try {
-			const ok = this.#verify(event);
-			if (!ok) invokeSafely(() => this.oninvalidevent?.());
-			return ok;
-		} catch (error) {
-			if (error instanceof WasmVerifyPoisonedError || error instanceof WebAssembly.RuntimeError) {
-				this.#verifyDead = true;
-				invokeSafely(() => this.onnotice?.("verify-poisoned: wasm instance aborted"));
-				return false;
-			}
-			throw error;
-		}
-	}
-	/** AsyncIterable of events for filters until the subscription is closed. */
-	stream(filters, opts) {
-		return streamFilters((f, o) => this.subscribe(f, o), filters, opts);
-	}
-	/**
-	* One-shot query: collect events until the REQ ends, then close. `end` reports how it ended —
-	* relay `EOSE`, relay `CLOSED` (with its reason), or the local timeout; events received before a
-	* CLOSED or the deadline are still returned. Abort rejects; a failed (re)connect rejects.
-	*/
-	async fetch(filters, opts) {
-		if (filters.length === 0) throw new MessageError("REQ requires at least one filter");
-		const canonical = canonicalizeFilters(filters);
-		if (!this.#connected) await this.connect({ signal: opts?.signal });
-		return fetchFilters((f, o) => this.subscribe(f, o), canonical, {
-			timeoutMs: opts?.timeoutMs ?? 4400,
-			signal: opts?.signal,
-			id: opts?.id
-		});
-	}
-	/** Publish an event and wait for OK. */
-	async publish(event, opts) {
-		if (!this.#connected) throw new RelayClosedError("not connected", this.url);
-		const timeoutMs = opts?.timeoutMs ?? this.#publishTimeoutMs;
-		return await new Promise((resolve, reject) => {
-			const timer = setTimeout(() => {
-				this.#publishes.delete(event.id);
-				reject(new RelayTimeoutError("publish timed out", this.url));
-			}, timeoutMs);
-			this.#publishes.set(event.id, {
-				resolve,
-				reject,
-				timer,
-				event,
-				timeoutMs
-			});
-			try {
-				this.#send(["EVENT", event]);
-			} catch (error) {
-				clearTimeout(timer);
-				this.#publishes.delete(event.id);
-				reject(error instanceof Error ? error : new RelayPublishError("publish failed", this.url));
-			}
-		});
-	}
-	/**
-	* NIP-45 COUNT: ask the relay how many events match `filters`. Resolves with the COUNT payload
-	* (count / optional approximate / optional hll).
-	*/
-	async count(filters, opts) {
-		if (!this.#connected) throw new RelayClosedError("not connected", this.url);
-		if (filters.length === 0) throw new RelayError("COUNT requires at least one filter", this.url);
-		throwIfAborted(opts?.signal);
-		const canonical = canonicalizeFilters(filters);
-		const id = opts?.id === void 0 ? this.nextSubId("count") : createSubscriptionId(opts.id);
-		const timeoutMs = opts?.timeoutMs ?? this.#publishTimeoutMs;
-		return new Promise((resolve, reject) => {
-			const cleanup = () => {
-				opts?.signal?.removeEventListener("abort", onAbort);
-			};
-			const waiter = {
-				resolve: (result) => {
-					if (waiter.timer !== void 0) clearTimeout(waiter.timer);
-					waiter.timer = void 0;
-					this.#counts.delete(id);
-					cleanup();
-					resolve(result);
-				},
-				reject: (err) => {
-					if (waiter.timer !== void 0) clearTimeout(waiter.timer);
-					waiter.timer = void 0;
-					this.#counts.delete(id);
-					cleanup();
-					reject(err);
-				},
-				timer: void 0,
-				filters: [...canonical],
-				authRetried: false,
-				timeoutMs
-			};
-			const onAbort = () => {
-				if (opts?.signal) waiter.reject(abortReason(opts.signal));
-			};
-			waiter.timer = setTimeout(() => {
-				waiter.reject(new RelayTimeoutError("count timed out", this.url));
-			}, timeoutMs);
-			this.#counts.set(id, waiter);
-			opts?.signal?.addEventListener("abort", onAbort, { once: true });
-			try {
-				this.#send([
-					"COUNT",
-					id,
-					...canonical
-				]);
-			} catch (error) {
-				waiter.reject(error instanceof Error ? error : new RelayPublishError("count failed", this.url));
-			}
-		});
-	}
-	/** NIP-42 AUTH: sign the current challenge and wait for OK. */
-	async auth(sign, opts) {
-		const challenge = this.#challenge;
-		if (challenge === void 0 || challenge === "") throw new RelayError("no AUTH challenge received from relay", this.url);
-		if (this.#authPromise) return this.#authPromise;
-		if (this.#answeredChallenge === challenge && this.#answeredResult !== void 0) return this.#answeredResult;
-		const pending = (async () => {
-			const template = makeAuthEvent(this.url, challenge);
-			let event;
-			try {
-				event = await sign(template);
-			} catch (error) {
-				if (error instanceof NoSignerError) return {
-					ok: false,
-					message: "auth: no signer"
-				};
-				throw error;
-			}
-			if (!this.#connected) throw new RelayClosedError("not connected", this.url);
-			const timeoutMs = opts?.timeoutMs ?? this.#publishTimeoutMs;
-			return new Promise((resolve, reject) => {
-				const timer = setTimeout(() => {
-					this.#publishes.delete(event.id);
-					reject(new RelayTimeoutError("auth timed out", this.url));
-				}, timeoutMs);
-				this.#publishes.set(event.id, {
-					resolve: (result) => {
-						if (this.#challenge === challenge) {
-							this.#answeredChallenge = challenge;
-							this.#answeredResult = result;
-						}
-						resolve(result);
-					},
-					reject,
-					timer,
-					timeoutMs
-				});
-				try {
-					this.#send(["AUTH", event]);
-				} catch (error) {
-					clearTimeout(timer);
-					this.#publishes.delete(event.id);
-					reject(error instanceof Error ? error : new RelayPublishError("auth send failed", this.url));
-				}
-			});
-		})();
-		this.#authPromise = pending;
-		try {
-			const result = await pending;
-			if (result.ok && this.#challenge === challenge) this.#authedChallenge = challenge;
-			return result;
-		} finally {
-			if (this.#authPromise === pending) this.#authPromise = void 0;
-		}
-	}
-	/**
-	* Clear a cached AUTH rejection for the current challenge so a later `auth()` signs again. A
-	* successful auth and in-flight answers are kept. When a challenge is pending and unanswered,
-	* `onauth` is re-fired so the pool's automatic auth can run once more.
-	*/
-	resetAuth() {
-		if (this.#answeredResult !== void 0 && !this.#answeredResult.ok) {
-			this.#answeredChallenge = void 0;
-			this.#answeredResult = void 0;
-		}
-		if (this.#challenge !== void 0 && this.#challenge !== this.#authedChallenge) {
-			const challenge = this.#challenge;
-			invokeSafely(() => this.onauth?.(challenge));
-		}
-	}
-	async #ensureAuthed() {
-		const signer = this.#authSigner;
-		if (!signer) return false;
-		for (let i = 0; i < 3; i++) {
-			if (this.#challenge === void 0 || this.#challenge === "") return false;
-			if (this.#authedChallenge === this.#challenge) return true;
-			const signed = this.#challenge;
-			const result = await this.auth(signer);
-			if (this.#authedChallenge === this.#challenge) return true;
-			if (!result.ok) {
-				if (this.#challenge === void 0 || this.#challenge === "" || this.#challenge === signed) return false;
-				continue;
-			}
-		}
-		return this.#authedChallenge === this.#challenge;
-	}
-	async #authThenResubscribe(sub, reason) {
-		try {
-			if (!await this.#ensureAuthed()) {
-				dropSubscription(this.#live, sub, reason);
-				return;
-			}
-			if (sub.closed || !this.#connected) {
-				dropSubscription(this.#live, sub, reason);
-				return;
-			}
-			sub.eosed = false;
-			const group = this.#liveBySubId.get(sub.id);
-			if (group) for (const att of group.attachments) att.eosed = false;
-			this.#send([
-				"REQ",
-				sub.id,
-				...sub.replayFilters()
-			]);
-		} catch {
-			dropSubscription(this.#live, sub, reason);
-		}
-	}
-	async #authThenRecount(id, waiter, reason) {
-		if (waiter.timer !== void 0) {
-			clearTimeout(waiter.timer);
-			waiter.timer = void 0;
-		}
-		const fail = () => {
-			waiter.reject(new RelayClosedError(reason || "COUNT closed", this.url));
-		};
-		try {
-			const ok = await this.#ensureAuthed();
-			if (this.#counts.get(id) !== waiter) return;
-			if (!ok) {
-				fail();
-				return;
-			}
-			if (!this.#connected) {
-				fail();
-				return;
-			}
-			waiter.timer = setTimeout(() => {
-				waiter.reject(new RelayTimeoutError("count timed out", this.url));
-			}, waiter.timeoutMs);
-			this.#send([
-				"COUNT",
-				id,
-				...waiter.filters
-			]);
-		} catch (error) {
-			if (!this.#counts.has(id)) return;
-			waiter.reject(error instanceof Error ? error : new RelayClosedError(reason || "COUNT closed", this.url));
-		}
-	}
-	async #authThenRepublish(waiter, eventId, message) {
-		if (waiter.timer !== void 0) {
-			clearTimeout(waiter.timer);
-			waiter.timer = void 0;
-		}
-		const finish = (result) => {
-			if (waiter.timer !== void 0) clearTimeout(waiter.timer);
-			this.#publishes.delete(eventId);
-			waiter.resolve(result);
-		};
-		try {
-			if (!waiter.event) {
-				finish({
-					ok: false,
-					message
-				});
-				return;
-			}
-			const ok = await this.#ensureAuthed();
-			if (this.#publishes.get(eventId) !== waiter) return;
-			if (!ok) {
-				finish({
-					ok: false,
-					message
-				});
-				return;
-			}
-			if (!this.#connected) {
-				finish({
-					ok: false,
-					message
-				});
-				return;
-			}
-			waiter.timer = setTimeout(() => {
-				this.#publishes.delete(eventId);
-				waiter.reject(new RelayTimeoutError("publish timed out", this.url));
-			}, waiter.timeoutMs);
-			this.#send(["EVENT", waiter.event]);
-		} catch {
-			if (!this.#publishes.has(eventId)) return;
-			finish({
-				ok: false,
-				message
-			});
-		}
-	}
-	/**
-	* NIP-77: run Negentropy reconciliation against this relay. Returns the local-only (`have`) and
-	* remote-only (`need`) event ids. Does not upload or download events.
-	*
-	* `timeoutMs` is a single wall-clock deadline for the whole session (`NEG-OPEN` through the last
-	* `NEG-MSG`), not a per-message budget. Default: {@link RelayOptions.publishTimeoutMs}.
-	*/
-	async negReconcile(filter, storage, opts) {
-		if (!this.#connected) throw new RelayClosedError("not connected", this.url);
-		throwIfAborted(opts?.signal);
-		const canonical = canonicalizeFilter(filter);
-		const id = opts?.id === void 0 ? this.nextSubId("neg") : assertSubscriptionId(opts.id);
-		const timeoutMs = opts?.timeoutMs ?? this.#publishTimeoutMs;
-		const prev = this.#neg.get(id);
-		if (prev) failNegSession(prev, new Nip77Error("closed: replaced by new NEG-OPEN"));
-		const session = createNegSession();
-		this.#neg.set(id, session);
-		try {
-			return await runWiredNegSession({
-				session,
-				storage,
-				filter: canonical,
-				id,
-				timeoutMs,
-				signal: opts?.signal,
-				send: (message) => this.#send(message),
-				url: this.url
-			});
-		} finally {
-			if (this.#neg.get(id) === session) {
-				this.#neg.delete(id);
-				try {
-					this.#send(["NEG-CLOSE", id]);
-				} catch {}
-			}
-		}
-	}
-	/** Generate a unique subscription id for this relay instance. */
-	nextSubId(prefix = "sub") {
-		this.#serial += 1;
-		return `${prefix}:${this.#serial}`;
-	}
-};
-//#endregion
-//#region src/relay/fan-in.ts
-/**
-* Aggregate EOSE/close across routed jobs. One `seen` set. `pending` counts URL list entries
-* (duplicates included). `pendingEose` counts unique `jobIndex:url` keys.
-*/
-function fanIn(pool, jobs, opts = {}) {
-	const seen = /* @__PURE__ */ new Set();
-	const closers = [];
-	let closed = false;
-	let eoseFired = false;
-	let sawEose = false;
-	let eoseTimer;
-	const eoseDone = /* @__PURE__ */ new Set();
-	const eoseAttempted = /* @__PURE__ */ new Set();
-	let pendingEose = 0;
-	let pending = 0;
-	const fireEose = () => {
-		if (closed || eoseFired) return;
-		eoseFired = true;
-		if (eoseTimer !== void 0) {
-			clearTimeout(eoseTimer);
-			eoseTimer = void 0;
-		}
-		invokeSafely(() => opts.oneose?.());
-	};
-	/**
-	* Remove one relay from the pending-EOSE set. `eosed` credits a real EOSE; a CLOSED or a connect
-	* failure only drops the wait — the aggregate `oneose` fires once every remaining relay ended AND
-	* at least one actually EOSE'd.
-	*/
-	const settleEose = (jobIndex, url, eosed) => {
-		const key = `${jobIndex}:${url}`;
-		if (eoseDone.has(key)) return;
-		eoseDone.add(key);
-		if (eosed) sawEose = true;
-		pendingEose -= 1;
-		if (pendingEose === 0 && sawEose) fireEose();
-	};
-	const settleClose = () => {
-		closed = true;
-		if (eoseTimer !== void 0) {
-			clearTimeout(eoseTimer);
-			eoseTimer = void 0;
-		}
-	};
-	const closeAll = (reason) => {
-		if (closed) return;
-		settleClose();
-		for (const c of closers) c.close(reason);
-		invokeSafely(() => opts.onclose?.(reason ?? "closed by client"));
-	};
-	if (opts.signal?.aborted === true) {
-		closed = true;
-		invokeSafely(() => opts.onclose?.("aborted"));
-		return { close: closeAll };
-	}
-	opts.signal?.addEventListener("abort", () => closeAll("aborted"), { once: true });
-	const failUrl = (jobIndex, key) => {
-		settleEose(jobIndex, key, false);
-		pending -= 1;
-		if (pending <= 0 && closers.length === 0 && !closed) {
-			settleClose();
-			invokeSafely(() => opts.onclose?.("all relays failed"));
-		}
-	};
-	const attach = (relay, job, jobIndex) => {
-		if (closed) return;
-		const received = opts.receivedEvent;
-		const sub = relay.subscribe([...job.filters], {
-			id: jobs.length === 1 ? job.id : void 0,
-			closeOnEose: opts.closeOnEose,
-			alreadyHaveEvent: (id) => {
-				let have = seen.has(id);
-				invokeSafely(() => {
-					have = have || Boolean(opts.alreadyHaveEvent?.(id));
-				});
-				return have;
-			},
-			receivedEvent: received === void 0 ? void 0 : (id) => invokeSafely(() => received(id, relay.url)),
-			onevent: (event) => {
-				seen.add(event.id);
-				invokeSafely(() => opts.onevent?.(event, relay.url));
-			},
-			oneose: () => settleEose(jobIndex, relay.url, true),
-			onclose: (reason) => {
-				settleEose(jobIndex, relay.url, false);
-				pending -= 1;
-				if (pending <= 0 && !closed) {
-					settleClose();
-					invokeSafely(() => opts.onclose?.(reason));
-				}
-			}
-		});
-		closers.push(sub);
-	};
-	for (const [jobIndex, job] of jobs.entries()) {
-		const jobUrls = /* @__PURE__ */ new Set();
-		for (const url of job.urls) {
-			let key;
-			try {
-				key = normalizeURL(url);
-			} catch {
-				key = url;
-			}
-			if (jobUrls.has(key)) continue;
-			jobUrls.add(key);
-			pending += 1;
-			const eoseKey = `${jobIndex}:${key}`;
-			if (!eoseAttempted.has(eoseKey)) {
-				eoseAttempted.add(eoseKey);
-				pendingEose += 1;
-			}
-			const tryAttach = (relay) => {
-				try {
-					attach(relay, job, jobIndex);
-				} catch (error) {
-					if (error instanceof RelayClosedError) {
-						failUrl(jobIndex, key);
-						return;
-					}
-					throw error;
-				}
-			};
-			(async () => {
-				let relay;
-				try {
-					relay = await pool.ensureRelay(key, {
-						signal: opts.signal,
-						timeoutMs: opts.connectTimeoutMs
-					});
-				} catch {
-					const existing = pool.getRelay(key);
-					if (existing !== void 0) {
-						tryAttach(existing);
-						return;
-					}
-					failUrl(jobIndex, key);
-					return;
-				}
-				tryAttach(relay);
-			})();
-		}
-	}
-	if (opts.eoseTimeoutMs !== void 0 && pending > 0) eoseTimer = setTimeout(() => {
-		eoseTimer = void 0;
-		fireEose();
-	}, opts.eoseTimeoutMs);
-	if (pending === 0) queueMicrotask(() => {
-		if (closed) return;
-		settleClose();
-		invokeSafely(() => opts.onclose?.("no relays"));
-	});
-	return { close: closeAll };
-}
-async function fetchRouted(pool, jobs, opts = {}) {
-	throwIfAborted(opts.signal);
-	const byId = /* @__PURE__ */ new Map();
-	await Promise.all(jobs.flatMap((job) => {
-		const urls = [];
-		for (const raw of job.urls) {
-			let key;
-			try {
-				key = normalizeURL(raw);
-			} catch {
-				key = raw;
-			}
-			if (!urls.includes(key)) urls.push(key);
-		}
-		return urls.map(async (url) => {
-			let batch;
-			let relayUrl;
-			try {
-				const relay = await pool.ensureRelay(url, {
-					signal: opts.signal,
-					timeoutMs: opts.connectTimeoutMs
-				});
-				relayUrl = relay.url;
-				batch = (await relay.fetch([...job.filters], {
-					timeoutMs: opts.timeoutMs,
-					signal: opts.signal
-				})).events;
-			} catch {
-				if (opts.signal?.aborted === true) throw abortReason(opts.signal);
-				return;
-			}
-			for (const event of batch) if (!byId.has(event.id)) byId.set(event.id, event);
-			for (const event of batch) invokeSafely(() => opts.onevent?.(event, relayUrl));
-		});
-	}));
-	return [...byId.values()];
-}
-//#endregion
-//#region src/relay/pool.ts
-function isIdle(relay) {
-	return relay.status !== RelayStatus.Connecting && relay.subscriptionCount === 0 && relay.inFlightCount === 0;
-}
-/** Multi-relay coordinator: connection reuse, cross-relay event dedup, fan-out publish. */
-var Pool = class {
-	#relays = /* @__PURE__ */ new Map();
-	#opts;
-	#lastActivity = /* @__PURE__ */ new Map();
-	#idleTimeoutMs;
-	#idleTimer;
-	#allowInsecure;
-	#trustedInsecure;
-	#pinned;
-	/** Per-relay timestamps of verification failures inside the sliding window. */
-	#invalidEvents = /* @__PURE__ */ new Map();
-	/** Normalized URL → epoch ms when its suspension lifts. */
-	#suspendedUntil = /* @__PURE__ */ new Map();
-	#resumeTimers = /* @__PURE__ */ new Map();
-	constructor(opts = {}) {
-		this.#opts = opts;
-		this.#allowInsecure = opts.allowInsecure ?? false;
-		this.#trustedInsecure = new Set((opts.trustedInsecureUrls ?? []).map(normalizeURL));
-		this.#pinned = new Set((opts.pinnedUrls ?? []).map(normalizeURL));
-		this.#idleTimeoutMs = opts.idleTimeoutMs ?? 0;
-		if (this.#idleTimeoutMs > 0) this.#idleTimer = setInterval(() => this.cleanIdleRelays(), opts.idleCleanupIntervalMs ?? 3e4);
-	}
-	setAllowInsecure(allow) {
-		this.#allowInsecure = allow;
-	}
-	setTrustedInsecureUrls(urls) {
-		this.#trustedInsecure = new Set(urls.map(normalizeURL));
-	}
-	setPinnedUrls(urls) {
-		this.#pinned = new Set(urls.map(normalizeURL));
-	}
-	/**
-	* Drop cached AUTH rejections and re-fire pending challenges on every pooled relay, so a later
-	* `setSigner` takes effect without reconnect.
-	*/
-	resetAuth() {
-		for (const relay of this.#relays.values()) relay.resetAuth();
-	}
-	cleanIdleRelays() {
-		if (this.#idleTimeoutMs <= 0) return;
-		const now = Date.now();
-		const idle = [];
-		for (const [url, relay] of this.#relays) {
-			if (this.#pinned.has(url) || !isIdle(relay)) continue;
-			const last = this.#lastActivity.get(url) ?? 0;
-			if (!relay.connected || now - last >= this.#idleTimeoutMs) idle.push(url);
-		}
-		for (const url of this.#lastActivity.keys()) if (!this.#relays.has(url)) this.#lastActivity.delete(url);
-		if (idle.length === 0) return;
-		this.close(idle);
-		invokeSafely(() => this.#opts.onIdleRelaysClosed?.(idle));
-	}
-	#touch(url) {
-		this.#lastActivity.set(url, Date.now());
-	}
-	/**
-	* Count one verification failure for `norm`; on the `limit + 1`-th inside `windowMs` suspend the
-	* relay: drop its connection (subscriptions kept), record `until`, and fire `onRelaySuspended`.
-	*/
-	#noteInvalidEvent(norm) {
-		const policy = this.#opts.invalidEventPolicy;
-		if (policy === void 0) return;
-		const now = Date.now();
-		const window = (this.#invalidEvents.get(norm) ?? []).filter((at) => now - at < policy.windowMs);
-		window.push(now);
-		if (window.length <= policy.limit) {
-			this.#invalidEvents.set(norm, window);
-			return;
-		}
-		this.#invalidEvents.delete(norm);
-		if (this.#suspendedUntil.has(norm)) return;
-		const until = now + policy.cooldownMs;
-		this.#suspendedUntil.set(norm, until);
-		this.#relays.get(norm)?.disconnect();
-		const resume = setTimeout(() => {
-			this.#resumeTimers.delete(norm);
-			this.#suspendedUntil.delete(norm);
-			const relay = this.#relays.get(norm);
-			if (relay === void 0 || relay.connected || relay.subscriptionCount === 0) return;
-			(async () => {
-				try {
-					await relay.connect();
-				} catch {}
-			})();
-		}, policy.cooldownMs);
-		this.#resumeTimers.set(norm, resume);
-		invokeSafely(() => this.#opts.onRelaySuspended?.(norm, until));
-	}
-	#rejectInsecure(url, norm) {
-		if (this.#allowInsecure) return;
-		if (!isInsecureRelayUrl(url)) return;
-		if (this.#trustedInsecure.has(norm)) return;
-		throw new RelayConnectionError("insecure relay connection blocked", norm);
-	}
-	#stopIdleCleanup() {
-		if (this.#idleTimer === void 0) return;
-		clearInterval(this.#idleTimer);
-		this.#idleTimer = void 0;
-	}
-	/**
-	* Soft cap: closing the least-recently-used idle non-pinned relay when a new non-pinned relay
-	* would push the count past `maxRelays`. Busy relays are never evicted; with none idle the cap is
-	* exceeded rather than failing.
-	*/
-	#enforceMaxRelays(incoming) {
-		const cap = this.#opts.maxRelays;
-		if (cap === void 0 || this.#pinned.has(incoming)) return;
-		let count = 0;
-		let oldestUrl;
-		let oldestAt = Number.POSITIVE_INFINITY;
-		for (const [url, relay] of this.#relays) {
-			if (this.#pinned.has(url)) continue;
-			count += 1;
-			if (!isIdle(relay)) continue;
-			const at = this.#lastActivity.get(url) ?? 0;
-			if (at < oldestAt) {
-				oldestAt = at;
-				oldestUrl = url;
-			}
-		}
-		if (count >= cap && oldestUrl !== void 0) this.close([oldestUrl]);
-	}
-	async ensureRelay(url, opts) {
-		const norm = normalizeURL(url);
-		this.#rejectInsecure(url, norm);
-		const suspendedUntil = this.#suspendedUntil.get(norm);
-		if (suspendedUntil !== void 0) {
-			if (Date.now() < suspendedUntil) throw new RelaySuspendedError(norm, suspendedUntil);
-			this.#suspendedUntil.delete(norm);
-		}
-		let relay = this.#relays.get(norm);
-		if (!relay) {
-			this.#enforceMaxRelays(norm);
-			const signFn = this.#opts.automaticallyAuth?.(norm) ?? void 0;
-			const created = new Relay(norm, {
-				websocketImplementation: this.#opts.websocketImplementation,
-				verifyEvent: this.#opts.verifyEvent,
-				publishTimeoutMs: this.#opts.publishTimeoutMs,
-				connectTimeoutMs: this.#opts.connectTimeoutMs,
-				enableReconnect: this.#opts.enableReconnect,
-				reconnectBackoffMs: this.#opts.reconnectBackoffMs,
-				enablePing: this.#opts.enablePing,
-				pingIntervalMs: this.#opts.pingIntervalMs,
-				pingTimeoutMs: this.#opts.pingTimeoutMs,
-				authSigner: signFn
-			});
-			created.onclose = () => {
-				this.#relays.delete(norm);
-				this.#lastActivity.delete(norm);
-			};
-			created.oninvalidevent = () => {
-				this.#noteInvalidEvent(norm);
-			};
-			if (signFn) created.onauth = () => {
-				(async () => {
-					try {
-						await created.auth(signFn);
-					} catch {}
-				})();
-			};
-			this.#relays.set(norm, created);
-			relay = created;
-		}
-		this.#touch(norm);
-		if (!relay.connected) try {
-			await relay.connect({
-				signal: opts?.signal,
-				timeoutMs: opts?.timeoutMs ?? this.#opts.connectTimeoutMs
-			});
-		} catch (error) {
-			if (this.#opts.enableReconnect !== true) {
-				this.#relays.delete(norm);
-				this.#lastActivity.delete(norm);
-			}
-			throw error;
-		}
-		return relay;
-	}
-	close(urls) {
-		if (!urls) {
-			this.#stopIdleCleanup();
-			for (const timer of this.#resumeTimers.values()) clearTimeout(timer);
-			this.#resumeTimers.clear();
-			this.#suspendedUntil.clear();
-			this.#invalidEvents.clear();
-			for (const relay of this.#relays.values()) relay.close();
-			this.#relays.clear();
-			this.#lastActivity.clear();
-			return;
-		}
-		for (const url of urls) {
-			const norm = normalizeURL(url);
-			const timer = this.#resumeTimers.get(norm);
-			if (timer !== void 0) {
-				clearTimeout(timer);
-				this.#resumeTimers.delete(norm);
-			}
-			this.#relays.get(norm)?.close();
-			this.#relays.delete(norm);
-			this.#lastActivity.delete(norm);
-		}
-	}
-	/**
-	* Subscribe across relays. Deduplicates by event id. Returns a closer; callbacks receive every
-	* new event once.
-	*/
-	subscribe(relays, filters, opts = {}) {
-		if (filters.length === 0) throw new MessageError("REQ requires at least one filter");
-		if (opts.id !== void 0) assertSubscriptionId(opts.id);
-		const canonical = canonicalizeFilters(filters);
-		return fanIn(this, [{
-			urls: relays,
-			filters: canonical,
-			id: opts.id
-		}], {
-			onevent: opts.onevent,
-			oneose: opts.oneose,
-			onclose: opts.onclose,
-			signal: opts.signal,
-			eoseTimeoutMs: opts.eoseTimeoutMs,
-			alreadyHaveEvent: opts.alreadyHaveEvent,
-			receivedEvent: opts.receivedEvent,
-			closeOnEose: opts.closeOnEose,
-			connectTimeoutMs: this.#opts.connectTimeoutMs
-		});
-	}
-	/**
-	* One-shot fetch per relay: each entry reports its own events and end reason (`eose`, `closed`,
-	* `timeout`), or `failed` when the connect or REQ itself errored. An abort rejects the whole
-	* call. Events are not deduped across relays — use {@link fetch} for that.
-	*/
-	async fetchEach(relays, filters, opts) {
-		if (filters.length === 0) throw new MessageError("REQ requires at least one filter");
-		throwIfAborted(opts?.signal);
-		const canonical = canonicalizeFilters(filters);
-		return Promise.all(relays.map(async (url) => {
-			try {
-				const relay = await this.ensureRelay(url, {
-					signal: opts?.signal,
-					timeoutMs: this.#opts.connectTimeoutMs
-				});
-				this.#touch(relay.url);
-				const result = await relay.fetch([...canonical], {
-					timeoutMs: opts?.timeoutMs,
-					signal: opts?.signal
-				});
-				return {
-					url: relay.url,
-					events: result.events,
-					end: result.end
-				};
-			} catch (error) {
-				if (opts?.signal?.aborted === true) throw abortReason(opts.signal);
-				return {
-					url,
-					events: [],
-					end: {
-						type: "failed",
-						reason: error instanceof Error ? error.message : String(error)
-					}
-				};
-			}
-		}));
-	}
-	/** Fetch events until each connected relay EOSE or timeout; dedupe by id. */
-	async fetch(relays, filters, opts) {
-		if (filters.length === 0) throw new MessageError("REQ requires at least one filter");
-		return fetchRouted(this, [{
-			urls: relays,
-			filters: canonicalizeFilters(filters)
-		}], {
-			timeoutMs: opts?.timeoutMs,
-			signal: opts?.signal,
-			connectTimeoutMs: this.#opts.connectTimeoutMs,
-			onevent: opts?.onevent
-		});
-	}
-	/** Publish to all listed relays; returns per-relay outcomes. */
-	async publish(relays, event, opts) {
-		return await Promise.all(relays.map(async (url) => {
-			try {
-				const relay = await this.ensureRelay(url, { timeoutMs: this.#opts.connectTimeoutMs });
-				this.#touch(relay.url);
-				const result = await relay.publish(event, { timeoutMs: opts?.timeoutMs });
-				return {
-					url: relay.url,
-					result
-				};
-			} catch (error) {
-				return {
-					url,
-					error: error instanceof Error ? error.message : String(error)
-				};
-			}
-		}));
-	}
-	/** First successful publish (Promise.any semantics). */
-	async publishAny(relays, event, opts) {
-		return Promise.any(relays.map(async (url) => {
-			const relay = await this.ensureRelay(url, { timeoutMs: this.#opts.connectTimeoutMs });
-			this.#touch(relay.url);
-			const result = await relay.publish(event, { timeoutMs: opts?.timeoutMs });
-			if (!result.ok) throw new RelayPublishError(result.message || "rejected", relay.url);
-			return {
-				url: relay.url,
-				result
-			};
-		}));
-	}
-	/**
-	* NIP-45 COUNT across relays. Per-relay outcomes; failures do not throw. Counts are not summed —
-	* each relay reports independently (may overlap).
-	*/
-	async count(relays, filters, opts) {
-		throwIfAborted(opts?.signal);
-		const canonical = canonicalizeFilters(filters);
-		return await Promise.all(relays.map(async (url) => {
-			try {
-				const relay = await this.ensureRelay(url, {
-					signal: opts?.signal,
-					timeoutMs: this.#opts.connectTimeoutMs
-				});
-				this.#touch(relay.url);
-				const payload = await relay.count(canonical, {
-					timeoutMs: opts?.timeoutMs,
-					signal: opts?.signal
-				});
-				const out = {
-					url: relay.url,
-					count: payload.count
-				};
-				if (payload.approximate !== void 0) out.approximate = payload.approximate;
-				if (payload.hll !== void 0) out.hll = payload.hll;
-				return out;
-			} catch (error) {
-				if (opts?.signal?.aborted === true) throw abortReason(opts.signal);
-				return {
-					url,
-					error: error instanceof Error ? error.message : String(error)
-				};
-			}
-		}));
-	}
-	listRelays() {
-		return [...this.#relays.keys()];
-	}
-	/** Lookup a pooled relay, including disconnected reconnecting entries. */
-	getRelay(url) {
-		try {
-			return this.#relays.get(normalizeURL(url));
-		} catch {
-			return this.#relays.get(url);
-		}
-	}
-	/** Currently connected URLs. Unlike listRelays(), excludes reconnecting/disconnected entries. */
-	connectedUrls() {
-		const urls = [];
-		for (const [url, relay] of this.#relays) if (relay.connected) urls.push(url);
-		return urls;
-	}
-};
-//#endregion
-export { RelayStatus as a, isInsecureRelayUrl as c, RelayClosedError as d, RelayConnectionError as f, RelayTimeoutError as g, RelaySuspendedError as h, Relay as i, getWebSocketImplementation as l, RelayPublishError as m, fanIn as n, Subscription as o, RelayError as p, fetchRouted as r, subscriptionToAsyncIterable as s, Pool as t, useWebSocketImplementation as u };
-
-//# sourceMappingURL=pool-As20OGxB.mjs.map