sliftutils 1.4.81 → 1.4.83

package/storage/proxydatabase/dist/ivfEmbeddingDatabase.ts.cache

@@ -0,0 +1,334 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true , configurable: true});
+//exports.removeEmbeddings = exports.insertEmbeddings = exports.searchEmbeddings = exports.rebuildStructure = void 0;
+const Database_1 = require("./Database");
+const transactionSet_1 = require("./transactionSet");
+const embeddingFormats_1 = require("../embeddingFormats");
+// Below this many embeddings we skip the IVF entirely (flat store). 1024 = a clean power of two.
+const FLAT_LIMIT = 1024;
+// Force a from-scratch rebuild once at each of these (multiples of 4 above FLAT_LIMIT, up to ~16k), gated by a step flag so each runs at most once ever.
+const REGENERATE_AT = [4096, 16384];
+const STEP_IVF = "ivf";
+// On delete, the member's exact cell plus this many nearby cells are checked, in case a rebuild left it non-optimal.
+const DELETE_FALLBACK_CELLS = 10;
+const REBALANCE_ITERATIONS = 4;
+function flatStore(database) {
+    return (0, Database_1.namespaceDatabase)(database, root => root.flat);
+}
+function centroidStore(database) {
+    return (0, Database_1.namespaceDatabase)(database, root => root.centroids);
+}
+function cellStore(database, cellId) {
+    return (0, Database_1.namespaceDatabase)(database, root => root.cells[cellId]);
+}
+function readSteps(database) {
+    var _a;
+    return (_a = database.readData(root => root.steps)) !== null && _a !== void 0 ? _a : {};
+}
+function readCount(database) {
+    var _a;
+    return (_a = database.readData(root => root.count)) !== null && _a !== void 0 ? _a : 0;
+}
+function rankCellsByCloseness(embedding, centroids) {
+    const ranked = [];
+    for (const cellId of centroids.keys()) {
+        ranked.push({ cellId, closeness: (0, embeddingFormats_1.getCloseness)(embedding, centroids.get(cellId)) });
+    }
+    ranked.sort((left, right) => right.closeness - left.closeness);
+    return ranked.map(entry => entry.cellId);
+}
+// Per-write chance of a full rebuild. Zero at/under the target size, then rises (cubically) past it so cells
+// stay roughly between target and ~2x target.
+function rebalanceProbability(fillRatio) {
+    if (fillRatio <= 1) {
+        return 0;
+    }
+    const over = fillRatio - 1;
+    return Math.min(1, over * over * over * 0.25);
+}
+// k-means. Decodes every member to a pooled float32 buffer ONCE, then assigns with a plain internal float
+// dot (no getCloseness call — comparing two float vectors is trivial) and keeps centroids as float means,
+// encoding them to StoredEmbedding only at the end. Releases the borrowed buffers when done.
+function clusterMembers(members, clusterCount, config) {
+    const memberFloats = [];
+    for (const member of members) {
+        memberFloats.push((0, embeddingFormats_1.embeddingToFloat32)(member.embedding, true));
+    }
+    const length = memberFloats.length ? memberFloats[0].length : 0;
+    let centroids = [];
+    const seedStep = members.length / clusterCount;
+    for (let clusterIndex = 0; clusterIndex < clusterCount; clusterIndex++) {
+        centroids.push(new Float32Array(memberFloats[Math.floor(clusterIndex * seedStep)]));
+    }
+    let groups = [];
+    for (let iteration = 0; iteration < REBALANCE_ITERATIONS; iteration++) {
+        groups = [];
+        for (let clusterIndex = 0; clusterIndex < centroids.length; clusterIndex++) {
+            groups.push([]);
+        }
+        for (let memberIndex = 0; memberIndex < memberFloats.length; memberIndex++) {
+            const memberFloat = memberFloats[memberIndex];
+            let bestIndex = 0;
+            let bestDot = -Infinity;
+            for (let centroidIndex = 0; centroidIndex < centroids.length; centroidIndex++) {
+                const centroidFloat = centroids[centroidIndex];
+                let dot = 0;
+                for (let dim = 0; dim < length; dim++) {
+                    dot += memberFloat[dim] * centroidFloat[dim];
+                }
+                if (dot > bestDot) {
+                    bestDot = dot;
+                    bestIndex = centroidIndex;
+                }
+            }
+            groups[bestIndex].push(memberIndex);
+        }
+        const nextCentroids = [];
+        const nextGroups = [];
+        for (const group of groups) {
+            if (!group.length) {
+                continue;
+            }
+            const mean = new Float32Array(length);
+            for (const memberIndex of group) {
+                const memberFloat = memberFloats[memberIndex];
+                for (let dim = 0; dim < length; dim++) {
+                    mean[dim] += memberFloat[dim];
+                }
+            }
+            let norm = 0;
+            for (let dim = 0; dim < length; dim++) {
+                norm += mean[dim] * mean[dim];
+            }
+            const magnitude = Math.sqrt(norm) || 1;
+            for (let dim = 0; dim < length; dim++) {
+                mean[dim] /= magnitude;
+            }
+            nextCentroids.push(mean);
+            nextGroups.push(group);
+        }
+        centroids = nextCentroids;
+        groups = nextGroups;
+    }
+    const result = [];
+    for (let clusterIndex = 0; clusterIndex < centroids.length; clusterIndex++) {
+        const centroid = (0, embeddingFormats_1.encodeEmbedding)({ input: centroids[clusterIndex], format: config.format, model: config.model });
+        const cellMembers = [];
+        for (const memberIndex of groups[clusterIndex]) {
+            cellMembers.push(members[memberIndex]);
+        }
+        result.push({ centroid, members: cellMembers });
+    }
+    for (const memberFloat of memberFloats) {
+        (0, embeddingFormats_1.releaseFloat32)(memberFloat);
+    }
+    return result;
+}
+// Re-cluster EVERY embedding (flat tier + all cells) into a fresh IVF, clear the flat tier, and mark IVF
+// mode. This is the rearranger: run probabilistically as the set grows, once at each regenerate threshold,
+// and once to upgrade from flat. Reads everything it uses, so it bails (does nothing) if anything isn't
+// synced and the caller's retry re-runs it; no caller cares about its result.
+function rebuildStructure(database) {
+    const config = database.readData(root => root.config);
+    if (!config)
+        return;
+    const allMembers = [];
+    const flat = (0, transactionSet_1.transactionRead)(flatStore(database));
+    if (!flat)
+        return;
+    for (const ref of flat.keys()) {
+        allMembers.push({ ref, embedding: flat.get(ref) });
+    }
+    const centroids = (0, transactionSet_1.transactionRead)(centroidStore(database));
+    if (!centroids)
+        return;
+    const oldCellIds = Array.from(centroids.keys());
+    const cellStores = database.readData(root => oldCellIds.map(cellId => root.cells[cellId]));
+    if (!cellStores)
+        return;
+    for (const store of cellStores) {
+        const members = (0, transactionSet_1.replayTransactionStore)(store);
+        for (const ref of members.keys()) {
+            allMembers.push({ ref, embedding: members.get(ref) });
+        }
+    }
+    if (!allMembers.length)
+        return;
+    const clusterCount = Math.max(1, Math.round(allMembers.length / config.cellTargetSize));
+    const clusters = clusterMembers(allMembers, clusterCount, config);
+    const newCellIds = new Set();
+    const centroidWrites = [];
+    for (const cluster of clusters) {
+        const cellId = (0, embeddingFormats_1.hashEmbedding)(cluster.centroid);
+        newCellIds.add(cellId);
+        centroidWrites.push({ key: cellId, value: cluster.centroid });
+        const memberWrites = cluster.members.map(member => ({ key: member.ref, value: member.embedding }));
+        (0, transactionSet_1.transactionMutate)(cellStore(database, cellId), memberWrites);
+    }
+    for (const oldCellId of oldCellIds) {
+        if (newCellIds.has(oldCellId)) {
+            continue;
+        }
+        centroidWrites.push({ key: oldCellId, value: undefined });
+        database.deleteData(root => root.cells[oldCellId]);
+    }
+    (0, transactionSet_1.transactionMutate)(centroidStore(database), centroidWrites);
+    database.deleteData(root => root.flat);
+    database.writeData(root => root.count, allMembers.length);
+    database.writeData(root => root.steps[STEP_IVF], true);
+}
+exports.rebuildStructure = rebuildStructure;
+function searchEmbeddings(database, query, options) {
+    const config = database.readData(root => root.config);
+    if (!config)
+        return undefined;
+    const steps = readSteps(database);
+    const hits = [];
+    if (!steps[STEP_IVF]) {
+        const flat = (0, transactionSet_1.transactionRead)(flatStore(database));
+        if (!flat)
+            return undefined;
+        for (const ref of flat.keys()) {
+            hits.push({ ref, closeness: (0, embeddingFormats_1.getCloseness)(query, flat.get(ref)) });
+        }
+        hits.sort((left, right) => right.closeness - left.closeness);
+        return hits.slice(0, options.resultCount);
+    }
+    const centroids = (0, transactionSet_1.transactionRead)(centroidStore(database));
+    if (!centroids)
+        return undefined;
+    if (!centroids.size)
+        return [];
+    const probeCellCount = Math.max(1, Math.ceil(options.probeBudget / config.cellTargetSize));
+    const probeCellIds = rankCellsByCloseness(query, centroids).slice(0, probeCellCount);
+    const stores = database.readData(root => probeCellIds.map(cellId => root.cells[cellId]));
+    if (!stores)
+        return undefined;
+    for (const store of stores) {
+        const members = (0, transactionSet_1.replayTransactionStore)(store);
+        for (const ref of members.keys()) {
+            hits.push({ ref, closeness: (0, embeddingFormats_1.getCloseness)(query, members.get(ref)) });
+        }
+    }
+    hits.sort((left, right) => right.closeness - left.closeness);
+    return hits.slice(0, options.resultCount);
+}
+exports.searchEmbeddings = searchEmbeddings;
+function insertEmbeddings(database, items) {
+    if (!items.length)
+        return true;
+    const config = database.readData(root => root.config);
+    if (!config)
+        return undefined;
+    const steps = readSteps(database);
+    const newCount = readCount(database) + items.length;
+    if (!steps[STEP_IVF]) {
+        const flatWrites = items.map(item => ({ key: item.ref, value: item.embedding }));
+        (0, transactionSet_1.transactionMutate)(flatStore(database), flatWrites);
+        database.writeData(root => root.count, newCount);
+        if (newCount > FLAT_LIMIT) {
+            rebuildStructure(database);
+        }
+        return true;
+    }
+    const centroids = (0, transactionSet_1.transactionRead)(centroidStore(database));
+    if (!centroids)
+        return undefined;
+    const itemsByCell = new Map();
+    for (const item of items) {
+        const cellId = rankCellsByCloseness(item.embedding, centroids)[0];
+        let group = itemsByCell.get(cellId);
+        if (!group) {
+            group = [];
+            itemsByCell.set(cellId, group);
+        }
+        group.push(item);
+    }
+    for (const cellId of itemsByCell.keys()) {
+        const group = itemsByCell.get(cellId);
+        const memberWrites = group.map(item => ({ key: item.ref, value: item.embedding }));
+        (0, transactionSet_1.transactionMutate)(cellStore(database, cellId), memberWrites);
+    }
+    database.writeData(root => root.count, newCount);
+    let regenerated = false;
+    for (const threshold of REGENERATE_AT) {
+        const stepName = "regen" + threshold;
+        if (!steps[stepName] && newCount > threshold) {
+            rebuildStructure(database);
+            database.writeData(root => root.steps[stepName], true);
+            regenerated = true;
+        }
+    }
+    if (!regenerated) {
+        const averageFill = newCount / Math.max(1, centroids.size) / config.cellTargetSize;
+        if (Math.random() < rebalanceProbability(averageFill)) {
+            rebuildStructure(database);
+        }
+    }
+    return true;
+}
+exports.insertEmbeddings = insertEmbeddings;
+function removeEmbeddings(database, items) {
+    if (!items.length)
+        return true;
+    const steps = readSteps(database);
+    const count = readCount(database);
+    if (!steps[STEP_IVF]) {
+        const flatDeletes = items.map(item => ({ key: item.ref, value: undefined }));
+        (0, transactionSet_1.transactionMutate)(flatStore(database), flatDeletes);
+        database.writeData(root => root.count, Math.max(0, count - items.length));
+        return true;
+    }
+    const centroids = (0, transactionSet_1.transactionRead)(centroidStore(database));
+    if (!centroids)
+        return undefined;
+    if (!centroids.size)
+        return true;
+    const candidatesByItem = [];
+    const candidateSet = new Set();
+    for (const item of items) {
+        const cellIds = rankCellsByCloseness(item.embedding, centroids).slice(0, 1 + DELETE_FALLBACK_CELLS);
+        candidatesByItem.push({ ref: item.ref, cellIds });
+        for (const cellId of cellIds) {
+            candidateSet.add(cellId);
+        }
+    }
+    const candidateCellIds = Array.from(candidateSet);
+    const stores = database.readData(root => candidateCellIds.map(cellId => root.cells[cellId]));
+    if (!stores)
+        return undefined;
+    const membersByCell = new Map();
+    for (let index = 0; index < candidateCellIds.length; index++) {
+        membersByCell.set(candidateCellIds[index], (0, transactionSet_1.replayTransactionStore)(stores[index]));
+    }
+    const deletesByCell = new Map();
+    for (const candidate of candidatesByItem) {
+        for (const cellId of candidate.cellIds) {
+            const members = membersByCell.get(cellId);
+            if (!members || !members.has(candidate.ref)) {
+                continue;
+            }
+            let refs = deletesByCell.get(cellId);
+            if (!refs) {
+                refs = [];
+                deletesByCell.set(cellId, refs);
+            }
+            refs.push(candidate.ref);
+            break;
+        }
+    }
+    let deletedCount = 0;
+    for (const cellId of deletesByCell.keys()) {
+        const refs = deletesByCell.get(cellId);
+        deletedCount += refs.length;
+        const memberDeletes = refs.map(ref => ({ key: ref, value: undefined }));
+        (0, transactionSet_1.transactionMutate)(cellStore(database, cellId), memberDeletes);
+    }
+    if (deletedCount) {
+        database.writeData(root => root.count, Math.max(0, count - deletedCount));
+    }
+    return true;
+}
+exports.removeEmbeddings = removeEmbeddings;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"ivfEmbeddingDatabase.js","sourceRoot":"","sources":["ivfEmbeddingDatabase.ts"],"names":[],"mappings":"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","sourcesContent":["import { Database, namespaceDatabase } from \"./Database\";\nimport { TransactionSetStore, transactionRead, transactionMutate, replayTransactionStore } from \"./transactionSet\";\nimport { StoredEmbedding, EmbeddingFormat, getCloseness, embeddingToFloat32, releaseFloat32, encodeEmbedding, hashEmbedding } from \"../embeddingFormats\";\n\nexport type IvfConfig = {\n    model: string;\n    format: EmbeddingFormat;\n    // Target number of embeddings per cell.\n    cellTargetSize: number;\n};\n\n// Tiered storage. Below FLAT_LIMIT embeddings the whole set lives in one flat transaction set (no IVF);\n// once it grows past that we build the IVF (centroids + per-cell sets) and stay there forever. `count` is\n// the live embedding count (re-derived exactly on a rebuild). `steps` records one-time upgrades that must\n// never re-run even if the set later shrinks and regrows.\nexport type IvfEmbeddingRoot = {\n    config: IvfConfig;\n    count: number;\n    flat: TransactionSetStore<StoredEmbedding>;\n    steps: { [step: string]: boolean };\n    centroids: TransactionSetStore<StoredEmbedding>;\n    cells: { [cellId: string]: TransactionSetStore<StoredEmbedding> };\n};\n\nexport type EmbeddingInput = { ref: string; embedding: StoredEmbedding };\nexport type SearchHit = { ref: string; closeness: number };\ntype CellEntry = { ref: string; embedding: StoredEmbedding };\n\n// Below this many embeddings we skip the IVF entirely (flat store). 1024 = a clean power of two.\nconst FLAT_LIMIT = 1024;\n// Force a from-scratch rebuild once at each of these (multiples of 4 above FLAT_LIMIT, up to ~16k), gated by a step flag so each runs at most once ever.\nconst REGENERATE_AT = [4096, 16384];\nconst STEP_IVF = \"ivf\";\n// On delete, the member's exact cell plus this many nearby cells are checked, in case a rebuild left it non-optimal.\nconst DELETE_FALLBACK_CELLS = 10;\nconst REBALANCE_ITERATIONS = 4;\n\nfunction flatStore(database: Database<IvfEmbeddingRoot>): Database<TransactionSetStore<StoredEmbedding>> {\n    return namespaceDatabase(database, root => root.flat);\n}\nfunction centroidStore(database: Database<IvfEmbeddingRoot>): Database<TransactionSetStore<StoredEmbedding>> {\n    return namespaceDatabase(database, root => root.centroids);\n}\nfunction cellStore(database: Database<IvfEmbeddingRoot>, cellId: string): Database<TransactionSetStore<StoredEmbedding>> {\n    return namespaceDatabase(database, root => root.cells[cellId]);\n}\n\nfunction readSteps(database: Database<IvfEmbeddingRoot>): { [step: string]: boolean } {\n    return database.readData(root => root.steps) ?? {};\n}\nfunction readCount(database: Database<IvfEmbeddingRoot>): number {\n    return database.readData(root => root.count) ?? 0;\n}\n\nfunction rankCellsByCloseness(embedding: StoredEmbedding, centroids: Map<string, StoredEmbedding>): string[] {\n    const ranked: { cellId: string; closeness: number }[] = [];\n    for (const cellId of centroids.keys()) {\n        ranked.push({ cellId, closeness: getCloseness(embedding, centroids.get(cellId)!) });\n    }\n    ranked.sort((left, right) => right.closeness - left.closeness);\n    return ranked.map(entry => entry.cellId);\n}\n\n// Per-write chance of a full rebuild. Zero at/under the target size, then rises (cubically) past it so cells\n// stay roughly between target and ~2x target.\nfunction rebalanceProbability(fillRatio: number): number {\n    if (fillRatio <= 1) {\n        return 0;\n    }\n    const over = fillRatio - 1;\n    return Math.min(1, over * over * over * 0.25);\n}\n\n// k-means. Decodes every member to a pooled float32 buffer ONCE, then assigns with a plain internal float\n// dot (no getCloseness call — comparing two float vectors is trivial) and keeps centroids as float means,\n// encoding them to StoredEmbedding only at the end. Releases the borrowed buffers when done.\nfunction clusterMembers(members: CellEntry[], clusterCount: number, config: IvfConfig): { centroid: StoredEmbedding; members: CellEntry[] }[] {\n    const memberFloats: Float32Array[] = [];\n    for (const member of members) {\n        memberFloats.push(embeddingToFloat32(member.embedding, true));\n    }\n    const length = memberFloats.length ? memberFloats[0].length : 0;\n    let centroids: Float32Array[] = [];\n    const seedStep = members.length / clusterCount;\n    for (let clusterIndex = 0; clusterIndex < clusterCount; clusterIndex++) {\n        centroids.push(new Float32Array(memberFloats[Math.floor(clusterIndex * seedStep)]));\n    }\n    let groups: number[][] = [];\n    for (let iteration = 0; iteration < REBALANCE_ITERATIONS; iteration++) {\n        groups = [];\n        for (let clusterIndex = 0; clusterIndex < centroids.length; clusterIndex++) {\n            groups.push([]);\n        }\n        for (let memberIndex = 0; memberIndex < memberFloats.length; memberIndex++) {\n            const memberFloat = memberFloats[memberIndex];\n            let bestIndex = 0;\n            let bestDot = -Infinity;\n            for (let centroidIndex = 0; centroidIndex < centroids.length; centroidIndex++) {\n                const centroidFloat = centroids[centroidIndex];\n                let dot = 0;\n                for (let dim = 0; dim < length; dim++) {\n                    dot += memberFloat[dim] * centroidFloat[dim];\n                }\n                if (dot > bestDot) {\n                    bestDot = dot;\n                    bestIndex = centroidIndex;\n                }\n            }\n            groups[bestIndex].push(memberIndex);\n        }\n        const nextCentroids: Float32Array[] = [];\n        const nextGroups: number[][] = [];\n        for (const group of groups) {\n            if (!group.length) {\n                continue;\n            }\n            const mean = new Float32Array(length);\n            for (const memberIndex of group) {\n                const memberFloat = memberFloats[memberIndex];\n                for (let dim = 0; dim < length; dim++) {\n                    mean[dim] += memberFloat[dim];\n                }\n            }\n            let norm = 0;\n            for (let dim = 0; dim < length; dim++) {\n                norm += mean[dim] * mean[dim];\n            }\n            const magnitude = Math.sqrt(norm) || 1;\n            for (let dim = 0; dim < length; dim++) {\n                mean[dim] /= magnitude;\n            }\n            nextCentroids.push(mean);\n            nextGroups.push(group);\n        }\n        centroids = nextCentroids;\n        groups = nextGroups;\n    }\n    const result: { centroid: StoredEmbedding; members: CellEntry[] }[] = [];\n    for (let clusterIndex = 0; clusterIndex < centroids.length; clusterIndex++) {\n        const centroid = encodeEmbedding({ input: centroids[clusterIndex], format: config.format, model: config.model });\n        const cellMembers: CellEntry[] = [];\n        for (const memberIndex of groups[clusterIndex]) {\n            cellMembers.push(members[memberIndex]);\n        }\n        result.push({ centroid, members: cellMembers });\n    }\n    for (const memberFloat of memberFloats) {\n        releaseFloat32(memberFloat);\n    }\n    return result;\n}\n\n// Re-cluster EVERY embedding (flat tier + all cells) into a fresh IVF, clear the flat tier, and mark IVF\n// mode. This is the rearranger: run probabilistically as the set grows, once at each regenerate threshold,\n// and once to upgrade from flat. Reads everything it uses, so it bails (does nothing) if anything isn't\n// synced and the caller's retry re-runs it; no caller cares about its result.\nexport function rebuildStructure(database: Database<IvfEmbeddingRoot>): void {\n    const config = database.readData(root => root.config);\n    if (!config) return;\n\n    const allMembers: CellEntry[] = [];\n    const flat = transactionRead(flatStore(database));\n    if (!flat) return;\n    for (const ref of flat.keys()) {\n        allMembers.push({ ref, embedding: flat.get(ref)! });\n    }\n    const centroids = transactionRead(centroidStore(database));\n    if (!centroids) return;\n    const oldCellIds = Array.from(centroids.keys());\n    const cellStores = database.readData(root => oldCellIds.map(cellId => root.cells[cellId]));\n    if (!cellStores) return;\n    for (const store of cellStores) {\n        const members = replayTransactionStore<StoredEmbedding>(store);\n        for (const ref of members.keys()) {\n            allMembers.push({ ref, embedding: members.get(ref)! });\n        }\n    }\n    if (!allMembers.length) return;\n\n    const clusterCount = Math.max(1, Math.round(allMembers.length / config.cellTargetSize));\n    const clusters = clusterMembers(allMembers, clusterCount, config);\n\n    const newCellIds = new Set<string>();\n    const centroidWrites: { key: string; value: StoredEmbedding | undefined }[] = [];\n    for (const cluster of clusters) {\n        const cellId = hashEmbedding(cluster.centroid);\n        newCellIds.add(cellId);\n        centroidWrites.push({ key: cellId, value: cluster.centroid });\n        const memberWrites = cluster.members.map(member => ({ key: member.ref, value: member.embedding }));\n        transactionMutate(cellStore(database, cellId), memberWrites);\n    }\n    for (const oldCellId of oldCellIds) {\n        if (newCellIds.has(oldCellId)) {\n            continue;\n        }\n        centroidWrites.push({ key: oldCellId, value: undefined });\n        database.deleteData(root => root.cells[oldCellId]);\n    }\n    transactionMutate(centroidStore(database), centroidWrites);\n    database.deleteData(root => root.flat);\n    database.writeData(root => root.count, allMembers.length);\n    database.writeData(root => root.steps[STEP_IVF], true);\n}\n\nexport function searchEmbeddings(\n    database: Database<IvfEmbeddingRoot>,\n    query: StoredEmbedding,\n    options: { probeBudget: number; resultCount: number },\n): SearchHit[] | undefined {\n    const config = database.readData(root => root.config);\n    if (!config) return undefined;\n    const steps = readSteps(database);\n\n    const hits: SearchHit[] = [];\n    if (!steps[STEP_IVF]) {\n        const flat = transactionRead(flatStore(database));\n        if (!flat) return undefined;\n        for (const ref of flat.keys()) {\n            hits.push({ ref, closeness: getCloseness(query, flat.get(ref)!) });\n        }\n        hits.sort((left, right) => right.closeness - left.closeness);\n        return hits.slice(0, options.resultCount);\n    }\n\n    const centroids = transactionRead(centroidStore(database));\n    if (!centroids) return undefined;\n    if (!centroids.size) return [];\n    const probeCellCount = Math.max(1, Math.ceil(options.probeBudget / config.cellTargetSize));\n    const probeCellIds = rankCellsByCloseness(query, centroids).slice(0, probeCellCount);\n    const stores = database.readData(root => probeCellIds.map(cellId => root.cells[cellId]));\n    if (!stores) return undefined;\n    for (const store of stores) {\n        const members = replayTransactionStore<StoredEmbedding>(store);\n        for (const ref of members.keys()) {\n            hits.push({ ref, closeness: getCloseness(query, members.get(ref)!) });\n        }\n    }\n    hits.sort((left, right) => right.closeness - left.closeness);\n    return hits.slice(0, options.resultCount);\n}\n\nexport function insertEmbeddings(\n    database: Database<IvfEmbeddingRoot>,\n    items: EmbeddingInput[],\n): true | undefined {\n    if (!items.length) return true;\n    const config = database.readData(root => root.config);\n    if (!config) return undefined;\n    const steps = readSteps(database);\n    const newCount = readCount(database) + items.length;\n\n    if (!steps[STEP_IVF]) {\n        const flatWrites = items.map(item => ({ key: item.ref, value: item.embedding }));\n        transactionMutate(flatStore(database), flatWrites);\n        database.writeData(root => root.count, newCount);\n        if (newCount > FLAT_LIMIT) {\n            rebuildStructure(database);\n        }\n        return true;\n    }\n\n    const centroids = transactionRead(centroidStore(database));\n    if (!centroids) return undefined;\n    const itemsByCell = new Map<string, EmbeddingInput[]>();\n    for (const item of items) {\n        const cellId = rankCellsByCloseness(item.embedding, centroids)[0];\n        let group = itemsByCell.get(cellId);\n        if (!group) {\n            group = [];\n            itemsByCell.set(cellId, group);\n        }\n        group.push(item);\n    }\n    for (const cellId of itemsByCell.keys()) {\n        const group = itemsByCell.get(cellId)!;\n        const memberWrites = group.map(item => ({ key: item.ref, value: item.embedding }));\n        transactionMutate(cellStore(database, cellId), memberWrites);\n    }\n    database.writeData(root => root.count, newCount);\n\n    let regenerated = false;\n    for (const threshold of REGENERATE_AT) {\n        const stepName = \"regen\" + threshold;\n        if (!steps[stepName] && newCount > threshold) {\n            rebuildStructure(database);\n            database.writeData(root => root.steps[stepName], true);\n            regenerated = true;\n        }\n    }\n    if (!regenerated) {\n        const averageFill = newCount / Math.max(1, centroids.size) / config.cellTargetSize;\n        if (Math.random() < rebalanceProbability(averageFill)) {\n            rebuildStructure(database);\n        }\n    }\n    return true;\n}\n\nexport function removeEmbeddings(\n    database: Database<IvfEmbeddingRoot>,\n    items: EmbeddingInput[],\n): true | undefined {\n    if (!items.length) return true;\n    const steps = readSteps(database);\n    const count = readCount(database);\n\n    if (!steps[STEP_IVF]) {\n        const flatDeletes = items.map(item => ({ key: item.ref, value: undefined }));\n        transactionMutate(flatStore(database), flatDeletes);\n        database.writeData(root => root.count, Math.max(0, count - items.length));\n        return true;\n    }\n\n    const centroids = transactionRead(centroidStore(database));\n    if (!centroids) return undefined;\n    if (!centroids.size) return true;\n\n    const candidatesByItem: { ref: string; cellIds: string[] }[] = [];\n    const candidateSet = new Set<string>();\n    for (const item of items) {\n        const cellIds = rankCellsByCloseness(item.embedding, centroids).slice(0, 1 + DELETE_FALLBACK_CELLS);\n        candidatesByItem.push({ ref: item.ref, cellIds });\n        for (const cellId of cellIds) {\n            candidateSet.add(cellId);\n        }\n    }\n\n    const candidateCellIds = Array.from(candidateSet);\n    const stores = database.readData(root => candidateCellIds.map(cellId => root.cells[cellId]));\n    if (!stores) return undefined;\n    const membersByCell = new Map<string, Map<string, StoredEmbedding>>();\n    for (let index = 0; index < candidateCellIds.length; index++) {\n        membersByCell.set(candidateCellIds[index], replayTransactionStore(stores[index]));\n    }\n\n    const deletesByCell = new Map<string, string[]>();\n    for (const candidate of candidatesByItem) {\n        for (const cellId of candidate.cellIds) {\n            const members = membersByCell.get(cellId);\n            if (!members || !members.has(candidate.ref)) {\n                continue;\n            }\n            let refs = deletesByCell.get(cellId);\n            if (!refs) {\n                refs = [];\n                deletesByCell.set(cellId, refs);\n            }\n            refs.push(candidate.ref);\n            break;\n        }\n    }\n\n    let deletedCount = 0;\n    for (const cellId of deletesByCell.keys()) {\n        const refs = deletesByCell.get(cellId)!;\n        deletedCount += refs.length;\n        const memberDeletes = refs.map(ref => ({ key: ref, value: undefined }));\n        transactionMutate(cellStore(database, cellId), memberDeletes);\n    }\n    if (deletedCount) {\n        database.writeData(root => root.count, Math.max(0, count - deletedCount));\n    }\n    return true;\n}\n"]}
+ /* _JS_SOURCE_HASH = "6bb25c321db29d41be7eec5ac48ec8aad9563a1f8c7710e6700a8deb6ed719c9"; */

package/storage/proxydatabase/dist/transactionSet.ts.cache

@@ -0,0 +1,108 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule && mod.default) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true , configurable: true});
+//exports.transactionMutate = exports.replayTransactionStore = exports.transactionRead = void 0;
+const cbor_x_1 = __importDefault(require("cbor-x"));
+// structuredClone keeps typed arrays / Maps / undefined intact through the round-trip.
+const transactionCbor = new cbor_x_1.default.Encoder({ structuredClone: true });
+const DEFAULT_COMPACT_AFTER_FILES = 16;
+function maxNumber(values, fallback) {
+    let result = fallback;
+    for (const value of values) {
+        if (value > result) {
+            result = value;
+        }
+    }
+    return result;
+}
+function decodeBuffers(buffers) {
+    const transactions = [];
+    for (const buffer of buffers) {
+        const decoded = transactionCbor.decode(buffer);
+        for (const transaction of decoded) {
+            transactions.push(transaction);
+        }
+    }
+    return transactions;
+}
+function readTransactionFiles(database) {
+    const snapshot = database.readData(store => {
+        // A never-written / deleted set reads as empty (vs the whole readData being undefined = not synced).
+        const present = store;
+        if (!present)
+            return { fileKeys: [], buffers: [] };
+        return { fileKeys: Object.keys(present), buffers: Object.values(present) };
+    });
+    if (!snapshot)
+        return undefined;
+    return { fileKeys: snapshot.fileKeys, transactions: decodeBuffers(snapshot.buffers) };
+}
+function replay(transactions) {
+    const ordered = transactions.slice().sort((left, right) => left.sequence - right.sequence);
+    const state = new Map();
+    for (const transaction of ordered) {
+        // undefined (not falsy) is the delete marker, so 0 / "" / false stay real values.
+        if (transaction.value === undefined) {
+            state.delete(transaction.key);
+        }
+        else {
+            state.set(transaction.key, transaction.value);
+        }
+    }
+    return state;
+}
+// Deletes old files by their ORIGINAL string key, so a stray non-numeric key still gets removed.
+function compactTransactions(database, allTransactions, oldFileKeys, newFileNumber) {
+    const finalState = replay(allTransactions);
+    const merged = [];
+    for (const key of finalState.keys()) {
+        merged.push({ sequence: merged.length, key, value: finalState.get(key) });
+    }
+    const encoded = transactionCbor.encode(merged);
+    database.writeData(store => store[String(newFileNumber)], encoded);
+    for (const fileKey of oldFileKeys) {
+        database.deleteData(store => store[fileKey]);
+    }
+}
+function transactionRead(database) {
+    const files = readTransactionFiles(database);
+    if (!files)
+        return undefined;
+    return replay(files.transactions);
+}
+exports.transactionRead = transactionRead;
+// Replay an already-read store (no read of its own), so a caller can fetch many sets in one batched read and materialize each.
+function replayTransactionStore(store) {
+    if (!store)
+        return new Map();
+    return replay(decodeBuffers(Object.values(store)));
+}
+exports.replayTransactionStore = replayTransactionStore;
+// Fire-and-forget: no caller should care whether this "succeeded". If the set isn't synced for reading
+// yet it simply does nothing this pass and the caller's retry wrapper re-runs the whole operation later.
+function transactionMutate(database, transactions, compactAfterFiles = DEFAULT_COMPACT_AFTER_FILES) {
+    if (!transactions.length)
+        return;
+    const files = readTransactionFiles(database);
+    if (!files)
+        return;
+    const baseSequence = maxNumber(files.transactions.map(transaction => transaction.sequence), -1) + 1;
+    const incoming = transactions.map((transaction, index) => ({
+        sequence: baseSequence + index,
+        key: transaction.key,
+        value: transaction.value,
+    }));
+    const nextFileNumber = maxNumber(files.fileKeys.map(fileKey => Number(fileKey)), -1) + 1;
+    if (files.fileKeys.length + 1 >= compactAfterFiles) {
+        compactTransactions(database, files.transactions.concat(incoming), files.fileKeys, nextFileNumber);
+    }
+    else {
+        const encoded = transactionCbor.encode(incoming);
+        database.writeData(store => store[String(nextFileNumber)], encoded);
+    }
+}
+exports.transactionMutate = transactionMutate;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"transactionSet.js","sourceRoot":"","sources":["transactionSet.ts"],"names":[],"mappings":"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","sourcesContent":["import cborx from \"cbor-x\";\nimport { Database } from \"./Database\";\n\n// structuredClone keeps typed arrays / Maps / undefined intact through the round-trip.\nconst transactionCbor = new cborx.Encoder({ structuredClone: true });\n\n// On the store: files keyed by a monotonic number, each a CBOR array of transactions; a transaction sets one key (value undefined = delete) and carries a global sequence number. Replaying every transaction in sequence order (last write wins) gives the current map. Mutations append a file, then fold the whole set into one once enough accumulate. Value is phantom — it only records what the encoded values deserialize to.\ndeclare const valueTag: unique symbol;\nexport type TransactionSetStore<Value> = {\n    [fileNumber: string]: Uint8Array;\n    [valueTag]?: Value;\n};\n\ntype Transaction = { sequence: number; key: string; value: unknown };\n\nconst DEFAULT_COMPACT_AFTER_FILES = 16;\n\nfunction maxNumber(values: number[], fallback: number): number {\n    let result = fallback;\n    for (const value of values) {\n        if (value > result) {\n            result = value;\n        }\n    }\n    return result;\n}\n\nfunction decodeBuffers(buffers: Uint8Array[]): Transaction[] {\n    const transactions: Transaction[] = [];\n    for (const buffer of buffers) {\n        const decoded = transactionCbor.decode(buffer) as Transaction[];\n        for (const transaction of decoded) {\n            transactions.push(transaction);\n        }\n    }\n    return transactions;\n}\n\nfunction readTransactionFiles<Value>(\n    database: Database<TransactionSetStore<Value>>,\n): { fileKeys: string[]; transactions: Transaction[] } | undefined {\n    const snapshot = database.readData(store => {\n        // A never-written / deleted set reads as empty (vs the whole readData being undefined = not synced).\n        const present = store as TransactionSetStore<Value> | undefined;\n        if (!present) return { fileKeys: [] as string[], buffers: [] as Uint8Array[] };\n        return { fileKeys: Object.keys(present), buffers: Object.values(present) };\n    });\n    if (!snapshot) return undefined;\n    return { fileKeys: snapshot.fileKeys, transactions: decodeBuffers(snapshot.buffers) };\n}\n\nfunction replay(transactions: Transaction[]): Map<string, unknown> {\n    const ordered = transactions.slice().sort((left, right) => left.sequence - right.sequence);\n    const state = new Map<string, unknown>();\n    for (const transaction of ordered) {\n        // undefined (not falsy) is the delete marker, so 0 / \"\" / false stay real values.\n        if (transaction.value === undefined) {\n            state.delete(transaction.key);\n        } else {\n            state.set(transaction.key, transaction.value);\n        }\n    }\n    return state;\n}\n\n// Deletes old files by their ORIGINAL string key, so a stray non-numeric key still gets removed.\nfunction compactTransactions<Value>(\n    database: Database<TransactionSetStore<Value>>,\n    allTransactions: Transaction[],\n    oldFileKeys: string[],\n    newFileNumber: number,\n): void {\n    const finalState = replay(allTransactions);\n    const merged: Transaction[] = [];\n    for (const key of finalState.keys()) {\n        merged.push({ sequence: merged.length, key, value: finalState.get(key) });\n    }\n    const encoded = transactionCbor.encode(merged) as Uint8Array;\n    database.writeData(store => store[String(newFileNumber)], encoded);\n    for (const fileKey of oldFileKeys) {\n        database.deleteData(store => store[fileKey]);\n    }\n}\n\nexport function transactionRead<Value>(\n    database: Database<TransactionSetStore<Value>>,\n): Map<string, Value> | undefined {\n    const files = readTransactionFiles(database);\n    if (!files) return undefined;\n    return replay(files.transactions) as Map<string, Value>;\n}\n\n// Replay an already-read store (no read of its own), so a caller can fetch many sets in one batched read and materialize each.\nexport function replayTransactionStore<Value>(store: TransactionSetStore<Value> | undefined): Map<string, Value> {\n    if (!store) return new Map();\n    return replay(decodeBuffers(Object.values(store))) as Map<string, Value>;\n}\n\n// Fire-and-forget: no caller should care whether this \"succeeded\". If the set isn't synced for reading\n// yet it simply does nothing this pass and the caller's retry wrapper re-runs the whole operation later.\nexport function transactionMutate<Value>(\n    database: Database<TransactionSetStore<Value>>,\n    transactions: { key: string; value: Value | undefined }[],\n    compactAfterFiles: number = DEFAULT_COMPACT_AFTER_FILES,\n): void {\n    if (!transactions.length) return;\n    const files = readTransactionFiles(database);\n    if (!files) return;\n    const baseSequence = maxNumber(files.transactions.map(transaction => transaction.sequence), -1) + 1;\n    const incoming: Transaction[] = transactions.map((transaction, index) => ({\n        sequence: baseSequence + index,\n        key: transaction.key,\n        value: transaction.value,\n    }));\n    const nextFileNumber = maxNumber(files.fileKeys.map(fileKey => Number(fileKey)), -1) + 1;\n    if (files.fileKeys.length + 1 >= compactAfterFiles) {\n        compactTransactions(database, files.transactions.concat(incoming), files.fileKeys, nextFileNumber);\n    } else {\n        const encoded = transactionCbor.encode(incoming) as Uint8Array;\n        database.writeData(store => store[String(nextFileNumber)], encoded);\n    }\n}\n"]}
+ /* _JS_SOURCE_HASH = "5c22d95f86091992a5fc7263774f46e9f486d5f3cb56788139eecadc876b9f16"; */

package/storage/proxydatabase/inMemoryDatabase.d.ts

@@ -0,0 +1,13 @@
+import { Database } from "./Database";
+export declare class InMemoryDatabase<Root> implements Database<Root> {
+    readCalls: number;
+    writeCalls: number;
+    deleteCalls: number;
+    bytesRead: number;
+    bytesWritten: number;
+    private root;
+    constructor(initial: Root);
+    readData<Value>(deref: (root: Root) => Value): Value | undefined;
+    writeData<Value>(deref: (root: Root) => Value, newValue: Value): void;
+    deleteData(deref: (root: Root) => unknown): void;
+}