sensemaking 0.24.6 → 0.25.0

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

@@ -160,7 +160,7 @@ function _ts_generator(thisArg, body) {
     }
 }
 var DB_FILENAME = 'cache.db';
-var SCHEMA_VERSION = '20';
+var SCHEMA_VERSION = '21';
 // unicode61 splits on spaces, so a language written without them indexes a whole run as one
 // token and word search finds nothing; the `_seg` sidecars (always populated) cover that case.
 var TOKENIZE = 'porter unicode61';
@@ -203,6 +203,12 @@ function ensureSchemaTables(conn, cfg) {
                         createContentTable(conn)
                     ];
                 case 2:
+                    _state.sent();
+                    return [
+                        4,
+                        conn.exec('CREATE TABLE IF NOT EXISTS indexed_sources ("path" TEXT PRIMARY KEY, text TEXT NOT NULL)')
+                    ];
+                case 3:
                     _state.sent();
                     // Coverage, not ownership: a path can appear under several presets. path leads the PK so the
                     // per-doc delete is an index hit -- keyed the other way, cold builds went quadratic.
@@ -210,58 +216,58 @@ function ensureSchemaTables(conn, cfg) {
                         4,
                         conn.exec('CREATE TABLE IF NOT EXISTS preset_files ("path" TEXT, preset TEXT, PRIMARY KEY ("path", preset))')
                     ];
-                case 3:
+                case 4:
                     _state.sent();
                     return [
                         4,
                         conn.exec('CREATE INDEX IF NOT EXISTS preset_files_preset ON preset_files(preset)')
                     ];
-                case 4:
+                case 5:
                     _state.sent();
                     _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
-                    _state.label = 5;
-                case 5:
+                    _state.label = 6;
+                case 6:
                     _state.trys.push([
-                        5,
-                        10,
+                        6,
                         11,
-                        12
+                        12,
+                        13
                     ]);
                     _iterator = (0, _indexts1.activeFeatures)(cfg)[Symbol.iterator]();
-                    _state.label = 6;
-                case 6:
+                    _state.label = 7;
+                case 7:
                     if (!!(_iteratorNormalCompletion = (_step = _iterator.next()).done)) return [
                         3,
-                        9
+                        10
                     ];
                     feature = _step.value;
                     return [
                         4,
                         feature.schema(conn)
                     ];
-                case 7:
-                    _state.sent();
-                    _state.label = 8;
                 case 8:
+                    _state.sent();
+                    _state.label = 9;
+                case 9:
                     _iteratorNormalCompletion = true;
                     return [
                         3,
-                        6
+                        7
                     ];
-                case 9:
+                case 10:
                     return [
                         3,
-                        12
+                        13
                     ];
-                case 10:
+                case 11:
                     err = _state.sent();
                     _didIteratorError = true;
                     _iteratorError = err;
                     return [
                         3,
-                        12
+                        13
                     ];
-                case 11:
+                case 12:
                     try {
                         if (!_iteratorNormalCompletion && _iterator.return != null) {
                             _iterator.return();
@@ -274,41 +280,41 @@ function ensureSchemaTables(conn, cfg) {
                     return [
                         7
                     ];
-                case 12:
+                case 13:
                     return [
                         4,
                         (0, _sharedts.getMeta)(conn, 'schema_version')
                     ];
-                case 13:
+                case 14:
                     if (!(_state.sent() === null)) return [
                         3,
-                        15
+                        16
                     ];
                     return [
                         4,
                         (0, _sharedts.setMeta)(conn, 'schema_version', SCHEMA_VERSION)
                     ];
-                case 14:
-                    _state.sent();
-                    _state.label = 15;
                 case 15:
+                    _state.sent();
+                    _state.label = 16;
+                case 16:
                     return [
                         4,
                         (0, _sharedts.getMeta)(conn, 'features')
                     ];
-                case 16:
+                case 17:
                     if (!(_state.sent() === null)) return [
                         3,
-                        18
+                        19
                     ];
                     return [
                         4,
                         (0, _sharedts.setMeta)(conn, 'features', (0, _indexts.featureSignature)(cfg, _indexts1.FEATURES))
                     ];
-                case 17:
-                    _state.sent();
-                    _state.label = 18;
                 case 18:
+                    _state.sent();
+                    _state.label = 19;
+                case 19:
                     return [
                         2
                     ];
@@ -330,18 +336,20 @@ function setJournalWal(db) {
         }
     }
 }
-function connect(dbPath, _cfg) {
+function connect(dbPath, _cfg, options) {
     return _async_to_generator(function() {
         var db, conn;
         return _ts_generator(this, function(_state) {
-            db = new _nodesqlite.DatabaseSync(dbPath);
+            db = new _nodesqlite.DatabaseSync(dbPath, options.existingOnly ? {
+                readOnly: true
+            } : {});
             try {
                 // Before journal_mode, not after: converting a fresh database to WAL takes a brief exclusive
                 // lock, and with no timeout set yet a second process opening the same tree fails in 1ms.
                 db.exec('PRAGMA busy_timeout = 30000');
                 // busy_timeout does not cover the WAL conversion itself: SQLite does not invoke the busy
                 // handler for it, so a concurrent cold open needs its own bounded wait.
-                setJournalWal(db);
+                if (!options.observational) setJournalWal(db);
                 (0, _sqlfunctionsts.registerFunctions)(db);
                 conn = (0, _connectionts.createConnection)(db);
                 return [
@@ -419,12 +427,12 @@ var sqliteOpenDialect = {
         return (0, _storets.createStore)(handle.db, conn);
     }
 };
-function openSqlite(cfg) {
+function openSqlite(cfg, options) {
     return _async_to_generator(function() {
         return _ts_generator(this, function(_state) {
             return [
                 2,
-                (0, _opents.openWithDialect)(cfg, sqliteOpenDialect)
+                (0, _opents.openWithDialect)(cfg, sqliteOpenDialect, options)
             ];
         });
     })();

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

@@ -1 +1 @@
-{"version":3,"sources":["/Users/kevin/Dev/OpenSource/ai/sensemaking/src/store/sqlite/open.ts"],"sourcesContent":["// The Node floor (>=22.20) is explained here and nowhere else: 22.20 is the first release with\n// both FTS5 and row-returning INSERT ... RETURNING. Raise it only for a load-bearing capability.\nimport { DatabaseSync } from 'node:sqlite';\nimport type { Config, ResolvedConfig } from '../../config/index.ts';\nimport { featureSignature } from '../../config/index.ts';\nimport { activeFeatures, FEATURES } from '../../features/index.ts';\nimport type { OpenResult } from '../open.ts';\nimport { openWithDialect } from '../open.ts';\nimport { getMeta, setMeta } from '../shared.ts';\nimport { BEGIN_WRITE, withTransaction } from '../transaction.ts';\nimport type { Connection, OpenDialect } from '../types.ts';\nimport { createConnection } from './connection.ts';\nimport { sqliteDialect } from './reconcile.ts';\nimport { registerFunctions } from './sql-functions.ts';\nimport { createStore } from './store.ts';\n\nexport const DB_FILENAME = 'cache.db';\n// Cache shape version, independent of the config's own `version`. Bumping it rebuilds\n// existing trees on first query.\nexport const SCHEMA_VERSION = '20';\n\nexport type { OpenResult };\n\n// unicode61 splits on spaces, so a language written without them indexes a whole run as one\n// token and word search finds nothing; the `_seg` sidecars (always populated) cover that case.\nconst TOKENIZE = 'porter unicode61';\n\ninterface SqliteHandle {\n  db: DatabaseSync;\n}\n\n// The `_seg` sidecars are appended after path, never inserted: bm25() and snippet(content, 2)\n// are documented against the first three columns. Each holds its field's exploded unspaced runs.\nasync function createContentTable(conn: Connection): Promise<void> {\n  await conn.exec(`CREATE VIRTUAL TABLE IF NOT EXISTS content USING fts5(title, summary, text, path UNINDEXED, title_seg, summary_seg, text_seg, tokenize = '${TOKENIZE}')`);\n}\n\n// Content is a separate table (not a column on frontmatter) so `SELECT * FROM frontmatter`\n// can't dump file text into context. Features add their own tables after the core ones.\nasync function ensureSchemaTables(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 createContentTable(conn);\n  // Coverage, not ownership: a path can appear under several presets. path leads the PK so the\n  // per-doc delete is an index hit -- keyed the other way, cold builds went quadratic.\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)) await feature.schema(conn);\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\n// Two processes opening the same fresh tree both try to convert it, and the loser gets SQLITE_BUSY\n// with no busy handler behind it. Bounded because a lock held past this is a real problem, not a race.\nfunction setJournalWal(db: DatabaseSync): void {\n  const deadline = Date.now() + 5000;\n  for (;;) {\n    try {\n      db.exec('PRAGMA journal_mode = WAL');\n      return;\n    } catch (err) {\n      if (Date.now() >= deadline || !/database is locked|busy/i.test((err as Error).message)) throw err;\n      Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, 20);\n    }\n  }\n}\n\nasync function connect(dbPath: string, _cfg: ResolvedConfig): Promise<{ handle: SqliteHandle; conn: Connection }> {\n  const db = new DatabaseSync(dbPath);\n  try {\n    // Before journal_mode, not after: converting a fresh database to WAL takes a brief exclusive\n    // lock, and with no timeout set yet a second process opening the same tree fails in 1ms.\n    db.exec('PRAGMA busy_timeout = 30000');\n    // busy_timeout does not cover the WAL conversion itself: SQLite does not invoke the busy\n    // handler for it, so a concurrent cold open needs its own bounded wait.\n    setJournalWal(db);\n    registerFunctions(db);\n    const conn = createConnection(db);\n    return { handle: { db }, conn };\n  } catch (err) {\n    // A throw here must release this handle, or on Windows the leaked WAL db is undeletable and\n    // scratch cleanup fails with EPERM/EBUSY.\n    db.close();\n    throw err;\n  }\n}\n\nasync function close(handle: SqliteHandle): Promise<void> {\n  handle.db.close();\n}\n\nasync function ensureSchema(_handle: SqliteHandle, conn: Connection, cfg: Config): Promise<void> {\n  // One writer at a time: the feature hooks check a column then add it, so two cold opens racing\n  // here both see it missing and the second ALTER fails with a duplicate column.\n  await withTransaction(conn, () => ensureSchemaTables(conn, cfg), BEGIN_WRITE);\n}\n\nasync function setDerivedBusyTimeout(handle: SqliteHandle, _conn: Connection, ms: number): Promise<void> {\n  handle.db.exec(`PRAGMA busy_timeout = ${ms}`);\n}\n\n// This store's dialect (types.ts's OpenDialect) for the shared orchestration in store/open.ts.\nexport const sqliteOpenDialect: OpenDialect<SqliteHandle> = {\n  filename: DB_FILENAME,\n  schemaVersion: SCHEMA_VERSION,\n  reconcileDialect: sqliteDialect,\n  connect,\n  close,\n  ensureSchema,\n  setDerivedBusyTimeout,\n  createStore: (handle, conn) => createStore(handle.db, conn),\n};\n\nexport async function openSqlite(cfg: ResolvedConfig): Promise<OpenResult> {\n  return openWithDialect(cfg, sqliteOpenDialect);\n}\n"],"names":["DB_FILENAME","SCHEMA_VERSION","openSqlite","sqliteOpenDialect","TOKENIZE","createContentTable","conn","exec","ensureSchemaTables","cfg","feature","activeFeatures","schema","getMeta","setMeta","featureSignature","FEATURES","setJournalWal","db","deadline","Date","now","err","test","message","Atomics","wait","Int32Array","SharedArrayBuffer","connect","dbPath","_cfg","DatabaseSync","registerFunctions","createConnection","handle","close","ensureSchema","_handle","withTransaction","BEGIN_WRITE","setDerivedBusyTimeout","_conn","ms","filename","schemaVersion","reconcileDialect","sqliteDialect","createStore","openWithDialect"],"mappings":"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"}
+{"version":3,"sources":["/Users/kevin/Dev/OpenSource/ai/sensemaking/src/store/sqlite/open.ts"],"sourcesContent":["// The Node floor (>=22.20) is explained here and nowhere else: 22.20 is the first release with\n// both FTS5 and row-returning INSERT ... RETURNING. Raise it only for a load-bearing capability.\nimport { DatabaseSync } from 'node:sqlite';\nimport type { Config, ResolvedConfig } from '../../config/index.ts';\nimport { featureSignature } from '../../config/index.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 { BEGIN_WRITE, withTransaction } from '../transaction.ts';\nimport type { Connection, OpenDialect } from '../types.ts';\nimport { createConnection } from './connection.ts';\nimport { sqliteDialect } from './reconcile.ts';\nimport { registerFunctions } from './sql-functions.ts';\nimport { createStore } from './store.ts';\n\nexport const DB_FILENAME = 'cache.db';\n// Cache shape version, independent of the config's own `version`. Bumping it rebuilds\n// existing trees on first query.\nexport const SCHEMA_VERSION = '21';\n\nexport type { OpenResult };\n\n// unicode61 splits on spaces, so a language written without them indexes a whole run as one\n// token and word search finds nothing; the `_seg` sidecars (always populated) cover that case.\nconst TOKENIZE = 'porter unicode61';\n\ninterface SqliteHandle {\n  db: DatabaseSync;\n}\n\n// The `_seg` sidecars are appended after path, never inserted: bm25() and snippet(content, 2)\n// are documented against the first three columns. Each holds its field's exploded unspaced runs.\nasync function createContentTable(conn: Connection): Promise<void> {\n  await conn.exec(`CREATE VIRTUAL TABLE IF NOT EXISTS content USING fts5(title, summary, text, path UNINDEXED, title_seg, summary_seg, text_seg, tokenize = '${TOKENIZE}')`);\n}\n\n// Content is a separate table (not a column on frontmatter) so `SELECT * FROM frontmatter`\n// can't dump file text into context. Features add their own tables after the core ones.\nasync function ensureSchemaTables(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 createContentTable(conn);\n  await conn.exec(`CREATE TABLE IF NOT EXISTS indexed_sources (\"path\" TEXT PRIMARY KEY, text TEXT NOT NULL)`);\n  // Coverage, not ownership: a path can appear under several presets. path leads the PK so the\n  // per-doc delete is an index hit -- keyed the other way, cold builds went quadratic.\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)) await feature.schema(conn);\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\n// Two processes opening the same fresh tree both try to convert it, and the loser gets SQLITE_BUSY\n// with no busy handler behind it. Bounded because a lock held past this is a real problem, not a race.\nfunction setJournalWal(db: DatabaseSync): void {\n  const deadline = Date.now() + 5000;\n  for (;;) {\n    try {\n      db.exec('PRAGMA journal_mode = WAL');\n      return;\n    } catch (err) {\n      if (Date.now() >= deadline || !/database is locked|busy/i.test((err as Error).message)) throw err;\n      Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, 20);\n    }\n  }\n}\n\nasync function connect(dbPath: string, _cfg: ResolvedConfig, options: { existingOnly: boolean; observational: boolean }): Promise<{ handle: SqliteHandle; conn: Connection }> {\n  const db = new DatabaseSync(dbPath, options.existingOnly ? { readOnly: true } : {});\n  try {\n    // Before journal_mode, not after: converting a fresh database to WAL takes a brief exclusive\n    // lock, and with no timeout set yet a second process opening the same tree fails in 1ms.\n    db.exec('PRAGMA busy_timeout = 30000');\n    // busy_timeout does not cover the WAL conversion itself: SQLite does not invoke the busy\n    // handler for it, so a concurrent cold open needs its own bounded wait.\n    if (!options.observational) setJournalWal(db);\n    registerFunctions(db);\n    const conn = createConnection(db);\n    return { handle: { db }, conn };\n  } catch (err) {\n    // A throw here must release this handle, or on Windows the leaked WAL db is undeletable and\n    // scratch cleanup fails with EPERM/EBUSY.\n    db.close();\n    throw err;\n  }\n}\n\nasync function close(handle: SqliteHandle): Promise<void> {\n  handle.db.close();\n}\n\nasync function ensureSchema(_handle: SqliteHandle, conn: Connection, cfg: Config): Promise<void> {\n  // One writer at a time: the feature hooks check a column then add it, so two cold opens racing\n  // here both see it missing and the second ALTER fails with a duplicate column.\n  await withTransaction(conn, () => ensureSchemaTables(conn, cfg), BEGIN_WRITE);\n}\n\nasync function setDerivedBusyTimeout(handle: SqliteHandle, _conn: Connection, ms: number): Promise<void> {\n  handle.db.exec(`PRAGMA busy_timeout = ${ms}`);\n}\n\n// This store's dialect (types.ts's OpenDialect) for the shared orchestration in store/open.ts.\nexport const sqliteOpenDialect: OpenDialect<SqliteHandle> = {\n  filename: DB_FILENAME,\n  schemaVersion: SCHEMA_VERSION,\n  reconcileDialect: sqliteDialect,\n  connect,\n  close,\n  ensureSchema,\n  setDerivedBusyTimeout,\n  createStore: (handle, conn) => createStore(handle.db, conn),\n};\n\nexport async function openSqlite(cfg: ResolvedConfig, options?: InternalOpenOptions): Promise<OpenResult> {\n  return openWithDialect(cfg, sqliteOpenDialect, options);\n}\n"],"names":["DB_FILENAME","SCHEMA_VERSION","openSqlite","sqliteOpenDialect","TOKENIZE","createContentTable","conn","exec","ensureSchemaTables","cfg","feature","activeFeatures","schema","getMeta","setMeta","featureSignature","FEATURES","setJournalWal","db","deadline","Date","now","err","test","message","Atomics","wait","Int32Array","SharedArrayBuffer","connect","dbPath","_cfg","options","DatabaseSync","existingOnly","readOnly","observational","registerFunctions","createConnection","handle","close","ensureSchema","_handle","withTransaction","BEGIN_WRITE","setDerivedBusyTimeout","_conn","ms","filename","schemaVersion","reconcileDialect","sqliteDialect","createStore","openWithDialect"],"mappings":"AAAA,+FAA+F;AAC/F,iGAAiG;;;;;;;;;;;;QAepFA;eAAAA;;QAGAC;eAAAA;;QA8FSC;eAAAA;;QAXTC;eAAAA;;;0BApGgB;uBAEI;wBACQ;sBAET;wBACC;6BACY;4BAEZ;2BACH;8BACI;uBACN;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAErB,IAAMH,cAAc;AAGpB,IAAMC,iBAAiB;AAI9B,4FAA4F;AAC5F,+FAA+F;AAC/F,IAAMG,WAAW;AAMjB,8FAA8F;AAC9F,iGAAiG;AACjG,SAAeC,mBAAmBC,IAAgB;;;;;oBAChD;;wBAAMA,KAAKC,IAAI,CAAC,AAAC,6IAAqJ,OAATH,UAAS;;;oBAAtK;;;;;;IACF;;AAEA,2FAA2F;AAC3F,wFAAwF;AACxF,SAAeI,mBAAmBF,IAAgB,EAAEG,GAAW;;YAQxD,2BAAA,mBAAA,gBAAA,WAAA,OAAMC;;;;oBAPX;;wBAAMJ,KAAKC,IAAI,CAAC;;;oBAAhB;oBACA;;wBAAMF,mBAAmBC;;;oBAAzB;oBACA;;wBAAMA,KAAKC,IAAI,CAAC;;;oBAAhB;oBACA,6FAA6F;oBAC7F,qFAAqF;oBACrF;;wBAAMD,KAAKC,IAAI,CAAC;;;oBAAhB;oBACA;;wBAAMD,KAAKC,IAAI,CAAC;;;oBAAhB;oBACK,kCAAA,2BAAA;;;;;;;;;oBAAA,YAAiBI,IAAAA,wBAAc,EAACF;;;2BAAhC,6BAAA,QAAA;;;;oBAAMC,UAAN;oBAAsC;;wBAAMA,QAAQE,MAAM,CAACN;;;oBAArB;;;oBAAtC;;;;;;;;;;;;oBAAA;oBAAA;;;;;;;6BAAA,6BAAA;4BAAA;;;4BAAA;kCAAA;;;;;;;oBACA;;wBAAMO,IAAAA,iBAAO,EAACP,MAAM;;;yBAArB,CAAA,AAAC,kBAA2C,IAAG,GAA/C;;;;oBAAkD;;wBAAMQ,IAAAA,iBAAO,EAACR,MAAM,kBAAkBL;;;oBAAtC;;;oBACjD;;wBAAMY,IAAAA,iBAAO,EAACP,MAAM;;;yBAArB,CAAA,AAAC,kBAAqC,IAAG,GAAzC;;;;oBAA4C;;wBAAMQ,IAAAA,iBAAO,EAACR,MAAM,YAAYS,IAAAA,yBAAgB,EAACN,KAAKO,kBAAQ;;;oBAA9D;;;;;;;;IAClD;;AAEA,mGAAmG;AACnG,uGAAuG;AACvG,SAASC,cAAcC,EAAgB;IACrC,IAAMC,WAAWC,KAAKC,GAAG,KAAK;IAC9B,OAAS;QACP,IAAI;YACFH,GAAGX,IAAI,CAAC;YACR;QACF,EAAE,OAAOe,KAAK;YACZ,IAAIF,KAAKC,GAAG,MAAMF,YAAY,CAAC,2BAA2BI,IAAI,CAAC,AAACD,IAAcE,OAAO,GAAG,MAAMF;YAC9FG,QAAQC,IAAI,CAAC,IAAIC,WAAW,IAAIC,kBAAkB,KAAK,GAAG,GAAG;QAC/D;IACF;AACF;AAEA,SAAeC,QAAQC,MAAc,EAAEC,IAAoB,EAAEC,OAA0D;;YAC/Gd,IASEZ;;YATFY,KAAK,IAAIe,wBAAY,CAACH,QAAQE,QAAQE,YAAY,GAAG;gBAAEC,UAAU;YAAK,IAAI,CAAC;YACjF,IAAI;gBACF,6FAA6F;gBAC7F,yFAAyF;gBACzFjB,GAAGX,IAAI,CAAC;gBACR,yFAAyF;gBACzF,wEAAwE;gBACxE,IAAI,CAACyB,QAAQI,aAAa,EAAEnB,cAAcC;gBAC1CmB,IAAAA,iCAAiB,EAACnB;gBACZZ,OAAOgC,IAAAA,8BAAgB,EAACpB;gBAC9B;;oBAAO;wBAAEqB,QAAQ;4BAAErB,IAAAA;wBAAG;wBAAGZ,MAAAA;oBAAK;;YAChC,EAAE,OAAOgB,KAAK;gBACZ,4FAA4F;gBAC5F,0CAA0C;gBAC1CJ,GAAGsB,KAAK;gBACR,MAAMlB;YACR;;;;;IACF;;AAEA,SAAekB,MAAMD,MAAoB;;;YACvCA,OAAOrB,EAAE,CAACsB,KAAK;;;;;IACjB;;AAEA,SAAeC,aAAaC,OAAqB,EAAEpC,IAAgB,EAAEG,GAAW;;;;;oBAC9E,+FAA+F;oBAC/F,+EAA+E;oBAC/E;;wBAAMkC,IAAAA,8BAAe,EAACrC,MAAM;mCAAME,mBAAmBF,MAAMG;2BAAMmC,0BAAW;;;oBAA5E;;;;;;IACF;;AAEA,SAAeC,sBAAsBN,MAAoB,EAAEO,KAAiB,EAAEC,EAAU;;;YACtFR,OAAOrB,EAAE,CAACX,IAAI,CAAC,AAAC,yBAA2B,OAAHwC;;;;;IAC1C;;AAGO,IAAM5C,oBAA+C;IAC1D6C,UAAUhD;IACViD,eAAehD;IACfiD,kBAAkBC,0BAAa;IAC/BtB,SAAAA;IACAW,OAAAA;IACAC,cAAAA;IACAI,uBAAAA;IACAO,aAAa,SAAbA,YAAcb,QAAQjC;eAAS8C,IAAAA,oBAAW,EAACb,OAAOrB,EAAE,EAAEZ;;AACxD;AAEO,SAAeJ,WAAWO,GAAmB,EAAEuB,OAA6B;;;YACjF;;gBAAOqB,IAAAA,uBAAe,EAAC5C,KAAKN,mBAAmB6B;;;IACjD"}

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

@@ -1,9 +1,9 @@
 import type { Database } from '@tursodatabase/database';
 import type { ResolvedConfig } from '../../config/index.js';
-import type { OpenResult } from '../open.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 = "8";
+export declare const SCHEMA_VERSION = "9";
 export type { OpenResult };
 export declare const tursoOpenDialect: OpenDialect<Database>;
-export declare function openTurso(cfg: ResolvedConfig): Promise<OpenResult>;
+export declare function openTurso(cfg: ResolvedConfig, options?: InternalOpenOptions): Promise<OpenResult>;

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

@@ -1,9 +1,9 @@
 import type { Database } from '@tursodatabase/database';
 import type { ResolvedConfig } from '../../config/index.js';
-import type { OpenResult } from '../open.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 = "8";
+export declare const SCHEMA_VERSION = "9";
 export type { OpenResult };
 export declare const tursoOpenDialect: OpenDialect<Database>;
-export declare function openTurso(cfg: ResolvedConfig): Promise<OpenResult>;
+export declare function openTurso(cfg: ResolvedConfig, options?: InternalOpenOptions): Promise<OpenResult>;

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

@@ -240,7 +240,7 @@ 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 = '8';
+var SCHEMA_VERSION = '9';
 // 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) {
@@ -261,50 +261,56 @@ function ensureSchema(_handle, conn, cfg) {
                     ];
                 case 2:
                     _state.sent();
-                    _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
-                    _state.label = 3;
+                    return [
+                        4,
+                        conn.exec('CREATE TABLE IF NOT EXISTS indexed_sources ("path" TEXT PRIMARY KEY, text TEXT NOT NULL)')
+                    ];
                 case 3:
+                    _state.sent();
+                    _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+                    _state.label = 4;
+                case 4:
                     _state.trys.push([
-                        3,
-                        8,
+                        4,
                         9,
-                        10
+                        10,
+                        11
                     ]);
                     _iterator = _reconcilets.CONTENT_FTS_DDL[Symbol.iterator]();
-                    _state.label = 4;
-                case 4:
+                    _state.label = 5;
+                case 5:
                     if (!!(_iteratorNormalCompletion = (_step = _iterator.next()).done)) return [
                         3,
-                        7
+                        8
                     ];
                     ddl = _step.value;
                     return [
                         4,
                         conn.exec(ddl)
                     ];
-                case 5:
-                    _state.sent();
-                    _state.label = 6;
                 case 6:
+                    _state.sent();
+                    _state.label = 7;
+                case 7:
                     _iteratorNormalCompletion = true;
                     return [
                         3,
-                        4
+                        5
                     ];
-                case 7:
+                case 8:
                     return [
                         3,
-                        10
+                        11
                     ];
-                case 8:
+                case 9:
                     err = _state.sent();
                     _didIteratorError = true;
                     _iteratorError = err;
                     return [
                         3,
-                        10
+                        11
                     ];
-                case 9:
+                case 10:
                     try {
                         if (!_iteratorNormalCompletion && _iterator.return != null) {
                             _iterator.return();
@@ -317,78 +323,78 @@ function ensureSchema(_handle, conn, cfg) {
                     return [
                         7
                     ];
-                case 10:
+                case 11:
                     return [
                         4,
                         conn.exec('CREATE TABLE IF NOT EXISTS preset_files ("path" TEXT, preset TEXT, PRIMARY KEY ("path", preset))')
                     ];
-                case 11:
+                case 12:
                     _state.sent();
                     return [
                         4,
                         conn.exec('CREATE INDEX IF NOT EXISTS preset_files_preset ON preset_files(preset)')
                     ];
-                case 12:
+                case 13:
                     _state.sent();
                     _iteratorNormalCompletion1 = true, _didIteratorError1 = false, _iteratorError1 = undefined;
-                    _state.label = 13;
-                case 13:
+                    _state.label = 14;
+                case 14:
                     _state.trys.push([
-                        13,
-                        20,
+                        14,
                         21,
-                        22
+                        22,
+                        23
                     ]);
                     _iterator1 = (0, _indexts1.activeFeatures)(cfg)[Symbol.iterator]();
-                    _state.label = 14;
-                case 14:
+                    _state.label = 15;
+                case 15:
                     if (!!(_iteratorNormalCompletion1 = (_step1 = _iterator1.next()).done)) return [
                         3,
-                        19
+                        20
                     ];
                     feature = _step1.value;
                     if (!(feature.name === 'embed')) return [
                         3,
-                        16
+                        17
                     ];
                     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))'))
                     ];
-                case 15:
+                case 16:
                     _state.sent();
                     return [
                         3,
-                        18
+                        19
                     ];
-                case 16:
+                case 17:
                     return [
                         4,
                         feature.schema(conn)
                     ];
-                case 17:
-                    _state.sent();
-                    _state.label = 18;
                 case 18:
+                    _state.sent();
+                    _state.label = 19;
+                case 19:
                     _iteratorNormalCompletion1 = true;
                     return [
                         3,
-                        14
+                        15
                     ];
-                case 19:
+                case 20:
                     return [
                         3,
-                        22
+                        23
                     ];
-                case 20:
+                case 21:
                     err = _state.sent();
                     _didIteratorError1 = true;
                     _iteratorError1 = err;
                     return [
                         3,
-                        22
+                        23
                     ];
-                case 21:
+                case 22:
                     try {
                         if (!_iteratorNormalCompletion1 && _iterator1.return != null) {
                             _iterator1.return();
@@ -401,41 +407,41 @@ function ensureSchema(_handle, conn, cfg) {
                     return [
                         7
                     ];
-                case 22:
+                case 23:
                     return [
                         4,
                         (0, _sharedts.getMeta)(conn, 'schema_version')
                     ];
-                case 23:
+                case 24:
                     if (!(_state.sent() === null)) return [
                         3,
-                        25
+                        26
                     ];
                     return [
                         4,
                         (0, _sharedts.setMeta)(conn, 'schema_version', SCHEMA_VERSION)
                     ];
-                case 24:
-                    _state.sent();
-                    _state.label = 25;
                 case 25:
+                    _state.sent();
+                    _state.label = 26;
+                case 26:
                     return [
                         4,
                         (0, _sharedts.getMeta)(conn, 'features')
                     ];
-                case 26:
+                case 27:
                     if (!(_state.sent() === null)) return [
                         3,
-                        28
+                        29
                     ];
                     return [
                         4,
                         (0, _sharedts.setMeta)(conn, 'features', (0, _indexts.featureSignature)(cfg, _indexts1.FEATURES))
                     ];
-                case 27:
-                    _state.sent();
-                    _state.label = 28;
                 case 28:
+                    _state.sent();
+                    _state.label = 29;
+                case 29:
                     return [
                         2
                     ];
@@ -443,29 +449,38 @@ function ensureSchema(_handle, conn, cfg) {
         });
     })();
 }
-function close(handle) {
-    return _async_to_generator(function() {
+function close(_0) {
+    return _async_to_generator(function(handle) {
+        var options;
+        var _arguments = arguments;
         return _ts_generator(this, function(_state) {
             switch(_state.label){
                 case 0:
+                    options = _arguments.length > 1 && _arguments[1] !== void 0 ? _arguments[1] : {};
+                    if (!!options.observational) return [
+                        3,
+                        2
+                    ];
                     return [
                         4,
                         (0, _connectionts.checkpointWal)(handle)
                     ];
                 case 1:
                     _state.sent();
+                    _state.label = 2;
+                case 2:
                     return [
                         4,
                         handle.close()
                     ];
-                case 2:
+                case 3:
                     _state.sent();
                     return [
                         2
                     ];
             }
         });
-    })();
+    }).apply(this, arguments);
 }
 function setDerivedBusyTimeout(_handle, conn, ms) {
     return _async_to_generator(function() {
@@ -485,7 +500,7 @@ function setDerivedBusyTimeout(_handle, conn, ms) {
         });
     })();
 }
-function connect(dbPath, _cfg) {
+function connect(dbPath, _cfg, options) {
     return _async_to_generator(function() {
         var turso, err, db, err1;
         return _ts_generator(this, function(_state) {
@@ -520,13 +535,15 @@ function connect(dbPath, _cfg) {
                     ]);
                     return [
                         4,
-                        turso.connect(dbPath, _object_spread_props(_object_spread({}, _nativets.CONNECT_OPTS), {
+                        turso.connect(dbPath, _object_spread(_object_spread_props(_object_spread({}, _nativets.CONNECT_OPTS), {
                             experimental: _to_consumable_array(_nativets.CONNECT_OPTS.experimental)
-                        }))
+                        }), options.existingOnly ? {
+                            fileMustExist: true
+                        } : {}))
                     ];
                 case 4:
-                    // `timeout` is connect-time only in this client; the derived value is set via runtime PRAGMA
-                    // below. Options in native.ts, shared with reclaimSpace's own connection.
+                    // Turso's readonly mode rejects native FTS SELECTs and TEMP query tables. Existing-only opens
+                    // stay query-capable; shared no-build orchestration and observational close prevent upkeep writes.
                     db = _state.sent();
                     return [
                         3,
@@ -561,16 +578,16 @@ var tursoOpenDialect = {
     },
     ensureSchema: ensureSchema,
     setDerivedBusyTimeout: setDerivedBusyTimeout,
-    createStore: function createStore(handle, conn) {
-        return (0, _storets.createStore)(handle, conn);
+    createStore: function createStore(handle, conn, _cfg, options) {
+        return (0, _storets.createStore)(handle, conn, options);
     }
 };
-function openTurso(cfg) {
+function openTurso(cfg, options) {
     return _async_to_generator(function() {
         return _ts_generator(this, function(_state) {
             return [
                 2,
-                (0, _opents.openWithDialect)(cfg, tursoOpenDialect)
+                (0, _opents.openWithDialect)(cfg, tursoOpenDialect, 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 { 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 = '8';\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  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): Promise<void> {\n  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): 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    // `timeout` is connect-time only in this client; the derived value is set via runtime PRAGMA\n    // below. Options in native.ts, shared with reclaimSpace's own connection.\n    db = await turso.connect(dbPath, { ...CONNECT_OPTS, experimental: [...CONNECT_OPTS.experimental] });\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) => createStore(handle, conn),\n};\n\nexport async function openTurso(cfg: ResolvedConfig): Promise<OpenResult> {\n  return openWithDialect(cfg, tursoOpenDialect);\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","checkpointWal","setDerivedBusyTimeout","ms","connect","dbPath","_cfg","turso","err","db","tursoApi","SenseError","TURSO_PACKAGE","message","CONNECT_OPTS","experimental","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 { 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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"}