sliftutils 1.4.81 → 1.4.82

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

@@ -0,0 +1,105 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true , configurable: true});
+//exports.InMemoryDatabase = void 0;
+// Rough byte size of a value, for the read/written-bytes metrics.
+function sizeOf(value) {
+    if (value === undefined || value === null) {
+        return 0;
+    }
+    if (value instanceof Uint8Array) {
+        return value.byteLength;
+    }
+    if (typeof value === "string") {
+        return value.length;
+    }
+    if (typeof value === "number") {
+        return 8;
+    }
+    if (typeof value === "boolean") {
+        return 1;
+    }
+    if (Array.isArray(value)) {
+        let total = 0;
+        for (const entry of value) {
+            total += sizeOf(entry);
+        }
+        return total;
+    }
+    if (typeof value === "object") {
+        let total = 0;
+        const record = value;
+        for (const key of Object.keys(record)) {
+            total += sizeOf(record[key]);
+        }
+        return total;
+    }
+    return 0;
+}
+// Record the property path a dereference lambda walks, so a write/delete can be applied at it.
+function capturePath(deref) {
+    const path = [];
+    const handler = {
+        get(_target, key) {
+            if (typeof key === "string") {
+                path.push(key);
+            }
+            return new Proxy({}, handler);
+        },
+    };
+    deref(new Proxy({}, handler));
+    return path;
+}
+function setPath(root, path, value) {
+    let node = root;
+    for (let index = 0; index < path.length - 1; index++) {
+        const key = path[index];
+        const next = node[key];
+        if (!next || typeof next !== "object") {
+            node[key] = {};
+        }
+        node = node[key];
+    }
+    node[path[path.length - 1]] = value;
+}
+function deletePath(root, path) {
+    let node = root;
+    for (let index = 0; index < path.length - 1; index++) {
+        const next = node[path[index]];
+        if (!next || typeof next !== "object") {
+            return;
+        }
+        node = next;
+    }
+    delete node[path[path.length - 1]];
+}
+// In-memory Database for tests/dev: holds the whole root as a plain object and counts every call plus the
+// bytes flowing through. Synchronous and always "synced", so reads only return undefined for a genuinely
+// missing scalar (a missing transaction set reads as empty inside the set helpers).
+class InMemoryDatabase {
+    constructor(initial) {
+        this.readCalls = 0;
+        this.writeCalls = 0;
+        this.deleteCalls = 0;
+        this.bytesRead = 0;
+        this.bytesWritten = 0;
+        this.root = initial;
+    }
+    readData(deref) {
+        this.readCalls++;
+        const result = deref(this.root);
+        this.bytesRead += sizeOf(result);
+        return result;
+    }
+    writeData(deref, newValue) {
+        this.writeCalls++;
+        this.bytesWritten += sizeOf(newValue);
+        setPath(this.root, capturePath(deref), newValue);
+    }
+    deleteData(deref) {
+        this.deleteCalls++;
+        deletePath(this.root, capturePath(deref));
+    }
+}
+exports.InMemoryDatabase = InMemoryDatabase;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"inMemoryDatabase.js","sourceRoot":"","sources":["inMemoryDatabase.ts"],"names":[],"mappings":";;;AAEA,kEAAkE;AAClE,SAAS,MAAM,CAAC,KAAc;IAC1B,IAAI,KAAK,KAAK,SAAS,IAAI,KAAK,KAAK,IAAI,EAAE,CAAC;QACxC,OAAO,CAAC,CAAC;IACb,CAAC;IACD,IAAI,KAAK,YAAY,UAAU,EAAE,CAAC;QAC9B,OAAO,KAAK,CAAC,UAAU,CAAC;IAC5B,CAAC;IACD,IAAI,OAAO,KAAK,KAAK,QAAQ,EAAE,CAAC;QAC5B,OAAO,KAAK,CAAC,MAAM,CAAC;IACxB,CAAC;IACD,IAAI,OAAO,KAAK,KAAK,QAAQ,EAAE,CAAC;QAC5B,OAAO,CAAC,CAAC;IACb,CAAC;IACD,IAAI,OAAO,KAAK,KAAK,SAAS,EAAE,CAAC;QAC7B,OAAO,CAAC,CAAC;IACb,CAAC;IACD,IAAI,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,EAAE,CAAC;QACvB,IAAI,KAAK,GAAG,CAAC,CAAC;QACd,KAAK,MAAM,KAAK,IAAI,KAAK,EAAE,CAAC;YACxB,KAAK,IAAI,MAAM,CAAC,KAAK,CAAC,CAAC;QAC3B,CAAC;QACD,OAAO,KAAK,CAAC;IACjB,CAAC;IACD,IAAI,OAAO,KAAK,KAAK,QAAQ,EAAE,CAAC;QAC5B,IAAI,KAAK,GAAG,CAAC,CAAC;QACd,MAAM,MAAM,GAAG,KAAgC,CAAC;QAChD,KAAK,MAAM,GAAG,IAAI,MAAM,CAAC,IAAI,CAAC,MAAM,CAAC,EAAE,CAAC;YACpC,KAAK,IAAI,MAAM,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC;QACjC,CAAC;QACD,OAAO,KAAK,CAAC;IACjB,CAAC;IACD,OAAO,CAAC,CAAC;AACb,CAAC;AAED,+FAA+F;AAC/F,SAAS,WAAW,CAAC,KAAiC;IAClD,MAAM,IAAI,GAAa,EAAE,CAAC;IAC1B,MAAM,OAAO,GAAyB;QAClC,GAAG,CAAC,OAAO,EAAE,GAAG;YACZ,IAAI,OAAO,GAAG,KAAK,QAAQ,EAAE,CAAC;gBAC1B,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;YACnB,CAAC;YACD,OAAO,IAAI,KAAK,CAAC,EAAE,EAAE,OAAO,CAAC,CAAC;QAClC,CAAC;KACJ,CAAC;IACF,KAAK,CAAC,IAAI,KAAK,CAAC,EAAE,EAAE,OAAO,CAAC,CAAC,CAAC;IAC9B,OAAO,IAAI,CAAC;AAChB,CAAC;AAED,SAAS,OAAO,CAAC,IAA6B,EAAE,IAAc,EAAE,KAAc;IAC1E,IAAI,IAAI,GAAG,IAAI,CAAC;IAChB,KAAK,IAAI,KAAK,GAAG,CAAC,EAAE,KAAK,GAAG,IAAI,CAAC,MAAM,GAAG,CAAC,EAAE,KAAK,EAAE,EAAE,CAAC;QACnD,MAAM,GAAG,GAAG,IAAI,CAAC,KAAK,CAAC,CAAC;QACxB,MAAM,IAAI,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC;QACvB,IAAI,CAAC,IAAI,IAAI,OAAO,IAAI,KAAK,QAAQ,EAAE,CAAC;YACpC,IAAI,CAAC,GAAG,CAAC,GAAG,EAAE,CAAC;QACnB,CAAC;QACD,IAAI,GAAG,IAAI,CAAC,GAAG,CAA4B,CAAC;IAChD,CAAC;IACD,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,GAAG,KAAK,CAAC;AACxC,CAAC;AAED,SAAS,UAAU,CAAC,IAA6B,EAAE,IAAc;IAC7D,IAAI,IAAI,GAAG,IAAI,CAAC;IAChB,KAAK,IAAI,KAAK,GAAG,CAAC,EAAE,KAAK,GAAG,IAAI,CAAC,MAAM,GAAG,CAAC,EAAE,KAAK,EAAE,EAAE,CAAC;QACnD,MAAM,IAAI,GAAG,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC;QAC/B,IAAI,CAAC,IAAI,IAAI,OAAO,IAAI,KAAK,QAAQ,EAAE,CAAC;YACpC,OAAO;QACX,CAAC;QACD,IAAI,GAAG,IAA+B,CAAC;IAC3C,CAAC;IACD,OAAO,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,CAAC;AACvC,CAAC;AAED,0GAA0G;AAC1G,yGAAyG;AACzG,oFAAoF;AACpF,MAAa,gBAAgB;IAQzB,YAAY,OAAa;QAPlB,cAAS,GAAG,CAAC,CAAC;QACd,eAAU,GAAG,CAAC,CAAC;QACf,gBAAW,GAAG,CAAC,CAAC;QAChB,cAAS,GAAG,CAAC,CAAC;QACd,iBAAY,GAAG,CAAC,CAAC;QAIpB,IAAI,CAAC,IAAI,GAAG,OAAkC,CAAC;IACnD,CAAC;IAED,QAAQ,CAAQ,KAA4B;QACxC,IAAI,CAAC,SAAS,EAAE,CAAC;QACjB,MAAM,MAAM,GAAG,KAAK,CAAC,IAAI,CAAC,IAAY,CAAC,CAAC;QACxC,IAAI,CAAC,SAAS,IAAI,MAAM,CAAC,MAAM,CAAC,CAAC;QACjC,OAAO,MAAM,CAAC;IAClB,CAAC;IACD,SAAS,CAAQ,KAA4B,EAAE,QAAe;QAC1D,IAAI,CAAC,UAAU,EAAE,CAAC;QAClB,IAAI,CAAC,YAAY,IAAI,MAAM,CAAC,QAAQ,CAAC,CAAC;QACtC,OAAO,CAAC,IAAI,CAAC,IAAI,EAAE,WAAW,CAAC,KAAmC,CAAC,EAAE,QAAQ,CAAC,CAAC;IACnF,CAAC;IACD,UAAU,CAAC,KAA8B;QACrC,IAAI,CAAC,WAAW,EAAE,CAAC;QACnB,UAAU,CAAC,IAAI,CAAC,IAAI,EAAE,WAAW,CAAC,KAAmC,CAAC,CAAC,CAAC;IAC5E,CAAC;CACJ;AA3BD,4CA2BC","sourcesContent":["import { Database } from \"./Database\";\n\n// Rough byte size of a value, for the read/written-bytes metrics.\nfunction sizeOf(value: unknown): number {\n    if (value === undefined || value === null) {\n        return 0;\n    }\n    if (value instanceof Uint8Array) {\n        return value.byteLength;\n    }\n    if (typeof value === \"string\") {\n        return value.length;\n    }\n    if (typeof value === \"number\") {\n        return 8;\n    }\n    if (typeof value === \"boolean\") {\n        return 1;\n    }\n    if (Array.isArray(value)) {\n        let total = 0;\n        for (const entry of value) {\n            total += sizeOf(entry);\n        }\n        return total;\n    }\n    if (typeof value === \"object\") {\n        let total = 0;\n        const record = value as Record<string, unknown>;\n        for (const key of Object.keys(record)) {\n            total += sizeOf(record[key]);\n        }\n        return total;\n    }\n    return 0;\n}\n\n// Record the property path a dereference lambda walks, so a write/delete can be applied at it.\nfunction capturePath(deref: (root: unknown) => unknown): string[] {\n    const path: string[] = [];\n    const handler: ProxyHandler<object> = {\n        get(_target, key) {\n            if (typeof key === \"string\") {\n                path.push(key);\n            }\n            return new Proxy({}, handler);\n        },\n    };\n    deref(new Proxy({}, handler));\n    return path;\n}\n\nfunction setPath(root: Record<string, unknown>, path: string[], value: unknown): void {\n    let node = root;\n    for (let index = 0; index < path.length - 1; index++) {\n        const key = path[index];\n        const next = node[key];\n        if (!next || typeof next !== \"object\") {\n            node[key] = {};\n        }\n        node = node[key] as Record<string, unknown>;\n    }\n    node[path[path.length - 1]] = value;\n}\n\nfunction deletePath(root: Record<string, unknown>, path: string[]): void {\n    let node = root;\n    for (let index = 0; index < path.length - 1; index++) {\n        const next = node[path[index]];\n        if (!next || typeof next !== \"object\") {\n            return;\n        }\n        node = next as Record<string, unknown>;\n    }\n    delete node[path[path.length - 1]];\n}\n\n// In-memory Database for tests/dev: holds the whole root as a plain object and counts every call plus the\n// bytes flowing through. Synchronous and always \"synced\", so reads only return undefined for a genuinely\n// missing scalar (a missing transaction set reads as empty inside the set helpers).\nexport class InMemoryDatabase<Root> implements Database<Root> {\n    public readCalls = 0;\n    public writeCalls = 0;\n    public deleteCalls = 0;\n    public bytesRead = 0;\n    public bytesWritten = 0;\n    private root: Record<string, unknown>;\n\n    constructor(initial: Root) {\n        this.root = initial as Record<string, unknown>;\n    }\n\n    readData<Value>(deref: (root: Root) => Value): Value | undefined {\n        this.readCalls++;\n        const result = deref(this.root as Root);\n        this.bytesRead += sizeOf(result);\n        return result;\n    }\n    writeData<Value>(deref: (root: Root) => Value, newValue: Value): void {\n        this.writeCalls++;\n        this.bytesWritten += sizeOf(newValue);\n        setPath(this.root, capturePath(deref as (root: unknown) => unknown), newValue);\n    }\n    deleteData(deref: (root: Root) => unknown): void {\n        this.deleteCalls++;\n        deletePath(this.root, capturePath(deref as (root: unknown) => unknown));\n    }\n}\n"]}
+ /* _JS_SOURCE_HASH = "aa6987f940c5d431dfd1c6d9989fec9aef7d35056bea35397ec8e94982f2c3ca"; */

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

@@ -0,0 +1,81 @@
+"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});
+const fs_1 = __importDefault(require("fs"));
+const inMemoryDatabase_1 = require("./inMemoryDatabase");
+const ivfEmbeddingDatabase_1 = require("./ivfEmbeddingDatabase");
+const embeddingFormats_1 = require("../embeddingFormats");
+const faceFramesData_1 = require("../faceFramesData");
+// Exercises the tiered IVF embedding database through the in-memory Database wrapper, which counts every
+// read/write/delete call and the bytes through each, across dataset sizes and load patterns, with timing.
+const DIM = 512;
+const FILE_NAME = "faceFrames2_full.f32";
+const MODEL = "buffalo_l";
+const FORMAT = "q8g8_2048";
+async function loadFloats(count) {
+    const byteLength = count * DIM * 4;
+    const filePath = await (0, faceFramesData_1.ensureFaceData)(FILE_NAME, byteLength);
+    const buffer = Buffer.alloc(byteLength);
+    const handle = fs_1.default.openSync(filePath, "r");
+    fs_1.default.readSync(handle, buffer, 0, byteLength, 0);
+    fs_1.default.closeSync(handle);
+    return new Float32Array(buffer.buffer, buffer.byteOffset, count * DIM);
+}
+async function buildInputs(count) {
+    const floats = await loadFloats(count);
+    const inputs = [];
+    for (let index = 0; index < count; index++) {
+        const slice = floats.subarray(index * DIM, (index + 1) * DIM);
+        inputs.push({ ref: "e" + index, embedding: (0, embeddingFormats_1.encodeEmbedding)({ input: slice, format: FORMAT, model: MODEL }) });
+    }
+    return inputs;
+}
+function freshDatabase(config) {
+    const root = { config, count: 0, flat: {}, steps: {}, centroids: {}, cells: {} };
+    return new inMemoryDatabase_1.InMemoryDatabase(root);
+}
+function pad(value, width) {
+    return String(value).padStart(width);
+}
+async function main() {
+    const config = { model: MODEL, format: FORMAT, cellTargetSize: 128 };
+    const runs = [
+        { size: 10000, batch: 1 },
+        { size: 10000, batch: 100 },
+        { size: 100000, batch: 1000 },
+    ];
+    let maxSize = 0;
+    for (const run of runs) {
+        if (run.size > maxSize) {
+            maxSize = run.size;
+        }
+    }
+    const loadStart = Date.now();
+    const allInputs = await buildInputs(maxSize);
+    console.log(`loaded + encoded ${maxSize} embeddings in ${((Date.now() - loadStart) / 1000).toFixed(1)}s\n`);
+    console.log(`${pad("added", 7)} ${pad("batch", 5)} | ${pad("secs", 7)} ${pad("reads", 8)} ${pad("writes", 8)} ${pad("deletes", 8)} ${pad("readMB", 9)} ${pad("writeMB", 8)} | recall`);
+    for (const run of runs) {
+        const database = freshDatabase(config);
+        const start = Date.now();
+        for (let offset = 0; offset < run.size; offset += run.batch) {
+            (0, ivfEmbeddingDatabase_1.insertEmbeddings)(database, allInputs.slice(offset, offset + run.batch));
+        }
+        const seconds = (Date.now() - start) / 1000;
+        let found = 0;
+        const sampleCount = 100;
+        for (let index = 0; index < sampleCount; index++) {
+            const query = allInputs[Math.floor(index * run.size / sampleCount)];
+            const hits = (0, ivfEmbeddingDatabase_1.searchEmbeddings)(database, query.embedding, { probeBudget: 512, resultCount: 1 });
+            if (hits && hits.length && hits[0].ref === query.ref) {
+                found++;
+            }
+        }
+        const recall = (found / sampleCount).toFixed(2);
+        console.log(`${pad(run.size, 7)} ${pad(run.batch, 5)} | ${pad(seconds.toFixed(1), 7)} ${pad(database.readCalls, 8)} ${pad(database.writeCalls, 8)} ${pad(database.deleteCalls, 8)} ${pad((database.bytesRead / 1e6).toFixed(0), 9)} ${pad((database.bytesWritten / 1e6).toFixed(0), 8)} | ${recall}`);
+    }
+}
+main();
+//# sourceMappingURL=data:application/json;base64,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
+ /* _JS_SOURCE_HASH = "31db07ffef35ecca7578f435bb6db898fafcf77607d50d5ffd52abaf2d4a1490"; */

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"; */