@gmickel/gno 1.46.0 → 2.0.0

package/src/embed/backlog.ts

@@ -1,25 +1,35 @@
+import type { EmbeddingPort } from "../llm/types";
 /**
  * Shared embedding backlog processor.
  * Used by CLI embed, Web scheduler, and MCP tools.
  *
  * @module src/embed/backlog
  */
-
-import type { EmbeddingPort } from "../llm/types";
 import type { StoreResult } from "../store/types";
 import type {
   BacklogItem,
   VectorIndexPort,
   VectorStatsPort,
 } from "../store/vector";
+import type { VectorVariantStore } from "../store/vector/variants";
 
+import {
+  assertInferenceActive,
+  isBackgroundInference,
+} from "../llm/inference-scope";
 import { err, ok } from "../store/types";
-import { getEmbeddingFingerprint } from "./fingerprint";
+import { getVectorStatsDatabase } from "../store/vector/stats";
+import { createVectorVariantStore } from "../store/vector/variants";
+import {
+  getEmbeddingFingerprint,
+  getVariantModelFingerprint,
+} from "./fingerprint";
 import {
   chunkRetryKey,
   embedAndStoreBatch,
   MAX_EMBED_CHUNK_ATTEMPTS,
 } from "./retry";
+import { embedVariantBacklog } from "./variant-backlog";
 
 // ─────────────────────────────────────────────────────────────────────────────
 // Types
@@ -32,6 +42,11 @@ export interface EmbedBacklogDeps {
   collection?: string;
   modelUri: string;
   batchSize?: number;
+  force?: boolean;
+  onProgress?: (embedded: number, errors: number) => void;
+  variantStore?: VectorVariantStore;
+  /** Recheck the effective runtime identity after asynchronous inference. */
+  identityStillCurrent?: () => boolean;
 }
 
 export interface EmbedBacklogResult {
@@ -62,8 +77,16 @@ interface Cursor {
 export async function embedBacklog(
   deps: EmbedBacklogDeps
 ): Promise<StoreResult<EmbedBacklogResult>> {
+  assertInferenceActive();
+  const prepared = await prepareEmbeddingBacklog(deps);
+  if (!prepared.ok) return prepared;
+  deps = prepared.value;
+  if (deps.variantStore) return embedVariantBacklog(deps, deps.variantStore);
   const { statsPort, embedPort, vectorIndex, modelUri, collection } = deps;
-  const batchSize = deps.batchSize ?? 32;
+  const background = isBackgroundInference();
+  const batchSize = background
+    ? Math.min(deps.batchSize ?? 32, 32)
+    : (deps.batchSize ?? 32);
   const embedFingerprint = getEmbeddingFingerprint({
     modelUri,
     dimensions: vectorIndex.dimensions,
@@ -77,6 +100,7 @@ export async function embedBacklog(
 
   const enqueueRetryItems = (items: BacklogItem[], attempts: number): void => {
     for (const item of items) {
+      assertInferenceActive();
       const key = chunkRetryKey(item);
       const existing = retryQueue.get(key);
       retryQueue.set(key, {
@@ -97,8 +121,10 @@ export async function embedBacklog(
     );
 
     for (let idx = 0; idx < entries.length; idx += batchSize) {
+      assertInferenceActive();
       const slice = entries.slice(idx, idx + batchSize);
       for (const entry of slice) {
+        assertInferenceActive();
         retryQueue.delete(chunkRetryKey(entry.item));
         entry.attempts += 1;
       }
@@ -109,6 +135,8 @@ export async function embedBacklog(
         items: slice.map((entry) => entry.item),
         modelUri,
         embedFingerprint,
+        identityStillCurrent: deps.identityStillCurrent,
+        statsPort,
       });
 
       embedded += retryResult.embedded;
@@ -120,6 +148,7 @@ export async function embedBacklog(
         retryResult.retryItems.map((item) => chunkRetryKey(item))
       );
       for (const entry of slice) {
+        assertInferenceActive();
         if (!retryByKey.has(chunkRetryKey(entry.item))) {
           continue;
         }
@@ -136,6 +165,7 @@ export async function embedBacklog(
 
   try {
     while (true) {
+      assertInferenceActive();
       // Get next batch using seek pagination
       const batchResult = await statsPort.getBacklog(
         modelUri,
@@ -169,10 +199,20 @@ export async function embedBacklog(
         items: batch,
         modelUri,
         embedFingerprint,
+        identityStillCurrent: deps.identityStillCurrent,
+        statsPort,
       });
       embedded += batchStoreResult.embedded;
       errors += batchStoreResult.errors;
       contentionErrors += batchStoreResult.contentionErrors;
+      if (background) {
+        errors += batchStoreResult.retryItems.length;
+        deps.onProgress?.(embedded, errors);
+        // Each cursor page is a turn. Failed early pages cannot starve later work.
+        await Bun.sleep(0);
+        if (deps.identityStillCurrent && !deps.identityStillCurrent()) break;
+        continue;
+      }
       enqueueRetryItems(batchStoreResult.retryItems, 1);
 
       if (embedded > beforeEmbedded) {
@@ -198,6 +238,7 @@ export async function embedBacklog(
       }
     }
 
+    assertInferenceActive();
     return ok({ embedded, errors, contentionErrors, syncError });
   } catch (e) {
     return err(
@@ -206,3 +247,65 @@ export async function embedBacklog(
     );
   }
 }
+
+/** Resolve authority before counts, dry runs, forced work, or early returns. */
+export async function prepareEmbeddingBacklog(
+  deps: EmbedBacklogDeps
+): Promise<StoreResult<EmbedBacklogDeps>> {
+  if (deps.variantStore) return ok(deps);
+  const db = getVectorStatsDatabase(deps.statsPort);
+  if (db) {
+    try {
+      const initialized = await deps.embedPort.init();
+      if (!initialized.ok) return err("INTERNAL", initialized.error.message);
+      const identity = deps.embedPort.getIdentity?.();
+      if (identity) {
+        const identitySnapshot = JSON.stringify(identity);
+        const dimensions = deps.embedPort.dimensions();
+        const variantStore = await createVectorVariantStore(db, {
+          model: deps.modelUri,
+          modelFingerprint: getVariantModelFingerprint(
+            { modelUri: deps.modelUri, dimensions },
+            identity
+          ),
+          contextSize: identity.contextSize,
+          truncationPolicy: identity.truncationPolicy,
+          dimensions,
+        });
+        return ok({
+          ...deps,
+          variantStore,
+          identityStillCurrent: () =>
+            (deps.identityStillCurrent?.() ?? true) &&
+            deps.embedPort.modelUri === deps.modelUri &&
+            deps.embedPort.dimensions() === dimensions &&
+            JSON.stringify(deps.embedPort.getIdentity?.()) === identitySnapshot,
+        });
+      }
+      // Unverified/HTTP ports retain legacy behavior until variant authority exists.
+      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 = ? AND activated_epoch IS NOT NULL LIMIT 1"
+          )
+          .get(deps.modelUri, "active")
+      ) {
+        return err(
+          "INVALID_INPUT",
+          "Effective embedding identity unavailable after variant activation"
+        );
+      }
+    } catch (cause) {
+      return err(
+        "QUERY_FAILED",
+        cause instanceof Error ? cause.message : String(cause)
+      );
+    }
+  }
+  return ok(deps);
+}

package/src/embed/batch.ts

@@ -1,13 +1,17 @@
+import type { EmbeddingPort, LlmResult } from "../llm/types";
 /**
  * Shared embedding batch helpers.
  *
  * @module src/embed/batch
  */
 
-import type { EmbeddingPort, LlmResult } from "../llm/types";
-
 import { getEmbeddingCompatibilityProfile } from "../llm/embedding-compatibility";
 import { inferenceFailedError } from "../llm/errors";
+import {
+  assertInferenceActive,
+  assertInferenceResult,
+  isBackgroundInference,
+} from "../llm/inference-scope";
 
 export interface EmbedBatchRecoveryResult {
   vectors: Array<number[] | null>;
@@ -70,8 +74,26 @@ export async function embedTextsWithRecovery(
   }
 
   const profile = getEmbeddingCompatibilityProfile(embedPort.modelUri);
+  // A background page gets one provider attempt. Recovery remains durable for
+  // the next pass instead of expanding the current native scheduling turn.
+  if (isBackgroundInference() && profile.batchEmbeddingTrusted) {
+    const result = await embedPort.embedBatch(texts);
+    assertInferenceResult(result);
+    if (!result.ok) return result;
+    const complete = result.value.length === texts.length;
+    return {
+      ok: true,
+      value: {
+        vectors: complete ? result.value : texts.map(() => null),
+        batchFailed: !complete,
+        fallbackErrors: complete ? 0 : texts.length,
+        failureSamples: complete ? [] : ["Embedding count mismatch"],
+      },
+    };
+  }
   if (profile.batchEmbeddingTrusted) {
     let batchResult = await embedPort.embedBatch(texts);
+    assertInferenceResult(batchResult);
     if (!batchResult.ok) {
       const formattedBatchError = formatFailureMessage(batchResult.error);
       if (isDisposedFailure(formattedBatchError)) {
@@ -80,6 +102,7 @@ export async function embedTextsWithRecovery(
           return reset;
         }
         batchResult = await embedPort.embedBatch(texts);
+        assertInferenceResult(batchResult);
       }
     }
     if (batchResult.ok && batchResult.value.length === texts.length) {
@@ -166,6 +189,7 @@ async function recoverWithAdaptiveBatches(
 
       if (rangeTexts.length === 1) {
         const result = await embedPort.embed(rangeTexts[0] ?? "");
+        assertInferenceResult(result);
         if (result.ok) {
           vectors[offset] = result.value;
           return;
@@ -179,6 +203,7 @@ async function recoverWithAdaptiveBatches(
         null;
       if (!batchAlreadyFailed) {
         batchResult = await embedPort.embedBatch(rangeTexts);
+        assertInferenceResult(batchResult);
       }
       if (
         batchResult &&
@@ -186,6 +211,7 @@ async function recoverWithAdaptiveBatches(
         batchResult.value.length === rangeTexts.length
       ) {
         for (const [index, vector] of batchResult.value.entries()) {
+          assertInferenceActive();
           vectors[offset + index] = vector;
         }
         return;
@@ -223,6 +249,12 @@ async function recoverWithAdaptiveBatches(
       },
     };
   } catch (error) {
+    assertInferenceActive();
+    if (
+      error instanceof Error &&
+      ["AbortError", "TimeoutError"].includes(error.name)
+    )
+      throw error;
     return {
       ok: false,
       error: inferenceFailedError(
@@ -245,7 +277,9 @@ async function recoverIndividually(
     let fallbackErrors = 0;
 
     for (const text of texts) {
+      assertInferenceActive();
       const result = await embedPort.embed(text);
+      assertInferenceResult(result);
       if (result.ok) {
         vectors.push(result.value);
       } else {
@@ -266,6 +300,12 @@ async function recoverIndividually(
       },
     };
   } catch (error) {
+    assertInferenceActive();
+    if (
+      error instanceof Error &&
+      ["AbortError", "TimeoutError"].includes(error.name)
+    )
+      throw error;
     return {
       ok: false,
       error: inferenceFailedError(

package/src/embed/fingerprint.ts

@@ -35,3 +35,19 @@ export function getEmbeddingFingerprint(
     .update(JSON.stringify(payload))
     .digest("hex");
 }
+
+/** Partition provenance combines actual weights/runtime with the unchanged formatter policy. */
+export function getVariantModelFingerprint(
+  input: EmbeddingFingerprintInput,
+  identity: { modelFingerprint: string; runtimeFingerprint: string }
+): string {
+  return new Bun.CryptoHasher("sha256")
+    .update(
+      JSON.stringify([
+        identity.modelFingerprint,
+        identity.runtimeFingerprint,
+        getEmbeddingFingerprint(input),
+      ])
+    )
+    .digest("hex");
+}

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 };
+  }
+}