@qntx/nostr 0.1.0 → 0.2.1

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-B-CGNDPS.d.mts

@@ -0,0 +1,207 @@
+import { t as Event } from "./event-fU3Y01PR.mjs";
+import { n as ProfileMetadata } from "./builder-BWn55Paf.mjs";
+import { t as RelayListItem } from "./nip65-DBfh2smt.mjs";
+import { t as Gossip } from "./gossip-BRQwIM_q.mjs";
+import { a as NostrError } from "./error-CR8Urc84.mjs";
+import { n as Pool } from "./pool-B7p_reAm.mjs";
+import { r as OutboxBound, t as EventStore } from "./types-2pCUprRU.mjs";
+import { t as ReactiveEventStore } from "./reactive-DFpqtIf_.mjs";
+import { i as EventPointer, t as AddressPointer } from "./nip19-BevCJZsp.mjs";
+//#region src/loaders/event.d.ts
+type EventRef = string | EventPointer | AddressPointer;
+/**
+ * Resolve an event reference (hex id, note, nevent, naddr, or pointer object) through the reactive
+ * index, fetching from relays on a miss. The index is the durable store — the loader keeps only
+ * in-flight coalescing, so a miss never blocks a later retry.
+ */
+type EventLoader = {
+  load: (ref: EventRef) => Promise<Event | undefined>;
+};
+//#endregion
+//#region src/loaders/replaceable.d.ts
+/** Result of a replaceable load: the winning event (or none) and freshness. */
+type ReplaceableLoadResult = {
+  event: Event | undefined;
+  fresh: boolean;
+};
+/** `default`: fetch when stale or unfetched; `force`: always fetch; `cache-only`: index only. */
+type LoadStyle = "default" | "force" | "cache-only";
+/** Loads the winning replaceable/addressable event of one kind for a pubkey. */
+type ReplaceableLoader = (pubkey: string, opts?: {
+  hints?: string[] | undefined;
+  style?: LoadStyle | undefined;
+}) => Promise<ReplaceableLoadResult>;
+//#endregion
+//#region src/loaders/lists.d.ts
+/** Result of a list loader: the source event, its decoded items, and freshness. */
+type ListResult<T> = {
+  event: Event | undefined;
+  items: T[];
+  fresh: boolean;
+};
+/** One muted entity decoded from a kind:10000 mute list. */
+type MutedEntity = {
+  label: "pubkey";
+  value: string;
+} | {
+  label: "thread";
+  value: string;
+} | {
+  label: "hashtag";
+  value: string;
+} | {
+  label: "word";
+  value: string;
+};
+type ListLoaderOpts = {
+  hints?: string[] | undefined;
+  style?: LoadStyle | undefined;
+};
+type ListLoaders = {
+  follows: (pubkey: string, opts?: ListLoaderOpts) => Promise<ListResult<string>>;
+  muteList: (pubkey: string, opts?: ListLoaderOpts) => Promise<ListResult<MutedEntity>>;
+  relayList: (pubkey: string, opts?: ListLoaderOpts) => Promise<ListResult<RelayListItem>>;
+  dmRelayList: (pubkey: string, opts?: ListLoaderOpts) => Promise<ListResult<string>>;
+};
+//#endregion
+//#region src/loaders/profile.d.ts
+/** A profile-card view of a pubkey: identity fields plus the kind:0 event. */
+type NostrUser = {
+  pubkey: string;
+  npub: string;
+  shortName: string;
+  image?: string;
+  metadata: ProfileMetadata;
+  lastUpdated: number;
+  event: Event | undefined;
+  fresh: boolean;
+};
+/** A {@link NostrUser} with no metadata — used when no kind:0 event exists. */
+declare function bareNostrUser(pubkey: string): NostrUser;
+type ProfileLoader = {
+  load: (pubkey: string, opts?: {
+    hints?: string[] | undefined;
+    style?: LoadStyle | undefined;
+  }) => Promise<NostrUser>;
+};
+//#endregion
+//#region src/loaders/outbox.d.ts
+/** Outbox feed lifecycle error (e.g. use after close). */
+declare class OutboxError extends NostrError {
+  name: string;
+}
+/** Options for {@link createOutboxFeed}. */
+type OutboxFeedOptions = {
+  pool: Pool;
+  gossip: Gossip;
+  storage: EventStore;
+  /** Fallback relays when an author has no known outbox routes. */
+  discoveryRelays: ReadonlyArray<string>;
+  authors: ReadonlyArray<string>;
+  /** Event kinds to fetch. Default `[Kind.TextNote]`. */
+  kinds?: ReadonlyArray<number> | undefined;
+  /** Max write-relays to use per author. Default 3. */
+  maxRelaysPerAuthor?: number | undefined;
+  fetchTimeoutMs?: number | undefined;
+  /** Called for live events after observe, and for sync events returned by applySync. */
+  onEvent?: ((event: Event) => void) | undefined;
+  /** Live ingest (e.g. `client.observe`) with the source relay URL. StartLive never putManys. */
+  observe?: ((event: Event, relayUrl: string) => void) | undefined;
+  /**
+   * Every receipt from every relay — live (including duplicates the feed's own dedupe skips) and
+   * sync fetch batches — for seenOn bookkeeping.
+   */
+  seen?: ((event: Event, relayUrl: string) => void) | undefined;
+  /**
+   * Sync path only. Awaited. Return events that should advance bounds. Throw → sync throws, bounds
+   * unchanged.
+   */
+  applySync?: ((events: ReadonlyArray<Event>) => Promise<ReadonlyArray<Event>>) | undefined;
+  /** Load kind:10002 for authors before sync when routes are missing. Requires a relay-list loader. */
+  hydrate?: ((pubkeys: ReadonlyArray<string>) => Promise<void>) | undefined;
+};
+/**
+ * Group authors by outbox relay (discovery fallback). `prefer` reorders existing candidates only;
+ * it never appends a URL that is not already in the author's outbox or discovery list. Returns
+ * Map<relayUrl, authors[]>.
+ */
+declare function groupAuthorsByOutboxRelay(authors: ReadonlyArray<string>, gossip: Gossip, discoveryRelays: ReadonlyArray<string>, maxRelaysPerAuthor?: number, prefer?: ReadonlyArray<string>): Map<string, string[]>;
+/**
+ * Outbox-model feed: history sync + live subscription for a set of authors, routed via NIP-65 write
+ * relays (with discovery fallback).
+ */
+declare class OutboxFeed {
+  #private;
+  constructor(opts: OutboxFeedOptions);
+  get authors(): ReadonlyArray<string>;
+  get kinds(): ReadonlyArray<number>;
+  /** Replace the author set (does not auto-restart live). */
+  setAuthors(authors: ReadonlyArray<string>): void;
+  getBound(pubkey: string, kind: number): OutboxBound | undefined;
+  /** Load NIP-65 relay lists for authors that have no outbox routes yet. */
+  hydrate(): Promise<void>;
+  /** One-shot history pull. Persistence is `applySync`; bounds move only for events it returns. */
+  sync(opts?: {
+    limit?: number | undefined;
+    since?: number | undefined;
+    until?: number | undefined;
+    signal?: AbortSignal | undefined;
+    /** Skip hydrate() even if provided. */
+    skipHydrate?: boolean | undefined;
+  }): Promise<Event[]>;
+  /**
+   * Start a live subscription across outbox relays for the current authors. Closes any previous
+   * live subscription.
+   */
+  startLive(opts?: {
+    signal?: AbortSignal | undefined;
+    since?: number | undefined;
+  }): {
+    close: (reason?: string) => void;
+  };
+  /** Convenience: hydrate + sync + startLive. */
+  start(opts?: {
+    limit?: number | undefined;
+    signal?: AbortSignal | undefined;
+  }): Promise<{
+    close: (reason?: string) => void;
+    events: Event[];
+  }>;
+  close(): void;
+}
+/** Factory matching other loaders helpers. */
+declare function createOutboxFeed(opts: OutboxFeedOptions): OutboxFeed;
+//#endregion
+//#region src/loaders/index.d.ts
+/** The loader surface returned by {@link createLoaders}. */
+type Loaders = {
+  follows: ListLoaders["follows"];
+  muteList: ListLoaders["muteList"];
+  relayList: ListLoaders["relayList"];
+  dmRelayList: ListLoaders["dmRelayList"];
+  profile: ProfileLoader["load"];
+  event: EventLoader["load"];
+  /** Generic replaceable loader for any kind; memoized per kind. */
+  replaceable: (kind: number) => ReplaceableLoader;
+  addRelay: (url: string) => void;
+  removeRelay: (url: string) => void;
+};
+/** Options for {@link createLoaders}. */
+type CreateLoadersOptions = {
+  pool: Pool;
+  relays: ReadonlyArray<string>;
+  /** The reactive index loaders read from and feed fetched events into. */
+  index: ReactiveEventStore;
+  /**
+   * Inbound-event sink for fetched events; defaults to `index.add`. Client wires its single ingest
+   * path so loader fetches get gossip meta and persistence like every other inbound event.
+   */
+  ingest?: (event: Event, relayUrl: string) => void;
+  staleAfterSec?: number;
+  fetchTimeoutMs?: number;
+};
+/** Build an instance-scoped loader suite (no module globals). */
+declare function createLoaders(opts: CreateLoadersOptions): Loaders;
+//#endregion
+export { ReplaceableLoader as _, OutboxFeed as a, groupAuthorsByOutboxRelay as c, bareNostrUser as d, ListLoaders as f, ReplaceableLoadResult as g, LoadStyle as h, OutboxError as i, NostrUser as l, MutedEntity as m, Loaders as n, OutboxFeedOptions as o, ListResult as p, createLoaders as r, createOutboxFeed as s, CreateLoadersOptions as t, ProfileLoader as u, EventLoader as v, EventRef as y };
+//# sourceMappingURL=index-B-CGNDPS.d.mts.map

package/dist/index-BIhSADwK.d.mts

@@ -0,0 +1,339 @@
+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 { a as PoolPublishResult, n as Pool, t as InvalidEventPolicy } from "./pool-B7p_reAm.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-B-CGNDPS.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>;
+  /**
+   * Forwarded to the pool: a relay exceeding `limit` verification failures inside `windowMs` is
+   * disconnected and suspended for `cooldownMs`.
+   */
+  invalidEventPolicy?: InvalidEventPolicy;
+  /** Forwarded to the pool: fired once when a relay is suspended, with the lift time. */
+  onRelaySuspended?: (url: string, until: number) => void;
+  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;
+  /** Forwarded to the pool: suspend a relay delivering too many invalid events. */
+  invalidEventPolicy(policy: InvalidEventPolicy): this;
+  /** Forwarded to the pool: fired once when a relay is suspended, with the lift time. */
+  onRelaySuspended(cb: (url: string, until: number) => void): 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-BIhSADwK.d.mts.map