brainbank 0.3.1 → 0.5.0

package/dist/{chunk-2BEWWQL2.js → chunk-MY36UPPQ.js}

@@ -2,15 +2,19 @@ import {
   isIgnoredDir,
   isIgnoredFile,
   isSupported
-} from "./chunk-MGIFEPYZ.js";
+} from "./chunk-DDECTPRM.js";
+import {
+  rerank
+} from "./chunk-YRGUIRN5.js";
 import {
   normalizeBM25,
   reciprocalRankFusion,
   sanitizeFTS
-} from "./chunk-E6WQM4DN.js";
+} from "./chunk-YOLKSYWK.js";
 import {
-  cosineSimilarity
-} from "./chunk-QNHBCOKB.js";
+  cosineSimilarity,
+  vecToBuffer
+} from "./chunk-U2Q2XGPZ.js";
 import {
   __name
 } from "./chunk-7QVYU63E.js";
@@ -81,7 +85,7 @@ var Collection = class {
     const id = Number(result.lastInsertRowid);
     this._db.prepare(
       "INSERT INTO kv_vectors (data_id, embedding) VALUES (?, ?)"
-    ).run(id, Buffer.from(vec.buffer));
+    ).run(id, vecToBuffer(vec));
     this._hnsw.add(vec, id);
     this._vecs.set(id, vec);
     return id;
@@ -110,7 +114,7 @@ var Collection = class {
           expiresAt
         );
         const id = Number(result.lastInsertRowid);
-        insertVec.run(id, Buffer.from(vecs[i].buffer));
+        insertVec.run(id, vecToBuffer(vecs[i]));
         ids.push(id);
       }
     });
@@ -146,12 +150,15 @@ var Collection = class {
       if (results.length >= k) break;
     }
     if (this._reranker && results.length > 1) {
-      const documents = results.map((r) => r.content);
-      const scores = await this._reranker.rank(query, documents);
-      const blended = results.map((r, i) => ({
-        ...r,
-        score: 0.6 * (r.score ?? 0) + 0.4 * (scores[i] ?? 0)
+      const asSearchResults = results.map((r) => ({
+        type: "collection",
+        score: r.score ?? 0,
+        content: r.content,
+        metadata: { id: r.id }
       }));
+      const reranked = await rerank(query, asSearchResults, this._reranker);
+      const rerankedById = new Map(reranked.map((r) => [r.metadata?.id, r.score]));
+      const blended = results.map((r) => ({ ...r, score: rerankedById.get(r.id) ?? r.score ?? 0 }));
       return this._filterByTags(
         blended.sort((a, b) => (b.score ?? 0) - (a.score ?? 0)),
         tags
@@ -216,19 +223,14 @@ var Collection = class {
   }
   // ── Private ──────────────────────────────────────
   _removeById(id) {
-    this._vecs.delete(id);
-    this._hnsw.remove(id);
     this._db.prepare("DELETE FROM kv_data WHERE id = ?").run(id);
+    this._hnsw.remove(id);
+    this._vecs.delete(id);
   }
   async _searchVector(query, k, minScore) {
     if (this._hnsw.size === 0) return [];
     const queryVec = await this._embedding.embed(query);
-    const now = Math.floor(Date.now() / 1e3);
-    const collectionCount = this._db.prepare(
-      "SELECT COUNT(*) as c FROM kv_data WHERE collection = ? AND (expires_at IS NULL OR expires_at > ?)"
-    ).get(this._name, now)?.c ?? 0;
-    const ratio = collectionCount > 0 ? Math.max(3, Math.min(50, Math.ceil(this._hnsw.size / collectionCount))) : 3;
-    const searchK = Math.min(k * ratio, this._hnsw.size);
+    const searchK = Math.min(k * 10, this._hnsw.size);
     const hits = this._hnsw.search(queryVec, searchK);
     const ids = hits.map((h) => h.id);
     if (ids.length === 0) return [];
@@ -308,6 +310,7 @@ function parseDuration(s) {
 __name(parseDuration, "parseDuration");
 
 // src/providers/vector/hnsw-index.ts
+import { existsSync } from "fs";
 var HNSWIndex = class {
   constructor(_dims, _maxElements = 2e6, _M = 16, _efConstruction = 200, _efSearch = 50) {
     this._dims = _dims;
@@ -398,6 +401,38 @@ var HNSWIndex = class {
   get size() {
     return this._ids.size;
   }
+  /**
+   * Save the HNSW graph to disk.
+   * The file can be loaded later with tryLoad() to skip vector-by-vector insertion.
+   */
+  save(path4) {
+    if (!this._index || this._ids.size === 0) return;
+    this._index.writeIndexSync(path4);
+  }
+  /**
+   * Try to load a previously saved HNSW index from disk.
+   * Returns true if loaded successfully, false if stale or missing.
+   * @param path File path to the saved index
+   * @param expectedCount Expected number of vectors (from SQLite) — used to detect staleness
+   */
+  tryLoad(path4, expectedCount) {
+    if (!this._index || !existsSync(path4)) return false;
+    try {
+      this._index.readIndexSync(path4);
+      const loadedCount = this._index.getCurrentCount();
+      if (loadedCount !== expectedCount) {
+        this.reinit();
+        return false;
+      }
+      const ids = this._index.getIdsList();
+      this._ids = new Set(ids);
+      this._index.setEf(this._efSearch);
+      return true;
+    } catch {
+      this.reinit();
+      return false;
+    }
+  }
 };
 
 // src/providers/embeddings/local-embedding.ts
@@ -460,7 +495,7 @@ var LocalEmbedding = class {
       const output = await pipe(batch, { pooling: "mean", normalize: true });
       for (let j = 0; j < batch.length; j++) {
         const start = j * this.dims;
-        results.push(new Float32Array(output.data.buffer, start * 4, this.dims));
+        results.push(output.data.slice(start, start + this.dims));
       }
     }
     return results;
@@ -502,22 +537,6 @@ function searchMMR(index, query, vectorCache, k, lambda = 0.7) {
 }
 __name(searchMMR, "searchMMR");
 
-// src/search/vector/rerank.ts
-async function rerank(query, results, reranker) {
-  const documents = results.map((r) => r.content);
-  const scores = await reranker.rank(query, documents);
-  const blended = results.map((r, i) => {
-    const pos = i + 1;
-    const rrfWeight = pos <= 3 ? 0.75 : pos <= 10 ? 0.6 : 0.4;
-    return {
-      ...r,
-      score: rrfWeight * r.score + (1 - rrfWeight) * (scores[i] ?? 0)
-    };
-  });
-  return blended.sort((a, b) => b.score - a.score);
-}
-__name(rerank, "rerank");
-
 // src/search/vector/vector-search.ts
 var VectorSearch = class {
   static {
@@ -645,6 +664,10 @@ var VectorSearch = class {
 };
 
 // src/search/keyword/keyword-search.ts
+function isFTSError(e) {
+  return e instanceof Error && /fts5|syntax error|parse error/i.test(e.message);
+}
+__name(isFTSError, "isFTSError");
 var KeywordSearch = class {
   constructor(_db) {
     this._db = _db;
@@ -683,7 +706,8 @@ var KeywordSearch = class {
         seenIds.add(r.id);
         results.push(this._toCodeResult(r, normalizeBM25(r.score), "bm25"));
       }
-    } catch {
+    } catch (e) {
+      if (!isFTSError(e)) throw e;
     }
     this._searchCodeByPath(rawQuery, seenIds, results);
   }
@@ -704,7 +728,8 @@ var KeywordSearch = class {
           results.push(this._toCodeResult(r, 0.6, "bm25-path"));
         }
       }
-    } catch {
+    } catch (e) {
+      if (!isFTSError(e)) throw e;
     }
   }
   /** FTS5 search across git commits. */
@@ -738,7 +763,8 @@ var KeywordSearch = class {
           }
         });
       }
-    } catch {
+    } catch (e) {
+      if (!isFTSError(e)) throw e;
     }
   }
   /** FTS5 search across memory patterns. */
@@ -769,7 +795,8 @@ var KeywordSearch = class {
           }
         });
       }
-    } catch {
+    } catch (e) {
+      if (!isFTSError(e)) throw e;
     }
   }
   /** Map a code_chunks row to a CodeResult. */
@@ -1002,6 +1029,9 @@ var IndexerRegistry = class {
   }
 };
 
+// src/core/initializer.ts
+import { dirname as dirname2, join as join2 } from "path";
+
 // src/db/database.ts
 import BetterSqlite3 from "better-sqlite3";
 import * as fs from "fs";
@@ -1484,24 +1514,34 @@ async function reembedTable(db, embedding, table, batchSize, onProgress) {
     `SELECT COUNT(*) as c FROM ${table.textTable}`
   ).get().c;
   if (totalCount === 0) return 0;
-  const insertVec = db.prepare(
-    `INSERT INTO ${table.vectorTable} (${table.fkColumn}, embedding) VALUES (?, ?)`
+  const tempTable = `_reembed_${table.vectorTable}`;
+  db.exec(`DROP TABLE IF EXISTS ${tempTable}`);
+  db.exec(`CREATE TABLE ${tempTable} AS SELECT * FROM ${table.vectorTable} WHERE 0`);
+  const insertTemp = db.prepare(
+    `INSERT INTO ${tempTable} (${table.fkColumn}, embedding) VALUES (?, ?)`
   );
-  db.prepare(`DELETE FROM ${table.vectorTable}`).run();
   let processed = 0;
-  for (let offset = 0; offset < totalCount; offset += batchSize) {
-    const batch = db.prepare(
-      `SELECT * FROM ${table.textTable} LIMIT ? OFFSET ?`
-    ).all(batchSize, offset);
-    const texts = batch.map((r) => table.textBuilder(r));
-    const vectors = await embedding.embedBatch(texts);
+  try {
+    for (let offset = 0; offset < totalCount; offset += batchSize) {
+      const batch = db.prepare(
+        `SELECT * FROM ${table.textTable} LIMIT ? OFFSET ?`
+      ).all(batchSize, offset);
+      const texts = batch.map((r) => table.textBuilder(r));
+      const vectors = await embedding.embedBatch(texts);
+      db.transaction(() => {
+        for (let j = 0; j < batch.length; j++) {
+          insertTemp.run(batch[j][table.idColumn], vecToBuffer(vectors[j]));
+        }
+      });
+      processed += batch.length;
+      onProgress?.(table.name, processed, totalCount);
+    }
     db.transaction(() => {
-      for (let j = 0; j < batch.length; j++) {
-        insertVec.run(batch[j][table.idColumn], Buffer.from(vectors[j].buffer));
-      }
+      db.exec(`DELETE FROM ${table.vectorTable}`);
+      db.exec(`INSERT INTO ${table.vectorTable} SELECT * FROM ${tempTable}`);
     });
-    processed += batch.length;
-    onProgress?.(table.name, processed, totalCount);
+  } finally {
+    db.exec(`DROP TABLE IF EXISTS ${tempTable}`);
   }
   return processed;
 }
@@ -1584,12 +1624,19 @@ __name(earlyInit, "earlyInit");
 async function lateInit(early, config, registry, sharedHnsw, kvVecs, getCollection) {
   const { db, embedding, kvHnsw, skipVectorLoad } = early;
   if (!skipVectorLoad) {
-    loadVectors(db, "kv_vectors", "data_id", kvHnsw, kvVecs);
+    const kvIndexPath = hnswPath(config.dbPath, "kv");
+    const kvCount = countRows(db, "kv_vectors");
+    if (kvHnsw.tryLoad(kvIndexPath, kvCount)) {
+      loadVecCache(db, "kv_vectors", "data_id", kvVecs);
+    } else {
+      loadVectors(db, "kv_vectors", "data_id", kvHnsw, kvVecs);
+    }
   }
   const ctx = buildIndexerContext(db, embedding, config, sharedHnsw, skipVectorLoad, getCollection);
   for (const mod of registry.all) {
     await mod.initialize(ctx);
   }
+  saveAllHnsw(config.dbPath, kvHnsw, sharedHnsw);
   return buildSearchLayer(db, embedding, config, registry, sharedHnsw);
 }
 __name(lateInit, "lateInit");
@@ -1607,7 +1654,14 @@ function buildIndexerContext(db, embedding, config, sharedHnsw, skipVectorLoad,
     ).init(), "createHnsw"),
     loadVectors: /* @__PURE__ */ __name((table, idCol, hnsw, cache) => {
       if (skipVectorLoad) return;
-      loadVectors(db, table, idCol, hnsw, cache);
+      const indexName = table.replace("_vectors", "").replace("_chunks", "");
+      const indexPath = hnswPath(config.dbPath, indexName);
+      const rowCount = countRows(db, table);
+      if (hnsw.tryLoad(indexPath, rowCount)) {
+        loadVecCache(db, table, idCol, cache);
+      } else {
+        loadVectors(db, table, idCol, hnsw, cache);
+      }
     }, "loadVectors"),
     getOrCreateSharedHnsw: /* @__PURE__ */ __name(async (type, maxElements) => {
       const existing = sharedHnsw.get(type);
@@ -1649,9 +1703,28 @@ function buildSearchLayer(db, embedding, config, registry, sharedHnsw) {
   return { search, bm25, contextBuilder };
 }
 __name(buildSearchLayer, "buildSearchLayer");
+function hnswPath(dbPath, name) {
+  return join2(dirname2(dbPath), `hnsw-${name}.index`);
+}
+__name(hnswPath, "hnswPath");
+function countRows(db, table) {
+  const row = db.prepare(`SELECT COUNT(*) as c FROM ${table}`).get();
+  return row?.c ?? 0;
+}
+__name(countRows, "countRows");
+function saveAllHnsw(dbPath, kvHnsw, sharedHnsw) {
+  try {
+    kvHnsw.save(hnswPath(dbPath, "kv"));
+    for (const [name, { hnsw }] of sharedHnsw) {
+      hnsw.save(hnswPath(dbPath, name));
+    }
+  } catch {
+  }
+}
+__name(saveAllHnsw, "saveAllHnsw");
 function loadVectors(db, table, idCol, hnsw, cache) {
-  const rows = db.prepare(`SELECT ${idCol}, embedding FROM ${table}`).all();
-  for (const row of rows) {
+  const iter = db.prepare(`SELECT ${idCol}, embedding FROM ${table}`).iterate();
+  for (const row of iter) {
     const vec = new Float32Array(
       row.embedding.buffer.slice(
         row.embedding.byteOffset,
@@ -1663,6 +1736,19 @@ function loadVectors(db, table, idCol, hnsw, cache) {
   }
 }
 __name(loadVectors, "loadVectors");
+function loadVecCache(db, table, idCol, cache) {
+  const iter = db.prepare(`SELECT ${idCol}, embedding FROM ${table}`).iterate();
+  for (const row of iter) {
+    const vec = new Float32Array(
+      row.embedding.buffer.slice(
+        row.embedding.byteOffset,
+        row.embedding.byteOffset + row.embedding.byteLength
+      )
+    );
+    cache.set(row[idCol], vec);
+  }
+}
+__name(loadVecCache, "loadVecCache");
 
 // src/core/search-api.ts
 var SearchAPI = class {
@@ -1735,11 +1821,7 @@ var SearchAPI = class {
   /** Apply reranking if a reranker is configured. */
   async _applyReranking(query, fused) {
     if (!this._d.config.reranker || fused.length <= 1) return fused;
-    const scores = await this._d.config.reranker.rank(query, fused.map((r) => r.content));
-    return fused.map((r, i) => {
-      const w = i < 3 ? 0.75 : i < 10 ? 0.6 : 0.4;
-      return { ...r, score: w * r.score + (1 - w) * (scores[i] ?? 0) };
-    }).sort((a, b) => b.score - a.score);
+    return rerank(query, fused, this._d.config.reranker);
   }
   // ── Keyword ─────────────────────────────────────
   async searchBM25(query, options) {
@@ -1774,6 +1856,20 @@ ${body}`);
   }
 };
 
+// src/indexers/base.ts
+function isIndexable(i) {
+  return typeof i.index === "function";
+}
+__name(isIndexable, "isIndexable");
+function isWatchable(i) {
+  return typeof i.onFileChange === "function" && typeof i.watchPatterns === "function";
+}
+__name(isWatchable, "isWatchable");
+function isCollectionPlugin(i) {
+  return typeof i.addCollection === "function" && typeof i.listCollections === "function";
+}
+__name(isCollectionPlugin, "isCollectionPlugin");
+
 // src/core/index-api.ts
 var IndexAPI = class {
   constructor(_d) {
@@ -1787,6 +1883,7 @@ var IndexAPI = class {
     const result = {};
     if (want.has("code")) {
       for (const mod of this._d.registry.allByType("code")) {
+        if (!isIndexable(mod)) continue;
         const label = mod.name === "code" ? "code" : mod.name;
         options.onProgress?.(label, "Starting...");
         const r = await mod.index({
@@ -1804,6 +1901,7 @@ var IndexAPI = class {
     }
     if (want.has("git")) {
       for (const mod of this._d.registry.allByType("git")) {
+        if (!isIndexable(mod)) continue;
         const label = mod.name === "git" ? "git" : mod.name;
         options.onProgress?.(label, "Starting...");
         const r = await mod.index({
@@ -1819,16 +1917,19 @@ var IndexAPI = class {
       }
     }
     if (want.has("docs") && this._d.registry.has("docs")) {
-      options.onProgress?.("docs", "Starting...");
-      result.docs = await this._d.registry.get("docs").indexCollections({
-        onProgress: /* @__PURE__ */ __name((coll, file, cur, total) => options.onProgress?.("docs", `[${coll}] ${cur}/${total}: ${file}`), "onProgress")
-      });
+      const docsPlugin = this._d.registry.get("docs");
+      if (isCollectionPlugin(docsPlugin)) {
+        options.onProgress?.("docs", "Starting...");
+        result.docs = await docsPlugin.indexCollections({
+          onProgress: /* @__PURE__ */ __name((coll, file, cur, total) => options.onProgress?.("docs", `[${coll}] ${cur}/${total}: ${file}`), "onProgress")
+        });
+      }
     }
     this._d.emit("indexed", result);
     return result;
   }
   async indexCode(options = {}) {
-    const mods = this._d.registry.allByType("code");
+    const mods = this._d.registry.allByType("code").filter(isIndexable);
     if (!mods.length) throw new Error("BrainBank: Indexer 'code' is not loaded. Add .use(code()) to your BrainBank instance.");
     const acc = { indexed: 0, skipped: 0, chunks: 0 };
     for (const mod of mods) {
@@ -1840,7 +1941,7 @@ var IndexAPI = class {
     return acc;
   }
   async indexGit(options = {}) {
-    const mods = this._d.registry.allByType("git");
+    const mods = this._d.registry.allByType("git").filter(isIndexable);
     if (!mods.length) throw new Error("BrainBank: Indexer 'git' is not loaded. Add .use(git()) to your BrainBank instance.");
     const acc = { indexed: 0, skipped: 0 };
     for (const mod of mods) {
@@ -1868,7 +1969,7 @@ function createWatcher(reindexFn, indexers, repoPath, options = {}) {
   let timer = null;
   const customPatterns = [];
   for (const indexer of indexers.values()) {
-    if (indexer.watchPatterns) {
+    if (isWatchable(indexer)) {
       customPatterns.push({ indexer, patterns: indexer.watchPatterns() });
     }
   }
@@ -1895,35 +1996,44 @@ function createWatcher(reindexFn, indexers, repoPath, options = {}) {
     return filePath === pattern;
   }
   __name(matchGlob, "matchGlob");
+  let flushing = false;
   async function flush() {
-    if (pending.size === 0) return;
-    const files = [...pending];
-    pending.clear();
-    let needsReindex = false;
-    for (const filePath of files) {
-      const absPath = path3.resolve(repoPath, filePath);
-      const customIndexer = matchCustomIndexer(absPath);
-      if (customIndexer?.onFileChange) {
-        try {
-          const handled = await customIndexer.onFileChange(absPath, detectEvent(absPath));
-          if (handled) {
-            onIndex?.(filePath, customIndexer.name);
-            continue;
+    if (flushing || pending.size === 0) return;
+    flushing = true;
+    try {
+      const files = [...pending];
+      pending.clear();
+      let needsReindex = false;
+      for (const filePath of files) {
+        const absPath = path3.resolve(repoPath, filePath);
+        const customIndexer = matchCustomIndexer(absPath);
+        if (customIndexer && isWatchable(customIndexer)) {
+          try {
+            const handled = await customIndexer.onFileChange(absPath, detectEvent(absPath));
+            if (handled) {
+              onIndex?.(filePath, customIndexer.name);
+              continue;
+            }
+          } catch (err) {
+            onError?.(err instanceof Error ? err : new Error(String(err)));
           }
+        }
+        if (isSupported(filePath)) {
+          needsReindex = true;
+          onIndex?.(filePath, "code");
+        }
+      }
+      if (needsReindex) {
+        try {
+          await reindexFn();
         } catch (err) {
           onError?.(err instanceof Error ? err : new Error(String(err)));
         }
       }
-      if (isSupported(filePath)) {
-        needsReindex = true;
-        onIndex?.(filePath, "code");
-      }
-    }
-    if (needsReindex) {
-      try {
-        await reindexFn();
-      } catch (err) {
-        onError?.(err instanceof Error ? err : new Error(String(err)));
+    } finally {
+      flushing = false;
+      if (pending.size > 0) {
+        timer = setTimeout(() => flush(), debounceMs);
       }
     }
   }
@@ -2115,6 +2225,12 @@ var BrainBank = class extends EventEmitter {
     this._requireInit("listCollectionNames");
     return this._db.prepare("SELECT DISTINCT collection FROM kv_data ORDER BY collection").all().map((r) => r.collection);
   }
+  /** Delete a collection's data and evict from cache. */
+  deleteCollection(name) {
+    this._requireInit("deleteCollection");
+    this._db.prepare("DELETE FROM kv_data WHERE collection = ?").run(name);
+    this._collections.delete(name);
+  }
   // ── Indexing (delegated to IndexAPI) ─────────────
   async index(options = {}) {
     await this.initialize();
@@ -2134,26 +2250,21 @@ var BrainBank = class extends EventEmitter {
   /** Register a document collection. */
   async addCollection(collection) {
     await this.initialize();
-    this._requireDocs("addCollection");
-    this.indexer("docs").addCollection(collection);
+    this._docsPlugin("addCollection").addCollection(collection);
   }
   /** Remove a collection and all its indexed data. */
   async removeCollection(name) {
     await this.initialize();
-    this._requireDocs("removeCollection");
-    this.indexer("docs").removeCollection(name);
+    this._docsPlugin("removeCollection").removeCollection(name);
   }
   /** List all registered collections. */
   listCollections() {
-    this._requireInit("listCollections");
-    this._requireDocs("listCollections");
-    return this.indexer("docs").listCollections();
+    return this._docsPlugin("listCollections").listCollections();
   }
   /** Index all (or specific) document collections. */
   async indexDocs(options = {}) {
     await this.initialize();
-    this._requireDocs("indexDocs");
-    const results = await this.indexer("docs").indexCollections(options);
+    const results = await this._docsPlugin("indexDocs").indexCollections(options);
     this.emit("docsIndexed", results);
     return results;
   }
@@ -2161,23 +2272,23 @@ var BrainBank = class extends EventEmitter {
   async searchDocs(query, options) {
     await this.initialize();
     if (!this.has("docs")) return [];
-    return this.indexer("docs").search(query, options);
+    return this._docsPlugin("searchDocs").search(query, options);
   }
   // ── Context metadata ─────────────────────────────
   /** Add context description for a collection path. */
   addContext(collection, path4, context) {
-    this._requireDocs("addContext");
-    this.indexer("docs").addContext(collection, path4, context);
+    const docs = this._docsPlugin("addContext");
+    if (docs.addContext) docs.addContext(collection, path4, context);
   }
   /** Remove context for a collection path. */
   removeContext(collection, path4) {
-    this._requireDocs("removeContext");
-    this.indexer("docs").removeContext(collection, path4);
+    const docs = this._docsPlugin("removeContext");
+    if (docs.removeContext) docs.removeContext(collection, path4);
   }
   /** List all context entries. */
   listContexts() {
-    this._requireDocs("listContexts");
-    return this.indexer("docs").listContexts();
+    const docs = this._docsPlugin("listContexts");
+    return docs.listContexts?.() ?? [];
   }
   // ── Search (delegated to SearchAPI) ─────────────
   /**
@@ -2318,9 +2429,13 @@ var BrainBank = class extends EventEmitter {
     if (!this._initialized)
       throw new Error(`BrainBank: Not initialized. Call await brain.initialize() before ${method}().`);
   }
-  _requireDocs(method) {
-    if (!this.has("docs"))
+  /** Get the docs indexer as CollectionPlugin with init + type check. */
+  _docsPlugin(method) {
+    this._requireInit(method);
+    const docs = this._registry.get("docs");
+    if (!docs || !isCollectionPlugin(docs))
       throw new Error(`BrainBank: Docs indexer not loaded. Add .use(docs()) before calling ${method}().`);
+    return docs;
   }
 };
 
@@ -2336,4 +2451,4 @@ export {
   ContextBuilder,
   BrainBank
 };
-//# sourceMappingURL=chunk-2BEWWQL2.js.map
+//# sourceMappingURL=chunk-MY36UPPQ.js.map