sensemaking 0.25.1 → 0.27.0

package/dist/cjs/store/sqlite/store.js

@@ -365,6 +365,68 @@ var CAPABILITIES = new Set([
     'segment'
 ]);
 function createStore(db, conn) {
+    var vectorScope = (0, _vectorsts.createNativeVectorScopeOwner)();
+    var vectors = {
+        pending: function pending() {
+            return _async_to_generator(function() {
+                return _ts_generator(this, function(_state) {
+                    return [
+                        2,
+                        (0, _vectorsts.pendingRows)(conn)
+                    ];
+                });
+            })();
+        },
+        writeVectors: function writeVectors(rows) {
+            return _async_to_generator(function() {
+                return _ts_generator(this, function(_state) {
+                    switch(_state.label){
+                        case 0:
+                            return [
+                                4,
+                                (0, _vectorsts1.writeVectorBatch)(conn, rows)
+                            ];
+                        case 1:
+                            _state.sent();
+                            return [
+                                2
+                            ];
+                    }
+                });
+            })();
+        },
+        candidates: function candidates(qv, storeDims, fetch, allowed) {
+            return _async_to_generator(function() {
+                return _ts_generator(this, function(_state) {
+                    return [
+                        2,
+                        (0, _vectorsts1.scanCandidates)(conn, qv, storeDims, fetch, allowed, vectorScope.activeFor(allowed))
+                    ];
+                });
+            })();
+        },
+        similar: function similar(path, opts) {
+            return _async_to_generator(function() {
+                return _ts_generator(this, function(_state) {
+                    return [
+                        2,
+                        (0, _vectorsts1.scanSimilar)(conn, path, opts, vectorScope.activeFor(opts.allowed))
+                    ];
+                });
+            })();
+        },
+        hasVector: function hasVector(path) {
+            return _async_to_generator(function() {
+                return _ts_generator(this, function(_state) {
+                    return [
+                        2,
+                        (0, _vectorsts.hasVectorRow)(conn, path)
+                    ];
+                });
+            })();
+        }
+    };
+    vectorScope.bind(vectors);
     return {
         name: 'sqlite',
         capabilities: CAPABILITIES,
@@ -468,66 +530,7 @@ function createStore(db, conn) {
                 })();
             }
         },
-        vectors: {
-            pending: function pending() {
-                return _async_to_generator(function() {
-                    return _ts_generator(this, function(_state) {
-                        return [
-                            2,
-                            (0, _vectorsts.pendingRows)(conn)
-                        ];
-                    });
-                })();
-            },
-            writeVectors: function writeVectors(rows) {
-                return _async_to_generator(function() {
-                    return _ts_generator(this, function(_state) {
-                        switch(_state.label){
-                            case 0:
-                                return [
-                                    4,
-                                    (0, _vectorsts1.writeVectorBatch)(conn, rows)
-                                ];
-                            case 1:
-                                _state.sent();
-                                return [
-                                    2
-                                ];
-                        }
-                    });
-                })();
-            },
-            candidates: function candidates(qv, storeDims, fetch, allowed) {
-                return _async_to_generator(function() {
-                    return _ts_generator(this, function(_state) {
-                        return [
-                            2,
-                            (0, _vectorsts1.scanCandidates)(conn, qv, storeDims, fetch, allowed)
-                        ];
-                    });
-                })();
-            },
-            similar: function similar(path, opts) {
-                return _async_to_generator(function() {
-                    return _ts_generator(this, function(_state) {
-                        return [
-                            2,
-                            (0, _vectorsts1.scanSimilar)(conn, path, opts)
-                        ];
-                    });
-                })();
-            },
-            hasVector: function hasVector(path) {
-                return _async_to_generator(function() {
-                    return _ts_generator(this, function(_state) {
-                        return [
-                            2,
-                            (0, _vectorsts.hasVectorRow)(conn, path)
-                        ];
-                    });
-                })();
-            }
-        },
+        vectors: vectors,
         engineStatus: function engineStatus() {
             return _async_to_generator(function() {
                 var row;

package/dist/cjs/store/sqlite/store.js.map

@@ -1 +1 @@
-{"version":3,"sources":["/Users/kevin/Dev/OpenSource/ai/sensemaking/src/store/sqlite/store.ts"],"sourcesContent":["import type { DatabaseSync } from 'node:sqlite';\nimport { getColumns } from '../shared.ts';\nimport { withTransaction } from '../transaction.ts';\nimport type { Capability, Connection, Statement, Store, VectorWriteRow } from '../types.ts';\nimport { hasVectorRow, pendingRows } from '../vectors.ts';\nimport { fieldStats } from './fieldStats.ts';\nimport { queryLexical } from './lexical.ts';\nimport { scanCandidates, scanSimilar, writeVectorBatch } from './vectors.ts';\n\nexport const CAPABILITIES: ReadonlySet<Capability> = new Set(['vectors', 'segment']);\n\n// Wraps the synchronous DatabaseSync connection in the async Store interface, sharing one\n// Connection instance (conn) with the builder's own reconcile call so transaction depth is tracked against the same object everywhere.\nexport function createStore(db: DatabaseSync, conn: Connection): Store {\n  return {\n    name: 'sqlite',\n    capabilities: CAPABILITIES,\n    async exec(sql: string): Promise<void> {\n      await conn.exec(sql);\n    },\n    async prepare(sql: string): Promise<Statement> {\n      return conn.prepare(sql);\n    },\n    async runBatch(sql: string, paramRows: unknown[][]): Promise<void> {\n      await conn.runBatch(sql, paramRows);\n    },\n    async transaction<T>(fn: () => Promise<T>): Promise<T> {\n      return withTransaction(conn, fn);\n    },\n    docs: {\n      async columns() {\n        return [...(await getColumns(conn))];\n      },\n      async fieldStats(columns, scopeWhere) {\n        return fieldStats(conn, columns, scopeWhere);\n      },\n    },\n    lexical: {\n      async query(terms, opts) {\n        return queryLexical(conn, terms, opts);\n      },\n    },\n    vectors: {\n      async pending() {\n        return pendingRows(conn);\n      },\n      async writeVectors(rows: VectorWriteRow[]) {\n        await writeVectorBatch(conn, rows);\n      },\n      async candidates(qv, storeDims, fetch, allowed) {\n        return scanCandidates(conn, qv, storeDims, fetch, allowed);\n      },\n      async similar(path, opts) {\n        return scanSimilar(conn, path, opts);\n      },\n      async hasVector(path) {\n        return hasVectorRow(conn, path);\n      },\n    },\n    async engineStatus() {\n      // Read back rather than recomputed: this is what open() actually set (3x the largest\n      // recorded reconcile, floored at 30s, capped at 10min), not a value re-derived here.\n      const row = db.prepare('PRAGMA busy_timeout').get() as { timeout: number };\n      return { busy_timeout: `${row.timeout}ms (derived: 3x the largest reconcile this cache has recorded, floored at 30000ms)` };\n    },\n    raw: {\n      async prepare(sql: string) {\n        const stmt = db.prepare(sql);\n        stmt.setReadBigInts(true); // int64 past 2^53 arrives as BigInt instead of throwing at step time\n        return {\n          columns: () => stmt.columns(),\n          // sense sql streams through an async iterator wrapping the sync iterate().\n          iterate: async function* (...params: unknown[]) {\n            yield* stmt.iterate(...(params as Parameters<typeof stmt.iterate>));\n          },\n        };\n      },\n    },\n    async close() {\n      db.close();\n    },\n  };\n}\n"],"names":["CAPABILITIES","createStore","Set","db","conn","name","capabilities","exec","sql","prepare","runBatch","paramRows","transaction","fn","withTransaction","docs","columns","getColumns","fieldStats","scopeWhere","lexical","query","terms","opts","queryLexical","vectors","pending","pendingRows","writeVectors","rows","writeVectorBatch","candidates","qv","storeDims","fetch","allowed","scanCandidates","similar","path","scanSimilar","hasVector","hasVectorRow","engineStatus","row","get","busy_timeout","timeout","raw","stmt","setReadBigInts","iterate","params","close"],"mappings":"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"}
+{"version":3,"sources":["/Users/kevin/Dev/OpenSource/ai/sensemaking/src/store/sqlite/store.ts"],"sourcesContent":["import type { DatabaseSync } from 'node:sqlite';\nimport { getColumns } from '../shared.ts';\nimport { withTransaction } from '../transaction.ts';\nimport type { Capability, Connection, Statement, Store, VectorStore, VectorWriteRow } from '../types.ts';\nimport { createNativeVectorScopeOwner, hasVectorRow, pendingRows } from '../vectors.ts';\nimport { fieldStats } from './fieldStats.ts';\nimport { queryLexical } from './lexical.ts';\nimport { scanCandidates, scanSimilar, writeVectorBatch } from './vectors.ts';\n\nexport const CAPABILITIES: ReadonlySet<Capability> = new Set(['vectors', 'segment']);\n\n// Wraps the synchronous DatabaseSync connection in the async Store interface, sharing one\n// Connection instance (conn) with the builder's own reconcile call so transaction depth is tracked against the same object everywhere.\nexport function createStore(db: DatabaseSync, conn: Connection): Store {\n  const vectorScope = createNativeVectorScopeOwner();\n  const vectors: VectorStore = {\n    async pending() {\n      return pendingRows(conn);\n    },\n    async writeVectors(rows: VectorWriteRow[]) {\n      await writeVectorBatch(conn, rows);\n    },\n    async candidates(qv, storeDims, fetch, allowed) {\n      return scanCandidates(conn, qv, storeDims, fetch, allowed, vectorScope.activeFor(allowed));\n    },\n    async similar(path, opts) {\n      return scanSimilar(conn, path, opts, vectorScope.activeFor(opts.allowed));\n    },\n    async hasVector(path) {\n      return hasVectorRow(conn, path);\n    },\n  };\n  vectorScope.bind(vectors);\n\n  return {\n    name: 'sqlite',\n    capabilities: CAPABILITIES,\n    async exec(sql: string): Promise<void> {\n      await conn.exec(sql);\n    },\n    async prepare(sql: string): Promise<Statement> {\n      return conn.prepare(sql);\n    },\n    async runBatch(sql: string, paramRows: unknown[][]): Promise<void> {\n      await conn.runBatch(sql, paramRows);\n    },\n    async transaction<T>(fn: () => Promise<T>): Promise<T> {\n      return withTransaction(conn, fn);\n    },\n    docs: {\n      async columns() {\n        return [...(await getColumns(conn))];\n      },\n      async fieldStats(columns, scopeWhere) {\n        return fieldStats(conn, columns, scopeWhere);\n      },\n    },\n    lexical: {\n      async query(terms, opts) {\n        return queryLexical(conn, terms, opts);\n      },\n    },\n    vectors,\n    async engineStatus() {\n      // Read back rather than recomputed: this is what open() actually set (3x the largest\n      // recorded reconcile, floored at 30s, capped at 10min), not a value re-derived here.\n      const row = db.prepare('PRAGMA busy_timeout').get() as { timeout: number };\n      return { busy_timeout: `${row.timeout}ms (derived: 3x the largest reconcile this cache has recorded, floored at 30000ms)` };\n    },\n    raw: {\n      async prepare(sql: string) {\n        const stmt = db.prepare(sql);\n        stmt.setReadBigInts(true); // int64 past 2^53 arrives as BigInt instead of throwing at step time\n        return {\n          columns: () => stmt.columns(),\n          // sense sql streams through an async iterator wrapping the sync iterate().\n          iterate: async function* (...params: unknown[]) {\n            yield* stmt.iterate(...(params as Parameters<typeof stmt.iterate>));\n          },\n        };\n      },\n    },\n    async close() {\n      db.close();\n    },\n  };\n}\n"],"names":["CAPABILITIES","createStore","Set","db","conn","vectorScope","createNativeVectorScopeOwner","vectors","pending","pendingRows","writeVectors","rows","writeVectorBatch","candidates","qv","storeDims","fetch","allowed","scanCandidates","activeFor","similar","path","opts","scanSimilar","hasVector","hasVectorRow","bind","name","capabilities","exec","sql","prepare","runBatch","paramRows","transaction","fn","withTransaction","docs","columns","getColumns","fieldStats","scopeWhere","lexical","query","terms","queryLexical","engineStatus","row","get","busy_timeout","timeout","raw","stmt","setReadBigInts","iterate","params","close"],"mappings":";;;;;;;;;;;QASaA;eAAAA;;QAIGC;eAAAA;;;wBAZW;6BACK;yBAEwC;4BAC7C;yBACE;0BACiC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEvD,IAAMD,eAAwC,IAAIE,IAAI;IAAC;IAAW;CAAU;AAI5E,SAASD,YAAYE,EAAgB,EAAEC,IAAgB;IAC5D,IAAMC,cAAcC,IAAAA,uCAA4B;IAChD,IAAMC,UAAuB;QACrBC,SAAN,SAAMA;;;oBACJ;;wBAAOC,IAAAA,sBAAW,EAACL;;;YACrB;;QACMM,cAAN,SAAMA,aAAaC,IAAsB;;;;;4BACvC;;gCAAMC,IAAAA,4BAAgB,EAACR,MAAMO;;;4BAA7B;;;;;;YACF;;QACME,YAAN,SAAMA,WAAWC,EAAE,EAAEC,SAAS,EAAEC,KAAK,EAAEC,OAAO;;;oBAC5C;;wBAAOC,IAAAA,0BAAc,EAACd,MAAMU,IAAIC,WAAWC,OAAOC,SAASZ,YAAYc,SAAS,CAACF;;;YACnF;;QACMG,SAAN,SAAMA,QAAQC,IAAI,EAAEC,IAAI;;;oBACtB;;wBAAOC,IAAAA,uBAAW,EAACnB,MAAMiB,MAAMC,MAAMjB,YAAYc,SAAS,CAACG,KAAKL,OAAO;;;YACzE;;QACMO,WAAN,SAAMA,UAAUH,IAAI;;;oBAClB;;wBAAOI,IAAAA,uBAAY,EAACrB,MAAMiB;;;YAC5B;;IACF;IACAhB,YAAYqB,IAAI,CAACnB;IAEjB,OAAO;QACLoB,MAAM;QACNC,cAAc5B;QACR6B,MAAN,SAAMA,KAAKC,GAAW;;;;;4BACpB;;gCAAM1B,KAAKyB,IAAI,CAACC;;;4BAAhB;;;;;;YACF;;QACMC,SAAN,SAAMA,QAAQD,GAAW;;;oBACvB;;wBAAO1B,KAAK2B,OAAO,CAACD;;;YACtB;;QACME,UAAN,SAAMA,SAASF,GAAW,EAAEG,SAAsB;;;;;4BAChD;;gCAAM7B,KAAK4B,QAAQ,CAACF,KAAKG;;;4BAAzB;;;;;;YACF;;QACMC,aAAN,SAAMA,YAAeC,EAAoB;;;oBACvC;;wBAAOC,IAAAA,8BAAe,EAAChC,MAAM+B;;;YAC/B;;QACAE,MAAM;YACEC,SAAN,SAAMA;;;;;gCACQ;;oCAAMC,IAAAA,oBAAU,EAACnC;;;gCAA7B;;oCAAQ;wCAAI;;;;;gBACd;;YACMoC,YAAN,SAAMA,WAAWF,OAAO,EAAEG,UAAU;;;wBAClC;;4BAAOD,IAAAA,wBAAU,EAACpC,MAAMkC,SAASG;;;gBACnC;;QACF;QACAC,SAAS;YACDC,OAAN,SAAMA,MAAMC,KAAK,EAAEtB,IAAI;;;wBACrB;;4BAAOuB,IAAAA,uBAAY,EAACzC,MAAMwC,OAAOtB;;;gBACnC;;QACF;QACAf,SAAAA;QACMuC,cAAN,SAAMA;;oBAGEC;;oBAFN,qFAAqF;oBACrF,qFAAqF;oBAC/EA,MAAM5C,GAAG4B,OAAO,CAAC,uBAAuBiB,GAAG;oBACjD;;wBAAO;4BAAEC,cAAc,AAAC,GAAc,OAAZF,IAAIG,OAAO,EAAC;wBAAoF;;;YAC5H;;QACAC,KAAK;YACGpB,SAAN,SAAMA,QAAQD,GAAW;;wBACjBsB;;wBAAAA,OAAOjD,GAAG4B,OAAO,CAACD;wBACxBsB,KAAKC,cAAc,CAAC,OAAO,qEAAqE;wBAChG;;4BAAO;gCACLf,SAAS,SAATA;2CAAec,KAAKd,OAAO;;gCAC3B,2EAA2E;gCAC3EgB,SAAS,SAATA;oCAA0B,IAAA,IAAA,OAAA,UAAA,QAAA,AAAGC,SAAH,UAAA,OAAA,OAAA,GAAA,OAAA,MAAA;wCAAGA,OAAH,QAAA,SAAA,CAAA,KAAoB;;;4CACrCH;;;;oDAAP;;mEAAA,0CAAOA,CAAAA,QAAAA,MAAKE,OAAO,OAAZF,OAAa,qBAAIG;;;oDAAxB;;;;;;oCACF;;4BACF;;;gBACF;;QACF;QACMC,OAAN,SAAMA;;;oBACJrD,GAAGqD,KAAK;;;;;YACV;;IACF;AACF"}

package/dist/cjs/store/sqlite/vectors.d.cts

@@ -1,8 +1,8 @@
 import type { Connection, VectorCandidate, VectorSimilar, VectorWriteRow } from '../types.js';
 export declare function writeVectorBatch(conn: Connection, rows: VectorWriteRow[]): Promise<void>;
-export declare function scanCandidates(conn: Connection, qv: Float32Array, storeDims: number, fetch: number, allowed?: Set<string>): Promise<VectorCandidate[]>;
+export declare function scanCandidates(conn: Connection, qv: Float32Array, storeDims: number, fetch: number, allowed?: Set<string>, nativeScope?: boolean): Promise<VectorCandidate[]>;
 export declare function scanSimilar(conn: Connection, path: string, opts: {
     exclude: Set<string>;
     allowed?: Set<string>;
     k: number;
-}): Promise<VectorSimilar[]>;
+}, nativeScope?: boolean): Promise<VectorSimilar[]>;

package/dist/cjs/store/sqlite/vectors.d.ts

@@ -1,8 +1,8 @@
 import type { Connection, VectorCandidate, VectorSimilar, VectorWriteRow } from '../types.js';
 export declare function writeVectorBatch(conn: Connection, rows: VectorWriteRow[]): Promise<void>;
-export declare function scanCandidates(conn: Connection, qv: Float32Array, storeDims: number, fetch: number, allowed?: Set<string>): Promise<VectorCandidate[]>;
+export declare function scanCandidates(conn: Connection, qv: Float32Array, storeDims: number, fetch: number, allowed?: Set<string>, nativeScope?: boolean): Promise<VectorCandidate[]>;
 export declare function scanSimilar(conn: Connection, path: string, opts: {
     exclude: Set<string>;
     allowed?: Set<string>;
     k: number;
-}): Promise<VectorSimilar[]>;
+}, nativeScope?: boolean): Promise<VectorSimilar[]>;

package/dist/cjs/store/sqlite/vectors.js

@@ -260,14 +260,16 @@ function writeVectorBatch(conn, rows) {
     })();
 }
 function scanCandidates(conn, qv, storeDims, fetch, allowed) {
+    var nativeScope = arguments.length > 5 && arguments[5] !== void 0 ? arguments[5] : false;
     return _async_to_generator(function() {
-        var stmt, rows, queryNorm, d, best, _iteratorNormalCompletion, _didIteratorError, _iteratorError, _iterator, _step, row, q, dot, norm, length, d1, d2, score, existing;
+        var scope, stmt, rows, queryNorm, d, best, _iteratorNormalCompletion, _didIteratorError, _iteratorError, _iterator, _step, row, q, dot, norm, length, d1, d2, score, existing;
         return _ts_generator(this, function(_state) {
             switch(_state.label){
                 case 0:
+                    scope = nativeScope ? ' AND "path" IN (SELECT "path" FROM '.concat(_vectorsts.NATIVE_VECTOR_SCOPE_TABLE, ")") : '';
                     return [
                         4,
-                        conn.prepare('SELECT "path", chunk, start_line, end_line, vector FROM embeddings WHERE vector IS NOT NULL ORDER BY "path", chunk')
+                        conn.prepare('SELECT "path", chunk, start_line, end_line, vector FROM embeddings WHERE vector IS NOT NULL'.concat(scope, ' ORDER BY "path", chunk'))
                     ];
                 case 1:
                     stmt = _state.sent();
@@ -342,8 +344,9 @@ function scanCandidates(conn, qv, storeDims, fetch, allowed) {
     })();
 }
 function scanSimilar(conn, path, opts) {
+    var nativeScope = arguments.length > 3 && arguments[3] !== void 0 ? arguments[3] : false;
     return _async_to_generator(function() {
-        var targetStmt, targetRows, target, stmt, rows, best, _iteratorNormalCompletion, _didIteratorError, _iteratorError, _iterator, _step, row, other, otherNorm, d, _iteratorNormalCompletion1, _didIteratorError1, _iteratorError1, _iterator1, _step1, t, dot, len, d1, score, existing;
+        var targetStmt, targetRows, target, scope, stmt, rows, best, _iteratorNormalCompletion, _didIteratorError, _iteratorError, _iterator, _step, row, other, otherNorm, d, _iteratorNormalCompletion1, _didIteratorError1, _iteratorError1, _iterator1, _step1, t, dot, len, d1, score, existing;
         return _ts_generator(this, function(_state) {
             switch(_state.label){
                 case 0:
@@ -373,9 +376,10 @@ function scanSimilar(conn, path, opts) {
                             norm: Math.sqrt(norm)
                         };
                     });
+                    scope = nativeScope ? ' AND "path" IN (SELECT "path" FROM '.concat(_vectorsts.NATIVE_VECTOR_SCOPE_TABLE, ")") : '';
                     return [
                         4,
-                        conn.prepare('SELECT "path", vector FROM embeddings WHERE vector IS NOT NULL')
+                        conn.prepare('SELECT "path", vector FROM embeddings WHERE vector IS NOT NULL'.concat(scope))
                     ];
                 case 3:
                     stmt = _state.sent();

package/dist/cjs/store/sqlite/vectors.js.map

@@ -1 +1 @@
-{"version":3,"sources":["/Users/kevin/Dev/OpenSource/ai/sensemaking/src/store/sqlite/vectors.ts"],"sourcesContent":["import type { Connection, VectorCandidate, VectorSimilar, VectorWriteRow } from '../types.ts';\nimport { asCosine, compareVectorScores, sampleEvenly } from '../vectors.ts';\n\n// One runBatch call per provider batch: the caller (embed/query.ts) already batches by the\n// provider's batchCap, so this is one crossing per batch, never per row.\nexport async function writeVectorBatch(conn: Connection, rows: VectorWriteRow[]): Promise<void> {\n  if (rows.length === 0) return;\n  await conn.runBatch(\n    'UPDATE embeddings SET scale = ?, vector = ? WHERE \"path\" = ? AND chunk = ?',\n    rows.map((row) => [row.scale, row.vector, row.path, row.chunk])\n  );\n}\n\n// Best chunk per file by cosine, its line range riding along: the JS loop over stored int8\n// BLOBs this store's scan strategy is (a native store scans differently, same contract).\nexport async function scanCandidates(conn: Connection, qv: Float32Array, storeDims: number, fetch: number, allowed?: Set<string>): Promise<VectorCandidate[]> {\n  const stmt = await conn.prepare('SELECT \"path\", chunk, start_line, end_line, vector FROM embeddings WHERE vector IS NOT NULL ORDER BY \"path\", chunk');\n  const rows = (await stmt.all()) as Array<{\n    path: string;\n    chunk: number;\n    start_line: number;\n    end_line: number;\n    vector: Uint8Array;\n  }>;\n\n  let queryNorm = 0;\n  for (let d = 0; d < Math.min(storeDims, qv.length); d++) queryNorm += qv[d] * qv[d];\n  queryNorm = Math.sqrt(queryNorm);\n\n  const best = new Map<string, { score: number; chunk: number; lines: string }>();\n  for (const row of rows) {\n    if (allowed && !allowed.has(row.path)) continue;\n    const q = new Int8Array(row.vector.buffer, row.vector.byteOffset, Math.min(storeDims, row.vector.byteLength));\n    // Rounding to int8 costs the stored row its unit norm, so dividing by that norm is what makes\n    // this a cosine rather than a scaled dot product. `scale` cancels out of the ratio.\n    let dot = 0;\n    let norm = 0;\n    const length = Math.min(q.length, qv.length);\n    for (let d = 0; d < length; d++) {\n      dot += q[d] * qv[d];\n      norm += q[d] * q[d];\n    }\n    for (let d = length; d < q.length; d++) norm += q[d] * q[d];\n    const score = norm === 0 || queryNorm === 0 ? 0 : dot / (Math.sqrt(norm) * queryNorm);\n    const existing = best.get(row.path);\n    if (!existing || score > existing.score || (score === existing.score && row.chunk < existing.chunk)) {\n      best.set(row.path, { score, chunk: row.chunk, lines: `L${row.start_line}-${row.end_line}` });\n    }\n  }\n  return [...best.entries()]\n    .map(([path, value]) => ({ path, ...value }))\n    .sort(compareVectorScores)\n    .slice(0, fetch)\n    .map(({ path, lines, score }) => ({ path, lines, similarity: asCosine(score) }));\n}\n\n// Note-to-note similarity is the max cosine over (target chunk, other chunk) pairs, one linear\n// scan of stored vectors.\nexport async function scanSimilar(conn: Connection, path: string, opts: { exclude: Set<string>; allowed?: Set<string>; k: number }): Promise<VectorSimilar[]> {\n  const targetStmt = await conn.prepare('SELECT vector FROM embeddings WHERE \"path\" = ? AND vector IS NOT NULL ORDER BY chunk');\n  const targetRows = (await targetStmt.all(path)) as Array<{ vector: Uint8Array }>;\n  if (targetRows.length === 0) return [];\n  // Each side's norm divides its own dot product, so both are taken once here rather than per pair.\n  const target = sampleEvenly(targetRows).map((row) => {\n    const v = new Int8Array(row.vector.buffer, row.vector.byteOffset, row.vector.byteLength);\n    let norm = 0;\n    for (let d = 0; d < v.length; d++) norm += v[d] * v[d];\n    return { v, norm: Math.sqrt(norm) };\n  });\n\n  const stmt = await conn.prepare('SELECT \"path\", vector FROM embeddings WHERE vector IS NOT NULL');\n  const rows = (await stmt.all()) as Array<{ path: string; vector: Uint8Array }>;\n  const best = new Map<string, number>();\n  for (const row of rows) {\n    if (row.path === path || opts.exclude.has(row.path) || (opts.allowed && !opts.allowed.has(row.path))) continue;\n    const other = new Int8Array(row.vector.buffer, row.vector.byteOffset, row.vector.byteLength);\n    let otherNorm = 0;\n    for (let d = 0; d < other.length; d++) otherNorm += other[d] * other[d];\n    otherNorm = Math.sqrt(otherNorm);\n    for (const t of target) {\n      let dot = 0;\n      const len = Math.min(t.v.length, other.length);\n      for (let d = 0; d < len; d++) dot += t.v[d] * other[d];\n      const score = t.norm === 0 || otherNorm === 0 ? 0 : dot / (t.norm * otherNorm);\n      const existing = best.get(row.path);\n      if (existing === undefined || score > existing) best.set(row.path, score);\n    }\n  }\n\n  return [...best.entries()]\n    .map(([p, score]) => ({ path: p, score }))\n    .sort(compareVectorScores)\n    .slice(0, opts.k)\n    .map(({ path: p, score }) => ({ path: p, similarity: asCosine(score) }));\n}\n"],"names":["scanCandidates","scanSimilar","writeVectorBatch","conn","rows","length","runBatch","map","row","scale","vector","path","chunk","qv","storeDims","fetch","allowed","stmt","queryNorm","d","best","q","dot","norm","score","existing","prepare","all","Math","min","sqrt","Map","has","Int8Array","buffer","byteOffset","byteLength","get","set","lines","start_line","end_line","entries","value","sort","compareVectorScores","slice","similarity","asCosine","opts","targetStmt","targetRows","target","other","otherNorm","t","len","sampleEvenly","v","exclude","undefined","p","k"],"mappings":"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"}
+{"version":3,"sources":["/Users/kevin/Dev/OpenSource/ai/sensemaking/src/store/sqlite/vectors.ts"],"sourcesContent":["import type { Connection, VectorCandidate, VectorSimilar, VectorWriteRow } from '../types.ts';\nimport { asCosine, compareVectorScores, NATIVE_VECTOR_SCOPE_TABLE, sampleEvenly } from '../vectors.ts';\n\n// One runBatch call per provider batch: the caller (embed/query.ts) already batches by the\n// provider's batchCap, so this is one crossing per batch, never per row.\nexport async function writeVectorBatch(conn: Connection, rows: VectorWriteRow[]): Promise<void> {\n  if (rows.length === 0) return;\n  await conn.runBatch(\n    'UPDATE embeddings SET scale = ?, vector = ? WHERE \"path\" = ? AND chunk = ?',\n    rows.map((row) => [row.scale, row.vector, row.path, row.chunk])\n  );\n}\n\n// Best chunk per file by cosine, its line range riding along: the JS loop over stored int8\n// BLOBs this store's scan strategy is (a native store scans differently, same contract).\nexport async function scanCandidates(conn: Connection, qv: Float32Array, storeDims: number, fetch: number, allowed?: Set<string>, nativeScope = false): Promise<VectorCandidate[]> {\n  const scope = nativeScope ? ` AND \"path\" IN (SELECT \"path\" FROM ${NATIVE_VECTOR_SCOPE_TABLE})` : '';\n  const stmt = await conn.prepare(`SELECT \"path\", chunk, start_line, end_line, vector FROM embeddings WHERE vector IS NOT NULL${scope} ORDER BY \"path\", chunk`);\n  const rows = (await stmt.all()) as Array<{\n    path: string;\n    chunk: number;\n    start_line: number;\n    end_line: number;\n    vector: Uint8Array;\n  }>;\n\n  let queryNorm = 0;\n  for (let d = 0; d < Math.min(storeDims, qv.length); d++) queryNorm += qv[d] * qv[d];\n  queryNorm = Math.sqrt(queryNorm);\n\n  const best = new Map<string, { score: number; chunk: number; lines: string }>();\n  for (const row of rows) {\n    if (allowed && !allowed.has(row.path)) continue;\n    const q = new Int8Array(row.vector.buffer, row.vector.byteOffset, Math.min(storeDims, row.vector.byteLength));\n    // Rounding to int8 costs the stored row its unit norm, so dividing by that norm is what makes\n    // this a cosine rather than a scaled dot product. `scale` cancels out of the ratio.\n    let dot = 0;\n    let norm = 0;\n    const length = Math.min(q.length, qv.length);\n    for (let d = 0; d < length; d++) {\n      dot += q[d] * qv[d];\n      norm += q[d] * q[d];\n    }\n    for (let d = length; d < q.length; d++) norm += q[d] * q[d];\n    const score = norm === 0 || queryNorm === 0 ? 0 : dot / (Math.sqrt(norm) * queryNorm);\n    const existing = best.get(row.path);\n    if (!existing || score > existing.score || (score === existing.score && row.chunk < existing.chunk)) {\n      best.set(row.path, { score, chunk: row.chunk, lines: `L${row.start_line}-${row.end_line}` });\n    }\n  }\n  return [...best.entries()]\n    .map(([path, value]) => ({ path, ...value }))\n    .sort(compareVectorScores)\n    .slice(0, fetch)\n    .map(({ path, lines, score }) => ({ path, lines, similarity: asCosine(score) }));\n}\n\n// Note-to-note similarity is the max cosine over (target chunk, other chunk) pairs, one linear\n// scan of stored vectors.\nexport async function scanSimilar(conn: Connection, path: string, opts: { exclude: Set<string>; allowed?: Set<string>; k: number }, nativeScope = false): Promise<VectorSimilar[]> {\n  const targetStmt = await conn.prepare('SELECT vector FROM embeddings WHERE \"path\" = ? AND vector IS NOT NULL ORDER BY chunk');\n  const targetRows = (await targetStmt.all(path)) as Array<{ vector: Uint8Array }>;\n  if (targetRows.length === 0) return [];\n  // Each side's norm divides its own dot product, so both are taken once here rather than per pair.\n  const target = sampleEvenly(targetRows).map((row) => {\n    const v = new Int8Array(row.vector.buffer, row.vector.byteOffset, row.vector.byteLength);\n    let norm = 0;\n    for (let d = 0; d < v.length; d++) norm += v[d] * v[d];\n    return { v, norm: Math.sqrt(norm) };\n  });\n\n  const scope = nativeScope ? ` AND \"path\" IN (SELECT \"path\" FROM ${NATIVE_VECTOR_SCOPE_TABLE})` : '';\n  const stmt = await conn.prepare(`SELECT \"path\", vector FROM embeddings WHERE vector IS NOT NULL${scope}`);\n  const rows = (await stmt.all()) as Array<{ path: string; vector: Uint8Array }>;\n  const best = new Map<string, number>();\n  for (const row of rows) {\n    if (row.path === path || opts.exclude.has(row.path) || (opts.allowed && !opts.allowed.has(row.path))) continue;\n    const other = new Int8Array(row.vector.buffer, row.vector.byteOffset, row.vector.byteLength);\n    let otherNorm = 0;\n    for (let d = 0; d < other.length; d++) otherNorm += other[d] * other[d];\n    otherNorm = Math.sqrt(otherNorm);\n    for (const t of target) {\n      let dot = 0;\n      const len = Math.min(t.v.length, other.length);\n      for (let d = 0; d < len; d++) dot += t.v[d] * other[d];\n      const score = t.norm === 0 || otherNorm === 0 ? 0 : dot / (t.norm * otherNorm);\n      const existing = best.get(row.path);\n      if (existing === undefined || score > existing) best.set(row.path, score);\n    }\n  }\n\n  return [...best.entries()]\n    .map(([p, score]) => ({ path: p, score }))\n    .sort(compareVectorScores)\n    .slice(0, opts.k)\n    .map(({ path: p, score }) => ({ path: p, similarity: asCosine(score) }));\n}\n"],"names":["scanCandidates","scanSimilar","writeVectorBatch","conn","rows","length","runBatch","map","row","scale","vector","path","chunk","qv","storeDims","fetch","allowed","nativeScope","scope","stmt","queryNorm","d","best","q","dot","norm","score","existing","NATIVE_VECTOR_SCOPE_TABLE","prepare","all","Math","min","sqrt","Map","has","Int8Array","buffer","byteOffset","byteLength","get","set","lines","start_line","end_line","entries","value","sort","compareVectorScores","slice","similarity","asCosine","opts","targetStmt","targetRows","target","other","otherNorm","t","len","sampleEvenly","v","exclude","undefined","p","k"],"mappings":"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"}

package/dist/cjs/store/stages.js.map

@@ -1 +1 @@
-{"version":3,"sources":["/Users/kevin/Dev/OpenSource/ai/sensemaking/src/store/stages.ts"],"sourcesContent":["// Per-stage wall time for one reconcile, all on this thread's clock. Stages name work a build has\n// to do, never the function or file doing it, so the vocabulary outlives a pipeline refactor.\nexport const STAGES_VERSION = 's1';\n\n// Every stage outside the feature hooks, in execution order. Feature hooks add\n// `feature:<name>:<hook>` keys, so a new feature becomes visible without touching this list.\nexport const FIXED_STAGES = ['list', 'existing', 'parse', 'alter', 'added-recheck', 'fm-upsert', 'text-index', 'presets', 'vanished', 'meta'] as const;\n\nexport const FEATURE_HOOKS = ['remove', 'store', 'after'] as const;\n\nexport type FeatureHook = (typeof FEATURE_HOOKS)[number];\n\nexport interface Stages {\n  version: string;\n  totalMs: number;\n  // The write transaction's own duration. It contains most of the spans below, so it is reported\n  // beside them rather than among them, and never counts toward the sum.\n  txMs: number;\n  // Summed worker-side parseFile time inside `parse`: CPU across workers, not a wall span, so it\n  // sits beside the spans like txMs and never counts toward the sum. 0 on the serial path.\n  parseWorkerMs: number;\n  // Disjoint spans, so `totalMs` less their sum is time no stage claims.\n  spans: Record<string, number>;\n}\n\nexport interface StageRecorder {\n  time<T>(stage: string, fn: () => T | Promise<T>): Promise<T>;\n  take(totalMs: number, txMs: number, parseWorkerMs?: number): Stages;\n}\n\nexport function featureStage(name: string, hook: FeatureHook): string {\n  return `feature:${name}:${hook}`;\n}\n\nconst round = (ms: number): number => Math.round(ms * 10) / 10;\n\n// `featureNames` seeds this build's feature-hook keys, so the key set is a function of config\n// alone: a cold build (nothing to remove) and an incremental one report the same stages.\nexport function stageRecorder(featureNames: readonly string[] = []): StageRecorder {\n  const spans = new Map<string, number>();\n  for (const stage of FIXED_STAGES) spans.set(stage, 0);\n  for (const name of featureNames) for (const hook of FEATURE_HOOKS) spans.set(featureStage(name, hook), 0);\n  return {\n    // A throw records nothing: an aborted reconcile must not report a partial stage as a complete one.\n    async time(stage, fn) {\n      const at = process.hrtime.bigint();\n      const value = await fn();\n      spans.set(stage, (spans.get(stage) ?? 0) + Number(process.hrtime.bigint() - at) / 1e6);\n      return value;\n    },\n    // Every declared stage reports, 0 included, so a store that skips some work and a store that\n    // does it cheaply read alike across a timeline. An absent `stages` is a build with no timers.\n    take(totalMs, txMs, parseWorkerMs = 0) {\n      const out: Record<string, number> = {};\n      for (const [stage, ms] of spans) out[stage] = round(ms);\n      return { version: STAGES_VERSION, totalMs: round(totalMs), txMs: round(txMs), parseWorkerMs: round(parseWorkerMs), spans: out };\n    },\n  };\n}\n\n// Time no stage claims: transaction commit, lock wait, and any cost added since without a timer.\n// A residual that grows across releases is the signal that this vocabulary stopped covering the build.\nexport function unaccountedMs(stages: Stages): number {\n  let sum = 0;\n  for (const ms of Object.values(stages.spans)) sum += ms;\n  return round(stages.totalMs - sum);\n}\n"],"names":["FEATURE_HOOKS","FIXED_STAGES","STAGES_VERSION","featureStage","stageRecorder","unaccountedMs","name","hook","round","ms","Math","featureNames","spans","Map","stage","set","time","fn","at","value","process","hrtime","bigint","get","Number","take","totalMs","txMs","parseWorkerMs","out","version","stages","sum","Object","values"],"mappings":"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"}
+{"version":3,"sources":["/Users/kevin/Dev/OpenSource/ai/sensemaking/src/store/stages.ts"],"sourcesContent":["// Per-stage wall time for one reconcile, all on this thread's clock. Stages name work a build has\n// to do, never the function or file doing it, so the vocabulary outlives a pipeline refactor.\nexport const STAGES_VERSION = 's1';\n\n// Every stage outside the feature hooks, in execution order. Feature hooks add\n// `feature:<name>:<hook>` keys, so a new feature becomes visible without touching this list.\nexport const FIXED_STAGES = ['list', 'existing', 'parse', 'alter', 'added-recheck', 'fm-upsert', 'text-index', 'presets', 'vanished', 'meta'] as const;\n\nexport const FEATURE_HOOKS = ['remove', 'store', 'after'] as const;\n\nexport type FeatureHook = (typeof FEATURE_HOOKS)[number];\n\nexport interface Stages {\n  version: string;\n  totalMs: number;\n  // The write transaction's own duration. It contains most of the spans below, so it is reported\n  // beside them rather than among them, and never counts toward the sum.\n  txMs: number;\n  // Summed worker-side parseFile elapsed time inside `parse`: concurrent workers can make it\n  // exceed the wall span, so it sits beside the spans like txMs and never counts toward the sum.\n  parseWorkerMs: number;\n  // Disjoint spans, so `totalMs` less their sum is time no stage claims.\n  spans: Record<string, number>;\n}\n\nexport interface StageRecorder {\n  time<T>(stage: string, fn: () => T | Promise<T>): Promise<T>;\n  take(totalMs: number, txMs: number, parseWorkerMs?: number): Stages;\n}\n\nexport function featureStage(name: string, hook: FeatureHook): string {\n  return `feature:${name}:${hook}`;\n}\n\nconst round = (ms: number): number => Math.round(ms * 10) / 10;\n\n// `featureNames` seeds this build's feature-hook keys, so the key set is a function of config\n// alone: a cold build (nothing to remove) and an incremental one report the same stages.\nexport function stageRecorder(featureNames: readonly string[] = []): StageRecorder {\n  const spans = new Map<string, number>();\n  for (const stage of FIXED_STAGES) spans.set(stage, 0);\n  for (const name of featureNames) for (const hook of FEATURE_HOOKS) spans.set(featureStage(name, hook), 0);\n  return {\n    // A throw records nothing: an aborted reconcile must not report a partial stage as a complete one.\n    async time(stage, fn) {\n      const at = process.hrtime.bigint();\n      const value = await fn();\n      spans.set(stage, (spans.get(stage) ?? 0) + Number(process.hrtime.bigint() - at) / 1e6);\n      return value;\n    },\n    // Every declared stage reports, 0 included, so a store that skips some work and a store that\n    // does it cheaply read alike across a timeline. An absent `stages` is a build with no timers.\n    take(totalMs, txMs, parseWorkerMs = 0) {\n      const out: Record<string, number> = {};\n      for (const [stage, ms] of spans) out[stage] = round(ms);\n      return { version: STAGES_VERSION, totalMs: round(totalMs), txMs: round(txMs), parseWorkerMs: round(parseWorkerMs), spans: out };\n    },\n  };\n}\n\n// Time no stage claims: transaction commit, lock wait, and any cost added since without a timer.\n// A residual that grows across releases is the signal that this vocabulary stopped covering the build.\nexport function unaccountedMs(stages: Stages): number {\n  let sum = 0;\n  for (const ms of Object.values(stages.spans)) sum += ms;\n  return round(stages.totalMs - sum);\n}\n"],"names":["FEATURE_HOOKS","FIXED_STAGES","STAGES_VERSION","featureStage","stageRecorder","unaccountedMs","name","hook","round","ms","Math","featureNames","spans","Map","stage","set","time","fn","at","value","process","hrtime","bigint","get","Number","take","totalMs","txMs","parseWorkerMs","out","version","stages","sum","Object","values"],"mappings":"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"}

package/dist/cjs/store/turso/connection.d.cts

@@ -1,5 +1,6 @@
 import type { Database } from '@tursodatabase/database';
 import type { Connection } from '../types.js';
+export declare const INSERT_BIND_BUDGET = 8192;
 export declare function checkpointWal(db: Database): Promise<void>;
 export declare function cacheFilePath(conn: Connection): Promise<string | null>;
 export declare function fileSize(path: string): Promise<number | null>;

package/dist/cjs/store/turso/connection.d.ts

@@ -1,5 +1,6 @@
 import type { Database } from '@tursodatabase/database';
 import type { Connection } from '../types.js';
+export declare const INSERT_BIND_BUDGET = 8192;
 export declare function checkpointWal(db: Database): Promise<void>;
 export declare function cacheFilePath(conn: Connection): Promise<string | null>;
 export declare function fileSize(path: string): Promise<number | null>;