@qntx/nostr 0.0.1

package/dist/storage-DOy0iLRE.mjs

@@ -0,0 +1,870 @@
+import { t as Kind } from "./kind-BLl4cLOc.mjs";
+import { a as itemCompare, h as eventAddress, i as isReplaceableWinner, u as sortEvents, y as parseEventAddress } from "./event-CzoQEFMF.mjs";
+import { o as matchFilter } from "./filter-BxwjEkZp.mjs";
+import { n as toStorageError, t as StorageError } from "./error-CwBxle6N.mjs";
+import { a as DeletionState, i as outboxBoundKey, n as decidePut, o as planDeletion, r as normalizeEvent } from "./memory-BCmhZPek.mjs";
+//#region src/storage/idb-types.ts
+const EVENTS = "events";
+const TAG_REFS = "tag_refs";
+const ADDRESSES = "addresses";
+const TOMBSTONES = "tombstones";
+const OUTBOX_BOUNDS = "outbox_bounds";
+const WRITE_STORES = [
+	EVENTS,
+	TAG_REFS,
+	ADDRESSES,
+	TOMBSTONES
+];
+//#endregion
+//#region src/storage/idb-helpers.ts
+function reqOf(req) {
+	return new Promise((resolve, reject) => {
+		req.onsuccess = () => resolve(req.result);
+		req.onerror = () => reject(req.error ?? new StorageError("IndexedDB request failed"));
+	});
+}
+function txDone(tx) {
+	return new Promise((resolve, reject) => {
+		tx.oncomplete = () => resolve();
+		tx.onerror = () => reject(tx.error ?? new StorageError("IndexedDB transaction failed"));
+	});
+}
+function walkCursor(source, range, direction, visit) {
+	return new Promise((resolve, reject) => {
+		const req = source.openCursor(range, direction);
+		req.onerror = () => reject(req.error ?? new StorageError("IndexedDB cursor failed"));
+		req.onsuccess = () => {
+			const cursor = req.result;
+			if (!cursor) {
+				resolve();
+				return;
+			}
+			if (visit(cursor)) {
+				resolve();
+				return;
+			}
+			cursor.continue();
+		};
+	});
+}
+function tagRefKey(name, value, id) {
+	return `${name}:${value.toLowerCase()}:${id.toLowerCase()}`;
+}
+function writeTagRefs(store, event) {
+	for (const tag of event.tags) {
+		if (tag[0] !== "e" && tag[0] !== "p" || tag[1] === void 0) continue;
+		const name = tag[0];
+		const value = tag[1].toLowerCase();
+		const id = event.id.toLowerCase();
+		store.put({
+			key: tagRefKey(name, value, id),
+			name,
+			value,
+			id,
+			created_at: event.created_at
+		});
+	}
+}
+function deleteStoredEvent(tx, event, addressRow) {
+	const tagRefs = tx.objectStore(TAG_REFS);
+	for (const tag of event.tags) if ((tag[0] === "e" || tag[0] === "p") && tag[1] !== void 0) tagRefs.delete(tagRefKey(tag[0], tag[1], event.id));
+	if (addressRow?.id === event.id) tx.objectStore(ADDRESSES).delete(addressRow.address);
+	tx.objectStore(EVENTS).delete(event.id);
+}
+function persistPlanTombstones(store, plan, coordIds, deletion) {
+	for (const id of plan.removeIds) {
+		store.put({
+			key: `id:${id}`,
+			type: "id"
+		});
+		store.delete(`pending:${id}`);
+	}
+	for (const id of coordIds) {
+		store.put({
+			key: `id:${id}`,
+			type: "id"
+		});
+		store.delete(`pending:${id}`);
+	}
+	for (const p of plan.pendingIds) {
+		if (deletion.ids.has(p.id)) continue;
+		store.put({
+			key: `pending:${p.id}`,
+			type: "pending",
+			pubkey: p.pubkey.toLowerCase()
+		});
+	}
+	for (const c of plan.coordinates) {
+		const prev = deletion.coordinates.get(c.key) ?? Number.NEGATIVE_INFINITY;
+		store.put({
+			key: `coord:${c.key}`,
+			type: "coord",
+			until: Math.max(prev, c.until)
+		});
+	}
+}
+function tombstonesToPlan(rows) {
+	const plan = {
+		removeIds: [],
+		pendingIds: [],
+		coordinates: []
+	};
+	for (const row of rows) {
+		if (!row || typeof row !== "object") continue;
+		const r = row;
+		if (r.type === "id" && typeof r.key === "string" && r.key.startsWith("id:")) {
+			plan.removeIds.push(r.key.slice(3).toLowerCase());
+			continue;
+		}
+		if (r.type === "pending" && typeof r.key === "string" && r.key.startsWith("pending:") && typeof r.pubkey === "string") {
+			plan.pendingIds.push({
+				id: r.key.slice(8).toLowerCase(),
+				pubkey: r.pubkey.toLowerCase()
+			});
+			continue;
+		}
+		if (r.type === "coord" && typeof r.key === "string" && r.key.startsWith("coord:") && typeof r.until === "number") plan.coordinates.push({
+			key: r.key.slice(6),
+			until: r.until
+		});
+	}
+	return plan;
+}
+function applyPutIndexedDb(tx, s, d) {
+	const events = tx.objectStore(EVENTS);
+	const tagRefs = tx.objectStore(TAG_REFS);
+	const addresses = tx.objectStore(ADDRESSES);
+	const tombstones = tx.objectStore(TOMBSTONES);
+	switch (d.action) {
+		case "skip": return d.result;
+		case "tombstone":
+			tombstones.put({
+				key: `id:${d.event.id}`,
+				type: "id"
+			});
+			tombstones.delete(`pending:${d.event.id}`);
+			s.deletion.ids.add(d.event.id);
+			s.deletion.pending.delete(d.event.id);
+			return "duplicate";
+		case "delete":
+			s.deletion.pending.delete(d.event.id);
+			persistPlanTombstones(tombstones, d.plan, d.coordIds, s.deletion);
+			s.deletion.absorb(d.plan);
+			for (const id of d.coordIds) s.deletion.ids.add(id);
+			events.put(d.event);
+			writeTagRefs(tagRefs, d.event);
+			return "deleted";
+		case "insert":
+			events.put(d.event);
+			writeTagRefs(tagRefs, d.event);
+			if (d.address) {
+				addresses.put({
+					address: d.address,
+					id: d.event.id,
+					created_at: d.event.created_at
+				});
+				s.replaceable.set(d.address, d.event.id);
+			}
+			return d.result;
+	}
+}
+//#endregion
+//#region src/storage/idb-query.ts
+function compareEventsDesc(a, b) {
+	if (a.created_at !== b.created_at) return b.created_at - a.created_at;
+	return a.id.localeCompare(b.id);
+}
+function prefixRange(prefix, since, until) {
+	return idbKeyRange().bound([...prefix, since ?? 0], [...prefix, until ?? Number.MAX_SAFE_INTEGER]);
+}
+function createdAtRange(since, until) {
+	return idbKeyRange().bound(since ?? 0, until ?? Number.MAX_SAFE_INTEGER);
+}
+function idbKeyRange() {
+	return globalThis.IDBKeyRange;
+}
+function epTagPrefixes(filter) {
+	const out = [];
+	for (const name of ["e", "p"]) {
+		const values = filter[`#${name}`];
+		if (!values) continue;
+		for (const value of values) out.push({
+			name,
+			value: value.toLowerCase()
+		});
+	}
+	return out;
+}
+function eventCursor(source, range) {
+	return {
+		open: () => source.openCursor(range, "prev"),
+		read: (cursor, ok) => {
+			ok(cursor.value);
+		}
+	};
+}
+function tagCursor(index, events, range) {
+	return {
+		open: () => index.openCursor(range, "prev"),
+		read: (cursor, ok, err) => {
+			const row = cursor.value;
+			const req = events.get(row.id);
+			req.onerror = () => err(req.error ?? new StorageError("IndexedDB get failed"));
+			req.onsuccess = () => ok(req.result);
+		}
+	};
+}
+function scanIds(tx, filter, accept, take) {
+	const ids = filter.ids ?? [];
+	const events = tx.objectStore(EVENTS);
+	const reqs = ids.map((id) => events.get(id.toLowerCase()));
+	return Promise.all(reqs.map((req) => reqOf(req))).then((rows) => {
+		const matched = [];
+		const seen = /* @__PURE__ */ new Set();
+		for (const event of rows) {
+			if (!event || seen.has(event.id) || !accept(event)) continue;
+			seen.add(event.id);
+			matched.push(event);
+		}
+		sortEvents(matched);
+		const out = filter.limit !== void 0 ? matched.slice(0, filter.limit) : matched;
+		for (const event of out) if (take(event)) break;
+	});
+}
+/** IDB auto-commits when onsuccess returns with no outstanding requests. */
+function kWayMerge(openers, accept, take) {
+	return new Promise((resolve, reject) => {
+		if (openers.length === 0) {
+			resolve();
+			return;
+		}
+		const slots = openers.map(() => ({
+			cursor: void 0,
+			head: void 0
+		}));
+		const seen = /* @__PURE__ */ new Set();
+		let inflight = 0;
+		let phase = "merge";
+		let drainT = 0;
+		let drainBuf = [];
+		const finish = () => {
+			if (phase === "done") return;
+			phase = "done";
+			resolve();
+		};
+		const fail = (error) => {
+			if (phase === "done") return;
+			phase = "done";
+			reject(error);
+		};
+		const stepCursor = (i) => {
+			const cursor = slots[i].cursor;
+			if (!cursor) return;
+			inflight++;
+			cursor.continue();
+		};
+		const emitDrain = () => {
+			sortEvents(drainBuf);
+			for (const event of drainBuf) {
+				if (seen.has(event.id) || !accept(event)) continue;
+				seen.add(event.id);
+				if (take(event)) {
+					finish();
+					return;
+				}
+			}
+			drainBuf = [];
+			phase = "merge";
+			pump();
+		};
+		const pump = () => {
+			if (phase === "done" || inflight > 0) return;
+			if (phase === "drain") {
+				emitDrain();
+				return;
+			}
+			let best;
+			for (let i = 0; i < slots.length; i++) {
+				const event = slots[i].head;
+				if (!event) continue;
+				if (!best || compareEventsDesc(event, best) < 0) best = event;
+			}
+			if (!best) {
+				finish();
+				return;
+			}
+			phase = "drain";
+			drainT = best.created_at;
+			drainBuf = [];
+			for (let i = 0; i < slots.length; i++) {
+				const event = slots[i].head;
+				if (!event || event.created_at !== drainT) continue;
+				drainBuf.push(event);
+				slots[i].head = void 0;
+				stepCursor(i);
+			}
+			if (inflight === 0) pump();
+		};
+		const onEvent = (i, event) => {
+			if (phase === "done") return;
+			const slot = slots[i];
+			const cursor = slot.cursor;
+			if (!event) {
+				if (cursor) {
+					inflight++;
+					cursor.continue();
+				} else pump();
+				return;
+			}
+			if (phase === "drain") {
+				if (event.created_at === drainT) {
+					drainBuf.push(event);
+					if (cursor) {
+						inflight++;
+						cursor.continue();
+					} else pump();
+					return;
+				}
+				slot.head = event;
+				pump();
+				return;
+			}
+			slot.head = event;
+			pump();
+		};
+		for (let i = 0; i < openers.length; i++) {
+			const req = openers[i].open();
+			req.onerror = () => fail(req.error ?? new StorageError("IndexedDB cursor failed"));
+			inflight++;
+			req.onsuccess = () => {
+				inflight--;
+				if (phase === "done") return;
+				const cursor = req.result;
+				const slot = slots[i];
+				if (!cursor) {
+					slot.cursor = void 0;
+					slot.head = void 0;
+					pump();
+					return;
+				}
+				slot.cursor = cursor;
+				inflight++;
+				openers[i].read(cursor, (event) => {
+					inflight--;
+					onEvent(i, event);
+				}, (error) => {
+					inflight--;
+					fail(error);
+				});
+			};
+		}
+	});
+}
+function scanFilter(tx, filter, accept, take) {
+	if (filter.limit === 0) return Promise.resolve();
+	if (filter.since !== void 0 && filter.until !== void 0 && filter.since > filter.until) return Promise.resolve();
+	if (filter.ids) return scanIds(tx, filter, accept, take);
+	const events = tx.objectStore(EVENTS);
+	const openers = [];
+	if (filter.authors && filter.kinds) {
+		const index = events.index("kind_pubkey_created_at");
+		for (const kind of filter.kinds) for (const pk of filter.authors) openers.push(eventCursor(index, prefixRange([kind, pk.toLowerCase()], filter.since, filter.until)));
+	} else if (filter.authors) {
+		const index = events.index("pubkey_created_at");
+		for (const pk of filter.authors) openers.push(eventCursor(index, prefixRange([pk.toLowerCase()], filter.since, filter.until)));
+	} else if (filter.kinds) {
+		const index = events.index("kind_created_at");
+		for (const kind of filter.kinds) openers.push(eventCursor(index, prefixRange([kind], filter.since, filter.until)));
+	} else {
+		const tags = epTagPrefixes(filter);
+		if (tags.length > 0) {
+			const index = tx.objectStore(TAG_REFS).index("name_value_created");
+			for (const tag of tags) openers.push(tagCursor(index, events, prefixRange([tag.name, tag.value], filter.since, filter.until)));
+		} else openers.push(eventCursor(events.index("created_at"), createdAtRange(filter.since, filter.until)));
+	}
+	return kWayMerge(openers, accept, take);
+}
+function openDb(dbName) {
+	return new Promise((resolve, reject) => {
+		const req = globalThis.indexedDB.open(dbName, 4);
+		req.onupgradeneeded = (ev) => {
+			const db = req.result;
+			const oldVersion = ev.oldVersion;
+			const tx = ev.target.transaction;
+			if (oldVersion < 1) db.createObjectStore(EVENTS, { keyPath: "id" });
+			if (oldVersion < 2) {
+				const events = tx.objectStore(EVENTS);
+				events.createIndex("created_at", "created_at");
+				events.createIndex("kind_created_at", ["kind", "created_at"]);
+				events.createIndex("pubkey_created_at", ["pubkey", "created_at"]);
+				events.createIndex("kind_pubkey_created_at", [
+					"kind",
+					"pubkey",
+					"created_at"
+				]);
+				db.createObjectStore(TAG_REFS, { keyPath: "key" }).createIndex("name_value_created", [
+					"name",
+					"value",
+					"created_at"
+				]);
+				db.createObjectStore(ADDRESSES, { keyPath: "address" });
+				db.createObjectStore(TOMBSTONES, { keyPath: "key" });
+				if (oldVersion >= 1) {
+					const all = events.getAll();
+					all.onsuccess = () => {
+						migrateV1Events(tx, all.result ?? []);
+						compactSupersededReplaceables(tx);
+					};
+				}
+			} else if (oldVersion < 3) compactSupersededReplaceables(tx);
+			if (oldVersion < 4) db.createObjectStore(OUTBOX_BOUNDS, { keyPath: "key" });
+		};
+		req.onsuccess = () => resolve(req.result);
+		req.onerror = () => reject(req.error ?? new StorageError("IndexedDB open failed"));
+	});
+}
+function migrateV1Events(tx, events) {
+	const byId = new Map(events.map((e) => [e.id.toLowerCase(), e]));
+	const deletion = new DeletionState();
+	const dels = events.filter((e) => e.kind === Kind.EventDeletion).sort((a, b) => a.created_at - b.created_at || a.id.localeCompare(b.id));
+	for (const del of dels) {
+		const plan = planDeletion(del, (id) => byId.get(id));
+		deletion.absorb(plan);
+		for (const c of plan.coordinates) for (const ev of events) {
+			if (ev.kind === Kind.EventDeletion) continue;
+			if (eventAddress(ev) === c.key && ev.created_at <= c.until) deletion.ids.add(ev.id.toLowerCase());
+		}
+	}
+	const eventsStore = tx.objectStore(EVENTS);
+	const tagRefs = tx.objectStore(TAG_REFS);
+	const addresses = tx.objectStore(ADDRESSES);
+	const tombstones = tx.objectStore(TOMBSTONES);
+	for (const id of deletion.ids) tombstones.put({
+		key: `id:${id}`,
+		type: "id"
+	});
+	for (const [id, pubkey] of deletion.pending) tombstones.put({
+		key: `pending:${id}`,
+		type: "pending",
+		pubkey: pubkey.toLowerCase()
+	});
+	for (const [key, until] of deletion.coordinates) tombstones.put({
+		key: `coord:${key}`,
+		type: "coord",
+		until
+	});
+	const winners = /* @__PURE__ */ new Map();
+	for (const event of events) {
+		const stored = normalizeEvent(event);
+		if (deletion.ids.has(stored.id) || deletion.covers(stored)) {
+			eventsStore.delete(event.id);
+			continue;
+		}
+		if (stored.id !== event.id) eventsStore.delete(event.id);
+		if (stored !== event) eventsStore.put(stored);
+		writeTagRefs(tagRefs, stored);
+		const addr = eventAddress(stored);
+		if (addr) {
+			const prev = winners.get(addr);
+			if (!prev || isReplaceableWinner(stored, prev)) winners.set(addr, stored);
+		}
+	}
+	for (const [address, event] of winners) addresses.put({
+		address,
+		id: event.id,
+		created_at: event.created_at
+	});
+}
+function compactSupersededReplaceables(tx) {
+	const eventsStore = tx.objectStore(EVENTS);
+	const addressesStore = tx.objectStore(ADDRESSES);
+	const evReq = eventsStore.getAll();
+	const addrReq = addressesStore.getAll();
+	let events;
+	let addressRows;
+	const run = () => {
+		if (events === void 0 || addressRows === void 0) return;
+		const byAddr = /* @__PURE__ */ new Map();
+		for (const row of addressRows) byAddr.set(row.address, row);
+		const kept = [];
+		for (const event of events) {
+			const addr = eventAddress(event);
+			if (addr) {
+				const row = byAddr.get(addr);
+				if (!row || row.id !== event.id) {
+					deleteStoredEvent(tx, event, row);
+					continue;
+				}
+			}
+			kept.push(event);
+		}
+		addressesStore.clear();
+		for (const event of kept) {
+			const addr = eventAddress(event);
+			if (!addr) continue;
+			addressesStore.put({
+				address: addr,
+				id: event.id,
+				created_at: event.created_at
+			});
+		}
+	};
+	evReq.onsuccess = () => {
+		events = evReq.result ?? [];
+		run();
+	};
+	addrReq.onsuccess = () => {
+		addressRows = addrReq.result ?? [];
+		run();
+	};
+}
+//#endregion
+//#region src/storage/indexeddb.ts
+/**
+* Browser IndexedDB event store with the same replaceable / deletion semantics
+* as {@link MemoryEventStore}. Requires a DOM IndexedDB implementation.
+*
+* `open` loads every tombstone and address row into memory. Fine at 10^4 events;
+* tens of MB at 10^5 addressables.
+*/
+var IndexedDbEventStore = class IndexedDbEventStore {
+	#dbName;
+	#db;
+	#deletion = new DeletionState();
+	#replaceable = /* @__PURE__ */ new Map();
+	/** Serializes writes so abort restore cannot roll back a committed sibling tx. */
+	#writeTail = Promise.resolve();
+	constructor(opts = {}) {
+		this.#dbName = opts.dbName ?? "@qntx/nostr";
+	}
+	static isAvailable() {
+		return typeof globalThis.indexedDB !== "undefined";
+	}
+	async open() {
+		if (this.#db) return;
+		if (!IndexedDbEventStore.isAvailable()) throw new StorageError("IndexedDB is not available in this environment");
+		this.#db = await openDb(this.#dbName);
+		await this.#loadCaches();
+	}
+	async #ensure() {
+		await this.open();
+		return this.#db;
+	}
+	/** Loads every tombstone and address row into RAM. Tens of MB at 10^5 addressables. */
+	async #loadCaches() {
+		const tx = this.#db.transaction([TOMBSTONES, ADDRESSES], "readonly");
+		const done = txDone(tx);
+		this.#deletion.clear();
+		this.#replaceable.clear();
+		const tombs = await reqOf(tx.objectStore(TOMBSTONES).getAll());
+		this.#deletion.absorb(tombstonesToPlan(tombs ?? []));
+		await walkCursor(tx.objectStore(ADDRESSES), void 0, "next", (cursor) => {
+			const row = cursor.value;
+			this.#replaceable.set(row.address, row.id);
+			return false;
+		});
+		await done;
+	}
+	#enqueueWrite(op) {
+		const run = this.#writeTail.then(op, op);
+		this.#writeTail = run.then(() => void 0, () => void 0);
+		return run;
+	}
+	async put(event) {
+		const [result] = await this.putMany([event]);
+		return result;
+	}
+	/** One readwrite transaction; abort rejects the whole batch with no partial persist. */
+	async putMany(events) {
+		if (events.length === 0) return [];
+		return this.#enqueueWrite(() => this.#putManyLocked(events));
+	}
+	async #putManyLocked(events) {
+		let db;
+		try {
+			db = await this.#ensure();
+		} catch (err) {
+			throw toStorageError(err);
+		}
+		const tx = db.transaction(WRITE_STORES, "readwrite");
+		const txOutcome = new Promise((resolve, reject) => {
+			tx.oncomplete = () => resolve();
+			tx.onerror = () => reject(tx.error ?? new StorageError("IndexedDB transaction failed"));
+			tx.onabort = () => reject(tx.error ?? new StorageError("IndexedDB transaction aborted"));
+		}).then(() => void 0, (err) => err);
+		const cache = this.#snapshotCaches();
+		try {
+			const results = await this.#putAllInTx(tx, events);
+			const txErr = await txOutcome;
+			if (txErr !== void 0) throw txErr;
+			return results;
+		} catch (err) {
+			this.#restoreCaches(cache);
+			try {
+				tx.abort();
+			} catch {}
+			await txOutcome;
+			throw toStorageError(err);
+		}
+	}
+	/** Sequential awaits so the tx stays alive between events. */
+	async #putAllInTx(tx, batch) {
+		const eventsStore = tx.objectStore(EVENTS);
+		const addressesStore = tx.objectStore(ADDRESSES);
+		const results = [];
+		for (const raw of batch) {
+			const event = normalizeEvent(raw);
+			const byId = /* @__PURE__ */ new Map();
+			const existing = await reqOf(eventsStore.get(event.id));
+			if (existing) byId.set(existing.id, existing);
+			if (event.kind === Kind.EventDeletion) for (const tag of event.tags) {
+				if (tag[0] !== "e" || tag[1] === void 0) continue;
+				const got = await reqOf(eventsStore.get(tag[1].toLowerCase()));
+				if (got) byId.set(got.id, got);
+			}
+			const addrRows = /* @__PURE__ */ new Map();
+			const ownAddr = eventAddress(event);
+			if (ownAddr) {
+				const row = await reqOf(addressesStore.get(ownAddr));
+				if (row) addrRows.set(ownAddr, {
+					id: row.id,
+					created_at: row.created_at
+				});
+			}
+			if (event.kind === Kind.EventDeletion) for (const tag of event.tags) {
+				if (tag[0] !== "a" || !tag[1]) continue;
+				const coord = parseEventAddress(tag[1]);
+				if (!coord) continue;
+				const key = `${coord.kind}:${coord.pubkey}:${coord.identifier}`;
+				if (addrRows.has(key)) continue;
+				const row = await reqOf(addressesStore.get(key));
+				if (row) addrRows.set(key, {
+					id: row.id,
+					created_at: row.created_at
+				});
+			}
+			const d = decidePut(event, {
+				deletion: this.#deletion,
+				getById: (id) => byId.get(id),
+				getReplaceable: (address) => addrRows.get(address)
+			});
+			if (d.action === "delete") {
+				const remove = /* @__PURE__ */ new Set([...d.plan.removeIds, ...d.coordIds]);
+				for (const id of remove) await this.#deleteEventRows(tx, id);
+			} else if (d.action === "insert" && d.replaceId) await this.#deleteEventRows(tx, d.replaceId);
+			results.push(applyPutIndexedDb(tx, {
+				deletion: this.#deletion,
+				replaceable: this.#replaceable
+			}, d));
+		}
+		return results;
+	}
+	#snapshotCaches() {
+		return {
+			replaceable: new Map(this.#replaceable),
+			ids: new Set(this.#deletion.ids),
+			pending: new Map(this.#deletion.pending),
+			coordinates: new Map(this.#deletion.coordinates)
+		};
+	}
+	#restoreCaches(snap) {
+		this.#replaceable = snap.replaceable;
+		this.#deletion.ids.clear();
+		for (const id of snap.ids) this.#deletion.ids.add(id);
+		this.#deletion.pending.clear();
+		for (const [k, v] of snap.pending) this.#deletion.pending.set(k, v);
+		this.#deletion.coordinates.clear();
+		for (const [k, v] of snap.coordinates) this.#deletion.coordinates.set(k, v);
+	}
+	async get(id) {
+		const key = id.toLowerCase();
+		if (this.#deletion.ids.has(key)) return void 0;
+		const tx = (await this.#ensure()).transaction(EVENTS, "readonly");
+		const done = txDone(tx);
+		const event = await reqOf(tx.objectStore(EVENTS).get(key));
+		await done;
+		return event;
+	}
+	async query(filters) {
+		const tx = (await this.#ensure()).transaction([EVENTS, TAG_REFS], "readonly");
+		const done = txDone(tx);
+		const seen = /* @__PURE__ */ new Set();
+		const events = [];
+		for (const filter of filters) {
+			const matched = await this.#queryOne(tx, filter);
+			for (const event of matched) {
+				if (seen.has(event.id)) continue;
+				seen.add(event.id);
+				events.push(event);
+			}
+		}
+		await done;
+		sortEvents(events);
+		return events;
+	}
+	async count(filters) {
+		const tx = (await this.#ensure()).transaction([EVENTS, TAG_REFS], "readonly");
+		const done = txDone(tx);
+		const seen = /* @__PURE__ */ new Set();
+		for (const filter of filters) {
+			const local = /* @__PURE__ */ new Set();
+			await this.#scan(tx, filter, (event) => {
+				local.add(event.id);
+				return filter.limit !== void 0 && local.size >= filter.limit;
+			});
+			for (const id of local) seen.add(id);
+		}
+		await done;
+		return seen.size;
+	}
+	async negentropyItems(filter) {
+		const tx = (await this.#ensure()).transaction([EVENTS, TAG_REFS], "readonly");
+		const done = txDone(tx);
+		const items = [];
+		await this.#scan(tx, filter, (event) => {
+			items.push({
+				id: event.id,
+				created_at: event.created_at
+			});
+			return filter.limit !== void 0 && items.length >= filter.limit;
+		});
+		await done;
+		items.sort(itemCompare);
+		return items;
+	}
+	#acceptHit(filter, event) {
+		if (this.#deletion.ids.has(event.id)) return false;
+		if (this.#deletion.covers(event)) return false;
+		return matchFilter(filter, event);
+	}
+	async #queryOne(tx, filter) {
+		const matched = [];
+		await this.#scan(tx, filter, (event) => {
+			matched.push(event);
+			return filter.limit !== void 0 && matched.length >= filter.limit;
+		});
+		sortEvents(matched);
+		return matched;
+	}
+	#scan(tx, filter, take) {
+		return scanFilter(tx, filter, (event) => this.#acceptHit(filter, event), take);
+	}
+	async getOutboxBound(pubkey, kind) {
+		try {
+			const tx = (await this.#ensure()).transaction(OUTBOX_BOUNDS, "readonly");
+			const done = txDone(tx);
+			const row = await reqOf(tx.objectStore(OUTBOX_BOUNDS).get(outboxBoundKey(pubkey, kind)));
+			await done;
+			if (row && typeof row.oldest === "number" && typeof row.newest === "number") return {
+				oldest: row.oldest,
+				newest: row.newest
+			};
+			return await this.#deriveOutboxBound(pubkey, kind);
+		} catch (err) {
+			throw toStorageError(err);
+		}
+	}
+	async setOutboxBound(pubkey, kind, bound) {
+		return this.#enqueueWrite(() => this.#setOutboxBoundLocked(pubkey, kind, bound));
+	}
+	async #setOutboxBoundLocked(pubkey, kind, bound) {
+		try {
+			const tx = (await this.#ensure()).transaction(OUTBOX_BOUNDS, "readwrite");
+			const done = txDone(tx);
+			tx.objectStore(OUTBOX_BOUNDS).put({
+				key: outboxBoundKey(pubkey, kind),
+				oldest: bound.oldest,
+				newest: bound.newest
+			});
+			await done;
+		} catch (err) {
+			throw toStorageError(err);
+		}
+	}
+	async remove(ids) {
+		return this.#enqueueWrite(() => this.#removeLocked(ids));
+	}
+	async #removeLocked(ids) {
+		const tx = (await this.#ensure()).transaction(WRITE_STORES, "readwrite");
+		const tombstones = tx.objectStore(TOMBSTONES);
+		const done = txDone(tx);
+		let n = 0;
+		for (const raw of ids) {
+			const id = raw.toLowerCase();
+			if (await this.#deleteEventRows(tx, id)) n += 1;
+			tombstones.put({
+				key: `id:${id}`,
+				type: "id"
+			});
+			tombstones.delete(`pending:${id}`);
+			this.#deletion.ids.add(id);
+			this.#deletion.pending.delete(id);
+		}
+		await done;
+		return n;
+	}
+	async clear() {
+		return this.#enqueueWrite(() => this.#clearLocked());
+	}
+	async #clearLocked() {
+		const db = await this.#ensure();
+		const stores = [...WRITE_STORES, OUTBOX_BOUNDS];
+		const tx = db.transaction(stores, "readwrite");
+		const done = txDone(tx);
+		for (const name of stores) tx.objectStore(name).clear();
+		this.#deletion.clear();
+		this.#replaceable.clear();
+		await done;
+	}
+	close() {
+		this.#db?.close();
+		this.#db = void 0;
+	}
+	async #deleteEventRows(tx, id) {
+		const event = await reqOf(tx.objectStore(EVENTS).get(id.toLowerCase()));
+		if (!event) return false;
+		const addr = eventAddress(event);
+		let row;
+		if (addr) {
+			row = await reqOf(tx.objectStore(ADDRESSES).get(addr));
+			if (this.#replaceable.get(addr) === event.id) this.#replaceable.delete(addr);
+		}
+		deleteStoredEvent(tx, event, row);
+		return true;
+	}
+	async #deriveOutboxBound(pubkey, kind) {
+		const db = await this.#ensure();
+		const pk = pubkey.toLowerCase();
+		const tx = db.transaction(EVENTS, "readonly");
+		const done = txDone(tx);
+		const index = tx.objectStore(EVENTS).index("kind_pubkey_created_at");
+		const range = prefixRange([kind, pk]);
+		const filter = {
+			authors: [pk],
+			kinds: [kind]
+		};
+		let oldest;
+		let newest;
+		const firstLive = (direction, assign) => walkCursor(index, range, direction, (cursor) => {
+			const event = cursor.value;
+			if (!this.#acceptHit(filter, event)) return false;
+			assign(event.created_at);
+			return true;
+		});
+		await Promise.all([firstLive("next", (createdAt) => {
+			oldest = createdAt;
+		}), firstLive("prev", (createdAt) => {
+			newest = createdAt;
+		})]);
+		await done;
+		if (oldest === void 0 || newest === void 0) return void 0;
+		return {
+			oldest,
+			newest
+		};
+	}
+};
+//#endregion
+export { IndexedDbEventStore as t };
+
+//# sourceMappingURL=storage-DOy0iLRE.mjs.map