@gmickel/gno 2.10.1 → 2.12.0

package/src/store/sqlite/adapter.ts

@@ -103,8 +103,10 @@ import type {
   SavedCapsuleReverificationState,
   SavedCapsuleVerificationExpectation,
   SavedCapsuleVerificationRecord,
+  StaleCollection,
   StorePort,
   StoreResult,
+  SyncCollectionsOptions,
   TagCount,
   TagRow,
   TagSource,
@@ -585,6 +587,27 @@ function resolveBusyTimeoutMs(busyTimeoutMs?: number): number {
   return busyTimeoutMs;
 }
 
+/** The index holds collections the config omits; the message names them. */
+export class StaleCollectionsError extends Error {}
+
+/** Names the collections a config omits and how to resolve it. */
+export function staleCollectionsMessage(
+  stale: readonly StaleCollection[]
+): string {
+  const names = stale
+    .map(
+      (c) =>
+        `${c.name} (${c.documents} ${c.documents === 1 ? "document" : "documents"})`
+    )
+    .join(", ");
+  return (
+    `This index holds collections the config does not list: ${names}. ` +
+    "Nothing was changed. Add them back to the config, open a separate index " +
+    '(--index <name>, or dbPath in the SDK), or run "gno cleanup" with this ' +
+    "config to delete their index data."
+  );
+}
+
 export class SqliteAdapter implements StorePort, SqliteDbProvider {
   private db: Database | null = null;
   private dbPath = "";
@@ -898,24 +921,36 @@ export class SqliteAdapter implements StorePort, SqliteDbProvider {
   // Config Sync
   // ─────────────────────────────────────────────────────────────────────────
 
-  async syncCollections(collections: Collection[]): Promise<StoreResult<void>> {
+  async syncCollections(
+    collections: Collection[],
+    options: SyncCollectionsOptions = {}
+  ): Promise<StoreResult<void>> {
+    let stale: StaleCollection[] = [];
     try {
       const db = this.ensureOpen();
 
       const transaction = db.transaction(() => {
-        // Get existing collection names
-        const existing = new Set(
-          db
-            .query<{ name: string }, []>("SELECT name FROM collections")
-            .all()
-            .map((r) => r.name)
-        );
-
-        const incoming = new Set(collections.map((c) => c.name));
-
-        // Delete removed collections
-        for (const name of existing) {
-          if (!incoming.has(name)) {
+        // Opening an index with a config never deletes indexed collections
+        // that config omits (their documents follow by cascade): a different
+        // config on the same index would wipe it. Only explicit removals do.
+        const { remove } = options;
+        const removed = new Set(remove === "stale" ? [] : remove);
+        const unlisted = this.queryStaleCollections(
+          db,
+          collections.map((c) => c.name)
+        ).filter((c) => remove !== "stale" && !removed.has(c.name));
+        // Unlisted collections without documents stay too; they only block
+        // the sync when they hold indexed documents.
+        stale = unlisted.filter((c) => c.documents > 0);
+        if (stale.length > 0 && !options.keepStale) {
+          throw new StaleCollectionsError();
+        }
+        const keep = new Set(unlisted.map((c) => c.name));
+        for (const { name } of this.queryStaleCollections(
+          db,
+          collections.map((c) => c.name)
+        )) {
+          if (!keep.has(name)) {
             db.run("DELETE FROM collections WHERE name = ?", [name]);
           }
         }
@@ -985,6 +1020,9 @@ export class SqliteAdapter implements StorePort, SqliteDbProvider {
       transaction.immediate();
       return ok(undefined);
     } catch (cause) {
+      if (cause instanceof StaleCollectionsError) {
+        return err("STALE_COLLECTIONS", staleCollectionsMessage(stale));
+      }
       return err(
         "QUERY_FAILED",
         cause instanceof Error ? cause.message : "Failed to sync collections",
@@ -993,6 +1031,55 @@ export class SqliteAdapter implements StorePort, SqliteDbProvider {
     }
   }
 
+  async listStaleCollections(
+    configured: readonly string[]
+  ): Promise<StoreResult<StaleCollection[]>> {
+    try {
+      return ok(this.queryStaleCollections(this.ensureOpen(), configured));
+    } catch (cause) {
+      return err(
+        "QUERY_FAILED",
+        cause instanceof Error ? cause.message : "Failed to list collections",
+        cause
+      );
+    }
+  }
+
+  /**
+   * Indexed collections `configured` omits, checked cheaply on each read of a
+   * long-lived client: another client may add a collection after it opened.
+   */
+  staleIndexedCollections(configured: readonly string[]): StaleCollection[] {
+    const db = this.ensureOpen();
+    const listed = new Set(configured);
+    const indexed = db
+      .query<{ name: string }, []>(
+        `SELECT c.name AS name FROM collections c
+         WHERE EXISTS (SELECT 1 FROM documents d WHERE d.collection = c.name)`
+      )
+      .all();
+    return indexed.some(({ name }) => !listed.has(name))
+      ? this.queryStaleCollections(db, configured).filter(
+          (c) => c.documents > 0
+        )
+      : [];
+  }
+
+  private queryStaleCollections(
+    db: Database,
+    configured: readonly string[]
+  ): StaleCollection[] {
+    const listed = new Set(configured);
+    return db
+      .query<StaleCollection, []>(
+        `SELECT c.name AS name,
+           (SELECT COUNT(*) FROM documents d WHERE d.collection = c.name) AS documents
+         FROM collections c ORDER BY c.name`
+      )
+      .all()
+      .filter((c) => !listed.has(c.name));
+  }
+
   async upsertCollections(
     collections: Collection[]
   ): Promise<StoreResult<void>> {
@@ -3119,6 +3206,64 @@ export class SqliteAdapter implements StorePort, SqliteDbProvider {
     }
   }
 
+  async getChunkTermPresence(
+    mirrorHashes: string[],
+    terms: string[]
+  ): Promise<
+    StoreResult<{ mirrorHash: string; seq: number; present: boolean[] }[]>
+  > {
+    try {
+      const uniqueHashes = uniqueNonEmptyValues(mirrorHashes);
+      if (uniqueHashes.length === 0 || terms.length === 0) return ok([]);
+      const db = this.ensureOpen();
+      // SQLite lower() folds ASCII only, so a non-ASCII term is also looked
+      // up in its upper-case and capitalized spellings (ÜBERBLICK, Überblick).
+      const spellings = terms.flatMap((term) => [
+        term,
+        term.toUpperCase(),
+        `${term.charAt(0).toUpperCase()}${term.slice(1)}`,
+      ]);
+      const columns = terms
+        .map(
+          () =>
+            "(instr(lower(text), ?) > 0 OR instr(text, ?) > 0 OR instr(text, ?) > 0)"
+        )
+        .join(", ");
+      const batchSize = Math.max(
+        1,
+        SQLITE_SAFE_PARAMETER_BATCH_SIZE - spellings.length
+      );
+      const rows: { mirrorHash: string; seq: number; present: boolean[] }[] =
+        [];
+      for (let i = 0; i < uniqueHashes.length; i += batchSize) {
+        const batch = uniqueHashes.slice(i, i + batchSize);
+        const values = db
+          .query<unknown, string[]>(
+            `SELECT mirror_hash, seq, ${columns} FROM content_chunks
+             WHERE mirror_hash IN (${batch.map(() => "?").join(",")})
+             ORDER BY mirror_hash, seq`
+          )
+          .values(...spellings, ...batch) as unknown[][];
+        for (const [mirrorHash, seq, ...present] of values) {
+          rows.push({
+            mirrorHash: String(mirrorHash),
+            seq: Number(seq),
+            present: present.map((flag) => flag === 1),
+          });
+        }
+      }
+      return ok(rows);
+    } catch (cause) {
+      return err(
+        "QUERY_FAILED",
+        cause instanceof Error
+          ? cause.message
+          : "Failed to read chunk term presence",
+        cause
+      );
+    }
+  }
+
   // ─────────────────────────────────────────────────────────────────────────
   // FTS Search
   // ─────────────────────────────────────────────────────────────────────────
@@ -3143,7 +3288,6 @@ export class SqliteAdapter implements StorePort, SqliteDbProvider {
         WITH fts_matches AS (
           SELECT
             rowid,
-            ${options.snippet ? "snippet(documents_fts, 2, '<mark>', '</mark>', '...', 32) as snippet," : ""}
             bm25(
               documents_fts,
               ${FTS5_FIELD_WEIGHTS.filepath},
@@ -3163,7 +3307,6 @@ export class SqliteAdapter implements StorePort, SqliteDbProvider {
           d.mirror_hash,
           ${options.chunkLanguage ? "(SELECT min(lc.seq) FROM content_chunks lc WHERE lc.mirror_hash = d.mirror_hash AND lc.language = ?) as seq," : "0 as seq,"}
           fm.score as score,
-          ${options.snippet ? "fm.snippet as snippet," : ""}
           d.docid,
           d.uri,
           d.title,
@@ -3197,7 +3340,6 @@ export class SqliteAdapter implements StorePort, SqliteDbProvider {
         mirror_hash: string;
         seq: number;
         score: number;
-        snippet?: string;
         docid: string;
         uri: string;
         title: string | null;
@@ -3247,7 +3389,6 @@ export class SqliteAdapter implements StorePort, SqliteDbProvider {
           mirrorHash: r.mirror_hash,
           seq: r.seq,
           score: r.score, // Raw bm25() - smaller (more negative) is better
-          snippet: r.snippet,
           docid: r.docid,
           uri: r.uri,
           title: r.title ?? undefined,
@@ -3693,9 +3834,89 @@ export class SqliteAdapter implements StorePort, SqliteDbProvider {
   }
 
   /**
-   * Get tag counts across all active documents.
-   * Optionally filter by collection or tag prefix.
+   * Map each superseded memory fact's URI to the end of its supersession
+   * chain. Input URIs may carry `?index=`; keys are the URIs as given and
+   * successors are canonical (undecorated).
    */
+  async getSupersedingUris(
+    uris: string[]
+  ): Promise<StoreResult<Map<string, string>>> {
+    try {
+      const db = this.ensureOpen();
+      const successorOf = db.query<
+        { uri: string; successor: string },
+        [string]
+      >(`
+        SELECT p.uri AS uri, s.uri AS successor
+        FROM documents p
+        JOIN doc_edges e ON e.dst_doc_id = p.id AND e.edge_type = 'supersedes'
+        JOIN documents s ON s.id = e.src_doc_id AND s.active = 1
+        WHERE p.uri IN (SELECT value FROM json_each(?))
+        ORDER BY s.id
+      `);
+      const canonical = new Map(uris.map((uri) => [uri, stripUriIndex(uri)]));
+      const next = new Map<string, string>();
+      const seen = new Set(canonical.values());
+      let frontier = [...seen];
+      while (frontier.length > 0) {
+        const discovered: string[] = [];
+        for (const row of successorOf.all(JSON.stringify(frontier))) {
+          next.set(row.uri, row.successor);
+          if (!seen.has(row.successor)) {
+            seen.add(row.successor);
+            discovered.push(row.successor);
+          }
+        }
+        frontier = discovered;
+      }
+      const result = new Map<string, string>();
+      for (const [input, uri] of canonical) {
+        const visited = new Set([uri]);
+        let current = next.get(uri);
+        while (current && next.has(current) && !visited.has(current)) {
+          visited.add(current);
+          current = next.get(current);
+        }
+        if (current && current !== uri) result.set(input, current);
+      }
+      return ok(result);
+    } catch (cause) {
+      return err(
+        "QUERY_FAILED",
+        cause instanceof Error ? cause.message : "Failed to read supersession",
+        cause
+      );
+    }
+  }
+
+  async getTypedMetadataDocuments(options?: {
+    collection?: string;
+  }): Promise<StoreResult<{ documents: number; metadata: string[] }>> {
+    try {
+      const db = this.ensureOpen();
+      const scope = options?.collection ? " AND collection = ?" : "";
+      const params = options?.collection ? [options.collection] : [];
+      const documents = db
+        .query<{ count: number }, string[]>(
+          `SELECT count(*) AS count FROM documents WHERE active = 1${scope}`
+        )
+        .get(...params)!.count;
+      const metadata = db
+        .query<{ typed_metadata: string }, string[]>(
+          `SELECT typed_metadata FROM documents WHERE active = 1 AND typed_metadata IS NOT NULL${scope}`
+        )
+        .all(...params)
+        .map((row) => row.typed_metadata);
+      return ok({ documents, metadata });
+    } catch (cause) {
+      return err(
+        "QUERY_FAILED",
+        cause instanceof Error ? cause.message : "Failed to read metadata",
+        cause
+      );
+    }
+  }
+
   async getTagCounts(options?: {
     collection?: string;
     prefix?: string;

package/src/store/types.ts

@@ -68,7 +68,23 @@ export type StoreErrorCode =
   | "VEC_REBUILD_FAILED"
   | "VEC_SYNC_FAILED"
   /** Embedding would build a separate vector partition without confirmation. */
-  | "VECTOR_PARTITION_FORK";
+  | "VECTOR_PARTITION_FORK"
+  /** The index holds indexed collections the opening config does not list. */
+  | "STALE_COLLECTIONS";
+
+/** How a config sync treats collections the config no longer lists. */
+export interface SyncCollectionsOptions {
+  /** Explicitly removed names, or every unlisted collection ("stale"). */
+  remove?: readonly string[] | "stale";
+  /** Leave unlisted collections untouched instead of failing. */
+  keepStale?: boolean;
+}
+
+/** A collection in the index that the opening config does not list. */
+export interface StaleCollection {
+  name: string;
+  documents: number;
+}
 
 /** Store error with structured details */
 export interface StoreError {
@@ -738,8 +754,6 @@ export interface FtsSearchOptions extends DocumentEligibilityOptions {
    * so runtime language filtering is not currently implemented.
    */
   language?: string;
-  /** Include snippet with highlights */
-  snippet?: boolean;
   /** Match documents containing ANY positive term instead of ALL of them. */
   anyTerm?: boolean;
   /**
@@ -770,7 +784,6 @@ export interface FtsResult {
   mirrorHash: string;
   seq: number;
   score: number;
-  snippet?: string;
   // Joined from documents table
   docid?: string;
   uri?: string;
@@ -1614,10 +1627,21 @@ export interface StorePort {
   // ─────────────────────────────────────────────────────────────────────────
 
   /**
-   * Sync collections from config to DB.
-   * Adds new, updates existing, removes deleted.
+   * Sync collections from config to DB: adds new and updates existing ones.
+   * A collection in the index but not in `collections` is deleted only when
+   * `options.remove` names it (or is "stale"). One that holds documents
+   * otherwise fails the sync with STALE_COLLECTIONS and changes nothing,
+   * unless `keepStale` leaves it untouched.
    */
-  syncCollections(collections: Collection[]): Promise<StoreResult<void>>;
+  syncCollections(
+    collections: Collection[],
+    options?: SyncCollectionsOptions
+  ): Promise<StoreResult<void>>;
+
+  /** Collections in the index that `configured` does not list, with counts. */
+  listStaleCollections(
+    configured: readonly string[]
+  ): Promise<StoreResult<StaleCollection[]>>;
 
   /**
    * Sync contexts from config to DB.
@@ -2159,6 +2183,20 @@ export interface StorePort {
     keys: { mirrorHash: string; seq: number }[]
   ): Promise<StoreResult<Map<string, ChunkRow[]>>>;
 
+  /**
+   * Optional: for every chunk of the given documents, which of the given
+   * lowercase terms occur in its text (substring match on ASCII-lowercased
+   * text), computed in the database so chunk text is never loaded. Rows are
+   * ordered by mirrorHash, then seq; `present[i]` answers `terms[i]`. Callers
+   * fall back to getChunksBatch when this capability is absent.
+   */
+  getChunkTermPresence?(
+    mirrorHashes: string[],
+    terms: string[]
+  ): Promise<
+    StoreResult<{ mirrorHash: string; seq: number; present: boolean[] }[]>
+  >;
+
   // ─────────────────────────────────────────────────────────────────────────
   // FTS Search
   // ─────────────────────────────────────────────────────────────────────────
@@ -2245,6 +2283,22 @@ export interface StorePort {
     documentIds: number[]
   ): Promise<StoreResult<Map<number, TagRow[]>>>;
 
+  /**
+   * For each URI whose document an active document supersedes, the URI of
+   * its current successor (the end of the supersession chain).
+   */
+  getSupersedingUris?(
+    uris: string[]
+  ): Promise<StoreResult<Map<string, string>>>;
+
+  /**
+   * Indexed typed metadata JSON of active documents, optionally in one
+   * collection, plus the active document count in that scope.
+   */
+  getTypedMetadataDocuments(options?: {
+    collection?: string;
+  }): Promise<StoreResult<{ documents: number; metadata: string[] }>>;
+
   /**
    * Get tag counts across all active documents.
    * Optionally filter by collection or tag prefix.

package/src/store/vector/variant-search.ts

@@ -82,6 +82,32 @@ export function vectorSearchUnavailableMessage(
   }`;
 }
 
+const MAX_CACHED_PROOFS = 100_000;
+const proofCaches = new WeakMap<
+  Database,
+  { marker: string; proofs: Map<string, boolean> }
+>();
+
+/**
+ * Input-hash proofs cached per connection. Any committed write, from this
+ * connection or another, changes the marker and drops the cache, so a cached
+ * proof never outlives the titles and chunk text it was computed from.
+ */
+function provenOwners(db: Database): Map<string, boolean> {
+  const { version, changes } = db
+    .query<{ version: number; changes: number }, []>(
+      "SELECT (SELECT data_version FROM pragma_data_version) AS version, total_changes() AS changes"
+    )
+    .get()!;
+  const marker = `${version}:${changes}`;
+  let cache = proofCaches.get(db);
+  if (cache?.marker !== marker || cache.proofs.size > MAX_CACHED_PROOFS) {
+    cache = { marker, proofs: new Map() };
+    proofCaches.set(db, cache);
+  }
+  return cache.proofs;
+}
+
 /** Null means legacy authority. Once promoted, unavailable provenance fails closed. */
 function searchVectorVariantsInSnapshot(
   db: Database,
@@ -148,14 +174,9 @@ function searchVectorVariantsInSnapshot(
   const tableName = `vec_v1_${partitionId}`;
   if (!db.query("SELECT 1 FROM sqlite_master WHERE name = ?").get(tableName))
     throw new Error("Activated variant index unavailable; run gno embed");
-  if (
-    db
-      .query(
-        `SELECT 1 FROM vector_variants v LEFT JOIN ${tableName} x ON x.variant_id = v.variant_id WHERE v.partition_id = ? AND (x.variant_id IS NULL OR x.embedding != v.embedding) LIMIT 1`
-      )
-      .get(partitionId)
-  )
-    throw new Error("Activated variant index inconsistent; run gno embed");
+  // The vec0 mirror is written in the same transactions as vector_variants and
+  // checked at activation and by `gno vec sync`; ranking below reads only
+  // vector_variants, so the mirror is never trusted here.
   const eligible = buildEligibleDocumentQuery(
     { ...options.eligibility, semanticMetadata: true },
     db
@@ -170,75 +191,92 @@ function searchVectorVariantsInSnapshot(
     conditions.push("o.mirror_hash IN (SELECT value FROM json_each(?))");
     params.push(JSON.stringify(options.allowedMirrorHashes));
   }
-  const bindings = db
-    .query<
-      {
-        document_id: number;
-        seq: number;
-        text: string;
-        title: string | null;
-        input_hash: string;
-      },
-      (string | number)[]
-    >(`
-    SELECT o.document_id, o.seq, c.text, d.title, v.input_hash
-    FROM vector_owners o
-    JOIN (${eligible.sql}) e ON e.id = o.document_id AND e.mirror_hash = o.mirror_hash
-    JOIN documents d ON d.id = o.document_id
-    JOIN content_chunks c ON c.mirror_hash = o.mirror_hash AND c.seq = o.seq
-    JOIN vector_variants v ON v.variant_id = o.variant_id AND v.partition_id = o.partition_id
-    WHERE ${conditions.join(" AND ")}
-  `)
-    .all(...eligible.params, ...params);
-  const proven = bindings
-    .filter(
-      (row) =>
-        row.input_hash ===
-        embeddingInputHash(
-          formatDocForEmbedding(row.text, row.title ?? undefined, model)
-        )
-    )
-    .map((row) => `${row.document_id}:${row.seq}`);
-  // Both owner eligibility and formatted-input validation precede ranking/LIMIT.
-  const rows = db
-    .query<
-      {
-        mirrorHash: string;
-        seq: number;
-        distance: number;
-        documentIds: string;
-      },
-      (Uint8Array | string | number)[]
-    >(`
-    SELECT o.mirror_hash AS mirrorHash, o.seq, vec_distance_cosine(v.embedding, ?) AS distance,
-      json_group_array(o.document_id) AS documentIds
-    FROM vector_owners o
-    JOIN (${eligible.sql}) e ON e.id = o.document_id AND e.mirror_hash = o.mirror_hash
-    JOIN documents d ON d.id = o.document_id
-    JOIN content_chunks c ON c.mirror_hash = o.mirror_hash AND c.seq = o.seq
-    JOIN vector_variants v ON v.variant_id = o.variant_id AND v.partition_id = o.partition_id
-    JOIN ${tableName} x ON x.variant_id = v.variant_id AND x.embedding = v.embedding
-    WHERE ${conditions.join(" AND ")}
-      AND (o.document_id || ':' || o.seq) IN (SELECT value FROM json_each(?))
-    GROUP BY v.variant_id, o.mirror_hash, o.seq
-    ORDER BY distance, o.mirror_hash, o.seq, v.variant_id LIMIT ?
-  `)
-    .all(
-      encodeEmbedding(embedding),
+  // Owner eligibility precedes ranking/LIMIT. Grouping before the distance
+  // keeps embedding blobs out of the group sorter.
+  const ranked = db.query<
+    {
+      mirrorHash: string;
+      seq: number;
+      inputHash: string;
+      distance: number;
+      documentIds: string;
+    },
+    (Uint8Array | string | number)[]
+  >(`
+    SELECT g.mirrorHash, g.seq, v.input_hash AS inputHash,
+      vec_distance_cosine(v.embedding, ?) AS distance, g.documentIds
+    FROM (
+      SELECT o.variant_id AS variantId, o.mirror_hash AS mirrorHash, o.seq,
+        json_group_array(o.document_id) AS documentIds
+      FROM vector_owners o
+      JOIN (${eligible.sql}) e ON e.id = o.document_id AND e.mirror_hash = o.mirror_hash
+      JOIN content_chunks c ON c.mirror_hash = o.mirror_hash AND c.seq = o.seq
+      WHERE ${conditions.join(" AND ")}
+      GROUP BY o.variant_id, o.mirror_hash, o.seq
+    ) g
+    JOIN vector_variants v ON v.variant_id = g.variantId AND v.partition_id = ?
+    ORDER BY distance, g.mirrorHash, g.seq, g.variantId LIMIT ?
+  `);
+  const owners = db.query<
+    { id: number; title: string | null; text: string },
+    [string, number, string]
+  >(`
+    SELECT d.id, d.title, c.text FROM documents d
+    JOIN content_chunks c ON c.mirror_hash = ? AND c.seq = ?
+    WHERE d.id IN (SELECT value FROM json_each(?))
+  `);
+  // A vector counts only while it matches its owner's current formatted
+  // input. Proving candidates in rank order and skipping unproven owners
+  // returns exactly what filtering every owner before ranking would.
+  const proofs = provenOwners(db);
+  const queryVector = encodeEmbedding(embedding);
+  let limit = k;
+  let results: VectorSearchResult[] = [];
+  for (;;) {
+    const rows = ranked.all(
+      queryVector,
       ...eligible.params,
       ...params,
-      JSON.stringify(proven),
-      k
+      partitionId,
+      limit
     );
-  return rows
-    .filter(
-      (row) =>
-        options.minScore === undefined || 1 - row.distance >= options.minScore
-    )
-    .map((row) => ({
-      ...row,
-      documentIds: JSON.parse(row.documentIds) as number[],
-    }));
+    results = [];
+    for (const row of rows) {
+      const documentIds = JSON.parse(row.documentIds) as number[];
+      const key = (id: number) =>
+        `${model}\0${id}\0${row.mirrorHash}\0${row.seq}\0${row.inputHash}`;
+      const unknown = documentIds.filter((id) => !proofs.has(key(id)));
+      if (unknown.length > 0) {
+        for (const owner of owners.all(
+          row.mirrorHash,
+          row.seq,
+          JSON.stringify(unknown)
+        )) {
+          proofs.set(
+            key(owner.id),
+            embeddingInputHash(
+              formatDocForEmbedding(owner.text, owner.title ?? undefined, model)
+            ) === row.inputHash
+          );
+        }
+      }
+      const proven = documentIds.filter((id) => proofs.get(key(id)));
+      if (proven.length === 0) continue;
+      results.push({
+        mirrorHash: row.mirrorHash,
+        seq: row.seq,
+        distance: row.distance,
+        documentIds: proven,
+      });
+      if (results.length === k) break;
+    }
+    if (results.length === k || rows.length < limit) break;
+    limit *= 4;
+  }
+  return results.filter(
+    (row) =>
+      options.minScore === undefined || 1 - row.distance >= options.minScore
+  );
 }
 
 /** Keep eligibility, provenance validation and ranking on one SQLite snapshot. */

package/browser-extension/artifacts/gno-browser-clipper-v2.10.1.zip.sha256

@@ -1 +0,0 @@
-e42897b28d0fc0fca7d1d7aca6ab016255cc3b5bf20d38bcac51535499eb7f25  gno-browser-clipper-v2.10.1.zip