akm-cli 0.9.17-alpha.3 → 0.9.17-alpha.4

package/dist/sources/providers/index.js

@@ -1,14 +0,0 @@
-// This Source Code Form is subject to the terms of the Mozilla Public
-// License, v. 2.0. If a copy of the MPL was not distributed with this
-// file, You can obtain one at https://mozilla.org/MPL/2.0/.
-/**
- * Centralized source provider registration.
- *
- * Import this module (side-effect import) to register all built-in source
- * providers with the provider registry. This replaces the individual
- * side-effect imports that were duplicated in source-search.ts and source-show.ts.
- */
-import "./filesystem.js";
-import "./git.js";
-import "./npm.js";
-import "./website.js";

package/dist/storage/engines/sqlite-migrations.js

@@ -1,271 +0,0 @@
-// This Source Code Form is subject to the terms of the Mozilla Public
-// License, v. 2.0. If a copy of the MPL was not distributed with this
-// file, You can obtain one at https://mozilla.org/MPL/2.0/.
-/**
- * Shared SQLite migration engine.
- *
- * SQLite schemas evolve through this transaction-per-migration runner backed
- * by a `schema_migrations` ledger.
- *
- * This module factors that runner out once. Each caller supplies only its own
- * `MIGRATIONS` array.
- *
- * Ledger/transaction contract:
- *   - `id` is permanent and must never be reused.
- *   - Applied IDs must be an exact ordered prefix of the registry.
- *   - Each `up` body and its ledger insert commit in the same transaction.
- *   - Migration bodies run only after `BEGIN IMMEDIATE` is observably active,
- *     and the transaction must remain active through the body's completion.
- *   - The caller owns semantic safety classification and any policy gate;
- *     this generic engine intentionally does not infer risk from SQL text.
- */
-import { sleepSync } from "../../runtime.js";
-export function assertMigrationRegistry(migrations) {
-    const seen = new Set();
-    for (const migration of migrations) {
-        if (seen.has(migration.id))
-            throw new Error(`Migration registry contains duplicate ID ${migration.id}.`);
-        seen.add(migration.id);
-    }
-}
-export function migrationLedgerExists(db) {
-    return !!db.prepare("SELECT 1 FROM sqlite_master WHERE type = 'table' AND name = 'schema_migrations'").get();
-}
-/** Inspect the database's applied IDs against the exact ordered registry prefix. */
-function inspectLedgerAgainst(db, registryIds) {
-    if (!migrationLedgerExists(db))
-        return { status: registryIds.length === 0 ? "current" : "old", migrationIds: [] };
-    const rows = db.prepare("SELECT id FROM schema_migrations ORDER BY rowid").all();
-    const migrationIds = rows.map((row) => row.id);
-    for (const [index, row] of rows.entries()) {
-        const expectedId = registryIds[index];
-        // Every id this binary knows matched in order and the ledger carries more:
-        // the database was migrated by a newer akm. Nothing here is applicable —
-        // this binary's whole registry is already applied — so this is version
-        // skew, not divergence.
-        if (!expectedId) {
-            return {
-                status: "newer",
-                migrationIds,
-                detail: `applied migration ID${rows.length - registryIds.length === 1 ? "" : "s"} ${migrationIds
-                    .slice(registryIds.length)
-                    .join(", ")} unknown to this akm`,
-            };
-        }
-        // A mismatch at a position this binary has a migration for is divergence,
-        // whether or not the id is one this binary knows later: this binary's
-        // migration at `index` was never applied, and something else was.
-        if (row.id !== expectedId) {
-            return {
-                status: "inconsistent",
-                migrationIds,
-                detail: `migration ledger is not an exact ordered prefix at position ${index + 1} (found '${row.id}', expected '${expectedId}'). ` +
-                    `Applied, in order: [${migrationIds.join(", ")}]. This akm's expected order: [${registryIds.join(", ")}].`,
-            };
-        }
-    }
-    return {
-        status: rows.length === registryIds.length ? "current" : "old",
-        migrationIds,
-    };
-}
-export function inspectMigrationLedger(db, migrations) {
-    assertMigrationRegistry(migrations);
-    return inspectLedgerAgainst(db, migrations.map((migration) => migration.id));
-}
-/**
- * Reject only a ledger this binary cannot reason about at all.
- *
- * A `newer` ledger — an exact ordered prefix of this binary's registry plus
- * migrations a later akm added — is NOT rejected. Two akm versions sharing one
- * data directory is a supported deployment (a bundled CLI alongside a newer
- * global install), and refusing the open bricked the older one for every
- * command while protecting nothing: its entire registry is already applied, so
- * it has no pending migration to run. Callers that want to tell an operator
- * about the skew read {@link MigrationLedgerState.status}.
- *
- * A `inconsistent` ledger is different: this binary has a migration that was
- * never applied and something else was applied in its place, so running the
- * pending set could conflict with schema it cannot see. That still refuses.
- */
-export function assertMigrationLedger(db, migrations) {
-    const state = inspectMigrationLedger(db, migrations);
-    if (state.status === "inconsistent") {
-        throw new Error(`Refusing a database whose migrations are not an exact ordered prefix: ${state.detail} ` +
-            "Applying this binary's missing migration now could run it against a schema a later migration already " +
-            "changed underneath it, which is a real risk of producing a wrong schema — not something akm can guess " +
-            "its way out of safely. This usually means the database was migrated by an incompatible akm build or " +
-            "fork, or schema_migrations was edited by hand. Restore this file from a backup taken before the " +
-            "divergence, or — if there is no backup and the data is not needed — delete it and let akm rebuild it " +
-            "from scratch (a derived index.db regenerates from your sources on the next 'akm index'; state.db loses " +
-            "durable history such as improve/proposal state and must be treated as a last resort).");
-    }
-    return state;
-}
-/**
- * Create the migrations ledger table if it does not exist. Must be called
- * unconditionally on every open so a fresh database bootstraps correctly.
- */
-export function ensureMigrationsTable(db) {
-    db.exec(`
-    CREATE TABLE IF NOT EXISTS schema_migrations (
-      id         TEXT    PRIMARY KEY,
-      applied_at TEXT    NOT NULL DEFAULT (datetime('now'))
-    );
-  `);
-}
-/**
- * Apply every pending migration, normally one transaction per migration.
- *
- * Each migration is applied in its own transaction so a failure in migration N
- * does not roll back already-applied migrations 1..N-1. The migration row is
- * inserted after the DDL succeeds in the same transaction, so a crash rolls
- * back both that migration's SQL and its ledger row. A caller may explicitly
- * group the initial prefix when ledger initialization and dependent early
- * migrations form one safety boundary.
- *
- * @param db          The open SQLite database.
- * @param migrations  The module's ordered, append-only migration list.
- * @param opts        Migration execution options.
- */
-export function runMigrations(db, migrations, opts) {
-    assertMigrationRegistry(migrations);
-    const lockedPrefixThrough = opts?.lockInitialMigrationPrefixThrough;
-    const lockedPrefixEnd = lockedPrefixThrough
-        ? migrations.findIndex((migration) => migration.id === lockedPrefixThrough)
-        : -1;
-    if (lockedPrefixThrough && lockedPrefixEnd < 0) {
-        throw new Error(`Initial locked migration prefix ends at unknown migration ID ${lockedPrefixThrough}.`);
-    }
-    if (lockedPrefixEnd >= 0) {
-        withImmediateWriteLock(db, () => {
-            if (!migrationLedgerExists(db)) {
-                opts?.beforeLedgerInitializationLocked?.(db);
-                ensureMigrationsTable(db);
-            }
-            assertMigrationLedger(db, migrations);
-            for (const migration of migrations.slice(0, lockedPrefixEnd + 1)) {
-                const already = db.prepare("SELECT 1 FROM schema_migrations WHERE id = ?").get(migration.id);
-                if (already)
-                    continue;
-                opts?.beforeMigration?.(migration);
-                opts?.beforeMigrationLocked?.(migration, db);
-                db.exec(migration.up);
-                db.prepare("INSERT INTO schema_migrations (id) VALUES (?)").run(migration.id);
-            }
-        });
-        assertMigrationLedger(db, migrations);
-    }
-    else if (migrationLedgerExists(db)) {
-        assertMigrationLedger(db, migrations);
-    }
-    else {
-        withImmediateWriteLock(db, () => {
-            if (migrationLedgerExists(db))
-                return;
-            opts?.beforeLedgerInitializationLocked?.(db);
-            ensureMigrationsTable(db);
-        });
-        assertMigrationLedger(db, migrations);
-    }
-    const appliedRows = db.prepare("SELECT id FROM schema_migrations ORDER BY rowid").all();
-    const applied = new Set(appliedRows.map((r) => r.id));
-    for (const migration of migrations) {
-        if (applied.has(migration.id))
-            continue;
-        opts?.beforeMigration?.(migration);
-        withImmediateWriteLock(db, () => {
-            // Re-check under the write lock. `applied` is a snapshot taken before the
-            // loop, so two processes bootstrapping the same fresh DB concurrently
-            // (both see existed=false) could each decide
-            // to apply migration N. The first commits; the second must not re-run the
-            // DDL and must not hit a UNIQUE violation on the ledger insert.
-            const already = db.prepare("SELECT 1 FROM schema_migrations WHERE id = ?").get(migration.id);
-            if (already)
-                return;
-            opts?.beforeMigrationLocked?.(migration, db);
-            db.exec(migration.up);
-            db.prepare("INSERT INTO schema_migrations (id) VALUES (?)").run(migration.id);
-        });
-        applied.add(migration.id);
-    }
-}
-/** Attempts to acquire the write lock before giving up to the caller. */
-const IMMEDIATE_LOCK_MAX_ATTEMPTS = 5;
-function isRetryableImmediateBeginError(error) {
-    const message = (error instanceof Error ? error.message : String(error)).toLowerCase();
-    return (message.includes("database is locked") ||
-        message.includes("database table is locked") ||
-        message.includes("did not open a transaction"));
-}
-function sleepImmediateRetry(ms) {
-    if (ms <= 0)
-        return;
-    sleepSync(ms);
-}
-/**
- * Run `fn` inside a `BEGIN IMMEDIATE` transaction.
- *
- * The write lock is taken up front rather than upgraded from a read lock, so a
- * second process bootstrapping the same database WAITS for the first to commit
- * instead of racing it. `db.transaction()` opens a DEFERRED transaction, which
- * only takes the write lock on first write — leaving the read-then-write gap
- * this guards.
- *
- * Deliberately local rather than reusing `withImmediateTransaction` from
- * core/state-db: that module imports this one, so the dependency cannot be
- * pointed the other way.
- */
-function withImmediateWriteLock(db, fn) {
-    if (db.inTransaction) {
-        fn();
-        return;
-    }
-    let lastBeginErr;
-    for (let attempt = 1; attempt <= IMMEDIATE_LOCK_MAX_ATTEMPTS; attempt++) {
-        try {
-            db.exec("BEGIN IMMEDIATE");
-            if (!db.inTransaction) {
-                throw new Error("BEGIN IMMEDIATE did not open a transaction (phantom contention state)");
-            }
-        }
-        catch (err) {
-            lastBeginErr = err;
-            if (isRetryableImmediateBeginError(err) && attempt < IMMEDIATE_LOCK_MAX_ATTEMPTS) {
-                if (db.inTransaction) {
-                    try {
-                        db.exec("ROLLBACK");
-                    }
-                    catch {
-                        // Transaction already gone; retrying is safe because fn has not run.
-                    }
-                }
-                sleepImmediateRetry(2 ** (attempt - 1));
-                continue;
-            }
-            throw err;
-        }
-        try {
-            fn();
-            if (!db.inTransaction) {
-                throw new Error("Migration write lock invariant violated: transaction opened by BEGIN IMMEDIATE was no longer active after the migration body ran; refusing to COMMIT (writes may have escaped serialization)");
-            }
-            db.exec("COMMIT");
-            return;
-        }
-        catch (err) {
-            if (db.inTransaction) {
-                try {
-                    db.exec("ROLLBACK");
-                }
-                catch {
-                    // Already rolled back by SQLite (e.g. the statement aborted the txn).
-                }
-            }
-            throw err;
-        }
-    }
-    throw lastBeginErr instanceof Error
-        ? lastBeginErr
-        : new Error(`could not acquire the migration write lock after ${IMMEDIATE_LOCK_MAX_ATTEMPTS} attempts`);
-}

package/dist/storage/repositories/canaries-repository.js

@@ -1,107 +0,0 @@
-// This Source Code Form is subject to the terms of the Mozilla Public
-// License, v. 2.0. If a copy of the MPL was not distributed with this
-// file, You can obtain one at https://mozilla.org/MPL/2.0/.
-/** Insert a freshly minted canary set (all rows active, one shared set id). */
-export function insertCanaries(db, canarySetId, canaries, now) {
-    if (canaries.length === 0)
-        return;
-    const ts = now ?? new Date().toISOString();
-    const stmt = db.prepare(`
-    INSERT INTO canary_queries (canary_set_id, anchor_ref, query, source, active, created_at)
-    VALUES (?, ?, ?, ?, 1, ?)
-  `);
-    db.transaction(() => {
-        for (const c of canaries) {
-            stmt.run(canarySetId, c.anchorRef, c.query, c.source ?? "auto", ts);
-        }
-    })();
-}
-/** Load the active canary set (empty array = never minted). */
-export function getActiveCanaries(db) {
-    // Scope to the NEWEST active set: if an interrupted refresh (or a bug) ever
-    // leaves two sets active, mixing their rows would silently corrupt the
-    // recall/entropy trend baselines. The newest set wins; stale-active rows are
-    // simply never returned.
-    return db
-        .prepare(`SELECT * FROM canary_queries
-       WHERE active = 1 AND canary_set_id = (
-         SELECT canary_set_id FROM canary_queries WHERE active = 1
-         ORDER BY created_at DESC, id DESC LIMIT 1
-       )
-       ORDER BY id`)
-        .all();
-}
-/** Load one canary set's rows by its exact set id (any active state), insertion order. */
-export function getCanariesBySetId(db, canarySetId) {
-    return db
-        .prepare(`SELECT * FROM canary_queries WHERE canary_set_id = ? ORDER BY id`)
-        .all(canarySetId);
-}
-/** List every distinct canary_set_id that still has active rows. */
-export function listActiveCanarySetIds(db) {
-    const rows = db.prepare(`SELECT DISTINCT canary_set_id FROM canary_queries WHERE active = 1`).all();
-    return rows.map((r) => r.canary_set_id);
-}
-/**
- * Deactivate every canary row in a set. Rows are RETAINED (active = 0) so
- * historical improve_cycle_metrics rows keyed on the old canary_set_id stay
- * interpretable; only `bun scripts/refresh-canary-set.ts --refresh` calls this.
- */
-export function deactivateCanarySet(db, canarySetId) {
-    const result = db
-        .prepare(`UPDATE canary_queries SET active = 0 WHERE canary_set_id = ? AND active = 1`)
-        .run(canarySetId);
-    const changes = result.changes ?? 0;
-    return typeof changes === "bigint" ? Number(changes) : changes;
-}
-/** Persist one qualifying cycle's store-health snapshot. */
-export function insertCycleMetrics(db, row) {
-    db.prepare(`
-    INSERT INTO improve_cycle_metrics
-      (run_id, ts, pass, canary_set_id, mean_recall, mean_ndcg, mean_mrr,
-       canary_ranks_json, store_total, store_by_type_json, distinct_content_ratio,
-       mean_bigram_diversity, over_generation_count, accepted_actions,
-       merge_floor_violations, alerts_json)
-    VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
-  `).run(row.run_id, row.ts, row.pass, row.canary_set_id, row.mean_recall, row.mean_ndcg, row.mean_mrr, row.canary_ranks_json, row.store_total, row.store_by_type_json, row.distinct_content_ratio, row.mean_bigram_diversity, row.over_generation_count, row.accepted_actions, row.merge_floor_violations, row.alerts_json);
-}
-/**
- * Load the most recent cycle rows for one canary set, OLDEST-first (the alert
- * evaluator's window order). Scoped by canary_set_id so trends never compare
- * across canary re-mints.
- */
-export function queryRecentCycleMetrics(db, canarySetId, limit) {
-    const rows = db
-        .prepare(`SELECT run_id, ts, pass, canary_set_id, mean_recall, mean_ndcg, mean_mrr,
-              canary_ranks_json, store_total, store_by_type_json, distinct_content_ratio,
-              mean_bigram_diversity, over_generation_count, accepted_actions,
-              merge_floor_violations, alerts_json
-       FROM improve_cycle_metrics WHERE canary_set_id = ?
-       ORDER BY ts DESC, id DESC LIMIT ?`)
-        .all(canarySetId, Math.max(0, limit));
-    return rows.reverse();
-}
-/** Load the single most recent cycle row across all canary sets (health surface). */
-export function getLatestCycleMetrics(db) {
-    const row = db
-        .prepare(`SELECT run_id, ts, pass, canary_set_id, mean_recall, mean_ndcg, mean_mrr,
-              canary_ranks_json, store_total, store_by_type_json, distinct_content_ratio,
-              mean_bigram_diversity, over_generation_count, accepted_actions,
-              merge_floor_violations, alerts_json
-       FROM improve_cycle_metrics ORDER BY ts DESC, id DESC LIMIT 1`)
-        .get();
-    return row == null ? undefined : row;
-}
-/**
- * Delete cycle rows older than `retentionDays` (default 365 — owner-approved;
- * a slow collapse needs a longer trend window than the 90-day events log).
- * Returns the purged row count. canary_queries rows are never purged.
- */
-export function purgeOldCycleMetrics(db, retentionDays = 365) {
-    if (!Number.isFinite(retentionDays) || retentionDays <= 0)
-        return 0;
-    const cutoff = new Date(Date.now() - retentionDays * 86_400_000).toISOString();
-    const result = db.prepare("DELETE FROM improve_cycle_metrics WHERE ts < ?").run(cutoff);
-    const changes = result.changes ?? 0;
-    return typeof changes === "bigint" ? Number(changes) : changes;
-}

package/dist/storage/repositories/embedding-salvage-repository.js

@@ -1,184 +0,0 @@
-// This Source Code Form is subject to the terms of the Mozilla Public
-// License, v. 2.0. If a copy of the MPL was not distributed with this
-// file, You can obtain one at https://mozilla.org/MPL/2.0/.
-/**
- * `index.db` embedding salvage (#955) — a transient, self-emptying table
- * that lets a full rebuild or an index-generation bump reuse vectors instead
- * of re-embedding a corpus whose content did not change.
- *
- * Zero steady-state cost by design: this is NOT a second embedding cache.
- * Rows are copied aside only at the moment they would otherwise be discarded
- * wholesale — a full-index wipe (`persistDirRecords`) or a generation bump
- * (`rebuildIncompatibleIndexGeneration`) — and are consumed by the very next
- * embedding pass (`generateEmbeddingsForDb`). A pass that completes without
- * abort or circuit-break purges whatever is left; an interrupted pass leaves
- * the table for the next attempt to pick up.
- *
- * Reuse is keyed on `sha256(search_text)` plus the fingerprint the vector was
- * generated under — a fingerprint mismatch or a single-byte content change
- * both correctly fall through to a real provider call. `content_hash` is the
- * PRIMARY KEY (not `(content_hash, fingerprint)`) so relabeling a whole
- * generation's fingerprint after a canary "keep" verdict is one UPDATE, and a
- * hash colliding across two discards simply keeps the most recent copy —
- * salvage is a best-effort optimization, not a durable multi-generation
- * archive.
- */
-import { createHash } from "node:crypto";
-import { blobToEmbedding } from "./embeddings-repository.js";
-import { getMeta } from "./index-meta-repository.js";
-import { SQLITE_CHUNK_SIZE } from "./index-sql.js";
-/**
- * Create the salvage table. Additive-only DDL: it carries no bearing on the
- * `entries` generation fingerprint (`hasCanonicalEntrySchema`), so adding it
- * does not require an index-generation bump.
- */
-export function ensureEmbeddingSalvageTable(db) {
-    db.exec(`
-    CREATE TABLE IF NOT EXISTS embedding_salvage (
-      content_hash TEXT PRIMARY KEY,
-      fingerprint  TEXT NOT NULL,
-      embedding    BLOB NOT NULL,
-      salvaged_at  TEXT NOT NULL
-    );
-  `);
-}
-/** The one hash function salvage writes and reuse lookups must agree on. */
-export function hashEmbeddableText(searchText) {
-    return createHash("sha256").update(searchText, "utf8").digest("hex");
-}
-function tableExists(db, name) {
-    return db.prepare("SELECT 1 FROM sqlite_master WHERE type='table' AND name=?").get(name) != null;
-}
-function tableHasColumn(db, table, column) {
-    const columns = db.prepare(`PRAGMA table_info(${table})`).all();
-    return columns.some((c) => c.name === column);
-}
-/**
- * Copy every (hash of search_text, embedding) pair about to be discarded
- * wholesale into `embedding_salvage`, tagged with the `embeddingFingerprint`
- * the discarded vectors were generated under. The caller MUST run this
- * inside the same transaction as the discard that follows it, so the copy
- * and the delete commit or roll back together.
- *
- * Streams `entries JOIN embeddings` in id-ordered pages of
- * {@link SQLITE_CHUNK_SIZE} instead of loading every row into memory before
- * hashing anything — a full rebuild of a large stash otherwise held the
- * entire corpus's search text and vectors in memory at once just to copy
- * them aside (#955, field-report follow-up).
- *
- * A no-op (returns 0) when there is no stored `embeddingFingerprint` to tag
- * rows with (nothing was ever verified against a provider, so there is
- * nothing worth reusing later) or the generation being discarded predates
- * the `entries.search_text` column or has no `embeddings` table at all — an
- * older generation than that has nothing this can safely read.
- */
-export function salvageEmbeddingsBeforeDiscard(db) {
-    const fingerprint = getMeta(db, "embeddingFingerprint");
-    if (!fingerprint)
-        return 0;
-    if (!tableExists(db, "entries") || !tableExists(db, "embeddings"))
-        return 0;
-    if (!tableHasColumn(db, "entries", "search_text"))
-        return 0;
-    const page = db.prepare("SELECT e.id AS id, e.search_text AS searchText, em.embedding AS embedding " +
-        "FROM entries e JOIN embeddings em ON em.id = e.id WHERE e.id > ? ORDER BY e.id LIMIT ?");
-    const insert = db.prepare("INSERT OR REPLACE INTO embedding_salvage (content_hash, fingerprint, embedding, salvaged_at) VALUES (?, ?, ?, ?)");
-    const salvagedAt = new Date().toISOString();
-    let lastId = 0;
-    let total = 0;
-    for (;;) {
-        const rows = page.all(lastId, SQLITE_CHUNK_SIZE);
-        if (rows.length === 0)
-            break;
-        for (const row of rows) {
-            insert.run(hashEmbeddableText(row.searchText), fingerprint, row.embedding, salvagedAt);
-        }
-        total += rows.length;
-        lastId = rows[rows.length - 1]?.id ?? lastId;
-        if (rows.length < SQLITE_CHUNK_SIZE)
-            break;
-    }
-    return total;
-}
-/**
- * Remove every salvage row. Called after an embedding pass completes without
- * abort or circuit-break (the salvaged generation has now either been reused
- * or superseded), and by `--reembed` / a canary "rebuild" verdict (the
- * salvaged vectors belong to a different model and are never reusable).
- */
-export function purgeEmbeddingSalvage(db) {
-    db.exec("DELETE FROM embedding_salvage");
-}
-/**
- * A canary "keep" verdict means the model did not actually change — only its
- * fingerprint STRING did (e.g. a gateway rename). Salvage rows tagged with
- * the old string are still valid vectors; rewrite them to the new string so
- * they remain reusable instead of silently going stale.
- */
-export function relabelEmbeddingSalvageFingerprint(db, fromFingerprint, toFingerprint) {
-    db.prepare("UPDATE embedding_salvage SET fingerprint = ? WHERE fingerprint = ?").run(toFingerprint, fromFingerprint);
-}
-/**
- * Reuse salvaged vectors for `entries` whose `searchText` hash matches a
- * salvage row tagged with the CURRENT `fingerprint` — never across
- * fingerprints, and never when `search_text` differs by even one byte (the
- * hash is exact-match only, by design). Matches are written via
- * `writeReused` in chunks of {@link SQLITE_CHUNK_SIZE}, each its own
- * transaction, mirroring the main pass's per-batch commit (#955) so an
- * interruption partway through the reuse step keeps whatever already wrote.
- *
- * The steady state of every ordinary run is an EMPTY salvage table (nothing
- * was just discarded), so this checks that first with one indexed lookup —
- * `SELECT 1 ... LIMIT 1` — before hashing a single pending entry. Hashing
- * every entry up front to look up a table that is empty 100% of the time
- * outside a rebuild was pure wasted work on the common path (#955,
- * field-report follow-up).
- */
-export function reuseSalvagedEmbeddings(db, entries, fingerprint, writeReused) {
-    if (entries.length === 0)
-        return { reusedCount: 0, remaining: [] };
-    const anySalvageForFingerprint = db
-        .prepare("SELECT 1 FROM embedding_salvage WHERE fingerprint = ? LIMIT 1")
-        .get(fingerprint);
-    if (!anySalvageForFingerprint)
-        return { reusedCount: 0, remaining: [...entries] };
-    const hashes = entries.map((entry) => hashEmbeddableText(entry.searchText));
-    const salvageByHash = new Map();
-    const uniqueHashes = [...new Set(hashes)];
-    for (let offset = 0; offset < uniqueHashes.length; offset += SQLITE_CHUNK_SIZE) {
-        const chunk = uniqueHashes.slice(offset, offset + SQLITE_CHUNK_SIZE);
-        const placeholders = chunk.map(() => "?").join(",");
-        const rows = db
-            .prepare(`SELECT content_hash AS contentHash, embedding FROM embedding_salvage WHERE fingerprint = ? AND content_hash IN (${placeholders})`)
-            .all(fingerprint, ...chunk);
-        for (const row of rows)
-            salvageByHash.set(row.contentHash, row.embedding);
-    }
-    if (salvageByHash.size === 0)
-        return { reusedCount: 0, remaining: [...entries] };
-    let reusedCount = 0;
-    const remaining = [];
-    for (let offset = 0; offset < entries.length; offset += SQLITE_CHUNK_SIZE) {
-        const end = Math.min(offset + SQLITE_CHUNK_SIZE, entries.length);
-        const chunkMatches = [];
-        for (let i = offset; i < end; i++) {
-            const entry = entries[i];
-            const blob = salvageByHash.get(hashes[i]);
-            if (blob)
-                chunkMatches.push({ entry, blob });
-            else
-                remaining.push(entry);
-        }
-        if (chunkMatches.length === 0)
-            continue;
-        db.transaction(() => {
-            for (const { entry, blob } of chunkMatches) {
-                if (writeReused(entry, blobToEmbedding(blob)))
-                    reusedCount++;
-                else
-                    remaining.push(entry);
-            }
-        })();
-    }
-    return { reusedCount, remaining };
-}