@qntx/nostr 0.0.1

package/dist/pool-C_j1OmBB.mjs

@@ -0,0 +1,1881 @@
+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 { isAuthRequired, makeAuthEvent } from "./nips/nip42.mjs";
+import { Nip77Error, runNegSession } from "./nips/nip77.mjs";
+//#region src/relay/error.ts
+var RelayError = class extends NostrError {
+	url;
+	constructor(message, url) {
+		super(url ? `${message} (${url})` : message);
+		this.url = url;
+	}
+};
+var RelayConnectionError = class extends RelayError {};
+var RelayPublishError = class extends RelayError {};
+var RelayClosedError = class extends RelayError {};
+//#endregion
+//#region src/relay/websocket.ts
+let impl;
+try {
+	if (typeof globalThis.WebSocket !== "undefined") impl = globalThis.WebSocket;
+} catch {}
+/** Inject a WebSocket implementation (required on Node unless undici/global is present). */
+function useWebSocketImplementation(websocketImplementation) {
+	impl = websocketImplementation;
+}
+function getWebSocketImplementation() {
+	if (!impl) throw new RelayConnectionError("No WebSocket implementation available; call useWebSocketImplementation() or run in a browser");
+	return impl;
+}
+//#endregion
+//#region src/relay/url.ts
+/**
+* True for `ws:` / `http:` URLs that are not `.onion`.
+* Local-network `ws://` is still insecure; allow those via a trusted set.
+*/
+function isInsecureRelayUrl(url) {
+	try {
+		const parsed = new URL(url);
+		if (parsed.hostname.endsWith(".onion")) return false;
+		return parsed.protocol === "ws:" || parsed.protocol === "http:";
+	} catch {
+		return false;
+	}
+}
+//#endregion
+//#region src/relay/subscription.ts
+var Subscription = class {
+	sendClose;
+	id;
+	filters;
+	handlers;
+	closeOnEose;
+	eosed = false;
+	closed = false;
+	/** True after one CLOSED `auth-required:` retry. */
+	authRetried = false;
+	/** Inclusive NIP-01 `since` watermark from verified EVENTs. */
+	lastCreatedAt;
+	/** Event ids at `lastCreatedAt` (same-second reconnect dedup). Not all seen ids. */
+	idsAtWatermark = /* @__PURE__ */ new Set();
+	#abort;
+	constructor(filters, opts, sendClose) {
+		this.sendClose = sendClose;
+		this.id = createSubscriptionId(opts.id);
+		this.filters = filters;
+		this.closeOnEose = opts.closeOnEose === true;
+		this.handlers = {
+			onevent: opts.onevent,
+			oneose: opts.oneose,
+			onclose: opts.onclose,
+			alreadyHaveEvent: opts.alreadyHaveEvent,
+			receivedEvent: opts.receivedEvent
+		};
+		if (opts.signal) {
+			if (opts.signal.aborted) this.close("aborted");
+			else {
+				const onAbort = () => this.close("aborted");
+				opts.signal.addEventListener("abort", onAbort, { once: true });
+				this.#abort = () => opts.signal?.removeEventListener("abort", onAbort);
+			}
+		}
+	}
+	close(reason = "closed by client") {
+		if (this.closed) return;
+		this.closed = true;
+		this.#abort?.();
+		this.sendClose(this.id);
+		this.handlers.onclose?.(reason);
+	}
+	/** Advance the reconnect watermark after a verified EVENT. */
+	noteVerified(event) {
+		if (this.lastCreatedAt === void 0 || event.created_at > this.lastCreatedAt) {
+			this.lastCreatedAt = event.created_at;
+			this.idsAtWatermark.clear();
+			this.idsAtWatermark.add(event.id);
+			return;
+		}
+		if (event.created_at === this.lastCreatedAt) this.idsAtWatermark.add(event.id);
+	}
+	/**
+	* Filters for re-REQ. Original `filters` stay unchanged.
+	* NIP-01 `since` is inclusive — never `lastCreatedAt + 1`.
+	*/
+	replayFilters() {
+		const since = this.lastCreatedAt;
+		if (since === void 0) return this.filters;
+		return this.filters.map((f) => ({
+			...f,
+			since: f.since === void 0 ? since : Math.max(f.since, since)
+		}));
+	}
+};
+/** AsyncIterable wrapper over a subscription's events until EOSE or close. */
+function subscriptionToAsyncIterable(start, opts) {
+	const queue = [];
+	let done = false;
+	let error;
+	let wake;
+	let closer;
+	const notify = () => {
+		wake?.();
+		wake = void 0;
+	};
+	closer = start({
+		onevent(event) {
+			queue.push(event);
+			notify();
+		},
+		oneose() {
+			if (opts?.includeEose === false) {
+				done = true;
+				closer?.close("eose");
+				notify();
+			}
+		},
+		onclose(reason) {
+			if (reason && reason !== "eose" && reason !== "closed by client" && reason !== "aborted") 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 });
+	}
+	return {
+		close(reason) {
+			closer?.close(reason);
+			done = true;
+			notify();
+		},
+		[Symbol.asyncIterator]() {
+			return {
+				async next() {
+					while (true) {
+						if (queue.length > 0) return {
+							value: queue.shift(),
+							done: false
+						};
+						if (error) throw error;
+						if (done) return {
+							value: void 0,
+							done: true
+						};
+						await new Promise((resolve) => {
+							wake = resolve;
+						});
+					}
+				},
+				async return() {
+					closer?.close("iterator returned");
+					done = true;
+					return {
+						value: void 0,
+						done: true
+					};
+				}
+			};
+		}
+	};
+}
+//#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);
+		try {
+			if (ctx.connected()) ctx.send(["CLOSE", id]);
+		} catch {}
+	});
+	ctx.subs.set(sub.id, sub);
+	if (ctx.connected()) ctx.send([
+		"REQ",
+		sub.id,
+		...filters
+	]);
+	else if (ctx.enableReconnect()) ctx.scheduleReconnect();
+	if (opts.eoseTimeoutMs !== void 0) ctx.armEoseTimeout(sub, opts.eoseTimeoutMs);
+	return sub;
+}
+function subscribeLive(ctx, filters, opts) {
+	const fp = filterFingerprint(filters);
+	let group = ctx.liveByFp.get(fp);
+	let created = false;
+	if (!group) {
+		created = true;
+		const wire = new Subscription(filters, { id: opts.id }, () => {
+			endLiveGroup(ctx, fp, {
+				sendClose: true,
+				reason: "closed by client"
+			});
+		});
+		group = {
+			fp,
+			sub: wire,
+			attachments: /* @__PURE__ */ new Set()
+		};
+		ctx.liveByFp.set(fp, group);
+		ctx.liveBySubId.set(wire.id, group);
+		ctx.subs.set(wire.id, wire);
+	}
+	const slot = { handle: void 0 };
+	const handle = new Subscription(filters, {
+		...opts,
+		id: group.sub.id
+	}, () => {
+		const current = slot.handle;
+		if (!current) return;
+		detachLive(ctx, fp, current);
+	});
+	slot.handle = handle;
+	if (handle.closed) {
+		if (created && group.attachments.size === 0) forgetLiveGroup(ctx, group);
+		return handle;
+	}
+	group.attachments.add(handle);
+	if (created) {
+		if (ctx.connected()) ctx.send([
+			"REQ",
+			group.sub.id,
+			...filters
+		]);
+		else if (ctx.enableReconnect()) ctx.scheduleReconnect();
+	}
+	if (opts.eoseTimeoutMs !== void 0) ctx.armEoseTimeout(handle, opts.eoseTimeoutMs);
+	if (group.sub.eosed) queueMicrotask(() => {
+		if (handle.closed || handle.eosed) return;
+		handle.eosed = true;
+		handle.handlers.oneose?.();
+	});
+	return handle;
+}
+function forgetLiveGroup(ctx, group) {
+	ctx.liveByFp.delete(group.fp);
+	ctx.liveBySubId.delete(group.sub.id);
+	ctx.subs.delete(group.sub.id);
+	group.sub.closed = true;
+}
+function detachLive(ctx, fp, handle) {
+	const group = ctx.liveByFp.get(fp);
+	if (!group) return;
+	if (!group.attachments.delete(handle)) return;
+	if (group.attachments.size > 0) return;
+	endLiveGroup(ctx, fp, {
+		sendClose: true,
+		reason: "closed by client"
+	});
+}
+function endLiveGroup(ctx, fp, opts) {
+	const group = ctx.liveByFp.get(fp);
+	if (!group) return;
+	const id = group.sub.id;
+	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, () => {
+		att.close(opts.reason);
+	});
+	flushListenerErrors(errors);
+}
+function deliverLiveEvent(ctx, group, event) {
+	const sub = group.sub;
+	const attachments = [...group.attachments];
+	const errors = [];
+	for (const att of attachments) captureListenerError(errors, () => {
+		att.handlers.receivedEvent?.(event.id);
+	});
+	if (sub.idsAtWatermark.has(event.id)) {
+		flushListenerErrors(errors);
+		return;
+	}
+	const recipients = [];
+	for (const att of attachments) {
+		if (att.closed) continue;
+		let skip = false;
+		captureListenerError(errors, () => {
+			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;
+	}
+	sub.noteVerified(event);
+	for (const att of recipients) att.noteVerified(event);
+	for (const att of recipients) captureListenerError(errors, () => {
+		att.handlers.onevent?.(event);
+	});
+	flushListenerErrors(errors);
+}
+function deliverLiveEose(group) {
+	const attachments = Array.from(group.attachments);
+	const errors = [];
+	for (const att of attachments) {
+		if (att.closed || att.eosed) continue;
+		att.eosed = true;
+		captureListenerError(errors, () => {
+			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, () => {
+		endLiveGroup(ctx, fp, {
+			sendClose: false,
+			reason
+		});
+	});
+	for (const sub of ctx.subs.values()) if (!sub.closed) {
+		sub.closed = true;
+		captureListenerError(errors, () => {
+			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);
+	if (group) {
+		endLiveGroup(ctx, group.fp, {
+			sendClose: false,
+			reason
+		});
+		return;
+	}
+	ctx.subs.delete(sub.id);
+	sub.closed = true;
+	sub.handlers.onclose?.(reason);
+}
+function onSubEvent(ctx, subId, event) {
+	const sub = ctx.subs.get(subId);
+	if (!sub || sub.closed) return;
+	const group = ctx.liveBySubId.get(subId);
+	if (group) {
+		deliverLiveEvent(ctx, group, event);
+		return;
+	}
+	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);
+		});
+		if (gen !== this.#gen) return;
+		if (!ok) {
+			this.#abortCurrentPing();
+			this.#opts.closeWs();
+		}
+	}
+	#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);
+			}
+		});
+	}
+	#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/relay.ts
+const RelayStatus = {
+	Initialized: "initialized",
+	Connecting: "connecting",
+	Connected: "connected",
+	Disconnected: "disconnected",
+	Closed: "closed"
+};
+const DEFAULT_BACKOFF = [
+	1e3,
+	2e3,
+	5e3,
+	1e4,
+	2e4,
+	3e4,
+	6e4
+];
+/**
+* Single-relay NIP-01 client.
+* Connection lifecycle, REQ/CLOSE, EVENT publish ACK, AUTH, COUNT, NIP-77, optional reconnect.
+*/
+var Relay = class Relay {
+	url;
+	#ws;
+	#connected = false;
+	#gen = 0;
+	#status = RelayStatus.Initialized;
+	#connecting;
+	#connectFinish;
+	#connectTimer;
+	#socketHandlers;
+	#subs = /* @__PURE__ */ new Map();
+	#liveByFp = /* @__PURE__ */ new Map();
+	#liveBySubId = /* @__PURE__ */ new Map();
+	#live;
+	#publishes = /* @__PURE__ */ new Map();
+	#counts = /* @__PURE__ */ new Map();
+	#neg = /* @__PURE__ */ new Map();
+	#WS;
+	#verify;
+	#verifyDead = false;
+	#publishTimeoutMs;
+	#connectTimeoutMs;
+	#enableReconnect;
+	#backoff;
+	#serial = 0;
+	#challenge;
+	#authedChallenge;
+	#authPromise;
+	#authSigner;
+	#intentionalClose = false;
+	#reconnectAttempts = 0;
+	#reconnectTimer;
+	#skipReconnect = false;
+	/** Collapses error+close pairs into a single terminal/reconnect action. */
+	#deathHandled = false;
+	#enablePing;
+	#ping;
+	onnotice = null;
+	onclose = null;
+	/** Fired when the relay sends a NIP-42 AUTH challenge. */
+	onauth = null;
+	/** Fired after a successful reconnect (not the initial connect). */
+	onreconnect = null;
+	constructor(url, opts = {}) {
+		this.url = normalizeURL(url);
+		this.#WS = opts.websocketImplementation ?? getWebSocketImplementation();
+		this.#verify = opts.verifyEvent ?? verifyEvent;
+		this.#publishTimeoutMs = opts.publishTimeoutMs ?? 4400;
+		this.#connectTimeoutMs = opts.connectTimeoutMs ?? 5e3;
+		this.#enableReconnect = opts.enableReconnect ?? false;
+		this.#backoff = opts.reconnectBackoffMs ?? DEFAULT_BACKOFF;
+		this.#enablePing = opts.enablePing ?? false;
+		this.#authSigner = opts.authSigner;
+		this.#ping = new PingLoop({
+			send: (message) => this.#send(message),
+			nextSubId: (prefix) => this.nextSubId(prefix),
+			getWs: () => this.#ws,
+			closeWs: () => {
+				const ws = this.#ws;
+				if (ws && ws.readyState === this.#WS.OPEN) try {
+					ws.close();
+				} catch {}
+			},
+			pingIntervalMs: opts.pingIntervalMs ?? 29e3,
+			pingTimeoutMs: opts.pingTimeoutMs ?? 2e4
+		});
+		this.#live = {
+			liveByFp: this.#liveByFp,
+			liveBySubId: this.#liveBySubId,
+			subs: this.#subs,
+			connected: () => this.#connected,
+			enableReconnect: () => this.#enableReconnect,
+			send: (message) => this.#send(message),
+			scheduleReconnect: () => this.#scheduleReconnect(),
+			acceptEvent: (event) => this.#acceptEvent(event),
+			armEoseTimeout
+		};
+	}
+	/** Latest NIP-42 challenge, if any. */
+	get challenge() {
+		return this.#challenge;
+	}
+	get connected() {
+		return this.#connected;
+	}
+	get status() {
+		return this.#status;
+	}
+	get generation() {
+		return this.#gen;
+	}
+	get reconnectEnabled() {
+		return this.#enableReconnect;
+	}
+	/** User subscriptions only; dummy ping REQs are not counted. */
+	get subscriptionCount() {
+		return this.#subs.size;
+	}
+	static async connect(url, opts) {
+		const relay = new Relay(url, opts);
+		await relay.connect({ signal: opts?.signal });
+		return relay;
+	}
+	async connect(opts) {
+		if (this.#connected) return;
+		if (this.#connecting) return await this.#connecting;
+		const gen = ++this.#gen;
+		this.#intentionalClose = false;
+		this.#skipReconnect = false;
+		this.#deathHandled = false;
+		this.#clearReconnectTimer();
+		this.#status = RelayStatus.Connecting;
+		const timeoutMs = opts?.timeoutMs ?? this.#connectTimeoutMs;
+		const isReconnect = this.#reconnectAttempts > 0;
+		let resolveConnect = () => {};
+		let rejectConnect = (_err) => {};
+		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;
+			}
+			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);
+			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();
+		};
+		this.#connecting = connecting;
+		this.#connectFinish = finish;
+		timer = setTimeout(() => {
+			if (gen !== this.#gen) {
+				release();
+				return;
+			}
+			if (!isReconnect && !this.#enableReconnect) this.#skipReconnect = true;
+			release();
+			finish(new RelayConnectionError("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) {
+			if (!isReconnect && !this.#enableReconnect) this.#skipReconnect = true;
+			finish(err);
+			if (gen === this.#gen) this.#handleSocketDeath("connection failed", {
+				fromConnectAttempt: true,
+				gen
+			});
+			await connecting;
+			return;
+		}
+		this.#ws = ws;
+		const onOpen = () => {
+			if (gen !== this.#gen) {
+				release();
+				return;
+			}
+			this.#connected = true;
+			this.#status = RelayStatus.Connected;
+			this.#deathHandled = false;
+			const wasReconnect = this.#reconnectAttempts > 0;
+			this.#challenge = void 0;
+			this.#authPromise = void 0;
+			this.#authedChallenge = void 0;
+			if (!resubscribeAll(this.#live)) {
+				this.#connected = false;
+				this.#status = RelayStatus.Disconnected;
+				if (!isReconnect && !this.#enableReconnect) this.#skipReconnect = true;
+				release();
+				finish(new RelayConnectionError("connection failed", this.url));
+				if (this.#enableReconnect && !this.#intentionalClose && !this.#skipReconnect && this.#subs.size > 0) this.#scheduleReconnect();
+				return;
+			}
+			this.#reconnectAttempts = 0;
+			if (this.#enablePing) this.#ping.start();
+			else this.#ping.stop();
+			if (wasReconnect) this.onreconnect?.();
+			finish();
+		};
+		const onError = () => {
+			if (gen !== this.#gen) {
+				release();
+				return;
+			}
+			this.#connected = false;
+			const fromConnectAttempt = !settled;
+			if (!settled && !isReconnect && !this.#enableReconnect) this.#skipReconnect = true;
+			release();
+			finish(new RelayConnectionError("connection failed", this.url));
+			if (gen === this.#gen) this.#handleSocketDeath("connection failed", {
+				fromConnectAttempt,
+				gen
+			});
+		};
+		const onClose = () => {
+			if (gen !== this.#gen) {
+				release();
+				return;
+			}
+			this.#connected = false;
+			const fromConnectAttempt = !settled;
+			if (!settled && !isReconnect && !this.#enableReconnect) this.#skipReconnect = true;
+			release();
+			if (fromConnectAttempt) finish(new RelayConnectionError("websocket closed", this.url));
+			if (gen === this.#gen) this.#handleSocketDeath("websocket closed", {
+				fromConnectAttempt,
+				gen
+			});
+		};
+		const onMessage = (ev) => {
+			if (gen !== this.#gen) return;
+			const data = typeof ev === "object" && ev !== null && "data" in ev ? ev.data : ev;
+			this.#onMessage(String(data));
+		};
+		handlers = {
+			onOpen,
+			onError,
+			onClose,
+			onMessage,
+			ws
+		};
+		this.#socketHandlers = handlers;
+		ws.addEventListener("open", onOpen);
+		ws.addEventListener("error", onError);
+		ws.addEventListener("close", onClose);
+		ws.addEventListener("message", onMessage);
+		await connecting;
+	}
+	#detachSocketHandlers() {
+		const h = this.#socketHandlers;
+		if (!h) return;
+		try {
+			h.ws.removeEventListener("open", h.onOpen);
+			h.ws.removeEventListener("error", h.onError);
+			h.ws.removeEventListener("close", h.onClose);
+			h.ws.removeEventListener("message", h.onMessage);
+		} catch {}
+		this.#socketHandlers = void 0;
+	}
+	/** Graceful shutdown: disables reconnect and closes all subscriptions. */
+	close() {
+		this.#gen += 1;
+		this.#status = RelayStatus.Closed;
+		this.#intentionalClose = true;
+		this.#skipReconnect = true;
+		this.#clearReconnectTimer();
+		if (this.#connectTimer !== void 0) {
+			clearTimeout(this.#connectTimer);
+			this.#connectTimer = void 0;
+		}
+		this.#ping.stop();
+		this.#connectFinish?.(new RelayClosedError("relay closed", this.url));
+		try {
+			closeAllSubscriptions(this.#live, "relay closed");
+		} finally {
+			this.#rejectPublishes(new RelayClosedError("relay closed", this.url));
+			this.#rejectCounts(new RelayClosedError("relay closed", this.url));
+			this.#rejectNeg(new RelayClosedError("relay closed", this.url));
+			this.#detachSocketHandlers();
+			this.#teardownSocket();
+			this.#connected = false;
+			this.onclose?.();
+		}
+	}
+	#teardownSocket() {
+		try {
+			this.#ws?.close();
+		} catch {}
+		this.#ws = void 0;
+	}
+	#clearReconnectTimer() {
+		if (this.#reconnectTimer !== void 0) {
+			clearTimeout(this.#reconnectTimer);
+			this.#reconnectTimer = void 0;
+		}
+	}
+	#rejectPublishes(err) {
+		for (const [, waiter] of this.#publishes) {
+			clearTimeout(waiter.timer);
+			waiter.reject(err);
+		}
+		this.#publishes.clear();
+	}
+	#rejectCounts(err) {
+		for (const [, waiter] of this.#counts) {
+			clearTimeout(waiter.timer);
+			waiter.reject(err);
+		}
+		this.#counts.clear();
+	}
+	#rejectNeg(err) {
+		for (const session of this.#neg.values()) failNegSession(session, err);
+		this.#neg.clear();
+	}
+	/**
+	* Unexpected socket death. Keep subscriptions if reconnecting.
+	*/
+	#handleSocketDeath(reason, opts) {
+		if (opts.gen !== this.#gen) return;
+		if (this.#deathHandled) return;
+		this.#deathHandled = true;
+		this.#ping.stop();
+		this.#detachSocketHandlers();
+		this.#connected = false;
+		this.#ws = void 0;
+		this.#rejectPublishes(new RelayClosedError(reason, this.url));
+		this.#rejectCounts(new RelayClosedError(reason, this.url));
+		this.#rejectNeg(new RelayClosedError(reason, this.url));
+		if (this.#enableReconnect && !this.#intentionalClose && !this.#skipReconnect && this.#subs.size > 0) {
+			this.#status = RelayStatus.Disconnected;
+			this.#scheduleReconnect();
+			return;
+		}
+		if (!this.#intentionalClose) this.#status = RelayStatus.Disconnected;
+		if (!opts.fromConnectAttempt || this.#subs.size > 0) {
+			closeAllSubscriptions(this.#live, reason);
+			if (!this.#intentionalClose) this.onclose?.();
+		}
+		this.#status = RelayStatus.Closed;
+	}
+	#scheduleReconnect() {
+		if (this.#reconnectTimer !== void 0) return;
+		if (this.#connected) return;
+		const delay = this.#backoff[Math.min(this.#reconnectAttempts, this.#backoff.length - 1)] ?? 6e4;
+		this.#reconnectAttempts += 1;
+		this.#reconnectTimer = setTimeout(() => {
+			this.#reconnectTimer = void 0;
+			if (this.#intentionalClose || this.#connected) return;
+			this.connect().catch(() => {
+				if (this.#enableReconnect && !this.#intentionalClose && !this.#skipReconnect && this.#subs.size > 0 && !this.#connected) this.#scheduleReconnect();
+			});
+		}, delay);
+	}
+	#send(message) {
+		if (!this.#ws || !this.#connected) throw new RelayClosedError("not connected", this.url);
+		const raw = typeof message === "string" ? message : encodeClientMessage(message);
+		this.#ws.send(raw);
+	}
+	#onMessage(raw) {
+		let msg;
+		try {
+			msg = parseRelayMessage(raw);
+		} catch {
+			return;
+		}
+		switch (msg[0]) {
+			case "EVENT": {
+				const [, subId, event] = msg;
+				if (this.#ping.hasWaiter(subId)) return;
+				onSubEvent(this.#live, subId, event);
+				break;
+			}
+			case "EOSE": {
+				const [, subId] = msg;
+				if (this.#ping.finishDummyPing(subId)) return;
+				onSubEose(this.#live, subId);
+				break;
+			}
+			case "CLOSED": {
+				const [, subId, reason] = msg;
+				if (this.#ping.finishDummyPing(subId)) return;
+				const countWaiter = this.#counts.get(subId);
+				if (countWaiter) {
+					if (isAuthRequired(reason) && this.#authSigner && !countWaiter.authRetried) {
+						countWaiter.authRetried = true;
+						this.#authThenRecount(subId, countWaiter, reason);
+						return;
+					}
+					countWaiter.reject(new RelayClosedError(reason || "COUNT closed", this.url));
+					return;
+				}
+				const sub = this.#subs.get(subId);
+				if (!sub) return;
+				if (isAuthRequired(reason) && this.#authSigner && !sub.authRetried) {
+					sub.authRetried = true;
+					this.#authThenResubscribe(sub, reason);
+					return;
+				}
+				dropSubscription(this.#live, sub, reason);
+				break;
+			}
+			case "OK": {
+				const [, eventId, ok, message] = msg;
+				const waiter = this.#publishes.get(eventId);
+				if (!waiter) return;
+				if (!ok && isAuthRequired(message) && waiter.event && !waiter.authRetried && this.#authSigner) {
+					waiter.authRetried = true;
+					this.#authThenRepublish(waiter, eventId, message);
+					return;
+				}
+				clearTimeout(waiter.timer);
+				this.#publishes.delete(eventId);
+				waiter.resolve({
+					ok,
+					message
+				});
+				break;
+			}
+			case "COUNT": {
+				const [, countId, payload] = msg;
+				const waiter = this.#counts.get(countId);
+				if (!waiter) return;
+				waiter.resolve(payload);
+				break;
+			}
+			case "NEG-MSG": {
+				const [, negId, hex] = msg;
+				const session = this.#neg.get(negId);
+				if (!session) return;
+				pushNegMsg(session, hex);
+				break;
+			}
+			case "NEG-ERR": {
+				const [, negId, reason] = msg;
+				const session = this.#neg.get(negId);
+				if (!session) return;
+				failNegErr(session, reason);
+				break;
+			}
+			case "NOTICE":
+				this.onnotice?.(msg[1]);
+				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. */
+	subscribe(filters, opts = {}) {
+		if (filters.length === 0) throw new MessageError("REQ requires at least one filter");
+		if (!this.#connected && !this.#enableReconnect) throw new RelayClosedError("not connected", this.url);
+		const canonical = canonicalizeFilters(filters);
+		if (opts.closeOnEose === true) return openExclusive(this.#live, canonical, opts);
+		return subscribeLive(this.#live, canonical, opts);
+	}
+	#acceptEvent(event) {
+		if (this.#verifyDead) return false;
+		try {
+			return this.#verify(event);
+		} catch (e) {
+			if (e instanceof WasmVerifyPoisonedError || e instanceof WebAssembly.RuntimeError) {
+				this.#verifyDead = true;
+				this.onnotice?.("verify-poisoned: wasm instance aborted");
+				return false;
+			}
+			throw e;
+		}
+	}
+	/** 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.
+	*/
+	async fetch(filters, opts) {
+		if (filters.length === 0) throw new MessageError("REQ requires at least one filter");
+		filters = canonicalizeFilters(filters);
+		if (!this.#connected) await this.connect({ signal: opts?.signal });
+		return fetchFilters((f, o) => this.subscribe(f, o), filters, {
+			timeoutMs: opts?.timeoutMs ?? 4400,
+			signal: opts?.signal,
+			id: opts?.id,
+			url: this.url
+		});
+	}
+	/** Publish an event and wait for OK. */
+	async publish(event, opts) {
+		if (!this.#connected) throw new RelayClosedError("not connected", this.url);
+		const timeoutMs = opts?.timeoutMs ?? this.#publishTimeoutMs;
+		return await new Promise((resolve, reject) => {
+			const timer = setTimeout(() => {
+				this.#publishes.delete(event.id);
+				reject(new RelayPublishError("publish timed out", this.url));
+			}, timeoutMs);
+			this.#publishes.set(event.id, {
+				resolve,
+				reject,
+				timer,
+				event,
+				timeoutMs
+			});
+			try {
+				this.#send(["EVENT", event]);
+			} catch (err) {
+				clearTimeout(timer);
+				this.#publishes.delete(event.id);
+				reject(err instanceof Error ? err : new RelayPublishError("publish failed", this.url));
+			}
+		});
+	}
+	/**
+	* NIP-45 COUNT: ask the relay how many events match `filters`.
+	* Resolves with the COUNT payload (count / optional approximate / optional hll).
+	*/
+	async count(filters, opts) {
+		if (!this.#connected) throw new RelayClosedError("not connected", this.url);
+		if (filters.length === 0) throw new RelayError("COUNT requires at least one filter", this.url);
+		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");
+		const timeoutMs = opts?.timeoutMs ?? this.#publishTimeoutMs;
+		return await new Promise((resolve, reject) => {
+			const cleanup = () => {
+				opts?.signal?.removeEventListener("abort", onAbort);
+			};
+			const waiter = {
+				resolve: (result) => {
+					if (waiter.timer !== void 0) clearTimeout(waiter.timer);
+					waiter.timer = void 0;
+					this.#counts.delete(id);
+					cleanup();
+					resolve(result);
+				},
+				reject: (err) => {
+					if (waiter.timer !== void 0) clearTimeout(waiter.timer);
+					waiter.timer = void 0;
+					this.#counts.delete(id);
+					cleanup();
+					reject(err);
+				},
+				timer: void 0,
+				filters: [...filters],
+				authRetried: false,
+				timeoutMs
+			};
+			const onAbort = () => waiter.reject(new RelayConnectionError("count aborted", this.url));
+			waiter.timer = setTimeout(() => {
+				waiter.reject(new RelayPublishError("count timed out", this.url));
+			}, timeoutMs);
+			this.#counts.set(id, waiter);
+			opts?.signal?.addEventListener("abort", onAbort, { once: true });
+			try {
+				this.#send([
+					"COUNT",
+					id,
+					...filters
+				]);
+			} catch (err) {
+				waiter.reject(err instanceof Error ? err : new RelayPublishError("count failed", this.url));
+			}
+		});
+	}
+	/**
+	* NIP-42 AUTH: sign the current challenge and wait for OK.
+	*/
+	async auth(sign, opts) {
+		const challenge = this.#challenge;
+		if (!challenge) throw new RelayError("no AUTH challenge received from relay", this.url);
+		if (this.#authPromise) return this.#authPromise;
+		const pending = (async () => {
+			const event = await sign(makeAuthEvent(this.url, challenge));
+			if (!this.#connected) throw new RelayClosedError("not connected", this.url);
+			const timeoutMs = opts?.timeoutMs ?? this.#publishTimeoutMs;
+			return await new Promise((resolve, reject) => {
+				const timer = setTimeout(() => {
+					this.#publishes.delete(event.id);
+					reject(new RelayPublishError("auth timed out", this.url));
+				}, timeoutMs);
+				this.#publishes.set(event.id, {
+					resolve,
+					reject,
+					timer,
+					timeoutMs
+				});
+				try {
+					this.#send(["AUTH", event]);
+				} catch (err) {
+					clearTimeout(timer);
+					this.#publishes.delete(event.id);
+					reject(err instanceof Error ? err : new RelayPublishError("auth send failed", this.url));
+				}
+			});
+		})();
+		this.#authPromise = pending;
+		try {
+			const result = await pending;
+			if (result.ok && this.#challenge === challenge) this.#authedChallenge = challenge;
+			return result;
+		} finally {
+			if (this.#authPromise === pending) this.#authPromise = void 0;
+		}
+	}
+	async #ensureAuthed() {
+		const signer = this.#authSigner;
+		if (!signer) return false;
+		for (let i = 0; i < 3; i++) {
+			if (!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;
+				continue;
+			}
+		}
+		return this.#authedChallenge === this.#challenge;
+	}
+	async #authThenResubscribe(sub, reason) {
+		try {
+			if (!await this.#ensureAuthed()) {
+				dropSubscription(this.#live, sub, reason);
+				return;
+			}
+			if (sub.closed || !this.#connected) {
+				dropSubscription(this.#live, sub, reason);
+				return;
+			}
+			sub.eosed = false;
+			const group = this.#liveBySubId.get(sub.id);
+			if (group) for (const att of group.attachments) att.eosed = false;
+			this.#send([
+				"REQ",
+				sub.id,
+				...sub.replayFilters()
+			]);
+		} catch {
+			dropSubscription(this.#live, sub, reason);
+		}
+	}
+	async #authThenRecount(id, waiter, reason) {
+		if (waiter.timer !== void 0) {
+			clearTimeout(waiter.timer);
+			waiter.timer = void 0;
+		}
+		const fail = () => {
+			waiter.reject(new RelayClosedError(reason || "COUNT closed", this.url));
+		};
+		try {
+			const ok = await this.#ensureAuthed();
+			if (this.#counts.get(id) !== waiter) return;
+			if (!ok) {
+				fail();
+				return;
+			}
+			if (!this.#connected) {
+				fail();
+				return;
+			}
+			waiter.timer = setTimeout(() => {
+				waiter.reject(new RelayPublishError("count timed out", this.url));
+			}, waiter.timeoutMs);
+			this.#send([
+				"COUNT",
+				id,
+				...waiter.filters
+			]);
+		} catch (err) {
+			if (!this.#counts.has(id)) return;
+			waiter.reject(err instanceof Error ? err : new RelayClosedError(reason || "COUNT closed", this.url));
+		}
+	}
+	async #authThenRepublish(waiter, eventId, message) {
+		if (waiter.timer !== void 0) {
+			clearTimeout(waiter.timer);
+			waiter.timer = void 0;
+		}
+		const finish = (result) => {
+			if (waiter.timer !== void 0) clearTimeout(waiter.timer);
+			this.#publishes.delete(eventId);
+			waiter.resolve(result);
+		};
+		try {
+			if (!waiter.event) {
+				finish({
+					ok: false,
+					message
+				});
+				return;
+			}
+			const ok = await this.#ensureAuthed();
+			if (this.#publishes.get(eventId) !== waiter) return;
+			if (!ok) {
+				finish({
+					ok: false,
+					message
+				});
+				return;
+			}
+			if (!this.#connected) {
+				finish({
+					ok: false,
+					message
+				});
+				return;
+			}
+			waiter.timer = setTimeout(() => {
+				this.#publishes.delete(eventId);
+				waiter.reject(new RelayPublishError("publish timed out", this.url));
+			}, waiter.timeoutMs);
+			this.#send(["EVENT", waiter.event]);
+		} catch {
+			if (!this.#publishes.has(eventId)) return;
+			finish({
+				ok: false,
+				message
+			});
+		}
+	}
+	/**
+	* NIP-77: run Negentropy reconciliation against this relay.
+	* Returns the local-only (`have`) and remote-only (`need`) event ids.
+	* Does not upload or download events.
+	*
+	* `timeoutMs` is a single wall-clock deadline for the whole session
+	* (`NEG-OPEN` through the last `NEG-MSG`), not a per-message budget.
+	* Default: {@link RelayOptions.publishTimeoutMs}.
+	*/
+	async negReconcile(filter, storage, opts) {
+		if (!this.#connected) throw new RelayClosedError("not connected", this.url);
+		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");
+		const timeoutMs = opts?.timeoutMs ?? this.#publishTimeoutMs;
+		const prev = this.#neg.get(id);
+		if (prev) failNegSession(prev, new Nip77Error("closed: replaced by new NEG-OPEN"));
+		const session = createNegSession();
+		this.#neg.set(id, session);
+		try {
+			return await runWiredNegSession({
+				session,
+				storage,
+				filter,
+				id,
+				timeoutMs,
+				signal: opts?.signal,
+				send: (message) => this.#send(message),
+				url: this.url
+			});
+		} finally {
+			if (this.#neg.get(id) === session) {
+				this.#neg.delete(id);
+				try {
+					this.#send(["NEG-CLOSE", id]);
+				} catch {}
+			}
+		}
+	}
+	/** Generate a unique subscription id for this relay instance. */
+	nextSubId(prefix = "sub") {
+		this.#serial += 1;
+		return `${prefix}:${this.#serial}`;
+	}
+};
+//#endregion
+//#region src/relay/fan-in.ts
+/**
+* Aggregate EOSE/close across routed jobs. One `seen` set.
+* `pending` counts URL list entries (duplicates included).
+* `pendingEose` counts unique `jobIndex:url` keys.
+*/
+function fanIn(pool, jobs, opts = {}) {
+	const seen = /* @__PURE__ */ new Set();
+	const closers = [];
+	let closed = false;
+	let eoseFired = false;
+	let 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;
+		}
+		opts.oneose?.();
+	};
+	const markEose = (jobIndex, url) => {
+		const key = `${jobIndex}:${url}`;
+		if (eoseDone.has(key)) return;
+		eoseDone.add(key);
+		pendingEose -= 1;
+		if (pendingEose === 0) 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);
+		opts.onclose?.(reason ?? "closed by client");
+	};
+	if (opts.signal?.aborted) {
+		closed = true;
+		opts.onclose?.("aborted");
+		return { close: closeAll };
+	}
+	opts.signal?.addEventListener("abort", () => closeAll("aborted"), { once: true });
+	const attach = (relay, job, jobIndex) => {
+		if (closed) return;
+		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,
+			onevent: (event) => {
+				seen.add(event.id);
+				opts.onevent?.(event);
+			},
+			oneose: () => markEose(jobIndex, relay.url),
+			onclose: (reason) => {
+				markEose(jobIndex, relay.url);
+				pending -= 1;
+				if (pending <= 0 && !closed) {
+					settleClose();
+					opts.onclose?.(reason);
+				}
+			}
+		});
+		closers.push(sub);
+	};
+	for (let jobIndex = 0; jobIndex < jobs.length; jobIndex++) {
+		const job = jobs[jobIndex];
+		for (const url of job.urls) {
+			let key;
+			try {
+				key = normalizeURL(url);
+			} catch {
+				key = url;
+			}
+			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();
+						return;
+					}
+					throw err;
+				}
+			};
+			pool.ensureRelay(url, {
+				signal: opts.signal,
+				timeoutMs: opts.connectTimeoutMs
+			}).then((relay) => tryAttach(relay), () => {
+				const relay = pool.getRelay(key);
+				if (relay) {
+					tryAttach(relay);
+					return;
+				}
+				failUrl();
+			});
+		}
+	}
+	if (opts.eoseTimeoutMs !== void 0 && pending > 0) eoseTimer = setTimeout(() => {
+		eoseTimer = void 0;
+		fireEose();
+	}, opts.eoseTimeoutMs);
+	if (pending === 0) queueMicrotask(() => {
+		if (closed) return;
+		settleClose();
+		opts.onclose?.("no relays");
+	});
+	return { close: closeAll };
+}
+async function fetchRouted(pool, jobs, opts = {}) {
+	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
+			});
+			for (const event of batch) if (!byId.has(event.id)) byId.set(event.id, event);
+		} catch {}
+	})));
+	return [...byId.values()];
+}
+//#endregion
+//#region src/relay/pool.ts
+/**
+* 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;
+	constructor(opts = {}) {
+		this.#opts = opts;
+		this.#allowInsecure = opts.allowInsecure ?? true;
+		this.#trustedInsecure = new Set((opts.trustedInsecureUrls ?? []).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));
+	}
+	cleanIdleRelays() {
+		if (this.#idleTimeoutMs <= 0) return;
+		const now = Date.now();
+		const idle = [];
+		for (const [url, relay] of this.#relays) {
+			if (relay.subscriptionCount > 0) 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);
+	}
+	#touch(url) {
+		this.#lastActivity.set(url, Date.now());
+	}
+	#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;
+	}
+	async ensureRelay(url, opts) {
+		const norm = normalizeURL(url);
+		this.#rejectInsecure(url, norm);
+		let relay = this.#relays.get(norm);
+		if (!relay) {
+			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);
+			};
+			if (signFn) created.onauth = () => {
+				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 (err) {
+			if (!this.#opts.enableReconnect) {
+				this.#relays.delete(norm);
+				this.#lastActivity.delete(norm);
+			}
+			throw err;
+		}
+		return relay;
+	}
+	close(urls) {
+		if (!urls) {
+			this.#stopIdleCleanup();
+			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);
+			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);
+		filters = canonicalizeFilters(filters);
+		return fanIn(this, [{
+			urls: relays,
+			filters,
+			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
+		});
+	}
+	/** 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
+		});
+	}
+	/** 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 (err) {
+				return {
+					url,
+					error: err instanceof Error ? err.message : String(err)
+				};
+			}
+		}));
+	}
+	/** 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) {
+		filters = 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(filters, {
+					timeoutMs: opts?.timeoutMs,
+					signal: opts?.signal
+				});
+				return {
+					url: relay.url,
+					count: payload.count,
+					approximate: payload.approximate,
+					hll: payload.hll
+				};
+			} catch (err) {
+				return {
+					url,
+					error: err instanceof Error ? err.message : String(err)
+				};
+			}
+		}));
+	}
+	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, 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