@nostr-wot/graph 0.2.0

package/dist/react/index.cjs

@@ -0,0 +1,835 @@
+'use strict';
+
+var react = require('react');
+var relay = require('@nostr-wot/relay');
+var nostrTools = require('nostr-tools');
+var pool = require('nostr-tools/pool');
+var jsxRuntime = require('react/jsx-runtime');
+
+// src/react/context.tsx
+
+// src/storage.ts
+var DB_PREFIX = "nostr-wot-graph";
+var DB_VERSION = 1;
+var STORE_PUBKEYS = "pubkeys";
+var STORE_FOLLOWS = "follows";
+var STORE_META = "meta";
+function encodeFollows(followIds) {
+  if (followIds.length === 0) return new ArrayBuffer(0);
+  const sorted = Array.from(followIds).sort((a, b) => a - b);
+  const deltas = new Uint32Array(sorted.length);
+  deltas[0] = sorted[0];
+  for (let i = 1; i < sorted.length; i++) {
+    deltas[i] = sorted[i] - sorted[i - 1];
+  }
+  return deltas.buffer;
+}
+function decodeFollows(buffer) {
+  if (!buffer || buffer.byteLength === 0) return new Uint32Array(0);
+  const deltas = new Uint32Array(buffer);
+  const result = new Uint32Array(deltas.length);
+  result[0] = deltas[0];
+  for (let i = 1; i < deltas.length; i++) {
+    result[i] = result[i - 1] + deltas[i];
+  }
+  return result;
+}
+function hasIndexedDB() {
+  return typeof indexedDB !== "undefined" && indexedDB !== null;
+}
+var GraphStorage = class {
+  constructor(namespace) {
+    this.db = null;
+    this.memoryOnly = false;
+    this.opened = false;
+    // In-memory caches (source of truth for reads/BFS).
+    this.pubkeyToId = /* @__PURE__ */ new Map();
+    this.idToPubkey = /* @__PURE__ */ new Map();
+    this.nextId = 1;
+    this.graphCache = /* @__PURE__ */ new Map();
+    this.metaCache = /* @__PURE__ */ new Map();
+    // Pending persistence buffers (drained by flush()).
+    this.dirtyFollows = /* @__PURE__ */ new Map();
+    this.dirtyPubkeys = [];
+    if (!namespace) throw new Error("GraphStorage requires a namespace");
+    this.namespace = namespace;
+  }
+  dbName() {
+    return `${DB_PREFIX}:${this.namespace}`;
+  }
+  /** Open (or create) the namespace DB and hydrate in-memory caches. */
+  async open() {
+    if (this.opened) return;
+    if (!hasIndexedDB()) {
+      this.memoryOnly = true;
+      this.opened = true;
+      return;
+    }
+    await new Promise((resolve, reject) => {
+      const request = indexedDB.open(this.dbName(), DB_VERSION);
+      request.onerror = () => reject(request.error);
+      request.onupgradeneeded = (event) => {
+        const database = event.target.result;
+        if (!database.objectStoreNames.contains(STORE_PUBKEYS)) {
+          const store = database.createObjectStore(STORE_PUBKEYS, { keyPath: "id" });
+          store.createIndex("pubkey", "pubkey", { unique: true });
+        }
+        if (!database.objectStoreNames.contains(STORE_FOLLOWS)) {
+          database.createObjectStore(STORE_FOLLOWS, { keyPath: "id" });
+        }
+        if (!database.objectStoreNames.contains(STORE_META)) {
+          database.createObjectStore(STORE_META, { keyPath: "key" });
+        }
+      };
+      request.onsuccess = () => {
+        this.db = request.result;
+        resolve();
+      };
+    });
+    this.opened = true;
+    await this.loadAll();
+  }
+  /** Hydrate the in-memory interning + follow maps + meta from the DB. */
+  async loadAll() {
+    this.pubkeyToId.clear();
+    this.idToPubkey.clear();
+    this.graphCache.clear();
+    this.metaCache.clear();
+    this.nextId = 1;
+    if (this.memoryOnly || !this.db) return;
+    const db = this.db;
+    const pubkeys = await this.getAll(db, STORE_PUBKEYS);
+    for (const record of pubkeys) {
+      this.pubkeyToId.set(record.pubkey, record.id);
+      this.idToPubkey.set(record.id, record.pubkey);
+      if (record.id >= this.nextId) this.nextId = record.id + 1;
+    }
+    const follows = await this.getAll(db, STORE_FOLLOWS);
+    for (const record of follows) {
+      this.graphCache.set(record.id, decodeFollows(record.follows));
+    }
+    const meta = await this.getAll(db, STORE_META);
+    for (const record of meta) {
+      this.metaCache.set(record.key, record.value);
+    }
+  }
+  getAll(db, store) {
+    return new Promise((resolve, reject) => {
+      const tx = db.transaction(store, "readonly");
+      const request = tx.objectStore(store).getAll();
+      request.onsuccess = () => resolve(request.result);
+      request.onerror = () => reject(request.error);
+    });
+  }
+  // ── Interning ──
+  /** Numeric id for a pubkey, or null if never seen. */
+  getId(pubkey) {
+    var _a;
+    return (_a = this.pubkeyToId.get(pubkey)) != null ? _a : null;
+  }
+  /** Numeric id for a pubkey, minting and buffering a new one if needed. */
+  getOrCreateId(pubkey) {
+    const existing = this.pubkeyToId.get(pubkey);
+    if (existing !== void 0) return existing;
+    const id = this.nextId++;
+    this.pubkeyToId.set(pubkey, id);
+    this.idToPubkey.set(id, pubkey);
+    this.dirtyPubkeys.push({ id, pubkey });
+    return id;
+  }
+  /** Batch variant of {@link getOrCreateId}. */
+  getOrCreateIds(pubkeys) {
+    const ids = new Array(pubkeys.length);
+    for (let i = 0; i < pubkeys.length; i++) {
+      ids[i] = this.getOrCreateId(pubkeys[i]);
+    }
+    return ids;
+  }
+  /** Pubkey for a numeric id, or null. */
+  getHex(id) {
+    var _a;
+    return (_a = this.idToPubkey.get(id)) != null ? _a : null;
+  }
+  /** Highest assigned id (for typed-array sizing). */
+  getMaxId() {
+    return this.nextId - 1;
+  }
+  // ── Follows ──
+  /** Store `pubkey`'s follow list. Interns everything and updates the cache. */
+  saveFollows(pubkey, follows) {
+    const id = this.getOrCreateId(pubkey);
+    const followIds = this.getOrCreateIds(follows);
+    this.graphCache.set(id, new Uint32Array(followIds));
+    this.dirtyFollows.set(id, followIds);
+  }
+  /** Follow ids for a node id — sync, from the in-memory cache. */
+  getFollowIdsSync(id) {
+    var _a;
+    return (_a = this.graphCache.get(id)) != null ? _a : new Uint32Array(0);
+  }
+  /** Follow ids for a pubkey (interned). Empty if unknown. */
+  getFollowIds(pubkey) {
+    const id = this.getId(pubkey);
+    if (id === null) return new Uint32Array(0);
+    return this.getFollowIdsSync(id);
+  }
+  /** Follow list of `pubkey` as hex strings. */
+  getFollows(pubkey) {
+    const ids = this.getFollowIds(pubkey);
+    const out = [];
+    for (let i = 0; i < ids.length; i++) {
+      const hex = this.getHex(ids[i]);
+      if (hex) out.push(hex);
+    }
+    return out;
+  }
+  // ── Meta ──
+  async setMeta(key, value) {
+    this.metaCache.set(key, value);
+    if (this.memoryOnly || !this.db) return;
+    const db = this.db;
+    await new Promise((resolve, reject) => {
+      const tx = db.transaction(STORE_META, "readwrite");
+      tx.objectStore(STORE_META).put({ key, value });
+      tx.oncomplete = () => resolve();
+      tx.onerror = () => reject(tx.error);
+    });
+  }
+  getMeta(key) {
+    return this.metaCache.get(key);
+  }
+  /** Read the structured graph meta record. */
+  getGraphMeta() {
+    var _a, _b, _c, _d;
+    return {
+      root: (_a = this.getMeta("root")) != null ? _a : null,
+      lastCrawl: (_b = this.getMeta("lastCrawl")) != null ? _b : null,
+      maxDepth: (_c = this.getMeta("maxDepth")) != null ? _c : null,
+      version: (_d = this.getMeta("version")) != null ? _d : DB_VERSION
+    };
+  }
+  // ── Persistence ──
+  /** Flush buffered pubkey + follow writes to IndexedDB. No-op in memory mode. */
+  async flush() {
+    if (this.memoryOnly || !this.db) {
+      this.dirtyPubkeys.length = 0;
+      this.dirtyFollows.clear();
+      return;
+    }
+    const db = this.db;
+    const pubkeys = this.dirtyPubkeys.splice(0, this.dirtyPubkeys.length);
+    const follows = Array.from(this.dirtyFollows.entries());
+    this.dirtyFollows.clear();
+    if (pubkeys.length === 0 && follows.length === 0) return;
+    await new Promise((resolve, reject) => {
+      const stores = [];
+      if (pubkeys.length) stores.push(STORE_PUBKEYS);
+      if (follows.length) stores.push(STORE_FOLLOWS);
+      const tx = db.transaction(stores, "readwrite");
+      if (pubkeys.length) {
+        const store = tx.objectStore(STORE_PUBKEYS);
+        for (const row of pubkeys) store.put(row);
+      }
+      if (follows.length) {
+        const store = tx.objectStore(STORE_FOLLOWS);
+        for (const [id, followIds] of follows) {
+          store.put({ id, follows: encodeFollows(followIds), updated_at: Date.now() });
+        }
+      }
+      tx.oncomplete = () => resolve();
+      tx.onerror = () => reject(tx.error);
+    });
+  }
+  // ── Stats / clear ──
+  stats() {
+    let edges = 0;
+    for (const follows of this.graphCache.values()) edges += follows.length;
+    return {
+      nodes: this.graphCache.size,
+      edges,
+      uniquePubkeys: this.pubkeyToId.size
+    };
+  }
+  /** Wipe this namespace: memory caches + persisted stores. */
+  async clear() {
+    this.pubkeyToId.clear();
+    this.idToPubkey.clear();
+    this.graphCache.clear();
+    this.metaCache.clear();
+    this.dirtyFollows.clear();
+    this.dirtyPubkeys.length = 0;
+    this.nextId = 1;
+    if (this.memoryOnly || !this.db) return;
+    const db = this.db;
+    await new Promise((resolve, reject) => {
+      const tx = db.transaction([STORE_FOLLOWS, STORE_PUBKEYS, STORE_META], "readwrite");
+      tx.objectStore(STORE_FOLLOWS).clear();
+      tx.objectStore(STORE_PUBKEYS).clear();
+      tx.objectStore(STORE_META).clear();
+      tx.oncomplete = () => resolve();
+      tx.onerror = () => reject(tx.error);
+    });
+  }
+  /** Close the underlying DB connection. */
+  close() {
+    if (this.db) {
+      this.db.close();
+      this.db = null;
+    }
+    this.opened = false;
+  }
+};
+
+// src/graph.ts
+var DEFAULT_MAX_HOPS = 6;
+var LocalGraph = class {
+  constructor(storage) {
+    this.cache = null;
+    this.cachedRoot = null;
+    this.storage = storage;
+  }
+  /** Invalidate the precomputed cache (called on crawl / root change / clear). */
+  invalidateCache() {
+    this.cache = null;
+    this.cachedRoot = null;
+  }
+  /**
+   * Precompute hops and paths from a root pubkey using a single BFS pass.
+   * Results stored in typed arrays indexed by node id for O(1) lookup.
+   */
+  buildCache(rootPubkey, maxHops = DEFAULT_MAX_HOPS) {
+    const rootId = this.storage.getId(rootPubkey);
+    if (rootId === null) {
+      this.cache = null;
+      this.cachedRoot = null;
+      return;
+    }
+    const maxId = this.storage.getMaxId();
+    const hops = new Uint8Array(maxId + 1);
+    const paths = new Uint32Array(maxId + 1);
+    hops[rootId] = 1;
+    paths[rootId] = 1;
+    let frontier = [rootId];
+    let hop = 0;
+    while (frontier.length > 0 && hop < maxHops) {
+      hop++;
+      const hopStored = hop + 1;
+      const nextFrontier = [];
+      for (let f = 0; f < frontier.length; f++) {
+        const nodeId = frontier[f];
+        const nodePaths = paths[nodeId];
+        const followIds = this.storage.getFollowIdsSync(nodeId);
+        for (let i = 0; i < followIds.length; i++) {
+          const fid = followIds[i];
+          if (fid > maxId) continue;
+          if (hops[fid] === 0) {
+            hops[fid] = hopStored;
+            paths[fid] = nodePaths;
+            nextFrontier.push(fid);
+          } else if (hops[fid] === hopStored) {
+            paths[fid] += nodePaths;
+          }
+        }
+      }
+      frontier = nextFrontier;
+    }
+    this.cache = { rootId, hops, paths, maxId };
+    this.cachedRoot = rootPubkey;
+  }
+  /** Ensure the cache is built for `root`. */
+  ensureCache(root, maxHops) {
+    if (this.cachedRoot !== root || !this.cache) {
+      this.buildCache(root, maxHops);
+    }
+  }
+  /**
+   * Distance info from `root` to `pubkey`. Returns `{ hops, paths }`, or `null`
+   * when unreached / unknown. Self → `{ hops: 0, paths: 1 }`.
+   */
+  getDistance(root, pubkey, maxHops = DEFAULT_MAX_HOPS) {
+    if (root === pubkey) return { hops: 0, paths: 1 };
+    this.ensureCache(root, maxHops);
+    if (!this.cache || this.cachedRoot !== root) return null;
+    const toId = this.storage.getId(pubkey);
+    if (toId === null || toId > this.cache.maxId) return null;
+    const h = this.cache.hops[toId];
+    if (h === 0) return null;
+    return { hops: h - 1, paths: this.cache.paths[toId] };
+  }
+  /** Follow list of `pubkey` as hex strings. */
+  getFollows(pubkey) {
+    return this.storage.getFollows(pubkey);
+  }
+};
+
+// src/crawl.ts
+var CrawlError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "CrawlError";
+  }
+};
+var DEFAULT_MAX_DEPTH = 2;
+var GraphCrawler = class {
+  constructor(options) {
+    this.aborted = false;
+    var _a, _b, _c;
+    this.pool = options.pool;
+    this.storage = options.storage;
+    this.relays = options.relays;
+    this.baseDelayMs = (_a = options.baseDelayMs) != null ? _a : 50;
+    this.maxConcurrent = (_b = options.maxConcurrent) != null ? _b : 5;
+    this.requestTimeoutMs = (_c = options.requestTimeoutMs) != null ? _c : 1e4;
+  }
+  /** Abort an in-flight crawl. */
+  stop() {
+    this.aborted = true;
+  }
+  async crawl(rootPubkey, opts = {}) {
+    var _a;
+    if (this.relays.length === 0) {
+      throw new CrawlError("no relays connected");
+    }
+    const maxDepth = (_a = opts.maxDepth) != null ? _a : DEFAULT_MAX_DEPTH;
+    const start = Date.now();
+    this.aborted = false;
+    const signal = opts.signal;
+    const onAbort = () => this.stop();
+    if (signal) {
+      if (signal.aborted) this.aborted = true;
+      else signal.addEventListener("abort", onAbort);
+    }
+    const fetched = /* @__PURE__ */ new Set();
+    const failed = /* @__PURE__ */ new Set();
+    const seen = /* @__PURE__ */ new Set([rootPubkey]);
+    let currentLevel = [rootPubkey];
+    let reachedDepth = 0;
+    let stoppedEarly = false;
+    try {
+      for (let depth = 0; depth <= maxDepth; depth++) {
+        if (currentLevel.length === 0) break;
+        if (this.aborted) {
+          stoppedEarly = true;
+          break;
+        }
+        const nextSet = /* @__PURE__ */ new Set();
+        await this.mapLimited(currentLevel, async (pubkey) => {
+          var _a2;
+          if (this.aborted) return;
+          const follows = await this.fetchNewest(pubkey);
+          if (this.aborted) return;
+          if (follows === null) {
+            failed.add(pubkey);
+          } else {
+            fetched.add(pubkey);
+            reachedDepth = Math.max(reachedDepth, depth);
+            this.storage.saveFollows(pubkey, follows);
+            if (depth < maxDepth) {
+              for (const f of follows) {
+                if (!seen.has(f)) {
+                  seen.add(f);
+                  nextSet.add(f);
+                }
+              }
+            }
+          }
+          (_a2 = opts.onProgress) == null ? void 0 : _a2.call(opts, { depth, fetched: fetched.size, queued: nextSet.size });
+        });
+        if (this.aborted) {
+          stoppedEarly = true;
+          break;
+        }
+        currentLevel = Array.from(nextSet);
+      }
+    } finally {
+      if (signal) signal.removeEventListener("abort", onAbort);
+      await this.storage.flush();
+    }
+    const stats = this.storage.stats();
+    return {
+      fetched: fetched.size,
+      nodes: stats.nodes,
+      edges: stats.edges,
+      depth: reachedDepth,
+      durationMs: Date.now() - start,
+      stoppedEarly
+    };
+  }
+  /**
+   * Fetch a single pubkey's newest kind:3 follow list across relays.
+   * Resolves to the follow pubkeys, or `null` if no event arrived.
+   */
+  fetchNewest(pubkey) {
+    return new Promise((resolve) => {
+      let newestAt = 0;
+      let follows = null;
+      let settled = false;
+      let sub = null;
+      const finish = () => {
+        if (settled) return;
+        settled = true;
+        clearTimeout(timer);
+        try {
+          sub == null ? void 0 : sub.close();
+        } catch (e) {
+        }
+        resolve(follows);
+      };
+      const timer = setTimeout(finish, this.requestTimeoutMs);
+      sub = this.pool.subscribe(
+        { kinds: [3], authors: [pubkey], limit: 1 },
+        {
+          onEvent: (ev) => {
+            if (ev && ev.created_at > newestAt) {
+              newestAt = ev.created_at;
+              follows = (ev.tags || []).filter((tag) => tag[0] === "p" && tag[1]).map((tag) => tag[1]);
+            }
+          },
+          onEose: finish
+        }
+      );
+      if (settled) {
+        try {
+          sub == null ? void 0 : sub.close();
+        } catch (e) {
+        }
+      }
+    });
+  }
+  /**
+   * Run `worker` over `items` with a max-concurrency cap and a base delay
+   * before each dispatch (preserving the crawler's per-relay rate limiting
+   * intent, now applied at the pool boundary).
+   */
+  async mapLimited(items, worker) {
+    let index = 0;
+    const runNext = async () => {
+      while (index < items.length) {
+        if (this.aborted) return;
+        const item = items[index++];
+        if (this.baseDelayMs > 0) {
+          await new Promise((r) => setTimeout(r, this.baseDelayMs));
+        }
+        if (this.aborted) return;
+        await worker(item);
+      }
+    };
+    const lanes = Math.min(this.maxConcurrent, Math.max(1, items.length));
+    await Promise.all(Array.from({ length: lanes }, () => runNext()));
+  }
+};
+
+// src/scoring.ts
+var DEFAULT_SCORING = {
+  distanceWeights: { 1: 1, 2: 0.5, 3: 0.25, 4: 0.1 },
+  pathBonus: { 2: 0.15, 3: 0.1, 4: 0.05 },
+  maxPathBonus: 0.5
+};
+function calculateScore(hops, paths, scoring = DEFAULT_SCORING) {
+  var _a, _b, _c, _d;
+  if (hops === 0) return 1;
+  if (hops === null || hops === void 0) return 0;
+  const { distanceWeights, pathBonus, maxPathBonus } = scoring;
+  const hopKey = Math.min(hops, 4);
+  const base = (_b = (_a = distanceWeights == null ? void 0 : distanceWeights[hopKey]) != null ? _a : DEFAULT_SCORING.distanceWeights[hopKey]) != null ? _b : 0.1;
+  let bonus = 0;
+  if (paths !== null && paths > 1 && hops > 1) {
+    let pathBonusValue;
+    if (typeof pathBonus === "object") {
+      pathBonusValue = (_d = (_c = pathBonus[hopKey]) != null ? _c : DEFAULT_SCORING.pathBonus[hopKey]) != null ? _d : 0.05;
+    } else {
+      pathBonusValue = pathBonus != null ? pathBonus : 0.1;
+    }
+    bonus = Math.min(pathBonusValue * (paths - 1), maxPathBonus != null ? maxPathBonus : 0.5);
+  }
+  const score = base + bonus;
+  return Math.min(Math.max(score, 0), 1);
+}
+
+// src/wot-source.ts
+function createWoTSource(graph) {
+  return {
+    getDistance(target) {
+      const info = graph.getDistance(target);
+      return info ? info.hops : null;
+    },
+    isInMyWoT(target, maxHops) {
+      return graph.isInWoT(target, maxHops);
+    },
+    filterByWoT(pubkeys, opts) {
+      return graph.filterByWoT(pubkeys, opts);
+    }
+  };
+}
+
+// src/wot-graph.ts
+var DEFAULT_MAX_HOPS2 = 2;
+var STORAGE_VERSION = 1;
+var WotGraph = class {
+  constructor(options) {
+    this.ownPool = null;
+    this.crawler = null;
+    this.root = null;
+    this.inFlight = null;
+    this.controller = null;
+    this.listeners = /* @__PURE__ */ new Set();
+    var _a;
+    this.namespace = options.namespace;
+    this.relays = [...options.relays];
+    this.scoring = mergeScoring(options.scoring);
+    this.websocketImplementation = options.websocketImplementation;
+    this.pool = (_a = options.pool) != null ? _a : null;
+    this.storage = new GraphStorage(this.namespace);
+    this.graph = new LocalGraph(this.storage);
+  }
+  /** Hydrate any cached graph from IndexedDB (fast path). */
+  async load() {
+    await this.storage.open();
+    this.root = this.storage.getGraphMeta().root;
+    this.graph.invalidateCache();
+    this.notify();
+  }
+  /**
+   * Build/refresh the graph by crawling kind:3 from `rootPubkey`.
+   * Concurrent calls return the same in-flight promise (idempotent).
+   */
+  crawl(rootPubkey, opts = {}) {
+    if (this.inFlight) return this.inFlight;
+    this.controller = new AbortController();
+    if (opts.signal) {
+      if (opts.signal.aborted) this.controller.abort();
+      else opts.signal.addEventListener("abort", () => {
+        var _a;
+        return (_a = this.controller) == null ? void 0 : _a.abort();
+      }, { once: true });
+    }
+    this.root = rootPubkey;
+    const run = (async () => {
+      var _a;
+      try {
+        await this.storage.open();
+        const pool = this.resolvePool();
+        this.crawler = new GraphCrawler({ pool, storage: this.storage, relays: this.relays });
+        const result = await this.crawler.crawl(rootPubkey, {
+          maxDepth: opts.maxDepth,
+          onProgress: opts.onProgress,
+          signal: this.controller.signal
+        });
+        await this.storage.setMeta("root", rootPubkey);
+        await this.storage.setMeta("lastCrawl", Date.now());
+        await this.storage.setMeta("maxDepth", (_a = opts.maxDepth) != null ? _a : DEFAULT_MAX_HOPS2);
+        await this.storage.setMeta("version", STORAGE_VERSION);
+        this.graph.invalidateCache();
+        this.notify();
+        return result;
+      } finally {
+        this.inFlight = null;
+        this.crawler = null;
+        this.controller = null;
+      }
+    })();
+    this.inFlight = run;
+    return run;
+  }
+  /** Distance info from the crawled root, or `null` if unreached/unknown. */
+  getDistance(pubkey) {
+    if (!this.root) return null;
+    return this.graph.getDistance(this.root, pubkey);
+  }
+  /** Trust score 0..1 via {@link calculateScore}. */
+  getScore(pubkey) {
+    const info = this.getDistance(pubkey);
+    return calculateScore(info ? info.hops : null, info ? info.paths : null, this.scoring);
+  }
+  /** Whether `pubkey` is within `maxHops` of the root. */
+  isInWoT(pubkey, maxHops = DEFAULT_MAX_HOPS2) {
+    const info = this.getDistance(pubkey);
+    return info !== null && info.hops <= maxHops;
+  }
+  /** Trusted subset of `pubkeys`, sorted by score descending. */
+  filterByWoT(pubkeys, opts) {
+    var _a;
+    const maxHops = (_a = opts == null ? void 0 : opts.maxHops) != null ? _a : DEFAULT_MAX_HOPS2;
+    const scored = [];
+    for (const pubkey of pubkeys) {
+      const info = this.getDistance(pubkey);
+      if (info !== null && info.hops <= maxHops) {
+        scored.push({ pubkey, score: calculateScore(info.hops, info.paths, this.scoring) });
+      }
+    }
+    scored.sort((a, b) => b.score - a.score);
+    return scored.map((s) => s.pubkey);
+  }
+  /** Follow list of `pubkey` as hex strings. */
+  getFollows(pubkey) {
+    return this.graph.getFollows(pubkey);
+  }
+  /** Aggregate stats + crawl meta. */
+  stats() {
+    const s = this.storage.stats();
+    const meta = this.storage.getGraphMeta();
+    return {
+      nodes: s.nodes,
+      edges: s.edges,
+      root: meta.root,
+      lastCrawl: meta.lastCrawl,
+      maxDepth: meta.maxDepth
+    };
+  }
+  /** True if the last crawl is older than `ttlMs` (or never happened). */
+  isStale(ttlMs) {
+    const last = this.storage.getGraphMeta().lastCrawl;
+    if (last === null) return true;
+    return Date.now() - last > ttlMs;
+  }
+  /** Wipe this namespace. */
+  async clear() {
+    await this.storage.clear();
+    this.root = null;
+    this.graph.invalidateCache();
+    this.notify();
+  }
+  /** Abort an in-flight crawl. Partial data stays usable. */
+  stop() {
+    var _a, _b;
+    (_a = this.controller) == null ? void 0 : _a.abort();
+    (_b = this.crawler) == null ? void 0 : _b.stop();
+  }
+  /** Adapter for `@nostr-wot/wot`'s `WoT` class. */
+  asWoTSource() {
+    return createWoTSource(this);
+  }
+  /** The root pubkey the graph is currently answering queries from. */
+  getRoot() {
+    return this.root;
+  }
+  /** Subscribe to graph changes (crawl / load / clear). Returns an unsubscribe. */
+  onChange(cb) {
+    this.listeners.add(cb);
+    return () => this.listeners.delete(cb);
+  }
+  /** Release the pool/storage this instance owns. */
+  destroy() {
+    this.storage.close();
+    if (this.ownPool) {
+      this.ownPool.destroy();
+      this.ownPool = null;
+    }
+  }
+  notify() {
+    for (const cb of this.listeners) cb();
+  }
+  resolvePool() {
+    if (this.pool) return this.pool;
+    if (this.relays.length === 0) throw new CrawlError("no relays connected");
+    if (this.websocketImplementation) {
+      pool.useWebSocketImplementation(this.websocketImplementation);
+    }
+    const rp = new relay.RelayPool({ urls: this.relays });
+    rp.ensurePool(() => new nostrTools.SimplePool());
+    this.ownPool = rp;
+    this.pool = rp;
+    return this.pool;
+  }
+};
+function mergeScoring(overrides) {
+  var _a;
+  if (!overrides) return { ...DEFAULT_SCORING };
+  return {
+    distanceWeights: { ...DEFAULT_SCORING.distanceWeights, ...overrides.distanceWeights },
+    pathBonus: { ...DEFAULT_SCORING.pathBonus, ...overrides.pathBonus },
+    maxPathBonus: (_a = overrides.maxPathBonus) != null ? _a : DEFAULT_SCORING.maxPathBonus
+  };
+}
+var WotGraphContext = react.createContext(null);
+function WotGraphProvider({ children, ...options }) {
+  const [ready, setReady] = react.useState(false);
+  const [crawling, setCrawling] = react.useState(false);
+  const [version, setVersion] = react.useState(0);
+  const graph = react.useMemo(() => new WotGraph(options), []);
+  react.useEffect(() => {
+    let mounted = true;
+    const unsub = graph.onChange(() => {
+      if (mounted) setVersion((v) => v + 1);
+    });
+    graph.load().catch(() => {
+    }).finally(() => {
+      if (mounted) setReady(true);
+    });
+    return () => {
+      mounted = false;
+      unsub();
+      graph.stop();
+      graph.destroy();
+    };
+  }, []);
+  const value = react.useMemo(
+    () => ({ graph, ready, crawling, setCrawling, version }),
+    [graph, ready, crawling, version]
+  );
+  return /* @__PURE__ */ jsxRuntime.jsx(WotGraphContext.Provider, { value, children });
+}
+function useWotGraphContext() {
+  const ctx = react.useContext(WotGraphContext);
+  if (!ctx) throw new Error("useWotGraph must be used within a WotGraphProvider");
+  return ctx;
+}
+function useWotGraph() {
+  const { graph, ready, crawling } = useWotGraphContext();
+  return { graph, ready, crawling };
+}
+function useDistance(pubkey) {
+  const { graph, version } = useWotGraphContext();
+  return react.useMemo(
+    () => pubkey ? graph.getDistance(pubkey) : null,
+    // version participates so queries refresh after a crawl.
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    [graph, pubkey, version]
+  );
+}
+function useCrawl() {
+  const { graph, crawling, setCrawling } = useWotGraphContext();
+  const [progress, setProgress] = react.useState(null);
+  const [error, setError] = react.useState(null);
+  const mounted = react.useRef(true);
+  react.useEffect(() => {
+    mounted.current = true;
+    return () => {
+      mounted.current = false;
+    };
+  }, []);
+  const crawl = react.useCallback(
+    async (rootPubkey, opts) => {
+      setError(null);
+      setCrawling(true);
+      try {
+        const result = await graph.crawl(rootPubkey, {
+          ...opts,
+          onProgress: (p) => {
+            var _a;
+            if (mounted.current) setProgress(p);
+            (_a = opts == null ? void 0 : opts.onProgress) == null ? void 0 : _a.call(opts, p);
+          }
+        });
+        return result;
+      } catch (err) {
+        const e = err instanceof Error ? err : new Error(String(err));
+        if (mounted.current) setError(e);
+        return null;
+      } finally {
+        if (mounted.current) setCrawling(false);
+      }
+    },
+    [graph, setCrawling]
+  );
+  const stop = react.useCallback(() => graph.stop(), [graph]);
+  return { crawl, stop, progress, crawling, error };
+}
+
+exports.WotGraph = WotGraph;
+exports.WotGraphProvider = WotGraphProvider;
+exports.useCrawl = useCrawl;
+exports.useDistance = useDistance;
+exports.useWotGraph = useWotGraph;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map