@qntx/nostr 0.0.1

package/dist/loaders-BNQszDAn.mjs

@@ -0,0 +1,767 @@
+import { a as isHex32, s as normalizeURL } from "./util-6tfLQ9JF.mjs";
+import { a as NostrError } from "./error-DZEs5OuZ.mjs";
+import { r as isAddressableKind, t as Kind } from "./kind-BLl4cLOc.mjs";
+import { _ as getDTag, d as sortedEvents, i as isReplaceableWinner } from "./event-CzoQEFMF.mjs";
+import { Nip19Error, decode, npubEncode } from "./nips/nip19.mjs";
+import { parseRelayList } from "./nips/nip65.mjs";
+import { parseDmRelayList } from "./nips/nip17.mjs";
+import { n as toStorageError } from "./error-CwBxle6N.mjs";
+//#region src/loaders/cache.ts
+function keyOf(spec) {
+	return `${spec.kind}:${spec.pubkey.toLowerCase()}:${spec.dTag ?? ""}`;
+}
+/** In-memory replaceable-event cache used by loaders (no DOM / localStorage). */
+var ReplaceableCache = class {
+	#events = /* @__PURE__ */ new Map();
+	get(spec) {
+		return this.#events.get(keyOf(spec));
+	}
+	set(spec, event, fetchedAt = Math.floor(Date.now() / 1e3)) {
+		this.#events.set(keyOf(spec), {
+			event,
+			fetchedAt
+		});
+	}
+	/** Keep newer event by created_at. */
+	putIfNewer(event, dTag) {
+		const spec = {
+			kind: event.kind,
+			pubkey: event.pubkey,
+			dTag
+		};
+		const prev = this.get(spec);
+		if (!prev?.event || isReplaceableWinner(event, prev.event)) this.set(spec, event);
+	}
+	clear(spec) {
+		if (spec) this.#events.delete(keyOf(spec));
+		else this.#events.clear();
+	}
+	get size() {
+		return this.#events.size;
+	}
+};
+//#endregion
+//#region src/loaders/context.ts
+/**
+* Explicit dependency bag for loaders — never a module-level singleton.
+*/
+var LoaderContext = class {
+	pool;
+	cache;
+	staleAfterSec;
+	fetchTimeoutMs;
+	#relays;
+	constructor(opts) {
+		this.pool = opts.pool;
+		this.#relays = [...opts.relays];
+		this.cache = opts.cache ?? new ReplaceableCache();
+		this.staleAfterSec = opts.staleAfterSec ?? 172800;
+		this.fetchTimeoutMs = opts.fetchTimeoutMs ?? 4400;
+	}
+	/** Snapshot of discovery/fallback relays. */
+	get relays() {
+		return this.#relays;
+	}
+	addRelay(url) {
+		if (!this.#relays.includes(url)) this.#relays.push(url);
+	}
+	removeRelay(url) {
+		this.#relays = this.#relays.filter((r) => r !== url);
+	}
+	setRelays(urls) {
+		this.#relays = [...urls];
+	}
+	isFresh(fetchedAt, now = Math.floor(Date.now() / 1e3)) {
+		return now - fetchedAt < this.staleAfterSec;
+	}
+};
+//#endregion
+//#region src/loaders/event.ts
+function dFilter(kind, identifier) {
+	if (isAddressableKind(kind)) return { "#d": [identifier] };
+	return {};
+}
+function parseRef(ref) {
+	if (typeof ref === "string") {
+		if (isHex32(ref)) return {
+			filter: { ids: [ref.toLowerCase()] },
+			hints: [],
+			cacheKey: `id:${ref.toLowerCase()}`
+		};
+		const decoded = decode(ref);
+		switch (decoded.type) {
+			case "note": return {
+				filter: { ids: [decoded.data] },
+				hints: [],
+				cacheKey: `id:${decoded.data}`
+			};
+			case "nevent": return {
+				filter: { ids: [decoded.data.id] },
+				hints: decoded.data.relays ?? [],
+				cacheKey: `id:${decoded.data.id}`
+			};
+			case "naddr": return {
+				filter: {
+					authors: [decoded.data.pubkey.toLowerCase()],
+					kinds: [decoded.data.kind],
+					...dFilter(decoded.data.kind, decoded.data.identifier)
+				},
+				hints: decoded.data.relays ?? [],
+				cacheKey: `addr:${decoded.data.kind}:${decoded.data.pubkey}:${decoded.data.identifier}`
+			};
+			default: throw new Nip19Error(`cannot load event from ${decoded.type}`);
+		}
+	}
+	if ("id" in ref) return {
+		filter: { ids: [ref.id.toLowerCase()] },
+		hints: ref.relays ?? [],
+		cacheKey: `id:${ref.id.toLowerCase()}`
+	};
+	return {
+		filter: {
+			authors: [ref.pubkey.toLowerCase()],
+			kinds: [ref.kind],
+			...dFilter(ref.kind, ref.identifier)
+		},
+		hints: ref.relays ?? [],
+		cacheKey: `addr:${ref.kind}:${ref.pubkey}:${ref.identifier}`
+	};
+}
+function createEventLoader(ctx) {
+	const inflight = /* @__PURE__ */ new Map();
+	const cache = /* @__PURE__ */ new Map();
+	return {
+		load(ref) {
+			const parsed = parseRef(ref);
+			if (cache.has(parsed.cacheKey)) return Promise.resolve(cache.get(parsed.cacheKey));
+			const hit = inflight.get(parsed.cacheKey);
+			if (hit) return hit;
+			const p = (async () => {
+				const relays = [.../* @__PURE__ */ new Set([...parsed.hints, ...ctx.relays])];
+				if (relays.length === 0) return void 0;
+				const events = await ctx.pool.fetch(relays, [parsed.filter], { timeoutMs: ctx.fetchTimeoutMs });
+				let best;
+				for (const e of events) if (!best || isReplaceableWinner(e, best)) best = e;
+				cache.set(parsed.cacheKey, best);
+				return best;
+			})().finally(() => inflight.delete(parsed.cacheKey));
+			inflight.set(parsed.cacheKey, p);
+			return p;
+		},
+		clearAll() {
+			inflight.clear();
+			cache.clear();
+		}
+	};
+}
+//#endregion
+//#region src/loaders/dataloader.ts
+var LoaderError = class extends NostrError {};
+var DataLoader = class {
+	#batchLoadFn;
+	#cacheKeyFn;
+	#maxBatchSize;
+	#useCache;
+	#cache = /* @__PURE__ */ new Map();
+	#inflight = /* @__PURE__ */ new Map();
+	#queue = [];
+	#scheduled = false;
+	constructor(batchLoadFn, options = {}) {
+		this.#batchLoadFn = batchLoadFn;
+		this.#cacheKeyFn = options.cacheKeyFn ?? ((k) => k);
+		this.#maxBatchSize = options.maxBatchSize ?? Infinity;
+		this.#useCache = options.cache !== false;
+	}
+	load(key) {
+		const cacheKey = this.#cacheKeyFn(key);
+		if (this.#useCache) {
+			const cached = this.#cache.get(cacheKey);
+			if (cached) return cached;
+		}
+		const inflight = this.#inflight.get(cacheKey);
+		if (inflight) return inflight;
+		const promise = new Promise((resolve, reject) => {
+			this.#queue.push({
+				key,
+				resolve,
+				reject
+			});
+			if (this.#queue.length >= this.#maxBatchSize) this.#dispatch();
+			else if (!this.#scheduled) {
+				this.#scheduled = true;
+				queueMicrotask(() => this.#dispatch());
+			}
+		}).finally(() => {
+			this.#inflight.delete(cacheKey);
+		});
+		this.#inflight.set(cacheKey, promise);
+		if (this.#useCache) this.#cache.set(cacheKey, promise);
+		return promise;
+	}
+	clear(key) {
+		this.#cache.delete(this.#cacheKeyFn(key));
+		this.#inflight.delete(this.#cacheKeyFn(key));
+	}
+	clearAll() {
+		this.#cache.clear();
+		this.#inflight.clear();
+	}
+	#dispatch() {
+		this.#scheduled = false;
+		const batch = this.#queue.splice(0, this.#maxBatchSize);
+		if (batch.length === 0) return;
+		const keys = batch.map((b) => b.key);
+		this.#batchLoadFn(keys).then((values) => {
+			if (values.length !== keys.length) {
+				const err = new LoaderError(`DataLoader batch function must return array of length ${keys.length}, got ${values.length}`);
+				for (const item of batch) item.reject(err);
+				return;
+			}
+			for (let i = 0; i < batch.length; i++) {
+				const value = values[i];
+				if (value instanceof Error) batch[i].reject(value);
+				else batch[i].resolve(value);
+			}
+		}).catch((err) => {
+			for (const item of batch) item.reject(err);
+		});
+		if (this.#queue.length > 0) {
+			this.#scheduled = true;
+			queueMicrotask(() => this.#dispatch());
+		}
+	}
+};
+//#endregion
+//#region src/loaders/replaceable.ts
+/**
+* Batch-fetch replaceable events (kind + authors) via the pool, with cache.
+* Durable cache is ReplaceableCache; DataLoader only coalesces in-flight requests.
+*/
+function createReplaceableLoader(ctx, kind) {
+	const loader = new DataLoader(async (keys) => {
+		const authors = [...new Set(keys.map((k) => k.pubkey))];
+		const hintRelays = [...new Set(keys.flatMap((k) => k.hints ?? []).concat(ctx.relays))];
+		const filter = {
+			kinds: [kind],
+			authors
+		};
+		const events = hintRelays.length > 0 ? await ctx.pool.fetch(hintRelays, [filter], { timeoutMs: ctx.fetchTimeoutMs }) : [];
+		const best = /* @__PURE__ */ new Map();
+		for (const event of events) {
+			if (event.kind !== kind) continue;
+			const prev = best.get(event.pubkey);
+			if (!prev || isReplaceableWinner(event, prev)) best.set(event.pubkey, event);
+		}
+		const now = Math.floor(Date.now() / 1e3);
+		return keys.map((k) => {
+			const event = best.get(k.pubkey) ?? null;
+			ctx.cache.set({
+				kind,
+				pubkey: k.pubkey,
+				dTag: event ? getDTag(event.tags) ?? void 0 : void 0
+			}, event, now);
+			return event;
+		});
+	}, {
+		cache: false,
+		cacheKeyFn: (k) => `${kind}:${k.pubkey}:${(k.hints ?? []).join(",")}`,
+		maxBatchSize: 50
+	});
+	return {
+		async load(pubkey, opts) {
+			const pk = pubkey.toLowerCase();
+			const style = opts?.style ?? "default";
+			const cached = ctx.cache.get({
+				kind,
+				pubkey: pk
+			});
+			if (style === "cache-only") return {
+				event: cached?.event ?? null,
+				fresh: false
+			};
+			if (style === "default" && cached && ctx.isFresh(cached.fetchedAt)) return {
+				event: cached.event,
+				fresh: false
+			};
+			return {
+				event: await loader.load({
+					pubkey: pk,
+					hints: opts?.hints
+				}),
+				fresh: true
+			};
+		},
+		clear(pubkey) {
+			if (pubkey) {
+				const pk = pubkey.toLowerCase();
+				loader.clear({ pubkey: pk });
+				ctx.cache.clear({
+					kind,
+					pubkey: pk
+				});
+			} else loader.clearAll();
+		}
+	};
+}
+//#endregion
+//#region src/loaders/lists.ts
+function fromTags(event, map) {
+	if (!event) return [];
+	const out = [];
+	for (const tag of event.tags) {
+		const item = map(tag);
+		if (item !== void 0) out.push(item);
+	}
+	return out;
+}
+function createListLoaders(ctx) {
+	const followsLoader = createReplaceableLoader(ctx, Kind.Contacts);
+	const muteLoader = createReplaceableLoader(ctx, Kind.MuteList);
+	const relayListLoader = createReplaceableLoader(ctx, Kind.RelayList);
+	const dmRelayListLoader = createReplaceableLoader(ctx, Kind.DirectMessageRelaysList);
+	return {
+		async follows(pubkey, opts) {
+			const { event, fresh } = await followsLoader.load(pubkey, opts);
+			return {
+				event,
+				fresh,
+				items: fromTags(event, (tag) => tag[0] === "p" && tag[1] && isHex32(tag[1]) ? tag[1].toLowerCase() : void 0)
+			};
+		},
+		async muteList(pubkey, opts) {
+			const { event, fresh } = await muteLoader.load(pubkey, opts);
+			return {
+				event,
+				fresh,
+				items: fromTags(event, (tag) => {
+					if (!tag[1]) return void 0;
+					switch (tag[0]) {
+						case "p": return isHex32(tag[1]) ? {
+							label: "pubkey",
+							value: tag[1].toLowerCase()
+						} : void 0;
+						case "e": return isHex32(tag[1]) ? {
+							label: "thread",
+							value: tag[1].toLowerCase()
+						} : void 0;
+						case "t": return {
+							label: "hashtag",
+							value: tag[1]
+						};
+						case "word": return {
+							label: "word",
+							value: tag[1]
+						};
+						default: return;
+					}
+				})
+			};
+		},
+		async relayList(pubkey, opts) {
+			const { event, fresh } = await relayListLoader.load(pubkey, opts);
+			let items = [];
+			if (event) try {
+				items = parseRelayList(event);
+			} catch {
+				items = [];
+			}
+			items = items.map((i) => {
+				try {
+					return {
+						...i,
+						url: normalizeURL(i.url)
+					};
+				} catch {
+					return i;
+				}
+			});
+			return {
+				event,
+				fresh,
+				items
+			};
+		},
+		async dmRelayList(pubkey, opts) {
+			const { event, fresh } = await dmRelayListLoader.load(pubkey, opts);
+			let items = [];
+			if (event) try {
+				items = parseDmRelayList(event);
+			} catch {
+				items = [];
+			}
+			return {
+				event,
+				fresh,
+				items
+			};
+		}
+	};
+}
+//#endregion
+//#region src/loaders/profile.ts
+function bareNostrUser(pubkey) {
+	const pk = pubkey.toLowerCase();
+	let npub;
+	try {
+		npub = npubEncode(pk);
+	} catch {
+		npub = pk;
+	}
+	return {
+		pubkey: pk,
+		npub,
+		shortName: npub.startsWith("npub1") ? `${npub.slice(0, 8)}…${npub.slice(-4)}` : pk.slice(0, 8),
+		metadata: {},
+		lastUpdated: 0,
+		event: null,
+		fresh: false
+	};
+}
+function parseMetadata(content) {
+	try {
+		const obj = JSON.parse(content);
+		return typeof obj === "object" && obj !== null ? obj : {};
+	} catch {
+		return {};
+	}
+}
+function createProfileLoader(ctx) {
+	const loader = createReplaceableLoader(ctx, Kind.Metadata);
+	return { async load(pubkey, opts) {
+		const base = bareNostrUser(pubkey);
+		const { event, fresh } = await loader.load(pubkey, opts);
+		if (!event) return {
+			...base,
+			fresh
+		};
+		const metadata = parseMetadata(event.content);
+		const display = metadata.display_name || metadata.name;
+		return {
+			...base,
+			shortName: display || base.shortName,
+			image: metadata.picture,
+			metadata,
+			lastUpdated: event.created_at,
+			event,
+			fresh
+		};
+	} };
+}
+//#endregion
+//#region src/loaders/outbox.ts
+var OutboxError = class extends NostrError {};
+function boundKey(pubkey, kind) {
+	return `${pubkey.toLowerCase()}:${kind}`;
+}
+/** Same skip/dedup as Gossip.setRoutes so prefer can match Client.relays. */
+function canonicalRelayUrls(urls) {
+	const out = [];
+	for (const raw of urls) try {
+		const url = normalizeURL(raw);
+		if (!out.includes(url)) out.push(url);
+	} catch {}
+	return out;
+}
+/**
+* Group authors by outbox relay (discovery fallback).
+* `prefer` reorders existing candidates only; it never appends a URL
+* that is not already in the author's outbox or discovery list.
+* Returns Map<relayUrl, authors[]>.
+*/
+function groupAuthorsByOutboxRelay(authors, gossip, discoveryRelays, maxRelaysPerAuthor = 3, prefer = []) {
+	const leftover = new Set((gossip.route({ authors: authors.map((a) => a.toLowerCase()) }).remainder?.authors ?? []).map((a) => a.toLowerCase()));
+	const preferSet = new Set(canonicalRelayUrls(prefer));
+	const discovery = canonicalRelayUrls(discoveryRelays);
+	const map = /* @__PURE__ */ new Map();
+	for (const author of authors) {
+		const pk = author.toLowerCase();
+		const urls = leftover.has(pk) ? discovery : gossip.outboxRelays(pk);
+		const preferred = [];
+		const rest = [];
+		for (const url of urls) if (preferSet.has(url)) preferred.push(url);
+		else rest.push(url);
+		for (const url of preferred.concat(rest).slice(0, maxRelaysPerAuthor)) {
+			const list = map.get(url) ?? [];
+			if (!list.includes(pk)) list.push(pk);
+			map.set(url, list);
+		}
+	}
+	return map;
+}
+/**
+* Outbox-model feed: history sync + live subscription for a set of authors,
+* routed via NIP-65 write relays (with discovery fallback).
+*/
+var OutboxFeed = class {
+	#pool;
+	#gossip;
+	#storage;
+	#discovery;
+	#kinds;
+	#maxRelays;
+	#timeoutMs;
+	#onEvent;
+	#observe;
+	#applySync;
+	#hydrate;
+	#bounds = /* @__PURE__ */ new Map();
+	#authors;
+	#liveCloser;
+	#closed = false;
+	constructor(opts) {
+		this.#pool = opts.pool;
+		this.#gossip = opts.gossip;
+		this.#storage = opts.storage;
+		this.#discovery = [...opts.discoveryRelays];
+		this.#authors = [...new Set(opts.authors.map((a) => a.toLowerCase()))];
+		this.#kinds = [...opts.kinds ?? [Kind.TextNote]];
+		this.#maxRelays = opts.maxRelaysPerAuthor ?? 3;
+		this.#timeoutMs = opts.fetchTimeoutMs ?? 4400;
+		this.#onEvent = opts.onEvent;
+		this.#observe = opts.observe;
+		this.#applySync = opts.applySync;
+		this.#hydrate = opts.hydrate;
+	}
+	get authors() {
+		return this.#authors;
+	}
+	get kinds() {
+		return this.#kinds;
+	}
+	/** Replace the author set (does not auto-restart live). */
+	setAuthors(authors) {
+		this.#authors = [...new Set(authors.map((a) => a.toLowerCase()))];
+	}
+	getBound(pubkey, kind) {
+		return this.#bounds.get(boundKey(pubkey, kind));
+	}
+	/**
+	* Load NIP-65 relay lists for authors that have no outbox routes yet.
+	*/
+	async hydrate() {
+		this.#assertOpen();
+		if (!this.#hydrate) return;
+		const missing = this.#authors.filter((pk) => this.#gossip.outboxRelays(pk).length === 0);
+		if (missing.length === 0) return;
+		await this.#hydrate(missing);
+	}
+	/**
+	* One-shot history pull. Persistence is `applySync`; bounds move only for events it returns.
+	*/
+	async sync(opts) {
+		this.#assertOpen();
+		if (!opts?.skipHydrate) await this.hydrate();
+		await this.#hydrateBoundsFromStore();
+		const byRelay = groupAuthorsByOutboxRelay(this.#authors, this.#gossip, this.#discovery, this.#maxRelays, this.#pool.connectedUrls());
+		if (byRelay.size === 0) return [];
+		const byId = /* @__PURE__ */ new Map();
+		await Promise.all([...byRelay.entries()].map(async ([url, authors]) => {
+			if (opts?.signal?.aborted) return;
+			const filters = this.#syncFilters(authors, opts);
+			try {
+				const batch = await this.#pool.fetch([url], filters, {
+					timeoutMs: this.#timeoutMs,
+					signal: opts?.signal
+				});
+				for (const event of batch) byId.set(event.id, event);
+			} catch {}
+		}));
+		const unique = [...byId.values()];
+		if (unique.length === 0) return [];
+		let applied = [];
+		if (this.#applySync) try {
+			applied = await this.#applySync(unique);
+		} catch (err) {
+			throw toStorageError(err);
+		}
+		const dirty = /* @__PURE__ */ new Set();
+		for (const event of applied) {
+			this.#updateBounds(event);
+			dirty.add(boundKey(event.pubkey, event.kind));
+			this.#onEvent?.(event);
+		}
+		await this.#persistBounds(dirty);
+		return sortedEvents(unique);
+	}
+	/**
+	* Start a live subscription across outbox relays for the current authors.
+	* Closes any previous live subscription.
+	*/
+	startLive(opts) {
+		this.#assertOpen();
+		this.#liveCloser?.close("restart");
+		const byRelay = groupAuthorsByOutboxRelay(this.#authors, this.#gossip, this.#discovery, this.#maxRelays, this.#pool.connectedUrls());
+		const seen = /* @__PURE__ */ new Set();
+		const closers = [];
+		const since = opts?.since ?? Math.floor(Date.now() / 1e3) - 60;
+		for (const [url, authors] of byRelay) {
+			const filter = {
+				authors,
+				kinds: this.#kinds,
+				since
+			};
+			closers.push(this.#pool.subscribe([url], [filter], {
+				signal: opts?.signal,
+				onevent: (event) => {
+					if (seen.has(event.id)) return;
+					seen.add(event.id);
+					this.#noteEvent(event);
+				}
+			}));
+		}
+		const closer = { close: (reason) => {
+			for (const c of closers) c.close(reason);
+			if (this.#liveCloser === closer) this.#liveCloser = void 0;
+		} };
+		this.#liveCloser = closer;
+		return closer;
+	}
+	/** Convenience: hydrate + sync + startLive. */
+	async start(opts) {
+		const events = await this.sync({
+			limit: opts?.limit,
+			signal: opts?.signal
+		});
+		const live = this.startLive({ signal: opts?.signal });
+		return {
+			close: (r) => live.close(r),
+			events
+		};
+	}
+	close() {
+		this.#closed = true;
+		this.#liveCloser?.close("feed closed");
+		this.#liveCloser = void 0;
+	}
+	#assertOpen() {
+		if (this.#closed) throw new OutboxError("OutboxFeed is closed");
+	}
+	async #hydrateBoundsFromStore() {
+		await Promise.all(this.#authors.flatMap((pk) => this.#kinds.map(async (kind) => {
+			const key = boundKey(pk, kind);
+			if (this.#bounds.has(key)) return;
+			const bound = await this.#storage.getOutboxBound(pk, kind);
+			if (!bound) return;
+			await this.#storage.setOutboxBound(pk, kind, bound);
+			this.#bounds.set(key, {
+				oldest: bound.oldest,
+				newest: bound.newest
+			});
+		})));
+	}
+	#syncFilters(authors, opts) {
+		const base = {
+			kinds: this.#kinds,
+			limit: opts?.limit ?? 50,
+			...opts?.until !== void 0 ? { until: opts.until } : {}
+		};
+		if (opts?.since !== void 0) return [{
+			...base,
+			authors,
+			since: opts.since
+		}];
+		const bounded = [];
+		const unbounded = [];
+		let minBoundedNewest;
+		for (const pk of authors) {
+			let newest;
+			let complete = true;
+			for (const kind of this.#kinds) {
+				const b = this.#bounds.get(boundKey(pk, kind));
+				if (!b) {
+					complete = false;
+					break;
+				}
+				if (newest === void 0 || b.newest < newest) newest = b.newest;
+			}
+			if (complete && newest !== void 0) {
+				bounded.push(pk);
+				if (minBoundedNewest === void 0 || newest < minBoundedNewest) minBoundedNewest = newest;
+			} else unbounded.push(pk);
+		}
+		if (bounded.length === 0 || minBoundedNewest === void 0) return [{
+			...base,
+			authors
+		}];
+		if (unbounded.length === 0) return [{
+			...base,
+			authors,
+			since: Math.max(0, minBoundedNewest - 1)
+		}];
+		return [{
+			...base,
+			authors: bounded,
+			since: Math.max(0, minBoundedNewest - 1)
+		}, {
+			...base,
+			authors: unbounded
+		}];
+	}
+	#noteEvent(event) {
+		this.#updateBounds(event);
+		const bound = this.#bounds.get(boundKey(event.pubkey, event.kind));
+		if (bound) this.#storage.setOutboxBound(event.pubkey, event.kind, {
+			oldest: bound.oldest,
+			newest: bound.newest
+		}).catch(() => {});
+		this.#observe?.(event);
+		this.#onEvent?.(event);
+	}
+	async #persistBounds(keys) {
+		const writes = [];
+		for (const key of keys) {
+			const bound = this.#bounds.get(key);
+			if (!bound) continue;
+			const sep = key.lastIndexOf(":");
+			writes.push(this.#storage.setOutboxBound(key.slice(0, sep), Number(key.slice(sep + 1)), {
+				oldest: bound.oldest,
+				newest: bound.newest
+			}));
+		}
+		if (writes.length === 0) return;
+		try {
+			await Promise.all(writes);
+		} catch (err) {
+			throw toStorageError(err);
+		}
+	}
+	#updateBounds(event) {
+		const key = boundKey(event.pubkey, event.kind);
+		const prev = this.#bounds.get(key);
+		if (!prev) {
+			this.#bounds.set(key, {
+				oldest: event.created_at,
+				newest: event.created_at
+			});
+			return;
+		}
+		if (event.created_at < prev.oldest) prev.oldest = event.created_at;
+		if (event.created_at > prev.newest) prev.newest = event.created_at;
+	}
+};
+/** Factory matching other loaders helpers. */
+function createOutboxFeed(opts) {
+	return new OutboxFeed(opts);
+}
+//#endregion
+//#region src/loaders/index.ts
+/** Build an instance-scoped loader suite (no module globals). */
+function createLoaders(opts) {
+	const context = new LoaderContext(opts);
+	const lists = createListLoaders(context);
+	const profile = createProfileLoader(context);
+	const event = createEventLoader(context);
+	return {
+		context,
+		follows: (pubkey, o) => lists.follows(pubkey, o),
+		muteList: (pubkey, o) => lists.muteList(pubkey, o),
+		relayList: (pubkey, o) => lists.relayList(pubkey, o),
+		dmRelayList: (pubkey, o) => lists.dmRelayList(pubkey, o),
+		profile: (pubkey, o) => profile.load(pubkey, o),
+		event: (ref) => event.load(ref)
+	};
+}
+//#endregion
+export { groupAuthorsByOutboxRelay as a, createListLoaders as c, LoaderError as d, createEventLoader as f, createOutboxFeed as i, createReplaceableLoader as l, ReplaceableCache as m, OutboxError as n, bareNostrUser as o, LoaderContext as p, OutboxFeed as r, createProfileLoader as s, createLoaders as t, DataLoader as u };
+
+//# sourceMappingURL=loaders-BNQszDAn.mjs.map