@qntx/nostr 0.5.0 → 0.7.0

package/dist/{pool-As20OGxB.mjs → relay-CvxPiQ_m.mjs}

@@ -1,11 +1,11 @@
-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 { _ as MessageError, b as WasmPoisonedError, u as normalizeURL, v as NostrError } from "./util-yFYzlbrm.mjs";
+import { n as verifyEvent } from "./verifier-BTLOpo1n.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 { n as createSubscriptionId, r as encodeClientMessage, s as parseRelayMessage, t as assertSubscriptionId } from "./message-CWLcFTQ1.mjs";
+import { t as NoSignerError } from "./error-gtJvV6YS.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 { i as throwIfAborted, n as onAbort, r as raceSignal, t as abortReason } from "./abort-DBq2STPj.mjs";
 import { Nip77Error, runNegSession } from "./nips/nip77.mjs";
 //#region src/relay/error.ts
 /** Base class for relay errors; carries the relay URL when known. */
@@ -62,21 +62,6 @@ function getWebSocketImplementation() {
 	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 {
@@ -117,25 +102,26 @@ async function runWiredNegSession(opts) {
 		return new Promise((resolve, reject) => {
 			const timer = setTimeout(() => {
 				session.waiter = void 0;
+				disposeAbort();
 				reject(timedOut());
 			}, remainingMs());
 			const fail = (err) => {
 				clearTimeout(timer);
 				session.waiter = void 0;
+				disposeAbort();
 				reject(err);
 			};
-			const onAbort = () => {
-				if (signal) fail(abortReason(signal));
-			};
 			session.waiter = {
 				resolve: (hex) => {
 					clearTimeout(timer);
-					signal?.removeEventListener("abort", onAbort);
+					disposeAbort();
 					resolve(hex);
 				},
 				reject: (err) => fail(err)
 			};
-			signal?.addEventListener("abort", onAbort, { once: true });
+			const disposeAbort = onAbort(signal, () => {
+				if (signal) fail(abortReason(signal));
+			});
 		});
 	};
 	return runNegSession({
@@ -310,17 +296,17 @@ var Subscription = class {
 		};
 		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);
-			}
+			else this.#abort = onAbort(opts.signal, () => this.close("aborted"));
 		}
 	}
+	/** Drop the signal listener. Terminal paths that mark `closed` without `close()` run this too. */
+	dispose() {
+		this.#abort?.();
+	}
 	close(reason = "closed by client") {
 		if (this.closed) return;
 		this.closed = true;
-		this.#abort?.();
+		this.dispose();
 		this.#sendClose(this.id);
 		invokeSafely(() => this.handlers.onclose?.(reason));
 	}
@@ -355,6 +341,7 @@ function subscriptionToAsyncIterable(start, opts) {
 	let wake;
 	let closer;
 	let localClose = false;
+	let disposeAbort;
 	const notify = () => {
 		wake?.();
 		wake = void 0;
@@ -364,6 +351,7 @@ function subscriptionToAsyncIterable(start, opts) {
 	});
 	const closeLocal = (reason) => {
 		localClose = true;
+		disposeAbort?.();
 		closer?.close(reason);
 		done = true;
 		notify();
@@ -385,7 +373,10 @@ function subscriptionToAsyncIterable(start, opts) {
 	});
 	if (opts?.signal) {
 		if (opts.signal.aborted) closeLocal("aborted");
-		else opts.signal.addEventListener("abort", () => closeLocal("aborted"), { once: true });
+		else {
+			disposeAbort = onAbort(opts.signal, () => closeLocal("aborted"));
+			if (done) disposeAbort();
+		}
 	}
 	return {
 		close(reason) {
@@ -421,6 +412,7 @@ function subscriptionToAsyncIterable(start, opts) {
 }
 //#endregion
 //#region src/relay/subscribe.ts
+/** REQ subscription runtime: exclusive one-shot, live coalescing, dispatch, reconnect replay. */
 function openExclusive(ctx, filters, opts) {
 	const sub = new Subscription(filters, opts, (id) => {
 		ctx.subs.delete(id);
@@ -495,6 +487,7 @@ function forgetLiveGroup(ctx, group) {
 	ctx.liveBySubId.delete(group.sub.id);
 	ctx.subs.delete(group.sub.id);
 	group.sub.closed = true;
+	group.sub.dispose();
 }
 function detachLive(ctx, group, handle) {
 	if (!group.attachments.delete(handle)) return;
@@ -560,6 +553,7 @@ function closeAllSubscriptions(ctx, reason) {
 	});
 	for (const sub of ctx.subs.values()) if (!sub.closed) {
 		sub.closed = true;
+		sub.dispose();
 		invokeSafely(() => {
 			sub.handlers.onclose?.(reason);
 		});
@@ -579,6 +573,7 @@ function dropSubscription(ctx, sub, reason) {
 	}
 	ctx.subs.delete(sub.id);
 	sub.closed = true;
+	sub.dispose();
 	invokeSafely(() => {
 		sub.handlers.onclose?.(reason);
 	});
@@ -656,6 +651,7 @@ async function fetchFilters(subscribe, filters, opts) {
 		const done = (err) => {
 			if (settled) return;
 			settled = true;
+			disposeAbort();
 			clearTimeout(timer);
 			let reason = "aborted";
 			if (err instanceof Error) reason = err.message;
@@ -664,6 +660,9 @@ async function fetchFilters(subscribe, filters, opts) {
 			if (err === void 0) resolve();
 			else reject(err);
 		};
+		const disposeAbort = onAbort(opts.signal, () => {
+			if (opts.signal !== void 0) done(abortReason(opts.signal));
+		});
 		const timer = setTimeout(() => {
 			end = { type: "timeout" };
 			done();
@@ -694,7 +693,6 @@ async function fetchFilters(subscribe, filters, opts) {
 				done();
 			}
 		});
-		opts.signal?.addEventListener("abort", () => done(opts.signal ? abortReason(opts.signal) : void 0), { once: true });
 	});
 	return {
 		events,
@@ -722,7 +720,17 @@ function armEoseTimeout(sub, eoseTimeoutMs) {
 }
 //#endregion
 //#region src/relay/relay.ts
-/** Relay lifecycle states. */
+/**
+* Relay lifecycle states:
+*
+* - `initialized` — constructed; `connect()` not yet attempted.
+* - `connecting` — a `connect()` attempt is in flight (socket opening / resubscribing).
+* - `connected` — socket open; REQ/EVENT/COUNT flow.
+* - `disconnected` — socket down: a reconnect is scheduled when `enableReconnect` has live
+*   subscriptions to restore, or `disconnect()` severed manually (REQ state kept).
+* - `closed` — terminal until the next `connect()`: `close()` or a socket death without a scheduled
+*   reconnect.
+*/
 const RelayStatus = {
 	Initialized: "initialized",
 	Connecting: "connecting",
@@ -730,6 +738,7 @@ const RelayStatus = {
 	Disconnected: "disconnected",
 	Closed: "closed"
 };
+const DEFAULT_REQUEST_TIMEOUT_MS = 4400;
 const DEFAULT_BACKOFF = [
 	1e3,
 	2e3,
@@ -747,7 +756,6 @@ const noop = () => {};
 var Relay = class Relay {
 	url;
 	#ws;
-	#connected = false;
 	#gen = 0;
 	#status = RelayStatus.Initialized;
 	#connecting;
@@ -777,25 +785,19 @@ var Relay = class Relay {
 	#answeredResult;
 	#authPromise;
 	#authSigner;
-	#intentionalClose = false;
+	/** `close()`/`disconnect()` was called; cleared by the next `connect()`. */
+	#manualStop = 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;
+	#listeners = {
+		notice: /* @__PURE__ */ new Set(),
+		close: /* @__PURE__ */ new Set(),
+		auth: /* @__PURE__ */ new Set(),
+		reconnect: /* @__PURE__ */ new Set(),
+		invalidevent: /* @__PURE__ */ new Set()
+	};
 	constructor(url, opts = {}) {
 		this.url = normalizeURL(url);
 		this.#WS = opts.websocketImplementation ?? getWebSocketImplementation();
@@ -823,7 +825,7 @@ var Relay = class Relay {
 			liveByFp: this.#liveByFp,
 			liveBySubId: this.#liveBySubId,
 			subs: this.#subs,
-			connected: () => this.#connected,
+			connected: () => this.#isOpen(),
 			enableReconnect: () => this.#enableReconnect,
 			send: (message) => this.#send(message),
 			scheduleReconnect: () => this.#scheduleReconnect(),
@@ -836,11 +838,17 @@ var Relay = class Relay {
 		return this.#challenge;
 	}
 	get connected() {
-		return this.#connected;
+		return this.#isOpen();
 	}
 	get status() {
 		return this.#status;
 	}
+	#isOpen() {
+		return this.#status === RelayStatus.Connected;
+	}
+	#setStatus(next) {
+		this.#status = next;
+	}
 	get generation() {
 		return this.#gen;
 	}
@@ -855,26 +863,38 @@ var Relay = class Relay {
 	get inFlightCount() {
 		return this.#publishes.size + this.#counts.size + this.#neg.size;
 	}
+	/**
+	* Listen for a relay event. Multiple listeners per type are allowed and fire in registration
+	* order; a throwing listener is reported and does not break the dispatch. Returns an unsubscribe
+	* function.
+	*/
+	on(type, listener) {
+		const set = this.#listeners[type];
+		set.add(listener);
+		return () => {
+			set.delete(listener);
+		};
+	}
+	#emit(type, payload) {
+		for (const listener of [...this.#listeners[type]]) invokeSafely(() => listener(payload));
+	}
 	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.#isOpen()) 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.#manualStop = false;
 		this.#clearReconnectTimer();
-		this.#status = RelayStatus.Connecting;
+		this.#setStatus(RelayStatus.Connecting);
 		const timeoutMs = opts?.timeoutMs ?? this.#connectTimeoutMs;
-		const isReconnect = this.#reconnectAttempts > 0;
 		let resolveConnect = noop;
 		let rejectConnect = noop;
 		let settled = false;
@@ -885,12 +905,7 @@ var Relay = class Relay {
 		});
 		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 {}
+			this.#removeSocketListeners(handlers);
 			if (this.#socketHandlers === handlers) this.#socketHandlers = void 0;
 			try {
 				if (ws.readyState !== this.#WS.CLOSED && ws.readyState !== this.#WS.CLOSING) ws.close();
@@ -914,7 +929,6 @@ var Relay = class Relay {
 				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", {
@@ -926,7 +940,6 @@ var Relay = class Relay {
 		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,
@@ -941,9 +954,7 @@ var Relay = class Relay {
 				release();
 				return;
 			}
-			this.#connected = true;
-			this.#status = RelayStatus.Connected;
-			this.#deathHandled = false;
+			this.#setStatus(RelayStatus.Connected);
 			const wasReconnect = this.#reconnectAttempts > 0;
 			this.#challenge = void 0;
 			this.#authPromise = void 0;
@@ -951,18 +962,16 @@ var Relay = class Relay {
 			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;
+				this.#setStatus(RelayStatus.Disconnected);
 				release();
 				finish(new RelayConnectionError("connection failed", this.url));
-				if (this.#enableReconnect && !this.#intentionalClose && !this.#skipReconnect && this.#subs.size > 0) this.#scheduleReconnect();
+				if (this.#enableReconnect && !this.#manualStop && 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?.());
+			if (wasReconnect) this.#emit("reconnect", void 0);
 			finish();
 		};
 		const onError = () => {
@@ -970,9 +979,7 @@ var Relay = class Relay {
 				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", {
@@ -985,9 +992,7 @@ var Relay = class Relay {
 				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", {
@@ -1014,23 +1019,25 @@ var Relay = class Relay {
 		ws.addEventListener("message", onMessage);
 		await raceSignal(connecting, opts?.signal);
 	}
-	#detachSocketHandlers() {
-		const h = this.#socketHandlers;
-		if (!h) return;
+	#removeSocketListeners(h) {
 		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 {}
+	}
+	#detachSocketHandlers() {
+		const h = this.#socketHandlers;
+		if (!h) return;
+		this.#removeSocketListeners(h);
 		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.#setStatus(RelayStatus.Closed);
+		this.#manualStop = true;
 		this.#clearReconnectTimer();
 		if (this.#connectTimer !== void 0) {
 			clearTimeout(this.#connectTimer);
@@ -1041,13 +1048,10 @@ var Relay = class Relay {
 		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.#failPending(new RelayClosedError("relay closed", this.url));
 			this.#detachSocketHandlers();
 			this.#teardownSocket();
-			this.#connected = false;
-			invokeSafely(() => this.onclose?.());
+			this.#emit("close", void 0);
 		}
 	}
 	/**
@@ -1057,9 +1061,8 @@ var Relay = class Relay {
 	*/
 	disconnect() {
 		this.#gen += 1;
-		this.#status = RelayStatus.Disconnected;
-		this.#intentionalClose = true;
-		this.#skipReconnect = true;
+		this.#setStatus(RelayStatus.Disconnected);
+		this.#manualStop = true;
 		this.#clearReconnectTimer();
 		if (this.#connectTimer !== void 0) {
 			clearTimeout(this.#connectTimer);
@@ -1067,12 +1070,9 @@ var Relay = class Relay {
 		}
 		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.#failPending(new RelayClosedError("relay disconnected", this.url));
 		this.#detachSocketHandlers();
 		this.#teardownSocket();
-		this.#connected = false;
 	}
 	#teardownSocket() {
 		try {
@@ -1104,49 +1104,50 @@ var Relay = class Relay {
 		for (const session of this.#neg.values()) failNegSession(session, err);
 		this.#neg.clear();
 	}
+	#failPending(err) {
+		this.#rejectPublishes(err);
+		this.#rejectCounts(err);
+		this.#rejectNeg(err);
+	}
 	/** Unexpected socket death. Keep subscriptions if reconnecting. */
 	#handleSocketDeath(reason, opts) {
 		if (opts.gen !== this.#gen) return;
-		if (this.#deathHandled) return;
-		this.#deathHandled = true;
+		this.#gen += 1;
 		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.#failPending(new RelayClosedError(reason, this.url));
+		if (this.#enableReconnect && !this.#manualStop && this.#subs.size > 0) {
+			this.#setStatus(RelayStatus.Disconnected);
 			this.#scheduleReconnect();
 			return;
 		}
-		if (!this.#intentionalClose) this.#status = RelayStatus.Disconnected;
+		this.#setStatus(RelayStatus.Disconnected);
 		if (opts.fromConnectAttempt !== true || this.#subs.size > 0) {
 			closeAllSubscriptions(this.#live, reason);
-			if (!this.#intentionalClose) invokeSafely(() => this.onclose?.());
+			if (!this.#manualStop) this.#emit("close", void 0);
 		}
-		this.#status = RelayStatus.Closed;
+		this.#setStatus(RelayStatus.Closed);
 	}
 	#scheduleReconnect() {
 		if (this.#reconnectTimer !== void 0) return;
-		if (this.#connected) return;
+		if (this.#isOpen()) 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;
+			if (this.#manualStop || this.#isOpen()) return;
 			(async () => {
 				try {
 					await this.connect();
 				} catch {
-					if (this.#enableReconnect && !this.#intentionalClose && !this.#skipReconnect && this.#subs.size > 0 && !this.#connected) this.#scheduleReconnect();
+					if (this.#enableReconnect && !this.#manualStop && this.#subs.size > 0 && !this.#isOpen()) this.#scheduleReconnect();
 				}
 			})();
 		}, delay);
 	}
 	#send(message) {
-		if (!this.#ws || !this.#connected) throw new RelayClosedError("not connected", this.url);
+		if (!this.#ws || !this.#isOpen()) throw new RelayClosedError("not connected", this.url);
 		const raw = typeof message === "string" ? message : encodeClientMessage(message);
 		this.#ws.send(raw);
 	}
@@ -1233,7 +1234,7 @@ var Relay = class Relay {
 			}
 			case "NOTICE": {
 				const [, notice] = msg;
-				invokeSafely(() => this.onnotice?.(notice));
+				this.#emit("notice", notice);
 				break;
 			}
 			case "AUTH": {
@@ -1245,7 +1246,7 @@ var Relay = class Relay {
 					this.#answeredResult = void 0;
 				}
 				this.#challenge = authChallenge;
-				invokeSafely(() => this.onauth?.(authChallenge));
+				this.#emit("auth", authChallenge);
 				break;
 			}
 		}
@@ -1253,7 +1254,7 @@ var Relay = class Relay {
 	/** 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);
+		if (!this.#isOpen() && !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);
@@ -1262,12 +1263,12 @@ var Relay = class Relay {
 		if (this.#verifyDead) return false;
 		try {
 			const ok = this.#verify(event);
-			if (!ok) invokeSafely(() => this.oninvalidevent?.());
+			if (!ok) this.#emit("invalidevent", void 0);
 			return ok;
 		} catch (error) {
-			if (error instanceof WasmVerifyPoisonedError || error instanceof WebAssembly.RuntimeError) {
+			if (error instanceof WasmPoisonedError) {
 				this.#verifyDead = true;
-				invokeSafely(() => this.onnotice?.("verify-poisoned: wasm instance aborted"));
+				this.#emit("notice", "wasm-poisoned: instance aborted");
 				return false;
 			}
 			throw error;
@@ -1285,53 +1286,61 @@ var Relay = class Relay {
 	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 });
+		if (!this.#isOpen()) 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. */
+	/**
+	* Publish an event and wait for OK. A concurrent publish of the same event id joins the in-flight
+	* publish instead of racing it — the joiner's `timeoutMs` does not apply.
+	*/
 	async publish(event, opts) {
-		if (!this.#connected) throw new RelayClosedError("not connected", this.url);
+		if (!this.#isOpen()) throw new RelayClosedError("not connected", this.url);
+		const existing = this.#publishes.get(event.id);
+		if (existing?.event !== void 0) return existing.promise;
 		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, {
+		const promise = new Promise((resolve, reject) => {
+			const waiter = {
 				resolve,
 				reject,
-				timer,
+				timer: setTimeout(() => {
+					if (this.#publishes.get(event.id) === waiter) {
+						this.#publishes.delete(event.id);
+						reject(new RelayTimeoutError("publish timed out", this.url));
+					}
+				}, timeoutMs),
 				event,
-				timeoutMs
-			});
+				timeoutMs,
+				get promise() {
+					return promise;
+				}
+			};
+			this.#publishes.set(event.id, waiter);
 			try {
 				this.#send(["EVENT", event]);
 			} catch (error) {
-				clearTimeout(timer);
-				this.#publishes.delete(event.id);
+				clearTimeout(waiter.timer);
+				if (this.#publishes.get(event.id) === waiter) this.#publishes.delete(event.id);
 				reject(error instanceof Error ? error : new RelayPublishError("publish failed", this.url));
 			}
 		});
+		return promise;
 	}
 	/**
 	* 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 (!this.#isOpen()) 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);
@@ -1352,14 +1361,13 @@ var Relay = class Relay {
 				authRetried: false,
 				timeoutMs
 			};
-			const onAbort = () => {
+			const cleanup = onAbort(opts?.signal, () => {
 				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",
@@ -1389,14 +1397,10 @@ var Relay = class Relay {
 				};
 				throw error;
 			}
-			if (!this.#connected) throw new RelayClosedError("not connected", this.url);
+			if (!this.#isOpen()) 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, {
+			const authPromise = new Promise((resolve, reject) => {
+				const waiter = {
 					resolve: (result) => {
 						if (this.#challenge === challenge) {
 							this.#answeredChallenge = challenge;
@@ -1405,17 +1409,27 @@ var Relay = class Relay {
 						resolve(result);
 					},
 					reject,
-					timer,
-					timeoutMs
-				});
+					timer: setTimeout(() => {
+						if (this.#publishes.get(event.id) === waiter) {
+							this.#publishes.delete(event.id);
+							reject(new RelayTimeoutError("auth timed out", this.url));
+						}
+					}, timeoutMs),
+					timeoutMs,
+					get promise() {
+						return authPromise;
+					}
+				};
+				this.#publishes.set(event.id, waiter);
 				try {
 					this.#send(["AUTH", event]);
 				} catch (error) {
-					clearTimeout(timer);
-					this.#publishes.delete(event.id);
+					clearTimeout(waiter.timer);
+					if (this.#publishes.get(event.id) === waiter) this.#publishes.delete(event.id);
 					reject(error instanceof Error ? error : new RelayPublishError("auth send failed", this.url));
 				}
 			});
+			return authPromise;
 		})();
 		this.#authPromise = pending;
 		try {
@@ -1428,8 +1442,8 @@ var Relay = class Relay {
 	}
 	/**
 	* 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.
+	* successful auth and in-flight answers are kept. When a challenge is pending and unanswered, an
+	* `auth` event is re-fired so the pool's automatic auth can run once more.
 	*/
 	resetAuth() {
 		if (this.#answeredResult !== void 0 && !this.#answeredResult.ok) {
@@ -1438,7 +1452,7 @@ var Relay = class Relay {
 		}
 		if (this.#challenge !== void 0 && this.#challenge !== this.#authedChallenge) {
 			const challenge = this.#challenge;
-			invokeSafely(() => this.onauth?.(challenge));
+			this.#emit("auth", challenge);
 		}
 	}
 	async #ensureAuthed() {
@@ -1463,7 +1477,7 @@ var Relay = class Relay {
 				dropSubscription(this.#live, sub, reason);
 				return;
 			}
-			if (sub.closed || !this.#connected) {
+			if (sub.closed || !this.#isOpen()) {
 				dropSubscription(this.#live, sub, reason);
 				return;
 			}
@@ -1494,7 +1508,7 @@ var Relay = class Relay {
 				fail();
 				return;
 			}
-			if (!this.#connected) {
+			if (!this.#isOpen()) {
 				fail();
 				return;
 			}
@@ -1518,7 +1532,7 @@ var Relay = class Relay {
 		}
 		const finish = (result) => {
 			if (waiter.timer !== void 0) clearTimeout(waiter.timer);
-			this.#publishes.delete(eventId);
+			if (this.#publishes.get(eventId) === waiter) this.#publishes.delete(eventId);
 			waiter.resolve(result);
 		};
 		try {
@@ -1538,7 +1552,7 @@ var Relay = class Relay {
 				});
 				return;
 			}
-			if (!this.#connected) {
+			if (!this.#isOpen()) {
 				finish({
 					ok: false,
 					message
@@ -1546,8 +1560,10 @@ var Relay = class Relay {
 				return;
 			}
 			waiter.timer = setTimeout(() => {
-				this.#publishes.delete(eventId);
-				waiter.reject(new RelayTimeoutError("publish timed out", this.url));
+				if (this.#publishes.get(eventId) === waiter) {
+					this.#publishes.delete(eventId);
+					waiter.reject(new RelayTimeoutError("publish timed out", this.url));
+				}
 			}, waiter.timeoutMs);
 			this.#send(["EVENT", waiter.event]);
 		} catch {
@@ -1566,7 +1582,7 @@ var Relay = class Relay {
 	* `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 (!this.#isOpen()) 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);
@@ -1602,565 +1618,6 @@ 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.
-*/
-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 };
+export { getWebSocketImplementation as a, RelayConnectionError as c, RelaySuspendedError as d, RelayTimeoutError as f, subscriptionToAsyncIterable as i, RelayError as l, Relay as n, useWebSocketImplementation as o, RelayStatus as r, RelayClosedError as s, DEFAULT_REQUEST_TIMEOUT_MS as t, RelayPublishError as u };
 
-//# sourceMappingURL=pool-As20OGxB.mjs.map
+//# sourceMappingURL=relay-CvxPiQ_m.mjs.map