@qntx/nostr 0.1.0 → 0.2.1

package/dist/storage-xXxLGCVb.mjs

@@ -0,0 +1,1376 @@
+import { c as isRecord } from "./util-LfQirgDk.mjs";
+import { t as Kind } from "./kind-Cxwhhkx8.mjs";
+import { _ as formatEventAddress, a as isReplaceableWinner, b as parseEventAddress, d as sortEvents, g as eventAddress, m as validateSignedEvent, o as itemCompare, t as compareEventsDesc } from "./event-D8Nfoh4K.mjs";
+import { a as matchFilter } from "./filter-BQl3GlHt.mjs";
+import { n as toStorageError, t as StorageError } from "./error-DrEIM7FO.mjs";
+import { a as planDeletion, i as DeletionState, n as decidePut, r as outboxBoundKey } from "./memory-index-Do1mz0WF.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
+async function reqOf(req) {
+	return new Promise((resolve, reject) => {
+		req.onsuccess = () => resolve(req.result);
+		req.onerror = () => reject(req.error ?? new StorageError("IndexedDB request failed"));
+	});
+}
+async function txDone(tx) {
+	return new Promise((resolve, reject) => {
+		tx.oncomplete = () => resolve();
+		tx.onerror = () => reject(tx.error ?? new StorageError("IndexedDB transaction failed"));
+	});
+}
+async 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 ?? void 0;
+			if (cursor === void 0) {
+				resolve();
+				return;
+			}
+			if (visit(cursor)) {
+				resolve();
+				return;
+			}
+			cursor.continue();
+		};
+	});
+}
+function tagRefKey(name, value, id) {
+	return `${name}:${value.toLowerCase()}:${id}`;
+}
+function writeTagRefs(store, event) {
+	for (const tag of event.tags) {
+		if (tag[0] !== "e" && tag[0] !== "p" || tag[1] === void 0) continue;
+		const value = tag[1].toLowerCase();
+		const { id } = event;
+		store.put({
+			key: tagRefKey(tag[0], value, id),
+			name: tag[0],
+			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
+		});
+	}
+	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 (!isRecord(row)) continue;
+		const r = row;
+		if (r["type"] === "id" && typeof r["key"] === "string" && r["key"].startsWith("id:")) {
+			plan.removeIds.push(r["key"].slice(3));
+			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),
+				pubkey: r["pubkey"]
+			});
+			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);
+	if (d.action === "skip") return d.result;
+	if (d.action === "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";
+	}
+	if (d.action === "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";
+	}
+	events.put(d.event);
+	writeTagRefs(tagRefs, d.event);
+	if (d.address !== void 0) {
+		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 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 === void 0) 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);
+		}
+	};
+}
+async function scanIds(tx, filter, accept, take) {
+	const ids = filter.ids ?? [];
+	const events = tx.objectStore(EVENTS);
+	const reqs = ids.map((id) => events.get(id.toLowerCase()));
+	const rows = await Promise.all(reqs.map(async (req) => reqOf(req)));
+	const matched = [];
+	const seen = /* @__PURE__ */ new Set();
+	for (const event of rows) {
+		if (event === void 0 || seen.has(event.id) || !accept(event)) continue;
+		seen.add(event.id);
+		matched.push(event);
+	}
+	sortEvents(matched);
+	const out = filter.limit === void 0 ? matched : matched.slice(0, filter.limit);
+	for (const event of out) if (take(event)) break;
+}
+/** IDB auto-commits when onsuccess returns with no outstanding requests. */
+async 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.at(i) ?? { cursor: void 0 };
+			if (cursor === void 0) 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 (const slot of slots) {
+				const event = slot.head;
+				if (event === void 0) continue;
+				if (best === void 0 || compareEventsDesc(event, best) < 0) best = event;
+			}
+			if (best === void 0) {
+				finish();
+				return;
+			}
+			phase = "drain";
+			drainT = best.created_at;
+			drainBuf = [];
+			for (const [i, slot] of slots.entries()) {
+				const event = slot.head;
+				if (event === void 0 || event.created_at !== drainT) continue;
+				drainBuf.push(event);
+				slot.head = void 0;
+				stepCursor(i);
+			}
+			if (inflight === 0) pump();
+		};
+		const onEvent = (i, event) => {
+			if (phase === "done") return;
+			const slot = slots.at(i);
+			if (slot === void 0) return;
+			const { cursor } = slot;
+			if (event === void 0) {
+				if (cursor === void 0) pump();
+				else {
+					inflight++;
+					cursor.continue();
+				}
+				return;
+			}
+			if (phase === "drain") {
+				if (event.created_at === drainT) {
+					drainBuf.push(event);
+					if (cursor === void 0) pump();
+					else {
+						inflight++;
+						cursor.continue();
+					}
+					return;
+				}
+				slot.head = event;
+				pump();
+				return;
+			}
+			slot.head = event;
+			pump();
+		};
+		const openSlot = (i, opener) => {
+			const req = opener.open();
+			req.onerror = () => fail(req.error ?? new StorageError("IndexedDB cursor failed"));
+			inflight++;
+			req.onsuccess = () => {
+				inflight--;
+				if (phase === "done") return;
+				const cursor = req.result ?? void 0;
+				const slot = slots.at(i);
+				if (slot === void 0) return;
+				if (cursor === void 0) {
+					slot.cursor = void 0;
+					slot.head = void 0;
+					pump();
+					return;
+				}
+				slot.cursor = cursor;
+				inflight++;
+				opener.read(cursor, (event) => {
+					inflight--;
+					onEvent(i, event);
+				}, (error) => {
+					inflight--;
+					fail(error);
+				});
+			};
+		};
+		for (const [i, opener] of openers.entries()) openSlot(i, opener);
+	});
+}
+async function scanFilter(tx, filter, accept, take) {
+	if (filter.limit === 0) return;
+	if (filter.since !== void 0 && filter.until !== void 0 && filter.since > filter.until) return;
+	if (filter.ids) return scanIds(tx, filter, accept, take);
+	const events = tx.objectStore(EVENTS);
+	const fullScan = eventCursor(events.index("created_at"), createdAtRange(filter.since, filter.until));
+	const openers = [];
+	if (filter.authors && filter.kinds) {
+		if (filter.authors.length * filter.kinds.length > 64) {
+			if (filter.kinds.length <= 64) {
+				const index = events.index("kind_created_at");
+				for (const kind of filter.kinds) openers.push(eventCursor(index, prefixRange([kind], filter.since, filter.until)));
+			} else openers.push(fullScan);
+		} else {
+			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) {
+		if (filter.authors.length > 64) openers.push(fullScan);
+		else {
+			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) {
+		if (filter.kinds.length > 64) openers.push(fullScan);
+		else {
+			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 > 64) openers.push(fullScan);
+		else 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(fullScan);
+	}
+	return kWayMerge(openers, accept, take);
+}
+async 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;
+			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 eventsStore = tx.objectStore(EVENTS);
+	const tagRefs = tx.objectStore(TAG_REFS);
+	const addresses = tx.objectStore(ADDRESSES);
+	const tombstones = tx.objectStore(TOMBSTONES);
+	const valid = [];
+	for (const e of events) {
+		if (validateSignedEvent(e)) {
+			valid.push(e);
+			continue;
+		}
+		if (typeof e === "object" && e !== null && "id" in e && typeof e.id === "string") eventsStore.delete(e.id);
+	}
+	const byId = new Map(valid.map((e) => [e.id, e]));
+	const deletion = new DeletionState();
+	const dels = valid.filter((e) => e.kind === Kind.EventDeletion).sort(itemCompare);
+	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 valid) {
+			if (ev.kind === Kind.EventDeletion) continue;
+			if (eventAddress(ev) === c.key && ev.created_at <= c.until) deletion.ids.add(ev.id);
+		}
+	}
+	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
+	});
+	for (const [key, until] of deletion.coordinates) tombstones.put({
+		key: `coord:${key}`,
+		type: "coord",
+		until
+	});
+	const winners = /* @__PURE__ */ new Map();
+	for (const event of valid) {
+		if (deletion.ids.has(event.id) || deletion.covers(event)) {
+			eventsStore.delete(event.id);
+			continue;
+		}
+		writeTagRefs(tagRefs, event);
+		const addr = eventAddress(event);
+		if (addr !== void 0) {
+			const prev = winners.get(addr);
+			if (!prev || isReplaceableWinner(event, prev)) winners.set(addr, event);
+		}
+	}
+	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 !== void 0) {
+				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 === void 0) 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 globalThis.indexedDB !== void 0;
+	}
+	async open() {
+		if (this.#db) return;
+		if (!IndexedDbEventStore.isAvailable()) throw new StorageError("IndexedDB is not available in this environment");
+		const db = await openDb(this.#dbName);
+		this.#db = db;
+		await this.#loadCaches(db);
+	}
+	async #ensure() {
+		await this.open();
+		const db = this.#db;
+		if (db === void 0) throw new StorageError("IndexedDB is not available in this environment");
+		return db;
+	}
+	/** Loads every tombstone and address row into RAM. Tens of MB at 10^5 addressables. */
+	async #loadCaches(db) {
+		const tx = 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;
+	}
+	async #enqueueWrite(op) {
+		const prev = this.#writeTail;
+		let release;
+		this.#writeTail = new Promise((resolve) => {
+			release = resolve;
+		});
+		try {
+			await prev;
+			return await op();
+		} finally {
+			release?.();
+		}
+	}
+	async put(event) {
+		const [result] = await this.putMany([event]);
+		if (result === void 0) throw new StorageError("putMany returned no result");
+		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(async () => this.#putManyLocked(events));
+	}
+	async #putManyLocked(events) {
+		let db;
+		try {
+			db = await this.#ensure();
+		} catch (error) {
+			throw toStorageError(error);
+		}
+		const tx = db.transaction(WRITE_STORES, "readwrite");
+		const txSettled = 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"));
+		});
+		const txOutcome = (async () => {
+			try {
+				await txSettled;
+				return;
+			} catch (error) {
+				return error;
+			}
+		})();
+		const cache = this.#snapshotCaches();
+		try {
+			const results = await this.#putAllInTx(tx, events);
+			const txErr = await txOutcome;
+			if (txErr !== void 0) throw toStorageError(txErr);
+			return results;
+		} catch (error) {
+			this.#restoreCaches(cache);
+			try {
+				tx.abort();
+			} catch {}
+			await txOutcome;
+			throw toStorageError(error);
+		}
+	}
+	/** 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) {
+			if (!validateSignedEvent(raw)) {
+				results.push("invalid");
+				continue;
+			}
+			const event = 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 !== void 0) {
+				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] === void 0) 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 !== void 0) 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;
+		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;
+	}
+	async #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 (error) {
+			throw toStorageError(error);
+		}
+	}
+	async setOutboxBound(pubkey, kind, bound) {
+		return this.#enqueueWrite(async () => 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 (error) {
+			throw toStorageError(error);
+		}
+	}
+	async remove(ids) {
+		return this.#enqueueWrite(async () => 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(async () => 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));
+		if (!event) return false;
+		const addr = eventAddress(event);
+		let row;
+		if (addr !== void 0) {
+			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 = async (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;
+		return {
+			oldest,
+			newest
+		};
+	}
+};
+//#endregion
+//#region src/storage/sqlite.ts
+/** Bound values per `IN (...)` list; stays below every host's variable limit. */
+const IN_CHUNK = 500;
+const SCHEMA_VERSION = 1;
+const SCHEMA_SQL = `
+CREATE TABLE IF NOT EXISTS events (
+  id TEXT PRIMARY KEY,
+  pubkey TEXT NOT NULL,
+  kind INTEGER NOT NULL,
+  created_at INTEGER NOT NULL,
+  content TEXT NOT NULL,
+  tags TEXT NOT NULL,
+  sig TEXT NOT NULL,
+  address TEXT
+);
+CREATE UNIQUE INDEX IF NOT EXISTS events_address
+  ON events(address) WHERE address IS NOT NULL;
+CREATE INDEX IF NOT EXISTS events_kind_created ON events(kind, created_at DESC, id);
+CREATE INDEX IF NOT EXISTS events_pubkey_kind_created
+  ON events(pubkey, kind, created_at DESC, id);
+CREATE INDEX IF NOT EXISTS events_pubkey_created ON events(pubkey, created_at DESC, id);
+CREATE INDEX IF NOT EXISTS events_created ON events(created_at DESC, id);
+CREATE TABLE IF NOT EXISTS tags (
+  event_id TEXT NOT NULL REFERENCES events(id) ON DELETE CASCADE,
+  name TEXT NOT NULL,
+  value TEXT NOT NULL,
+  created_at INTEGER NOT NULL
+);
+CREATE INDEX IF NOT EXISTS tags_name_value_created
+  ON tags(name, value, created_at DESC);
+CREATE TABLE IF NOT EXISTS tombstones (
+  kind TEXT NOT NULL CHECK(kind IN ('id', 'pending', 'coord')),
+  key TEXT NOT NULL,
+  pubkey TEXT,
+  until INTEGER,
+  PRIMARY KEY(kind, key)
+);
+CREATE TABLE IF NOT EXISTS outbox_bounds (
+  pubkey TEXT NOT NULL,
+  kind INTEGER NOT NULL,
+  oldest INTEGER NOT NULL,
+  newest INTEGER NOT NULL,
+  PRIMARY KEY(pubkey, kind)
+);
+`;
+function rowToEvent(row) {
+	return {
+		kind: row.kind,
+		tags: JSON.parse(row.tags),
+		content: row.content,
+		created_at: row.created_at,
+		pubkey: row.pubkey,
+		id: row.id,
+		sig: row.sig
+	};
+}
+function chunkValues(values) {
+	const chunks = [];
+	for (let i = 0; i < values.length; i += IN_CHUNK) chunks.push(values.slice(i, i + IN_CHUNK));
+	return chunks;
+}
+function inClause(column, count) {
+	return `${column} IN (${Array.from({ length: count }, () => "?").join(",")})`;
+}
+/**
+* Compile one NIP-01 filter into query variants. `IN` lists are chunked so a variant never binds
+* more than {@link IN_CHUNK} values per list; variants are the cartesian product of chunks across
+* constrained fields. `deferred` means a `#<multi-char>` tag term cannot use the tags index (only
+* single-letter tag names are indexed) and must be checked with `matchFilter` before `limit`.
+* Returns `undefined` when an empty list field makes the filter match nothing.
+*/
+function compileFilter(filter) {
+	const variants = [];
+	const pushIn = (values, clause) => {
+		variants.push(chunkValues(values).map((chunk) => ({
+			wheres: [clause(chunk.length)],
+			params: [...chunk]
+		})));
+	};
+	if (filter.ids) {
+		if (filter.ids.length === 0) return;
+		pushIn(filter.ids.map((id) => id.toLowerCase()), (n) => inClause("id", n));
+	}
+	if (filter.authors) {
+		if (filter.authors.length === 0) return;
+		pushIn(filter.authors.map((pk) => pk.toLowerCase()), (n) => inClause("pubkey", n));
+	}
+	if (filter.kinds) {
+		if (filter.kinds.length === 0) return;
+		pushIn(filter.kinds, (n) => inClause("kind", n));
+	}
+	if (filter.since !== void 0) variants.push([{
+		wheres: ["created_at >= ?"],
+		params: [filter.since]
+	}]);
+	if (filter.until !== void 0) variants.push([{
+		wheres: ["created_at <= ?"],
+		params: [filter.until]
+	}]);
+	let deferred = false;
+	for (const key of Object.keys(filter)) {
+		if (!key.startsWith("#")) continue;
+		const name = key.slice(1);
+		const values = filter[key];
+		if (!values) continue;
+		if (name.length !== 1) {
+			deferred = true;
+			continue;
+		}
+		if (values.length === 0) return;
+		const normalized = name === "e" || name === "p" ? values.map((v) => v.toLowerCase()) : values;
+		variants.push(chunkValues(normalized).map((chunk) => ({
+			wheres: [`EXISTS (SELECT 1 FROM tags t WHERE t.event_id = events.id AND t.name = ? AND ${inClause("t.value", chunk.length)})`],
+			params: [name, ...chunk]
+		})));
+	}
+	const plans = [{
+		wheres: [],
+		params: []
+	}];
+	for (const field of variants) {
+		const next = [];
+		for (const plan of plans) for (const variant of field) next.push({
+			wheres: [...plan.wheres, ...variant.wheres],
+			params: [...plan.params, ...variant.params]
+		});
+		plans.length = 0;
+		plans.push(...next);
+	}
+	return {
+		plans,
+		deferred
+	};
+}
+/**
+* SQLite-backed {@link EventStore} for React Native (`expo-sqlite`, `op-sqlite`) and desktop
+* runtimes. Same semantics as {@link MemoryEventStore} and {@link IndexedDbEventStore}: identical
+* `decidePut` insertion policy, NIP-09 tombstones, and filter handling, with the database — not
+* in-memory caches — as the source of truth.
+*
+* Construct via {@link SqliteEventStore.open}; writes are serialized and run inside an exclusive
+* driver transaction.
+*/
+var SqliteEventStore = class SqliteEventStore {
+	#driver;
+	#writeTail = Promise.resolve();
+	constructor(driver) {
+		this.#driver = driver;
+	}
+	/** Create the schema on first use and return a ready store. */
+	static async open(driver) {
+		const store = new SqliteEventStore(driver);
+		await store.#migrate();
+		return store;
+	}
+	async #migrate() {
+		try {
+			await this.#driver.exec("PRAGMA foreign_keys = ON");
+			const version = (await this.#driver.all("PRAGMA user_version"))[0]?.user_version ?? 0;
+			if (version === 0) {
+				await this.#driver.exec(SCHEMA_SQL);
+				await this.#driver.exec(`PRAGMA user_version = ${SCHEMA_VERSION}`);
+			} else if (version !== SCHEMA_VERSION) throw toStorageError(/* @__PURE__ */ new Error(`unsupported sqlite event store schema version ${version}`));
+		} catch (error) {
+			throw toStorageError(error);
+		}
+	}
+	async #enqueueWrite(op) {
+		const tail = this.#writeTail;
+		const result = (async () => {
+			await tail;
+			return op();
+		})();
+		this.#writeTail = (async () => {
+			try {
+				await result;
+			} catch {}
+		})();
+		return result;
+	}
+	async put(event) {
+		const result = (await this.putMany([event])).at(0);
+		if (result === void 0) throw toStorageError(/* @__PURE__ */ new Error("putMany returned no result"));
+		return result;
+	}
+	async putMany(events) {
+		if (events.length === 0) return [];
+		return this.#enqueueWrite(async () => {
+			try {
+				return await this.#driver.transaction(async (tx) => this.#putAllInTx(tx, events));
+			} catch (error) {
+				throw toStorageError(error);
+			}
+		});
+	}
+	async #putAllInTx(tx, batch) {
+		const results = [];
+		for (const event of batch) {
+			const lookup = await this.#buildLookup(tx, event);
+			const decision = decidePut(event, lookup);
+			await this.#applyDecision(tx, decision);
+			results.push(decision.result);
+		}
+		return results;
+	}
+	async #buildLookup(tx, event) {
+		const byId = /* @__PURE__ */ new Map();
+		const idList = [event.id];
+		if (event.kind === Kind.EventDeletion) {
+			for (const tag of event.tags) if (tag[0] === "e" && tag[1] !== void 0 && tag[1] !== "") idList.push(tag[1].toLowerCase());
+		}
+		for (const row of await this.#eventRowsByIds(tx, idList)) byId.set(row.id, row);
+		const byAddress = /* @__PURE__ */ new Map();
+		const addressList = [];
+		const ownAddress = eventAddress(event);
+		if (ownAddress !== void 0) addressList.push(ownAddress);
+		if (event.kind === Kind.EventDeletion) for (const tag of event.tags) {
+			if (tag[0] !== "a" || tag[1] === void 0 || tag[1] === "") continue;
+			const coord = parseEventAddress(tag[1]);
+			if (coord === void 0) continue;
+			const key = formatEventAddress(coord.kind, coord.pubkey, coord.identifier);
+			if (!addressList.includes(key)) addressList.push(key);
+		}
+		const addressRows = [];
+		for (const chunk of chunkValues(addressList)) addressRows.push(...await tx.all(`SELECT address, id, created_at FROM events
+           WHERE ${inClause("address", chunk.length)}`, chunk));
+		for (const row of addressRows.flat()) byAddress.set(row.address, {
+			id: row.id,
+			created_at: row.created_at
+		});
+		const deletion = new DeletionState();
+		const tombstoneRows = await tx.all(ownAddress === void 0 ? `SELECT kind, key, pubkey, until FROM tombstones
+           WHERE kind IN ('id', 'pending') AND key = ?` : `SELECT kind, key, pubkey, until FROM tombstones
+           WHERE (kind IN ('id', 'pending') AND key = ?)
+              OR (kind = 'coord' AND key = ?)`, ownAddress === void 0 ? [event.id] : [event.id, ownAddress]);
+		for (const row of tombstoneRows) if (row.kind === "id") deletion.ids.add(row.key);
+		else if (row.kind === "pending" && row.pubkey !== null) deletion.pending.set(row.key, row.pubkey);
+		else if (row.kind === "coord" && row.until !== null) deletion.coordinates.set(row.key, row.until);
+		return {
+			deletion,
+			getById: (id) => byId.get(id),
+			getReplaceable: (address) => byAddress.get(address)
+		};
+	}
+	async #eventRowsByIds(tx, ids) {
+		const events = [];
+		for (const chunk of chunkValues(ids)) {
+			const rows = await tx.all(`SELECT id, pubkey, kind, created_at, content, tags, sig FROM events
+         WHERE ${inClause("id", chunk.length)}`, chunk);
+			for (const row of rows) events.push(rowToEvent(row));
+		}
+		return events;
+	}
+	async #applyDecision(tx, d) {
+		switch (d.action) {
+			case "skip": return;
+			case "tombstone":
+				await this.#putTombstone(tx, "id", d.event.id);
+				await this.#deleteTombstone(tx, "pending", d.event.id);
+				return;
+			case "delete":
+				await this.#persistPlan(tx, d.event.id, d.plan, d.coordIds);
+				for (const id of [...d.plan.removeIds, ...d.coordIds]) await this.#deleteEvent(tx, id);
+				await this.#insertEvent(tx, d.event);
+				return;
+			case "insert":
+				if (d.replaceId !== void 0) await this.#deleteEvent(tx, d.replaceId);
+				await this.#insertEvent(tx, d.event);
+		}
+	}
+	/** Persist a deletion plan's tombstones, mirroring `DeletionState.absorb`. */
+	async #persistPlan(tx, deletionId, plan, coordIds) {
+		await this.#deleteTombstone(tx, "pending", deletionId);
+		for (const id of [...plan.removeIds, ...coordIds]) {
+			await this.#putTombstone(tx, "id", id);
+			await this.#deleteTombstone(tx, "pending", id);
+		}
+		for (const p of plan.pendingIds) if ((await tx.all(`SELECT 1 AS found FROM tombstones WHERE kind = 'id' AND key = ?`, [p.id])).length === 0) await tx.run(`INSERT OR REPLACE INTO tombstones (kind, key, pubkey) VALUES ('pending', ?, ?)`, [p.id, p.pubkey]);
+		for (const c of plan.coordinates) await tx.run(`INSERT INTO tombstones (kind, key, until) VALUES ('coord', ?, ?)
+         ON CONFLICT(kind, key)
+         DO UPDATE SET until = MAX(tombstones.until, excluded.until)`, [c.key, c.until]);
+	}
+	async #putTombstone(tx, kind, key) {
+		await tx.run(`INSERT OR REPLACE INTO tombstones (kind, key) VALUES (?, ?)`, [kind, key]);
+	}
+	async #deleteTombstone(tx, kind, key) {
+		await tx.run(`DELETE FROM tombstones WHERE kind = ? AND key = ?`, [kind, key]);
+	}
+	async #insertEvent(tx, event) {
+		await tx.run(`INSERT INTO events (id, pubkey, kind, created_at, content, tags, sig, address)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?)`, [
+			event.id,
+			event.pubkey,
+			event.kind,
+			event.created_at,
+			event.content,
+			JSON.stringify(event.tags),
+			event.sig,
+			eventAddress(event) ?? null
+		]);
+		for (const tag of event.tags) {
+			if (tag[0] === void 0 || tag[1] === void 0 || tag[0].length !== 1) continue;
+			await tx.run(`INSERT INTO tags (event_id, name, value, created_at) VALUES (?, ?, ?, ?)`, [
+				event.id,
+				tag[0],
+				tag[0] === "e" || tag[0] === "p" ? tag[1].toLowerCase() : tag[1],
+				event.created_at
+			]);
+		}
+	}
+	async #deleteEvent(tx, id) {
+		return (await tx.run(`DELETE FROM events WHERE id = ?`, [id])).changes;
+	}
+	async get(id) {
+		try {
+			const row = (await this.#driver.all(`SELECT id, pubkey, kind, created_at, content, tags, sig FROM events
+         WHERE id = ?`, [id.toLowerCase()])).at(0);
+			return row === void 0 ? void 0 : rowToEvent(row);
+		} catch (error) {
+			throw toStorageError(error);
+		}
+	}
+	async query(filters) {
+		try {
+			const perFilter = [];
+			for (const filter of filters) perFilter.push(await this.#filterRows(filter, "*"));
+			const seen = /* @__PURE__ */ new Set();
+			const events = [];
+			for (const rows of perFilter) for (const event of rows) {
+				if (seen.has(event.id)) continue;
+				seen.add(event.id);
+				events.push(event);
+			}
+			return sortEvents(events);
+		} catch (error) {
+			throw toStorageError(error);
+		}
+	}
+	async count(filters) {
+		try {
+			const perFilter = [];
+			for (const filter of filters) perFilter.push(await this.#filterRows(filter, "id, created_at"));
+			const seen = /* @__PURE__ */ new Set();
+			for (const rows of perFilter) for (const row of rows) seen.add(row.id);
+			return seen.size;
+		} catch (error) {
+			throw toStorageError(error);
+		}
+	}
+	async negentropyItems(filter) {
+		try {
+			return [...await this.#filterRows(filter, "id, created_at")].sort(itemCompare);
+		} catch (error) {
+			throw toStorageError(error);
+		}
+	}
+	async #filterRows(filter, select) {
+		if (filter.limit === 0) return [];
+		const compiled = compileFilter(filter);
+		if (compiled === void 0) return [];
+		const { plans, deferred } = compiled;
+		if (deferred) {
+			const matched = (await this.#planRows(plans, "*", void 0)).map(rowToEvent).filter((event) => matchFilter(filter, event));
+			const limited = filter.limit === void 0 ? matched : matched.slice(0, filter.limit);
+			return select === "*" ? limited : limited.map((e) => ({
+				id: e.id,
+				created_at: e.created_at
+			}));
+		}
+		if (select === "*") return (await this.#planRows(plans, "*", filter.limit)).map(rowToEvent);
+		return this.#planRows(plans, "id, created_at", filter.limit);
+	}
+	/** Rows for the compiled plans of one filter, deduped newest-first, `limit` applied. */
+	async #planRows(plans, select, limit) {
+		const tail = ` ORDER BY created_at DESC, id ASC${limit === void 0 ? "" : " LIMIT ?"}`;
+		const perPlan = [];
+		for (const plan of plans) {
+			const where = plan.wheres.length > 0 ? ` WHERE ${plan.wheres.join(" AND ")}` : "";
+			const params = limit === void 0 ? plan.params : [...plan.params, limit];
+			perPlan.push(await this.#driver.all(`SELECT ${select} FROM events${where}${tail}`, params));
+		}
+		const sorted = perPlan.flat().sort(compareEventsDesc);
+		const seen = /* @__PURE__ */ new Set();
+		const merged = [];
+		for (const row of sorted) {
+			if (seen.has(row.id)) continue;
+			seen.add(row.id);
+			merged.push(row);
+		}
+		return limit === void 0 ? merged : merged.slice(0, limit);
+	}
+	async getOutboxBound(pubkey, kind) {
+		const pk = pubkey.toLowerCase();
+		try {
+			const row = (await this.#driver.all(`SELECT oldest, newest FROM outbox_bounds
+         WHERE pubkey = ? AND kind = ?`, [pk, kind])).at(0);
+			if (row !== void 0) return {
+				oldest: row.oldest,
+				newest: row.newest
+			};
+			const d = (await this.#driver.all(`SELECT MIN(created_at) AS oldest, MAX(created_at) AS newest
+         FROM events WHERE pubkey = ? AND kind = ?`, [pk, kind])).at(0);
+			if (d === void 0 || d.oldest === null || d.newest === null) return;
+			return {
+				oldest: d.oldest,
+				newest: d.newest
+			};
+		} catch (error) {
+			throw toStorageError(error);
+		}
+	}
+	async setOutboxBound(pubkey, kind, bound) {
+		const pk = pubkey.toLowerCase();
+		await this.#enqueueWrite(async () => {
+			try {
+				await this.#driver.transaction(async (tx) => {
+					await tx.run(`INSERT OR REPLACE INTO outbox_bounds (pubkey, kind, oldest, newest)
+             VALUES (?, ?, ?, ?)`, [
+						pk,
+						kind,
+						bound.oldest,
+						bound.newest
+					]);
+				});
+			} catch (error) {
+				throw toStorageError(error);
+			}
+		});
+	}
+	async remove(ids) {
+		const lowered = ids.map((id) => id.toLowerCase());
+		return this.#enqueueWrite(async () => {
+			try {
+				return await this.#driver.transaction(async (tx) => {
+					let removed = 0;
+					for (const id of lowered) {
+						removed += await this.#deleteEvent(tx, id);
+						await this.#putTombstone(tx, "id", id);
+						await this.#deleteTombstone(tx, "pending", id);
+					}
+					return removed;
+				});
+			} catch (error) {
+				throw toStorageError(error);
+			}
+		});
+	}
+	async clear() {
+		await this.#enqueueWrite(async () => {
+			try {
+				await this.#driver.transaction(async (tx) => {
+					await tx.run("DELETE FROM tags");
+					await tx.run("DELETE FROM events");
+					await tx.run("DELETE FROM tombstones");
+					await tx.run("DELETE FROM outbox_bounds");
+				});
+			} catch (error) {
+				throw toStorageError(error);
+			}
+		});
+	}
+};
+//#endregion
+export { IndexedDbEventStore as n, SqliteEventStore as t };
+
+//# sourceMappingURL=storage-xXxLGCVb.mjs.map