@gmickel/gno 2.8.2 → 2.8.3

package/src/ingestion/types.ts

@@ -185,9 +185,18 @@ export interface SyncOptions {
   /** Conversion limits override */
   limits?: {
     maxBytes?: number;
+    /** Per-file conversion wall-clock budget (config `conversion.timeoutMs`). */
     timeoutMs?: number;
     maxOutputChars?: number;
+    /** Process memory ceiling while a file converts (`conversion.maxMemoryMb`). */
+    maxMemoryMb?: number;
   };
+  /**
+   * Internal: called once when one file's conversion has run longer than
+   * `SLOW_CONVERSION_NOTICE_MS` (or half its budget, if sooner), naming the
+   * file while it is still running.
+   */
+  onSlowConversion?: (event: SlowConversionEvent) => void;
   /**
    * Max concurrent file processing (default: 1).
    * Higher values improve throughput but increase memory pressure.
@@ -207,6 +216,15 @@ export interface SyncOptions {
   sourceAvailability?: "any" | "local";
 }
 
+/** A file whose conversion is taking longer than the notice threshold. */
+export interface SlowConversionEvent {
+  collection: string;
+  /** Collection-relative path of the file being converted. */
+  relPath: string;
+  elapsedMs: number;
+  budgetMs: number;
+}
+
 export type ContentTypeSource =
   | "frontmatter-type"
   | "prefix"

package/src/llm/native-worker/embedding-identity.ts

@@ -1,9 +1,21 @@
 // Bun has no inode/ctime identity API. Check replacement during hashing/loading.
 import { stat } from "node:fs/promises";
 
-const nativePackage: { version: string } = await Bun.file(
-  new URL("../package.json", import.meta.resolve("node-llama-cpp"))
-).json();
+/**
+ * node-llama-cpp's version, part of the embedding runtime identity. A
+ * standalone compiled executable ships no node-llama-cpp package (it cannot
+ * run local inference), so the lookup must not stop it from loading.
+ */
+const readNativePackage = async (): Promise<{ version: string }> => {
+  try {
+    return (await Bun.file(
+      new URL("../package.json", import.meta.resolve("node-llama-cpp"))
+    ).json()) as { version: string };
+  } catch {
+    return { version: "unavailable" };
+  }
+};
+const nativePackage = await readNativePackage();
 
 export async function fileIdentity(path: string): Promise<string> {
   const info = await stat(path, { bigint: true });

package/src/mcp/http-transport.ts

@@ -17,6 +17,7 @@ import { MCP_SERVER_NAME, VERSION } from "../app/constants";
 import { EgressDeniedError } from "../core/egress-enforcement";
 import { httpMcpRequestNamespace } from "../core/request-receipts";
 import { withInferenceScope } from "../llm/inference-scope";
+import { remoteSafeSessionsError } from "../sessions/types";
 import { createMcpServerSurface, type ToolContext } from "./context";
 import {
   enforceHttpMcpEgress,
@@ -44,6 +45,8 @@ const POLICY_CHANGED_SSE = new TextEncoder().encode(
 export interface HttpMcpTransportRuntime extends HttpMcpSessionRuntime {
   readonly authorizationEpoch?: string;
   readonly isShuttingDown: boolean;
+  /** Adopt config-file collection edits; see ResidentRuntime.refreshConfig. */
+  refreshConfig?(): Promise<void>;
   admitRequest(signal?: AbortSignal): ResidentRequestHandle | null;
 }
 
@@ -281,6 +284,14 @@ export class HttpMcpTransport {
     if (!MCP_HTTP_METHODS.has(request.method)) return methodNotAllowed();
     if (this.#closed || this.#runtime.isShuttingDown)
       return jsonRpcError(503, -32_000, "Resident runtime is unavailable");
+    // Before admission: adopting config-file collection edits moves the
+    // policy epoch, which would void a request already admitted.
+    try {
+      await this.#runtime.refreshConfig?.();
+    } catch (error) {
+      const typed = remoteSafeSessionsError(error);
+      return jsonRpcError(500, -32_000, `${typed.code}: ${typed.message}`);
+    }
     if (!(await this.#acquireCapacity(request.signal))) {
       if (this.#closed || this.#runtime.isShuttingDown)
         return jsonRpcError(503, -32_000, "Resident runtime is unavailable");

package/src/mcp/tools/links.ts

@@ -26,7 +26,7 @@ import { normalizeCollectionName } from "../../core/validation";
 import { getActivePreset } from "../../llm/registry";
 import { createVectorIndexPort } from "../../store/vector";
 import {
-  readStoredDocumentVectors,
+  readSimilaritySourceVectors,
   resolveStoredVectorSource,
   similarityHitDocuments,
   storedVectorSearchOptions,
@@ -415,55 +415,27 @@ export function handleSimilar(
       const preset = getActivePreset(ctx.config);
       const modelUri = preset.embed;
 
-      // Stored chunk vectors from the active partition (NO model loading required)
+      // Similarity source vector (first chunk, unit length) from the active
+      // partition (NO model loading required)
       const db = ctx.store.getRawDb();
       const source = resolveStoredVectorSource(db, modelUri);
 
-      let vectors: Float32Array[];
+      let embedding: Float32Array | undefined;
       try {
-        vectors =
-          readStoredDocumentVectors(db, source, [
-            { id: doc.id, mirrorHash: doc.mirrorHash },
-          ]).get(doc.id) ?? [];
+        embedding = readSimilaritySourceVectors(db, source, [
+          { id: doc.id, mirrorHash: doc.mirrorHash },
+        ]).get(doc.id);
       } catch (e) {
         throw new Error(
           `Invalid stored embedding data: ${e instanceof Error ? e.message : String(e)}`
         );
       }
-      const first = vectors[0];
-      if (!first) {
+      if (!embedding) {
         throw new Error(
           `${MCP_ERRORS.NOT_FOUND.code}: Document has no embeddings. Run: gno embed`
         );
       }
-
-      // Compute average embedding from all chunks
-      const dimensions = first.length;
-      const avgEmbedding = new Float32Array(dimensions);
-      for (const embedding of vectors) {
-        if (embedding.length !== dimensions) {
-          throw new Error(
-            `Invalid stored embedding data: Inconsistent embedding dimensions: expected ${dimensions}, got ${embedding.length}`
-          );
-        }
-        for (let i = 0; i < dimensions; i++) {
-          const current = avgEmbedding[i] ?? 0;
-          avgEmbedding[i] = current + (embedding[i] ?? 0) / vectors.length;
-        }
-      }
-
-      // Normalize the average embedding for cosine similarity
-      let norm = 0;
-      for (let i = 0; i < dimensions; i++) {
-        const val = avgEmbedding[i] ?? 0;
-        norm += val * val;
-      }
-      norm = Math.sqrt(norm);
-      if (norm > 0) {
-        for (let i = 0; i < dimensions; i++) {
-          avgEmbedding[i] = (avgEmbedding[i] ?? 0) / norm;
-        }
-      }
+      const dimensions = embedding.length;
 
       // Create vector index for search
       const vectorResult = await createVectorIndexPort(db, {
@@ -496,7 +468,7 @@ export function handleSimilar(
       // Search for similar documents (larger pool for filtering)
       const candidateLimit = Math.min(limit * 20, 200);
       const searchResult = await vectorIndex.searchNearest(
-        avgEmbedding,
+        embedding,
         candidateLimit,
         storedVectorSearchOptions(source)
       );

package/src/serve/resident-request.ts

@@ -2,6 +2,23 @@ import type { ResidentRuntime } from "./resident-runtime";
 /** Admission and bounded-reader boundary for resident REST reads. */
 
 import { withInferenceScope } from "../llm/inference-scope";
+import { sessionsErrorResponse } from "./routes/sessions";
+
+/**
+ * Adopt config-file collection edits before a request is admitted (adoption
+ * moves the policy epoch, which would void an admitted request). Returns the
+ * error response when the config cannot be read or is bound elsewhere.
+ */
+export async function refreshResidentConfig(
+  runtime: Pick<ResidentRuntime, "refreshConfig">
+): Promise<Response | null> {
+  try {
+    await runtime.refreshConfig?.();
+    return null;
+  } catch (error) {
+    return sessionsErrorResponse(error);
+  }
+}
 
 function unavailableResponse(): Response {
   return Response.json(
@@ -87,6 +104,8 @@ export async function handleResidentRead(
   request: Request | undefined,
   operation: (signal: AbortSignal) => Promise<Response> | Response
 ): Promise<Response> {
+  const refreshFailure = await refreshResidentConfig(runtime);
+  if (refreshFailure) return refreshFailure;
   const admitted = runtime.admitRequest(request?.signal);
   if (!admitted) return unavailableResponse();
 

package/src/serve/resident-runtime.ts

@@ -51,10 +51,16 @@ import {
 } from "../core/shutdown-budget";
 import { acquireCliWriteLease } from "../core/write-lease";
 import { defaultSyncService, withContentTypeRules } from "../ingestion";
+import { disposeFileProcessor } from "../ingestion/file-processor";
 import { withOwnedInferenceScope } from "../llm/inference-scope";
 import { getActivePreset } from "../llm/registry";
 import { createToolContext, Mutex } from "../mcp/context";
 import { watchedCollections } from "../sessions/config";
+import {
+  adoptServedConfig,
+  readInstanceConfig,
+} from "../sessions/config-refresh";
+import { remoteSafeSessionsError } from "../sessions/types";
 import { SqliteAdapter } from "../store/sqlite/adapter";
 import {
   createServerContext,
@@ -78,6 +84,8 @@ import {
 import { CollectionWatchService as DefaultCollectionWatchService } from "./watch-service";
 
 const OWNER_LOCK_TIMEOUT_MS = 0;
+/** How often an idle resident re-reads its config file for collection edits. */
+const CONFIG_REFRESH_INTERVAL_MS = 2_000;
 
 export type ResidentMode = "serve" | "daemon";
 
@@ -146,6 +154,15 @@ export interface ResidentRuntime {
     provider: (() => HttpMcpTransportStatus) | null
   ): void;
   setPolicySessionInvalidator(invalidator: (() => Promise<void>) | null): void;
+  /**
+   * Adopt collection (and context) edits made to the config file while the
+   * resident runs, with the sessions refresh's binding checks: rejects when
+   * the file is unreadable or bound to another index, leaving the served
+   * config as it was. Other settings keep their restart behaviour. Callers
+   * run it before admitting a request (an adoption moves the policy epoch).
+   * Optional only for test doubles; the real runtime always provides it.
+   */
+  refreshConfig?(): Promise<void>;
   admitRequest(signal?: AbortSignal): ResidentRequestHandle | null;
   withModelLease<T>(operation: () => Promise<T>): Promise<T>;
   markContentMutation(): void;
@@ -472,17 +489,56 @@ export async function startResidentRuntime(
     startBackgroundWork: (operation) => backgroundWork.start(operation),
   });
 
+  const setServedConfig = (config: Config): void => {
+    ctxHolder.config = config;
+    ctxHolder.current = { ...ctxHolder.current, config };
+    ctxHolder.watchService?.updateCollections(
+      watchedCollections(config),
+      withContentTypeRules({}, config)
+    );
+  };
+  const instance = {
+    configPath: actualConfigPath,
+    indexName: canonicalizeIndexName(options.index ?? DEFAULT_INDEX_NAME),
+  };
+  let configRefresh: Promise<void> | undefined;
+  const refreshConfig = (): Promise<void> => {
+    configRefresh ??= (async () => {
+      const file = await readInstanceConfig(
+        instance,
+        deps.loadConfig ?? loadConfig
+      );
+      const served = ctxHolder.config;
+      const next: Config = {
+        ...served,
+        collections: file.collections,
+        contexts: file.contexts,
+      };
+      if (Bun.deepEquals(next, served)) return;
+      await adoptServedConfig(
+        {
+          ...instance,
+          store,
+          config: served,
+          setConfig: setServedConfig,
+          invalidateEgressPolicy: async () => {
+            await ctxHolder.invalidateEgressPolicy?.();
+          },
+          markContentMutation: () => ctxHolder.markContentMutation?.(),
+          markIndexMutation: () => ctxHolder.markIndexMutation?.(),
+        },
+        next
+      );
+    })().finally(() => {
+      configRefresh = undefined;
+    });
+    return configRefresh;
+  };
+
   const mcpContext = createToolContext({
     store,
     getConfig: () => ctxHolder.config,
-    setConfig: (config) => {
-      ctxHolder.config = config;
-      ctxHolder.current = { ...ctxHolder.current, config };
-      ctxHolder.watchService?.updateCollections(
-        watchedCollections(config),
-        withContentTypeRules({}, config)
-      );
-    },
+    setConfig: setServedConfig,
     actualConfigPath,
     indexName: canonicalizeIndexName(options.index ?? DEFAULT_INDEX_NAME),
     toolMutex,
@@ -633,6 +689,7 @@ export async function startResidentRuntime(
     setPolicySessionInvalidator(invalidator) {
       policySessionInvalidator = invalidator;
     },
+    refreshConfig,
     async syncAll(syncOptions = {}) {
       const request = admission.admit();
       if (!request) throw new Error("Resident runtime is shutting down");
@@ -674,8 +731,11 @@ export async function startResidentRuntime(
     dispose(closeSurface) {
       if (disposal) return disposal;
       disposed = true;
+      clearInterval(configRefreshTimer);
       admission.stop();
       jobManager.stop();
+      // A file mid-preparation fails now instead of holding shutdown.
+      disposeFileProcessor();
       admissionState = "draining";
       shutdownState = "graceful";
       disposal = disposeResidentResources({
@@ -725,5 +785,21 @@ export async function startResidentRuntime(
     };
   };
   mcpContext.getResidentStatus = () => runtime.getStatus();
+  // Without requests (a headless daemon) the watcher still follows the file.
+  let lastRefreshError: string | undefined;
+  const configRefreshTimer = setInterval(() => {
+    backgroundWork.start(async () => {
+      try {
+        await refreshConfig();
+        lastRefreshError = undefined;
+      } catch (error) {
+        const message = remoteSafeSessionsError(error).message;
+        if (message !== lastRefreshError)
+          console.warn(`gno ${mode}: config not reloaded: ${message}`);
+        lastRefreshError = message;
+      }
+    });
+  }, CONFIG_REFRESH_INTERVAL_MS);
+  configRefreshTimer.unref?.();
   return { success: true, runtime };
 }

package/src/serve/routes/links.ts

@@ -8,7 +8,7 @@ import type { SqliteAdapter } from "../../store/sqlite/adapter";
 import type { ServerContext } from "../context";
 
 import {
-  readStoredDocumentVectors,
+  readSimilaritySourceVectors,
   resolveStoredVectorSource,
   similarityHitDocuments,
   storedVectorSearchOptions,
@@ -313,7 +313,7 @@ export async function handleDocBacklinks(
  *   ?threshold=0.5 (min similarity score 0-1, default 0.5)
  *   ?crossCollection=true (search across all collections, default false)
  *
- * Algorithm: seq=0 embedding (fallback to first available) -> vector search -> exclude self
+ * Algorithm: first-chunk source vector (readSimilaritySourceVectors) -> vector search -> exclude self
  */
 export async function handleDocSimilar(
   ctx: ServerContext,
@@ -378,18 +378,14 @@ export async function handleDocSimilar(
     } satisfies SimilarDocResponse);
   }
 
-  // Stored vector of the document's first chunk, from the active partition
+  // Similarity source vector (first chunk, unit length), active partition
   const db = store.getRawDb();
   const source = resolveStoredVectorSource(db, ctx.vectorIndex.model);
   let embedding: Float32Array | undefined;
   try {
-    [embedding] =
-      readStoredDocumentVectors(
-        db,
-        source,
-        [{ id: doc.id, mirrorHash: doc.mirrorHash }],
-        { firstChunkOnly: true }
-      ).get(doc.id) ?? [];
+    embedding = readSimilaritySourceVectors(db, source, [
+      { id: doc.id, mirrorHash: doc.mirrorHash },
+    ]).get(doc.id);
   } catch (e) {
     return errorResponse(
       "RUNTIME",
@@ -410,20 +406,6 @@ export async function handleDocSimilar(
       },
     } satisfies SimilarDocResponse);
   }
-  const dimensions = embedding.length;
-
-  // Normalize embedding for cosine similarity
-  let norm = 0;
-  for (let i = 0; i < dimensions; i++) {
-    const val = embedding[i] ?? 0;
-    norm += val * val;
-  }
-  norm = Math.sqrt(norm);
-  if (norm > 0) {
-    for (let i = 0; i < dimensions; i++) {
-      embedding[i] = (embedding[i] ?? 0) / norm;
-    }
-  }
 
   // Search for similar docs (request extra to account for self-exclusion, filtering)
   const candidateLimit = Math.min(limit * 20, 200);

package/src/serve/server.ts

@@ -28,7 +28,7 @@ import { withRemoteHostPathRedaction } from "./host-path-redaction";
 import { PDFJS_ASSET_CACHE_CONTROL } from "./pdfjs-assets";
 // HTML import - Bun handles bundling TSX/CSS automatically via routes
 import homepage from "./public/index.html";
-import { handleResidentRead } from "./resident-request";
+import { handleResidentRead, refreshResidentConfig } from "./resident-request";
 import {
   handleActiveJob,
   handleAsk,
@@ -702,7 +702,8 @@ export async function startServer(
         "/api/collections": {
           GET: async () =>
             withSecurityHeaders(
-              await handleCollections(ctxHolder.config),
+              (await refreshResidentConfig(runtime as ResidentRuntime)) ??
+                (await handleCollections(ctxHolder.config)),
               isDev
             ),
           POST: async (req: Request) => {

package/src/sessions/config-refresh.ts

@@ -53,9 +53,10 @@ export async function assertInstanceBinding(
  * before it can touch this one.
  */
 export async function readInstanceConfig(
-  instance: SessionsInstance
+  instance: SessionsInstance,
+  load: typeof loadConfig = loadConfig
 ): Promise<Config> {
-  const loaded = await loadConfig(instance.configPath);
+  const loaded = await load(instance.configPath);
   if (!loaded.ok) {
     throw new SessionsError(
       "SESSIONS_RUNTIME_FAILURE",

package/src/store/sqlite/graph-similarity.ts

@@ -6,7 +6,7 @@
 import type { Database } from "bun:sqlite";
 
 import {
-  readStoredDocumentVectors,
+  readSimilaritySourceVectors,
   resolveStoredVectorSource,
 } from "../vector/stored-vectors";
 
@@ -27,13 +27,6 @@ export interface StoredSimilarityEdge {
   score: number;
 }
 
-function unit(vector: Float32Array): Float32Array {
-  let norm = 0;
-  for (const value of vector) norm += value * value;
-  norm = Math.sqrt(norm);
-  return norm > 0 ? vector.map((value) => value / norm) : vector;
-}
-
 function dot(a: Float32Array, b: Float32Array): number {
   let sum = 0;
   for (let i = 0; i < a.length; i++) sum += (a[i] ?? 0) * (b[i] ?? 0);
@@ -61,15 +54,14 @@ export function storedSimilarityEdges(
         ORDER BY docid
       `)
       .all(JSON.stringify(docids));
-    const vectors = readStoredDocumentVectors(
+    const vectors = readSimilaritySourceVectors(
       db,
       resolveStoredVectorSource(db, model),
-      documents,
-      { firstChunkOnly: true }
+      documents
     );
     const nodes = documents.flatMap((document) => {
-      const vector = vectors.get(document.id)?.[0];
-      return vector ? [{ ...document, vector: unit(vector) }] : [];
+      const vector = vectors.get(document.id);
+      return vector ? [{ ...document, vector }] : [];
     });
     const edges: StoredSimilarityEdge[] = [];
     for (const node of nodes) {

package/src/store/vector/partition-index.ts

@@ -0,0 +1,100 @@
+/**
+ * Maintenance of an activated vector partition's vec0 index
+ * (`vec_v1_<partition>`), which mirrors the partition's `vector_variants`.
+ * `gno vec sync` and `gno vec rebuild` use it on indexes embedded since 2.7.
+ * Neither changes authority, owners or variants, so the variant epoch stays.
+ *
+ * @module src/store/vector/partition-index
+ */
+import type { Database } from "bun:sqlite";
+
+export interface StoredPartition {
+  partitionId: string;
+  dimensions: number;
+}
+
+const tableName = (partition: StoredPartition): string =>
+  `vec_v1_${partition.partitionId}`;
+
+const createTable = (db: Database, partition: StoredPartition): void => {
+  db.exec(`CREATE VIRTUAL TABLE IF NOT EXISTS ${tableName(partition)} USING vec0(
+    variant_id INTEGER PRIMARY KEY,
+    embedding FLOAT[${partition.dimensions}] distance_metric=cosine
+  )`);
+};
+
+const insertVariants = (
+  db: Database,
+  partition: StoredPartition,
+  rows: Iterable<{ variantId: number; embedding: Uint8Array }>
+): number => {
+  let inserted = 0;
+  for (const row of rows) {
+    db.run(
+      `INSERT INTO ${tableName(partition)}(variant_id, embedding) VALUES (?, ?)`,
+      [row.variantId, row.embedding]
+    );
+    inserted += 1;
+  }
+  return inserted;
+};
+
+/**
+ * Remove index rows without a matching variant (orphans and stale
+ * embeddings), then add the variants the index lacks. Requires sqlite-vec.
+ */
+export function syncPartitionIndex(
+  db: Database,
+  partition: StoredPartition
+): { added: number; removed: number } {
+  const table = tableName(partition);
+  return db
+    .transaction(() => {
+      createTable(db, partition);
+      const stale = db
+        .query<{ variantId: number }, [string]>(`
+          SELECT x.variant_id AS variantId FROM ${table} x
+          LEFT JOIN vector_variants v ON v.variant_id = x.variant_id
+            AND v.partition_id = ?
+          WHERE v.variant_id IS NULL OR x.embedding != v.embedding
+        `)
+        .all(partition.partitionId);
+      for (const { variantId } of stale) {
+        db.run(`DELETE FROM ${table} WHERE variant_id = ?`, [variantId]);
+      }
+      const missing = db
+        .query<{ variantId: number; embedding: Uint8Array }, [string]>(`
+          SELECT v.variant_id AS variantId, v.embedding FROM vector_variants v
+          LEFT JOIN ${table} x ON x.variant_id = v.variant_id
+          WHERE v.partition_id = ? AND x.variant_id IS NULL
+        `)
+        .all(partition.partitionId);
+      return {
+        added: insertVariants(db, partition, missing),
+        removed: stale.length,
+      };
+    })
+    .immediate();
+}
+
+/** Drop and repopulate the index from the partition's variants. */
+export function rebuildPartitionIndex(
+  db: Database,
+  partition: StoredPartition
+): number {
+  return db
+    .transaction(() => {
+      db.exec(`DROP TABLE IF EXISTS ${tableName(partition)}`);
+      createTable(db, partition);
+      return insertVariants(
+        db,
+        partition,
+        db
+          .query<{ variantId: number; embedding: Uint8Array }, [string]>(
+            "SELECT variant_id AS variantId, embedding FROM vector_variants WHERE partition_id = ?"
+          )
+          .iterate(partition.partitionId)
+      );
+    })
+    .immediate();
+}

package/src/store/vector/stored-vectors.ts

@@ -53,25 +53,30 @@ interface PartitionVectorRow {
   embedding: Uint8Array;
 }
 
+const unitVector = (vector: Float32Array): Float32Array => {
+  let norm = 0;
+  for (const value of vector) norm += value * value;
+  norm = Math.sqrt(norm);
+  return norm > 0 ? vector.map((value) => value / norm) : vector;
+};
+
 /**
- * Chunk vectors of current active documents, ordered by chunk seq, keyed by
- * document id. Partition vectors count only while their owner still yields
- * the stored input (the rule vector search applies). `firstChunkOnly` keeps
- * the lowest-seq vector per document.
+ * The similarity source vector of each current active document, keyed by
+ * document id: the stored vector of its first chunk (lowest seq whose vector
+ * is current), unit-normalized. Every similarity surface (CLI, MCP, REST and
+ * graph edges) uses this one rule, so scores agree. Partition vectors count
+ * only while their owner still yields the stored input (the rule vector
+ * search applies).
  */
-export function readStoredDocumentVectors(
+export function readSimilaritySourceVectors(
   db: Database,
   source: StoredVectorSource,
-  documents: StoredVectorDocument[],
-  options: { firstChunkOnly?: boolean } = {}
-): Map<number, Float32Array[]> {
-  const vectors = new Map<number, Float32Array[]>();
+  documents: StoredVectorDocument[]
+): Map<number, Float32Array> {
+  const vectors = new Map<number, Float32Array>();
   const add = (documentId: number, blob: Uint8Array): void => {
-    const existing = vectors.get(documentId);
-    if (existing && options.firstChunkOnly) return;
-    const embedding = decodeEmbedding(blob);
-    if (existing) existing.push(embedding);
-    else vectors.set(documentId, [embedding]);
+    if (!vectors.has(documentId))
+      vectors.set(documentId, unitVector(decodeEmbedding(blob)));
   };
   if (documents.length === 0) return vectors;
 
@@ -95,7 +100,7 @@ export function readStoredDocumentVectors(
         JSON.stringify(documents.map((document) => document.id))
       );
     for (const row of rows) {
-      if (options.firstChunkOnly && vectors.has(row.documentId)) continue;
+      if (vectors.has(row.documentId)) continue;
       const input = formatDocForEmbedding(
         row.text,
         row.title ?? undefined,

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

@@ -1 +0,0 @@
-7bc830276cb923a482b662b980208b0978bf8ddbfbade0873e67d9757cf9c989  gno-browser-clipper-v2.8.2.zip