@nostr-wot/graph 0.2.0 → 0.3.0

package/dist/react/index.cjs

@@ -10,19 +10,13 @@ var jsxRuntime = require('react/jsx-runtime');
 
 // src/storage.ts
 var DB_PREFIX = "nostr-wot-graph";
-var DB_VERSION = 1;
+var DB_VERSION = 2;
 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;
+var EMPTY_IDS = new Uint32Array(0);
+function newerVersion(candidate, prior) {
+  return candidate.createdAt > prior.createdAt || candidate.createdAt === prior.createdAt && candidate.id < prior.id;
 }
 function decodeFollows(buffer) {
   if (!buffer || buffer.byteLength === 0) return new Uint32Array(0);
@@ -34,6 +28,42 @@ function decodeFollows(buffer) {
   }
   return result;
 }
+function encodeCompactFollows(ids) {
+  const sorted = Array.from(new Set(Array.from(ids))).sort((a, b) => a - b);
+  const bytes = [];
+  let prior = 0;
+  for (const id of sorted) {
+    if (!Number.isInteger(id) || id < 0 || id > 4294967295) {
+      throw new RangeError("Follow IDs must be unsigned 32-bit integers");
+    }
+    let delta = id - prior;
+    prior = id;
+    while (delta >= 128) {
+      bytes.push(delta % 128 | 128);
+      delta = Math.floor(delta / 128);
+    }
+    bytes.push(delta);
+  }
+  return Uint8Array.from(bytes).buffer;
+}
+function decodeCompactFollows(buffer) {
+  const values = [];
+  let prior = 0, delta = 0, factor = 1;
+  for (const byte of new Uint8Array(buffer)) {
+    delta += (byte & 127) * factor;
+    if (delta > 4294967295 || factor > 268435456) throw new Error("Invalid follow varint");
+    if (byte & 128) factor *= 128;
+    else {
+      prior += delta;
+      if (prior > 4294967295) throw new Error("Follow id overflow");
+      values.push(prior);
+      delta = 0;
+      factor = 1;
+    }
+  }
+  if (factor !== 1) throw new Error("Truncated follow varint");
+  return Uint32Array.from(values);
+}
 function hasIndexedDB() {
   return typeof indexedDB !== "undefined" && indexedDB !== null;
 }
@@ -42,6 +72,11 @@ var GraphStorage = class {
     this.db = null;
     this.memoryOnly = false;
     this.opened = false;
+    this.opening = null;
+    this.revision = 0;
+    this.edges = 0;
+    this.versions = /* @__PURE__ */ new Map();
+    this.flushing = Promise.resolve();
     // In-memory caches (source of truth for reads/BFS).
     this.pubkeyToId = /* @__PURE__ */ new Map();
     this.idToPubkey = /* @__PURE__ */ new Map();
@@ -59,7 +94,16 @@ var GraphStorage = class {
   }
   /** Open (or create) the namespace DB and hydrate in-memory caches. */
   async open() {
+    if (this.opening) return this.opening;
     if (this.opened) return;
+    this.opening = this.openDatabase();
+    try {
+      await this.opening;
+    } finally {
+      this.opening = null;
+    }
+  }
+  async openDatabase() {
     if (!hasIndexedDB()) {
       this.memoryOnly = true;
       this.opened = true;
@@ -86,8 +130,8 @@ var GraphStorage = class {
         resolve();
       };
     });
-    this.opened = true;
     await this.loadAll();
+    this.opened = true;
   }
   /** Hydrate the in-memory interning + follow maps + meta from the DB. */
   async loadAll() {
@@ -96,26 +140,35 @@ var GraphStorage = class {
     this.graphCache.clear();
     this.metaCache.clear();
     this.nextId = 1;
+    this.versions.clear();
+    this.edges = 0;
+    this.revision++;
     if (this.memoryOnly || !this.db) return;
     const db = this.db;
-    const pubkeys = await this.getAll(db, STORE_PUBKEYS);
+    const tx = db.transaction([STORE_PUBKEYS, STORE_FOLLOWS, STORE_META], "readonly");
+    const [pubkeys, follows, meta] = await Promise.all([
+      this.getAll(tx, STORE_PUBKEYS),
+      this.getAll(tx, STORE_FOLLOWS),
+      this.getAll(tx, STORE_META)
+    ]);
     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));
+      if (record.encoding && record.encoding !== "delta-varint-v1") throw new Error("Unknown follow encoding");
+      const row = record.encoding === "delta-varint-v1" ? decodeCompactFollows(record.follows) : Uint32Array.from(new Set(decodeFollows(record.follows)));
+      this.graphCache.set(record.id, row);
+      this.edges += row.length;
+      if (record.version) this.versions.set(record.id, record.version);
     }
-    const meta = await this.getAll(db, STORE_META);
     for (const record of meta) {
       this.metaCache.set(record.key, record.value);
     }
   }
-  getAll(db, store) {
+  getAll(tx, 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);
@@ -156,21 +209,41 @@ var GraphStorage = class {
   }
   // ── Follows ──
   /** Store `pubkey`'s follow list. Interns everything and updates the cache. */
-  saveFollows(pubkey, follows) {
+  saveFollows(pubkey, follows, version) {
+    var _a;
     const id = this.getOrCreateId(pubkey);
-    const followIds = this.getOrCreateIds(follows);
-    this.graphCache.set(id, new Uint32Array(followIds));
-    this.dirtyFollows.set(id, followIds);
+    const priorVersion = this.versions.get(id);
+    if (version && priorVersion && !newerVersion(version, priorVersion)) return false;
+    const followIds = this.getOrCreateIds([...new Set(follows)]).sort((a, b) => a - b);
+    const prior = this.graphCache.get(id);
+    const changed = !prior || prior.length !== followIds.length || followIds.some((v, i) => prior[i] !== v);
+    if (version) this.versions.set(id, { ...version });
+    else this.versions.delete(id);
+    if (changed) {
+      this.edges += followIds.length - ((_a = prior == null ? void 0 : prior.length) != null ? _a : 0);
+      this.graphCache.set(id, new Uint32Array(followIds));
+      this.revision++;
+    }
+    if (changed || version || priorVersion) this.dirtyFollows.set(id, followIds);
+    return true;
+  }
+  getRevision() {
+    return this.revision;
+  }
+  getFollowVersion(pubkey) {
+    const id = this.getId(pubkey);
+    const version = id === null ? void 0 : this.versions.get(id);
+    return version ? { ...version } : void 0;
   }
   /** 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);
+    return (_a = this.graphCache.get(id)) != null ? _a : EMPTY_IDS;
   }
   /** Follow ids for a pubkey (interned). Empty if unknown. */
   getFollowIds(pubkey) {
     const id = this.getId(pubkey);
-    if (id === null) return new Uint32Array(0);
+    if (id === null) return EMPTY_IDS;
     return this.getFollowIdsSync(id);
   }
   /** Follow list of `pubkey` as hex strings. */
@@ -185,15 +258,28 @@ var GraphStorage = class {
   }
   // ── Meta ──
   async setMeta(key, value) {
-    this.metaCache.set(key, value);
-    if (this.memoryOnly || !this.db) return;
+    await this.setMetaBatch({ [key]: value });
+  }
+  async setMetaBatch(values) {
+    if (this.memoryOnly || !this.db) {
+      for (const [key, value] of Object.entries(values)) this.metaCache.set(key, value);
+      return;
+    }
     const db = this.db;
     await new Promise((resolve, reject) => {
       const tx = db.transaction(STORE_META, "readwrite");
-      tx.objectStore(STORE_META).put({ key, value });
+      for (const [key, value] of Object.entries(values)) tx.objectStore(STORE_META).put({ key, value });
       tx.oncomplete = () => resolve();
-      tx.onerror = () => reject(tx.error);
+      tx.onerror = () => {
+        var _a;
+        return reject((_a = tx.error) != null ? _a : new Error("Graph transaction failed"));
+      };
+      tx.onabort = () => {
+        var _a;
+        return reject((_a = tx.error) != null ? _a : new Error("Metadata write aborted"));
+      };
     });
+    for (const [key, value] of Object.entries(values)) this.metaCache.set(key, value);
   }
   getMeta(key) {
     return this.metaCache.get(key);
@@ -210,16 +296,22 @@ var GraphStorage = class {
   }
   // ── Persistence ──
   /** Flush buffered pubkey + follow writes to IndexedDB. No-op in memory mode. */
-  async flush() {
+  flush() {
+    const run = this.flushing.then(() => this.flushPending());
+    this.flushing = run.catch(() => {
+    });
+    return run;
+  }
+  async flushPending() {
     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 pubkeys = this.dirtyPubkeys.slice();
     const follows = Array.from(this.dirtyFollows.entries());
-    this.dirtyFollows.clear();
+    const versions = new Map(follows.map(([id]) => [id, this.versions.get(id)]));
     if (pubkeys.length === 0 && follows.length === 0) return;
     await new Promise((resolve, reject) => {
       const stores = [];
@@ -233,25 +325,53 @@ var GraphStorage = class {
       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() });
+          store.put({ id, follows: encodeCompactFollows(followIds), encoding: "delta-varint-v1", updated_at: Date.now(), version: versions.get(id) });
         }
       }
       tx.oncomplete = () => resolve();
-      tx.onerror = () => reject(tx.error);
+      tx.onerror = () => {
+        var _a;
+        return reject((_a = tx.error) != null ? _a : new Error("Graph transaction failed"));
+      };
+      tx.onabort = () => {
+        var _a;
+        return reject((_a = tx.error) != null ? _a : new Error("Graph flush aborted"));
+      };
     });
+    this.dirtyPubkeys.splice(0, pubkeys.length);
+    for (const [id, row] of follows) {
+      if (this.dirtyFollows.get(id) === row) this.dirtyFollows.delete(id);
+    }
   }
   // ── Stats / clear ──
   stats() {
-    let edges = 0;
-    for (const follows of this.graphCache.values()) edges += follows.length;
     return {
       nodes: this.graphCache.size,
-      edges,
+      edges: this.edges,
       uniquePubkeys: this.pubkeyToId.size
     };
   }
   /** Wipe this namespace: memory caches + persisted stores. */
   async clear() {
+    await this.flushing;
+    if (!this.memoryOnly && this.db) {
+      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 = () => {
+          var _a;
+          return reject((_a = tx.error) != null ? _a : new Error("Graph transaction failed"));
+        };
+        tx.onabort = () => {
+          var _a;
+          return reject((_a = tx.error) != null ? _a : new Error("Graph clear aborted"));
+        };
+      });
+    }
     this.pubkeyToId.clear();
     this.idToPubkey.clear();
     this.graphCache.clear();
@@ -259,16 +379,9 @@ var GraphStorage = class {
     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);
-    });
+    this.versions.clear();
+    this.edges = 0;
+    this.revision++;
   }
   /** Close the underlying DB connection. */
   close() {
@@ -305,40 +418,35 @@ var LocalGraph = class {
       return;
     }
     const maxId = this.storage.getMaxId();
-    const hops = new Uint8Array(maxId + 1);
-    const paths = new Uint32Array(maxId + 1);
+    const hops = new Uint32Array(maxId + 1);
+    const paths = new Float64Array(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;
-          }
+    const queue = new Uint32Array(maxId + 1);
+    queue[0] = rootId;
+    let length = 1;
+    for (let head = 0; head < length; head++) {
+      const nodeId = queue[head];
+      const distance = hops[nodeId] - 1;
+      if (distance >= maxHops) continue;
+      const hopStored = distance + 2;
+      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;
+          queue[length++] = fid;
         }
+        if (hops[fid] === hopStored) paths[fid] = Math.min(Number.MAX_SAFE_INTEGER, paths[fid] + paths[nodeId]);
       }
-      frontier = nextFrontier;
     }
-    this.cache = { rootId, hops, paths, maxId };
+    this.cache = { rootId, hops, paths, maxId, maxHops, revision: this.storage.getRevision() };
     this.cachedRoot = rootPubkey;
   }
   /** Ensure the cache is built for `root`. */
   ensureCache(root, maxHops) {
-    if (this.cachedRoot !== root || !this.cache) {
+    if (this.cachedRoot !== root || !this.cache || this.cache.maxHops < maxHops || this.cache.revision !== this.storage.getRevision()) {
       this.buildCache(root, maxHops);
     }
   }
@@ -347,13 +455,14 @@ var LocalGraph = class {
    * when unreached / unknown. Self → `{ hops: 0, paths: 1 }`.
    */
   getDistance(root, pubkey, maxHops = DEFAULT_MAX_HOPS) {
+    if (!Number.isSafeInteger(maxHops) || maxHops < 0) throw new RangeError("maxHops must be a non-negative safe integer");
     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;
+    if (h === 0 || h - 1 > maxHops) return null;
     return { hops: h - 1, paths: this.cache.paths[toId] };
   }
   /** Follow list of `pubkey` as hex strings. */
@@ -373,24 +482,32 @@ var DEFAULT_MAX_DEPTH = 2;
 var GraphCrawler = class {
   constructor(options) {
     this.aborted = false;
-    var _a, _b, _c;
+    this.pending = /* @__PURE__ */ new Set();
+    var _a, _b, _c, _d, _e;
+    this.batchSize = (_a = options.batchSize) != null ? _a : 100;
+    for (const [name, value] of Object.entries({ batchSize: this.batchSize, maxConcurrent: (_b = options.maxConcurrent) != null ? _b : 5 })) {
+      if (!Number.isSafeInteger(value) || value < 1) throw new RangeError(`${name} must be a positive safe integer`);
+    }
     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;
+    this.baseDelayMs = (_c = options.baseDelayMs) != null ? _c : 50;
+    this.maxConcurrent = (_d = options.maxConcurrent) != null ? _d : 5;
+    this.requestTimeoutMs = (_e = options.requestTimeoutMs) != null ? _e : 1e4;
   }
   /** Abort an in-flight crawl. */
   stop() {
     this.aborted = true;
+    for (const finish of this.pending) finish();
   }
   async crawl(rootPubkey, opts = {}) {
-    var _a;
+    var _a, _b;
     if (this.relays.length === 0) {
       throw new CrawlError("no relays connected");
     }
-    const maxDepth = (_a = opts.maxDepth) != null ? _a : DEFAULT_MAX_DEPTH;
+    const maxDepth = opts.maxHops === void 0 ? (_a = opts.maxDepth) != null ? _a : DEFAULT_MAX_DEPTH : opts.maxHops - 1;
+    const bound = (_b = opts.maxHops) != null ? _b : maxDepth;
+    if (!Number.isSafeInteger(bound) || bound < 0) throw new RangeError("crawl depth must be a non-negative safe integer");
     const start = Date.now();
     this.aborted = false;
     const signal = opts.signal;
@@ -413,27 +530,32 @@ var GraphCrawler = class {
           break;
         }
         const nextSet = /* @__PURE__ */ new Set();
-        await this.mapLimited(currentLevel, async (pubkey) => {
-          var _a2;
-          if (this.aborted) return;
-          const follows = await this.fetchNewest(pubkey);
+        const batches = [];
+        for (let i = 0; i < currentLevel.length; i += this.batchSize) batches.push(currentLevel.slice(i, i + this.batchSize));
+        await this.mapLimited(batches, async (authors) => {
+          var _a2, _b2;
+          const events = await this.fetchNewest(authors);
           if (this.aborted) return;
-          if (follows === null) {
-            failed.add(pubkey);
-          } else {
-            fetched.add(pubkey);
-            reachedDepth = Math.max(reachedDepth, depth);
-            this.storage.saveFollows(pubkey, follows);
+          for (const pubkey of authors) {
+            const event = events.get(pubkey);
+            if (!event) failed.add(pubkey);
+            else {
+              fetched.add(pubkey);
+              reachedDepth = Math.max(reachedDepth, depth);
+              const follows = (event.tags || []).filter((tag) => tag[0] === "p" && typeof tag[1] === "string" && tag[1]).map((tag) => tag[1]);
+              this.storage.saveFollows(pubkey, follows, { createdAt: event.created_at, id: String((_a2 = event.id) != null ? _a2 : "") });
+            }
             if (depth < maxDepth) {
-              for (const f of follows) {
-                if (!seen.has(f)) {
-                  seen.add(f);
-                  nextSet.add(f);
+              for (const follow of this.storage.getFollows(pubkey)) {
+                if (!seen.has(follow)) {
+                  seen.add(follow);
+                  nextSet.add(follow);
                 }
               }
             }
+            (_b2 = opts.onProgress) == null ? void 0 : _b2.call(opts, { depth, fetched: fetched.size, queued: nextSet.size });
+            if (this.aborted) break;
           }
-          (_a2 = opts.onProgress) == null ? void 0 : _a2.call(opts, { depth, fetched: fetched.size, queued: nextSet.size });
         });
         if (this.aborted) {
           stoppedEarly = true;
@@ -456,43 +578,44 @@ var GraphCrawler = class {
     };
   }
   /**
-   * Fetch a single pubkey's newest kind:3 follow list across relays.
-   * Resolves to the follow pubkeys, or `null` if no event arrived.
+   * Fetch one author batch, retaining the deterministic newest kind:3 per author.
+   * No global limit: a prolific author must not displace another author's list.
    */
-  fetchNewest(pubkey) {
-    return new Promise((resolve) => {
-      let newestAt = 0;
-      let follows = null;
+  fetchNewest(authors) {
+    return new Promise((resolve, reject) => {
+      const newest = /* @__PURE__ */ new Map();
+      const allowed = new Set(authors);
       let settled = false;
       let sub = null;
       const finish = () => {
         if (settled) return;
         settled = true;
         clearTimeout(timer);
+        this.pending.delete(finish);
         try {
           sub == null ? void 0 : sub.close();
         } catch (e) {
         }
-        resolve(follows);
+        resolve(newest);
       };
       const timer = setTimeout(finish, this.requestTimeoutMs);
-      sub = this.pool.subscribe(
-        { kinds: [3], authors: [pubkey], limit: 1 },
-        {
+      this.pending.add(finish);
+      try {
+        sub = this.pool.subscribe({ kinds: [3], authors }, {
           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]);
-            }
+            var _a, _b;
+            if (settled || !ev || ev.kind !== 3 || typeof ev.pubkey !== "string" || !allowed.has(ev.pubkey) || !Number.isSafeInteger(ev.created_at) || ev.created_at < 0 || ev.created_at > Date.now() / 1e3 + 60) return;
+            const prior = newest.get(ev.pubkey);
+            if (!prior || newerVersion({ createdAt: ev.created_at, id: String((_a = ev.id) != null ? _a : "") }, { createdAt: prior.created_at, id: String((_b = prior.id) != null ? _b : "") })) newest.set(ev.pubkey, ev);
           },
           onEose: finish
-        }
-      );
-      if (settled) {
-        try {
-          sub == null ? void 0 : sub.close();
-        } catch (e) {
-        }
+        });
+        if (settled) sub.close();
+      } catch (error) {
+        clearTimeout(timer);
+        this.pending.delete(finish);
+        settled = true;
+        reject(error);
       }
     });
   }
@@ -515,7 +638,16 @@ var GraphCrawler = class {
       }
     };
     const lanes = Math.min(this.maxConcurrent, Math.max(1, items.length));
-    await Promise.all(Array.from({ length: lanes }, () => runNext()));
+    const outcomes = await Promise.allSettled(Array.from({ length: lanes }, async () => {
+      try {
+        await runNext();
+      } catch (error) {
+        this.stop();
+        throw error;
+      }
+    }));
+    const failure = outcomes.find((outcome) => outcome.status === "rejected");
+    if (failure) throw failure.reason;
   }
 };
 
@@ -564,7 +696,7 @@ function createWoTSource(graph) {
 
 // src/wot-graph.ts
 var DEFAULT_MAX_HOPS2 = 2;
-var STORAGE_VERSION = 1;
+var STORAGE_VERSION = 2;
 var WotGraph = class {
   constructor(options) {
     this.ownPool = null;
@@ -595,46 +727,53 @@ var WotGraph = class {
    */
   crawl(rootPubkey, opts = {}) {
     if (this.inFlight) return this.inFlight;
-    this.controller = new AbortController();
+    const controller = new AbortController();
+    this.controller = controller;
+    const onAbort = () => controller.abort();
     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 });
+      if (opts.signal.aborted) controller.abort();
+      else opts.signal.addEventListener("abort", onAbort, { once: true });
     }
     this.root = rootPubkey;
     const run = (async () => {
-      var _a;
+      var _a, _b;
       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,
+          maxHops: opts.maxHops,
           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();
+        await this.storage.setMetaBatch({
+          root: rootPubkey,
+          lastCrawl: result.stoppedEarly ? null : Date.now(),
+          maxDepth: opts.maxHops === void 0 ? (_a = opts.maxDepth) != null ? _a : DEFAULT_MAX_HOPS2 : Math.max(0, opts.maxHops - 1),
+          version: STORAGE_VERSION
+        });
         return result;
       } finally {
+        (_b = opts.signal) == null ? void 0 : _b.removeEventListener("abort", onAbort);
+        this.graph.invalidateCache();
         this.inFlight = null;
         this.crawler = null;
         this.controller = null;
+        this.notify();
       }
     })();
     this.inFlight = run;
     return run;
   }
   /** Distance info from the crawled root, or `null` if unreached/unknown. */
-  getDistance(pubkey) {
+  getDistance(pubkey, maxHops = 6) {
     if (!this.root) return null;
-    return this.graph.getDistance(this.root, pubkey);
+    return this.graph.getDistance(this.root, pubkey, maxHops);
+  }
+  /** Batch distances; all lookups share one numeric traversal. */
+  getDistances(pubkeys, maxHops = 6) {
+    return new Map(pubkeys.map((pubkey) => [pubkey, this.getDistance(pubkey, maxHops)]));
   }
   /** Trust score 0..1 via {@link calculateScore}. */
   getScore(pubkey) {
@@ -643,7 +782,7 @@ var WotGraph = class {
   }
   /** Whether `pubkey` is within `maxHops` of the root. */
   isInWoT(pubkey, maxHops = DEFAULT_MAX_HOPS2) {
-    const info = this.getDistance(pubkey);
+    const info = this.getDistance(pubkey, maxHops);
     return info !== null && info.hops <= maxHops;
   }
   /** Trusted subset of `pubkeys`, sorted by score descending. */
@@ -652,7 +791,7 @@ var WotGraph = class {
     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);
+      const info = this.getDistance(pubkey, maxHops);
       if (info !== null && info.hops <= maxHops) {
         scored.push({ pubkey, score: calculateScore(info.hops, info.paths, this.scoring) });
       }
@@ -684,6 +823,11 @@ var WotGraph = class {
   }
   /** Wipe this namespace. */
   async clear() {
+    var _a;
+    this.stop();
+    await ((_a = this.inFlight) == null ? void 0 : _a.catch(() => {
+    }));
+    await this.storage.open();
     await this.storage.clear();
     this.root = null;
     this.graph.invalidateCache();
@@ -710,10 +854,13 @@ var WotGraph = class {
   }
   /** Release the pool/storage this instance owns. */
   destroy() {
-    this.storage.close();
+    this.stop();
+    if (this.inFlight) void this.inFlight.then(() => this.storage.close(), () => this.storage.close());
+    else this.storage.close();
     if (this.ownPool) {
       this.ownPool.destroy();
       this.ownPool = null;
+      this.pool = null;
     }
   }
   notify() {