@qntx/nostr 0.1.0 → 0.2.1

package/dist/{pool-C_j1OmBB.mjs → pool-C2xOcsun.mjs}

@@ -1,26 +1,57 @@
-import { s as normalizeURL } from "./util-6tfLQ9JF.mjs";
-import { a as NostrError, i as MessageError, s as WasmVerifyPoisonedError } from "./error-DZEs5OuZ.mjs";
-import { s as verifyEvent } from "./key-Dn-aX4x4.mjs";
-import { i as filterFingerprint, n as canonicalizeFilters, t as canonicalizeFilter } from "./filter-BxwjEkZp.mjs";
-import { n as createSubscriptionId, r as encodeClientMessage, s as parseRelayMessage, t as assertSubscriptionId } from "./message-C_Uj-Y-c.mjs";
+import { g as NostrError, h as MessageError, l as normalizeURL, v as WasmVerifyPoisonedError } from "./util-LfQirgDk.mjs";
+import { s as verifyEvent } from "./key-Bbtys6o7.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) {
-		super(url ? `${message} (${url})` : message);
+	constructor(message, url, options) {
+		super(url !== void 0 && url !== "" ? `${message} (${url})` : message, options);
 		this.url = url;
 	}
 };
-var RelayConnectionError = class extends RelayError {};
-var RelayPublishError = class extends RelayError {};
-var RelayClosedError = class extends RelayError {};
+/** 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 (typeof globalThis.WebSocket !== "undefined") impl = globalThis.WebSocket;
+	if (globalThis.WebSocket !== void 0) impl = globalThis.WebSocket;
 } catch {}
 /** Inject a WebSocket implementation (required on Node unless undici/global is present). */
 function useWebSocketImplementation(websocketImplementation) {
@@ -33,8 +64,8 @@ function getWebSocketImplementation() {
 //#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.
+* 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 {
@@ -46,9 +77,211 @@ function isInsecureRelayUrl(url) {
 	}
 }
 //#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 {
-	sendClose;
 	id;
 	filters;
 	handlers;
@@ -61,9 +294,10 @@ var Subscription = class {
 	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.#sendClose = sendClose;
 		this.id = createSubscriptionId(opts.id);
 		this.filters = filters;
 		this.closeOnEose = opts.closeOnEose === true;
@@ -87,8 +321,8 @@ var Subscription = class {
 		if (this.closed) return;
 		this.closed = true;
 		this.#abort?.();
-		this.sendClose(this.id);
-		this.handlers.onclose?.(reason);
+		this.#sendClose(this.id);
+		invokeSafely(() => this.handlers.onclose?.(reason));
 	}
 	/** Advance the reconnect watermark after a verified EVENT. */
 	noteVerified(event) {
@@ -101,8 +335,8 @@ var Subscription = class {
 		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`.
+	* Filters for re-REQ. Original `filters` stay unchanged. NIP-01 `since` is inclusive — never
+	* `lastCreatedAt + 1`.
 	*/
 	replayFilters() {
 		const since = this.lastCreatedAt;
@@ -120,65 +354,62 @@ function subscriptionToAsyncIterable(start, opts) {
 	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) {
-				done = true;
-				closer?.close("eose");
-				notify();
-			}
+			if (opts?.includeEose === false) closeLocal("eose");
 		},
 		onclose(reason) {
-			if (reason && reason !== "eose" && reason !== "closed by client" && reason !== "aborted") error = new RelayClosedError(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) {
-			closer.close("aborted");
-			done = true;
-		} else opts.signal.addEventListener("abort", () => {
-			closer?.close("aborted");
-			done = true;
-			notify();
-		}, { once: true });
+		if (opts.signal.aborted) closeLocal("aborted");
+		else opts.signal.addEventListener("abort", () => closeLocal("aborted"), { once: true });
 	}
 	return {
 		close(reason) {
-			closer?.close(reason);
-			done = true;
-			notify();
+			closeLocal(reason ?? "closed by client");
 		},
 		[Symbol.asyncIterator]() {
 			return {
 				async next() {
 					while (true) {
-						if (queue.length > 0) return {
-							value: queue.shift(),
+						const value = queue.shift();
+						if (value !== void 0) return {
+							value,
 							done: false
 						};
-						if (error) throw error;
+						if (error !== void 0) throw error;
 						if (done) return {
 							value: void 0,
 							done: true
 						};
-						await new Promise((resolve) => {
-							wake = resolve;
-						});
+						await waitForWake();
 					}
 				},
 				async return() {
-					closer?.close("iterator returned");
-					done = true;
+					closeLocal("iterator returned");
 					return {
 						value: void 0,
 						done: true
@@ -190,18 +421,6 @@ function subscriptionToAsyncIterable(start, opts) {
 }
 //#endregion
 //#region src/relay/subscribe.ts
-function captureListenerError(errors, fn) {
-	try {
-		fn();
-	} catch (err) {
-		errors.push(err);
-	}
-}
-function flushListenerErrors(errors) {
-	if (errors.length === 0) return;
-	if (errors.length === 1) throw errors[0];
-	throw new AggregateError(errors);
-}
 function openExclusive(ctx, filters, opts) {
 	const sub = new Subscription(filters, opts, (id) => {
 		ctx.subs.delete(id);
@@ -267,7 +486,7 @@ function subscribeLive(ctx, filters, opts) {
 	if (group.sub.eosed) queueMicrotask(() => {
 		if (handle.closed || handle.eosed) return;
 		handle.eosed = true;
-		handle.handlers.oneose?.();
+		invokeSafely(() => handle.handlers.oneose?.());
 	});
 	return handle;
 }
@@ -290,70 +509,54 @@ function detachLive(ctx, fp, handle) {
 function endLiveGroup(ctx, fp, opts) {
 	const group = ctx.liveByFp.get(fp);
 	if (!group) return;
-	const id = group.sub.id;
+	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 {}
-	const errors = [];
-	for (const att of remaining) captureListenerError(errors, () => {
+	for (const att of remaining) invokeSafely(() => {
 		att.close(opts.reason);
 	});
-	flushListenerErrors(errors);
 }
 function deliverLiveEvent(ctx, group, event) {
-	const sub = group.sub;
+	const { sub } = group;
 	const attachments = [...group.attachments];
-	const errors = [];
-	for (const att of attachments) captureListenerError(errors, () => {
+	for (const att of attachments) invokeSafely(() => {
 		att.handlers.receivedEvent?.(event.id);
 	});
-	if (sub.idsAtWatermark.has(event.id)) {
-		flushListenerErrors(errors);
-		return;
-	}
+	if (sub.idsAtWatermark.has(event.id)) return;
 	const recipients = [];
 	for (const att of attachments) {
 		if (att.closed) continue;
 		let skip = false;
-		captureListenerError(errors, () => {
+		invokeSafely(() => {
 			skip = Boolean(att.handlers.alreadyHaveEvent?.(event.id));
 		});
 		if (!skip) recipients.push(att);
 	}
-	if (recipients.length === 0) {
-		flushListenerErrors(errors);
-		return;
-	}
-	if (!ctx.acceptEvent(event)) {
-		flushListenerErrors(errors);
-		return;
-	}
+	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) captureListenerError(errors, () => {
+	for (const att of recipients) invokeSafely(() => {
 		att.handlers.onevent?.(event);
 	});
-	flushListenerErrors(errors);
 }
 function deliverLiveEose(group) {
-	const attachments = Array.from(group.attachments);
-	const errors = [];
+	const attachments = [...group.attachments];
 	for (const att of attachments) {
 		if (att.closed || att.eosed) continue;
 		att.eosed = true;
-		captureListenerError(errors, () => {
+		invokeSafely(() => {
 			att.handlers.oneose?.();
 		});
 	}
-	flushListenerErrors(errors);
 }
 function closeAllSubscriptions(ctx, reason) {
-	const errors = [];
-	const fps = Array.from(ctx.liveByFp.keys());
-	for (const fp of fps) captureListenerError(errors, () => {
+	const fps = [...ctx.liveByFp.keys()];
+	for (const fp of fps) invokeSafely(() => {
 		endLiveGroup(ctx, fp, {
 			sendClose: false,
 			reason
@@ -361,14 +564,13 @@ function closeAllSubscriptions(ctx, reason) {
 	});
 	for (const sub of ctx.subs.values()) if (!sub.closed) {
 		sub.closed = true;
-		captureListenerError(errors, () => {
+		invokeSafely(() => {
 			sub.handlers.onclose?.(reason);
 		});
 	}
 	ctx.subs.clear();
 	ctx.liveByFp.clear();
 	ctx.liveBySubId.clear();
-	flushListenerErrors(errors);
 }
 function dropSubscription(ctx, sub, reason) {
 	const group = ctx.liveBySubId.get(sub.id);
@@ -381,7 +583,9 @@ function dropSubscription(ctx, sub, reason) {
 	}
 	ctx.subs.delete(sub.id);
 	sub.closed = true;
-	sub.handlers.onclose?.(reason);
+	invokeSafely(() => {
+		sub.handlers.onclose?.(reason);
+	});
 }
 function onSubEvent(ctx, subId, event) {
 	const sub = ctx.subs.get(subId);
@@ -391,302 +595,121 @@ function onSubEvent(ctx, subId, event) {
 		deliverLiveEvent(ctx, group, event);
 		return;
 	}
-	sub.handlers.receivedEvent?.(event.id);
-	if (sub.idsAtWatermark.has(event.id)) return;
-	if (sub.handlers.alreadyHaveEvent?.(event.id)) return;
-	if (!ctx.acceptEvent(event)) return;
-	sub.noteVerified(event);
-	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 {
-		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) {
-	const events = [];
-	const seen = /* @__PURE__ */ new Set();
-	await new Promise((resolve, reject) => {
-		let settled = false;
-		const done = (err) => {
-			if (settled) return;
-			settled = true;
-			clearTimeout(timer);
-			sub.close(err ? err.message : "fetch complete");
-			if (err) reject(err);
-			else resolve();
-		};
-		const timer = setTimeout(() => 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() {
-				done();
-			},
-			onclose() {
-				if (!settled) done();
-			}
-		});
-		opts.signal?.addEventListener("abort", () => done(new RelayConnectionError("fetch aborted", opts.url)), { once: true });
-	});
-	return events;
-}
-function armEoseTimeout(sub, eoseTimeoutMs) {
-	const timer = setTimeout(() => {
-		if (sub.eosed || sub.closed) return;
-		sub.eosed = true;
-		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/neg-session.ts
-function createNegSession() {
-	return {
-		queue: [],
-		waiter: void 0,
-		error: void 0
-	};
-}
-function pushNegMsg(session, hex) {
-	if (session.waiter) {
-		const waiter = session.waiter;
-		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.waiter;
-		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 RelayPublishError("negentropy timed out", url);
-	const remainingMs = () => deadline - Date.now();
-	const next = () => {
-		if (session.error) return Promise.reject(session.error);
-		if (remainingMs() <= 0) return Promise.reject(timedOut());
-		const queued = session.queue.shift();
-		if (queued !== void 0) return Promise.resolve(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 = () => fail(new RelayConnectionError("negentropy aborted", url));
-			session.waiter = {
-				resolve: (hex) => {
-					clearTimeout(timer);
-					signal?.removeEventListener("abort", onAbort);
-					resolve(hex);
-				},
-				reject: (err) => fail(err)
-			};
-			signal?.addEventListener("abort", onAbort, { once: true });
-		});
-	};
-	return await 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 || 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 || this.#waiters.size > 0) done(false);
-			}, this.#opts.pingTimeoutMs);
-			ping.then(done);
+	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 (gen !== this.#gen) return;
-		if (!ok) {
-			this.#abortCurrentPing();
-			this.#opts.closeWs();
+		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;
 		}
 	}
-	#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 {
-				ws.ping();
-			} catch {
-				finish(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();
+	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(() => 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() {
+				done();
+			},
+			onclose() {
+				if (!settled) done(opts.signal?.aborted === true ? abortReason(opts.signal) : void 0);
 			}
 		});
-	}
-	#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);
-			}
+		opts.signal?.addEventListener("abort", () => done(opts.signal ? abortReason(opts.signal) : void 0), { once: true });
+	});
+	return events;
+}
+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",
@@ -703,9 +726,10 @@ const DEFAULT_BACKOFF = [
 	3e4,
 	6e4
 ];
+const noop = () => {};
 /**
-* Single-relay NIP-01 client.
-* Connection lifecycle, REQ/CLOSE, EVENT publish ACK, AUTH, COUNT, NIP-77, optional reconnect.
+* Single-relay NIP-01 client. Connection lifecycle, REQ/CLOSE, EVENT publish ACK, AUTH, COUNT,
+* NIP-77, optional reconnect.
 */
 var Relay = class Relay {
 	url;
@@ -734,6 +758,10 @@ var Relay = class Relay {
 	#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;
@@ -744,12 +772,17 @@ var Relay = class Relay {
 	#deathHandled = false;
 	#enablePing;
 	#ping;
-	onnotice = null;
-	onclose = null;
+	onnotice;
+	onclose;
 	/** Fired when the relay sends a NIP-42 AUTH challenge. */
-	onauth = null;
+	onauth;
 	/** Fired after a successful reconnect (not the initial connect). */
-	onreconnect = null;
+	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();
@@ -805,6 +838,10 @@ var Relay = class Relay {
 	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 });
@@ -812,7 +849,11 @@ var Relay = class Relay {
 	}
 	async connect(opts) {
 		if (this.#connected) return;
-		if (this.#connecting) return await this.#connecting;
+		if (this.#connecting) {
+			await raceSignal(this.#connecting, opts?.signal);
+			return;
+		}
+		throwIfAborted(opts?.signal);
 		const gen = ++this.#gen;
 		this.#intentionalClose = false;
 		this.#skipReconnect = false;
@@ -821,84 +862,64 @@ var Relay = class Relay {
 		this.#status = RelayStatus.Connecting;
 		const timeoutMs = opts?.timeoutMs ?? this.#connectTimeoutMs;
 		const isReconnect = this.#reconnectAttempts > 0;
-		let resolveConnect = () => {};
-		let rejectConnect = (_err) => {};
+		let resolveConnect = noop;
+		let rejectConnect = noop;
 		let settled = false;
-		let timer;
 		let ws;
-		let handlers;
 		const connecting = new Promise((resolve, reject) => {
 			resolveConnect = resolve;
 			rejectConnect = reject;
 		});
 		const release = () => {
-			if (!ws) return;
-			if (handlers) {
-				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;
-			}
+			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 onAbort = () => {
-			if (gen !== this.#gen) {
-				release();
-				return;
-			}
-			this.#intentionalClose = true;
-			this.#skipReconnect = true;
-			release();
-			finish(new RelayConnectionError("connection aborted", this.url));
-			if (gen === this.#gen) this.#handleSocketDeath("connection aborted", {
-				fromConnectAttempt: true,
-				gen
-			});
-		};
 		const finish = (err) => {
 			if (settled) return;
 			settled = true;
-			if (timer !== void 0) clearTimeout(timer);
+			clearTimeout(timer);
 			if (this.#connectTimer === timer) this.#connectTimer = void 0;
-			opts?.signal?.removeEventListener("abort", onAbort);
 			if (this.#connectFinish === finish) this.#connectFinish = void 0;
 			if (this.#connecting === connecting) this.#connecting = void 0;
-			if (err) rejectConnect(err instanceof Error ? err : new RelayConnectionError("connection failed", this.url));
-			else resolveConnect();
+			if (err === void 0) resolveConnect();
+			else rejectConnect(err);
 		};
 		this.#connecting = connecting;
 		this.#connectFinish = finish;
-		timer = setTimeout(() => {
+		const timer = setTimeout(() => {
 			if (gen !== this.#gen) {
 				release();
 				return;
 			}
 			if (!isReconnect && !this.#enableReconnect) this.#skipReconnect = true;
 			release();
-			finish(new RelayConnectionError("connection timed out", this.url));
+			finish(new RelayTimeoutError("connection timed out", this.url));
 			if (gen === this.#gen) this.#handleSocketDeath("connection timed out", {
 				fromConnectAttempt: true,
 				gen
 			});
 		}, timeoutMs);
 		this.#connectTimer = timer;
-		opts?.signal?.addEventListener("abort", onAbort, { once: true });
 		try {
 			ws = new this.#WS(this.url);
-		} catch (err) {
+		} catch (error) {
 			if (!isReconnect && !this.#enableReconnect) this.#skipReconnect = true;
-			finish(err);
+			finish(error);
 			if (gen === this.#gen) this.#handleSocketDeath("connection failed", {
 				fromConnectAttempt: true,
 				gen
 			});
-			await connecting;
+			await raceSignal(connecting, opts?.signal);
 			return;
 		}
 		this.#ws = ws;
@@ -914,6 +935,8 @@ var Relay = class Relay {
 			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;
@@ -926,7 +949,7 @@ var Relay = class Relay {
 			this.#reconnectAttempts = 0;
 			if (this.#enablePing) this.#ping.start();
 			else this.#ping.stop();
-			if (wasReconnect) this.onreconnect?.();
+			if (wasReconnect) invokeSafely(() => this.onreconnect?.());
 			finish();
 		};
 		const onError = () => {
@@ -964,7 +987,7 @@ var Relay = class Relay {
 			const data = typeof ev === "object" && ev !== null && "data" in ev ? ev.data : ev;
 			this.#onMessage(String(data));
 		};
-		handlers = {
+		const handlers = {
 			onOpen,
 			onError,
 			onClose,
@@ -976,7 +999,7 @@ var Relay = class Relay {
 		ws.addEventListener("error", onError);
 		ws.addEventListener("close", onClose);
 		ws.addEventListener("message", onMessage);
-		await connecting;
+		await raceSignal(connecting, opts?.signal);
 	}
 	#detachSocketHandlers() {
 		const h = this.#socketHandlers;
@@ -1011,8 +1034,32 @@ var Relay = class Relay {
 			this.#detachSocketHandlers();
 			this.#teardownSocket();
 			this.#connected = false;
-			this.onclose?.();
+			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 {
@@ -1044,9 +1091,7 @@ var Relay = class Relay {
 		for (const session of this.#neg.values()) failNegSession(session, err);
 		this.#neg.clear();
 	}
-	/**
-	* Unexpected socket death. Keep subscriptions if reconnecting.
-	*/
+	/** Unexpected socket death. Keep subscriptions if reconnecting. */
 	#handleSocketDeath(reason, opts) {
 		if (opts.gen !== this.#gen) return;
 		if (this.#deathHandled) return;
@@ -1064,9 +1109,9 @@ var Relay = class Relay {
 			return;
 		}
 		if (!this.#intentionalClose) this.#status = RelayStatus.Disconnected;
-		if (!opts.fromConnectAttempt || this.#subs.size > 0) {
+		if (opts.fromConnectAttempt !== true || this.#subs.size > 0) {
 			closeAllSubscriptions(this.#live, reason);
-			if (!this.#intentionalClose) this.onclose?.();
+			if (!this.#intentionalClose) invokeSafely(() => this.onclose?.());
 		}
 		this.#status = RelayStatus.Closed;
 	}
@@ -1078,9 +1123,13 @@ var Relay = class Relay {
 		this.#reconnectTimer = setTimeout(() => {
 			this.#reconnectTimer = void 0;
 			if (this.#intentionalClose || this.#connected) return;
-			this.connect().catch(() => {
-				if (this.#enableReconnect && !this.#intentionalClose && !this.#skipReconnect && this.#subs.size > 0 && !this.#connected) this.#scheduleReconnect();
-			});
+			(async () => {
+				try {
+					await this.connect();
+				} catch {
+					if (this.#enableReconnect && !this.#intentionalClose && !this.#skipReconnect && this.#subs.size > 0 && !this.#connected) this.#scheduleReconnect();
+				}
+			})();
 		}, delay);
 	}
 	#send(message) {
@@ -1135,7 +1184,7 @@ var Relay = class Relay {
 				const [, eventId, ok, message] = msg;
 				const waiter = this.#publishes.get(eventId);
 				if (!waiter) return;
-				if (!ok && isAuthRequired(message) && waiter.event && !waiter.authRetried && this.#authSigner) {
+				if (!ok && isAuthRequired(message) && waiter.event !== void 0 && waiter.authRetried !== true && this.#authSigner) {
 					waiter.authRetried = true;
 					this.#authThenRepublish(waiter, eventId, message);
 					return;
@@ -1169,14 +1218,23 @@ var Relay = class Relay {
 				failNegErr(session, reason);
 				break;
 			}
-			case "NOTICE":
-				this.onnotice?.(msg[1]);
+			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;
-			case "AUTH":
-				this.#challenge = msg[1];
-				this.#authPromise = void 0;
-				this.#authedChallenge = void 0;
-				this.onauth?.(msg[1]);
+			}
 		}
 	}
 	/** Low-level REQ with callbacks. Survives reconnect when enableReconnect is on. */
@@ -1190,28 +1248,28 @@ var Relay = class Relay {
 	#acceptEvent(event) {
 		if (this.#verifyDead) return false;
 		try {
-			return this.#verify(event);
-		} catch (e) {
-			if (e instanceof WasmVerifyPoisonedError || e instanceof WebAssembly.RuntimeError) {
+			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;
-				this.onnotice?.("verify-poisoned: wasm instance aborted");
+				invokeSafely(() => this.onnotice?.("verify-poisoned: wasm instance aborted"));
 				return false;
 			}
-			throw e;
+			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 EOSE or timeout, then close.
-	*/
+	/** One-shot query: collect events until EOSE or timeout, then close. */
 	async fetch(filters, opts) {
 		if (filters.length === 0) throw new MessageError("REQ requires at least one filter");
-		filters = canonicalizeFilters(filters);
+		const canonical = canonicalizeFilters(filters);
 		if (!this.#connected) await this.connect({ signal: opts?.signal });
-		return fetchFilters((f, o) => this.subscribe(f, o), filters, {
+		return fetchFilters((f, o) => this.subscribe(f, o), canonical, {
 			timeoutMs: opts?.timeoutMs ?? 4400,
 			signal: opts?.signal,
 			id: opts?.id,
@@ -1225,7 +1283,7 @@ var Relay = class Relay {
 		return await new Promise((resolve, reject) => {
 			const timer = setTimeout(() => {
 				this.#publishes.delete(event.id);
-				reject(new RelayPublishError("publish timed out", this.url));
+				reject(new RelayTimeoutError("publish timed out", this.url));
 			}, timeoutMs);
 			this.#publishes.set(event.id, {
 				resolve,
@@ -1236,25 +1294,25 @@ var Relay = class Relay {
 			});
 			try {
 				this.#send(["EVENT", event]);
-			} catch (err) {
+			} catch (error) {
 				clearTimeout(timer);
 				this.#publishes.delete(event.id);
-				reject(err instanceof Error ? err : new RelayPublishError("publish failed", this.url));
+				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).
+	* 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);
-		if (opts?.signal?.aborted) throw new RelayConnectionError("count aborted", this.url);
-		filters = canonicalizeFilters(filters);
-		const id = opts?.id !== void 0 ? createSubscriptionId(opts.id) : this.nextSubId("count");
+		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 await new Promise((resolve, reject) => {
+		return new Promise((resolve, reject) => {
 			const cleanup = () => {
 				opts?.signal?.removeEventListener("abort", onAbort);
 			};
@@ -1274,13 +1332,15 @@ var Relay = class Relay {
 					reject(err);
 				},
 				timer: void 0,
-				filters: [...filters],
+				filters: [...canonical],
 				authRetried: false,
 				timeoutMs
 			};
-			const onAbort = () => waiter.reject(new RelayConnectionError("count aborted", this.url));
+			const onAbort = () => {
+				if (opts?.signal) waiter.reject(abortReason(opts.signal));
+			};
 			waiter.timer = setTimeout(() => {
-				waiter.reject(new RelayPublishError("count timed out", this.url));
+				waiter.reject(new RelayTimeoutError("count timed out", this.url));
 			}, timeoutMs);
 			this.#counts.set(id, waiter);
 			opts?.signal?.addEventListener("abort", onAbort, { once: true });
@@ -1288,41 +1348,56 @@ var Relay = class Relay {
 				this.#send([
 					"COUNT",
 					id,
-					...filters
+					...canonical
 				]);
-			} catch (err) {
-				waiter.reject(err instanceof Error ? err : new RelayPublishError("count failed", this.url));
+			} 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.
-	*/
+	/** NIP-42 AUTH: sign the current challenge and wait for OK. */
 	async auth(sign, opts) {
 		const challenge = this.#challenge;
-		if (!challenge) throw new RelayError("no AUTH challenge received from relay", this.url);
+		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 event = await sign(makeAuthEvent(this.url, challenge));
+			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 await new Promise((resolve, reject) => {
+			return new Promise((resolve, reject) => {
 				const timer = setTimeout(() => {
 					this.#publishes.delete(event.id);
-					reject(new RelayPublishError("auth timed out", this.url));
+					reject(new RelayTimeoutError("auth timed out", this.url));
 				}, timeoutMs);
 				this.#publishes.set(event.id, {
-					resolve,
+					resolve: (result) => {
+						if (this.#challenge === challenge) {
+							this.#answeredChallenge = challenge;
+							this.#answeredResult = result;
+						}
+						resolve(result);
+					},
 					reject,
 					timer,
 					timeoutMs
 				});
 				try {
 					this.#send(["AUTH", event]);
-				} catch (err) {
+				} catch (error) {
 					clearTimeout(timer);
 					this.#publishes.delete(event.id);
-					reject(err instanceof Error ? err : new RelayPublishError("auth send failed", this.url));
+					reject(error instanceof Error ? error : new RelayPublishError("auth send failed", this.url));
 				}
 			});
 		})();
@@ -1335,17 +1410,32 @@ var Relay = class Relay {
 			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) return false;
+			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 || this.#challenge === signed) return false;
+				if (this.#challenge === void 0 || this.#challenge === "" || this.#challenge === signed) return false;
 				continue;
 			}
 		}
@@ -1393,16 +1483,16 @@ var Relay = class Relay {
 				return;
 			}
 			waiter.timer = setTimeout(() => {
-				waiter.reject(new RelayPublishError("count timed out", this.url));
+				waiter.reject(new RelayTimeoutError("count timed out", this.url));
 			}, waiter.timeoutMs);
 			this.#send([
 				"COUNT",
 				id,
 				...waiter.filters
 			]);
-		} catch (err) {
+		} catch (error) {
 			if (!this.#counts.has(id)) return;
-			waiter.reject(err instanceof Error ? err : new RelayClosedError(reason || "COUNT closed", this.url));
+			waiter.reject(error instanceof Error ? error : new RelayClosedError(reason || "COUNT closed", this.url));
 		}
 	}
 	async #authThenRepublish(waiter, eventId, message) {
@@ -1441,7 +1531,7 @@ var Relay = class Relay {
 			}
 			waiter.timer = setTimeout(() => {
 				this.#publishes.delete(eventId);
-				waiter.reject(new RelayPublishError("publish timed out", this.url));
+				waiter.reject(new RelayTimeoutError("publish timed out", this.url));
 			}, waiter.timeoutMs);
 			this.#send(["EVENT", waiter.event]);
 		} catch {
@@ -1453,19 +1543,17 @@ var Relay = class Relay {
 		}
 	}
 	/**
-	* 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.
+	* 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}.
+	* `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);
-		if (opts?.signal?.aborted) throw new RelayConnectionError("negentropy aborted", this.url);
-		filter = canonicalizeFilter(filter);
-		const id = opts?.id !== void 0 ? assertSubscriptionId(opts.id) : this.nextSubId("neg");
+		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"));
@@ -1475,7 +1563,7 @@ var Relay = class Relay {
 			return await runWiredNegSession({
 				session,
 				storage,
-				filter,
+				filter: canonical,
 				id,
 				timeoutMs,
 				signal: opts?.signal,
@@ -1500,9 +1588,8 @@ var Relay = class Relay {
 //#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.
+* 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();
@@ -1521,7 +1608,7 @@ function fanIn(pool, jobs, opts = {}) {
 			clearTimeout(eoseTimer);
 			eoseTimer = void 0;
 		}
-		opts.oneose?.();
+		invokeSafely(() => opts.oneose?.());
 	};
 	const markEose = (jobIndex, url) => {
 		const key = `${jobIndex}:${url}`;
@@ -1541,24 +1628,39 @@ function fanIn(pool, jobs, opts = {}) {
 		if (closed) return;
 		settleClose();
 		for (const c of closers) c.close(reason);
-		opts.onclose?.(reason ?? "closed by client");
+		invokeSafely(() => opts.onclose?.(reason ?? "closed by client"));
 	};
-	if (opts.signal?.aborted) {
+	if (opts.signal?.aborted === true) {
 		closed = true;
-		opts.onclose?.("aborted");
+		invokeSafely(() => opts.onclose?.("aborted"));
 		return { close: closeAll };
 	}
 	opts.signal?.addEventListener("abort", () => closeAll("aborted"), { once: true });
+	const failUrl = (jobIndex, key) => {
+		markEose(jobIndex, key);
+		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) => Boolean(opts.alreadyHaveEvent?.(id) || seen.has(id)),
-			receivedEvent: opts.receivedEvent,
+			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);
-				opts.onevent?.(event);
+				invokeSafely(() => opts.onevent?.(event, relay.url));
 			},
 			oneose: () => markEose(jobIndex, relay.url),
 			onclose: (reason) => {
@@ -1566,14 +1668,14 @@ function fanIn(pool, jobs, opts = {}) {
 				pending -= 1;
 				if (pending <= 0 && !closed) {
 					settleClose();
-					opts.onclose?.(reason);
+					invokeSafely(() => opts.onclose?.(reason));
 				}
 			}
 		});
 		closers.push(sub);
 	};
-	for (let jobIndex = 0; jobIndex < jobs.length; jobIndex++) {
-		const job = jobs[jobIndex];
+	for (const [jobIndex, job] of jobs.entries()) {
+		const jobUrls = /* @__PURE__ */ new Set();
 		for (const url of job.urls) {
 			let key;
 			try {
@@ -1581,42 +1683,43 @@ function fanIn(pool, jobs, opts = {}) {
 			} 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 failUrl = () => {
-				markEose(jobIndex, key);
-				pending -= 1;
-				if (pending <= 0 && closers.length === 0 && !closed) {
-					settleClose();
-					opts.onclose?.("all relays failed");
-				}
-			};
 			const tryAttach = (relay) => {
 				try {
 					attach(relay, job, jobIndex);
-				} catch (err) {
-					if (err instanceof RelayClosedError) {
-						failUrl();
+				} catch (error) {
+					if (error instanceof RelayClosedError) {
+						failUrl(jobIndex, key);
 						return;
 					}
-					throw err;
+					throw error;
 				}
 			};
-			pool.ensureRelay(url, {
-				signal: opts.signal,
-				timeoutMs: opts.connectTimeoutMs
-			}).then((relay) => tryAttach(relay), () => {
-				const relay = pool.getRelay(key);
-				if (relay) {
-					tryAttach(relay);
+			(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;
 				}
-				failUrl();
-			});
+				tryAttach(relay);
+			})();
 		}
 	}
 	if (opts.eoseTimeoutMs !== void 0 && pending > 0) eoseTimer = setTimeout(() => {
@@ -1626,31 +1729,53 @@ function fanIn(pool, jobs, opts = {}) {
 	if (pending === 0) queueMicrotask(() => {
 		if (closed) return;
 		settleClose();
-		opts.onclose?.("no relays");
+		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) => job.urls.map(async (url) => {
-		try {
-			const batch = await (await pool.ensureRelay(url, {
-				signal: opts.signal,
-				timeoutMs: opts.connectTimeoutMs
-			})).fetch([...job.filters], {
-				timeoutMs: opts.timeoutMs,
-				signal: opts.signal
-			});
+	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
+				});
+			} 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);
-		} catch {}
-	})));
+			for (const event of batch) invokeSafely(() => opts.onevent?.(event, relayUrl));
+		});
+	}));
 	return [...byId.values()];
 }
 //#endregion
 //#region src/relay/pool.ts
-/**
-* Multi-relay coordinator: connection reuse, cross-relay event dedup, fan-out publish.
-*/
+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;
@@ -1659,10 +1784,17 @@ var Pool = class {
 	#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 ?? true;
+		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);
 	}
@@ -1672,23 +1804,66 @@ var Pool = class {
 	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 (relay.subscriptionCount > 0) continue;
+			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);
-		this.#opts.onIdleRelaysClosed?.(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;
@@ -1700,11 +1875,40 @@ var Pool = class {
 		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,
@@ -1722,8 +1926,15 @@ var Pool = class {
 				this.#relays.delete(norm);
 				this.#lastActivity.delete(norm);
 			};
+			created.oninvalidevent = () => {
+				this.#noteInvalidEvent(norm);
+			};
 			if (signFn) created.onauth = () => {
-				created.auth(signFn).catch(() => {});
+				(async () => {
+					try {
+						await created.auth(signFn);
+					} catch {}
+				})();
 			};
 			this.#relays.set(norm, created);
 			relay = created;
@@ -1734,18 +1945,22 @@ var Pool = class {
 				signal: opts?.signal,
 				timeoutMs: opts?.timeoutMs ?? this.#opts.connectTimeoutMs
 			});
-		} catch (err) {
-			if (!this.#opts.enableReconnect) {
+		} catch (error) {
+			if (this.#opts.enableReconnect !== true) {
 				this.#relays.delete(norm);
 				this.#lastActivity.delete(norm);
 			}
-			throw err;
+			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();
@@ -1753,22 +1968,27 @@ var Pool = class {
 		}
 		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 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);
-		filters = canonicalizeFilters(filters);
+		const canonical = canonicalizeFilters(filters);
 		return fanIn(this, [{
 			urls: relays,
-			filters,
+			filters: canonical,
 			id: opts.id
 		}], {
 			onevent: opts.onevent,
@@ -1791,7 +2011,8 @@ var Pool = class {
 		}], {
 			timeoutMs: opts?.timeoutMs,
 			signal: opts?.signal,
-			connectTimeoutMs: this.#opts.connectTimeoutMs
+			connectTimeoutMs: this.#opts.connectTimeoutMs,
+			onevent: opts?.onevent
 		});
 	}
 	/** Publish to all listed relays; returns per-relay outcomes. */
@@ -1805,10 +2026,10 @@ var Pool = class {
 					url: relay.url,
 					result
 				};
-			} catch (err) {
+			} catch (error) {
 				return {
 					url,
-					error: err instanceof Error ? err.message : String(err)
+					error: error instanceof Error ? error.message : String(error)
 				};
 			}
 		}));
@@ -1827,11 +2048,12 @@ var Pool = class {
 		}));
 	}
 	/**
-	* NIP-45 COUNT across relays. Per-relay outcomes; failures do not throw.
-	* Counts are not summed — each relay reports independently (may overlap).
+	* 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) {
-		filters = canonicalizeFilters(filters);
+		throwIfAborted(opts?.signal);
+		const canonical = canonicalizeFilters(filters);
 		return await Promise.all(relays.map(async (url) => {
 			try {
 				const relay = await this.ensureRelay(url, {
@@ -1839,20 +2061,22 @@ var Pool = class {
 					timeoutMs: this.#opts.connectTimeoutMs
 				});
 				this.#touch(relay.url);
-				const payload = await relay.count(filters, {
+				const payload = await relay.count(canonical, {
 					timeoutMs: opts?.timeoutMs,
 					signal: opts?.signal
 				});
-				return {
+				const out = {
 					url: relay.url,
-					count: payload.count,
-					approximate: payload.approximate,
-					hll: payload.hll
+					count: payload.count
 				};
-			} catch (err) {
+				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: err instanceof Error ? err.message : String(err)
+					error: error instanceof Error ? error.message : String(error)
 				};
 			}
 		}));
@@ -1876,6 +2100,6 @@ var Pool = class {
 	}
 };
 //#endregion
-export { RelayStatus as a, isInsecureRelayUrl as c, RelayClosedError as d, RelayConnectionError as f, 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 };
+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-C_j1OmBB.mjs.map
+//# sourceMappingURL=pool-C2xOcsun.mjs.map