@qntx/nostr 0.6.0 → 0.8.0

package/dist/relay-quCs7MHD.mjs

@@ -0,0 +1,1811 @@
+import { _ as MessageError, b as WasmPoisonedError, u as normalizeURL, v as NostrError } from "./util-DMF9AIO0.mjs";
+import { n as verifyEvent } from "./verifier-B51Wkt5H.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-oNr7t0SJ.mjs";
+import { t as NoSignerError } from "./error-DlhGW4mJ.mjs";
+import { t as invokeSafely } from "./report-CHld4uWj.mjs";
+import { isAuthRequired, makeAuthEvent } from "./nips/nip42.mjs";
+import { i as throwIfAborted, n as onAbort, r as raceSignal, t as abortReason } from "./abort-DBq2STPj.mjs";
+import { t as Emitter } from "./emitter-DkCY6NkU.mjs";
+import { Nip77Error, runNegSession } from "./nips/nip77.mjs";
+//#region src/relay/error.ts
+/** Base class for relay errors; carries the relay URL when known. */
+var RelayError = class extends NostrError {
+	name = "RelayError";
+	url;
+	constructor(message, url, options) {
+		super(url !== void 0 && url !== "" ? `${message} (${url})` : message, options);
+		this.url = url;
+	}
+};
+/** A relay connection attempt or socket failed. */
+var RelayConnectionError = class extends RelayError {
+	name = "RelayConnectionError";
+};
+/** A relay answered an EVENT with `ok: false`. */
+var RelayPublishError = class extends RelayError {
+	name = "RelayPublishError";
+};
+/** A subscription was closed by the relay (`CLOSED`) or the socket dropped. */
+var RelayClosedError = class extends RelayError {
+	name = "RelayClosedError";
+};
+/** A relay operation exceeded its deadline. */
+var RelayTimeoutError = class extends RelayError {
+	name = "RelayTimeoutError";
+};
+/**
+* A relay was suspended for delivering more events that fail id/signature verification than its
+* {@link PoolOptions.invalidEventPolicy} allows. Carries `until`, the epoch-ms time when the relay
+* may connect again.
+*/
+var RelaySuspendedError = class extends RelayError {
+	name = "RelaySuspendedError";
+	/** Epoch milliseconds when the suspension lifts. */
+	until;
+	constructor(url, until) {
+		super("relay suspended for delivering invalid events", url);
+		this.until = until;
+	}
+};
+//#endregion
+//#region src/relay/websocket.ts
+let impl;
+try {
+	if (globalThis.WebSocket !== void 0) impl = globalThis.WebSocket;
+} catch {}
+/** Inject a WebSocket implementation (required on Node unless undici/global is present). */
+function useWebSocketImplementation(websocketImplementation) {
+	impl = websocketImplementation;
+}
+function getWebSocketImplementation() {
+	if (!impl) throw new RelayConnectionError("No WebSocket implementation available; call useWebSocketImplementation() or run in a browser");
+	return impl;
+}
+//#endregion
+//#region src/relay/auth.ts
+var RelayAuth = class {
+	#challenge;
+	#authedChallenge;
+	/** Challenge value already answered on this connection; duplicates are not re-signed. */
+	#answeredChallenge;
+	/** Settled OK verdict for `#answeredChallenge`; set only once the relay replies. */
+	#answeredResult;
+	#authPromise;
+	#url;
+	#isOpen;
+	#sendAuth;
+	#defaultTimeoutMs;
+	constructor(deps) {
+		this.#url = deps.url;
+		this.#isOpen = deps.isOpen;
+		this.#sendAuth = deps.sendAuth;
+		this.#defaultTimeoutMs = deps.defaultTimeoutMs;
+	}
+	/** Latest NIP-42 challenge, if any. */
+	get challenge() {
+		return this.#challenge;
+	}
+	/**
+	* A re-sent identical challenge keeps the in-flight/settled dedupe; only a new challenge value
+	* resets the answer state.
+	*/
+	handleChallenge(challenge) {
+		if (challenge !== this.#challenge) {
+			this.#authPromise = void 0;
+			this.#authedChallenge = void 0;
+			this.#answeredChallenge = void 0;
+			this.#answeredResult = void 0;
+		}
+		this.#challenge = challenge;
+	}
+	/** New connection: challenge and answer state belong to the old socket. */
+	resetConnection() {
+		this.#challenge = void 0;
+		this.#authPromise = void 0;
+		this.#authedChallenge = void 0;
+		this.#answeredChallenge = void 0;
+		this.#answeredResult = void 0;
+	}
+	/** Sign the current challenge and wait for OK. */
+	async auth(sign, opts) {
+		const challenge = this.#challenge;
+		if (challenge === void 0 || challenge === "") throw new RelayError("no AUTH challenge received from relay", this.#url);
+		if (this.#authPromise) return this.#authPromise;
+		if (this.#answeredChallenge === challenge && this.#answeredResult !== void 0) return this.#answeredResult;
+		const pending = (async () => {
+			const template = makeAuthEvent(this.#url, challenge);
+			let event;
+			try {
+				event = await sign(template);
+			} catch (error) {
+				if (error instanceof NoSignerError) return {
+					ok: false,
+					message: "auth: no signer"
+				};
+				throw error;
+			}
+			if (!this.#isOpen()) throw new RelayClosedError("not connected", this.#url);
+			const result = await this.#sendAuth(event, opts?.timeoutMs ?? this.#defaultTimeoutMs);
+			if (this.#challenge === challenge) {
+				this.#answeredChallenge = challenge;
+				this.#answeredResult = result;
+			}
+			return result;
+		})();
+		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(signer) {
+		if (!signer) return false;
+		for (let i = 0; i < 3; i++) {
+			if (this.#challenge === void 0 || this.#challenge === "") return false;
+			if (this.#authedChallenge === this.#challenge) return true;
+			const signed = this.#challenge;
+			const result = await this.auth(signer);
+			if (this.#authedChallenge === this.#challenge) return true;
+			if (!result.ok) {
+				if (this.#challenge === void 0 || this.#challenge === "" || this.#challenge === signed) return false;
+				continue;
+			}
+		}
+		return this.#authedChallenge === this.#challenge;
+	}
+	/**
+	* Clear a cached AUTH rejection for the current challenge (a successful auth and in-flight
+	* answers are kept) and return the unanswered challenge to re-emit, if any.
+	*/
+	resetRejection() {
+		if (this.#answeredResult !== void 0 && !this.#answeredResult.ok) {
+			this.#answeredChallenge = void 0;
+			this.#answeredResult = void 0;
+		}
+		if (this.#challenge !== void 0 && this.#challenge !== this.#authedChallenge) return this.#challenge;
+	}
+};
+//#endregion
+//#region src/relay/count-tracker.ts
+/**
+* COUNT request correlation: one waiter per request id with a timeout, abort cleanup and a re-send
+* after AUTH.
+*/
+var CountTracker = class {
+	#entries = /* @__PURE__ */ new Map();
+	get size() {
+		return this.#entries.size;
+	}
+	get(id) {
+		return this.#entries.get(id);
+	}
+	/**
+	* Register a waiter, wire the abort listener, arm its timeout and call `send`. A send throw
+	* rejects (`sendError` when the throw is not an Error). resolve/reject unwind the timer, abort
+	* listener and map entry.
+	*/
+	async track(id, opts) {
+		return new Promise((resolve, reject) => {
+			const waiter = {
+				id,
+				resolve: (result) => {
+					this.#finish(waiter);
+					cleanup();
+					resolve(result);
+				},
+				reject: (err) => {
+					this.#finish(waiter);
+					cleanup();
+					reject(err);
+				},
+				timer: void 0,
+				filters: opts.filters,
+				authRetried: false,
+				timeoutMs: opts.timeoutMs,
+				timeoutError: opts.timeoutError
+			};
+			const cleanup = onAbort(opts.signal, () => {
+				if (opts.signal !== void 0) waiter.reject(abortReason(opts.signal));
+			});
+			waiter.timer = setTimeout(() => {
+				waiter.reject(opts.timeoutError());
+			}, opts.timeoutMs);
+			this.#entries.set(id, waiter);
+			try {
+				opts.send();
+			} catch (error) {
+				waiter.reject(error instanceof Error ? error : opts.sendError());
+			}
+		});
+	}
+	/** Stop a waiter's timeout without settling (AUTH retry window). */
+	clearTimer(waiter) {
+		if (waiter.timer !== void 0) {
+			clearTimeout(waiter.timer);
+			waiter.timer = void 0;
+		}
+	}
+	/** Re-arm the timeout for a re-sent COUNT (after an AUTH retry). */
+	restartTimer(id) {
+		const waiter = this.#entries.get(id);
+		if (waiter === void 0) return;
+		waiter.timer = setTimeout(() => {
+			waiter.reject(waiter.timeoutError());
+		}, waiter.timeoutMs);
+	}
+	/**
+	* Re-send a COUNT after the relay demanded AUTH: pause the timeout through the AUTH window,
+	* re-arm it and re-send on success, reject on failure.
+	*/
+	async authRetry(waiter, deps) {
+		this.clearTimer(waiter);
+		try {
+			const ok = await deps.ensureAuthed();
+			if (this.#entries.get(waiter.id) !== waiter) return;
+			if (!ok || !deps.isOpen()) {
+				waiter.reject(deps.failError());
+				return;
+			}
+			this.restartTimer(waiter.id);
+			deps.send();
+		} catch (error) {
+			if (this.#entries.get(waiter.id) === void 0) return;
+			waiter.reject(error instanceof Error ? error : deps.failError());
+		}
+	}
+	rejectAll(err) {
+		for (const waiter of this.#entries.values()) {
+			this.clearTimer(waiter);
+			waiter.reject(err);
+		}
+		this.#entries.clear();
+	}
+	#finish(waiter) {
+		this.clearTimer(waiter);
+		this.#entries.delete(waiter.id);
+	}
+};
+//#endregion
+//#region src/relay/subscription.ts
+/**
+* Internal REQ runtime: owns its lifecycle flags, watermark bookkeeping and handler dispatch.
+* `onLocalClose` is supplied by the registry — it sends CLOSE / detaches from a live group — and is
+* invoked by {@link close} only, never by {@link end}.
+*/
+var Subscription = class {
+	id;
+	filters;
+	closeOnEose;
+	#handlers;
+	#onLocalClose;
+	#abortDispose;
+	#eoseTimer;
+	#closed = false;
+	#eosed = 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();
+	constructor(filters, opts, onLocalClose) {
+		this.#onLocalClose = onLocalClose;
+		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.eoseTimeoutMs !== void 0) this.#eoseTimer = setTimeout(() => {
+			this.#eoseTimer = void 0;
+			this.markEose();
+		}, opts.eoseTimeoutMs);
+		if (opts.signal) {
+			if (opts.signal.aborted) this.close("aborted");
+			else this.#abortDispose = onAbort(opts.signal, () => this.close("aborted"));
+		}
+	}
+	get closed() {
+		return this.#closed;
+	}
+	get eosed() {
+		return this.#eosed;
+	}
+	get lastCreatedAt() {
+		return this.#lastCreatedAt;
+	}
+	get idsAtWatermark() {
+		return this.#idsAtWatermark;
+	}
+	/**
+	* Local close: idempotent; clears the EOSE timer and abort listener, detaches via `onLocalClose`
+	* (sends CLOSE / leaves the live group), then fires `onclose`.
+	*/
+	close(reason = "closed by client") {
+		if (this.#closed) return;
+		this.#closed = true;
+		this.#teardown();
+		this.#onLocalClose(this);
+		invokeSafely(() => this.#handlers.onclose?.(reason));
+	}
+	/** Remote/transport termination: like {@link close} but `onLocalClose` is not called. */
+	end(reason) {
+		if (this.#closed) return;
+		this.#closed = true;
+		this.#teardown();
+		invokeSafely(() => this.#handlers.onclose?.(reason));
+	}
+	#teardown() {
+		if (this.#eoseTimer !== void 0) {
+			clearTimeout(this.#eoseTimer);
+			this.#eoseTimer = void 0;
+		}
+		this.#abortDispose?.();
+		this.#abortDispose = void 0;
+	}
+	/** Mark EOSE: fires `oneose`, then closes when `closeOnEose`. No-op when closed or EOSE'd. */
+	markEose() {
+		if (this.#closed || this.#eosed) return;
+		this.#eosed = true;
+		if (this.#eoseTimer !== void 0) {
+			clearTimeout(this.#eoseTimer);
+			this.#eoseTimer = void 0;
+		}
+		invokeSafely(() => this.#handlers.oneose?.());
+		if (this.closeOnEose) this.close("eose");
+	}
+	/** Clear `eosed` for a replayed REQ (AUTH retry / reconnect). */
+	rearm() {
+		this.#eosed = false;
+	}
+	/** First `auth-required:` retry wins; later calls report false without side effects. */
+	beginAuthRetry() {
+		if (this.#authRetried) return false;
+		this.#authRetried = true;
+		return true;
+	}
+	resetAuthRetry() {
+		this.#authRetried = false;
+	}
+	/** `receivedEvent` for every EVENT id, before watermark/alreadyHaveEvent/verify. */
+	notifyReceived(id) {
+		invokeSafely(() => this.#handlers.receivedEvent?.(id));
+	}
+	alreadyHas(id) {
+		let have = false;
+		invokeSafely(() => {
+			have = Boolean(this.#handlers.alreadyHaveEvent?.(id));
+		});
+		return have;
+	}
+	isAtWatermark(id) {
+		return this.#idsAtWatermark.has(id);
+	}
+	/** Verified event: advance the watermark, then fire `onevent`. */
+	deliver(event) {
+		this.noteVerified(event);
+		invokeSafely(() => this.#handlers.onevent?.(event));
+	}
+	/** 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 head = 0;
+	let done = false;
+	let error;
+	let wake;
+	let closer;
+	let localClose = false;
+	let disposeAbort;
+	const notify = () => {
+		wake?.();
+		wake = void 0;
+	};
+	const waitForWake = async () => new Promise((resolve) => {
+		wake = resolve;
+	});
+	const closeLocal = (reason) => {
+		localClose = true;
+		disposeAbort?.();
+		closer?.close(reason);
+		done = true;
+		notify();
+	};
+	closer = start({
+		onevent(event) {
+			queue.push(event);
+			notify();
+		},
+		oneose() {
+			if (opts?.includeEose === false) closeLocal("eose");
+		},
+		onclose(reason) {
+			if (opts?.signal?.aborted === true) localClose = true;
+			if (!localClose && reason) error = new RelayClosedError(reason);
+			done = true;
+			notify();
+		}
+	});
+	if (opts?.signal) {
+		if (opts.signal.aborted) closeLocal("aborted");
+		else {
+			disposeAbort = onAbort(opts.signal, () => closeLocal("aborted"));
+			if (done) disposeAbort();
+		}
+	}
+	return {
+		close(reason) {
+			closeLocal(reason ?? "closed by client");
+		},
+		[Symbol.asyncIterator]() {
+			return {
+				async next() {
+					while (true) {
+						const value = head < queue.length ? queue[head] : void 0;
+						if (value !== void 0) {
+							head += 1;
+							if (head === queue.length) {
+								queue.length = 0;
+								head = 0;
+							}
+							return {
+								value,
+								done: false
+							};
+						}
+						if (error !== void 0) throw error;
+						if (done) return {
+							value: void 0,
+							done: true
+						};
+						await waitForWake();
+					}
+				},
+				async return() {
+					closeLocal("iterator returned");
+					return {
+						value: void 0,
+						done: true
+					};
+				}
+			};
+		}
+	};
+}
+//#endregion
+//#region src/relay/fetch.ts
+function streamFilters(subscribe, filters, opts) {
+	return subscriptionToAsyncIterable((handlers) => subscribe(filters, {
+		...handlers,
+		id: opts?.id,
+		signal: opts?.signal
+	}), { signal: opts?.signal });
+}
+async function fetchFilters(subscribe, filters, opts) {
+	throwIfAborted(opts.signal);
+	const events = [];
+	const seen = /* @__PURE__ */ new Set();
+	let end = { type: "timeout" };
+	await new Promise((resolve, reject) => {
+		let settled = false;
+		const done = (err) => {
+			if (settled) return;
+			settled = true;
+			disposeAbort();
+			clearTimeout(timer);
+			let reason = "aborted";
+			if (err instanceof Error) reason = err.message;
+			else if (err === void 0) reason = "fetch complete";
+			sub.close(reason);
+			if (err === void 0) resolve();
+			else reject(err);
+		};
+		const disposeAbort = onAbort(opts.signal, () => {
+			if (opts.signal !== void 0) done(abortReason(opts.signal));
+		});
+		const timer = setTimeout(() => {
+			end = { type: "timeout" };
+			done();
+		}, opts.timeoutMs);
+		const sub = subscribe(filters, {
+			id: opts.id,
+			signal: opts.signal,
+			closeOnEose: true,
+			onevent(event) {
+				if (seen.has(event.id)) return;
+				seen.add(event.id);
+				events.push(event);
+			},
+			oneose() {
+				end = { type: "eose" };
+				done();
+			},
+			onclose(reason) {
+				if (settled) return;
+				if (opts.signal?.aborted === true) {
+					done(abortReason(opts.signal));
+					return;
+				}
+				end = {
+					type: "closed",
+					reason
+				};
+				done();
+			}
+		});
+	});
+	return {
+		events,
+		end
+	};
+}
+//#endregion
+//#region src/relay/neg-session.ts
+function createNegSession() {
+	return {
+		queue: [],
+		waiter: void 0,
+		error: void 0
+	};
+}
+function pushNegMsg(session, hex) {
+	if (session.waiter) {
+		const { waiter } = session;
+		session.waiter = void 0;
+		waiter.resolve(hex);
+	} else session.queue.push(hex);
+}
+function failNegSession(session, err) {
+	session.error = err;
+	if (session.waiter) {
+		const { waiter } = session;
+		session.waiter = void 0;
+		waiter.reject(err);
+	}
+}
+function failNegErr(session, reason) {
+	failNegSession(session, new Nip77Error(reason));
+}
+/** Route a NEG-MSG/NEG-ERR frame to its session; unknown ids are ignored. */
+function dispatchNegMessage(sessions, msg) {
+	const session = sessions.get(msg[1]);
+	if (session === void 0) return;
+	if (msg[0] === "NEG-MSG") {
+		pushNegMsg(session, msg[2]);
+		return;
+	}
+	failNegErr(session, msg[2]);
+}
+/** Fail every tracked session (socket teardown). */
+function failAllNegSessions(sessions, err) {
+	for (const session of sessions.values()) failNegSession(session, err);
+	sessions.clear();
+}
+/** Wire queue/timeout/abort around `runNegSession`. Not a second session class. */
+async function runWiredNegSession(opts) {
+	const { session, storage, filter, id, timeoutMs, signal, send, url } = opts;
+	const deadline = Date.now() + timeoutMs;
+	const timedOut = () => new RelayTimeoutError("negentropy timed out", url);
+	const remainingMs = () => deadline - Date.now();
+	const next = async () => {
+		if (session.error !== void 0) throw session.error;
+		if (remainingMs() <= 0) throw timedOut();
+		const queued = session.queue.shift();
+		if (queued !== void 0) return queued;
+		return new Promise((resolve, reject) => {
+			const timer = setTimeout(() => {
+				session.waiter = void 0;
+				disposeAbort();
+				reject(timedOut());
+			}, remainingMs());
+			const fail = (err) => {
+				clearTimeout(timer);
+				session.waiter = void 0;
+				disposeAbort();
+				reject(err);
+			};
+			session.waiter = {
+				resolve: (hex) => {
+					clearTimeout(timer);
+					disposeAbort();
+					resolve(hex);
+				},
+				reject: (err) => fail(err)
+			};
+			const disposeAbort = onAbort(signal, () => {
+				if (signal) fail(abortReason(signal));
+			});
+		});
+	};
+	return runNegSession({
+		storage,
+		openingSend: (hex) => {
+			send([
+				"NEG-OPEN",
+				id,
+				filter,
+				hex
+			]);
+		},
+		msgSend: (hex) => {
+			send([
+				"NEG-MSG",
+				id,
+				hex
+			]);
+		},
+		next
+	});
+}
+/**
+* Drive a NIP-77 reconcile session against the session map: fail a same-id predecessor, register,
+* wire queue/timeout/abort, and send NEG-CLOSE on exit.
+*/
+async function runTrackedNegSession(opts) {
+	const { sessions, id, send } = opts;
+	const prev = sessions.get(id);
+	if (prev) failNegSession(prev, new Nip77Error("closed: replaced by new NEG-OPEN"));
+	const session = createNegSession();
+	sessions.set(id, session);
+	try {
+		return await runWiredNegSession({
+			session,
+			storage: opts.storage,
+			filter: opts.filter,
+			id,
+			timeoutMs: opts.timeoutMs,
+			signal: opts.signal,
+			send,
+			url: opts.url
+		});
+	} finally {
+		if (sessions.get(id) === session) {
+			sessions.delete(id);
+			try {
+				send(["NEG-CLOSE", id]);
+			} catch {}
+		}
+	}
+}
+//#endregion
+//#region src/relay/ok-tracker.ts
+var OkTracker = class {
+	#entries = /* @__PURE__ */ new Map();
+	get size() {
+		return this.#entries.size;
+	}
+	get(eventId) {
+		return this.#entries.get(eventId);
+	}
+	/** Joiner's view: only publish waiters (carrying an `event`) are joinable. */
+	inFlight(eventId) {
+		const waiter = this.#entries.get(eventId);
+		return waiter?.event === void 0 ? void 0 : waiter.promise;
+	}
+	/**
+	* Register a waiter, arm its timeout and call `send`. A send throw removes the entry and rejects
+	* (`sendError` when the throw is not an Error). The timer only rejects while this waiter still
+	* owns the id.
+	*/
+	async track(eventId, opts) {
+		const promise = new Promise((resolve, reject) => {
+			const waiter = {
+				id: eventId,
+				resolve,
+				reject,
+				timer: setTimeout(() => {
+					if (this.#entries.get(eventId) === waiter) {
+						this.#entries.delete(eventId);
+						reject(opts.timeoutError());
+					}
+				}, opts.timeoutMs),
+				event: opts.event,
+				authRetried: false,
+				timeoutMs: opts.timeoutMs,
+				timeoutError: opts.timeoutError,
+				get promise() {
+					return promise;
+				}
+			};
+			this.#entries.set(eventId, waiter);
+			try {
+				opts.send();
+			} catch (error) {
+				this.#finish(waiter);
+				reject(error instanceof Error ? error : opts.sendError());
+			}
+		});
+		return promise;
+	}
+	/**
+	* An OK reply arrived: `retry` is the caller's auth-required policy — a kept waiter is returned
+	* unsettled for the retry path; otherwise the entry is settled and undefined is returned.
+	*/
+	handleOk(eventId, ok, message, retry) {
+		const waiter = this.#entries.get(eventId);
+		if (waiter === void 0) return;
+		if (!retry(waiter)) {
+			this.settle(waiter, {
+				ok,
+				message
+			});
+			return;
+		}
+		return waiter;
+	}
+	/** Settle a waiter: stop its timer, drop the entry it still owns, then resolve. */
+	settle(waiter, result) {
+		this.#finish(waiter);
+		waiter.resolve(result);
+	}
+	/** Stop a waiter's timeout without settling (AUTH retry window). */
+	clearTimer(waiter) {
+		if (waiter.timer !== void 0) {
+			clearTimeout(waiter.timer);
+			waiter.timer = void 0;
+		}
+	}
+	/** Re-arm the timeout for a re-sent frame (after an AUTH retry). */
+	restartTimer(eventId) {
+		const waiter = this.#entries.get(eventId);
+		if (waiter === void 0) return;
+		waiter.timer = setTimeout(() => {
+			if (this.#entries.get(eventId) === waiter) {
+				this.#entries.delete(eventId);
+				waiter.reject(waiter.timeoutError());
+			}
+		}, waiter.timeoutMs);
+	}
+	/**
+	* Re-send a tracked EVENT after the relay demanded AUTH: pause the timeout through the AUTH
+	* window, re-arm it and re-send on success, settle `{ok:false,message}` on failure. AUTH waiters
+	* (no `event`) settle immediately.
+	*/
+	async authRetry(waiter, message, deps) {
+		this.clearTimer(waiter);
+		const finish = (result) => {
+			this.settle(waiter, result);
+		};
+		try {
+			const { event } = waiter;
+			if (event === void 0) {
+				finish({
+					ok: false,
+					message
+				});
+				return;
+			}
+			const ok = await deps.ensureAuthed();
+			if (this.#entries.get(waiter.id) !== waiter) return;
+			if (!ok || !deps.isOpen()) {
+				finish({
+					ok: false,
+					message
+				});
+				return;
+			}
+			this.restartTimer(waiter.id);
+			deps.send(event);
+		} catch {
+			if (this.#entries.get(waiter.id) === void 0) return;
+			finish({
+				ok: false,
+				message
+			});
+		}
+	}
+	rejectAll(err) {
+		for (const waiter of this.#entries.values()) {
+			this.clearTimer(waiter);
+			waiter.reject(err);
+		}
+		this.#entries.clear();
+	}
+	#finish(waiter) {
+		this.clearTimer(waiter);
+		if (this.#entries.get(waiter.id) === waiter) this.#entries.delete(waiter.id);
+	}
+};
+const PING_DUMMY_FILTER = {
+	ids: ["a".repeat(64)],
+	limit: 0
+};
+/** Browser WebSocket and `ws` both use 1 for OPEN. */
+const WS_OPEN = 1;
+/** Node `ws` delivers `pong` on the EventEmitter, not via addEventListener. */
+function canNativePing(ws) {
+	return typeof ws.ping === "function" && (typeof ws.once === "function" || typeof ws.on === "function");
+}
+/** REQ-dummy or native ping/pong keepalive. Does not import class Relay. */
+var PingLoop = class {
+	#opts;
+	#timer;
+	#waiters = /* @__PURE__ */ new Map();
+	#gen = 0;
+	#nativePing;
+	constructor(opts) {
+		this.#opts = opts;
+	}
+	start() {
+		this.stop();
+		this.#timer = setInterval(() => {
+			this.#pingpong();
+		}, this.#opts.pingIntervalMs);
+	}
+	stop() {
+		if (this.#timer !== void 0) {
+			clearInterval(this.#timer);
+			this.#timer = void 0;
+		}
+		this.#abortCurrentPing();
+	}
+	hasWaiter(id) {
+		return this.#waiters.has(id);
+	}
+	finishDummyPing(id) {
+		const waiter = this.#waiters.get(id);
+		if (!waiter) return false;
+		this.#waiters.delete(id);
+		waiter.resolve(true);
+		try {
+			this.#opts.send(["CLOSE", id]);
+		} catch {}
+		return true;
+	}
+	#abortCurrentPing() {
+		this.#gen += 1;
+		const native = this.#nativePing;
+		this.#nativePing = void 0;
+		native?.abort();
+		for (const waiter of this.#waiters.values()) waiter.resolve(false);
+		this.#waiters.clear();
+	}
+	async #pingpong() {
+		const ws = this.#opts.getWs();
+		if (!ws || ws.readyState !== WS_OPEN) return;
+		if (this.#nativePing !== void 0 || this.#waiters.size > 0) return;
+		const gen = this.#gen;
+		const ping = canNativePing(ws) ? this.#waitForNativePing(ws) : this.#waitForDummyPing();
+		const ok = await new Promise((resolve) => {
+			let settled = false;
+			const done = (alive) => {
+				if (settled) return;
+				settled = true;
+				clearTimeout(timer);
+				resolve(alive);
+			};
+			const timer = setTimeout(() => {
+				if (this.#nativePing !== void 0 || this.#waiters.size > 0) done(false);
+			}, this.#opts.pingTimeoutMs);
+			(async () => {
+				done(await ping);
+			})();
+		});
+		if (gen !== this.#gen) return;
+		if (!ok) {
+			this.#abortCurrentPing();
+			this.#opts.closeWs();
+		}
+	}
+	async #waitForNativePing(ws) {
+		return new Promise((resolve) => {
+			let settled = false;
+			const finish = (alive) => {
+				if (settled) return;
+				settled = true;
+				this.#nativePing = void 0;
+				ws.off?.("pong", onPong);
+				resolve(alive);
+			};
+			const onPong = () => finish(true);
+			this.#nativePing = { abort: () => finish(false) };
+			if (typeof ws.on === "function" && typeof ws.off === "function") ws.on("pong", onPong);
+			else if (typeof ws.once === "function") ws.once("pong", onPong);
+			else ws.on?.("pong", onPong);
+			try {
+				if (typeof ws.ping === "function") ws.ping();
+				else finish(false);
+			} catch {
+				finish(false);
+			}
+		});
+	}
+	async #waitForDummyPing() {
+		return new Promise((resolve) => {
+			const id = this.#opts.nextSubId("__ping__");
+			this.#waiters.set(id, { resolve });
+			try {
+				this.#opts.send([
+					"REQ",
+					id,
+					PING_DUMMY_FILTER
+				]);
+			} catch {
+				this.#waiters.delete(id);
+				resolve(false);
+			}
+		});
+	}
+};
+//#endregion
+//#region src/relay/subscription-registry.ts
+/**
+* Owns every open REQ of a relay: exclusive subscriptions keyed by id, and live coalescing groups
+* (one wire REQ plus per-subscriber handles) keyed by fingerprint and wire id.
+*/
+var SubscriptionRegistry = class {
+	#subs = /* @__PURE__ */ new Map();
+	#liveByFp = /* @__PURE__ */ new Map();
+	#liveBySubId = /* @__PURE__ */ new Map();
+	#isOpen;
+	#enableReconnect;
+	#send;
+	#scheduleReconnect;
+	#acceptEvent;
+	constructor(deps) {
+		this.#isOpen = deps.isOpen;
+		this.#enableReconnect = deps.enableReconnect;
+		this.#send = deps.send;
+		this.#scheduleReconnect = deps.scheduleReconnect;
+		this.#acceptEvent = deps.acceptEvent;
+	}
+	/** User subscriptions only; dummy ping REQs are not counted. */
+	get size() {
+		return this.#subs.size;
+	}
+	get(subId) {
+		return this.#subs.get(subId);
+	}
+	/** Exclusive one-shot REQ when `closeOnEose`, live coalescing otherwise. */
+	open(filters, opts) {
+		if (opts.closeOnEose === true) return this.#openExclusive(filters, opts);
+		return this.#openLive(filters, opts);
+	}
+	handleEvent(subId, event) {
+		const sub = this.#subs.get(subId);
+		if (!sub || sub.closed) return;
+		const group = this.#liveBySubId.get(subId);
+		if (group) {
+			this.#deliverLiveEvent(group, event);
+			return;
+		}
+		sub.notifyReceived(event.id);
+		if (sub.isAtWatermark(event.id)) return;
+		if (sub.alreadyHas(event.id)) return;
+		if (!this.#acceptEvent(event)) return;
+		sub.deliver(event);
+	}
+	handleEose(subId) {
+		const sub = this.#subs.get(subId);
+		if (!sub || sub.closed || sub.eosed) return;
+		const group = this.#liveBySubId.get(subId);
+		if (group) {
+			sub.markEose();
+			this.#deliverLiveEose(group);
+			return;
+		}
+		sub.markEose();
+	}
+	/** Remote/transport termination of a REQ (CLOSED, auth-retry failure). */
+	drop(sub, reason) {
+		const group = this.#liveBySubId.get(sub.id);
+		if (group) {
+			this.#endLiveGroup(group, {
+				sendClose: false,
+				reason
+			});
+			return;
+		}
+		this.#subs.delete(sub.id);
+		sub.end(reason);
+	}
+	/**
+	* Re-REQ after the relay demanded AUTH: drop the subscription when auth fails or the
+	* socket/subscription died during the AUTH window, replay the REQ on success.
+	*/
+	async authRetry(sub, reason, ensureAuthed) {
+		try {
+			if (!await ensureAuthed() || sub.closed || !this.#isOpen()) {
+				this.drop(sub, reason);
+				return;
+			}
+			this.replay(sub);
+		} catch {
+			this.drop(sub, reason);
+		}
+	}
+	/** Re-REQ after AUTH: rearm the wire and its handles, then send the replayed filters. */
+	replay(sub) {
+		sub.rearm();
+		const group = this.#liveBySubId.get(sub.id);
+		if (group) for (const att of group.attachments) att.rearm();
+		this.#send([
+			"REQ",
+			sub.id,
+			...sub.replayFilters()
+		]);
+	}
+	/** Reconnect path: rearm every open REQ and re-send; false on send failure. */
+	replayAll() {
+		for (const sub of this.#subs.values()) {
+			if (sub.closed) continue;
+			sub.rearm();
+			sub.resetAuthRetry();
+			const group = this.#liveBySubId.get(sub.id);
+			if (group) for (const att of group.attachments) {
+				att.rearm();
+				att.resetAuthRetry();
+			}
+			try {
+				this.#send([
+					"REQ",
+					sub.id,
+					...sub.replayFilters()
+				]);
+			} catch {
+				return false;
+			}
+		}
+		return true;
+	}
+	closeAll(reason) {
+		const groups = [...this.#liveBySubId.values()];
+		for (const group of groups) invokeSafely(() => {
+			this.#endLiveGroup(group, {
+				sendClose: false,
+				reason
+			});
+		});
+		for (const sub of this.#subs.values()) sub.end(reason);
+		this.#subs.clear();
+		this.#liveByFp.clear();
+		this.#liveBySubId.clear();
+	}
+	#openExclusive(filters, opts) {
+		const sub = new Subscription(filters, opts, (closed) => {
+			this.#subs.delete(closed.id);
+			try {
+				if (this.#isOpen()) this.#send(["CLOSE", closed.id]);
+			} catch {}
+		});
+		this.#subs.set(sub.id, sub);
+		if (this.#isOpen()) this.#send([
+			"REQ",
+			sub.id,
+			...filters
+		]);
+		else if (this.#enableReconnect) this.#scheduleReconnect();
+		return sub;
+	}
+	#openLive(filters, opts) {
+		const fp = filterFingerprint(filters);
+		let group = this.#liveByFp.get(fp);
+		if (group?.sub.eosed === true) group = void 0;
+		let created = false;
+		if (!group) {
+			created = true;
+			const slot = { group: void 0 };
+			const wire = new Subscription(filters, { id: opts.id }, () => {
+				const g = slot.group;
+				if (g) this.#endLiveGroup(g, {
+					sendClose: true,
+					reason: "closed by client"
+				});
+			});
+			group = {
+				fp,
+				sub: wire,
+				attachments: /* @__PURE__ */ new Set()
+			};
+			slot.group = group;
+			this.#liveByFp.set(fp, group);
+			this.#liveBySubId.set(wire.id, group);
+			this.#subs.set(wire.id, wire);
+		}
+		const slot = { handle: void 0 };
+		const attached = group;
+		const handle = new Subscription(filters, {
+			...opts,
+			id: group.sub.id
+		}, () => {
+			const current = slot.handle;
+			if (!current) return;
+			this.#detachLive(attached, current);
+		});
+		slot.handle = handle;
+		if (handle.closed) {
+			if (created && group.attachments.size === 0) this.#forgetLiveGroup(group, "closed by client");
+			return handle;
+		}
+		group.attachments.add(handle);
+		if (created) {
+			if (this.#isOpen()) this.#send([
+				"REQ",
+				group.sub.id,
+				...filters
+			]);
+			else if (this.#enableReconnect) this.#scheduleReconnect();
+		}
+		return handle;
+	}
+	#forgetLiveGroup(group, reason) {
+		if (this.#liveByFp.get(group.fp) === group) this.#liveByFp.delete(group.fp);
+		this.#liveBySubId.delete(group.sub.id);
+		this.#subs.delete(group.sub.id);
+		group.sub.end(reason);
+	}
+	#detachLive(group, handle) {
+		if (!group.attachments.delete(handle)) return;
+		if (group.attachments.size > 0) return;
+		this.#endLiveGroup(group, {
+			sendClose: true,
+			reason: "closed by client"
+		});
+	}
+	#endLiveGroup(group, opts) {
+		const { id } = group.sub;
+		const remaining = [...group.attachments];
+		group.attachments.clear();
+		this.#forgetLiveGroup(group, opts.reason);
+		if (opts.sendClose) try {
+			if (this.#isOpen()) this.#send(["CLOSE", id]);
+		} catch {}
+		for (const att of remaining) invokeSafely(() => {
+			att.close(opts.reason);
+		});
+	}
+	#deliverLiveEvent(group, event) {
+		const { sub } = group;
+		const attachments = [...group.attachments];
+		for (const att of attachments) att.notifyReceived(event.id);
+		if (sub.isAtWatermark(event.id)) return;
+		const recipients = [];
+		for (const att of attachments) {
+			if (att.closed) continue;
+			if (!att.alreadyHas(event.id)) recipients.push(att);
+		}
+		if (recipients.length === 0) return;
+		if (!this.#acceptEvent(event)) return;
+		sub.noteVerified(event);
+		for (const att of recipients) att.deliver(event);
+	}
+	#deliverLiveEose(group) {
+		const attachments = [...group.attachments];
+		for (const att of attachments) att.markEose();
+	}
+};
+//#endregion
+//#region src/relay/relay.ts
+/**
+* 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",
+	Connected: "connected",
+	Disconnected: "disconnected",
+	Closed: "closed"
+};
+const DEFAULT_REQUEST_TIMEOUT_MS = 4400;
+const DEFAULT_BACKOFF = [
+	1e3,
+	2e3,
+	5e3,
+	1e4,
+	2e4,
+	3e4,
+	6e4
+];
+const noop = () => {};
+/**
+* Single-relay NIP-01 client. Connection lifecycle, REQ/CLOSE, EVENT publish ACK, AUTH, COUNT,
+* NIP-77, optional reconnect.
+*/
+var Relay = class Relay {
+	url;
+	#ws;
+	#gen = 0;
+	#status = RelayStatus.Initialized;
+	#connecting;
+	#connectFinish;
+	#connectTimer;
+	#socketHandlers;
+	#subscriptions;
+	#ok = new OkTracker();
+	#countRequests = new CountTracker();
+	#authState;
+	#ensureAuthed;
+	#neg = /* @__PURE__ */ new Map();
+	#WS;
+	#verify;
+	#verifyDead = false;
+	#publishTimeoutMs;
+	#connectTimeoutMs;
+	#enableReconnect;
+	#backoff;
+	#serial = 0;
+	#authSigner;
+	/** `close()`/`disconnect()` was called; cleared by the next `connect()`. */
+	#manualStop = false;
+	#reconnectAttempts = 0;
+	#reconnectTimer;
+	#enablePing;
+	#ping;
+	#events = new Emitter();
+	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.#subscriptions = new SubscriptionRegistry({
+			isOpen: () => this.#isOpen(),
+			enableReconnect: this.#enableReconnect,
+			send: (message) => this.#send(message),
+			scheduleReconnect: () => this.#scheduleReconnect(),
+			acceptEvent: (event) => this.#acceptEvent(event)
+		});
+		this.#authState = new RelayAuth({
+			url: this.url,
+			isOpen: () => this.#isOpen(),
+			sendAuth: (event, timeoutMs) => this.#ok.track(event.id, {
+				timeoutMs,
+				timeoutError: () => new RelayTimeoutError("auth timed out", this.url),
+				sendError: () => new RelayPublishError("auth send failed", this.url),
+				send: () => this.#send(["AUTH", event])
+			}),
+			defaultTimeoutMs: this.#publishTimeoutMs
+		});
+		this.#ensureAuthed = this.#authState.ensureAuthed.bind(this.#authState, this.#authSigner);
+	}
+	/** Latest NIP-42 challenge, if any. */
+	get challenge() {
+		return this.#authState.challenge;
+	}
+	get 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;
+	}
+	get reconnectEnabled() {
+		return this.#enableReconnect;
+	}
+	/** User subscriptions only; dummy ping REQs are not counted. */
+	get subscriptionCount() {
+		return this.#subscriptions.size;
+	}
+	/** One-shot requests still awaiting a relay reply (EVENT ACK, COUNT, NEG). */
+	get inFlightCount() {
+		return this.#ok.size + this.#countRequests.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) {
+		return this.#events.on(type, listener);
+	}
+	static async connect(url, opts) {
+		const relay = new Relay(url, opts);
+		await relay.connect({ signal: opts?.signal });
+		return relay;
+	}
+	async connect(opts) {
+		if (this.#isOpen()) return;
+		if (this.#connecting) {
+			await raceSignal(this.#connecting, opts?.signal);
+			return;
+		}
+		throwIfAborted(opts?.signal);
+		const gen = ++this.#gen;
+		this.#manualStop = false;
+		this.#clearReconnectTimer();
+		this.#setStatus(RelayStatus.Connecting);
+		const timeoutMs = opts?.timeoutMs ?? this.#connectTimeoutMs;
+		let resolveConnect = noop;
+		let rejectConnect = noop;
+		let settled = false;
+		let ws;
+		const connecting = new Promise((resolve, reject) => {
+			resolveConnect = resolve;
+			rejectConnect = reject;
+		});
+		const release = () => {
+			if (ws === void 0) return;
+			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();
+			} catch {}
+			if (this.#ws === ws) this.#ws = void 0;
+		};
+		const guarded = (fn) => {
+			return () => {
+				if (gen !== this.#gen) {
+					release();
+					return;
+				}
+				fn();
+			};
+		};
+		const finish = (err) => {
+			if (settled) return;
+			settled = true;
+			clearTimeout(timer);
+			if (this.#connectTimer === timer) this.#connectTimer = void 0;
+			if (this.#connectFinish === finish) this.#connectFinish = void 0;
+			if (this.#connecting === connecting) this.#connecting = void 0;
+			if (err === void 0) resolveConnect();
+			else rejectConnect(err);
+		};
+		this.#connecting = connecting;
+		this.#connectFinish = finish;
+		const timer = setTimeout(guarded(() => {
+			release();
+			finish(new RelayTimeoutError("connection timed out", this.url));
+			if (gen === this.#gen) this.#handleSocketDeath("connection timed out", {
+				fromConnectAttempt: true,
+				gen
+			});
+		}), timeoutMs);
+		this.#connectTimer = timer;
+		try {
+			ws = new this.#WS(this.url);
+		} catch (error) {
+			finish(error);
+			if (gen === this.#gen) this.#handleSocketDeath("connection failed", {
+				fromConnectAttempt: true,
+				gen
+			});
+			await raceSignal(connecting, opts?.signal);
+			return;
+		}
+		this.#ws = ws;
+		const onOpen = guarded(() => {
+			this.#setStatus(RelayStatus.Connected);
+			const wasReconnect = this.#reconnectAttempts > 0;
+			this.#authState.resetConnection();
+			if (!this.#subscriptions.replayAll()) {
+				this.#setStatus(RelayStatus.Disconnected);
+				release();
+				finish(new RelayConnectionError("connection failed", this.url));
+				if (this.#enableReconnect && !this.#manualStop && this.#subscriptions.size > 0) this.#scheduleReconnect();
+				return;
+			}
+			this.#reconnectAttempts = 0;
+			if (this.#enablePing) this.#ping.start();
+			else this.#ping.stop();
+			if (wasReconnect) this.#events.emit("reconnect", void 0);
+			finish();
+		});
+		const onError = guarded(() => {
+			const fromConnectAttempt = !settled;
+			release();
+			finish(new RelayConnectionError("connection failed", this.url));
+			if (gen === this.#gen) this.#handleSocketDeath("connection failed", {
+				fromConnectAttempt,
+				gen
+			});
+		});
+		const onClose = guarded(() => {
+			const fromConnectAttempt = !settled;
+			release();
+			if (fromConnectAttempt) finish(new RelayConnectionError("websocket closed", this.url));
+			if (gen === this.#gen) this.#handleSocketDeath("websocket closed", {
+				fromConnectAttempt,
+				gen
+			});
+		});
+		const onMessage = (ev) => {
+			if (gen !== this.#gen) return;
+			const data = typeof ev === "object" && ev !== null && "data" in ev ? ev.data : ev;
+			this.#onMessage(String(data));
+		};
+		const handlers = {
+			onOpen,
+			onError,
+			onClose,
+			onMessage,
+			ws
+		};
+		this.#socketHandlers = handlers;
+		ws.addEventListener("open", onOpen);
+		ws.addEventListener("error", onError);
+		ws.addEventListener("close", onClose);
+		ws.addEventListener("message", onMessage);
+		await raceSignal(connecting, opts?.signal);
+	}
+	#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.#setStatus(RelayStatus.Closed);
+		this.#manualStop = 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 {
+			this.#subscriptions.closeAll("relay closed");
+		} finally {
+			this.#failPending(new RelayClosedError("relay closed", this.url));
+			this.#detachSocketHandlers();
+			this.#teardownSocket();
+			this.#events.emit("close", void 0);
+		}
+	}
+	/**
+	* Sever the socket while keeping every subscription: unlike {@link close}, open REQ state is
+	* preserved and reconnect stays suppressed — the next {@link connect} re-subscribes all of them.
+	* {@link Pool} uses this to suspend a relay without tearing down its live subscriptions.
+	*/
+	disconnect() {
+		this.#gen += 1;
+		this.#setStatus(RelayStatus.Disconnected);
+		this.#manualStop = true;
+		this.#clearReconnectTimer();
+		if (this.#connectTimer !== void 0) {
+			clearTimeout(this.#connectTimer);
+			this.#connectTimer = void 0;
+		}
+		this.#ping.stop();
+		this.#connectFinish?.(new RelayClosedError("relay disconnected", this.url));
+		this.#failPending(new RelayClosedError("relay disconnected", this.url));
+		this.#detachSocketHandlers();
+		this.#teardownSocket();
+	}
+	#teardownSocket() {
+		try {
+			this.#ws?.close();
+		} catch {}
+		this.#ws = void 0;
+	}
+	#clearReconnectTimer() {
+		if (this.#reconnectTimer !== void 0) {
+			clearTimeout(this.#reconnectTimer);
+			this.#reconnectTimer = void 0;
+		}
+	}
+	#failPending(err) {
+		this.#ok.rejectAll(err);
+		this.#countRequests.rejectAll(err);
+		failAllNegSessions(this.#neg, err);
+	}
+	/** Unexpected socket death. Keep subscriptions if reconnecting. */
+	#handleSocketDeath(reason, opts) {
+		if (opts.gen !== this.#gen) return;
+		this.#gen += 1;
+		this.#ping.stop();
+		this.#detachSocketHandlers();
+		this.#ws = void 0;
+		this.#failPending(new RelayClosedError(reason, this.url));
+		if (this.#enableReconnect && !this.#manualStop && this.#subscriptions.size > 0) {
+			this.#setStatus(RelayStatus.Disconnected);
+			this.#scheduleReconnect();
+			return;
+		}
+		this.#setStatus(RelayStatus.Disconnected);
+		if (opts.fromConnectAttempt !== true || this.#subscriptions.size > 0) {
+			this.#subscriptions.closeAll(reason);
+			if (!this.#manualStop) this.#events.emit("close", void 0);
+		}
+		this.#setStatus(RelayStatus.Closed);
+	}
+	#scheduleReconnect() {
+		if (this.#reconnectTimer !== void 0) 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.#manualStop || this.#isOpen()) return;
+			(async () => {
+				try {
+					await this.connect();
+				} catch {
+					if (this.#enableReconnect && !this.#manualStop && this.#subscriptions.size > 0 && !this.#isOpen()) this.#scheduleReconnect();
+				}
+			})();
+		}, delay);
+	}
+	#send(message) {
+		if (!this.#ws || !this.#isOpen()) 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;
+				this.#subscriptions.handleEvent(subId, event);
+				break;
+			}
+			case "EOSE": {
+				const [, subId] = msg;
+				if (this.#ping.finishDummyPing(subId)) return;
+				this.#subscriptions.handleEose(subId);
+				break;
+			}
+			case "CLOSED": {
+				const [, subId, reason] = msg;
+				if (this.#ping.finishDummyPing(subId)) return;
+				const countWaiter = this.#countRequests.get(subId);
+				if (countWaiter) {
+					if (isAuthRequired(reason) && this.#authSigner && !countWaiter.authRetried) {
+						countWaiter.authRetried = true;
+						this.#countRequests.authRetry(countWaiter, {
+							ensureAuthed: this.#ensureAuthed,
+							isOpen: () => this.#isOpen(),
+							failError: () => new RelayClosedError(reason || "COUNT closed", this.url),
+							send: () => this.#send([
+								"COUNT",
+								subId,
+								...countWaiter.filters
+							])
+						});
+						return;
+					}
+					countWaiter.reject(new RelayClosedError(reason || "COUNT closed", this.url));
+					return;
+				}
+				const sub = this.#subscriptions.get(subId);
+				if (!sub) return;
+				if (isAuthRequired(reason) && this.#authSigner && sub.beginAuthRetry()) {
+					this.#subscriptions.authRetry(sub, reason, this.#ensureAuthed);
+					return;
+				}
+				this.#subscriptions.drop(sub, reason);
+				break;
+			}
+			case "OK": {
+				const [, eventId, ok, message] = msg;
+				const waiter = this.#ok.handleOk(eventId, ok, message, (w) => !ok && isAuthRequired(message) && w.event !== void 0 && !w.authRetried && this.#authSigner !== void 0);
+				if (!waiter) return;
+				waiter.authRetried = true;
+				this.#ok.authRetry(waiter, message, {
+					ensureAuthed: this.#ensureAuthed,
+					isOpen: () => this.#isOpen(),
+					send: (event) => this.#send(["EVENT", event])
+				});
+				return;
+			}
+			case "COUNT": {
+				const [, countId, payload] = msg;
+				const waiter = this.#countRequests.get(countId);
+				if (!waiter) return;
+				waiter.resolve(payload);
+				break;
+			}
+			case "NEG-MSG":
+			case "NEG-ERR":
+				dispatchNegMessage(this.#neg, msg);
+				break;
+			case "NOTICE": {
+				const [, notice] = msg;
+				this.#events.emit("notice", notice);
+				break;
+			}
+			case "AUTH": {
+				const [, authChallenge] = msg;
+				this.#authState.handleChallenge(authChallenge);
+				this.#events.emit("auth", authChallenge);
+				break;
+			}
+		}
+	}
+	/** Low-level REQ with callbacks. Survives reconnect when enableReconnect is on. */
+	subscribe(filters, opts = {}) {
+		if (filters.length === 0) throw new MessageError("REQ requires at least one filter");
+		if (!this.#isOpen() && !this.#enableReconnect) throw new RelayClosedError("not connected", this.url);
+		const canonical = canonicalizeFilters(filters);
+		return this.#subscriptions.open(canonical, opts);
+	}
+	#acceptEvent(event) {
+		if (this.#verifyDead) return false;
+		try {
+			const ok = this.#verify(event);
+			if (!ok) this.#events.emit("invalidevent", void 0);
+			return ok;
+		} catch (error) {
+			if (error instanceof WasmPoisonedError) {
+				this.#verifyDead = true;
+				this.#events.emit("notice", "wasm-poisoned: instance aborted");
+				return false;
+			}
+			throw error;
+		}
+	}
+	/** AsyncIterable of events for filters until the subscription is closed. */
+	stream(filters, opts) {
+		return streamFilters((f, o) => this.subscribe(f, o), filters, opts);
+	}
+	/**
+	* One-shot query: collect events until the REQ ends, then close. `end` reports how it ended —
+	* relay `EOSE`, relay `CLOSED` (with its reason), or the local timeout; events received before a
+	* CLOSED or the deadline are still returned. Abort rejects; a failed (re)connect rejects.
+	*/
+	async fetch(filters, opts) {
+		if (filters.length === 0) throw new MessageError("REQ requires at least one filter");
+		const canonical = canonicalizeFilters(filters);
+		if (!this.#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. 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.#isOpen()) throw new RelayClosedError("not connected", this.url);
+		const existing = this.#ok.inFlight(event.id);
+		if (existing !== void 0) return existing;
+		const timeoutMs = opts?.timeoutMs ?? this.#publishTimeoutMs;
+		return this.#ok.track(event.id, {
+			timeoutMs,
+			timeoutError: () => new RelayTimeoutError("publish timed out", this.url),
+			sendError: () => new RelayPublishError("publish failed", this.url),
+			event,
+			send: () => this.#send(["EVENT", event])
+		});
+	}
+	/**
+	* 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.#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 this.#countRequests.track(id, {
+			timeoutMs,
+			timeoutError: () => new RelayTimeoutError("count timed out", this.url),
+			sendError: () => new RelayPublishError("count failed", this.url),
+			filters: [...canonical],
+			signal: opts?.signal,
+			send: () => this.#send([
+				"COUNT",
+				id,
+				...canonical
+			])
+		});
+	}
+	/** NIP-42 AUTH: sign the current challenge and wait for OK. */
+	async auth(sign, opts) {
+		return this.#authState.auth(sign, opts);
+	}
+	/**
+	* 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, an
+	* `auth` event is re-fired so the pool's automatic auth can run once more.
+	*/
+	resetAuth() {
+		const challenge = this.#authState.resetRejection();
+		if (challenge !== void 0) this.#events.emit("auth", challenge);
+	}
+	/**
+	* 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.#isOpen()) throw new RelayClosedError("not connected", this.url);
+		throwIfAborted(opts?.signal);
+		const id = opts?.id === void 0 ? this.nextSubId("neg") : assertSubscriptionId(opts.id);
+		return runTrackedNegSession({
+			sessions: this.#neg,
+			id,
+			storage,
+			filter: canonicalizeFilter(filter),
+			timeoutMs: opts?.timeoutMs ?? this.#publishTimeoutMs,
+			signal: opts?.signal,
+			send: (message) => this.#send(message),
+			url: this.url
+		});
+	}
+	/** Generate a unique subscription id for this relay instance. */
+	nextSubId(prefix = "sub") {
+		this.#serial += 1;
+		return `${prefix}:${this.#serial}`;
+	}
+};
+//#endregion
+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=relay-quCs7MHD.mjs.map