sensemaking 0.27.1 → 0.28.0

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

@@ -17,24 +17,173 @@ _export(exports, {
     },
     get tursoApi () {
         return tursoApi;
+    },
+    get tursoNative () {
+        return tursoNative;
     }
 });
 var _nativets = require("../native.js");
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
+    try {
+        var info = gen[key](arg);
+        var value = info.value;
+    } catch (error) {
+        reject(error);
+        return;
+    }
+    if (info.done) resolve(value);
+    else Promise.resolve(value).then(_next, _throw);
+}
+function _async_to_generator(fn) {
+    return function() {
+        var self = this, args = arguments;
+        return new Promise(function(resolve, reject) {
+            var gen = fn.apply(self, args);
+            function _next(value) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
+            }
+            function _throw(err) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
+            }
+            _next(undefined);
+        });
+    };
+}
+function _ts_generator(thisArg, body) {
+    var f, y, t, _ = {
+        label: 0,
+        sent: function() {
+            if (t[0] & 1) throw t[1];
+            return t[1];
+        },
+        trys: [],
+        ops: []
+    }, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype), d = Object.defineProperty;
+    return d(g, "next", {
+        value: verb(0)
+    }), d(g, "throw", {
+        value: verb(1)
+    }), d(g, "return", {
+        value: verb(2)
+    }), typeof Symbol === "function" && d(g, Symbol.iterator, {
+        value: function() {
+            return this;
+        }
+    }), g;
+    function verb(n) {
+        return function(v) {
+            return step([
+                n,
+                v
+            ]);
+        };
+    }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while(g && (g = 0, op[0] && (_ = 0)), _)try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [
+                op[0] & 2,
+                t.value
+            ];
+            switch(op[0]){
+                case 0:
+                case 1:
+                    t = op;
+                    break;
+                case 4:
+                    _.label++;
+                    return {
+                        value: op[1],
+                        done: false
+                    };
+                case 5:
+                    _.label++;
+                    y = op[1];
+                    op = [
+                        0
+                    ];
+                    continue;
+                case 7:
+                    op = _.ops.pop();
+                    _.trys.pop();
+                    continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) {
+                        _ = 0;
+                        continue;
+                    }
+                    if (op[0] === 3 && (!t || op[1] > t[0] && op[1] < t[3])) {
+                        _.label = op[1];
+                        break;
+                    }
+                    if (op[0] === 6 && _.label < t[1]) {
+                        _.label = t[1];
+                        t = op;
+                        break;
+                    }
+                    if (t && _.label < t[2]) {
+                        _.label = t[2];
+                        _.ops.push(op);
+                        break;
+                    }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop();
+                    continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) {
+            op = [
+                6,
+                e
+            ];
+            y = 0;
+        } finally{
+            f = t = 0;
+        }
+        if (op[0] & 5) throw op[1];
+        return {
+            value: op[0] ? op[1] : void 0,
+            done: true
+        };
+    }
+}
 var TURSO_PACKAGE = '@tursodatabase/database';
-var TURSO = {
-    store: 'turso',
-    pkg: TURSO_PACKAGE,
-    sizeHint: '~16MB'
-};
 var CONNECT_OPTS = {
     timeout: 30000,
     experimental: [
         'index_method'
     ]
 };
-var tursoApiPromise;
+var tursoNativePromise;
+function tursoNative() {
+    if (!tursoNativePromise) {
+        var descriptor = {
+            store: 'turso',
+            pkg: TURSO_PACKAGE,
+            sizeHint: '~16MB',
+            range: (0, _nativets.peerRange)(TURSO_PACKAGE)
+        };
+        tursoNativePromise = (0, _nativets.loadOrInstall)(descriptor, (0, _nativets.packageNodeModules)());
+    }
+    return tursoNativePromise;
+}
 function tursoApi() {
-    if (!tursoApiPromise) tursoApiPromise = (0, _nativets.loadOrInstall)(TURSO, (0, _nativets.packageNodeModules)());
-    return tursoApiPromise;
+    return _async_to_generator(function() {
+        return _ts_generator(this, function(_state) {
+            switch(_state.label){
+                case 0:
+                    return [
+                        4,
+                        tursoNative()
+                    ];
+                case 1:
+                    return [
+                        2,
+                        _state.sent().api
+                    ];
+            }
+        });
+    })();
 }
 /* CJS INTEROP */ if (exports.__esModule && exports.default) { try { Object.defineProperty(exports.default, '__esModule', { value: true }); for (var key in exports) { exports.default[key] = exports[key]; } } catch (_) {}; module.exports = exports.default; }

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

@@ -1 +1 @@
-{"version":3,"sources":["/Users/kevin/Dev/open-source/ai/sensemaking/src/store/turso/native.ts"],"sourcesContent":["import { loadOrInstall, type NativeDescriptor, packageNodeModules } from '../native.ts';\n\nexport const TURSO_PACKAGE = '@tursodatabase/database';\n\nconst TURSO: NativeDescriptor = { store: 'turso', pkg: TURSO_PACKAGE, sizeHint: '~16MB' };\n\n// Every connect() in this store goes through these: the same 30s floor sqlite opens with, and the\n// FTS index method ensureSchema() needs. reclaimSpace adds 'vacuum'; nothing else may (PLAN 3.54).\nexport const CONNECT_OPTS = { timeout: 30_000, experimental: ['index_method'] } as const;\n\nlet tursoApiPromise: Promise<typeof import('@tursodatabase/database')> | undefined;\n\n// One accessor every consumer must go through, not each its own bare-specifier import: Node\n// keeps returning a pre-install \"not found\" miss to any new lookup of the same path afterward.\nexport function tursoApi(): Promise<typeof import('@tursodatabase/database')> {\n  if (!tursoApiPromise) tursoApiPromise = loadOrInstall<typeof import('@tursodatabase/database')>(TURSO, packageNodeModules());\n  return tursoApiPromise;\n}\n"],"names":["CONNECT_OPTS","TURSO_PACKAGE","tursoApi","TURSO","store","pkg","sizeHint","timeout","experimental","tursoApiPromise","loadOrInstall","packageNodeModules"],"mappings":";;;;;;;;;;;QAQaA;eAAAA;;QANAC;eAAAA;;QAYGC;eAAAA;;;wBAdyD;AAElE,IAAMD,gBAAgB;AAE7B,IAAME,QAA0B;IAAEC,OAAO;IAASC,KAAKJ;IAAeK,UAAU;AAAQ;AAIjF,IAAMN,eAAe;IAAEO,SAAS;IAAQC,cAAc;QAAC;KAAe;AAAC;AAE9E,IAAIC;AAIG,SAASP;IACd,IAAI,CAACO,iBAAiBA,kBAAkBC,IAAAA,uBAAa,EAA2CP,OAAOQ,IAAAA,4BAAkB;IACzH,OAAOF;AACT"}
+{"version":3,"sources":["/Users/kevin/Dev/open-source/ai/sensemaking/src/store/turso/native.ts"],"sourcesContent":["import { loadOrInstall, type NativeDescriptor, type NativeModule, packageNodeModules, peerRange } from '../native.ts';\n\nexport const TURSO_PACKAGE = '@tursodatabase/database';\n\n// Every connect() in this store goes through these: the same 30s floor sqlite opens with, and the\n// FTS index method ensureSchema() needs. reclaimSpace adds 'vacuum'; nothing else may (PLAN 3.54).\nexport const CONNECT_OPTS = { timeout: 30_000, experimental: ['index_method'] } as const;\n\ntype TursoApi = typeof import('@tursodatabase/database');\n\nlet tursoNativePromise: Promise<NativeModule<TursoApi>> | undefined;\n\n// One accessor every consumer must go through, not each its own bare-specifier import: Node\n// keeps returning a pre-install \"not found\" miss to any new lookup of the same path afterward.\nexport function tursoNative(): Promise<NativeModule<TursoApi>> {\n  if (!tursoNativePromise) {\n    const descriptor: NativeDescriptor = { store: 'turso', pkg: TURSO_PACKAGE, sizeHint: '~16MB', range: peerRange(TURSO_PACKAGE) };\n    tursoNativePromise = loadOrInstall<TursoApi>(descriptor, packageNodeModules());\n  }\n  return tursoNativePromise;\n}\n\nexport async function tursoApi(): Promise<TursoApi> {\n  return (await tursoNative()).api;\n}\n"],"names":["CONNECT_OPTS","TURSO_PACKAGE","tursoApi","tursoNative","timeout","experimental","tursoNativePromise","descriptor","store","pkg","sizeHint","range","peerRange","loadOrInstall","packageNodeModules","api"],"mappings":";;;;;;;;;;;QAMaA;eAAAA;;QAJAC;eAAAA;;QAoBSC;eAAAA;;QARNC;eAAAA;;;wBAduF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEhG,IAAMF,gBAAgB;AAItB,IAAMD,eAAe;IAAEI,SAAS;IAAQC,cAAc;QAAC;KAAe;AAAC;AAI9E,IAAIC;AAIG,SAASH;IACd,IAAI,CAACG,oBAAoB;QACvB,IAAMC,aAA+B;YAAEC,OAAO;YAASC,KAAKR;YAAeS,UAAU;YAASC,OAAOC,IAAAA,mBAAS,EAACX;QAAe;QAC9HK,qBAAqBO,IAAAA,uBAAa,EAAWN,YAAYO,IAAAA,4BAAkB;IAC7E;IACA,OAAOR;AACT;AAEO,SAAeJ;;;;;oBACZ;;wBAAMC;;;oBAAd;;wBAAQ,cAAqBY,GAAG;;;;IAClC"}

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

@@ -25,10 +25,14 @@ _export(exports, {
 var _typests = require("../../embed/types.js");
 var _errorsts = require("../../errors.js");
 var _indexts = require("../../features/index.js");
+var _enginets = require("../engine.js");
+var _nativets = require("../native.js");
 var _opents = require("../open.js");
 var _sharedts = require("../shared.js");
 var _connectionts = require("./connection.js");
-var _nativets = require("./native.js");
+var _enginets1 = require("./engine.js");
+var _lexicalts = require("./lexical.js");
+var _nativets1 = require("./native.js");
 var _reconcilets = require("./reconcile.js");
 var _storets = require("./store.js");
 function _array_like_to_array(arr, len) {
@@ -271,45 +275,50 @@ function ensureCoreSchema(_handle, conn) {
                 case 4:
                     _state.trys.push([
                         4,
-                        9,
                         10,
-                        11
+                        11,
+                        12
                     ]);
-                    _iterator = _reconcilets.CONTENT_FTS_DDL[Symbol.iterator]();
-                    _state.label = 5;
+                    return [
+                        4,
+                        (0, _enginets1.tursoFts)()
+                    ];
                 case 5:
+                    _iterator = _state.sent().indexDdl()[Symbol.iterator]();
+                    _state.label = 6;
+                case 6:
                     if (!!(_iteratorNormalCompletion = (_step = _iterator.next()).done)) return [
                         3,
-                        8
+                        9
                     ];
                     ddl = _step.value;
                     return [
                         4,
                         conn.exec(ddl)
                     ];
-                case 6:
-                    _state.sent();
-                    _state.label = 7;
                 case 7:
+                    _state.sent();
+                    _state.label = 8;
+                case 8:
                     _iteratorNormalCompletion = true;
                     return [
                         3,
-                        5
+                        6
                     ];
-                case 8:
+                case 9:
                     return [
                         3,
-                        11
+                        12
                     ];
-                case 9:
+                case 10:
                     err = _state.sent();
                     _didIteratorError = true;
                     _iteratorError = err;
                     return [
                         3,
-                        11
+                        12
                     ];
-                case 10:
+                case 11:
                     try {
                         if (!_iteratorNormalCompletion && _iterator.return != null) {
                             _iterator.return();
@@ -322,36 +331,36 @@ function ensureCoreSchema(_handle, conn) {
                     return [
                         7
                     ];
-                case 11:
+                case 12:
                     return [
                         4,
                         conn.exec('CREATE TABLE IF NOT EXISTS preset_files ("path" TEXT, preset TEXT, PRIMARY KEY ("path", preset))')
                     ];
-                case 12:
+                case 13:
                     _state.sent();
                     return [
                         4,
                         conn.exec('CREATE INDEX IF NOT EXISTS preset_files_preset ON preset_files(preset)')
                     ];
-                case 13:
+                case 14:
                     _state.sent();
                     return [
                         4,
                         (0, _sharedts.getMeta)(conn, 'schema_version')
                     ];
-                case 14:
+                case 15:
                     if (!(_state.sent() === null)) return [
                         3,
-                        16
+                        17
                     ];
                     return [
                         4,
                         (0, _sharedts.setMeta)(conn, 'schema_version', SCHEMA_VERSION)
                     ];
-                case 15:
-                    _state.sent();
-                    _state.label = 16;
                 case 16:
+                    _state.sent();
+                    _state.label = 17;
+                case 17:
                     return [
                         2
                     ];
@@ -509,7 +518,7 @@ function connect(dbPath, _cfg, options) {
                     ]);
                     return [
                         4,
-                        (0, _nativets.tursoApi)()
+                        (0, _nativets1.tursoApi)()
                     ];
                 case 1:
                     turso = _state.sent();
@@ -520,7 +529,7 @@ function connect(dbPath, _cfg, options) {
                 case 2:
                     err = _state.sent();
                     if (_instanceof(err, _errorsts.SenseError)) throw err;
-                    throw new _errorsts.SenseError('STORE_DEPENDENCY_MISSING', 'store "turso" needs the '.concat(_nativets.TURSO_PACKAGE, " package (").concat(err.message, ")"));
+                    throw new _errorsts.SenseError('STORE_DEPENDENCY_MISSING', 'store "turso" needs the '.concat(_nativets1.TURSO_PACKAGE, " package (").concat(err.message, ")"));
                 case 3:
                     _state.trys.push([
                         3,
@@ -530,8 +539,8 @@ function connect(dbPath, _cfg, options) {
                     ]);
                     return [
                         4,
-                        turso.connect(dbPath, _object_spread(_object_spread_props(_object_spread({}, _nativets.CONNECT_OPTS), {
-                            experimental: _to_consumable_array(_nativets.CONNECT_OPTS.experimental)
+                        turso.connect(dbPath, _object_spread(_object_spread_props(_object_spread({}, _nativets1.CONNECT_OPTS), {
+                            experimental: _to_consumable_array(_nativets1.CONNECT_OPTS.experimental)
                         }), options.existingOnly ? {
                             fileMustExist: true
                         } : {}))
@@ -559,6 +568,140 @@ function connect(dbPath, _cfg, options) {
         });
     })();
 }
+function tursoEngineIdentity() {
+    return _async_to_generator(function() {
+        var _tmp;
+        return _ts_generator(this, function(_state) {
+            switch(_state.label){
+                case 0:
+                    _tmp = [
+                        _nativets1.TURSO_PACKAGE
+                    ];
+                    return [
+                        4,
+                        (0, _nativets1.tursoNative)()
+                    ];
+                case 1:
+                    return [
+                        2,
+                        _enginets.engineIdentity.apply(void 0, _tmp.concat([
+                            _state.sent().version
+                        ]))
+                    ];
+            }
+        });
+    })();
+}
+// The real schema, content write and lexical query over store/engine.ts's fixture, in memory.
+function checkTursoEngine() {
+    return _async_to_generator(function() {
+        var _ref, api, version, db, conn, docs;
+        return _ts_generator(this, function(_state) {
+            switch(_state.label){
+                case 0:
+                    return [
+                        4,
+                        (0, _nativets1.tursoNative)()
+                    ];
+                case 1:
+                    _ref = _state.sent(), api = _ref.api, version = _ref.version;
+                    return [
+                        4,
+                        api.connect(':memory:', _object_spread_props(_object_spread({}, _nativets1.CONNECT_OPTS), {
+                            experimental: _to_consumable_array(_nativets1.CONNECT_OPTS.experimental)
+                        }))
+                    ];
+                case 2:
+                    db = _state.sent();
+                    _state.label = 3;
+                case 3:
+                    _state.trys.push([
+                        3,
+                        ,
+                        8,
+                        10
+                    ]);
+                    conn = (0, _connectionts.createConnection)(db);
+                    return [
+                        4,
+                        conn.exec('CREATE TABLE meta (key TEXT PRIMARY KEY, value TEXT)')
+                    ];
+                case 4:
+                    _state.sent();
+                    return [
+                        4,
+                        ensureCoreSchema(db, conn)
+                    ];
+                case 5:
+                    _state.sent();
+                    docs = _enginets.ENGINE_CHECK_DOCS.map(function(doc) {
+                        return {
+                            relPath: doc.path,
+                            search: {
+                                title: doc.title,
+                                summary: doc.summary,
+                                text: doc.text
+                            }
+                        };
+                    });
+                    return [
+                        4,
+                        (0, _reconcilets.reconcileTursoContentWithStrategy)(conn, [], docs, 'incremental')
+                    ];
+                case 6:
+                    _state.sent();
+                    return [
+                        4,
+                        (0, _enginets.checkEngine)('turso', (0, _enginets.engineIdentity)(_nativets1.TURSO_PACKAGE, version), (0, _enginets.npmRemedy)(_nativets1.TURSO_PACKAGE, (0, _nativets.peerRange)(_nativets1.TURSO_PACKAGE)), function(terms) {
+                            return _async_to_generator(function() {
+                                return _ts_generator(this, function(_state) {
+                                    switch(_state.label){
+                                        case 0:
+                                            return [
+                                                4,
+                                                (0, _lexicalts.queryLexical)(conn, terms, {
+                                                    whereJoin: '',
+                                                    whereCond: '',
+                                                    scopeCond: '',
+                                                    limit: 10
+                                                })
+                                            ];
+                                        case 1:
+                                            return [
+                                                2,
+                                                _state.sent().map(function(hit) {
+                                                    return hit.path;
+                                                })
+                                            ];
+                                    }
+                                });
+                            })();
+                        })
+                    ];
+                case 7:
+                    _state.sent();
+                    return [
+                        3,
+                        10
+                    ];
+                case 8:
+                    return [
+                        4,
+                        db.close()
+                    ];
+                case 9:
+                    _state.sent();
+                    return [
+                        7
+                    ];
+                case 10:
+                    return [
+                        2
+                    ];
+            }
+        });
+    })();
+}
 var tursoOpenDialect = {
     filename: DB_FILENAME,
     schemaVersion: SCHEMA_VERSION,
@@ -571,6 +714,8 @@ var tursoOpenDialect = {
     isLocked: function isLocked(err) {
         return /File is locked by another process|locked a portion of the file/.test(err.message);
     },
+    engineIdentity: tursoEngineIdentity,
+    checkEngine: checkTursoEngine,
     ensureCoreSchema: ensureCoreSchema,
     ensureFeatureSchema: ensureFeatureSchema,
     setDerivedBusyTimeout: setDerivedBusyTimeout,

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

@@ -1 +1 @@
-{"version":3,"sources":["/Users/kevin/Dev/open-source/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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"}
+{"version":3,"sources":["/Users/kevin/Dev/open-source/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 { ParsedDoc } from '../../scan/index.ts';\nimport { ENGINE_CHECK_DOCS, engineIdentity, npmRemedy, checkEngine as runEngineCheck } from '../engine.ts';\nimport { peerRange } from '../native.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 { tursoFts } from './engine.ts';\nimport { queryLexical } from './lexical.ts';\nimport { CONNECT_OPTS, TURSO_PACKAGE, tursoApi, tursoNative } from './native.ts';\nimport { reconcileTursoContentWithStrategy, 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 (await tursoFts()).indexDdl()) 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\nasync function tursoEngineIdentity(): Promise<string> {\n  return engineIdentity(TURSO_PACKAGE, (await tursoNative()).version);\n}\n\n// The real schema, content write and lexical query over store/engine.ts's fixture, in memory.\nasync function checkTursoEngine(): Promise<void> {\n  const { api, version } = await tursoNative();\n  const db = await api.connect(':memory:', { ...CONNECT_OPTS, experimental: [...CONNECT_OPTS.experimental] });\n  try {\n    const conn = createConnection(db);\n    await conn.exec('CREATE TABLE meta (key TEXT PRIMARY KEY, value TEXT)');\n    await ensureCoreSchema(db, conn);\n    const docs = ENGINE_CHECK_DOCS.map((doc) => ({ relPath: doc.path, search: { title: doc.title, summary: doc.summary, text: doc.text } }) as ParsedDoc);\n    await reconcileTursoContentWithStrategy(conn, [], docs, 'incremental');\n    await runEngineCheck('turso', engineIdentity(TURSO_PACKAGE, version), npmRemedy(TURSO_PACKAGE, peerRange(TURSO_PACKAGE)), async (terms) => (await queryLexical(conn, terms, { whereJoin: '', whereCond: '', scopeCond: '', limit: 10 })).map((hit) => hit.path));\n  } finally {\n    await db.close();\n  }\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  engineIdentity: tursoEngineIdentity,\n  checkEngine: checkTursoEngine,\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","tursoFts","indexDdl","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","tursoEngineIdentity","tursoNative","engineIdentity","version","checkTursoEngine","api","docs","ENGINE_CHECK_DOCS","map","doc","relPath","path","search","title","summary","text","reconcileTursoContentWithStrategy","runEngineCheck","npmRemedy","peerRange","terms","queryLexical","whereJoin","whereCond","scopeCond","limit","hit","filename","schemaVersion","reconcileDialect","tursoDialect","isLocked","test","checkEngine","createStore","openWithDialect"],"mappings":"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"}

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

@@ -1,7 +1,6 @@
 import type { ReconcileDelta } from '../../features/types.js';
 import type { ParsedDoc } from '../../scan/index.js';
 import type { Connection, ReconcileDialect } from '../types.js';
-export declare const CONTENT_FTS_DDL: readonly ["CREATE INDEX IF NOT EXISTS content_fts ON content USING fts (title_stem, summary_stem, text_stem) WITH (weights = 'title_stem=10.0,summary_stem=5.0,text_stem=1.0')", "CREATE INDEX IF NOT EXISTS content_fts_ngram ON content USING fts (title_ngram, summary_ngram, text_ngram) WITH (tokenizer='ngram', weights='title_ngram=10.0,summary_ngram=5.0,text_ngram=1.0')"];
 export declare const CONTENT_FTS_NAMES: readonly ["content_fts", "content_fts_ngram"];
 export declare const FTS_REBUILD_THRESHOLD = 250;
 export type TursoFtsStrategy = 'incremental' | 'rebuild';

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

@@ -1,7 +1,6 @@
 import type { ReconcileDelta } from '../../features/types.js';
 import type { ParsedDoc } from '../../scan/index.js';
 import type { Connection, ReconcileDialect } from '../types.js';
-export declare const CONTENT_FTS_DDL: readonly ["CREATE INDEX IF NOT EXISTS content_fts ON content USING fts (title_stem, summary_stem, text_stem) WITH (weights = 'title_stem=10.0,summary_stem=5.0,text_stem=1.0')", "CREATE INDEX IF NOT EXISTS content_fts_ngram ON content USING fts (title_ngram, summary_ngram, text_ngram) WITH (tokenizer='ngram', weights='title_ngram=10.0,summary_ngram=5.0,text_ngram=1.0')"];
 export declare const CONTENT_FTS_NAMES: readonly ["content_fts", "content_fts_ngram"];
 export declare const FTS_REBUILD_THRESHOLD = 250;
 export type TursoFtsStrategy = 'incremental' | 'rebuild';