@gmickel/gno 1.45.1 → 2.0.0

package/src/embed/retry.ts

@@ -1,9 +1,17 @@
 import type { EmbeddingPort } from "../llm/types";
 import type { StoreResult } from "../store/types";
-import type { BacklogItem, VectorIndexPort, VectorRow } from "../store/vector";
+import type {
+  BacklogItem,
+  VectorIndexPort,
+  VectorRow,
+  VectorStatsPort,
+} from "../store/vector";
 
 import { isSqliteLockContention } from "../core/file-lock";
+import { assertInferenceActive } from "../llm/inference-scope";
 import { formatDocForEmbedding } from "../pipeline/contextual";
+import { err, ok } from "../store/types";
+import { getVectorStatsDatabase } from "../store/vector/stats";
 import { embedTextsWithRecovery } from "./batch";
 
 export const MAX_EMBED_CHUNK_ATTEMPTS = 2;
@@ -42,12 +50,21 @@ export interface EmbedStoreBatchResult {
 // src/cli/commands/index-cmd.ts) must surface contentionErrors in their
 // summary and exit non-zero — the integrator wires that.
 
-export function chunkRetryKey(item: Pick<BacklogItem, "mirrorHash" | "seq">) {
+export function chunkRetryKey(
+  item: Pick<BacklogItem, "mirrorHash" | "seq"> & {
+    documentId?: number;
+    inputHash?: string;
+  }
+) {
+  if (item.documentId !== undefined && item.inputHash !== undefined) {
+    return `${item.documentId}\0${item.mirrorHash}\0${item.seq}\0${item.inputHash}`;
+  }
   return `${item.mirrorHash}\0${item.seq}`;
 }
 
 export function addUniqueSamples(target: string[], samples: string[]): void {
   for (const sample of samples) {
+    assertInferenceActive();
     if (target.length >= MAX_EMBED_FAILURE_SAMPLES) {
       break;
     }
@@ -127,6 +144,7 @@ export async function upsertVectorsWithContentionRetry(
   vectors: VectorRow[],
   delays?: number[]
 ): Promise<StoreResult<void>> {
+  assertInferenceActive();
   let storeResult = await vectorIndex.upsertVectors(vectors);
   let attempts = 1;
   while (
@@ -138,6 +156,7 @@ export async function upsertVectorsWithContentionRetry(
     if (delayMs > 0) {
       await Bun.sleep(delayMs);
     }
+    assertInferenceActive();
     storeResult = await vectorIndex.upsertVectors(vectors);
     attempts += 1;
   }
@@ -150,10 +169,22 @@ export async function embedAndStoreBatch(params: {
   items: BacklogItem[];
   modelUri: string;
   embedFingerprint: string;
+  statsPort?: VectorStatsPort;
+  identityStillCurrent?: () => boolean;
   /** Test seam: override contention-retry delays in milliseconds. */
   delays?: number[];
 }): Promise<EmbedStoreBatchResult> {
   const { embedPort, vectorIndex, items, modelUri, embedFingerprint } = params;
+  const db = params.statsPort && getVectorStatsDatabase(params.statsPort);
+  if (db && !vectorIndex.upsertVectorsChecked)
+    return {
+      embedded: 0,
+      errors: items.length,
+      contentionErrors: 0,
+      retryItems: [],
+      errorSamples: ["Atomic vector checkpoint unavailable"],
+      batchFailed: false,
+    };
   const embedResult = await embedTextsWithRecovery(
     embedPort,
     items.map((item) =>
@@ -180,6 +211,7 @@ export async function embedAndStoreBatch(params: {
   const vectors: VectorRow[] = [];
   const retryItems: BacklogItem[] = [];
   for (const [idx, item] of items.entries()) {
+    assertInferenceActive();
     const embedding = embedResult.value.vectors[idx];
     if (!embedding) {
       retryItems.push(item);
@@ -207,8 +239,75 @@ export async function embedAndStoreBatch(params: {
     };
   }
 
+  let written = 0;
+  let committedRows: VectorRow[] = [];
+  const itemsByKey = new Map(items.map((item) => [chunkRetryKey(item), item]));
+  const checkpoint = (rows: VectorRow[]): VectorRow[] => {
+    assertInferenceActive();
+    if (params.identityStillCurrent && !params.identityStillCurrent())
+      return [];
+    if (!db) return rows;
+    // A concurrently activated verified partition forbids a late legacy write.
+    if (
+      db
+        .query(
+          "SELECT 1 FROM sqlite_master WHERE type = 'table' AND name = 'vector_partitions'"
+        )
+        .get() &&
+      db
+        .query(
+          "SELECT 1 FROM vector_partitions WHERE model = ? AND state = 'active' AND activated_epoch IS NOT NULL LIMIT 1"
+        )
+        .get(modelUri)
+    )
+      return [];
+    return rows.filter((row) => {
+      const item = itemsByKey.get(chunkRetryKey(row));
+      const current = db
+        .query<{ text: string; title: string | null }, [string, number]>(`
+        SELECT c.text, d.title FROM content_chunks c
+        JOIN documents d ON d.mirror_hash = c.mirror_hash AND d.active = 1
+        WHERE c.mirror_hash = ? AND c.seq = ? ORDER BY d.id LIMIT 1
+      `)
+        .get(row.mirrorHash, row.seq);
+      return (
+        !!item &&
+        !!current &&
+        formatDocForEmbedding(
+          current.text,
+          current.title ?? undefined,
+          modelUri
+        ) ===
+          formatDocForEmbedding(item.text, item.title ?? undefined, modelUri)
+      );
+    });
+  };
   const storeResult = await upsertVectorsWithContentionRetry(
-    vectorIndex,
+    {
+      upsertVectors: async (rows) => {
+        if (vectorIndex.upsertVectorsChecked) {
+          const result = await vectorIndex.upsertVectorsChecked(
+            rows,
+            (candidates) => {
+              committedRows = checkpoint(candidates);
+              return committedRows;
+            }
+          );
+          if (!result.ok) return result;
+          written = result.value;
+          return ok(undefined);
+        }
+        if (db)
+          return err("INVALID_INPUT", "Atomic vector checkpoint unavailable");
+        const valid = checkpoint(rows);
+        const result = await vectorIndex.upsertVectors(valid);
+        if (result.ok) {
+          written = valid.length;
+          committedRows = valid;
+        }
+        return result;
+      },
+    },
     vectors,
     params.delays
   );
@@ -237,11 +336,20 @@ export async function embedAndStoreBatch(params: {
     };
   }
 
+  const vectorKeys = new Set(vectors.map((row) => chunkRetryKey(row)));
+  const committedKeys = new Set(committedRows.map((row) => chunkRetryKey(row)));
   return {
-    embedded: vectors.length,
+    embedded: written,
     errors: 0,
     contentionErrors: 0,
-    retryItems,
+    retryItems: [
+      ...retryItems,
+      ...items.filter(
+        (item) =>
+          vectorKeys.has(chunkRetryKey(item)) &&
+          !committedKeys.has(chunkRetryKey(item))
+      ),
+    ],
     errorSamples: embedResult.value.failureSamples,
     suggestion: embedResult.value.retrySuggestion,
     batchFailed: embedResult.value.batchFailed,

package/src/embed/variant-backlog.ts

@@ -0,0 +1,105 @@
+import type { StoreResult } from "../store/types";
+import type { VectorVariantStore } from "../store/vector/variants";
+import type { EmbedBacklogDeps, EmbedBacklogResult } from "./backlog";
+
+import {
+  assertInferenceActive,
+  isBackgroundInference,
+} from "../llm/inference-scope";
+import { err, ok } from "../store/types";
+import { getVectorStatsDatabase } from "../store/vector/stats";
+import { variantBacklogPage } from "./variant-plan";
+import { embedVariantBatch } from "./variant-retry";
+
+/** One bounded owner pass plus one retry; mutations stay durably pending for the next pass. */
+export async function embedVariantBacklog(
+  deps: EmbedBacklogDeps,
+  store: VectorVariantStore
+): Promise<StoreResult<EmbedBacklogResult>> {
+  const identityStillCurrent = deps.identityStillCurrent;
+  if (!identityStillCurrent)
+    return err(
+      "INVALID_INPUT",
+      "Variant embedding requires an effective runtime identity check"
+    );
+  const db = getVectorStatsDatabase(deps.statsPort);
+  if (deps.collection && !db)
+    return err(
+      "INVALID_INPUT",
+      "Collection-scoped variant backlog requires document ownership storage"
+    );
+  const background = isBackgroundInference();
+  const batchSize = background
+    ? Math.min(deps.batchSize ?? 32, 32)
+    : (deps.batchSize ?? 32);
+  if (!Number.isSafeInteger(batchSize) || batchSize < 1)
+    return err("INVALID_INPUT", "Invalid embedding batch size");
+  const total = { embedded: 0, errors: 0, contentionErrors: 0 };
+  let after: { documentId: number; seq: number } | undefined;
+  try {
+    while (identityStillCurrent()) {
+      assertInferenceActive();
+      const pending = variantBacklogPage(deps, store, batchSize, after);
+      if (!pending.length) break;
+      const last = pending.at(-1)!;
+      after = { documentId: last.documentId, seq: last.seq };
+      const owners = deps.collection
+        ? pending.filter(
+            (owner) =>
+              !!db!
+                .query(
+                  "SELECT 1 FROM documents WHERE id = ? AND collection = ? AND active = 1"
+                )
+                .get(owner.documentId, deps.collection!)
+          )
+        : pending;
+      let result = await embedVariantBatch({
+        store,
+        embedPort: deps.embedPort,
+        owners,
+        identityStillCurrent,
+        force: deps.force,
+      });
+      total.embedded += result.embedded;
+      total.errors += result.errors;
+      total.contentionErrors += result.contentionErrors;
+      if (background) total.errors += result.retryOwners.length;
+      if (!background && result.retryOwners.length) {
+        result = await embedVariantBatch({
+          store,
+          embedPort: deps.embedPort,
+          owners: result.retryOwners,
+          identityStillCurrent,
+          force: deps.force,
+        });
+        total.embedded += result.embedded;
+        total.errors += result.errors + result.retryOwners.length;
+        total.contentionErrors += result.contentionErrors;
+      }
+      deps.onProgress?.(total.embedded, total.errors);
+      if (background) await Bun.sleep(0);
+    }
+    assertInferenceActive();
+    // Capture the epoch before checking completeness; activate rechecks under write lock.
+    const epoch = store.epoch();
+    if (identityStillCurrent() && !store.pending({ limit: 1 }).length) {
+      try {
+        if (!store.isActive()) store.syncIndex();
+        if (!identityStillCurrent()) return ok(total);
+        store.activate(epoch);
+      } catch (cause) {
+        return ok({
+          ...total,
+          syncError: cause instanceof Error ? cause.message : String(cause),
+        });
+      }
+    }
+    assertInferenceActive();
+    return ok(total);
+  } catch (cause) {
+    return err(
+      "QUERY_FAILED",
+      cause instanceof Error ? cause.message : String(cause)
+    );
+  }
+}

package/src/embed/variant-plan.ts

@@ -0,0 +1,62 @@
+import type { VectorVariantStore } from "../store/vector/variants";
+import type { EmbedBacklogDeps } from "./backlog";
+
+import { getVectorStatsDatabase } from "../store/vector/stats";
+
+/** Counts and execution enumerate the same exact current owner partition. */
+export function variantBacklogPage(
+  deps: EmbedBacklogDeps,
+  store: VectorVariantStore,
+  limit: number,
+  after?: { documentId: number; seq: number }
+) {
+  if (!deps.force) return store.pending({ limit, after });
+  const db = getVectorStatsDatabase(deps.statsPort);
+  if (!db)
+    throw new Error("Forced variants require document ownership storage");
+  const rows = db
+    .query<
+      { documentId: number; seq: number },
+      [number, number, number, number]
+    >(`
+    SELECT d.id AS documentId, c.seq FROM documents d
+    JOIN content_chunks c ON c.mirror_hash = d.mirror_hash
+    WHERE d.active = 1 AND (d.id > ? OR (d.id = ? AND c.seq > ?))
+    ORDER BY d.id, c.seq LIMIT ?
+  `)
+    .all(
+      after?.documentId ?? -1,
+      after?.documentId ?? -1,
+      after?.seq ?? -1,
+      limit
+    );
+  return rows.flatMap((row) => {
+    const owner = store.current(row.documentId, row.seq);
+    return owner ? [owner] : [];
+  });
+}
+
+export function countVariantBacklog(deps: EmbedBacklogDeps): number {
+  const store = deps.variantStore;
+  if (!store) throw new Error("Verified variant identity required");
+  const db = getVectorStatsDatabase(deps.statsPort);
+  let after: { documentId: number; seq: number } | undefined;
+  let count = 0;
+  while (true) {
+    const owners = variantBacklogPage(deps, store, 256, after);
+    if (!owners.length) return count;
+    for (const owner of owners) {
+      if (
+        !deps.collection ||
+        db
+          ?.query(
+            "SELECT 1 FROM documents WHERE id = ? AND collection = ? AND active = 1"
+          )
+          .get(owner.documentId, deps.collection)
+      )
+        count += 1;
+    }
+    const last = owners.at(-1)!;
+    after = { documentId: last.documentId, seq: last.seq };
+  }
+}

package/src/embed/variant-retry.ts

@@ -0,0 +1,113 @@
+import type { EmbeddingPort } from "../llm/types";
+import type { VectorOwnerInput } from "../store/vector/types";
+import type { VectorVariantStore } from "../store/vector/variants";
+
+import { err, ok } from "../store/types";
+import { embedTextsWithRecovery } from "./batch";
+import {
+  chunkRetryKey,
+  isUpsertLockContention,
+  upsertVectorsWithContentionRetry,
+} from "./retry";
+
+function isCurrent(
+  store: VectorVariantStore,
+  owner: VectorOwnerInput
+): boolean {
+  const current = store.current(owner.documentId, owner.seq);
+  return (
+    current?.mirrorHash === owner.mirrorHash &&
+    current.inputHash === owner.inputHash &&
+    current.formattedInput === owner.formattedInput
+  );
+}
+
+/** Exact inputs are inferred once; successful current owners checkpoint atomically. */
+export async function embedVariantBatch(params: {
+  store: VectorVariantStore;
+  embedPort: EmbeddingPort;
+  owners: VectorOwnerInput[];
+  identityStillCurrent: () => boolean;
+  delays?: number[];
+  force?: boolean;
+}): Promise<{
+  embedded: number;
+  errors: number;
+  contentionErrors: number;
+  retryOwners: VectorOwnerInput[];
+}> {
+  const { store, embedPort, identityStillCurrent } = params;
+  const empty = {
+    embedded: 0,
+    errors: 0,
+    contentionErrors: 0,
+    retryOwners: [] as VectorOwnerInput[],
+  };
+  if (!identityStillCurrent()) return empty;
+  const owners = [
+    ...new Map(
+      params.owners.map((owner) => [chunkRetryKey(owner), owner])
+    ).values(),
+  ].filter((owner) => isCurrent(store, owner));
+  const inputs = new Map<string, string>();
+  const reusable = new Set<string>();
+  for (const owner of owners) {
+    if (!params.force && store.reusable(owner)) reusable.add(owner.inputHash);
+    else inputs.set(owner.inputHash, owner.formattedInput);
+  }
+  const keys = [...inputs.keys()];
+  const result = await embedTextsWithRecovery(embedPort, [...inputs.values()]);
+  if (!identityStillCurrent()) return empty;
+  const current = owners.filter((owner) => isCurrent(store, owner));
+  const vectors = new Map<string, Float32Array>();
+  if (result.ok) {
+    for (const [index, key] of keys.entries()) {
+      const vector = result.value.vectors[index];
+      if (vector) vectors.set(key, new Float32Array(vector));
+    }
+  }
+  const retryOwners = current.filter(
+    (owner) => !reusable.has(owner.inputHash) && !vectors.has(owner.inputHash)
+  );
+  const rows = current
+    .filter(
+      (owner) => reusable.has(owner.inputHash) || vectors.has(owner.inputHash)
+    )
+    .map((owner) => ({ owner, embedding: vectors.get(owner.inputHash) }));
+  if (!rows.length) return { ...empty, retryOwners };
+  let written = 0;
+  const persisted = await upsertVectorsWithContentionRetry(
+    {
+      upsertVectors: () => {
+        try {
+          // A contention wait may allow document or runtime mutations. Revalidate each attempt.
+          if (!identityStillCurrent()) return Promise.resolve(ok(undefined));
+          const valid = rows.filter(({ owner }) => isCurrent(store, owner));
+          store.write(valid);
+          written = valid.length;
+          return Promise.resolve(ok(undefined));
+        } catch (cause) {
+          return Promise.resolve(
+            err(
+              "QUERY_FAILED",
+              cause instanceof Error ? cause.message : String(cause),
+              cause
+            )
+          );
+        }
+      },
+    },
+    [],
+    params.delays
+  );
+  if (!persisted.ok)
+    return {
+      ...empty,
+      retryOwners,
+      errors: isUpsertLockContention(persisted.error) ? 0 : rows.length,
+      contentionErrors: isUpsertLockContention(persisted.error)
+        ? rows.length
+        : 0,
+    };
+  return { ...empty, embedded: written, retryOwners };
+}