sensemaking 0.25.1 → 0.27.0

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

@@ -3,7 +3,7 @@ import type { ResolvedConfig } from '../../config/index.js';
 import type { InternalOpenOptions, OpenResult } from '../open.js';
 import type { OpenDialect } from '../types.js';
 export declare const DB_FILENAME = "cache.turso.db";
-export declare const SCHEMA_VERSION = "9";
+export declare const SCHEMA_VERSION = "10";
 export type { OpenResult };
 export declare const tursoOpenDialect: OpenDialect<Database>;
 export declare function openTurso(cfg: ResolvedConfig, options?: InternalOpenOptions): Promise<OpenResult>;

package/dist/cjs/store/turso/open.js

@@ -22,10 +22,9 @@ _export(exports, {
         return tursoOpenDialect;
     }
 });
-var _indexts = require("../../config/index.js");
 var _typests = require("../../embed/types.js");
 var _errorsts = require("../../errors.js");
-var _indexts1 = require("../../features/index.js");
+var _indexts = require("../../features/index.js");
 var _opents = require("../open.js");
 var _sharedts = require("../shared.js");
 var _connectionts = require("./connection.js");
@@ -240,12 +239,12 @@ function _unsupported_iterable_to_array(o, minLen) {
     if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _array_like_to_array(o, minLen);
 }
 var DB_FILENAME = 'cache.turso.db';
-var SCHEMA_VERSION = '9';
+var SCHEMA_VERSION = '10';
 // This store's Handle (types.ts's OpenDialect<Handle>) is the connected Database itself: no
 // extra native state to thread, unlike duckdb's separate instance/connection pair.
-function ensureSchema(_handle, conn, cfg) {
+function ensureCoreSchema(_handle, conn) {
     return _async_to_generator(function() {
-        var _iteratorNormalCompletion, _didIteratorError, _iteratorError, _iterator, _step, ddl, err, _iteratorNormalCompletion1, _didIteratorError1, _iteratorError1, _iterator1, _step1, feature, err;
+        var _iteratorNormalCompletion, _didIteratorError, _iteratorError, _iterator, _step, ddl, err;
         return _ts_generator(this, function(_state) {
             switch(_state.label){
                 case 0:
@@ -336,112 +335,108 @@ function ensureSchema(_handle, conn, cfg) {
                     ];
                 case 13:
                     _state.sent();
-                    _iteratorNormalCompletion1 = true, _didIteratorError1 = false, _iteratorError1 = undefined;
-                    _state.label = 14;
+                    return [
+                        4,
+                        (0, _sharedts.getMeta)(conn, 'schema_version')
+                    ];
                 case 14:
+                    if (!(_state.sent() === null)) return [
+                        3,
+                        16
+                    ];
+                    return [
+                        4,
+                        (0, _sharedts.setMeta)(conn, 'schema_version', SCHEMA_VERSION)
+                    ];
+                case 15:
+                    _state.sent();
+                    _state.label = 16;
+                case 16:
+                    return [
+                        2
+                    ];
+            }
+        });
+    })();
+}
+function ensureFeatureSchema(_handle, conn, cfg) {
+    return _async_to_generator(function() {
+        var _iteratorNormalCompletion, _didIteratorError, _iteratorError, _iterator, _step, feature, err;
+        return _ts_generator(this, function(_state) {
+            switch(_state.label){
+                case 0:
+                    _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+                    _state.label = 1;
+                case 1:
                     _state.trys.push([
-                        14,
-                        21,
-                        22,
-                        23
+                        1,
+                        8,
+                        9,
+                        10
                     ]);
-                    _iterator1 = (0, _indexts1.activeFeatures)(cfg)[Symbol.iterator]();
-                    _state.label = 15;
-                case 15:
-                    if (!!(_iteratorNormalCompletion1 = (_step1 = _iterator1.next()).done)) return [
+                    _iterator = (0, _indexts.activeFeatures)(cfg)[Symbol.iterator]();
+                    _state.label = 2;
+                case 2:
+                    if (!!(_iteratorNormalCompletion = (_step = _iterator.next()).done)) return [
                         3,
-                        20
+                        7
                     ];
-                    feature = _step1.value;
+                    feature = _step.value;
                     if (!(feature.name === 'embed')) return [
                         3,
-                        17
+                        4
                     ];
                     return [
                         4,
-                        conn.exec('CREATE TABLE IF NOT EXISTS embeddings ("path" TEXT, chunk INTEGER, start_line INTEGER, end_line INTEGER, scale REAL, vector F32_BLOB('.concat(_typests.STORE_DIMS, '), PRIMARY KEY ("path", chunk))'))
+                        conn.exec('CREATE TABLE IF NOT EXISTS embeddings ("path" TEXT, chunk INTEGER, start_line INTEGER, end_line INTEGER, content_identity TEXT NOT NULL, scale REAL, vector F32_BLOB('.concat(_typests.STORE_DIMS, '), PRIMARY KEY ("path", chunk))'))
                     ];
-                case 16:
+                case 3:
                     _state.sent();
                     return [
                         3,
-                        19
+                        6
                     ];
-                case 17:
+                case 4:
                     return [
                         4,
                         feature.schema(conn)
                     ];
-                case 18:
+                case 5:
                     _state.sent();
-                    _state.label = 19;
-                case 19:
-                    _iteratorNormalCompletion1 = true;
+                    _state.label = 6;
+                case 6:
+                    _iteratorNormalCompletion = true;
                     return [
                         3,
-                        15
+                        2
                     ];
-                case 20:
+                case 7:
                     return [
                         3,
-                        23
+                        10
                     ];
-                case 21:
+                case 8:
                     err = _state.sent();
-                    _didIteratorError1 = true;
-                    _iteratorError1 = err;
+                    _didIteratorError = true;
+                    _iteratorError = err;
                     return [
                         3,
-                        23
+                        10
                     ];
-                case 22:
+                case 9:
                     try {
-                        if (!_iteratorNormalCompletion1 && _iterator1.return != null) {
-                            _iterator1.return();
+                        if (!_iteratorNormalCompletion && _iterator.return != null) {
+                            _iterator.return();
                         }
                     } finally{
-                        if (_didIteratorError1) {
-                            throw _iteratorError1;
+                        if (_didIteratorError) {
+                            throw _iteratorError;
                         }
                     }
                     return [
                         7
                     ];
-                case 23:
-                    return [
-                        4,
-                        (0, _sharedts.getMeta)(conn, 'schema_version')
-                    ];
-                case 24:
-                    if (!(_state.sent() === null)) return [
-                        3,
-                        26
-                    ];
-                    return [
-                        4,
-                        (0, _sharedts.setMeta)(conn, 'schema_version', SCHEMA_VERSION)
-                    ];
-                case 25:
-                    _state.sent();
-                    _state.label = 26;
-                case 26:
-                    return [
-                        4,
-                        (0, _sharedts.getMeta)(conn, 'features')
-                    ];
-                case 27:
-                    if (!(_state.sent() === null)) return [
-                        3,
-                        29
-                    ];
-                    return [
-                        4,
-                        (0, _sharedts.setMeta)(conn, 'features', (0, _indexts.featureSignature)(cfg, _indexts1.FEATURES))
-                    ];
-                case 28:
-                    _state.sent();
-                    _state.label = 29;
-                case 29:
+                case 10:
                     return [
                         2
                     ];
@@ -576,7 +571,8 @@ var tursoOpenDialect = {
     isLocked: function isLocked(err) {
         return /File is locked by another process|locked a portion of the file/.test(err.message);
     },
-    ensureSchema: ensureSchema,
+    ensureCoreSchema: ensureCoreSchema,
+    ensureFeatureSchema: ensureFeatureSchema,
     setDerivedBusyTimeout: setDerivedBusyTimeout,
     createStore: function createStore(handle, conn, _cfg, options) {
         return (0, _storets.createStore)(handle, conn, options);

package/dist/cjs/store/turso/open.js.map

@@ -1 +1 @@
-{"version":3,"sources":["/Users/kevin/Dev/OpenSource/ai/sensemaking/src/store/turso/open.ts"],"sourcesContent":["import type { Database } from '@tursodatabase/database';\nimport type { Config, ResolvedConfig } from '../../config/index.ts';\nimport { featureSignature } from '../../config/index.ts';\nimport { STORE_DIMS } from '../../embed/types.ts';\nimport { SenseError } from '../../errors.ts';\nimport { activeFeatures, FEATURES } from '../../features/index.ts';\nimport type { InternalOpenOptions, OpenResult } from '../open.ts';\nimport { openWithDialect } from '../open.ts';\nimport { getMeta, setMeta } from '../shared.ts';\nimport type { Connection, OpenDialect } from '../types.ts';\nimport { checkpointWal, createConnection } from './connection.ts';\nimport { CONNECT_OPTS, TURSO_PACKAGE, tursoApi } from './native.ts';\nimport { CONTENT_FTS_DDL, tursoDialect } from './reconcile.ts';\nimport { createStore } from './store.ts';\n\nexport const DB_FILENAME = 'cache.turso.db';\n// Independent of sqlite's and duckdb's SCHEMA_VERSION: each store's cache shape evolves\n// separately. Covers the FTS indexes, the \"_ngram\" sidecar columns, and embeddings.vector's width.\nexport const SCHEMA_VERSION = '9';\n\nexport type { OpenResult };\n\n// This store's Handle (types.ts's OpenDialect<Handle>) is the connected Database itself: no\n// extra native state to thread, unlike duckdb's separate instance/connection pair.\nasync function ensureSchema(_handle: Database, conn: Connection, cfg: Config): Promise<void> {\n  await conn.exec(`CREATE TABLE IF NOT EXISTS frontmatter (\"path\" TEXT PRIMARY KEY, \"_mtime\" REAL, \"_ctime\" REAL, \"_size\" INTEGER, \"_parse_error\" TEXT)`);\n  await conn.exec(`CREATE TABLE IF NOT EXISTS content (\"path\" TEXT PRIMARY KEY, title TEXT, summary TEXT, text TEXT, title_stem TEXT, summary_stem TEXT, text_stem TEXT, title_ngram TEXT, summary_ngram TEXT, text_ngram TEXT)`);\n  await conn.exec(`CREATE TABLE IF NOT EXISTS indexed_sources (\"path\" TEXT PRIMARY KEY, text TEXT NOT NULL)`);\n  for (const ddl of CONTENT_FTS_DDL) await conn.exec(ddl);\n  await conn.exec(`CREATE TABLE IF NOT EXISTS preset_files (\"path\" TEXT, preset TEXT, PRIMARY KEY (\"path\", preset))`);\n  await conn.exec('CREATE INDEX IF NOT EXISTS preset_files_preset ON preset_files(preset)');\n  for (const feature of activeFeatures(cfg)) {\n    // Native F32_BLOB(STORE_DIMS) instead of the embed feature's engine-neutral BLOB DDL. `scale`\n    // is kept unused, so the shared reconcile-time INSERT/DELETE names a column both stores have.\n    if (feature.name === 'embed') {\n      await conn.exec(`CREATE TABLE IF NOT EXISTS embeddings (\"path\" TEXT, chunk INTEGER, start_line INTEGER, end_line INTEGER, scale REAL, vector F32_BLOB(${STORE_DIMS}), PRIMARY KEY (\"path\", chunk))`);\n      continue;\n    }\n    await feature.schema(conn);\n  }\n  if ((await getMeta(conn, 'schema_version')) === null) await setMeta(conn, 'schema_version', SCHEMA_VERSION);\n  if ((await getMeta(conn, 'features')) === null) await setMeta(conn, 'features', featureSignature(cfg, FEATURES));\n}\n\nasync function close(handle: Database, options: { observational?: boolean } = {}): Promise<void> {\n  if (!options.observational) await checkpointWal(handle);\n  await handle.close();\n}\n\nasync function setDerivedBusyTimeout(_handle: Database, conn: Connection, ms: number): Promise<void> {\n  await conn.exec(`PRAGMA busy_timeout = ${ms}`);\n}\n\nasync function connect(dbPath: string, _cfg: ResolvedConfig, options: { existingOnly: boolean; observational: boolean }): Promise<{ handle: Database; conn: Connection }> {\n  // Dynamic, not a top-level import: a sqlite or duckdb tree must never attempt to resolve this\n  // optional dependency until a turso tree is actually opened. Installed on first use if missing.\n  let turso: Awaited<ReturnType<typeof tursoApi>>;\n  try {\n    turso = await tursoApi();\n  } catch (err) {\n    if (err instanceof SenseError) throw err;\n    throw new SenseError('STORE_DEPENDENCY_MISSING', `store \"turso\" needs the ${TURSO_PACKAGE} package (${(err as Error).message})`);\n  }\n\n  let db: Database;\n  try {\n    // Turso's readonly mode rejects native FTS SELECTs and TEMP query tables. Existing-only opens\n    // stay query-capable; shared no-build orchestration and observational close prevent upkeep writes.\n    db = await turso.connect(dbPath, { ...CONNECT_OPTS, experimental: [...CONNECT_OPTS.experimental], ...(options.existingOnly ? { fileMustExist: true } : {}) });\n  } catch (err) {\n    throw new SenseError('STORE_DEPENDENCY_MISSING', `store \"turso\" failed to open ${dbPath}: ${(err as Error).message}`);\n  }\n  return { handle: db, conn: createConnection(db) };\n}\n\n// This store's dialect (types.ts's OpenDialect) for the shared orchestration in store/open.ts.\nexport const tursoOpenDialect: OpenDialect<Database> = {\n  filename: DB_FILENAME,\n  schemaVersion: SCHEMA_VERSION,\n  reconcileDialect: tursoDialect,\n  connect,\n  close,\n  // \"Locking error: Failed locking file ...\", worded per platform: posix \"File is locked by another\n  // process\", Windows \"another process has locked a portion of the file (os error 33)\". Distinct from\n  // the write-time \"database is locked\" its connect-time `timeout` covers; that one never reaches here.\n  isLocked: (err) => /File is locked by another process|locked a portion of the file/.test(err.message),\n  ensureSchema,\n  setDerivedBusyTimeout,\n  createStore: (handle, conn, _cfg, options) => createStore(handle, conn, options),\n};\n\nexport async function openTurso(cfg: ResolvedConfig, options?: InternalOpenOptions): Promise<OpenResult> {\n  return openWithDialect(cfg, tursoOpenDialect, options);\n}\n"],"names":["DB_FILENAME","SCHEMA_VERSION","openTurso","tursoOpenDialect","ensureSchema","_handle","conn","cfg","ddl","feature","exec","CONTENT_FTS_DDL","activeFeatures","name","STORE_DIMS","schema","getMeta","setMeta","featureSignature","FEATURES","close","handle","options","observational","checkpointWal","setDerivedBusyTimeout","ms","connect","dbPath","_cfg","turso","err","db","tursoApi","SenseError","TURSO_PACKAGE","message","CONNECT_OPTS","experimental","existingOnly","fileMustExist","createConnection","filename","schemaVersion","reconcileDialect","tursoDialect","isLocked","test","createStore","openWithDialect"],"mappings":"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"}
+{"version":3,"sources":["/Users/kevin/Dev/OpenSource/ai/sensemaking/src/store/turso/open.ts"],"sourcesContent":["import type { Database } from '@tursodatabase/database';\nimport type { Config, ResolvedConfig } from '../../config/index.ts';\nimport { STORE_DIMS } from '../../embed/types.ts';\nimport { SenseError } from '../../errors.ts';\nimport { activeFeatures } from '../../features/index.ts';\nimport type { InternalOpenOptions, OpenResult } from '../open.ts';\nimport { openWithDialect } from '../open.ts';\nimport { getMeta, setMeta } from '../shared.ts';\nimport type { Connection, OpenDialect } from '../types.ts';\nimport { checkpointWal, createConnection } from './connection.ts';\nimport { CONNECT_OPTS, TURSO_PACKAGE, tursoApi } from './native.ts';\nimport { CONTENT_FTS_DDL, tursoDialect } from './reconcile.ts';\nimport { createStore } from './store.ts';\n\nexport const DB_FILENAME = 'cache.turso.db';\n// Independent of sqlite's and duckdb's SCHEMA_VERSION: each store's cache shape evolves\n// separately. Covers the FTS indexes, the \"_ngram\" sidecar columns, and embeddings.vector's width.\nexport const SCHEMA_VERSION = '10';\n\nexport type { OpenResult };\n\n// This store's Handle (types.ts's OpenDialect<Handle>) is the connected Database itself: no\n// extra native state to thread, unlike duckdb's separate instance/connection pair.\nasync function ensureCoreSchema(_handle: Database, conn: Connection): Promise<void> {\n  await conn.exec(`CREATE TABLE IF NOT EXISTS frontmatter (\"path\" TEXT PRIMARY KEY, \"_mtime\" REAL, \"_ctime\" REAL, \"_size\" INTEGER, \"_parse_error\" TEXT)`);\n  await conn.exec(`CREATE TABLE IF NOT EXISTS content (\"path\" TEXT PRIMARY KEY, title TEXT, summary TEXT, text TEXT, title_stem TEXT, summary_stem TEXT, text_stem TEXT, title_ngram TEXT, summary_ngram TEXT, text_ngram TEXT)`);\n  await conn.exec(`CREATE TABLE IF NOT EXISTS indexed_sources (\"path\" TEXT PRIMARY KEY, text TEXT NOT NULL)`);\n  for (const ddl of CONTENT_FTS_DDL) await conn.exec(ddl);\n  await conn.exec(`CREATE TABLE IF NOT EXISTS preset_files (\"path\" TEXT, preset TEXT, PRIMARY KEY (\"path\", preset))`);\n  await conn.exec('CREATE INDEX IF NOT EXISTS preset_files_preset ON preset_files(preset)');\n  if ((await getMeta(conn, 'schema_version')) === null) await setMeta(conn, 'schema_version', SCHEMA_VERSION);\n}\n\nasync function ensureFeatureSchema(_handle: Database, conn: Connection, cfg: Config): Promise<void> {\n  for (const feature of activeFeatures(cfg)) {\n    // Native F32_BLOB(STORE_DIMS) instead of the embed feature's engine-neutral BLOB DDL. `scale`\n    // is kept unused, so the shared reconcile-time INSERT/DELETE names a column both stores have.\n    if (feature.name === 'embed') {\n      await conn.exec(`CREATE TABLE IF NOT EXISTS embeddings (\"path\" TEXT, chunk INTEGER, start_line INTEGER, end_line INTEGER, content_identity TEXT NOT NULL, scale REAL, vector F32_BLOB(${STORE_DIMS}), PRIMARY KEY (\"path\", chunk))`);\n      continue;\n    }\n    await feature.schema(conn);\n  }\n}\n\nasync function close(handle: Database, options: { observational?: boolean } = {}): Promise<void> {\n  if (!options.observational) await checkpointWal(handle);\n  await handle.close();\n}\n\nasync function setDerivedBusyTimeout(_handle: Database, conn: Connection, ms: number): Promise<void> {\n  await conn.exec(`PRAGMA busy_timeout = ${ms}`);\n}\n\nasync function connect(dbPath: string, _cfg: ResolvedConfig, options: { existingOnly: boolean; observational: boolean }): Promise<{ handle: Database; conn: Connection }> {\n  // Dynamic, not a top-level import: a sqlite or duckdb tree must never attempt to resolve this\n  // optional dependency until a turso tree is actually opened. Installed on first use if missing.\n  let turso: Awaited<ReturnType<typeof tursoApi>>;\n  try {\n    turso = await tursoApi();\n  } catch (err) {\n    if (err instanceof SenseError) throw err;\n    throw new SenseError('STORE_DEPENDENCY_MISSING', `store \"turso\" needs the ${TURSO_PACKAGE} package (${(err as Error).message})`);\n  }\n\n  let db: Database;\n  try {\n    // Turso's readonly mode rejects native FTS SELECTs and TEMP query tables. Existing-only opens\n    // stay query-capable; shared no-build orchestration and observational close prevent upkeep writes.\n    db = await turso.connect(dbPath, { ...CONNECT_OPTS, experimental: [...CONNECT_OPTS.experimental], ...(options.existingOnly ? { fileMustExist: true } : {}) });\n  } catch (err) {\n    throw new SenseError('STORE_DEPENDENCY_MISSING', `store \"turso\" failed to open ${dbPath}: ${(err as Error).message}`);\n  }\n  return { handle: db, conn: createConnection(db) };\n}\n\n// This store's dialect (types.ts's OpenDialect) for the shared orchestration in store/open.ts.\nexport const tursoOpenDialect: OpenDialect<Database> = {\n  filename: DB_FILENAME,\n  schemaVersion: SCHEMA_VERSION,\n  reconcileDialect: tursoDialect,\n  connect,\n  close,\n  // \"Locking error: Failed locking file ...\", worded per platform: posix \"File is locked by another\n  // process\", Windows \"another process has locked a portion of the file (os error 33)\". Distinct from\n  // the write-time \"database is locked\" its connect-time `timeout` covers; that one never reaches here.\n  isLocked: (err) => /File is locked by another process|locked a portion of the file/.test(err.message),\n  ensureCoreSchema,\n  ensureFeatureSchema,\n  setDerivedBusyTimeout,\n  createStore: (handle, conn, _cfg, options) => createStore(handle, conn, options),\n};\n\nexport async function openTurso(cfg: ResolvedConfig, options?: InternalOpenOptions): Promise<OpenResult> {\n  return openWithDialect(cfg, tursoOpenDialect, options);\n}\n"],"names":["DB_FILENAME","SCHEMA_VERSION","openTurso","tursoOpenDialect","ensureCoreSchema","_handle","conn","ddl","exec","CONTENT_FTS_DDL","getMeta","setMeta","ensureFeatureSchema","cfg","feature","activeFeatures","name","STORE_DIMS","schema","close","handle","options","observational","checkpointWal","setDerivedBusyTimeout","ms","connect","dbPath","_cfg","turso","err","db","tursoApi","SenseError","TURSO_PACKAGE","message","CONNECT_OPTS","experimental","existingOnly","fileMustExist","createConnection","filename","schemaVersion","reconcileDialect","tursoDialect","isLocked","test","createStore","openWithDialect"],"mappings":"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"}

package/dist/cjs/store/turso/store.js

@@ -23,7 +23,6 @@ var _vectorsts = require("../vectors.js");
 var _connectionts = require("./connection.js");
 var _fieldStatsts = require("./fieldStats.js");
 var _lexicalts = require("./lexical.js");
-var _sqlfunctionsts = require("./sql-functions.js");
 var _vectorsts1 = require("./vectors.js");
 function _array_like_to_array(arr, len) {
     if (len == null || len > arr.length) len = arr.length;
@@ -371,6 +370,27 @@ var CAPABILITIES = new Set([
 var BLOAT_FACTOR = 1.5;
 function createStore(db, conn) {
     var options = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : {};
+    var vectorScope = (0, _vectorsts.createNativeVectorScopeOwner)();
+    // The column's fixed DDL width (STORE_DIMS) is what every scan binds against, not the
+    // interface's per-call storeDims -- see vectors.ts's padded() for why a shorter vector is still correct against a wider column.
+    var vectors = {
+        pending: function pending() {
+            return (0, _vectorsts.pendingRows)(conn);
+        },
+        writeVectors: function writeVectors(rows) {
+            return (0, _vectorsts1.writeVectorBatch)(conn, _typests.STORE_DIMS, rows);
+        },
+        candidates: function candidates(qv, _storeDims, fetch, allowed) {
+            return (0, _vectorsts1.scanCandidates)(conn, qv, _typests.STORE_DIMS, fetch, allowed, vectorScope.activeFor(allowed));
+        },
+        similar: function similar(path, opts) {
+            return (0, _vectorsts1.scanSimilar)(conn, _typests.STORE_DIMS, path, opts, vectorScope.activeFor(opts.allowed));
+        },
+        hasVector: function hasVector(path) {
+            return (0, _vectorsts.hasVectorRow)(conn, path);
+        }
+    };
+    vectorScope.bind(vectors);
     return {
         name: 'turso',
         capabilities: CAPABILITIES,
@@ -460,25 +480,7 @@ function createStore(db, conn) {
                 return (0, _lexicalts.queryLexical)(conn, terms, opts);
             }
         },
-        // The column's fixed DDL width (STORE_DIMS) is what every scan binds against, not the
-        // interface's per-call storeDims -- see vectors.ts's padded() for why a shorter vector is still correct against a wider column.
-        vectors: {
-            pending: function pending() {
-                return (0, _vectorsts.pendingRows)(conn);
-            },
-            writeVectors: function writeVectors(rows) {
-                return (0, _vectorsts1.writeVectorBatch)(conn, _typests.STORE_DIMS, rows);
-            },
-            candidates: function candidates(qv, _storeDims, fetch, allowed) {
-                return (0, _vectorsts1.scanCandidates)(conn, qv, _typests.STORE_DIMS, fetch, allowed);
-            },
-            similar: function similar(path, opts) {
-                return (0, _vectorsts1.scanSimilar)(conn, _typests.STORE_DIMS, path, opts);
-            },
-            hasVector: function hasVector(path) {
-                return (0, _vectorsts.hasVectorRow)(conn, path);
-            }
-        },
+        vectors: vectors,
         engineStatus: function engineStatus() {
             return _async_to_generator(function() {
                 var row;
@@ -487,7 +489,7 @@ function createStore(db, conn) {
                         case 0:
                             return [
                                 4,
-                                db.prepare('PRAGMA busy_timeout')
+                                conn.prepare('PRAGMA busy_timeout')
                             ];
                         case 1:
                             return [
@@ -515,11 +517,11 @@ function createStore(db, conn) {
                             case 0:
                                 return [
                                     4,
-                                    db.prepare((0, _sqlfunctionsts.rewriteFunctions)(sql))
+                                    conn.prepare(sql)
                                 ];
                             case 1:
                                 stmt = _state.sent();
-                                stmt.safeIntegers(true); // int64 past 2^53 arrives as BigInt instead of losing precision
+                                stmt.setReadBigInts(true); // int64 past 2^53 arrives as BigInt instead of losing precision
                                 return [
                                     2,
                                     {

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

@@ -1 +1 @@
-{"version":3,"sources":["/Users/kevin/Dev/OpenSource/ai/sensemaking/src/store/turso/store.ts"],"sourcesContent":["import type { Database } from '@tursodatabase/database';\nimport { STORE_DIMS } from '../../embed/types.ts';\nimport { getColumns, getMeta, setMeta } from '../shared.ts';\nimport { withTransaction } from '../transaction.ts';\nimport type { Capability, Connection, Statement, Store } from '../types.ts';\nimport { hasVectorRow, pendingRows } from '../vectors.ts';\nimport { cacheFilePath, checkpointWal, fileSize, reclaimSpace } from './connection.ts';\nimport { fieldStats } from './fieldStats.ts';\nimport { queryLexical } from './lexical.ts';\nimport { rewriteFunctions } from './sql-functions.ts';\nimport { scanCandidates, scanSimilar, writeVectorBatch } from './vectors.ts';\n\n// No 'segment': has()/basename() resolve via SQL rewrite below (sql-functions.ts), but segment() has no SQL form and the client cannot register it as a UDF.\nexport const CAPABILITIES: ReadonlySet<Capability> = new Set(['vectors']);\n\n// close() reclaims once the cache file outgrows its compact size by this factor: the disk\n// overhead a user should accept (PLAN 3.52), in postgres autovacuum scale-factor shape.\nconst BLOAT_FACTOR = 1.5;\n\n// Shares one Connection instance (conn) with the builder's own reconcile call so transaction depth\n// (see transaction.ts) is tracked against the same object everywhere.\nexport function createStore(db: Database, conn: Connection, options: { observational?: boolean } = {}): Store {\n  return {\n    name: 'turso',\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      fieldStats: (columns, scopeWhere) => fieldStats(conn, columns, scopeWhere),\n    },\n    lexical: {\n      query: (terms, opts) => queryLexical(conn, terms, opts),\n    },\n    // The column's fixed DDL width (STORE_DIMS) is what every scan binds against, not the\n    // interface's per-call storeDims -- see vectors.ts's padded() for why a shorter vector is still correct against a wider column.\n    vectors: {\n      pending: () => pendingRows(conn),\n      writeVectors: (rows) => writeVectorBatch(conn, STORE_DIMS, rows),\n      candidates: (qv, _storeDims, fetch, allowed) => scanCandidates(conn, qv, STORE_DIMS, fetch, allowed),\n      similar: (path, opts) => scanSimilar(conn, STORE_DIMS, path, opts),\n      hasVector: (path) => hasVectorRow(conn, path),\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). Turso's PRAGMA busy_timeout names its column \"busy_timeout\" (spike-verified), not \"timeout\" like real SQLite.\n      const row = (await (await db.prepare('PRAGMA busy_timeout')).get()) as { busy_timeout: number };\n      return { busy_timeout: `${row.busy_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 = await db.prepare(rewriteFunctions(sql));\n        stmt.safeIntegers(true); // int64 past 2^53 arrives as BigInt instead of losing precision\n        return {\n          columns: () => stmt.columns(),\n          // sense sql streams through the client's own async generator.\n          iterate: async function* (...params: unknown[]) {\n            yield* stmt.iterate(...params);\n          },\n        };\n      },\n    },\n    async close() {\n      if (options.observational) {\n        await db.close();\n        return;\n      }\n      // Checkpoint before measuring: the last reconcile's pages sit in the WAL, not the file yet.\n      await checkpointWal(db);\n      let reclaimPath: string | null = null;\n      try {\n        const path = await cacheFilePath(conn);\n        const base = Number((await getMeta(conn, 'compact_size')) ?? '0');\n        const size = path === null ? null : await fileSize(path);\n        if (size !== null) {\n          // No baseline yet (cold build or an upgraded cache): record it, never reclaim here, so a\n          // cold build pays no VACUUM (PLAN 3.49 Track A) and an upgraded cache heals on a crossing.\n          if (base === 0) {\n            await setMeta(conn, 'compact_size', String(size));\n            // The meta write landed past the checkpoint; leave no WAL for the next opener.\n            await checkpointWal(db);\n          } else if (size > BLOAT_FACTOR * base) {\n            reclaimPath = path;\n          }\n        }\n      } catch (err) {\n        console.error(`sense: turso cache bloat check failed, the cache will keep its space until one succeeds: ${(err as Error).message}`);\n      }\n      await db.close();\n      // After this store's connection is closed, never before: turso hands the file to one\n      // connection at a time, and reclaimSpace opens its own to carry the `vacuum` flag (PLAN 3.54).\n      if (reclaimPath !== null) await reclaimSpace(reclaimPath);\n    },\n  };\n}\n"],"names":["CAPABILITIES","createStore","Set","BLOAT_FACTOR","db","conn","options","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","STORE_DIMS","candidates","qv","_storeDims","fetch","allowed","scanCandidates","similar","path","scanSimilar","hasVector","hasVectorRow","engineStatus","row","get","busy_timeout","raw","stmt","rewriteFunctions","safeIntegers","iterate","params","close","reclaimPath","base","size","err","observational","checkpointWal","cacheFilePath","getMeta","Number","fileSize","setMeta","String","console","error","message","reclaimSpace"],"mappings":"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"}
+{"version":3,"sources":["/Users/kevin/Dev/OpenSource/ai/sensemaking/src/store/turso/store.ts"],"sourcesContent":["import type { Database } from '@tursodatabase/database';\nimport { STORE_DIMS } from '../../embed/types.ts';\nimport { getColumns, getMeta, setMeta } from '../shared.ts';\nimport { withTransaction } from '../transaction.ts';\nimport type { Capability, Connection, Statement, Store, VectorStore } from '../types.ts';\nimport { createNativeVectorScopeOwner, hasVectorRow, pendingRows } from '../vectors.ts';\nimport { cacheFilePath, checkpointWal, fileSize, reclaimSpace } from './connection.ts';\nimport { fieldStats } from './fieldStats.ts';\nimport { queryLexical } from './lexical.ts';\nimport { scanCandidates, scanSimilar, writeVectorBatch } from './vectors.ts';\n\n// No 'segment': has()/basename() resolve via SQL rewrite below (sql-functions.ts), but segment() has no SQL form and the client cannot register it as a UDF.\nexport const CAPABILITIES: ReadonlySet<Capability> = new Set(['vectors']);\n\n// close() reclaims once the cache file outgrows its compact size by this factor: the disk\n// overhead a user should accept (PLAN 3.52), in postgres autovacuum scale-factor shape.\nconst BLOAT_FACTOR = 1.5;\n\n// Shares one Connection instance (conn) with the builder's own reconcile call so transaction depth\n// (see transaction.ts) is tracked against the same object everywhere.\nexport function createStore(db: Database, conn: Connection, options: { observational?: boolean } = {}): Store {\n  const vectorScope = createNativeVectorScopeOwner();\n  // The column's fixed DDL width (STORE_DIMS) is what every scan binds against, not the\n  // interface's per-call storeDims -- see vectors.ts's padded() for why a shorter vector is still correct against a wider column.\n  const vectors: VectorStore = {\n    pending: () => pendingRows(conn),\n    writeVectors: (rows) => writeVectorBatch(conn, STORE_DIMS, rows),\n    candidates: (qv, _storeDims, fetch, allowed) => scanCandidates(conn, qv, STORE_DIMS, fetch, allowed, vectorScope.activeFor(allowed)),\n    similar: (path, opts) => scanSimilar(conn, STORE_DIMS, path, opts, vectorScope.activeFor(opts.allowed)),\n    hasVector: (path) => hasVectorRow(conn, path),\n  };\n  vectorScope.bind(vectors);\n\n  return {\n    name: 'turso',\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      fieldStats: (columns, scopeWhere) => fieldStats(conn, columns, scopeWhere),\n    },\n    lexical: {\n      query: (terms, opts) => queryLexical(conn, terms, opts),\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). Turso's PRAGMA busy_timeout names its column \"busy_timeout\" (spike-verified), not \"timeout\" like real SQLite.\n      const row = (await (await conn.prepare('PRAGMA busy_timeout')).get()) as { busy_timeout: number };\n      return { busy_timeout: `${row.busy_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 = await conn.prepare(sql);\n        stmt.setReadBigInts(true); // int64 past 2^53 arrives as BigInt instead of losing precision\n        return {\n          columns: () => stmt.columns(),\n          // sense sql streams through the client's own async generator.\n          iterate: async function* (...params: unknown[]) {\n            yield* stmt.iterate(...params);\n          },\n        };\n      },\n    },\n    async close() {\n      if (options.observational) {\n        await db.close();\n        return;\n      }\n      // Checkpoint before measuring: the last reconcile's pages sit in the WAL, not the file yet.\n      await checkpointWal(db);\n      let reclaimPath: string | null = null;\n      try {\n        const path = await cacheFilePath(conn);\n        const base = Number((await getMeta(conn, 'compact_size')) ?? '0');\n        const size = path === null ? null : await fileSize(path);\n        if (size !== null) {\n          // No baseline yet (cold build or an upgraded cache): record it, never reclaim here, so a\n          // cold build pays no VACUUM (PLAN 3.49 Track A) and an upgraded cache heals on a crossing.\n          if (base === 0) {\n            await setMeta(conn, 'compact_size', String(size));\n            // The meta write landed past the checkpoint; leave no WAL for the next opener.\n            await checkpointWal(db);\n          } else if (size > BLOAT_FACTOR * base) {\n            reclaimPath = path;\n          }\n        }\n      } catch (err) {\n        console.error(`sense: turso cache bloat check failed, the cache will keep its space until one succeeds: ${(err as Error).message}`);\n      }\n      await db.close();\n      // After this store's connection is closed, never before: turso hands the file to one\n      // connection at a time, and reclaimSpace opens its own to carry the `vacuum` flag (PLAN 3.54).\n      if (reclaimPath !== null) await reclaimSpace(reclaimPath);\n    },\n  };\n}\n"],"names":["CAPABILITIES","createStore","Set","BLOAT_FACTOR","db","conn","options","vectorScope","createNativeVectorScopeOwner","vectors","pending","pendingRows","writeVectors","rows","writeVectorBatch","STORE_DIMS","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","raw","stmt","setReadBigInts","iterate","params","close","reclaimPath","base","size","err","observational","checkpointWal","cacheFilePath","getMeta","Number","fileSize","setMeta","String","console","error","message","reclaimSpace"],"mappings":";;;;;;;;;;;QAYaA;eAAAA;;QAQGC;eAAAA;;;uBAnBW;wBACkB;6BACb;yBAEwC;4BACH;4BAC1C;yBACE;0BACiC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAGvD,IAAMD,eAAwC,IAAIE,IAAI;IAAC;CAAU;AAExE,0FAA0F;AAC1F,wFAAwF;AACxF,IAAMC,eAAe;AAId,SAASF,YAAYG,EAAY,EAAEC,IAAgB;QAAEC,UAAAA,iEAAuC,CAAC;IAClG,IAAMC,cAAcC,IAAAA,uCAA4B;IAChD,sFAAsF;IACtF,gIAAgI;IAChI,IAAMC,UAAuB;QAC3BC,SAAS,SAATA;mBAAeC,IAAAA,sBAAW,EAACN;;QAC3BO,cAAc,SAAdA,aAAeC;mBAASC,IAAAA,4BAAgB,EAACT,MAAMU,mBAAU,EAAEF;;QAC3DG,YAAY,SAAZA,WAAaC,IAAIC,YAAYC,OAAOC;mBAAYC,IAAAA,0BAAc,EAAChB,MAAMY,IAAIF,mBAAU,EAAEI,OAAOC,SAASb,YAAYe,SAAS,CAACF;;QAC3HG,SAAS,SAATA,QAAUC,MAAMC;mBAASC,IAAAA,uBAAW,EAACrB,MAAMU,mBAAU,EAAES,MAAMC,MAAMlB,YAAYe,SAAS,CAACG,KAAKL,OAAO;;QACrGO,WAAW,SAAXA,UAAYH;mBAASI,IAAAA,uBAAY,EAACvB,MAAMmB;;IAC1C;IACAjB,YAAYsB,IAAI,CAACpB;IAEjB,OAAO;QACLqB,MAAM;QACNC,cAAc/B;QACRgC,MAAN,SAAMA,KAAKC,GAAW;;;;;4BACpB;;gCAAM5B,KAAK2B,IAAI,CAACC;;;4BAAhB;;;;;;YACF;;QACMC,SAAN,SAAMA,QAAQD,GAAW;;;oBACvB;;wBAAO5B,KAAK6B,OAAO,CAACD;;;YACtB;;QACME,UAAN,SAAMA,SAASF,GAAW,EAAEG,SAAsB;;;;;4BAChD;;gCAAM/B,KAAK8B,QAAQ,CAACF,KAAKG;;;4BAAzB;;;;;;YACF;;QACMC,aAAN,SAAMA,YAAeC,EAAoB;;;oBACvC;;wBAAOC,IAAAA,8BAAe,EAAClC,MAAMiC;;;YAC/B;;QACAE,MAAM;YACEC,SAAN,SAAMA;;;;;gCACQ;;oCAAMC,IAAAA,oBAAU,EAACrC;;;gCAA7B;;oCAAQ;wCAAI;;;;;gBACd;;YACAsC,YAAY,SAAZA,WAAaF,SAASG;uBAAeD,IAAAA,wBAAU,EAACtC,MAAMoC,SAASG;;QACjE;QACAC,SAAS;YACPC,OAAO,SAAPA,MAAQC,OAAOtB;uBAASuB,IAAAA,uBAAY,EAAC3C,MAAM0C,OAAOtB;;QACpD;QACAhB,SAAAA;QACMwC,cAAN,SAAMA;;oBAGEC;;;;4BAAc;;gCAAM7C,KAAK6B,OAAO,CAAC;;;4BAA1B;;gCAAO,cAA2CiB,GAAG;;;4BAA5DD,MAAO;4BACb;;gCAAO;oCAAEE,cAAc,AAAC,GAAmB,OAAjBF,IAAIE,YAAY,EAAC;gCAAoF;;;;YACjI;;QACAC,KAAK;YACGnB,SAAN,SAAMA,QAAQD,GAAW;;wBACjBqB;;;;gCAAO;;oCAAMjD,KAAK6B,OAAO,CAACD;;;gCAA1BqB,OAAO;gCACbA,KAAKC,cAAc,CAAC,OAAO,gEAAgE;gCAC3F;;oCAAO;wCACLd,SAAS,SAATA;mDAAea,KAAKb,OAAO;;wCAC3B,8DAA8D;wCAC9De,SAAS,SAATA;4CAA0B,IAAA,IAAA,OAAA,UAAA,QAAA,AAAGC,SAAH,UAAA,OAAA,OAAA,GAAA,OAAA,MAAA;gDAAGA,OAAH,QAAA,SAAA,CAAA,KAAoB;;;oDACrCH;;;;4DAAP;;2EAAA,0CAAOA,CAAAA,QAAAA,MAAKE,OAAO,OAAZF,OAAa,qBAAGG;;;4DAAvB;;;;;;4CACF;;oCACF;;;;gBACF;;QACF;QACMC,OAAN,SAAMA;;oBAOAC,aAGmB,MADfnC,MACAoC,MACAC,YAYCC;;;;iCAtBLxD,QAAQyD,aAAa,EAArBzD;;;;4BACF;;gCAAMF,GAAGsD,KAAK;;;4BAAd;4BACA;;;;4BAEF,4FAA4F;4BAC5F;;gCAAMM,IAAAA,2BAAa,EAAC5D;;;4BAApB;4BACIuD,cAA6B;;;;;;;;;4BAElB;;gCAAMM,IAAAA,2BAAa,EAAC5D;;;4BAA3BmB,OAAO;4BACQ;;gCAAM0C,IAAAA,iBAAO,EAAC7D,MAAM;;;4BAAnCuD,OAAOO;iCAAQ,OAAA,2BAAA,kBAAA,OAAwC;;iCAChD3C,CAAAA,SAAS,IAAG,GAAZA;;;;mCAAgB;;;;;;4BAAO;;gCAAM4C,IAAAA,sBAAQ,EAAC5C;;;mCAAf;;;4BAA9BqC;iCACFA,CAAAA,SAAS,IAAG,GAAZA;;;;iCAGED,CAAAA,SAAS,CAAA,GAATA;;;;4BACF;;gCAAMS,IAAAA,iBAAO,EAAChE,MAAM,gBAAgBiE,OAAOT;;;4BAA3C;4BACA,+EAA+E;4BAC/E;;gCAAMG,IAAAA,2BAAa,EAAC5D;;;4BAApB;;;;;;4BACK,IAAIyD,OAAO1D,eAAeyD,MAAM;gCACrCD,cAAcnC;4BAChB;;;;;;;;4BAEKsC;4BACPS,QAAQC,KAAK,CAAC,AAAC,4FAAkH,OAAvB,AAACV,IAAcW,OAAO;;;;;;4BAElI;;gCAAMrE,GAAGsD,KAAK;;;4BAAd;iCAGIC,CAAAA,gBAAgB,IAAG,GAAnBA;;;;4BAAsB;;gCAAMe,IAAAA,0BAAY,EAACf;;;4BAAnB;;;;;;;;YAC5B;;IACF;AACF"}

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

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

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

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

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

@@ -256,16 +256,15 @@ function dequantize(row, dims) {
     for(var d = 0; d < Math.min(q.length, dims); d++)out[d] = q[d] * row.scale;
     return out;
 }
-function cosineSimilarity(a, b) {
+function vectorNorm(vector) {
+    var norm = 0;
+    for(var d = 0; d < vector.length; d++)norm += vector[d] * vector[d];
+    return Math.sqrt(norm);
+}
+function cosineSimilarity(a, b, aNorm, bNorm) {
     var dot = 0;
-    var na = 0;
-    var nb = 0;
-    for(var d = 0; d < a.length; d++){
-        dot += a[d] * b[d];
-        na += a[d] * a[d];
-        nb += b[d] * b[d];
-    }
-    return dot / (Math.sqrt(na) * Math.sqrt(nb) + 1e-32);
+    for(var d = 0; d < a.length; d++)dot += a[d] * b[d];
+    return dot / (aNorm * bNorm + 1e-32);
 }
 function writeVectorBatch(conn, dims, rows) {
     return _async_to_generator(function() {
@@ -295,15 +294,18 @@ function writeVectorBatch(conn, dims, rows) {
     })();
 }
 function scanCandidates(conn, qv, dims, fetch, allowed) {
+    var nativeScope = arguments.length > 5 && arguments[5] !== void 0 ? arguments[5] : false;
     return _async_to_generator(function() {
-        var q, stmt, rows, best, _iteratorNormalCompletion, _didIteratorError, _iteratorError, _iterator, _step, row, score, existing;
+        var q, queryNorm, scope, stmt, rows, best, _iteratorNormalCompletion, _didIteratorError, _iteratorError, _iterator, _step, row, vector, score, existing;
         return _ts_generator(this, function(_state) {
             switch(_state.label){
                 case 0:
                     q = padded(qv, dims);
+                    queryNorm = vectorNorm(q);
+                    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();
@@ -319,7 +321,8 @@ function scanCandidates(conn, qv, dims, fetch, allowed) {
                         for(_iterator = rows[Symbol.iterator](); !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
                             row = _step.value;
                             if (allowed && !allowed.has(row.path)) continue;
-                            score = cosineSimilarity(q, decode(row.vector, dims));
+                            vector = decode(row.vector, dims);
+                            score = cosineSimilarity(q, vector, queryNorm, vectorNorm(vector));
                             existing = best.get(row.path);
                             if (!existing || score > existing.score || score === existing.score && row.chunk < existing.chunk) {
                                 best.set(row.path, {
@@ -364,8 +367,9 @@ function scanCandidates(conn, qv, dims, fetch, allowed) {
     })();
 }
 function scanSimilar(conn, dims, path, opts) {
+    var nativeScope = arguments.length > 4 && arguments[4] !== void 0 ? arguments[4] : false;
     return _async_to_generator(function() {
-        var targetStmt, targetRows, targets, stmt, rows, best, _iteratorNormalCompletion, _didIteratorError, _iteratorError, _iterator, _step, row, other, _iteratorNormalCompletion1, _didIteratorError1, _iteratorError1, _iterator1, _step1, t, score, existing;
+        var targetStmt, targetRows, targets, scope, stmt, rows, best, _iteratorNormalCompletion, _didIteratorError, _iteratorError, _iterator, _step, row, other, otherNorm, _iteratorNormalCompletion1, _didIteratorError1, _iteratorError1, _iterator1, _step1, t, score, existing;
         return _ts_generator(this, function(_state) {
             switch(_state.label){
                 case 0:
@@ -390,11 +394,16 @@ function scanSimilar(conn, dims, path, opts) {
                         []
                     ];
                     targets = (0, _vectorsts.sampleEvenly)(targetRows).map(function(row) {
-                        return decode(row.vector, dims);
+                        var vector = decode(row.vector, dims);
+                        return {
+                            vector: vector,
+                            norm: vectorNorm(vector)
+                        };
                     });
+                    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();
@@ -411,11 +420,12 @@ function scanSimilar(conn, dims, path, opts) {
                             row = _step.value;
                             if (row.path === path || opts.exclude.has(row.path) || opts.allowed && !opts.allowed.has(row.path)) continue;
                             other = decode(row.vector, dims);
+                            otherNorm = vectorNorm(other);
                             _iteratorNormalCompletion1 = true, _didIteratorError1 = false, _iteratorError1 = undefined;
                             try {
                                 for(_iterator1 = targets[Symbol.iterator](); !(_iteratorNormalCompletion1 = (_step1 = _iterator1.next()).done); _iteratorNormalCompletion1 = true){
                                     t = _step1.value;
-                                    score = cosineSimilarity(t, other);
+                                    score = cosineSimilarity(t.vector, other, t.norm, otherNorm);
                                     existing = best.get(row.path);
                                     if (existing === undefined || score > existing) best.set(row.path, score);
                                 }

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

@@ -1 +1 @@
-{"version":3,"sources":["/Users/kevin/Dev/OpenSource/ai/sensemaking/src/store/turso/vectors.ts"],"sourcesContent":["import type { Connection, VectorCandidate, VectorSimilar, VectorWriteRow } from '../types.ts';\nimport { asCosine, compareVectorScores, sampleEvenly } from '../vectors.ts';\n\n// Native F32_BLOB(dims) columns, dims fixed at DDL time (open.ts, STORE_DIMS). Both scans\n// score in JS: a per-row vector_distance_cos measured 3.5-8x slower on this row engine.\n\n// A model narrower than the column zero-pads: the added dimensions contribute nothing to\n// either dot product or norm, so cosine is unchanged.\nfunction padded(values: ArrayLike<number>, dims: number): Float32Array {\n  const out = new Float32Array(dims);\n  for (let d = 0; d < Math.min(values.length, dims); d++) out[d] = values[d];\n  return out;\n}\n\n// A bound Float32Array stores truncated bytes with no error; a Buffer view over the same\n// bytes round-trips exact (measured 0.7.2).\nfunction toBlob(v: Float32Array): Buffer {\n  return Buffer.from(v.buffer, v.byteOffset, v.byteLength);\n}\n\nfunction decode(vector: Buffer, dims: number): Float32Array {\n  return new Float32Array(vector.buffer, vector.byteOffset, dims);\n}\n\n// Rows arrive int8-quantized with a per-vector scale (embed/query.ts's toStore); this store\n// dequantizes to floats, as duckdb does.\nfunction dequantize(row: VectorWriteRow, dims: number): Float32Array {\n  const q = new Int8Array(row.vector.buffer, row.vector.byteOffset, row.vector.byteLength);\n  const out = new Float32Array(dims);\n  for (let d = 0; d < Math.min(q.length, dims); d++) out[d] = q[d] * row.scale;\n  return out;\n}\n\nfunction cosineSimilarity(a: Float32Array, b: Float32Array): number {\n  let dot = 0;\n  let na = 0;\n  let nb = 0;\n  for (let d = 0; d < a.length; d++) {\n    dot += a[d] * b[d];\n    na += a[d] * a[d];\n    nb += b[d] * b[d];\n  }\n  return dot / (Math.sqrt(na) * Math.sqrt(nb) + 1e-32);\n}\n\n// `scale` stays NULL: the column exists so the row shape matches the other stores, and\n// cosine is scale-invariant once the value is dequantized here.\nexport async function writeVectorBatch(conn: Connection, dims: number, rows: VectorWriteRow[]): Promise<void> {\n  if (rows.length === 0) return;\n  await conn.runBatch(\n    'UPDATE embeddings SET vector = ? WHERE \"path\" = ? AND chunk = ?',\n    rows.map((row) => [toBlob(dequantize(row, dims)), row.path, row.chunk])\n  );\n}\n\n// Best chunk per file by cosine. GROUP BY with MIN() cannot do this on 0.7.2: the aggregate\n// is right but the bare start_line/end_line come from an arbitrary row in the group.\nexport async function scanCandidates(conn: Connection, qv: Float32Array, dims: number, fetch: number, allowed?: Set<string>): Promise<VectorCandidate[]> {\n  const q = padded(qv, dims);\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<{ path: string; chunk: number; start_line: number; end_line: number; vector: Buffer }>;\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 score = cosineSimilarity(q, decode(row.vector, dims));\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// Max cosine over (target chunk, other chunk) pairs. The SQL cross-join duckdb uses measured\n// 6-8x slower here at 26k chunks (2026-08-30).\nexport async function scanSimilar(conn: Connection, dims: number, path: string, opts: { exclude: Set<string>; allowed?: Set<string>; k: number }): Promise<VectorSimilar[]> {\n  if (opts.allowed && opts.allowed.size === 0) return [];\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: Buffer }>;\n  if (targetRows.length === 0) return [];\n  const targets = sampleEvenly(targetRows).map((row) => decode(row.vector, dims));\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: Buffer }>;\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 = decode(row.vector, dims);\n    for (const t of targets) {\n      const score = cosineSimilarity(t, other);\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","padded","values","dims","out","Float32Array","d","Math","min","length","toBlob","v","Buffer","from","buffer","byteOffset","byteLength","decode","vector","dequantize","row","q","Int8Array","scale","cosineSimilarity","a","b","dot","na","nb","sqrt","conn","rows","runBatch","map","path","chunk","qv","fetch","allowed","stmt","best","score","existing","prepare","all","Map","has","get","set","lines","start_line","end_line","entries","value","sort","compareVectorScores","slice","similarity","asCosine","opts","targetStmt","targetRows","targets","other","t","size","sampleEvenly","exclude","undefined","p","k"],"mappings":"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"}
+{"version":3,"sources":["/Users/kevin/Dev/OpenSource/ai/sensemaking/src/store/turso/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// Native F32_BLOB(dims) columns, dims fixed at DDL time (open.ts, STORE_DIMS). Both scans\n// score in JS: a per-row vector_distance_cos measured 3.5-8x slower on this row engine.\n\n// A model narrower than the column zero-pads: the added dimensions contribute nothing to\n// either dot product or norm, so cosine is unchanged.\nfunction padded(values: ArrayLike<number>, dims: number): Float32Array {\n  const out = new Float32Array(dims);\n  for (let d = 0; d < Math.min(values.length, dims); d++) out[d] = values[d];\n  return out;\n}\n\n// A bound Float32Array stores truncated bytes with no error; a Buffer view over the same\n// bytes round-trips exact (measured 0.7.2).\nfunction toBlob(v: Float32Array): Buffer {\n  return Buffer.from(v.buffer, v.byteOffset, v.byteLength);\n}\n\nfunction decode(vector: Buffer, dims: number): Float32Array {\n  return new Float32Array(vector.buffer, vector.byteOffset, dims);\n}\n\n// Rows arrive int8-quantized with a per-vector scale (embed/query.ts's toStore); this store\n// dequantizes to floats, as duckdb does.\nfunction dequantize(row: VectorWriteRow, dims: number): Float32Array {\n  const q = new Int8Array(row.vector.buffer, row.vector.byteOffset, row.vector.byteLength);\n  const out = new Float32Array(dims);\n  for (let d = 0; d < Math.min(q.length, dims); d++) out[d] = q[d] * row.scale;\n  return out;\n}\n\nfunction vectorNorm(vector: Float32Array): number {\n  let norm = 0;\n  for (let d = 0; d < vector.length; d++) norm += vector[d] * vector[d];\n  return Math.sqrt(norm);\n}\n\nfunction cosineSimilarity(a: Float32Array, b: Float32Array, aNorm: number, bNorm: number): number {\n  let dot = 0;\n  for (let d = 0; d < a.length; d++) dot += a[d] * b[d];\n  return dot / (aNorm * bNorm + 1e-32);\n}\n\n// `scale` stays NULL: the column exists so the row shape matches the other stores, and\n// cosine is scale-invariant once the value is dequantized here.\nexport async function writeVectorBatch(conn: Connection, dims: number, rows: VectorWriteRow[]): Promise<void> {\n  if (rows.length === 0) return;\n  await conn.runBatch(\n    'UPDATE embeddings SET vector = ? WHERE \"path\" = ? AND chunk = ?',\n    rows.map((row) => [toBlob(dequantize(row, dims)), row.path, row.chunk])\n  );\n}\n\n// Best chunk per file by cosine. GROUP BY with MIN() cannot do this on 0.7.2: the aggregate\n// is right but the bare start_line/end_line come from an arbitrary row in the group.\nexport async function scanCandidates(conn: Connection, qv: Float32Array, dims: number, fetch: number, allowed?: Set<string>, nativeScope = false): Promise<VectorCandidate[]> {\n  const q = padded(qv, dims);\n  const queryNorm = vectorNorm(q);\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<{ path: string; chunk: number; start_line: number; end_line: number; vector: Buffer }>;\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 vector = decode(row.vector, dims);\n    const score = cosineSimilarity(q, vector, queryNorm, vectorNorm(vector));\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// Max cosine over (target chunk, other chunk) pairs. The SQL cross-join duckdb uses measured\n// 6-8x slower here at 26k chunks (2026-08-30).\nexport async function scanSimilar(conn: Connection, dims: number, path: string, opts: { exclude: Set<string>; allowed?: Set<string>; k: number }, nativeScope = false): Promise<VectorSimilar[]> {\n  if (opts.allowed && opts.allowed.size === 0) return [];\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: Buffer }>;\n  if (targetRows.length === 0) return [];\n  const targets = sampleEvenly(targetRows).map((row) => {\n    const vector = decode(row.vector, dims);\n    return { vector, norm: vectorNorm(vector) };\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: Buffer }>;\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 = decode(row.vector, dims);\n    const otherNorm = vectorNorm(other);\n    for (const t of targets) {\n      const score = cosineSimilarity(t.vector, other, 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","padded","values","dims","out","Float32Array","d","Math","min","length","toBlob","v","Buffer","from","buffer","byteOffset","byteLength","decode","vector","dequantize","row","q","Int8Array","scale","vectorNorm","norm","sqrt","cosineSimilarity","a","b","aNorm","bNorm","dot","conn","rows","runBatch","map","path","chunk","qv","fetch","allowed","nativeScope","queryNorm","scope","stmt","best","score","existing","NATIVE_VECTOR_SCOPE_TABLE","prepare","all","Map","has","get","set","lines","start_line","end_line","entries","value","sort","compareVectorScores","slice","similarity","asCosine","opts","targetStmt","targetRows","targets","other","otherNorm","t","size","sampleEvenly","exclude","undefined","p","k"],"mappings":"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"}

package/dist/cjs/store/types.d.cts

@@ -27,6 +27,7 @@ export interface ReconcileDialect {
     beginMode(): string;
     checkColumnLimit(count: number): void;
     addColumns(conn: Connection, names: string[]): Promise<void>;
+    updateFrontmatter?(conn: Connection, writableColumns: string[], rows: unknown[][]): Promise<void>;
     reconcileContent(conn: Connection, touched: string[], docs: ParsedDoc[], delta: ReconcileDelta, cfg: Config): Promise<void>;
     recordDuration?(conn: Connection, ms: number): Promise<void>;
 }
@@ -45,7 +46,9 @@ export interface OpenDialect<Handle> {
         observational?: boolean;
     }): Promise<void>;
     isLocked?(err: Error): boolean;
-    ensureSchema(handle: Handle, conn: Connection, cfg: Config): Promise<void>;
+    ensureCoreSchema(handle: Handle, conn: Connection): Promise<void>;
+    ensureFeatureSchema(handle: Handle, conn: Connection, cfg: Config): Promise<void>;
+    prepareConnection?(handle: Handle, conn: Connection, cfg: Config): Promise<void>;
     setDerivedBusyTimeout?(handle: Handle, conn: Connection, ms: number): Promise<void>;
     prepareLexical?(conn: Connection): Promise<void>;
     assertLexicalReady?(conn: Connection): Promise<void>;