@qntx/nostr 0.1.0 → 0.2.0

package/dist/{http-6vevbBlu.d.mts → http-C4HwIu4B.d.mts}

@@ -1,22 +1,22 @@
 //#region src/nips/http.d.ts
 /**
- * Shared nips HTTP primitive. Not a pack entry (core has zero network).
- * Callers never pass `redirect`; sendManual always sets `"manual"`.
+ * Shared nips HTTP primitive. Not a pack entry (core has zero network). Callers never pass
+ * `redirect`; sendManual always sets `"manual"`.
  */
 type ManualFetch = (url: string, init?: {
   method?: string;
   headers?: Record<string, string>;
   body?: Blob | FormData | string | null;
-  signal?: AbortSignal;
+  signal?: AbortSignal | undefined;
 }) => Promise<{
   ok: boolean;
   status: number;
   headers: {
-    get(name: string): string | null;
+    get: (name: string) => string | null;
   };
-  json(): Promise<unknown>;
-  arrayBuffer(): Promise<ArrayBuffer>;
+  json: () => Promise<unknown>;
+  arrayBuffer: () => Promise<ArrayBuffer>;
 }>;
 //#endregion
 export { ManualFetch as t };
-//# sourceMappingURL=http-6vevbBlu.d.mts.map
+//# sourceMappingURL=http-C4HwIu4B.d.mts.map

package/dist/{http-D2rhokZo.mjs → http-CuazNRIP.mjs}

@@ -1,11 +1,15 @@
 //#region src/nips/http.ts
 function requireGlobalFetch(missing) {
 	if (typeof globalThis.fetch !== "function") throw missing();
-	return globalThis.fetch.bind(globalThis);
+	const fetchImpl = globalThis.fetch.bind(globalThis);
+	return async (url, init) => fetchImpl(url, init === void 0 ? init : {
+		...init,
+		signal: init.signal ?? null
+	});
 }
 /** Always sets redirect:manual. Shared by fetchManual and headStatus. */
 async function sendManual(fetchImpl, url, init) {
-	return await fetchImpl(url, {
+	return fetchImpl(url, {
 		...init,
 		redirect: "manual"
 	});
@@ -13,12 +17,12 @@ async function sendManual(fetchImpl, url, init) {
 async function fetchManual(fetchImpl, url, init, wrapNetwork) {
 	try {
 		return await sendManual(fetchImpl, url, init);
-	} catch (err) {
-		if (err instanceof Error && err.name === "AbortError") throw err;
-		throw wrapNetwork(err);
+	} catch (error) {
+		if (error instanceof Error && error.name === "AbortError") throw error;
+		throw wrapNetwork(error);
 	}
 }
 //#endregion
 export { requireGlobalFetch as n, sendManual as r, fetchManual as t };
 
-//# sourceMappingURL=http-D2rhokZo.mjs.map
+//# sourceMappingURL=http-CuazNRIP.mjs.map

package/dist/http-CuazNRIP.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"http-CuazNRIP.mjs","names":[],"sources":["../src/nips/http.ts"],"sourcesContent":["/**\n * Shared nips HTTP primitive. Not a pack entry (core has zero network). Callers never pass\n * `redirect`; sendManual always sets `\"manual\"`.\n */\n\nexport type ManualFetch = (\n  url: string,\n  init?: {\n    method?: string;\n    headers?: Record<string, string>;\n    // oxlint-disable-next-line no-restricted-types -- mirrors RequestInit.body, which is nullable\n    body?: Blob | FormData | string | null;\n    signal?: AbortSignal | undefined;\n  },\n) => Promise<{\n  ok: boolean;\n  status: number;\n  // oxlint-disable-next-line no-restricted-types -- mirrors Headers.get, which returns null\n  headers: { get: (name: string) => string | null };\n  json: () => Promise<unknown>;\n  arrayBuffer: () => Promise<ArrayBuffer>;\n}>;\n\ntype ManualInit = NonNullable<Parameters<ManualFetch>[1]>;\n\nexport function requireGlobalFetch(missing: () => Error): ManualFetch {\n  if (typeof globalThis.fetch !== \"function\") {\n    throw missing();\n  }\n  const fetchImpl = globalThis.fetch.bind(globalThis);\n  // RequestInit.signal is AbortSignal | null and rejects explicit undefined under\n  // exactOptionalPropertyTypes; normalize it for the real fetch.\n  return async (url, init) =>\n    fetchImpl(url, init === undefined ? init : { ...init, signal: init.signal ?? null });\n}\n\n/** Always sets redirect:manual. Shared by fetchManual and headStatus. */\nexport async function sendManual(\n  fetchImpl: ManualFetch,\n  url: string,\n  init: ManualInit,\n): Promise<Awaited<ReturnType<ManualFetch>>> {\n  return fetchImpl(url, { ...init, redirect: \"manual\" } as Parameters<ManualFetch>[1]);\n}\n\nexport async function fetchManual(\n  fetchImpl: ManualFetch,\n  url: string,\n  init: ManualInit,\n  wrapNetwork: (err: unknown) => Error,\n): Promise<Awaited<ReturnType<ManualFetch>>> {\n  try {\n    return await sendManual(fetchImpl, url, init);\n  } catch (error) {\n    if (error instanceof Error && error.name === \"AbortError\") {\n      throw error;\n    }\n    throw wrapNetwork(error);\n  }\n}\n"],"mappings":";AAyBA,SAAgB,mBAAmB,SAAmC;CACpE,IAAI,OAAO,WAAW,UAAU,YAC9B,MAAM,QAAQ;CAEhB,MAAM,YAAY,WAAW,MAAM,KAAK,UAAU;CAGlD,OAAO,OAAO,KAAK,SACjB,UAAU,KAAK,SAAS,KAAA,IAAY,OAAO;EAAE,GAAG;EAAM,QAAQ,KAAK,UAAU;CAAK,CAAC;AACvF;;AAGA,eAAsB,WACpB,WACA,KACA,MAC2C;CAC3C,OAAO,UAAU,KAAK;EAAE,GAAG;EAAM,UAAU;CAAS,CAA+B;AACrF;AAEA,eAAsB,YACpB,WACA,KACA,MACA,aAC2C;CAC3C,IAAI;EACF,OAAO,MAAM,WAAW,WAAW,KAAK,IAAI;CAC9C,SAAS,OAAO;EACd,IAAI,iBAAiB,SAAS,MAAM,SAAS,cAC3C,MAAM;EAER,MAAM,YAAY,KAAK;CACzB;AACF"}

package/dist/index-B425CAcQ.d.mts

@@ -0,0 +1,328 @@
+import { n as EventTemplate, r as UnsignedEvent, t as Event } from "./event-fU3Y01PR.mjs";
+import { t as EventBuilder } from "./builder-BWn55Paf.mjs";
+import { t as Filter } from "./filter-C0IMByE3.mjs";
+import { t as Gossip } from "./gossip-BRQwIM_q.mjs";
+import { a as NostrError } from "./error-CR8Urc84.mjs";
+import { i as PoolPublishResult, t as Pool } from "./pool-tEr7c5bG.mjs";
+import { t as WebSocketConstructor } from "./websocket-CmeqvAkp.mjs";
+import { t as EventStore } from "./types-2pCUprRU.mjs";
+import { t as ReactiveEventStore } from "./reactive-DFpqtIf_.mjs";
+import { a as OutboxFeed, n as Loaders } from "./index-JdaS_uce.mjs";
+import { a as Rumor } from "./nip59-zQgdLcEr.mjs";
+import { i as ReplyTo, r as Recipient } from "./nip17-DNEkz8rM.mjs";
+import { t as NostrSigner } from "./types-CRQEk0Oi.mjs";
+import { t as StorageError } from "./error-BW7re1UN.mjs";
+//#region src/client/types.d.ts
+/** Direction of a {@link Client.sync} run: upload, download, or both. */
+declare const SyncDirection: {
+  readonly Up: "up";
+  readonly Down: "down";
+  readonly Both: "both";
+};
+/** Union of the {@link SyncDirection} values. */
+type SyncDirectionName = (typeof SyncDirection)[keyof typeof SyncDirection];
+/** Options for {@link Client.sync} (NIP-77 set reconciliation). */
+type SyncOptions = {
+  relays?: ReadonlyArray<string>;
+  direction?: SyncDirectionName;
+  /**
+   * Wall-clock deadline for the Negentropy reconciliation session (`NEG-OPEN` through `NEG-CLOSE`),
+   * in milliseconds. One clock for the whole session — not reset per `NEG-MSG`. Default: the relay
+   * `publishTimeoutMs`. Upload/download phases reuse this value as their per-call timeout.
+   */
+  timeoutMs?: number;
+  signal?: AbortSignal;
+  dryRun?: boolean;
+  /** When false, skip observe/storage on downloaded events. Default true. */
+  observe?: boolean;
+};
+/** Outcome of a {@link Client.sync} run: ids compared, sent, received, and failures. */
+type SyncSummary = {
+  local: string[];
+  remote: string[];
+  sent: string[];
+  received: string[];
+  sendFailures: Record<string, string>;
+  persistFailures: Record<string, string>;
+};
+/** Options for {@link Client.builder} / `ClientOptions` accepted by the builder. */
+type ClientOptions = {
+  signer?: NostrSigner;
+  relays?: ReadonlyArray<string>;
+  websocketImplementation?: WebSocketConstructor;
+  /** Injected EVENT verifier. Default is core BIP-340. */
+  verifyEvent?: (event: Event) => boolean;
+  connectTimeoutMs?: number;
+  publishTimeoutMs?: number;
+  /**
+   * When true (default), answer NIP-42 AUTH automatically. The signer is read at challenge time, so
+   * `setSigner()` applies to live connections; challenges received while no signer is set are
+   * ignored.
+   */
+  automaticAuth?: boolean;
+  /** When true (default), relays reconnect with backoff after disconnect. */
+  enableReconnect?: boolean;
+  /** Keepalive ping. Default false. */
+  enablePing?: boolean;
+  pingIntervalMs?: number;
+  pingTimeoutMs?: number;
+  /** Forwarded to the pool: when false (default), `ws://` relays are rejected. */
+  allowInsecure?: boolean;
+  /** Forwarded to the pool: `ws://` URLs allowed despite `allowInsecure`. */
+  trustedInsecureUrls?: ReadonlyArray<string>;
+  /** Forwarded to the pool: close idle relays after this many ms. */
+  idleTimeoutMs?: number;
+  /** Forwarded to the pool: soft cap on connected non-pinned relays. */
+  maxRelays?: number;
+  /** Forwarded to the pool: relays never closed by idle cleanup or `maxRelays`. */
+  pinnedUrls?: ReadonlyArray<string>;
+  gossip?: Gossip;
+  /**
+   * Local event store. Defaults to {@link MemoryEventStore}. Browser apps that want persistence must
+   * pass {@link IndexedDbEventStore} and `await open()`.
+   */
+  storage?: EventStore;
+  /**
+   * Synchronous reactive index that mirrors every ingested event before callbacks and persistence.
+   * Defaults to a new {@link ReactiveEventStore}.
+   */
+  index?: ReactiveEventStore;
+  /**
+   * When true (default), every ingested event is written to storage. Set false to disable automatic
+   * persistence while keeping the store for manual use.
+   */
+  persistEvents?: boolean;
+  /**
+   * Storage I/O failures: live `putMany` flush and `fetchEvents({ localFirst: true })` query. Those
+   * paths do not throw.
+   */
+  onstorageerror?: (err: StorageError) => void;
+};
+type FetchEventsOptions = {
+  relays?: string[];
+  timeoutMs?: number;
+  signal?: AbortSignal;
+  gossip?: boolean;
+  /** When true, query local storage first and merge with network results. Defaults to false. */
+  localFirst?: boolean;
+  /** When false, skip writing fetched events to storage/observe. Default true. */
+  observe?: boolean;
+  /**
+   * Every event of every relay batch, including duplicates across relays. `relayUrl` is the
+   * normalized URL of the relay that delivered it.
+   */
+  onevent?: (event: Event, relayUrl: string) => void;
+};
+type SubscribeOptions = {
+  relays?: string[];
+  /**
+   * First receipt of each event only (deduped across relays). `relayUrl` is the normalized URL of
+   * the relay that delivered it first.
+   */
+  onevent?: (event: Event, relayUrl: string) => void;
+  /** Every receipt from every relay, including duplicates skipped by dedupe. */
+  receivedEvent?: (id: string, relayUrl: string) => void;
+  oneose?: () => void;
+  onclose?: (reason: string) => void;
+  signal?: AbortSignal;
+  id?: string;
+  /**
+   * If set, fire `oneose` once after this many ms if not all relays have EOSEd. Does not close the
+   * subscription.
+   */
+  eoseTimeoutMs?: number;
+  /** Fan out REQs via NIP-65 gossip routes when available. */
+  gossip?: boolean;
+  /** When false, skip writing received events to storage/observe. Default true. */
+  observe?: boolean;
+};
+type PublishOptions = {
+  relays?: string[];
+  timeoutMs?: number;
+  gossip?: boolean;
+  /** When false, skip writing the published event to storage/observe. Default true. */
+  observe?: boolean;
+};
+/** Options for sending a NIP-17 private message. */
+type SendPrivateMessageOptions = {
+  readonly subject?: string;
+  readonly replyTo?: ReplyTo;
+  readonly created_at?: number;
+  readonly timeoutMs?: number;
+  readonly observe?: boolean;
+};
+/** Result of sending a NIP-17 DM: the rumor plus per-recipient wrap publish results. */
+type PrivateMessageSendResult = {
+  rumor: Rumor;
+  wraps: ReadonlyArray<{
+    recipient: string;
+    wrap: Event;
+    results: PoolPublishResult[];
+  }>;
+};
+/** An unwrapped NIP-17 private message: the received gift wrap and its inner rumor. */
+type ReceivedPrivateMessage = {
+  wrap: Event;
+  rumor: Rumor;
+  /** Normalized URL of the relay that delivered the wrap, when known. */
+  relayUrl?: string;
+};
+/** Options for fetching NIP-17 private-message history. */
+type FetchPrivateMessagesOptions = {
+  readonly since?: number;
+  readonly until?: number;
+  readonly timeoutMs?: number;
+  readonly signal?: AbortSignal;
+  readonly observe?: boolean;
+};
+/** Options for a live NIP-17 private-message subscription. */
+type SubscribePrivateMessagesOptions = {
+  readonly since?: number;
+  readonly onevent?: (msg: ReceivedPrivateMessage) => void;
+  readonly oneose?: () => void;
+  readonly onclose?: (reason: string) => void;
+  readonly signal?: AbortSignal;
+  readonly eoseTimeoutMs?: number;
+  readonly observe?: boolean;
+};
+/** Client lifecycle, configuration, or abort failure (not cryptographic). */
+declare class ClientError extends NostrError {
+  name: string;
+}
+//#endregion
+//#region src/client/builder.d.ts
+/**
+ * Fluent constructor for {@link Client}. The constructor is supplied by {@link Client.builder} so
+ * this module never imports the `Client` value, keeping the client/builder dependency
+ * one-directional.
+ */
+declare class ClientBuilder {
+  #private;
+  constructor(newClient: (opts: ClientOptions) => Client);
+  signer(signer: NostrSigner): this;
+  relays(urls: ReadonlyArray<string>): this;
+  addRelay(url: string): this;
+  websocketImplementation(impl: WebSocketConstructor): this;
+  verifyEvent(fn: (event: Event) => boolean): this;
+  connectTimeoutMs(ms: number): this;
+  publishTimeoutMs(ms: number): this;
+  automaticAuth(enabled: boolean): this;
+  /** Allow `ws://` relays. Default false. */
+  allowInsecure(allow: boolean): this;
+  /** `ws://` URLs allowed despite `allowInsecure` being off. */
+  trustedInsecureUrls(urls: ReadonlyArray<string>): this;
+  /** Close idle relays after this many ms. Unset = disabled. */
+  idleTimeoutMs(ms: number): this;
+  /** Soft cap on connected non-pinned relays. */
+  maxRelays(n: number): this;
+  /** Relays never closed by idle cleanup or `maxRelays` eviction. */
+  pinnedUrls(urls: ReadonlyArray<string>): this;
+  enableReconnect(enabled: boolean): this;
+  enablePing(enabled: boolean): this;
+  pingIntervalMs(ms: number): this;
+  pingTimeoutMs(ms: number): this;
+  /**
+   * Local event store. Defaults to {@link MemoryEventStore}. Browser apps that want persistence must
+   * pass {@link IndexedDbEventStore} and `await open()`.
+   */
+  storage(store: EventStore): this;
+  /**
+   * Synchronous reactive index mirroring ingested events. Defaults to a new
+   * {@link ReactiveEventStore}.
+   */
+  index(index: ReactiveEventStore): this;
+  /** When false, Client will not auto-write events to storage. Default true. */
+  persistEvents(enabled: boolean): this;
+  gossip(gossip: Gossip): this;
+  onstorageerror(fn: (err: StorageError) => void): this;
+  build(): Client;
+}
+//#endregion
+//#region src/client/client.d.ts
+/** Layer-5 facade: signer + default relays + pool + loaders + gossip + event store. */
+declare class Client {
+  #private;
+  readonly pool: Pool;
+  readonly loaders: Loaders;
+  readonly gossip: Gossip;
+  readonly storage: EventStore;
+  readonly index: ReactiveEventStore;
+  onstorageerror: ((err: StorageError) => void) | undefined;
+  constructor(opts?: ClientOptions);
+  static builder(): ClientBuilder;
+  get signer(): NostrSigner | undefined;
+  get relays(): ReadonlyArray<string>;
+  get isShutdown(): boolean;
+  setSigner(signer: NostrSigner | undefined): void;
+  addRelay(url: string): void;
+  removeRelay(url: string): void;
+  /** Connect all configured relays (best-effort; failures are ignored). */
+  connect(opts?: {
+    signal?: AbortSignal;
+  }): Promise<void>;
+  shutdown(): Promise<void>;
+  /** Ingest one inbound event: index (with relay URL) → meta → persistence. */
+  observe(event: Event, relayUrl?: string): void;
+  /** Ingest many events (deduped by id, order preserved) as one persist batch. */
+  observeAll(events: ReadonlyArray<Event>): void;
+  /**
+   * Explicitly load kind:10002 and kind:10050 lists for pubkeys and feed gossip. Does not
+   * background-fetch unknown authors on every subscribe (predictable DX).
+   */
+  hydrateGossip(pubkeys: ReadonlyArray<string>, opts?: {
+    hints?: string[];
+    force?: boolean;
+  }): Promise<void>;
+  /**
+   * Create an outbox-model feed for the given authors (NIP-65 write relays). Live events go through
+   * {@link observe}; sync persists via applySync.
+   */
+  outbox(opts: {
+    authors: ReadonlyArray<string>;
+    kinds?: ReadonlyArray<number>;
+    onEvent?: (event: Event) => void;
+    maxRelaysPerAuthor?: number;
+  }): OutboxFeed;
+  getPublicKey(): Promise<string>;
+  signEvent(unsigned: UnsignedEvent): Promise<Event>;
+  signEventBuilder(builder: EventBuilder): Promise<Event>;
+  signTemplate(template: EventTemplate): Promise<Event>;
+  /**
+   * Sign (if builder) and publish to relays. With `gossip: true`, prefers the author's NIP-65
+   * outbox relays, tagged `p` inboxes, and up to 5 `e`/`a` tag relay hints when known. On any
+   * successful OK, observes the event into storage/gossip.
+   */
+  publish(eventOrBuilder: Event | EventBuilder, opts?: PublishOptions): Promise<PoolPublishResult[]>;
+  /**
+   * Fetch events. With `gossip: true`, routes filters by NIP-65 when possible. With `localFirst:
+   * true`, merges storage hits with network results.
+   */
+  fetchEvents(filter: Filter | Filter[], opts?: FetchEventsOptions): Promise<Event[]>;
+  /** Query local storage only (no network). */
+  queryLocal(filter: Filter | Filter[]): Promise<Event[]>;
+  subscribe(filter: Filter | Filter[], opts?: SubscribeOptions): {
+    close: (reason?: string) => void;
+  };
+  /** Publish a kind:10050 NIP-17 DM relay list (`relay` tags). Not kind 10002. */
+  setDmRelays(relays: ReadonlyArray<string>, opts?: PublishOptions): Promise<PoolPublishResult[]>;
+  sendPrivateMessage(recipients: string | Recipient | ReadonlyArray<string | Recipient>, content: string, opts?: SendPrivateMessageOptions): Promise<PrivateMessageSendResult>;
+  fetchPrivateMessages(opts?: FetchPrivateMessagesOptions): Promise<ReceivedPrivateMessage[]>;
+  subscribePrivateMessages(opts?: SubscribePrivateMessagesOptions): Promise<{
+    close: (reason?: string) => void;
+  }>;
+  /**
+   * NIP-77 sync against one relay: reconcile, then optionally upload local-only events and/or
+   * download remote-only events. `observe: false` skips putMany and ingest; received ids are still
+   * listed. `persistEvents: false` skips putMany, still ingests when observe is on.
+   */
+  syncToRelay(url: string, filter: Filter, opts?: Omit<SyncOptions, "relays">): Promise<SyncSummary>;
+  /**
+   * NIP-77 sync against the given relays (or Client default relays). Independent sessions run in
+   * parallel. Fulfilled summaries are merged; if every relay rejects, throws the first rejection in
+   * URL order.
+   */
+  sync(filter: Filter, opts?: SyncOptions): Promise<SyncSummary>;
+}
+//#endregion
+export { FetchEventsOptions as a, PublishOptions as c, SubscribeOptions as d, SubscribePrivateMessagesOptions as f, SyncSummary as g, SyncOptions as h, ClientOptions as i, ReceivedPrivateMessage as l, SyncDirectionName as m, ClientBuilder as n, FetchPrivateMessagesOptions as o, SyncDirection as p, ClientError as r, PrivateMessageSendResult as s, Client as t, SendPrivateMessageOptions as u };
+//# sourceMappingURL=index-B425CAcQ.d.mts.map

package/dist/index-BVyfUBuG.d.mts

@@ -0,0 +1,181 @@
+import { t as Event } from "./event-fU3Y01PR.mjs";
+import { t as Filter } from "./filter-C0IMByE3.mjs";
+import { i as PutResult, n as NegentropyItem, r as OutboxBound, t as EventStore } from "./types-2pCUprRU.mjs";
+//#region src/storage/memory-index.d.ts
+type MemoryIndexOptions = {
+  /**
+   * FIFO cap applied independently to each deletion-state collection: tombstoned event ids, pending
+   * e-tag ids, and coordinate tombstones. Default unbounded. Trade-off: once an entry is trimmed, a
+   * re-arriving old deleted event or replaceable version can be accepted again.
+   */
+  maxTombstones?: number;
+  /**
+   * FIFO cap on replaceable/addressable winner watermarks recorded by {@link evict}. A watermark
+   * keeps only `{ id, created_at }` per address so stale versions stay rejected after the winner's
+   * body is evicted, and a re-put of the watermarked id re-inserts it. Default 0 (no watermark
+   * retention); callers that evict should pass a bound. Once a watermark is trimmed, an older
+   * evicted version can be accepted again — the same trade-off as deletion tombstones.
+   */
+  maxWatermarks?: number;
+  /** Fires after every physical index insert (accept, replace, deletion event). */
+  onInsert?: (event: Event) => void;
+  /** Fires after every physical index remove (replace, delete, evict, remove, clear). */
+  onRemove?: (event: Event) => void;
+};
+/**
+ * Synchronous in-memory event index with NIP-01 replaceable / addressable / ephemeral handling and
+ * NIP-09 deletion (kind 5) application. Shared by {@link MemoryEventStore} (async facade) and
+ * `ReactiveEventStore`.
+ */
+declare class MemoryIndex {
+  #private;
+  constructor(opts?: MemoryIndexOptions);
+  put(raw: Event): PutResult;
+  /** Sequential `put` in input order. */
+  putMany(events: ReadonlyArray<Event>): PutResult[];
+  get(id: string): Event | undefined;
+  /** Current event at a `kind:pubkey:d` coordinate (replaceable or addressable). */
+  getByAddress(address: string): Event | undefined;
+  query(filters: ReadonlyArray<Filter>): Event[];
+  count(filters: ReadonlyArray<Filter>): number;
+  negentropyItems(filter: Filter): NegentropyItem[];
+  /** Remove by id and tombstone (like a local NIP-09). Returns removed count. */
+  remove(ids: ReadonlyArray<string>): number;
+  /**
+   * Remove by id without writing a tombstone (LRU eviction). When the evicted event is the current
+   * winner of a replaceable/addressable address, a `{ id, created_at }` watermark is recorded so
+   * stale versions stay rejected while the body is gone; the watermarks are FIFO-bounded by
+   * `maxWatermarks`.
+   */
+  evict(ids: ReadonlyArray<string>): number;
+  /**
+   * True when the id is tombstoned, or the coordinate has a deletion marker that still covers the
+   * current event at that address: a replacement published after the marker's `until` clears the
+   * deletion. Coordinates are matched on the canonical lowercase pubkey.
+   */
+  isDeleted(idOrAddress: string): boolean;
+  getOutboxBound(pubkey: string, kind: number): OutboxBound | undefined;
+  setOutboxBound(pubkey: string, kind: number, bound: OutboxBound): void;
+  clear(): void;
+  get size(): number;
+}
+//#endregion
+//#region src/storage/memory.d.ts
+/** In-memory event store: async {@link EventStore} facade over the synchronous {@link MemoryIndex}. */
+declare class MemoryEventStore implements EventStore {
+  #private;
+  put(raw: Event): Promise<PutResult>;
+  /** Sequential `put` in input order. No transaction: a throw leaves earlier events applied. */
+  putMany(events: ReadonlyArray<Event>): Promise<PutResult[]>;
+  get(id: string): Promise<Event | undefined>;
+  query(filters: Filter[]): Promise<Event[]>;
+  count(filters: Filter[]): Promise<number>;
+  negentropyItems(filter: Filter): Promise<NegentropyItem[]>;
+  remove(ids: string[]): Promise<number>;
+  getOutboxBound(pubkey: string, kind: number): Promise<OutboxBound | undefined>;
+  setOutboxBound(pubkey: string, kind: number, bound: OutboxBound): Promise<void>;
+  clear(): Promise<void>;
+  get size(): number;
+}
+//#endregion
+//#region src/storage/indexeddb.d.ts
+/** Options for {@link IndexedDbEventStore}. */
+type IndexedDbEventStoreOptions = {
+  /** IndexedDB database name. */
+  dbName?: string;
+};
+/**
+ * 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.
+ */
+declare class IndexedDbEventStore implements EventStore {
+  #private;
+  constructor(opts?: IndexedDbEventStoreOptions);
+  static isAvailable(): boolean;
+  open(): Promise<void>;
+  put(event: Event): Promise<PutResult>;
+  /** One readwrite transaction; abort rejects the whole batch with no partial persist. */
+  putMany(events: ReadonlyArray<Event>): Promise<PutResult[]>;
+  get(id: string): Promise<Event | undefined>;
+  query(filters: Filter[]): Promise<Event[]>;
+  count(filters: Filter[]): Promise<number>;
+  negentropyItems(filter: Filter): Promise<NegentropyItem[]>;
+  getOutboxBound(pubkey: string, kind: number): Promise<OutboxBound | undefined>;
+  setOutboxBound(pubkey: string, kind: number, bound: OutboxBound): Promise<void>;
+  remove(ids: string[]): Promise<number>;
+  clear(): Promise<void>;
+  close(): void;
+}
+//#endregion
+//#region src/storage/sqlite.d.ts
+/** Value bindable to a SQLite statement parameter. */
+type SqlValue = string | number | null | Uint8Array;
+/**
+ * Minimal async SQLite driver surface.
+ *
+ * `transaction` must serialize `fn` exclusively — no interleaved statements from other callers may
+ * run while the callback transaction is active. It commits when `fn` resolves and rolls back when
+ * `fn` rejects.
+ *
+ * The store always issues statements sequentially — a driver never sees a second `exec`/`run`/`all`
+ * start before the previous one settles, inside or outside a transaction — so drivers need not
+ * support overlapping statements on one connection.
+ *
+ * `expo-sqlite` maps onto this interface without changes to query code:
+ *
+ * ```ts
+ * const db = await openDatabaseAsync("nostr.db");
+ * const driver: SqlDriver = {
+ *   exec: (sql) => db.execAsync(sql),
+ *   run: async (sql, params = []) => {
+ *     const r = await db.runAsync(sql, params);
+ *     return { changes: r.changes };
+ *   },
+ *   all: (sql, params = []) => db.getAllAsync(sql, params),
+ *   transaction: (fn) => db.withExclusiveTransactionAsync(() => fn(driver)),
+ * };
+ * ```
+ */
+type SqlDriver = {
+  /** Execute SQL without parameters (DDL, PRAGMA, multi-statement batches). */
+  exec: (sql: string) => Promise<void>;
+  /** Run a statement; resolves with the number of changed rows. */
+  run: (sql: string, params?: ReadonlyArray<SqlValue>) => Promise<{
+    changes: number;
+  }>;
+  /** Run a query; resolves with all result rows. */
+  all: <Row>(sql: string, params?: ReadonlyArray<SqlValue>) => Promise<Row[]>;
+  /** Run `fn` inside an exclusive transaction; commit on resolve, roll back on reject. */
+  transaction: <T>(fn: (tx: SqlDriver) => Promise<T>) => Promise<T>;
+};
+/**
+ * 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.
+ */
+declare class SqliteEventStore implements EventStore {
+  #private;
+  private constructor();
+  /** Create the schema on first use and return a ready store. */
+  static open(driver: SqlDriver): Promise<SqliteEventStore>;
+  put(event: Event): Promise<PutResult>;
+  putMany(events: ReadonlyArray<Event>): Promise<PutResult[]>;
+  get(id: string): Promise<Event | undefined>;
+  query(filters: Filter[]): Promise<Event[]>;
+  count(filters: Filter[]): Promise<number>;
+  negentropyItems(filter: Filter): Promise<NegentropyItem[]>;
+  getOutboxBound(pubkey: string, kind: number): Promise<OutboxBound | undefined>;
+  setOutboxBound(pubkey: string, kind: number, bound: OutboxBound): Promise<void>;
+  remove(ids: string[]): Promise<number>;
+  clear(): Promise<void>;
+}
+//#endregion
+export { IndexedDbEventStoreOptions as a, MemoryIndexOptions as c, IndexedDbEventStore as i, SqlValue as n, MemoryEventStore as o, SqliteEventStore as r, MemoryIndex as s, SqlDriver as t };
+//# sourceMappingURL=index-BVyfUBuG.d.mts.map