@gmickel/gno 2.12.2 → 2.14.0

package/src/store/vector/sqlite-vec.ts

@@ -68,6 +68,37 @@ export function modelTableName(modelUri: string): string {
 // ─────────────────────────────────────────────────────────────────────────────
 
 const indexDatabases = new WeakMap<VectorIndexPort, Database>();
+/** Query-only read connections, mapped to the shared connection that writes. */
+const writerDatabases = new WeakMap<
+  Database,
+  { writer: Database; idle: () => Promise<void> }
+>();
+
+/**
+ * Register `reader` as a query-only connection whose writes go to `writer`;
+ * `idle` resolves once no write transaction is open on `writer`.
+ */
+export function bindReadConnection(
+  reader: Database,
+  writer: Database,
+  idle: () => Promise<void>
+): void {
+  writerDatabases.set(reader, { writer, idle });
+}
+
+/**
+ * The connection to write on for `db`: itself, or for a query-only read
+ * connection, the shared connection behind it. Partition resolution records
+ * runtime callers and migrates legacy partitions, so it runs there.
+ */
+export function writerConnection(db: Database): Database {
+  return writerDatabases.get(db)?.writer ?? db;
+}
+
+/** Wait until the shared connection behind `db` has committed its open batch. */
+export function writerIdle(db: Database): Promise<void> {
+  return writerDatabases.get(db)?.idle() ?? Promise.resolve();
+}
 
 /** Partition resolution needs the database behind a vector index port. */
 export function getVectorIndexDatabase(
@@ -131,9 +162,22 @@ export async function createVectorIndexPort(
     loadError = e instanceof Error ? e.message : String(e);
   }
 
+  // A query-only (read) connection cannot create the table. A missing table
+  // there means no vectors were ever stored for this model: search is empty.
+  const tableExists =
+    db
+      .query<{ found: number }, [string]>(
+        "SELECT 1 AS found FROM sqlite_master WHERE name = ?"
+      )
+      .get(tableName) !== null;
+  const queryOnly =
+    db.query<{ query_only: number }, []>("PRAGMA query_only").get()
+      ?.query_only === 1;
+  const noVectorsYet = searchAvailable && !tableExists && queryOnly;
+
   // Create per-model vec0 table if extension available
   // Graceful degradation: if table creation fails, storage still works
-  if (searchAvailable) {
+  if (searchAvailable && !tableExists && !queryOnly) {
     try {
       db.exec(`
         CREATE VIRTUAL TABLE IF NOT EXISTS ${tableName} USING vec0(
@@ -161,26 +205,32 @@ export async function createVectorIndexPort(
   `);
 
   // Prepared statements for vec0 table (if available)
-  const deleteVecChunkStmt = searchAvailable
-    ? db.prepare(`DELETE FROM ${tableName} WHERE chunk_id = ?`)
-    : null;
-
-  const insertVecStmt = searchAvailable
-    ? db.prepare(`INSERT INTO ${tableName} (chunk_id, embedding) VALUES (?, ?)`)
-    : null;
+  const deleteVecChunkStmt =
+    searchAvailable && !noVectorsYet
+      ? db.prepare(`DELETE FROM ${tableName} WHERE chunk_id = ?`)
+      : null;
+
+  const insertVecStmt =
+    searchAvailable && !noVectorsYet
+      ? db.prepare(
+          `INSERT INTO ${tableName} (chunk_id, embedding) VALUES (?, ?)`
+        )
+      : null;
 
-  const searchStmt = searchAvailable
-    ? db.prepare(`
+  const searchStmt =
+    searchAvailable && !noVectorsYet
+      ? db.prepare(`
         SELECT chunk_id, distance
         FROM ${tableName}
         WHERE embedding MATCH ?
           AND k = ?
       `)
-    : null;
+      : null;
 
-  const deleteVecStmt = searchAvailable
-    ? db.prepare(`DELETE FROM ${tableName} WHERE chunk_id LIKE ? || ':%'`)
-    : null;
+  const deleteVecStmt =
+    searchAvailable && !noVectorsYet
+      ? db.prepare(`DELETE FROM ${tableName} WHERE chunk_id LIKE ? || ':%'`)
+      : null;
 
   // Track if vec0 writes failed this session (needs sync)
   let vecDirty = false;
@@ -291,7 +341,7 @@ export async function createVectorIndexPort(
       k: number,
       searchOptions?: VectorSearchOptions
     ): Promise<StoreResult<VectorSearchResult[]>> {
-      if (!(searchAvailable && searchStmt)) {
+      if (!searchAvailable || !(searchStmt || noVectorsYet)) {
         return Promise.resolve(
           err("VEC_SEARCH_UNAVAILABLE", formatUnavailableMessage(loadError))
         );
@@ -397,6 +447,8 @@ export async function createVectorIndexPort(
             )
           );
         }
+        // No per-model table on a read connection: nothing was ever stored.
+        if (!searchStmt) return Promise.resolve(ok([]));
         const results = searchStmt.all(encodeEmbedding(embedding), k) as {
           chunk_id: string;
           distance: number;

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

@@ -13,10 +13,16 @@ import { buildEligibleDocumentQuery } from "../sqlite/eligibility";
 import {
   embeddingPartitionIdentity,
   identityPartitionId,
+  isPartitionActivated,
   resolveRuntimePartition,
   retrievalUse,
 } from "./runtime-compat";
-import { encodeEmbedding, getVectorIndexDatabase } from "./sqlite-vec";
+import {
+  encodeEmbedding,
+  getVectorIndexDatabase,
+  writerConnection,
+  writerIdle,
+} from "./sqlite-vec";
 import { embeddingInputHash } from "./variants";
 
 /** Fallback/warning code: this runtime may not read the activated vectors. */
@@ -35,13 +41,22 @@ export type SearchPartition =
  * an activated partition gets a reason instead of an identity; vector spaces
  * are never mixed.
  */
-export async function resolveVectorSearchIdentity(
+export function resolveVectorSearchIdentity(
   port: EmbeddingPort,
   vectorIndex: VectorIndexPort
+): Promise<SearchPartition> {
+  return resolveSearchPartition(port, vectorIndex, false);
+}
+
+async function resolveSearchPartition(
+  port: EmbeddingPort,
+  vectorIndex: VectorIndexPort,
+  waited: boolean
 ): Promise<SearchPartition> {
   const primary = embeddingPartitionIdentity(port);
-  const db = getVectorIndexDatabase(vectorIndex);
-  if (!primary || !db) return { identity: primary };
+  const indexDb = getVectorIndexDatabase(vectorIndex);
+  if (!primary || !indexDb) return { identity: primary };
+  const db = writerConnection(indexDb);
   let resolved;
   try {
     resolved = await resolveRuntimePartition(db, port, primary);
@@ -61,6 +76,28 @@ export async function resolveVectorSearchIdentity(
   );
   if (use.kind === "unavailable")
     return { unavailable: { reason: use.reason, building: use.building } };
+  // A first query on an upgraded index can migrate its legacy partition inside
+  // a sync batch still open on the shared connection; the read connection sees
+  // it only once that batch commits. Wait for that one batch, then resolve
+  // again (the migration commits with it, or reruns if the batch rolled back).
+  const partitionId = identityPartitionId(resolved.identity);
+  if (
+    indexDb !== db &&
+    isPartitionActivated(db, partitionId) &&
+    !isPartitionActivated(indexDb, partitionId)
+  ) {
+    if (!waited) {
+      await writerIdle(indexDb);
+      return resolveSearchPartition(port, vectorIndex, true);
+    }
+    return {
+      unavailable: {
+        reason:
+          "its vector partition is being migrated while the index syncs; retry shortly",
+        building: false,
+      },
+    };
+  }
   return { identity: resolved.identity };
 }
 

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

@@ -1 +0,0 @@
-34953d40a06904ec1c0fc7c6df54aaa14cb24acb05b38c3f15d572a285f7b3fc  gno-browser-clipper-v2.12.2.zip