@qntx/nostr 0.0.1

package/dist/client-Bd8B1mYm.mjs

@@ -0,0 +1,835 @@
+import { s as normalizeURL } from "./util-6tfLQ9JF.mjs";
+import { a as NostrError } from "./error-DZEs5OuZ.mjs";
+import { t as Kind } from "./kind-BLl4cLOc.mjs";
+import { d as sortedEvents } from "./event-CzoQEFMF.mjs";
+import { t as EventBuilder } from "./builder-q0VsvnYE.mjs";
+import { n as canonicalizeFilters, t as canonicalizeFilter } from "./filter-BxwjEkZp.mjs";
+import { n as fanIn, r as fetchRouted, t as Pool } from "./pool-C_j1OmBB.mjs";
+import { storageFromItems } from "./nips/nip77.mjs";
+import { isGiftWrapKind, requireNip59Crypto, unwrap } from "./nips/nip59.mjs";
+import { Nip17Error, buildChatMessageRumor, dmRelayListEventBuilder, normalizeRecipients, requireDmRelays, wrapDirectMessage } from "./nips/nip17.mjs";
+import { t as Gossip } from "./gossip-3xkRRCm_.mjs";
+import { i as createOutboxFeed, t as createLoaders } from "./loaders-BNQszDAn.mjs";
+import { n as toStorageError } from "./error-CwBxle6N.mjs";
+import { t as MemoryEventStore } from "./memory-BCmhZPek.mjs";
+//#region src/client/builder.ts
+/** Fluent constructor for {@link Client}. */
+var ClientBuilder = class {
+	#opts = {};
+	signer(signer) {
+		this.#opts = {
+			...this.#opts,
+			signer
+		};
+		return this;
+	}
+	relays(urls) {
+		this.#opts = {
+			...this.#opts,
+			relays: [...urls]
+		};
+		return this;
+	}
+	addRelay(url) {
+		this.#opts = {
+			...this.#opts,
+			relays: [...this.#opts.relays ?? [], url]
+		};
+		return this;
+	}
+	websocketImplementation(impl) {
+		this.#opts = {
+			...this.#opts,
+			websocketImplementation: impl
+		};
+		return this;
+	}
+	verifyEvent(fn) {
+		this.#opts = {
+			...this.#opts,
+			verifyEvent: fn
+		};
+		return this;
+	}
+	connectTimeoutMs(ms) {
+		this.#opts = {
+			...this.#opts,
+			connectTimeoutMs: ms
+		};
+		return this;
+	}
+	publishTimeoutMs(ms) {
+		this.#opts = {
+			...this.#opts,
+			publishTimeoutMs: ms
+		};
+		return this;
+	}
+	automaticAuth(enabled) {
+		this.#opts = {
+			...this.#opts,
+			automaticAuth: enabled
+		};
+		return this;
+	}
+	enableReconnect(enabled) {
+		this.#opts = {
+			...this.#opts,
+			enableReconnect: enabled
+		};
+		return this;
+	}
+	enablePing(enabled) {
+		this.#opts = {
+			...this.#opts,
+			enablePing: enabled
+		};
+		return this;
+	}
+	pingIntervalMs(ms) {
+		this.#opts = {
+			...this.#opts,
+			pingIntervalMs: ms
+		};
+		return this;
+	}
+	pingTimeoutMs(ms) {
+		this.#opts = {
+			...this.#opts,
+			pingTimeoutMs: ms
+		};
+		return this;
+	}
+	/**
+	* Local event store. Defaults to {@link MemoryEventStore}.
+	* Browser apps that want persistence must pass {@link IndexedDbEventStore} and `await open()`.
+	*/
+	storage(store) {
+		this.#opts = {
+			...this.#opts,
+			storage: store
+		};
+		return this;
+	}
+	/** When false, Client will not auto-write events to storage. Default true. */
+	persistEvents(enabled) {
+		this.#opts = {
+			...this.#opts,
+			persistEvents: enabled
+		};
+		return this;
+	}
+	gossip(gossip) {
+		this.#opts = {
+			...this.#opts,
+			gossip
+		};
+		return this;
+	}
+	onstorageerror(fn) {
+		this.#opts = {
+			...this.#opts,
+			onstorageerror: fn
+		};
+		return this;
+	}
+	build() {
+		return new Client(this.#opts);
+	}
+};
+//#endregion
+//#region src/client/dm.ts
+function giftWrapRelays(gossip, event) {
+	const targets = [];
+	for (const tag of event.tags) if (tag[0] === "p" && tag[1]) targets.push(tag[1].toLowerCase());
+	if (targets.length === 0) throw new Nip17Error("gift wrap has no p-tag recipient");
+	if (targets.length !== 1) throw new Nip17Error("gift wrap must have exactly one p-tag recipient");
+	const relays = gossip.dmRelays(targets[0]);
+	if (relays.length === 0) throw new Nip17Error("no kind 10050 in gossip; use sendPrivateMessage or pass relays");
+	return relays;
+}
+async function setDmRelays(deps, relays, opts) {
+	return deps.publish(dmRelayListEventBuilder(relays), {
+		gossip: true,
+		...opts
+	});
+}
+async function sendPrivateMessage(deps, recipients, content, opts) {
+	deps.assertAlive();
+	const crypto = deps.requireNip59Crypto();
+	const sender = await crypto.getPublicKey();
+	const list = normalizeRecipients(recipients);
+	if (list.length === 0) throw new Nip17Error("recipients must not be empty");
+	const targets = /* @__PURE__ */ new Set([sender.toLowerCase(), ...list.map((r) => r.pubkey)]);
+	await deps.hydrateGossip([...targets]);
+	for (const pk of targets) requireDmRelays(pk, deps.gossip.dmRelays(pk));
+	const rumor = buildChatMessageRumor(sender, list, content, {
+		created_at: opts?.created_at,
+		subject: opts?.subject,
+		replyTo: opts?.replyTo
+	});
+	const wraps = await wrapDirectMessage(crypto, list, rumor);
+	return {
+		rumor,
+		wraps: await Promise.all(wraps.map(async ({ recipient, wrap }) => {
+			const relays = requireDmRelays(recipient, deps.gossip.dmRelays(recipient));
+			const results = await deps.pool.publish(relays, wrap, { timeoutMs: opts?.timeoutMs });
+			if (results.some((r) => r.result?.ok) && deps.wantObserve(opts?.observe)) deps.observe(wrap);
+			return {
+				recipient,
+				wrap,
+				results
+			};
+		}))
+	};
+}
+async function fetchPrivateMessages(deps, opts) {
+	deps.assertAlive();
+	const crypto = deps.requireNip59Crypto();
+	const self = await crypto.getPublicKey();
+	deps.throwIfAborted(opts?.signal);
+	await deps.hydrateGossip([self]);
+	deps.throwIfAborted(opts?.signal);
+	const relays = requireDmRelays(self, deps.gossip.dmRelays(self));
+	const events = await deps.pool.fetch(relays, [{
+		kinds: [Kind.GiftWrap],
+		"#p": [self],
+		since: opts?.since,
+		until: opts?.until
+	}], {
+		timeoutMs: opts?.timeoutMs,
+		signal: opts?.signal
+	});
+	const byRumor = /* @__PURE__ */ new Map();
+	for (const wrap of events) try {
+		const rumor = await unwrap(crypto, wrap);
+		if (deps.wantObserve(opts?.observe)) deps.observe(wrap);
+		byRumor.set(rumor.id, {
+			wrap,
+			rumor
+		});
+	} catch {}
+	return [...byRumor.values()].sort((a, b) => {
+		if (a.rumor.created_at !== b.rumor.created_at) return a.rumor.created_at - b.rumor.created_at;
+		return a.rumor.id.localeCompare(b.rumor.id);
+	});
+}
+async function subscribePrivateMessages(deps, opts) {
+	deps.assertAlive();
+	const crypto = deps.requireNip59Crypto();
+	const self = await crypto.getPublicKey();
+	deps.throwIfAborted(opts?.signal);
+	await deps.hydrateGossip([self]);
+	deps.throwIfAborted(opts?.signal);
+	const relays = requireDmRelays(self, deps.gossip.dmRelays(self));
+	const seen = /* @__PURE__ */ new Set();
+	let tail = Promise.resolve();
+	let closed = false;
+	const markClosed = () => {
+		closed = true;
+	};
+	if (opts?.signal?.aborted) markClosed();
+	else opts?.signal?.addEventListener("abort", markClosed, { once: true });
+	const inner = deps.pool.subscribe(relays, [{
+		kinds: [Kind.GiftWrap, Kind.GiftWrapEphemeral],
+		"#p": [self],
+		since: opts?.since
+	}], {
+		signal: opts?.signal,
+		oneose: opts?.oneose,
+		onclose: (reason) => {
+			markClosed();
+			opts?.onclose?.(reason);
+		},
+		eoseTimeoutMs: opts?.eoseTimeoutMs,
+		onevent: (wrap) => {
+			if (closed) return;
+			tail = tail.then(async () => {
+				if (closed) return;
+				try {
+					const rumor = await unwrap(crypto, wrap);
+					if (closed) return;
+					if (seen.has(rumor.id)) return;
+					seen.add(rumor.id);
+					if (deps.wantObserve(opts?.observe)) deps.observe(wrap);
+					opts?.onevent?.({
+						wrap,
+						rumor
+					});
+				} catch {}
+			}).catch(() => {});
+		}
+	});
+	return { close: (reason) => {
+		markClosed();
+		inner.close(reason);
+	} };
+}
+//#endregion
+//#region src/client/gossip-io.ts
+/** Remainder is one job on defaults; throw before any REQ when defaults are empty. */
+function jobsForFilters(gossip, filters, defaultRelays) {
+	const routed = filters.map((f) => gossip.route(f));
+	const defaults = routed.some((r) => r.remainder !== void 0) ? defaultRelays() : void 0;
+	const jobs = [];
+	for (const r of routed) {
+		for (const [url, sub] of r.perRelay) jobs.push({
+			urls: [url],
+			filters: [sub]
+		});
+		if (r.remainder) jobs.push({
+			urls: defaults,
+			filters: [r.remainder]
+		});
+	}
+	return jobs;
+}
+function fetchGossip(pool, gossip, filters, defaultRelays, opts) {
+	return fetchRouted(pool, jobsForFilters(gossip, filters, defaultRelays), {
+		timeoutMs: opts?.timeoutMs,
+		signal: opts?.signal
+	});
+}
+function subscribeGossip(pool, gossip, filters, defaultRelays, opts) {
+	const jobs = jobsForFilters(gossip, filters, defaultRelays);
+	if (jobs.length === 0) {
+		queueMicrotask(() => opts.oneose?.());
+		return { close: () => {} };
+	}
+	return fanIn(pool, jobs, opts);
+}
+//#endregion
+//#region src/client/types.ts
+const SyncDirection = {
+	Up: "up",
+	Down: "down",
+	Both: "both"
+};
+/** Client lifecycle, configuration, or abort failure (not cryptographic). */
+var ClientError = class extends NostrError {};
+//#endregion
+//#region src/client/sync.ts
+const SYNC_ID_BATCH = 100;
+const SYNC_UPLOAD_CONCURRENCY = 8;
+function uniqueIds(ids) {
+	return [...new Set(ids)];
+}
+function emptySummary() {
+	return {
+		local: [],
+		remote: [],
+		sent: [],
+		received: [],
+		sendFailures: {},
+		persistFailures: {}
+	};
+}
+function mergeSyncSummary(into, other) {
+	const sendFailures = {
+		...into.sendFailures,
+		...other.sendFailures
+	};
+	const persistFailures = {
+		...into.persistFailures,
+		...other.persistFailures
+	};
+	return {
+		local: uniqueIds([...into.local, ...other.local]),
+		remote: uniqueIds([...into.remote, ...other.remote]),
+		sent: uniqueIds([...into.sent, ...other.sent]),
+		received: uniqueIds([...into.received, ...other.received]),
+		sendFailures,
+		persistFailures
+	};
+}
+/**
+* NIP-77 sync against one relay: reconcile, then optionally upload
+* local-only events and/or download remote-only events.
+* `observe: false` skips putMany and ingestMeta; received ids are still listed.
+* `persistEvents: false` skips putMany, still ingestMeta when observe is on.
+*/
+async function syncToRelay(deps, url, filter, opts) {
+	deps.assertAlive();
+	deps.throwIfAborted(opts?.signal);
+	const direction = opts?.direction ?? SyncDirection.Down;
+	filter = canonicalizeFilter(filter);
+	const items = await deps.storage.negentropyItems(filter);
+	const storage = storageFromItems(items);
+	const { have, need } = await (await deps.pool.ensureRelay(url, { signal: opts?.signal })).negReconcile(filter, storage, {
+		timeoutMs: opts?.timeoutMs,
+		signal: opts?.signal
+	});
+	const summary = {
+		local: have,
+		remote: need,
+		sent: [],
+		received: [],
+		sendFailures: {},
+		persistFailures: {}
+	};
+	if (opts?.dryRun) return summary;
+	if (direction === SyncDirection.Up || direction === SyncDirection.Both) {
+		if (have.length > 0) {
+			const found = await deps.storage.query([{ ids: have }]);
+			const foundById = new Map(found.map((event) => [event.id, event]));
+			for (const id of have) if (!foundById.has(id)) summary.sendFailures[id] = "event not found in local store";
+			for (let i = 0; i < found.length; i += SYNC_UPLOAD_CONCURRENCY) {
+				const chunk = found.slice(i, i + SYNC_UPLOAD_CONCURRENCY);
+				await Promise.all(chunk.map(async (event) => {
+					try {
+						const results = await deps.pool.publish([url], event, { timeoutMs: opts?.timeoutMs });
+						if (results.some((r) => r.result?.ok)) summary.sent.push(event.id);
+						else summary.sendFailures[event.id] = results[0]?.error ?? results[0]?.result?.message ?? "publish failed";
+					} catch (error) {
+						summary.sendFailures[event.id] = error instanceof Error ? error.message : String(error);
+					}
+				}));
+			}
+		}
+	}
+	if ((direction === SyncDirection.Down || direction === SyncDirection.Both) && need.length > 0) {
+		const shouldObserve = deps.wantObserve(opts?.observe);
+		for (let i = 0; i < need.length; i += SYNC_ID_BATCH) {
+			const batch = need.slice(i, i + SYNC_ID_BATCH);
+			deps.throwIfAborted(opts?.signal);
+			const events = await deps.pool.fetch([url], [{ ids: batch }], {
+				timeoutMs: opts?.timeoutMs,
+				signal: opts?.signal
+			});
+			if (!shouldObserve) {
+				for (const event of events) summary.received.push(event.id);
+				continue;
+			}
+			if (!deps.persistEvents) {
+				for (const event of events) {
+					deps.ingestMeta(event);
+					summary.received.push(event.id);
+				}
+				continue;
+			}
+			let results;
+			try {
+				results = await deps.storage.putMany(events);
+			} catch (err) {
+				const message = err instanceof Error ? err.message : String(err);
+				for (const event of events) summary.persistFailures[event.id] = message;
+				break;
+			}
+			for (let j = 0; j < events.length; j++) {
+				const event = events[j];
+				if (results[j] === "rejected") continue;
+				deps.ingestMeta(event);
+				summary.received.push(event.id);
+			}
+		}
+	}
+	return summary;
+}
+/**
+* NIP-77 sync against the given relays (or Client default relays).
+* Independent sessions run in parallel. Fulfilled summaries are merged;
+* if every relay rejects, throws the first rejection in URL order.
+*/
+async function sync(deps, filter, opts) {
+	deps.assertAlive();
+	const urls = deps.defaultRelays(opts?.relays ? [...opts.relays] : void 0);
+	const results = await Promise.allSettled(urls.map((url) => syncToRelay(deps, url, filter, opts)));
+	let merged = emptySummary();
+	let fulfilled = 0;
+	let firstRejection;
+	for (const result of results) if (result.status === "fulfilled") {
+		fulfilled += 1;
+		merged = mergeSyncSummary(merged, result.value);
+	} else firstRejection ??= result.reason;
+	if (urls.length > 0 && fulfilled === 0) throw firstRejection;
+	return merged;
+}
+//#endregion
+//#region src/client/client.ts
+/**
+* Layer-5 facade: signer + default relays + pool + loaders + gossip + event store.
+*/
+var Client = class {
+	pool;
+	loaders;
+	gossip;
+	storage;
+	onstorageerror;
+	#signer;
+	#relays;
+	#shutdown = false;
+	#persistEvents;
+	#persistQueue = [];
+	#flushing;
+	constructor(opts = {}) {
+		this.#signer = opts.signer;
+		this.#relays = [...opts.relays ?? []];
+		this.gossip = opts.gossip ?? new Gossip();
+		this.storage = opts.storage ?? new MemoryEventStore();
+		this.#persistEvents = opts.persistEvents ?? true;
+		this.onstorageerror = opts.onstorageerror ?? null;
+		const autoAuth = opts.automaticAuth ?? Boolean(opts.signer);
+		this.pool = new Pool({
+			websocketImplementation: opts.websocketImplementation,
+			verifyEvent: opts.verifyEvent,
+			enablePing: opts.enablePing,
+			pingIntervalMs: opts.pingIntervalMs,
+			pingTimeoutMs: opts.pingTimeoutMs,
+			connectTimeoutMs: opts.connectTimeoutMs,
+			publishTimeoutMs: opts.publishTimeoutMs,
+			enableReconnect: opts.enableReconnect ?? true,
+			automaticallyAuth: autoAuth ? () => {
+				const signer = this.#signer;
+				if (!signer) return null;
+				return async (template) => {
+					const pk = await signer.getPublicKey();
+					return signer.signEvent({
+						...template,
+						pubkey: pk
+					});
+				};
+			} : void 0
+		});
+		this.loaders = createLoaders({
+			pool: this.pool,
+			relays: this.#relays
+		});
+	}
+	static builder() {
+		return new ClientBuilder();
+	}
+	get signer() {
+		return this.#signer;
+	}
+	get relays() {
+		return this.#relays;
+	}
+	get isShutdown() {
+		return this.#shutdown;
+	}
+	setSigner(signer) {
+		this.#signer = signer;
+	}
+	addRelay(url) {
+		if (!this.#relays.includes(url)) {
+			this.#relays.push(url);
+			this.loaders.context.addRelay(url);
+		}
+	}
+	removeRelay(url) {
+		this.#relays = this.#relays.filter((r) => r !== url);
+		this.loaders.context.removeRelay(url);
+		this.pool.close([url]);
+	}
+	/** Connect all configured relays (best-effort; failures are ignored). */
+	async connect(opts) {
+		this.#assertAlive();
+		await Promise.allSettled(this.#relays.map((url) => this.pool.ensureRelay(url, { signal: opts?.signal })));
+	}
+	async shutdown() {
+		this.#shutdown = true;
+		while (this.#flushing) await this.#flushing;
+		this.pool.close();
+		this.loaders.context.cache.clear();
+	}
+	#assertAlive() {
+		if (this.#shutdown) throw new ClientError("client is shut down");
+	}
+	#defaultRelays(urls) {
+		const list = urls ?? this.#relays;
+		if (list.length === 0) throw new ClientError("no relays configured");
+		return list;
+	}
+	#wantObserve(flag) {
+		return flag !== false;
+	}
+	/**
+	* Unified ingest pipeline: gossip + replaceable loader cache immediately;
+	* storage writes are coalesced into a single-flight `putMany`.
+	*/
+	observe(event) {
+		this.#ingestMeta(event);
+		if (!this.#persistEvents) return;
+		this.#persistQueue.push(event);
+		this.#armFlush();
+	}
+	/** Observe many events (deduped by id, order preserved) as one persist batch. */
+	observeAll(events) {
+		const seen = /* @__PURE__ */ new Set();
+		for (const event of events) {
+			if (seen.has(event.id)) continue;
+			seen.add(event.id);
+			this.#ingestMeta(event);
+			if (this.#persistEvents) this.#persistQueue.push(event);
+		}
+		if (this.#persistEvents && this.#persistQueue.length > 0) this.#armFlush();
+	}
+	#ingestMeta(event) {
+		this.gossip.ingest(event);
+		if (event.kind === Kind.Metadata || event.kind === Kind.Contacts || event.kind === Kind.MuteList || event.kind === Kind.RelayList || event.kind === Kind.DirectMessageRelaysList) this.loaders.context.cache.putIfNewer(event);
+	}
+	#armFlush() {
+		if (this.#flushing) return;
+		this.#flushing = this.#flushLoop();
+	}
+	async #flushLoop() {
+		try {
+			await new Promise((resolve) => {
+				queueMicrotask(resolve);
+			});
+			while (this.#persistQueue.length > 0) {
+				const batch = this.#persistQueue.splice(0);
+				try {
+					await this.storage.putMany(batch);
+				} catch (err) {
+					this.onstorageerror?.(toStorageError(err));
+				}
+			}
+		} finally {
+			this.#flushing = void 0;
+			if (this.#persistQueue.length > 0) this.#armFlush();
+		}
+	}
+	/**
+	* Explicitly load kind:10002 and kind:10050 lists for pubkeys and feed gossip.
+	* Does not background-fetch unknown authors on every subscribe (predictable DX).
+	*/
+	async hydrateGossip(pubkeys, opts) {
+		this.#assertAlive();
+		await Promise.all(pubkeys.map(async (pk) => {
+			const style = opts?.force ? "force" : "default";
+			const [relayList, dmList] = await Promise.all([this.loaders.relayList(pk, {
+				hints: opts?.hints,
+				style
+			}), this.loaders.dmRelayList(pk, {
+				hints: opts?.hints,
+				style
+			})]);
+			if (relayList.event) this.observe(relayList.event);
+			if (dmList.event) this.observe(dmList.event);
+		}));
+	}
+	/**
+	* Create an outbox-model feed for the given authors (NIP-65 write relays).
+	* Live events go through {@link observe}; sync persists via applySync.
+	*/
+	outbox(opts) {
+		this.#assertAlive();
+		return createOutboxFeed({
+			pool: this.pool,
+			gossip: this.gossip,
+			storage: this.storage,
+			discoveryRelays: this.#relays,
+			authors: opts.authors,
+			kinds: opts.kinds,
+			onEvent: opts.onEvent,
+			maxRelaysPerAuthor: opts.maxRelaysPerAuthor,
+			observe: (event) => this.observe(event),
+			applySync: async (events) => {
+				if (!this.#persistEvents) {
+					for (const event of events) this.#ingestMeta(event);
+					return [];
+				}
+				const results = await this.storage.putMany(events);
+				const applied = [];
+				for (let i = 0; i < events.length; i++) {
+					if (results[i] === "rejected" || results[i] === "ephemeral") continue;
+					this.#ingestMeta(events[i]);
+					applied.push(events[i]);
+				}
+				return applied;
+			},
+			hydrate: (pubkeys) => this.hydrateGossip(pubkeys)
+		});
+	}
+	async getPublicKey() {
+		if (!this.#signer) throw new ClientError("no signer configured");
+		return this.#signer.getPublicKey();
+	}
+	async signEvent(unsigned) {
+		if (!this.#signer) throw new ClientError("no signer configured");
+		return this.#signer.signEvent(unsigned);
+	}
+	async signEventBuilder(builder) {
+		if (!this.#signer) throw new ClientError("no signer configured");
+		return builder.sign(this.#signer);
+	}
+	async signTemplate(template) {
+		if (!this.#signer) throw new ClientError("no signer configured");
+		const pubkey = await this.#signer.getPublicKey();
+		return this.#signer.signEvent({
+			...template,
+			pubkey
+		});
+	}
+	/**
+	* Sign (if builder) and publish to relays.
+	* With `gossip: true`, prefers the author's NIP-65 outbox relays, tagged `p`
+	* inboxes, and up to 5 `e`/`a` tag relay hints when known.
+	* On any successful OK, observes the event into storage/gossip.
+	*/
+	async publish(eventOrBuilder, opts) {
+		this.#assertAlive();
+		const event = eventOrBuilder instanceof EventBuilder ? await this.signEventBuilder(eventOrBuilder) : eventOrBuilder;
+		let relays = opts?.relays;
+		if (!relays && isGiftWrapKind(event.kind)) relays = giftWrapRelays(this.gossip, event);
+		else if (!relays && opts?.gossip) {
+			const urls = [];
+			const add = (list) => {
+				for (const url of list) if (!urls.includes(url)) urls.push(url);
+			};
+			add(this.gossip.outboxRelays(event.pubkey));
+			for (const tag of event.tags) if (tag[0] === "p" && tag[1]) add(this.gossip.inboxRelays(tag[1]));
+			let hintCount = 0;
+			for (const tag of event.tags) {
+				if (hintCount >= 5) break;
+				if (tag[0] !== "e" && tag[0] !== "a" || !tag[2]) continue;
+				try {
+					const url = normalizeURL(tag[2]);
+					if (!urls.includes(url)) {
+						urls.push(url);
+						hintCount += 1;
+					}
+				} catch {}
+			}
+			if (urls.length > 0) relays = urls;
+		}
+		const results = await this.pool.publish(this.#defaultRelays(relays), event, { timeoutMs: opts?.timeoutMs });
+		if (results.some((r) => r.result?.ok) && this.#wantObserve(opts?.observe)) this.observe(event);
+		return results;
+	}
+	/**
+	* Fetch events. With `gossip: true`, routes filters by NIP-65 when possible.
+	* With `localFirst: true`, merges storage hits with network results.
+	*/
+	async fetchEvents(filter, opts) {
+		this.#assertAlive();
+		const filters = canonicalizeFilters(Array.isArray(filter) ? filter : [filter]);
+		const shouldObserve = this.#wantObserve(opts?.observe);
+		const byId = /* @__PURE__ */ new Map();
+		if (opts?.localFirst) try {
+			const local = await this.storage.query(filters);
+			for (const e of local) byId.set(e.id, e);
+		} catch (err) {
+			this.onstorageerror?.(toStorageError(err));
+		}
+		const ingest = (events) => {
+			for (const e of events) {
+				byId.set(e.id, e);
+				if (shouldObserve) this.observe(e);
+			}
+		};
+		if (!opts?.gossip || opts.relays) {
+			ingest(await this.pool.fetch(this.#defaultRelays(opts?.relays), filters, {
+				timeoutMs: opts?.timeoutMs,
+				signal: opts?.signal
+			}));
+			return sortedEvents([...byId.values()]);
+		}
+		ingest(await fetchGossip(this.pool, this.gossip, filters, () => this.#defaultRelays(), {
+			timeoutMs: opts?.timeoutMs,
+			signal: opts?.signal
+		}));
+		return sortedEvents([...byId.values()]);
+	}
+	/**
+	* Query local storage only (no network).
+	*/
+	async queryLocal(filter) {
+		this.#assertAlive();
+		const filters = canonicalizeFilters(Array.isArray(filter) ? filter : [filter]);
+		return this.storage.query(filters);
+	}
+	subscribe(filter, opts) {
+		this.#assertAlive();
+		const filters = canonicalizeFilters(Array.isArray(filter) ? filter : [filter]);
+		const shouldObserve = this.#wantObserve(opts?.observe);
+		const wrapEvent = (event) => {
+			if (shouldObserve) this.observe(event);
+			opts?.onevent?.(event);
+		};
+		if (!opts?.gossip || opts.relays) return this.pool.subscribe(this.#defaultRelays(opts?.relays), filters, {
+			onevent: wrapEvent,
+			oneose: opts?.oneose,
+			onclose: opts?.onclose,
+			signal: opts?.signal,
+			id: opts?.id,
+			eoseTimeoutMs: opts?.eoseTimeoutMs
+		});
+		return subscribeGossip(this.pool, this.gossip, filters, () => this.#defaultRelays(), {
+			onevent: wrapEvent,
+			oneose: opts?.oneose,
+			onclose: opts?.onclose,
+			signal: opts?.signal,
+			eoseTimeoutMs: opts?.eoseTimeoutMs
+		});
+	}
+	#requireNip59Crypto() {
+		if (!this.#signer) throw new ClientError("no signer configured");
+		return requireNip59Crypto(this.#signer);
+	}
+	#throwIfAborted(signal) {
+		if (!signal?.aborted) return;
+		if (signal.reason instanceof Error) throw signal.reason;
+		throw new ClientError("aborted");
+	}
+	#dmDeps() {
+		return {
+			pool: this.pool,
+			gossip: this.gossip,
+			hydrateGossip: (pubkeys) => this.hydrateGossip(pubkeys),
+			observe: (event) => this.observe(event),
+			assertAlive: () => this.#assertAlive(),
+			requireNip59Crypto: () => this.#requireNip59Crypto(),
+			throwIfAborted: (signal) => this.#throwIfAborted(signal),
+			wantObserve: (flag) => this.#wantObserve(flag),
+			publish: (eventOrBuilder, opts) => this.publish(eventOrBuilder, opts)
+		};
+	}
+	#syncDeps() {
+		return {
+			pool: this.pool,
+			storage: this.storage,
+			persistEvents: this.#persistEvents,
+			assertAlive: () => this.#assertAlive(),
+			throwIfAborted: (signal) => this.#throwIfAborted(signal),
+			wantObserve: (flag) => this.#wantObserve(flag),
+			ingestMeta: (event) => this.#ingestMeta(event),
+			defaultRelays: (urls) => this.#defaultRelays(urls)
+		};
+	}
+	/** Publish a kind:10050 NIP-17 DM relay list (`relay` tags). Not kind 10002. */
+	async setDmRelays(relays, opts) {
+		return setDmRelays(this.#dmDeps(), relays, opts);
+	}
+	async sendPrivateMessage(recipients, content, opts) {
+		return sendPrivateMessage(this.#dmDeps(), recipients, content, opts);
+	}
+	async fetchPrivateMessages(opts) {
+		return fetchPrivateMessages(this.#dmDeps(), opts);
+	}
+	async subscribePrivateMessages(opts) {
+		return subscribePrivateMessages(this.#dmDeps(), opts);
+	}
+	/**
+	* NIP-77 sync against one relay: reconcile, then optionally upload
+	* local-only events and/or download remote-only events.
+	* `observe: false` skips putMany and ingestMeta; received ids are still listed.
+	* `persistEvents: false` skips putMany, still ingestMeta when observe is on.
+	*/
+	async syncToRelay(url, filter, opts) {
+		return syncToRelay(this.#syncDeps(), url, filter, opts);
+	}
+	/**
+	* NIP-77 sync against the given relays (or Client default relays).
+	* Independent sessions run in parallel. Fulfilled summaries are merged;
+	* if every relay rejects, throws the first rejection in URL order.
+	*/
+	async sync(filter, opts) {
+		return sync(this.#syncDeps(), filter, opts);
+	}
+};
+//#endregion
+export { ClientBuilder as i, ClientError as n, SyncDirection as r, Client as t };
+
+//# sourceMappingURL=client-Bd8B1mYm.mjs.map