@qntx/nostr 0.1.0 → 0.2.1

package/dist/{client-Bd8B1mYm.mjs → client-5DhgYV7P.mjs}

@@ -1,21 +1,33 @@
-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 { g as NostrError, l as normalizeURL } from "./util-LfQirgDk.mjs";
+import { t as Kind } from "./kind-Cxwhhkx8.mjs";
+import { f as sortedEvents, o as itemCompare } from "./event-D8Nfoh4K.mjs";
+import { t as EventBuilder } from "./builder-CyrGKRVP.mjs";
+import { n as canonicalizeFilters, o as matchFilters, t as canonicalizeFilter } from "./filter-BQl3GlHt.mjs";
+import { t as NoSignerError } from "./error-B__OMBRY.mjs";
+import { t as invokeSafely } from "./report-CHld4uWj.mjs";
+import { n as fanIn, r as fetchRouted, t as Pool } from "./pool-C2xOcsun.mjs";
+import { r as throwIfAborted } from "./abort-Ba8tDrOI.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";
+import { t as Gossip } from "./gossip-oloDMWEj.mjs";
+import { i as createOutboxFeed, t as createLoaders } from "./loaders-o6YXB_Ri.mjs";
+import { n as toStorageError } from "./error-DrEIM7FO.mjs";
+import { t as MemoryIndex } from "./memory-index-Do1mz0WF.mjs";
+import { t as MemoryEventStore } from "./memory-C2EVx0_O.mjs";
+import { t as ReactiveEventStore } from "./reactive-DDlThDSZ.mjs";
 //#region src/client/builder.ts
-/** Fluent constructor for {@link Client}. */
+/**
+* Fluent constructor for {@link Client}. The constructor is supplied by {@link Client.builder} so
+* this module never imports the `Client` value, keeping the client/builder dependency
+* one-directional.
+*/
 var ClientBuilder = class {
 	#opts = {};
+	#newClient;
+	constructor(newClient) {
+		this.#newClient = newClient;
+	}
 	signer(signer) {
 		this.#opts = {
 			...this.#opts,
@@ -72,6 +84,62 @@ var ClientBuilder = class {
 		};
 		return this;
 	}
+	/** Allow `ws://` relays. Default false. */
+	allowInsecure(allow) {
+		this.#opts = {
+			...this.#opts,
+			allowInsecure: allow
+		};
+		return this;
+	}
+	/** `ws://` URLs allowed despite `allowInsecure` being off. */
+	trustedInsecureUrls(urls) {
+		this.#opts = {
+			...this.#opts,
+			trustedInsecureUrls: urls
+		};
+		return this;
+	}
+	/** Close idle relays after this many ms. Unset = disabled. */
+	idleTimeoutMs(ms) {
+		this.#opts = {
+			...this.#opts,
+			idleTimeoutMs: ms
+		};
+		return this;
+	}
+	/** Soft cap on connected non-pinned relays. */
+	maxRelays(n) {
+		this.#opts = {
+			...this.#opts,
+			maxRelays: n
+		};
+		return this;
+	}
+	/** Relays never closed by idle cleanup or `maxRelays` eviction. */
+	pinnedUrls(urls) {
+		this.#opts = {
+			...this.#opts,
+			pinnedUrls: urls
+		};
+		return this;
+	}
+	/** Forwarded to the pool: suspend a relay delivering too many invalid events. */
+	invalidEventPolicy(policy) {
+		this.#opts = {
+			...this.#opts,
+			invalidEventPolicy: policy
+		};
+		return this;
+	}
+	/** Forwarded to the pool: fired once when a relay is suspended, with the lift time. */
+	onRelaySuspended(cb) {
+		this.#opts = {
+			...this.#opts,
+			onRelaySuspended: cb
+		};
+		return this;
+	}
 	enableReconnect(enabled) {
 		this.#opts = {
 			...this.#opts,
@@ -101,8 +169,8 @@ var ClientBuilder = class {
 		return this;
 	}
 	/**
-	* Local event store. Defaults to {@link MemoryEventStore}.
-	* Browser apps that want persistence must pass {@link IndexedDbEventStore} and `await open()`.
+	* Local event store. Defaults to {@link MemoryEventStore}. Browser apps that want persistence must
+	* pass {@link IndexedDbEventStore} and `await open()`.
 	*/
 	storage(store) {
 		this.#opts = {
@@ -111,6 +179,17 @@ var ClientBuilder = class {
 		};
 		return this;
 	}
+	/**
+	* Synchronous reactive index mirroring ingested events. Defaults to a new
+	* {@link ReactiveEventStore}.
+	*/
+	index(index) {
+		this.#opts = {
+			...this.#opts,
+			index
+		};
+		return this;
+	}
 	/** When false, Client will not auto-write events to storage. Default true. */
 	persistEvents(enabled) {
 		this.#opts = {
@@ -134,17 +213,18 @@ var ClientBuilder = class {
 		return this;
 	}
 	build() {
-		return new Client(this.#opts);
+		return this.#newClient(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());
+	for (const tag of event.tags) if (tag[0] === "p" && tag[1] !== void 0 && 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]);
+	const [target] = targets;
+	if (targets.length !== 1 || target === void 0) throw new Nip17Error("gift wrap must have exactly one p-tag recipient");
+	const relays = gossip.dmRelays(target);
 	if (relays.length === 0) throw new Nip17Error("no kind 10050 in gossip; use sendPrivateMessage or pass relays");
 	return relays;
 }
@@ -174,7 +254,7 @@ async function sendPrivateMessage(deps, recipients, content, opts) {
 		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);
+			if (results.some((r) => r.result?.ok === true) && deps.wantObserve(opts?.observe)) deps.ingest(wrap);
 			return {
 				recipient,
 				wrap,
@@ -191,6 +271,7 @@ async function fetchPrivateMessages(deps, opts) {
 	await deps.hydrateGossip([self]);
 	deps.throwIfAborted(opts?.signal);
 	const relays = requireDmRelays(self, deps.gossip.dmRelays(self));
+	const urls = /* @__PURE__ */ new Map();
 	const events = await deps.pool.fetch(relays, [{
 		kinds: [Kind.GiftWrap],
 		"#p": [self],
@@ -198,21 +279,31 @@ async function fetchPrivateMessages(deps, opts) {
 		until: opts?.until
 	}], {
 		timeoutMs: opts?.timeoutMs,
-		signal: opts?.signal
+		signal: opts?.signal,
+		onevent: (event, relayUrl) => {
+			let set = urls.get(event.id);
+			if (!set) urls.set(event.id, set = /* @__PURE__ */ new Set());
+			set.add(relayUrl);
+		}
 	});
 	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);
+		const wrapUrls = urls.get(wrap.id);
+		const firstUrl = wrapUrls?.values().next().value;
+		if (deps.wantObserve(opts?.observe)) {
+			deps.ingest(wrap, firstUrl);
+			if (wrapUrls) {
+				for (const url of wrapUrls) if (url !== firstUrl) deps.markSeen(wrap.id, url);
+			}
+		}
 		byRumor.set(rumor.id, {
 			wrap,
-			rumor
+			rumor,
+			...firstUrl === void 0 ? {} : { relayUrl: firstUrl }
 		});
 	} 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);
-	});
+	return [...byRumor.values()].sort((a, b) => itemCompare(a.rumor, b.rumor));
 }
 async function subscribePrivateMessages(deps, opts) {
 	deps.assertAlive();
@@ -223,12 +314,21 @@ async function subscribePrivateMessages(deps, opts) {
 	deps.throwIfAborted(opts?.signal);
 	const relays = requireDmRelays(self, deps.gossip.dmRelays(self));
 	const seen = /* @__PURE__ */ new Set();
+	const processed = /* @__PURE__ */ new Set();
+	const pendingUrls = /* @__PURE__ */ new Map();
+	const flushSeen = (wrapId) => {
+		processed.add(wrapId);
+		const extra = pendingUrls.get(wrapId);
+		if (extra === void 0) return;
+		pendingUrls.delete(wrapId);
+		for (const url of extra) deps.markSeen(wrapId, url);
+	};
 	let tail = Promise.resolve();
 	let closed = false;
 	const markClosed = () => {
 		closed = true;
 	};
-	if (opts?.signal?.aborted) markClosed();
+	if (opts?.signal?.aborted === true) markClosed();
 	else opts?.signal?.addEventListener("abort", markClosed, { once: true });
 	const inner = deps.pool.subscribe(relays, [{
 		kinds: [Kind.GiftWrap, Kind.GiftWrapEphemeral],
@@ -242,22 +342,45 @@ async function subscribePrivateMessages(deps, opts) {
 			opts?.onclose?.(reason);
 		},
 		eoseTimeoutMs: opts?.eoseTimeoutMs,
-		onevent: (wrap) => {
+		receivedEvent: (id, relayUrl) => {
 			if (closed) return;
-			tail = tail.then(async () => {
-				if (closed) return;
+			if (processed.has(id)) {
+				deps.markSeen(id, relayUrl);
+				return;
+			}
+			const list = pendingUrls.get(id);
+			if (list === void 0) pendingUrls.set(id, [relayUrl]);
+			else if (!list.includes(relayUrl)) list.push(relayUrl);
+		},
+		onevent: (wrap, relayUrl) => {
+			if (closed) return;
+			const prev = tail;
+			let release;
+			tail = new Promise((resolve) => {
+				release = resolve;
+			});
+			(async () => {
+				await prev;
 				try {
+					if (closed) return;
 					const rumor = await unwrap(crypto, wrap);
 					if (closed) return;
-					if (seen.has(rumor.id)) return;
+					if (seen.has(rumor.id)) {
+						flushSeen(wrap.id);
+						return;
+					}
 					seen.add(rumor.id);
-					if (deps.wantObserve(opts?.observe)) deps.observe(wrap);
+					if (deps.wantObserve(opts?.observe)) deps.ingest(wrap, relayUrl);
+					flushSeen(wrap.id);
 					opts?.onevent?.({
 						wrap,
-						rumor
+						rumor,
+						relayUrl
 					});
-				} catch {}
-			}).catch(() => {});
+				} catch {} finally {
+					release?.();
+				}
+			})();
 		}
 	});
 	return { close: (reason) => {
@@ -266,6 +389,18 @@ async function subscribePrivateMessages(deps, opts) {
 	} };
 }
 //#endregion
+//#region src/client/types.ts
+/** Direction of a {@link Client.sync} run: upload, download, or both. */
+const SyncDirection = {
+	Up: "up",
+	Down: "down",
+	Both: "both"
+};
+/** Client lifecycle, configuration, or abort failure (not cryptographic). */
+var ClientError = class extends NostrError {
+	name = "ClientError";
+};
+//#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) {
@@ -277,17 +412,21 @@ function jobsForFilters(gossip, filters, defaultRelays) {
 			urls: [url],
 			filters: [sub]
 		});
-		if (r.remainder) jobs.push({
-			urls: defaults,
-			filters: [r.remainder]
-		});
+		if (r.remainder !== void 0) {
+			if (defaults === void 0) throw new ClientError("unrouted remainder without default relays");
+			jobs.push({
+				urls: defaults,
+				filters: [r.remainder]
+			});
+		}
 	}
 	return jobs;
 }
-function fetchGossip(pool, gossip, filters, defaultRelays, opts) {
+async function fetchGossip(pool, gossip, filters, defaultRelays, opts) {
 	return fetchRouted(pool, jobsForFilters(gossip, filters, defaultRelays), {
 		timeoutMs: opts?.timeoutMs,
-		signal: opts?.signal
+		signal: opts?.signal,
+		onevent: opts?.onevent
 	});
 }
 function subscribeGossip(pool, gossip, filters, defaultRelays, opts) {
@@ -299,15 +438,6 @@ function subscribeGossip(pool, gossip, filters, defaultRelays, opts) {
 	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;
@@ -343,19 +473,18 @@ function mergeSyncSummary(into, other) {
 	};
 }
 /**
-* 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.
+* NIP-77 sync against one relay: reconcile, then optionally upload local-only events and/or
+* download remote-only events. `observe: false` skips putMany and ingest; received ids are still
+* listed. `persistEvents: false` skips putMany, still ingests 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 canon = canonicalizeFilter(filter);
+	const items = await deps.storage.negentropyItems(canon);
 	const storage = storageFromItems(items);
-	const { have, need } = await (await deps.pool.ensureRelay(url, { signal: opts?.signal })).negReconcile(filter, storage, {
+	const { have, need } = await (await deps.pool.ensureRelay(url, { signal: opts?.signal })).negReconcile(canon, storage, {
 		timeoutMs: opts?.timeoutMs,
 		signal: opts?.signal
 	});
@@ -367,24 +496,22 @@ async function syncToRelay(deps, url, filter, opts) {
 		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 (opts?.dryRun === true) return summary;
+	if ((direction === SyncDirection.Up || direction === SyncDirection.Both) && 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 === true)) 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) {
@@ -392,17 +519,28 @@ async function syncToRelay(deps, url, filter, opts) {
 		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 urlsById = /* @__PURE__ */ new Map();
 			const events = await deps.pool.fetch([url], [{ ids: batch }], {
 				timeoutMs: opts?.timeoutMs,
-				signal: opts?.signal
+				signal: opts?.signal,
+				onevent: shouldObserve ? (event, relayUrl) => {
+					const urls = urlsById.get(event.id);
+					if (urls === void 0) urlsById.set(event.id, [relayUrl]);
+					else if (!urls.includes(relayUrl)) urls.push(relayUrl);
+				} : void 0
 			});
 			if (!shouldObserve) {
 				for (const event of events) summary.received.push(event.id);
 				continue;
 			}
+			const ingestAll = (event) => {
+				const urls = urlsById.get(event.id) ?? [];
+				deps.ingest(event, urls[0], { persist: false });
+				for (const url of urls.slice(1)) deps.markSeen(event.id, url);
+			};
 			if (!deps.persistEvents) {
 				for (const event of events) {
-					deps.ingestMeta(event);
+					ingestAll(event);
 					summary.received.push(event.id);
 				}
 				continue;
@@ -410,15 +548,14 @@ async function syncToRelay(deps, url, filter, opts) {
 			let results;
 			try {
 				results = await deps.storage.putMany(events);
-			} catch (err) {
-				const message = err instanceof Error ? err.message : String(err);
+			} catch (error) {
+				const message = error instanceof Error ? error.message : String(error);
 				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);
+			for (const [j, event] of events.entries()) {
+				if (results[j] === "rejected" || results[j] === "invalid") continue;
+				ingestAll(event);
 				summary.received.push(event.id);
 			}
 		}
@@ -426,14 +563,14 @@ async function syncToRelay(deps, url, filter, opts) {
 	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.
+* 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)));
+	const results = await Promise.allSettled(urls.map(async (url) => syncToRelay(deps, url, filter, opts)));
 	let merged = emptySummary();
 	let fulfilled = 0;
 	let firstRejection;
@@ -446,14 +583,13 @@ async function sync(deps, filter, opts) {
 }
 //#endregion
 //#region src/client/client.ts
-/**
-* Layer-5 facade: signer + default relays + pool + loaders + gossip + event store.
-*/
-var Client = class {
+/** Layer-5 facade: signer + default relays + pool + loaders + gossip + event store. */
+var Client = class Client {
 	pool;
 	loaders;
 	gossip;
 	storage;
+	index;
 	onstorageerror;
 	#signer;
 	#relays;
@@ -463,12 +599,16 @@ var Client = class {
 	#flushing;
 	constructor(opts = {}) {
 		this.#signer = opts.signer;
-		this.#relays = [...opts.relays ?? []];
+		this.#relays = [];
+		for (const raw of opts.relays ?? []) {
+			const url = normalizeURL(raw);
+			if (!this.#relays.includes(url)) this.#relays.push(url);
+		}
 		this.gossip = opts.gossip ?? new Gossip();
 		this.storage = opts.storage ?? new MemoryEventStore();
+		this.index = opts.index ?? new ReactiveEventStore();
 		this.#persistEvents = opts.persistEvents ?? true;
-		this.onstorageerror = opts.onstorageerror ?? null;
-		const autoAuth = opts.automaticAuth ?? Boolean(opts.signer);
+		this.onstorageerror = opts.onstorageerror;
 		this.pool = new Pool({
 			websocketImplementation: opts.websocketImplementation,
 			verifyEvent: opts.verifyEvent,
@@ -478,25 +618,32 @@ var Client = class {
 			connectTimeoutMs: opts.connectTimeoutMs,
 			publishTimeoutMs: opts.publishTimeoutMs,
 			enableReconnect: opts.enableReconnect ?? true,
-			automaticallyAuth: autoAuth ? () => {
+			allowInsecure: opts.allowInsecure,
+			trustedInsecureUrls: opts.trustedInsecureUrls,
+			idleTimeoutMs: opts.idleTimeoutMs,
+			maxRelays: opts.maxRelays,
+			pinnedUrls: opts.pinnedUrls,
+			invalidEventPolicy: opts.invalidEventPolicy,
+			onRelaySuspended: opts.onRelaySuspended,
+			automaticallyAuth: opts.automaticAuth ?? true ? () => async (template) => {
 				const signer = this.#signer;
-				if (!signer) return null;
-				return async (template) => {
-					const pk = await signer.getPublicKey();
-					return signer.signEvent({
-						...template,
-						pubkey: pk
-					});
-				};
+				if (!signer) throw new NoSignerError("no signer configured for AUTH");
+				const pk = await signer.getPublicKey();
+				return signer.signEvent({
+					...template,
+					pubkey: pk
+				});
 			} : void 0
 		});
 		this.loaders = createLoaders({
 			pool: this.pool,
-			relays: this.#relays
+			relays: this.#relays,
+			index: this.index,
+			ingest: (event, relayUrl) => this.#ingest(event, relayUrl)
 		});
 	}
 	static builder() {
-		return new ClientBuilder();
+		return new ClientBuilder((opts) => new Client(opts));
 	}
 	get signer() {
 		return this.#signer;
@@ -509,28 +656,30 @@ var Client = class {
 	}
 	setSigner(signer) {
 		this.#signer = signer;
+		this.pool.resetAuth();
 	}
 	addRelay(url) {
-		if (!this.#relays.includes(url)) {
-			this.#relays.push(url);
-			this.loaders.context.addRelay(url);
+		const normalized = normalizeURL(url);
+		if (!this.#relays.includes(normalized)) {
+			this.#relays.push(normalized);
+			this.loaders.addRelay(normalized);
 		}
 	}
 	removeRelay(url) {
-		this.#relays = this.#relays.filter((r) => r !== url);
-		this.loaders.context.removeRelay(url);
-		this.pool.close([url]);
+		const normalized = normalizeURL(url);
+		this.#relays = this.#relays.filter((r) => r !== normalized);
+		this.loaders.removeRelay(normalized);
+		this.pool.close([normalized]);
 	}
 	/** 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 })));
+		await Promise.allSettled(this.#relays.map(async (url) => this.pool.ensureRelay(url, { signal: opts?.signal })));
 	}
 	async shutdown() {
 		this.#shutdown = true;
-		while (this.#flushing) await this.#flushing;
+		while (this.#flushing !== void 0) await this.#flushing;
 		this.pool.close();
-		this.loaders.context.cache.clear();
 	}
 	#assertAlive() {
 		if (this.#shutdown) throw new ClientError("client is shut down");
@@ -543,30 +692,38 @@ var Client = class {
 	#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();
+	/** Ingest one inbound event: index (with relay URL) → meta → persistence. */
+	observe(event, relayUrl) {
+		this.#ingest(event, relayUrl);
 	}
-	/** Observe many events (deduped by id, order preserved) as one persist batch. */
+	/** Ingest 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);
+			this.#ingest(event);
 		}
-		if (this.#persistEvents && this.#persistQueue.length > 0) this.#armFlush();
+	}
+	/**
+	* The single inbound-event pipeline: reactive index add (with the source relay URL recorded in
+	* seenOn), gossip routing meta, then the persistence decision. `persist: false` skips the storage
+	* queue for callers that persist via their own awaited `putMany` (down-sync); `meta: false` is a
+	* pure sighting/index add.
+	*/
+	#ingest(event, relayUrl, opts) {
+		this.index.add(event, relayUrl);
+		if (opts?.meta !== false) this.#ingestMeta(event);
+		if (opts?.persist === false || !this.#persistEvents) return;
+		this.#persistQueue.push(event);
+		this.#armFlush();
+	}
+	/** Record a relay sighting for an id already in the index. */
+	#markSeen(id, relayUrl) {
+		this.index.markSeen(id, relayUrl);
 	}
 	#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;
@@ -581,8 +738,8 @@ var Client = class {
 				const batch = this.#persistQueue.splice(0);
 				try {
 					await this.storage.putMany(batch);
-				} catch (err) {
-					this.onstorageerror?.(toStorageError(err));
+				} catch (error) {
+					invokeSafely(() => this.onstorageerror?.(toStorageError(error)));
 				}
 			}
 		} finally {
@@ -591,13 +748,13 @@ var Client = class {
 		}
 	}
 	/**
-	* Explicitly load kind:10002 and kind:10050 lists for pubkeys and feed gossip.
-	* Does not background-fetch unknown authors on every subscribe (predictable DX).
+	* 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 style = opts?.force === true ? "force" : "default";
 			const [relayList, dmList] = await Promise.all([this.loaders.relayList(pk, {
 				hints: opts?.hints,
 				style
@@ -610,8 +767,8 @@ var Client = class {
 		}));
 	}
 	/**
-	* Create an outbox-model feed for the given authors (NIP-65 write relays).
-	* Live events go through {@link observe}; sync persists via applySync.
+	* 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();
@@ -624,22 +781,27 @@ var Client = class {
 			kinds: opts.kinds,
 			onEvent: opts.onEvent,
 			maxRelaysPerAuthor: opts.maxRelaysPerAuthor,
-			observe: (event) => this.observe(event),
+			observe: (event, relayUrl) => this.observe(event, relayUrl),
+			seen: (event, relayUrl) => this.#ingest(event, relayUrl, {
+				persist: false,
+				meta: false
+			}),
 			applySync: async (events) => {
 				if (!this.#persistEvents) {
-					for (const event of events) this.#ingestMeta(event);
+					for (const event of events) this.#ingest(event, void 0, { persist: false });
 					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]);
+				for (const [i, event] of events.entries()) {
+					const result = results[i];
+					if (result === "rejected" || result === "ephemeral" || result === "invalid") continue;
+					this.#ingest(event, void 0, { persist: false });
+					applied.push(event);
 				}
 				return applied;
 			},
-			hydrate: (pubkeys) => this.hydrateGossip(pubkeys)
+			hydrate: async (pubkeys) => this.hydrateGossip(pubkeys)
 		});
 	}
 	async getPublicKey() {
@@ -663,27 +825,26 @@ var Client = class {
 		});
 	}
 	/**
-	* 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.
+	* 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) {
+		else if (!relays && opts?.gossip === true) {
 			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]));
+			for (const tag of event.tags) if (tag[0] === "p" && tag[1] !== void 0) 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;
+				if (tag[0] !== "e" && tag[0] !== "a" || tag[2] === void 0) continue;
 				try {
 					const url = normalizeURL(tag[2]);
 					if (!urls.includes(url)) {
@@ -695,46 +856,57 @@ var Client = class {
 			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);
+		if (results.some((r) => r.result?.ok === true) && 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.
+	* 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 candidates = [];
+		if (opts?.localFirst === true) 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);
+			for (const e of local) {
+				candidates.push(e);
+				if (shouldObserve) this.#ingest(e, void 0, {
+					persist: false,
+					meta: false
+				});
 			}
-		};
-		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()]);
+		} catch (error) {
+			invokeSafely(() => this.onstorageerror?.(toStorageError(error)));
 		}
-		ingest(await fetchGossip(this.pool, this.gossip, filters, () => this.#defaultRelays(), {
+		const onevent = (event, relayUrl) => {
+			if (shouldObserve) this.#ingest(event, relayUrl, {
+				persist: false,
+				meta: false
+			});
+			opts?.onevent?.(event, relayUrl);
+		};
+		const batch = opts?.gossip !== true || opts.relays !== void 0 ? await this.pool.fetch(this.#defaultRelays(opts?.relays), filters, {
 			timeoutMs: opts?.timeoutMs,
-			signal: opts?.signal
-		}));
-		return sortedEvents([...byId.values()]);
+			signal: opts?.signal,
+			onevent
+		}) : await fetchGossip(this.pool, this.gossip, filters, () => this.#defaultRelays(), {
+			timeoutMs: opts?.timeoutMs,
+			signal: opts?.signal,
+			onevent
+		});
+		for (const e of batch) {
+			candidates.push(e);
+			if (shouldObserve) this.observe(e);
+		}
+		const tmp = new MemoryIndex();
+		const ephemeral = /* @__PURE__ */ new Map();
+		const merged = opts?.localFirst === true ? [...this.index.query(filters), ...candidates] : candidates;
+		for (const e of merged) if (tmp.put(e) === "ephemeral" && matchFilters(filters, e)) ephemeral.set(e.id, e);
+		return sortedEvents([...tmp.query(filters), ...ephemeral.values()]);
 	}
-	/**
-	* Query local storage only (no network).
-	*/
+	/** Query local storage only (no network). */
 	async queryLocal(filter) {
 		this.#assertAlive();
 		const filters = canonicalizeFilters(Array.isArray(filter) ? filter : [filter]);
@@ -744,12 +916,17 @@ var Client = class {
 		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);
+		const wrapEvent = (event, relayUrl) => {
+			if (shouldObserve) this.observe(event, relayUrl);
+			opts?.onevent?.(event, relayUrl);
+		};
+		const wrapReceived = (id, relayUrl) => {
+			if (shouldObserve) this.#markSeen(id, relayUrl);
+			opts?.receivedEvent?.(id, relayUrl);
 		};
-		if (!opts?.gossip || opts.relays) return this.pool.subscribe(this.#defaultRelays(opts?.relays), filters, {
+		if (opts?.gossip !== true || opts.relays !== void 0) return this.pool.subscribe(this.#defaultRelays(opts?.relays), filters, {
 			onevent: wrapEvent,
+			receivedEvent: wrapReceived,
 			oneose: opts?.oneose,
 			onclose: opts?.onclose,
 			signal: opts?.signal,
@@ -758,6 +935,7 @@ var Client = class {
 		});
 		return subscribeGossip(this.pool, this.gossip, filters, () => this.#defaultRelays(), {
 			onevent: wrapEvent,
+			receivedEvent: wrapReceived,
 			oneose: opts?.oneose,
 			onclose: opts?.onclose,
 			signal: opts?.signal,
@@ -769,21 +947,20 @@ var Client = class {
 		return requireNip59Crypto(this.#signer);
 	}
 	#throwIfAborted(signal) {
-		if (!signal?.aborted) return;
-		if (signal.reason instanceof Error) throw signal.reason;
-		throw new ClientError("aborted");
+		throwIfAborted(signal);
 	}
 	#dmDeps() {
 		return {
 			pool: this.pool,
 			gossip: this.gossip,
-			hydrateGossip: (pubkeys) => this.hydrateGossip(pubkeys),
-			observe: (event) => this.observe(event),
+			hydrateGossip: async (pubkeys) => this.hydrateGossip(pubkeys),
+			ingest: (event, relayUrl) => this.#ingest(event, relayUrl),
+			markSeen: (id, relayUrl) => this.#markSeen(id, relayUrl),
 			assertAlive: () => this.#assertAlive(),
 			requireNip59Crypto: () => this.#requireNip59Crypto(),
 			throwIfAborted: (signal) => this.#throwIfAborted(signal),
 			wantObserve: (flag) => this.#wantObserve(flag),
-			publish: (eventOrBuilder, opts) => this.publish(eventOrBuilder, opts)
+			publish: async (eventOrBuilder, opts) => this.publish(eventOrBuilder, opts)
 		};
 	}
 	#syncDeps() {
@@ -794,7 +971,8 @@ var Client = class {
 			assertAlive: () => this.#assertAlive(),
 			throwIfAborted: (signal) => this.#throwIfAborted(signal),
 			wantObserve: (flag) => this.#wantObserve(flag),
-			ingestMeta: (event) => this.#ingestMeta(event),
+			ingest: (event, relayUrl, opts) => this.#ingest(event, relayUrl, opts),
+			markSeen: (id, relayUrl) => this.#markSeen(id, relayUrl),
 			defaultRelays: (urls) => this.#defaultRelays(urls)
 		};
 	}
@@ -812,18 +990,17 @@ var Client = class {
 		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.
+	* NIP-77 sync against one relay: reconcile, then optionally upload local-only events and/or
+	* download remote-only events. `observe: false` skips putMany and ingest; received ids are still
+	* listed. `persistEvents: false` skips putMany, still ingests 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.
+	* 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);
@@ -832,4 +1009,4 @@ var Client = class {
 //#endregion
 export { ClientBuilder as i, ClientError as n, SyncDirection as r, Client as t };
 
-//# sourceMappingURL=client-Bd8B1mYm.mjs.map
+//# sourceMappingURL=client-5DhgYV7P.mjs.map