sensemaking 0.27.0 → 0.28.0

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

@@ -26,10 +26,13 @@ _export(exports, {
 });
 var _nodesqlite = require("node:sqlite");
 var _indexts = require("../../features/index.js");
+var _enginets = require("../engine.js");
 var _opents = require("../open.js");
 var _sharedts = require("../shared.js");
 var _transactionts = require("../transaction.js");
 var _connectionts = require("./connection.js");
+var _enginets1 = require("./engine.js");
+var _lexicalts = require("./lexical.js");
 var _reconcilets = require("./reconcile.js");
 var _sqlfunctionsts = require("./sql-functions.js");
 var _storets = require("./store.js");
@@ -160,11 +163,6 @@ function _ts_generator(thisArg, body) {
 }
 var DB_FILENAME = 'cache.db';
 var SCHEMA_VERSION = '22';
-// 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';
-// The `_seg` sidecars are appended after path, never inserted: bm25() and snippet(content, 2)
-// are documented against the first three columns. Each holds its field's exploded unspaced runs.
 function createContentTable(conn) {
     return _async_to_generator(function() {
         return _ts_generator(this, function(_state) {
@@ -172,7 +170,7 @@ function createContentTable(conn) {
                 case 0:
                     return [
                         4,
-                        conn.exec("CREATE VIRTUAL TABLE IF NOT EXISTS content USING fts5(title, summary, text, path UNINDEXED, title_seg, summary_seg, text_seg, tokenize = '".concat(TOKENIZE, "')"))
+                        conn.exec((0, _enginets1.sqliteFts)().createContent())
                     ];
                 case 1:
                     _state.sent();
@@ -408,12 +406,127 @@ function setDerivedBusyTimeout(handle, _conn, ms) {
         });
     })();
 }
+// The real schema, content write and lexical query over store/engine.ts's fixture, in memory.
+function checkSqliteEngine() {
+    return _async_to_generator(function() {
+        var db, conn, docs, remedy;
+        return _ts_generator(this, function(_state) {
+            switch(_state.label){
+                case 0:
+                    db = new _nodesqlite.DatabaseSync(':memory:');
+                    _state.label = 1;
+                case 1:
+                    _state.trys.push([
+                        1,
+                        ,
+                        7,
+                        8
+                    ]);
+                    (0, _sqlfunctionsts.registerFunctions)(db);
+                    conn = (0, _connectionts.createConnection)(db);
+                    return [
+                        4,
+                        conn.exec('CREATE TABLE meta (key TEXT PRIMARY KEY, value TEXT)')
+                    ];
+                case 2:
+                    _state.sent();
+                    return [
+                        4,
+                        ensureCoreSchemaTables(conn)
+                    ];
+                case 3:
+                    _state.sent();
+                    return [
+                        4,
+                        conn.runBatch('INSERT INTO frontmatter ("path") VALUES (?)', _enginets.ENGINE_CHECK_DOCS.map(function(doc) {
+                            return [
+                                doc.path
+                            ];
+                        }))
+                    ];
+                case 4:
+                    _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,
+                        conn.runBatch(_reconcilets.INSERT_CONTENT_SQL, docs.map(_reconcilets.contentRow))
+                    ];
+                case 5:
+                    _state.sent();
+                    remedy = "this SQLite is bundled with Node ".concat(process.version, " (SQLite ").concat(_enginets1.SQLITE_VERSION !== null && _enginets1.SQLITE_VERSION !== void 0 ? _enginets1.SQLITE_VERSION : 'unknown', "); run sense on a Node release whose bundled SQLite passes");
+                    return [
+                        4,
+                        (0, _enginets.checkEngine)('sqlite', (0, _enginets1.sqliteIdentity)(), remedy, 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 6:
+                    _state.sent();
+                    return [
+                        3,
+                        8
+                    ];
+                case 7:
+                    db.close();
+                    return [
+                        7
+                    ];
+                case 8:
+                    return [
+                        2
+                    ];
+            }
+        });
+    })();
+}
 var sqliteOpenDialect = {
     filename: DB_FILENAME,
     schemaVersion: SCHEMA_VERSION,
     reconcileDialect: _reconcilets.sqliteDialect,
     connect: connect,
     close: close,
+    engineIdentity: function engineIdentity() {
+        return _async_to_generator(function() {
+            return _ts_generator(this, function(_state) {
+                return [
+                    2,
+                    (0, _enginets1.sqliteIdentity)()
+                ];
+            });
+        })();
+    },
+    checkEngine: checkSqliteEngine,
     ensureCoreSchema: ensureCoreSchema,
     ensureFeatureSchema: ensureFeatureSchema,
     setDerivedBusyTimeout: setDerivedBusyTimeout,

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 { activeFeatures } 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 = '22';\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. Feature schema is published later with its generation.\nasync function ensureCoreSchemaTables(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 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  if ((await getMeta(conn, 'schema_version')) === null) await setMeta(conn, 'schema_version', SCHEMA_VERSION);\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 ensureCoreSchema(_handle: SqliteHandle, conn: Connection): Promise<void> {\n  // One writer at a time: two cold opens can bootstrap the same database concurrently.\n  await withTransaction(conn, () => ensureCoreSchemaTables(conn), BEGIN_WRITE);\n}\n\nasync function ensureFeatureSchema(_handle: SqliteHandle, conn: Connection, cfg: Config): Promise<void> {\n  for (const feature of activeFeatures(cfg)) await feature.schema(conn);\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  ensureCoreSchema,\n  ensureFeatureSchema,\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","ensureCoreSchemaTables","getMeta","setMeta","setJournalWal","db","deadline","Date","now","err","test","message","Atomics","wait","Int32Array","SharedArrayBuffer","connect","dbPath","_cfg","options","DatabaseSync","existingOnly","readOnly","observational","registerFunctions","createConnection","handle","close","ensureCoreSchema","_handle","withTransaction","BEGIN_WRITE","ensureFeatureSchema","cfg","feature","activeFeatures","schema","setDerivedBusyTimeout","_conn","ms","filename","schemaVersion","reconcileDialect","sqliteDialect","createStore","openWithDialect"],"mappings":"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"}
+{"version":3,"sources":["/Users/kevin/Dev/open-source/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 { activeFeatures } from '../../features/index.ts';\nimport type { ParsedDoc } from '../../scan/index.ts';\nimport { ENGINE_CHECK_DOCS, checkEngine as runEngineCheck } from '../engine.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 { SQLITE_VERSION, sqliteFts, sqliteIdentity } from './engine.ts';\nimport { queryLexical } from './lexical.ts';\nimport { contentRow, INSERT_CONTENT_SQL, 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 = '22';\n\nexport type { OpenResult };\n\ninterface SqliteHandle {\n  db: DatabaseSync;\n}\n\nasync function createContentTable(conn: Connection): Promise<void> {\n  await conn.exec(sqliteFts().createContent());\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. Feature schema is published later with its generation.\nasync function ensureCoreSchemaTables(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 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  if ((await getMeta(conn, 'schema_version')) === null) await setMeta(conn, 'schema_version', SCHEMA_VERSION);\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 ensureCoreSchema(_handle: SqliteHandle, conn: Connection): Promise<void> {\n  // One writer at a time: two cold opens can bootstrap the same database concurrently.\n  await withTransaction(conn, () => ensureCoreSchemaTables(conn), BEGIN_WRITE);\n}\n\nasync function ensureFeatureSchema(_handle: SqliteHandle, conn: Connection, cfg: Config): Promise<void> {\n  for (const feature of activeFeatures(cfg)) await feature.schema(conn);\n}\n\nasync function setDerivedBusyTimeout(handle: SqliteHandle, _conn: Connection, ms: number): Promise<void> {\n  handle.db.exec(`PRAGMA busy_timeout = ${ms}`);\n}\n\n// The real schema, content write and lexical query over store/engine.ts's fixture, in memory.\nasync function checkSqliteEngine(): Promise<void> {\n  const db = new DatabaseSync(':memory:');\n  try {\n    registerFunctions(db);\n    const conn = createConnection(db);\n    await conn.exec('CREATE TABLE meta (key TEXT PRIMARY KEY, value TEXT)');\n    await ensureCoreSchemaTables(conn);\n    await conn.runBatch(\n      'INSERT INTO frontmatter (\"path\") VALUES (?)',\n      ENGINE_CHECK_DOCS.map((doc) => [doc.path])\n    );\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 conn.runBatch(INSERT_CONTENT_SQL, docs.map(contentRow));\n    const remedy = `this SQLite is bundled with Node ${process.version} (SQLite ${SQLITE_VERSION ?? 'unknown'}); run sense on a Node release whose bundled SQLite passes`;\n    await runEngineCheck('sqlite', sqliteIdentity(), remedy, async (terms) => (await queryLexical(conn, terms, { whereJoin: '', whereCond: '', scopeCond: '', limit: 10 })).map((hit) => hit.path));\n  } finally {\n    db.close();\n  }\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  engineIdentity: async () => sqliteIdentity(),\n  checkEngine: checkSqliteEngine,\n  ensureCoreSchema,\n  ensureFeatureSchema,\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","createContentTable","conn","exec","sqliteFts","createContent","ensureCoreSchemaTables","getMeta","setMeta","setJournalWal","db","deadline","Date","now","err","test","message","Atomics","wait","Int32Array","SharedArrayBuffer","connect","dbPath","_cfg","options","DatabaseSync","existingOnly","readOnly","observational","registerFunctions","createConnection","handle","close","ensureCoreSchema","_handle","withTransaction","BEGIN_WRITE","ensureFeatureSchema","cfg","feature","activeFeatures","schema","setDerivedBusyTimeout","_conn","ms","checkSqliteEngine","docs","remedy","runBatch","ENGINE_CHECK_DOCS","map","doc","path","relPath","search","title","summary","text","INSERT_CONTENT_SQL","contentRow","process","version","SQLITE_VERSION","runEngineCheck","sqliteIdentity","terms","queryLexical","whereJoin","whereCond","scopeCond","limit","hit","filename","schemaVersion","reconcileDialect","sqliteDialect","engineIdentity","checkEngine","createStore","openWithDialect"],"mappings":"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"}

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

@@ -1 +1 @@
-{"version":3,"sources":["/Users/kevin/Dev/OpenSource/ai/sensemaking/src/store/sqlite/reconcile.ts"],"sourcesContent":["import type { Config } from '../../config/index.ts';\nimport { SenseError } from '../../errors.ts';\nimport type { ReconcileDelta } from '../../features/types.ts';\nimport type { ParsedDoc } from '../../scan/index.ts';\nimport { segmentField } from '../../text/segment.ts';\nimport { quoteIdent, recordReconcileDuration } from '../shared.ts';\nimport { BEGIN_WRITE } from '../transaction.ts';\nimport type { Connection, ReconcileDialect } from '../types.ts';\n\n// This store's dialect (types.ts's ReconcileDialect) for the shared orchestration in\n// store/reconcile.ts. content is FTS5-virtual with \"_seg\" sidecars for lexical.ts.\n\n// SQLite's compile-time SQLITE_MAX_COLUMN, default 2000 (https://www.sqlite.org/limits.html).\nconst MAX_FRONTMATTER_COLUMNS = 2000;\n\n// Shared by reconcileContent() and the tokenize-only rebuild in open.ts, so both prepare the\n// same literal instead of two copies drifting apart.\nexport const INSERT_CONTENT_SQL = `INSERT INTO content (rowid, title, summary, text, \"path\", title_seg, summary_seg, text_seg) VALUES ((SELECT rowid FROM frontmatter WHERE \"path\" = ?), ?, ?, ?, ?, ?, ?, ?)`;\n\n// A single content row's param tuple, matching INSERT_CONTENT_SQL's placeholder order.\n// Assumes the frontmatter row for doc.relPath already exists (rowid subquery).\nexport function contentRow(doc: ParsedDoc): unknown[] {\n  return [doc.relPath, doc.search.title, doc.search.summary, doc.search.text, doc.relPath, segmentField(doc.search.title), segmentField(doc.search.summary), segmentField(doc.search.text)];\n}\n\nasync function reconcileContent(conn: Connection, touched: string[], docs: ParsedDoc[], _delta: ReconcileDelta, _cfg: Config): Promise<void> {\n  // FTS5 has no upsert, so delete-before-insert, coupled to the frontmatter rowid (indexed via\n  // its PRIMARY KEY) rather than the UNINDEXED `path` column, which a per-row DELETE would scan to find.\n  // builder.ts's generation fence rejects a plan whose added/touched classification went stale\n  // behind another publication, so this receives one classification from the locked generation.\n  if (touched.length > 0)\n    await conn.runBatch(\n      'DELETE FROM content WHERE rowid = (SELECT rowid FROM frontmatter WHERE \"path\" = ?)',\n      touched.map((p) => [p])\n    );\n\n  if (docs.length > 0) await conn.runBatch(INSERT_CONTENT_SQL, docs.map(contentRow));\n}\n\n// SQLite's ADD COLUMN is metadata-only, so a loop costs nothing extra over one statement.\nasync function addColumns(conn: Connection, names: string[]): Promise<void> {\n  for (const name of names) await conn.exec(`ALTER TABLE frontmatter ADD COLUMN ${quoteIdent(name)}`);\n}\n\nexport const sqliteDialect: ReconcileDialect = {\n  beginMode: () => BEGIN_WRITE,\n  checkColumnLimit(count) {\n    // Fence before ALTERing: SQLite's own failure past this point is a raw\n    // \"too many columns on sqlite_altertab_frontmatter\" with no indication of the boundary or the levers.\n    if (count > MAX_FRONTMATTER_COLUMNS) {\n      throw new SenseError(\n        'COLUMN_LIMIT',\n        `frontmatter would need ${count} columns, crossing SQLite's compile-time SQLITE_MAX_COLUMN limit (default ${MAX_FRONTMATTER_COLUMNS}; see https://www.sqlite.org/limits.html). Narrow the presets' include globs so fewer/other files are indexed, or fix whatever is generating unbounded frontmatter keys.`\n      );\n    }\n  },\n  addColumns,\n  reconcileContent,\n  recordDuration: recordReconcileDuration,\n};\n"],"names":["INSERT_CONTENT_SQL","contentRow","sqliteDialect","MAX_FRONTMATTER_COLUMNS","doc","relPath","search","title","summary","text","segmentField","reconcileContent","conn","touched","docs","_delta","_cfg","length","runBatch","map","p","addColumns","names","name","exec","quoteIdent","beginMode","BEGIN_WRITE","checkColumnLimit","count","SenseError","recordDuration","recordReconcileDuration"],"mappings":";;;;;;;;;;;QAiBaA;eAAAA;;QAIGC;eAAAA;;QAuBHC;eAAAA;;;wBA3Cc;yBAGE;wBACuB;6BACxB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAG5B,qFAAqF;AACrF,mFAAmF;AAEnF,8FAA8F;AAC9F,IAAMC,0BAA0B;AAIzB,IAAMH,qBAAqB;AAI3B,SAASC,WAAWG,GAAc;IACvC,OAAO;QAACA,IAAIC,OAAO;QAAED,IAAIE,MAAM,CAACC,KAAK;QAAEH,IAAIE,MAAM,CAACE,OAAO;QAAEJ,IAAIE,MAAM,CAACG,IAAI;QAAEL,IAAIC,OAAO;QAAEK,IAAAA,uBAAY,EAACN,IAAIE,MAAM,CAACC,KAAK;QAAGG,IAAAA,uBAAY,EAACN,IAAIE,MAAM,CAACE,OAAO;QAAGE,IAAAA,uBAAY,EAACN,IAAIE,MAAM,CAACG,IAAI;KAAE;AAC3L;AAEA,SAAeE,iBAAiBC,IAAgB,EAAEC,OAAiB,EAAEC,IAAiB,EAAEC,MAAsB,EAAEC,IAAY;;;;;yBAKtHH,CAAAA,QAAQI,MAAM,GAAG,CAAA,GAAjBJ;;;;oBACF;;wBAAMD,KAAKM,QAAQ,CACjB,sFACAL,QAAQM,GAAG,CAAC,SAACC;mCAAM;gCAACA;6BAAE;;;;oBAFxB;;;yBAKEN,CAAAA,KAAKG,MAAM,GAAG,CAAA,GAAdH;;;;oBAAiB;;wBAAMF,KAAKM,QAAQ,CAAClB,oBAAoBc,KAAKK,GAAG,CAAClB;;;oBAAjD;;;;;;;;IACvB;;AAEA,0FAA0F;AAC1F,SAAeoB,WAAWT,IAAgB,EAAEU,KAAe;;YACpD,2BAAA,mBAAA,gBAAA,WAAA,OAAMC;;;;oBAAN,kCAAA,2BAAA;;;;;;;;;oBAAA,YAAcD;;;2BAAd,6BAAA,QAAA;;;;oBAAMC,OAAN;oBAAqB;;wBAAMX,KAAKY,IAAI,CAAC,AAAC,sCAAsD,OAAjBC,IAAAA,oBAAU,EAACF;;;oBAAjE;;;oBAArB;;;;;;;;;;;;oBAAA;oBAAA;;;;;;;6BAAA,6BAAA;4BAAA;;;4BAAA;kCAAA;;;;;;;;;;;;IACP;;AAEO,IAAMrB,gBAAkC;IAC7CwB,WAAW,SAAXA;eAAiBC,0BAAW;;IAC5BC,kBAAAA,SAAAA,iBAAiBC,KAAK;QACpB,uEAAuE;QACvE,sGAAsG;QACtG,IAAIA,QAAQ1B,yBAAyB;YACnC,MAAM,IAAI2B,oBAAU,CAClB,gBACA,AAAC,0BAA2G3B,OAAlF0B,OAAM,8EAAoG,OAAxB1B,yBAAwB;QAExI;IACF;IACAkB,YAAAA;IACAV,kBAAAA;IACAoB,gBAAgBC,iCAAuB;AACzC"}
+{"version":3,"sources":["/Users/kevin/Dev/open-source/ai/sensemaking/src/store/sqlite/reconcile.ts"],"sourcesContent":["import type { Config } from '../../config/index.ts';\nimport { SenseError } from '../../errors.ts';\nimport type { ReconcileDelta } from '../../features/types.ts';\nimport type { ParsedDoc } from '../../scan/index.ts';\nimport { segmentField } from '../../text/segment.ts';\nimport { quoteIdent, recordReconcileDuration } from '../shared.ts';\nimport { BEGIN_WRITE } from '../transaction.ts';\nimport type { Connection, ReconcileDialect } from '../types.ts';\n\n// This store's dialect (types.ts's ReconcileDialect) for the shared orchestration in\n// store/reconcile.ts. content is FTS5-virtual with \"_seg\" sidecars for lexical.ts.\n\n// SQLite's compile-time SQLITE_MAX_COLUMN, default 2000 (https://www.sqlite.org/limits.html).\nconst MAX_FRONTMATTER_COLUMNS = 2000;\n\n// Shared by reconcileContent() and the tokenize-only rebuild in open.ts, so both prepare the\n// same literal instead of two copies drifting apart.\nexport const INSERT_CONTENT_SQL = `INSERT INTO content (rowid, title, summary, text, \"path\", title_seg, summary_seg, text_seg) VALUES ((SELECT rowid FROM frontmatter WHERE \"path\" = ?), ?, ?, ?, ?, ?, ?, ?)`;\n\n// A single content row's param tuple, matching INSERT_CONTENT_SQL's placeholder order.\n// Assumes the frontmatter row for doc.relPath already exists (rowid subquery).\nexport function contentRow(doc: ParsedDoc): unknown[] {\n  return [doc.relPath, doc.search.title, doc.search.summary, doc.search.text, doc.relPath, segmentField(doc.search.title), segmentField(doc.search.summary), segmentField(doc.search.text)];\n}\n\nasync function reconcileContent(conn: Connection, touched: string[], docs: ParsedDoc[], _delta: ReconcileDelta, _cfg: Config): Promise<void> {\n  // FTS5 has no upsert, so delete-before-insert, coupled to the frontmatter rowid (indexed via\n  // its PRIMARY KEY) rather than the UNINDEXED `path` column, which a per-row DELETE would scan to find.\n  // builder.ts's generation fence rejects a plan whose added/touched classification went stale\n  // behind another publication, so this receives one classification from the locked generation.\n  if (touched.length > 0)\n    await conn.runBatch(\n      'DELETE FROM content WHERE rowid = (SELECT rowid FROM frontmatter WHERE \"path\" = ?)',\n      touched.map((p) => [p])\n    );\n\n  if (docs.length > 0) await conn.runBatch(INSERT_CONTENT_SQL, docs.map(contentRow));\n}\n\n// SQLite's ADD COLUMN is metadata-only, so a loop costs nothing extra over one statement.\nasync function addColumns(conn: Connection, names: string[]): Promise<void> {\n  for (const name of names) await conn.exec(`ALTER TABLE frontmatter ADD COLUMN ${quoteIdent(name)}`);\n}\n\nexport const sqliteDialect: ReconcileDialect = {\n  beginMode: () => BEGIN_WRITE,\n  checkColumnLimit(count) {\n    // Fence before ALTERing: SQLite's own failure past this point is a raw\n    // \"too many columns on sqlite_altertab_frontmatter\" with no indication of the boundary or the levers.\n    if (count > MAX_FRONTMATTER_COLUMNS) {\n      throw new SenseError(\n        'COLUMN_LIMIT',\n        `frontmatter would need ${count} columns, crossing SQLite's compile-time SQLITE_MAX_COLUMN limit (default ${MAX_FRONTMATTER_COLUMNS}; see https://www.sqlite.org/limits.html). Narrow the presets' include globs so fewer/other files are indexed, or fix whatever is generating unbounded frontmatter keys.`\n      );\n    }\n  },\n  addColumns,\n  reconcileContent,\n  recordDuration: recordReconcileDuration,\n};\n"],"names":["INSERT_CONTENT_SQL","contentRow","sqliteDialect","MAX_FRONTMATTER_COLUMNS","doc","relPath","search","title","summary","text","segmentField","reconcileContent","conn","touched","docs","_delta","_cfg","length","runBatch","map","p","addColumns","names","name","exec","quoteIdent","beginMode","BEGIN_WRITE","checkColumnLimit","count","SenseError","recordDuration","recordReconcileDuration"],"mappings":";;;;;;;;;;;QAiBaA;eAAAA;;QAIGC;eAAAA;;QAuBHC;eAAAA;;;wBA3Cc;yBAGE;wBACuB;6BACxB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAG5B,qFAAqF;AACrF,mFAAmF;AAEnF,8FAA8F;AAC9F,IAAMC,0BAA0B;AAIzB,IAAMH,qBAAqB;AAI3B,SAASC,WAAWG,GAAc;IACvC,OAAO;QAACA,IAAIC,OAAO;QAAED,IAAIE,MAAM,CAACC,KAAK;QAAEH,IAAIE,MAAM,CAACE,OAAO;QAAEJ,IAAIE,MAAM,CAACG,IAAI;QAAEL,IAAIC,OAAO;QAAEK,IAAAA,uBAAY,EAACN,IAAIE,MAAM,CAACC,KAAK;QAAGG,IAAAA,uBAAY,EAACN,IAAIE,MAAM,CAACE,OAAO;QAAGE,IAAAA,uBAAY,EAACN,IAAIE,MAAM,CAACG,IAAI;KAAE;AAC3L;AAEA,SAAeE,iBAAiBC,IAAgB,EAAEC,OAAiB,EAAEC,IAAiB,EAAEC,MAAsB,EAAEC,IAAY;;;;;yBAKtHH,CAAAA,QAAQI,MAAM,GAAG,CAAA,GAAjBJ;;;;oBACF;;wBAAMD,KAAKM,QAAQ,CACjB,sFACAL,QAAQM,GAAG,CAAC,SAACC;mCAAM;gCAACA;6BAAE;;;;oBAFxB;;;yBAKEN,CAAAA,KAAKG,MAAM,GAAG,CAAA,GAAdH;;;;oBAAiB;;wBAAMF,KAAKM,QAAQ,CAAClB,oBAAoBc,KAAKK,GAAG,CAAClB;;;oBAAjD;;;;;;;;IACvB;;AAEA,0FAA0F;AAC1F,SAAeoB,WAAWT,IAAgB,EAAEU,KAAe;;YACpD,2BAAA,mBAAA,gBAAA,WAAA,OAAMC;;;;oBAAN,kCAAA,2BAAA;;;;;;;;;oBAAA,YAAcD;;;2BAAd,6BAAA,QAAA;;;;oBAAMC,OAAN;oBAAqB;;wBAAMX,KAAKY,IAAI,CAAC,AAAC,sCAAsD,OAAjBC,IAAAA,oBAAU,EAACF;;;oBAAjE;;;oBAArB;;;;;;;;;;;;oBAAA;oBAAA;;;;;;;6BAAA,6BAAA;4BAAA;;;4BAAA;kCAAA;;;;;;;;;;;;IACP;;AAEO,IAAMrB,gBAAkC;IAC7CwB,WAAW,SAAXA;eAAiBC,0BAAW;;IAC5BC,kBAAAA,SAAAA,iBAAiBC,KAAK;QACpB,uEAAuE;QACvE,sGAAsG;QACtG,IAAIA,QAAQ1B,yBAAyB;YACnC,MAAM,IAAI2B,oBAAU,CAClB,gBACA,AAAC,0BAA2G3B,OAAlF0B,OAAM,8EAAoG,OAAxB1B,yBAAwB;QAExI;IACF;IACAkB,YAAAA;IACAV,kBAAAA;IACAoB,gBAAgBC,iCAAuB;AACzC"}

package/dist/cjs/store/sqlite/sql-functions.js.map

@@ -1 +1 @@
-{"version":3,"sources":["/Users/kevin/Dev/OpenSource/ai/sensemaking/src/store/sqlite/sql-functions.ts"],"sourcesContent":["import type { DatabaseSync } from 'node:sqlite';\nimport { segmentMatch } from '../../text/segment.ts';\nimport { basenameImpl, hasImpl } from '../sql-functions.ts';\n\nexport function registerFunctions(db: DatabaseSync): void {\n  db.function('has', { deterministic: true, varargs: false }, hasImpl);\n\n  db.function('basename', { deterministic: true, varargs: true }, basenameImpl);\n\n  // Raw `content MATCH '<unspaced text>'` cannot be rewritten behind the author's back and matches\n  // nothing, so the same transform is available to hand-written SQL by name.\n  db.function('segment', { deterministic: true, varargs: false }, (terms: unknown): string => {\n    const text = terms === null || terms === undefined ? '' : String(terms);\n    return segmentMatch(text);\n  });\n}\n"],"names":["registerFunctions","db","function","deterministic","varargs","hasImpl","basenameImpl","terms","text","undefined","String","segmentMatch"],"mappings":";;;;+BAIgBA;;;eAAAA;;;yBAHa;8BACS;AAE/B,SAASA,kBAAkBC,EAAgB;IAChDA,GAAGC,QAAQ,CAAC,OAAO;QAAEC,eAAe;QAAMC,SAAS;IAAM,GAAGC,uBAAO;IAEnEJ,GAAGC,QAAQ,CAAC,YAAY;QAAEC,eAAe;QAAMC,SAAS;IAAK,GAAGE,4BAAY;IAE5E,iGAAiG;IACjG,2EAA2E;IAC3EL,GAAGC,QAAQ,CAAC,WAAW;QAAEC,eAAe;QAAMC,SAAS;IAAM,GAAG,SAACG;QAC/D,IAAMC,OAAOD,UAAU,QAAQA,UAAUE,YAAY,KAAKC,OAAOH;QACjE,OAAOI,IAAAA,uBAAY,EAACH;IACtB;AACF"}
+{"version":3,"sources":["/Users/kevin/Dev/open-source/ai/sensemaking/src/store/sqlite/sql-functions.ts"],"sourcesContent":["import type { DatabaseSync } from 'node:sqlite';\nimport { segmentMatch } from '../../text/segment.ts';\nimport { basenameImpl, hasImpl } from '../sql-functions.ts';\n\nexport function registerFunctions(db: DatabaseSync): void {\n  db.function('has', { deterministic: true, varargs: false }, hasImpl);\n\n  db.function('basename', { deterministic: true, varargs: true }, basenameImpl);\n\n  // Raw `content MATCH '<unspaced text>'` cannot be rewritten behind the author's back and matches\n  // nothing, so the same transform is available to hand-written SQL by name.\n  db.function('segment', { deterministic: true, varargs: false }, (terms: unknown): string => {\n    const text = terms === null || terms === undefined ? '' : String(terms);\n    return segmentMatch(text);\n  });\n}\n"],"names":["registerFunctions","db","function","deterministic","varargs","hasImpl","basenameImpl","terms","text","undefined","String","segmentMatch"],"mappings":";;;;+BAIgBA;;;eAAAA;;;yBAHa;8BACS;AAE/B,SAASA,kBAAkBC,EAAgB;IAChDA,GAAGC,QAAQ,CAAC,OAAO;QAAEC,eAAe;QAAMC,SAAS;IAAM,GAAGC,uBAAO;IAEnEJ,GAAGC,QAAQ,CAAC,YAAY;QAAEC,eAAe;QAAMC,SAAS;IAAK,GAAGE,4BAAY;IAE5E,iGAAiG;IACjG,2EAA2E;IAC3EL,GAAGC,QAAQ,CAAC,WAAW;QAAEC,eAAe;QAAMC,SAAS;IAAM,GAAG,SAACG;QAC/D,IAAMC,OAAOD,UAAU,QAAQA,UAAUE,YAAY,KAAKC,OAAOH;QACjE,OAAOI,IAAAA,uBAAY,EAACH;IACtB;AACF"}

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

@@ -1 +1 @@
-{"version":3,"sources":["/Users/kevin/Dev/OpenSource/ai/sensemaking/src/store/sqlite/store.ts"],"sourcesContent":["import type { DatabaseSync } from 'node:sqlite';\nimport { getColumns } from '../shared.ts';\nimport { withTransaction } from '../transaction.ts';\nimport type { Capability, Connection, Statement, Store, VectorStore, VectorWriteRow } from '../types.ts';\nimport { createNativeVectorScopeOwner, hasVectorRow, pendingRows } from '../vectors.ts';\nimport { fieldStats } from './fieldStats.ts';\nimport { queryLexical } from './lexical.ts';\nimport { scanCandidates, scanSimilar, writeVectorBatch } from './vectors.ts';\n\nexport const CAPABILITIES: ReadonlySet<Capability> = new Set(['vectors', 'segment']);\n\n// Wraps the synchronous DatabaseSync connection in the async Store interface, sharing one\n// Connection instance (conn) with the builder's own reconcile call so transaction depth is tracked against the same object everywhere.\nexport function createStore(db: DatabaseSync, conn: Connection): Store {\n  const vectorScope = createNativeVectorScopeOwner();\n  const vectors: VectorStore = {\n    async pending() {\n      return pendingRows(conn);\n    },\n    async writeVectors(rows: VectorWriteRow[]) {\n      await writeVectorBatch(conn, rows);\n    },\n    async candidates(qv, storeDims, fetch, allowed) {\n      return scanCandidates(conn, qv, storeDims, fetch, allowed, vectorScope.activeFor(allowed));\n    },\n    async similar(path, opts) {\n      return scanSimilar(conn, path, opts, vectorScope.activeFor(opts.allowed));\n    },\n    async hasVector(path) {\n      return hasVectorRow(conn, path);\n    },\n  };\n  vectorScope.bind(vectors);\n\n  return {\n    name: 'sqlite',\n    capabilities: CAPABILITIES,\n    async exec(sql: string): Promise<void> {\n      await conn.exec(sql);\n    },\n    async prepare(sql: string): Promise<Statement> {\n      return conn.prepare(sql);\n    },\n    async runBatch(sql: string, paramRows: unknown[][]): Promise<void> {\n      await conn.runBatch(sql, paramRows);\n    },\n    async transaction<T>(fn: () => Promise<T>): Promise<T> {\n      return withTransaction(conn, fn);\n    },\n    docs: {\n      async columns() {\n        return [...(await getColumns(conn))];\n      },\n      async fieldStats(columns, scopeWhere) {\n        return fieldStats(conn, columns, scopeWhere);\n      },\n    },\n    lexical: {\n      async query(terms, opts) {\n        return queryLexical(conn, terms, opts);\n      },\n    },\n    vectors,\n    async engineStatus() {\n      // Read back rather than recomputed: this is what open() actually set (3x the largest\n      // recorded reconcile, floored at 30s, capped at 10min), not a value re-derived here.\n      const row = db.prepare('PRAGMA busy_timeout').get() as { timeout: number };\n      return { busy_timeout: `${row.timeout}ms (derived: 3x the largest reconcile this cache has recorded, floored at 30000ms)` };\n    },\n    raw: {\n      async prepare(sql: string) {\n        const stmt = db.prepare(sql);\n        stmt.setReadBigInts(true); // int64 past 2^53 arrives as BigInt instead of throwing at step time\n        return {\n          columns: () => stmt.columns(),\n          // sense sql streams through an async iterator wrapping the sync iterate().\n          iterate: async function* (...params: unknown[]) {\n            yield* stmt.iterate(...(params as Parameters<typeof stmt.iterate>));\n          },\n        };\n      },\n    },\n    async close() {\n      db.close();\n    },\n  };\n}\n"],"names":["CAPABILITIES","createStore","Set","db","conn","vectorScope","createNativeVectorScopeOwner","vectors","pending","pendingRows","writeVectors","rows","writeVectorBatch","candidates","qv","storeDims","fetch","allowed","scanCandidates","activeFor","similar","path","opts","scanSimilar","hasVector","hasVectorRow","bind","name","capabilities","exec","sql","prepare","runBatch","paramRows","transaction","fn","withTransaction","docs","columns","getColumns","fieldStats","scopeWhere","lexical","query","terms","queryLexical","engineStatus","row","get","busy_timeout","timeout","raw","stmt","setReadBigInts","iterate","params","close"],"mappings":"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"}
+{"version":3,"sources":["/Users/kevin/Dev/open-source/ai/sensemaking/src/store/sqlite/store.ts"],"sourcesContent":["import type { DatabaseSync } from 'node:sqlite';\nimport { getColumns } from '../shared.ts';\nimport { withTransaction } from '../transaction.ts';\nimport type { Capability, Connection, Statement, Store, VectorStore, VectorWriteRow } from '../types.ts';\nimport { createNativeVectorScopeOwner, hasVectorRow, pendingRows } from '../vectors.ts';\nimport { fieldStats } from './fieldStats.ts';\nimport { queryLexical } from './lexical.ts';\nimport { scanCandidates, scanSimilar, writeVectorBatch } from './vectors.ts';\n\nexport const CAPABILITIES: ReadonlySet<Capability> = new Set(['vectors', 'segment']);\n\n// Wraps the synchronous DatabaseSync connection in the async Store interface, sharing one\n// Connection instance (conn) with the builder's own reconcile call so transaction depth is tracked against the same object everywhere.\nexport function createStore(db: DatabaseSync, conn: Connection): Store {\n  const vectorScope = createNativeVectorScopeOwner();\n  const vectors: VectorStore = {\n    async pending() {\n      return pendingRows(conn);\n    },\n    async writeVectors(rows: VectorWriteRow[]) {\n      await writeVectorBatch(conn, rows);\n    },\n    async candidates(qv, storeDims, fetch, allowed) {\n      return scanCandidates(conn, qv, storeDims, fetch, allowed, vectorScope.activeFor(allowed));\n    },\n    async similar(path, opts) {\n      return scanSimilar(conn, path, opts, vectorScope.activeFor(opts.allowed));\n    },\n    async hasVector(path) {\n      return hasVectorRow(conn, path);\n    },\n  };\n  vectorScope.bind(vectors);\n\n  return {\n    name: 'sqlite',\n    capabilities: CAPABILITIES,\n    async exec(sql: string): Promise<void> {\n      await conn.exec(sql);\n    },\n    async prepare(sql: string): Promise<Statement> {\n      return conn.prepare(sql);\n    },\n    async runBatch(sql: string, paramRows: unknown[][]): Promise<void> {\n      await conn.runBatch(sql, paramRows);\n    },\n    async transaction<T>(fn: () => Promise<T>): Promise<T> {\n      return withTransaction(conn, fn);\n    },\n    docs: {\n      async columns() {\n        return [...(await getColumns(conn))];\n      },\n      async fieldStats(columns, scopeWhere) {\n        return fieldStats(conn, columns, scopeWhere);\n      },\n    },\n    lexical: {\n      async query(terms, opts) {\n        return queryLexical(conn, terms, opts);\n      },\n    },\n    vectors,\n    async engineStatus() {\n      // Read back rather than recomputed: this is what open() actually set (3x the largest\n      // recorded reconcile, floored at 30s, capped at 10min), not a value re-derived here.\n      const row = db.prepare('PRAGMA busy_timeout').get() as { timeout: number };\n      return { busy_timeout: `${row.timeout}ms (derived: 3x the largest reconcile this cache has recorded, floored at 30000ms)` };\n    },\n    raw: {\n      async prepare(sql: string) {\n        const stmt = db.prepare(sql);\n        stmt.setReadBigInts(true); // int64 past 2^53 arrives as BigInt instead of throwing at step time\n        return {\n          columns: () => stmt.columns(),\n          // sense sql streams through an async iterator wrapping the sync iterate().\n          iterate: async function* (...params: unknown[]) {\n            yield* stmt.iterate(...(params as Parameters<typeof stmt.iterate>));\n          },\n        };\n      },\n    },\n    async close() {\n      db.close();\n    },\n  };\n}\n"],"names":["CAPABILITIES","createStore","Set","db","conn","vectorScope","createNativeVectorScopeOwner","vectors","pending","pendingRows","writeVectors","rows","writeVectorBatch","candidates","qv","storeDims","fetch","allowed","scanCandidates","activeFor","similar","path","opts","scanSimilar","hasVector","hasVectorRow","bind","name","capabilities","exec","sql","prepare","runBatch","paramRows","transaction","fn","withTransaction","docs","columns","getColumns","fieldStats","scopeWhere","lexical","query","terms","queryLexical","engineStatus","row","get","busy_timeout","timeout","raw","stmt","setReadBigInts","iterate","params","close"],"mappings":"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"}

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

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

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

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

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

@@ -1 +1 @@
-{"version":3,"sources":["/Users/kevin/Dev/OpenSource/ai/sensemaking/src/store/transaction.ts"],"sourcesContent":["// Store-agnostic joining transaction helper: node:sqlite and DuckDB both support only\n// BEGIN/COMMIT/ROLLBACK, no SAVEPOINT -- nesting joins the outer transaction, sharing one semantics through exec(sql).\ninterface ExecConnection {\n  exec(sql: string): Promise<void>;\n}\n\ninterface TxState {\n  depth: number;\n  rollbackOnly: boolean;\n}\n\n// Keyed by connection, not a module singleton: two connections can coexist in one process\n// (e.g. watch.ts alongside a CLI query) and must not share depth.\nconst states = new WeakMap<ExecConnection, TxState>();\n\nfunction stateFor(conn: ExecConnection): TxState {\n  let state = states.get(conn);\n  if (!state) {\n    state = { depth: 0, rollbackOnly: false };\n    states.set(conn, state);\n  }\n  return state;\n}\n\nasync function enter(conn: ExecConnection, state: TxState, begin: string): Promise<void> {\n  if (state.depth === 0) {\n    await conn.exec(begin);\n    state.rollbackOnly = false;\n  }\n  state.depth++;\n}\n\n// Reaching depth 0 still rollback-only means an inner scope failed and an enclosing catch\n// swallowed it; commit here would persist a partial write, so this rolls back and throws instead.\nasync function leaveOk(conn: ExecConnection, state: TxState): Promise<void> {\n  state.depth--;\n  if (state.depth > 0) return;\n  if (state.rollbackOnly) {\n    await conn.exec('ROLLBACK');\n    throw new Error('transaction rolled back: a nested scope failed');\n  }\n  await conn.exec('COMMIT');\n}\n\nasync function leaveErr(conn: ExecConnection, state: TxState): Promise<void> {\n  state.rollbackOnly = true;\n  state.depth--;\n  if (state.depth === 0) await conn.exec('ROLLBACK');\n}\n\n// A writer takes its lock at BEGIN rather than on first write: SQLite will not retry a deferred\n// transaction that read first and then upgrades, so busy_timeout never applies and the second\n// concurrent command fails outright instead of queueing. Reads keep plain BEGIN, or every snapshot\n// read (map, peek) would serialize against writers. DuckDB has no IMMEDIATE and passes nothing.\nexport const BEGIN_WRITE = 'BEGIN IMMEDIATE';\n\n// Depth-0 opens the transaction; a nested call joins it and issues no SQL of its own. The outermost\n// call owns COMMIT/ROLLBACK, so join semantics never differ by call site.\nexport async function withTransaction<T>(conn: ExecConnection, fn: () => Promise<T>, begin = 'BEGIN'): Promise<T> {\n  const state = stateFor(conn);\n  await enter(conn, state, begin);\n  let result: T;\n  try {\n    result = await fn();\n  } catch (err) {\n    await leaveErr(conn, state);\n    throw err;\n  }\n  await leaveOk(conn, state);\n  return result;\n}\n"],"names":["BEGIN_WRITE","withTransaction","states","WeakMap","stateFor","conn","state","get","depth","rollbackOnly","set","enter","begin","exec","leaveOk","Error","leaveErr","fn","result","err"],"mappings":"AAAA,sFAAsF;AACtF,uHAAuH;;;;;;;;;;;;QAqD1GA;eAAAA;;QAISC;eAAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA/CtB,0FAA0F;AAC1F,kEAAkE;AAClE,IAAMC,SAAS,IAAIC;AAEnB,SAASC,SAASC,IAAoB;IACpC,IAAIC,QAAQJ,OAAOK,GAAG,CAACF;IACvB,IAAI,CAACC,OAAO;QACVA,QAAQ;YAAEE,OAAO;YAAGC,cAAc;QAAM;QACxCP,OAAOQ,GAAG,CAACL,MAAMC;IACnB;IACA,OAAOA;AACT;AAEA,SAAeK,MAAMN,IAAoB,EAAEC,KAAc,EAAEM,KAAa;;;;;yBAClEN,CAAAA,MAAME,KAAK,KAAK,CAAA,GAAhBF;;;;oBACF;;wBAAMD,KAAKQ,IAAI,CAACD;;;oBAAhB;oBACAN,MAAMG,YAAY,GAAG;;;oBAEvBH,MAAME,KAAK;;;;;;IACb;;AAEA,0FAA0F;AAC1F,kGAAkG;AAClG,SAAeM,QAAQT,IAAoB,EAAEC,KAAc;;;;;oBACzDA,MAAME,KAAK;oBACX,IAAIF,MAAME,KAAK,GAAG,GAAG;;;yBACjBF,MAAMG,YAAY,EAAlBH;;;;oBACF;;wBAAMD,KAAKQ,IAAI,CAAC;;;oBAAhB;oBACA,MAAM,IAAIE,MAAM;;oBAElB;;wBAAMV,KAAKQ,IAAI,CAAC;;;oBAAhB;;;;;;IACF;;AAEA,SAAeG,SAASX,IAAoB,EAAEC,KAAc;;;;;oBAC1DA,MAAMG,YAAY,GAAG;oBACrBH,MAAME,KAAK;yBACPF,CAAAA,MAAME,KAAK,KAAK,CAAA,GAAhBF;;;;oBAAmB;;wBAAMD,KAAKQ,IAAI,CAAC;;;oBAAhB;;;;;;;;IACzB;;AAMO,IAAMb,cAAc;AAIpB,SAAeC,gBAAmBI,IAAoB,EAAEY,EAAoB;QAAEL,QAAAA,iEAAQ;;YACrFN,OAEFY,QAGKC;;;;oBALHb,QAAQF,SAASC;oBACvB;;wBAAMM,MAAMN,MAAMC,OAAOM;;;oBAAzB;;;;;;;;;oBAGW;;wBAAMK;;;oBAAfC,SAAS;;;;;;oBACFC;oBACP;;wBAAMH,SAASX,MAAMC;;;oBAArB;oBACA,MAAMa;;oBAER;;wBAAML,QAAQT,MAAMC;;;oBAApB;oBACA;;wBAAOY;;;;IACT"}
+{"version":3,"sources":["/Users/kevin/Dev/open-source/ai/sensemaking/src/store/transaction.ts"],"sourcesContent":["// Store-agnostic joining transaction helper: node:sqlite and DuckDB both support only\n// BEGIN/COMMIT/ROLLBACK, no SAVEPOINT -- nesting joins the outer transaction, sharing one semantics through exec(sql).\ninterface ExecConnection {\n  exec(sql: string): Promise<void>;\n}\n\ninterface TxState {\n  depth: number;\n  rollbackOnly: boolean;\n}\n\n// Keyed by connection, not a module singleton: two connections can coexist in one process\n// (e.g. watch.ts alongside a CLI query) and must not share depth.\nconst states = new WeakMap<ExecConnection, TxState>();\n\nfunction stateFor(conn: ExecConnection): TxState {\n  let state = states.get(conn);\n  if (!state) {\n    state = { depth: 0, rollbackOnly: false };\n    states.set(conn, state);\n  }\n  return state;\n}\n\nasync function enter(conn: ExecConnection, state: TxState, begin: string): Promise<void> {\n  if (state.depth === 0) {\n    await conn.exec(begin);\n    state.rollbackOnly = false;\n  }\n  state.depth++;\n}\n\n// Reaching depth 0 still rollback-only means an inner scope failed and an enclosing catch\n// swallowed it; commit here would persist a partial write, so this rolls back and throws instead.\nasync function leaveOk(conn: ExecConnection, state: TxState): Promise<void> {\n  state.depth--;\n  if (state.depth > 0) return;\n  if (state.rollbackOnly) {\n    await conn.exec('ROLLBACK');\n    throw new Error('transaction rolled back: a nested scope failed');\n  }\n  await conn.exec('COMMIT');\n}\n\nasync function leaveErr(conn: ExecConnection, state: TxState): Promise<void> {\n  state.rollbackOnly = true;\n  state.depth--;\n  if (state.depth === 0) await conn.exec('ROLLBACK');\n}\n\n// A writer takes its lock at BEGIN rather than on first write: SQLite will not retry a deferred\n// transaction that read first and then upgrades, so busy_timeout never applies and the second\n// concurrent command fails outright instead of queueing. Reads keep plain BEGIN, or every snapshot\n// read (map, peek) would serialize against writers. DuckDB has no IMMEDIATE and passes nothing.\nexport const BEGIN_WRITE = 'BEGIN IMMEDIATE';\n\n// Depth-0 opens the transaction; a nested call joins it and issues no SQL of its own. The outermost\n// call owns COMMIT/ROLLBACK, so join semantics never differ by call site.\nexport async function withTransaction<T>(conn: ExecConnection, fn: () => Promise<T>, begin = 'BEGIN'): Promise<T> {\n  const state = stateFor(conn);\n  await enter(conn, state, begin);\n  let result: T;\n  try {\n    result = await fn();\n  } catch (err) {\n    await leaveErr(conn, state);\n    throw err;\n  }\n  await leaveOk(conn, state);\n  return result;\n}\n"],"names":["BEGIN_WRITE","withTransaction","states","WeakMap","stateFor","conn","state","get","depth","rollbackOnly","set","enter","begin","exec","leaveOk","Error","leaveErr","fn","result","err"],"mappings":"AAAA,sFAAsF;AACtF,uHAAuH;;;;;;;;;;;;QAqD1GA;eAAAA;;QAISC;eAAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA/CtB,0FAA0F;AAC1F,kEAAkE;AAClE,IAAMC,SAAS,IAAIC;AAEnB,SAASC,SAASC,IAAoB;IACpC,IAAIC,QAAQJ,OAAOK,GAAG,CAACF;IACvB,IAAI,CAACC,OAAO;QACVA,QAAQ;YAAEE,OAAO;YAAGC,cAAc;QAAM;QACxCP,OAAOQ,GAAG,CAACL,MAAMC;IACnB;IACA,OAAOA;AACT;AAEA,SAAeK,MAAMN,IAAoB,EAAEC,KAAc,EAAEM,KAAa;;;;;yBAClEN,CAAAA,MAAME,KAAK,KAAK,CAAA,GAAhBF;;;;oBACF;;wBAAMD,KAAKQ,IAAI,CAACD;;;oBAAhB;oBACAN,MAAMG,YAAY,GAAG;;;oBAEvBH,MAAME,KAAK;;;;;;IACb;;AAEA,0FAA0F;AAC1F,kGAAkG;AAClG,SAAeM,QAAQT,IAAoB,EAAEC,KAAc;;;;;oBACzDA,MAAME,KAAK;oBACX,IAAIF,MAAME,KAAK,GAAG,GAAG;;;yBACjBF,MAAMG,YAAY,EAAlBH;;;;oBACF;;wBAAMD,KAAKQ,IAAI,CAAC;;;oBAAhB;oBACA,MAAM,IAAIE,MAAM;;oBAElB;;wBAAMV,KAAKQ,IAAI,CAAC;;;oBAAhB;;;;;;IACF;;AAEA,SAAeG,SAASX,IAAoB,EAAEC,KAAc;;;;;oBAC1DA,MAAMG,YAAY,GAAG;oBACrBH,MAAME,KAAK;yBACPF,CAAAA,MAAME,KAAK,KAAK,CAAA,GAAhBF;;;;oBAAmB;;wBAAMD,KAAKQ,IAAI,CAAC;;;oBAAhB;;;;;;;;IACzB;;AAMO,IAAMb,cAAc;AAIpB,SAAeC,gBAAmBI,IAAoB,EAAEY,EAAoB;QAAEL,QAAAA,iEAAQ;;YACrFN,OAEFY,QAGKC;;;;oBALHb,QAAQF,SAASC;oBACvB;;wBAAMM,MAAMN,MAAMC,OAAOM;;;oBAAzB;;;;;;;;;oBAGW;;wBAAMK;;;oBAAfC,SAAS;;;;;;oBACFC;oBACP;;wBAAMH,SAASX,MAAMC;;;oBAArB;oBACA,MAAMa;;oBAER;;wBAAML,QAAQT,MAAMC;;;oBAApB;oBACA;;wBAAOY;;;;IACT"}

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

@@ -1 +1 @@
-{"version":3,"sources":["/Users/kevin/Dev/OpenSource/ai/sensemaking/src/store/turso/connection.ts"],"sourcesContent":["import { stat } from 'node:fs/promises';\nimport { setImmediate } from 'node:timers/promises';\nimport type { Database } from '@tursodatabase/database';\nimport { rewriteInsert } from '../batch.ts';\nimport { setMeta } from '../shared.ts';\nimport { BEGIN_WRITE, withTransaction } from '../transaction.ts';\nimport type { Connection, RunResult, Statement } from '../types.ts';\nimport { CONNECT_OPTS, tursoApi } from './native.ts';\nimport { rewriteFunctions } from './sql-functions.ts';\n\n// The client's own Statement class isn't re-exported by name from '@tursodatabase/database',\n// so its type is derived structurally from Database.prepare()'s return type instead.\ntype TursoStatement = Awaited<ReturnType<Database['prepare']>>;\n\n// Bound native multi-row compilation work; this is not Turso's variable-count limit.\nexport const INSERT_BIND_BUDGET = 8192;\n\nasync function closeStatement(stmt: TursoStatement, failed: boolean, failure: unknown): Promise<void> {\n  try {\n    await stmt.close();\n  } catch (cleanup) {\n    if (failed) throw new AggregateError([failure, cleanup], 'Turso statement execution and cleanup failed');\n    throw cleanup;\n  } finally {\n    // Native result cleanup can wait on the event loop even after the statement is finalized.\n    await setImmediate();\n  }\n}\n\n// Native statements are finalized after execution. Reusing the portable statement prepares\n// it again; column metadata remains available after execution without retaining native state.\nclass TursoStatementWrapper implements Statement {\n  private stmt: TursoStatement | null;\n  private readonly metadata: Array<{ name: string }>;\n  private readBigInts = false;\n  private readonly db: Database;\n  private readonly sql: string;\n\n  constructor(db: Database, sql: string, stmt: TursoStatement) {\n    this.db = db;\n    this.sql = sql;\n    this.stmt = stmt;\n    this.metadata = stmt.columns();\n  }\n\n  private async acquire(): Promise<TursoStatement> {\n    const retained = this.stmt;\n    this.stmt = null;\n    const stmt = retained ?? (await this.db.prepare(this.sql));\n    try {\n      stmt.safeIntegers(this.readBigInts);\n    } catch (error) {\n      await closeStatement(stmt, true, error);\n      throw error;\n    }\n    return stmt;\n  }\n\n  private async execute<T>(operation: (stmt: TursoStatement) => Promise<T>): Promise<T> {\n    const stmt = await this.acquire();\n    let failed = false;\n    let failure: unknown;\n    try {\n      return await operation(stmt);\n    } catch (error) {\n      failed = true;\n      failure = error;\n      throw error;\n    } finally {\n      await closeStatement(stmt, failed, failure);\n    }\n  }\n\n  async run(...params: unknown[]): Promise<RunResult> {\n    return this.execute((stmt) => stmt.run(...params));\n  }\n\n  async get(...params: unknown[]): Promise<unknown> {\n    return this.execute((stmt) => stmt.get(...params));\n  }\n\n  async all(...params: unknown[]): Promise<unknown[]> {\n    return this.execute((stmt) => stmt.all(...params));\n  }\n\n  async *iterate(...params: unknown[]): AsyncIterable<unknown> {\n    const stmt = await this.acquire();\n    let failed = false;\n    let failure: unknown;\n    try {\n      yield* stmt.iterate(...params);\n    } catch (error) {\n      failed = true;\n      failure = error;\n      throw error;\n    } finally {\n      await closeStatement(stmt, failed, failure);\n    }\n  }\n\n  columns(): Array<{ name: string }> {\n    return this.metadata;\n  }\n\n  setReadBigInts(enabled: boolean): void {\n    this.readBigInts = enabled;\n  }\n}\n\n// This client leaves the WAL behind for the next opener, where node:sqlite checkpoints on the last\n// close, so a tree reconciled over and over grows one without bound. Best-effort: close must not throw.\nexport async function checkpointWal(db: Database): Promise<void> {\n  try {\n    await db.exec('PRAGMA wal_checkpoint(TRUNCATE)');\n  } catch (err) {\n    console.error(`sense: turso WAL checkpoint failed, the -wal file will keep growing until one succeeds: ${(err as Error).message}`);\n  }\n}\n\n// The main cache file's path, or null when unresolvable. The store holds a Database and\n// Connection, not a path (PLAN 3.52), so the path is read from the database itself.\nexport async function cacheFilePath(conn: Connection): Promise<string | null> {\n  const rows = (await (await conn.prepare('PRAGMA database_list')).all()) as Array<{ name: string; file: string }>;\n  return rows.find((r) => r.name === 'main')?.file || null;\n}\n\nexport async function fileSize(path: string): Promise<number | null> {\n  try {\n    return (await stat(path)).size;\n  } catch {\n    return null;\n  }\n}\n\n// Reclaims turso#8170's FTS space amplification (PLAN 3.41), on a throwaway connection after the\n// store's own has closed: `vacuum` doubles incremental reconcile cost merely by being enabled (3.54).\nexport async function reclaimSpace(path: string): Promise<void> {\n  try {\n    const turso = await tursoApi();\n    const db = await turso.connect(path, { ...CONNECT_OPTS, experimental: [...CONNECT_OPTS.experimental, 'vacuum'] });\n    try {\n      await db.exec('VACUUM');\n      const size = await fileSize(path);\n      // Recorded here, not by the caller: this connection is the only one still open on the file.\n      if (size !== null) await setMeta(createConnection(db), 'compact_size', String(size));\n      await checkpointWal(db);\n    } finally {\n      await db.close();\n    }\n  } catch (err) {\n    console.error(`sense: turso VACUUM failed, the cache will keep the space until one succeeds: ${(err as Error).message}`);\n  }\n}\n\nexport function createConnection(db: Database): Connection {\n  const conn: Connection = {\n    async exec(sql: string): Promise<void> {\n      await db.exec(sql);\n    },\n    async prepare(sql: string): Promise<Statement> {\n      const rewritten = rewriteFunctions(sql);\n      const stmt = await db.prepare(rewritten);\n      try {\n        return new TursoStatementWrapper(db, rewritten, stmt);\n      } catch (error) {\n        await closeStatement(stmt, true, error);\n        throw error;\n      }\n    },\n    // Fold INSERTs into bounded multi-row statements in one transaction. UPDATE/DELETE keep\n    // the per-row loop; each native statement owns its finalization and cleanup turn.\n    async runBatch(sql: string, paramRows: unknown[][]): Promise<void> {\n      if (paramRows.length === 0) return;\n      await withTransaction(\n        conn,\n        async () => {\n          const shape = rewriteInsert(sql, 1);\n          const batchRows = shape ? Math.max(1, Math.floor(INSERT_BIND_BUDGET / shape.width)) : paramRows.length;\n          for (let offset = 0; offset < paramRows.length; offset += batchRows) {\n            const rows = shape ? paramRows.slice(offset, offset + batchRows) : paramRows;\n            const rewritten = shape ? rewriteInsert(sql, rows.length) : null;\n            const stmt = await db.prepare(rewritten?.sql ?? sql);\n            let failed = false;\n            let failure: unknown;\n            try {\n              if (rewritten) {\n                // Pass one array: spreading a wide tuple can exceed the JS argument limit.\n                await stmt.run(rows.flat());\n              } else {\n                for (const row of rows) await stmt.run(row);\n              }\n            } catch (error) {\n              failed = true;\n              failure = error;\n              throw error;\n            } finally {\n              await closeStatement(stmt, failed, failure);\n            }\n          }\n        },\n        BEGIN_WRITE\n      );\n    },\n  };\n  return conn;\n}\n"],"names":["INSERT_BIND_BUDGET","cacheFilePath","checkpointWal","createConnection","fileSize","reclaimSpace","closeStatement","stmt","failed","failure","cleanup","close","AggregateError","setImmediate","TursoStatementWrapper","db","sql","readBigInts","metadata","columns","acquire","retained","error","prepare","safeIntegers","execute","operation","run","params","get","all","iterate","setReadBigInts","enabled","err","exec","console","message","conn","rows","find","r","name","file","path","stat","size","turso","tursoApi","connect","CONNECT_OPTS","experimental","setMeta","String","rewritten","rewriteFunctions","runBatch","paramRows","length","withTransaction","shape","batchRows","offset","row","rewriteInsert","Math","max","floor","width","slice","flat","BEGIN_WRITE"],"mappings":"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"}
+{"version":3,"sources":["/Users/kevin/Dev/open-source/ai/sensemaking/src/store/turso/connection.ts"],"sourcesContent":["import { stat } from 'node:fs/promises';\nimport { setImmediate } from 'node:timers/promises';\nimport type { Database } from '@tursodatabase/database';\nimport { rewriteInsert } from '../batch.ts';\nimport { setMeta } from '../shared.ts';\nimport { BEGIN_WRITE, withTransaction } from '../transaction.ts';\nimport type { Connection, RunResult, Statement } from '../types.ts';\nimport { CONNECT_OPTS, tursoApi } from './native.ts';\nimport { rewriteFunctions } from './sql-functions.ts';\n\n// The client's own Statement class isn't re-exported by name from '@tursodatabase/database',\n// so its type is derived structurally from Database.prepare()'s return type instead.\ntype TursoStatement = Awaited<ReturnType<Database['prepare']>>;\n\n// Bound native multi-row compilation work; this is not Turso's variable-count limit.\nexport const INSERT_BIND_BUDGET = 8192;\n\nasync function closeStatement(stmt: TursoStatement, failed: boolean, failure: unknown): Promise<void> {\n  try {\n    await stmt.close();\n  } catch (cleanup) {\n    if (failed) throw new AggregateError([failure, cleanup], 'Turso statement execution and cleanup failed');\n    throw cleanup;\n  } finally {\n    // Native result cleanup can wait on the event loop even after the statement is finalized.\n    await setImmediate();\n  }\n}\n\n// Native statements are finalized after execution. Reusing the portable statement prepares\n// it again; column metadata remains available after execution without retaining native state.\nclass TursoStatementWrapper implements Statement {\n  private stmt: TursoStatement | null;\n  private readonly metadata: Array<{ name: string }>;\n  private readBigInts = false;\n  private readonly db: Database;\n  private readonly sql: string;\n\n  constructor(db: Database, sql: string, stmt: TursoStatement) {\n    this.db = db;\n    this.sql = sql;\n    this.stmt = stmt;\n    this.metadata = stmt.columns();\n  }\n\n  private async acquire(): Promise<TursoStatement> {\n    const retained = this.stmt;\n    this.stmt = null;\n    const stmt = retained ?? (await this.db.prepare(this.sql));\n    try {\n      stmt.safeIntegers(this.readBigInts);\n    } catch (error) {\n      await closeStatement(stmt, true, error);\n      throw error;\n    }\n    return stmt;\n  }\n\n  private async execute<T>(operation: (stmt: TursoStatement) => Promise<T>): Promise<T> {\n    const stmt = await this.acquire();\n    let failed = false;\n    let failure: unknown;\n    try {\n      return await operation(stmt);\n    } catch (error) {\n      failed = true;\n      failure = error;\n      throw error;\n    } finally {\n      await closeStatement(stmt, failed, failure);\n    }\n  }\n\n  async run(...params: unknown[]): Promise<RunResult> {\n    return this.execute((stmt) => stmt.run(...params));\n  }\n\n  async get(...params: unknown[]): Promise<unknown> {\n    return this.execute((stmt) => stmt.get(...params));\n  }\n\n  async all(...params: unknown[]): Promise<unknown[]> {\n    return this.execute((stmt) => stmt.all(...params));\n  }\n\n  async *iterate(...params: unknown[]): AsyncIterable<unknown> {\n    const stmt = await this.acquire();\n    let failed = false;\n    let failure: unknown;\n    try {\n      yield* stmt.iterate(...params);\n    } catch (error) {\n      failed = true;\n      failure = error;\n      throw error;\n    } finally {\n      await closeStatement(stmt, failed, failure);\n    }\n  }\n\n  columns(): Array<{ name: string }> {\n    return this.metadata;\n  }\n\n  setReadBigInts(enabled: boolean): void {\n    this.readBigInts = enabled;\n  }\n}\n\n// This client leaves the WAL behind for the next opener, where node:sqlite checkpoints on the last\n// close, so a tree reconciled over and over grows one without bound. Best-effort: close must not throw.\nexport async function checkpointWal(db: Database): Promise<void> {\n  try {\n    await db.exec('PRAGMA wal_checkpoint(TRUNCATE)');\n  } catch (err) {\n    console.error(`sense: turso WAL checkpoint failed, the -wal file will keep growing until one succeeds: ${(err as Error).message}`);\n  }\n}\n\n// The main cache file's path, or null when unresolvable. The store holds a Database and\n// Connection, not a path (PLAN 3.52), so the path is read from the database itself.\nexport async function cacheFilePath(conn: Connection): Promise<string | null> {\n  const rows = (await (await conn.prepare('PRAGMA database_list')).all()) as Array<{ name: string; file: string }>;\n  return rows.find((r) => r.name === 'main')?.file || null;\n}\n\nexport async function fileSize(path: string): Promise<number | null> {\n  try {\n    return (await stat(path)).size;\n  } catch {\n    return null;\n  }\n}\n\n// Reclaims turso#8170's FTS space amplification (PLAN 3.41), on a throwaway connection after the\n// store's own has closed: `vacuum` doubles incremental reconcile cost merely by being enabled (3.54).\nexport async function reclaimSpace(path: string): Promise<void> {\n  try {\n    const turso = await tursoApi();\n    const db = await turso.connect(path, { ...CONNECT_OPTS, experimental: [...CONNECT_OPTS.experimental, 'vacuum'] });\n    try {\n      await db.exec('VACUUM');\n      const size = await fileSize(path);\n      // Recorded here, not by the caller: this connection is the only one still open on the file.\n      if (size !== null) await setMeta(createConnection(db), 'compact_size', String(size));\n      await checkpointWal(db);\n    } finally {\n      await db.close();\n    }\n  } catch (err) {\n    console.error(`sense: turso VACUUM failed, the cache will keep the space until one succeeds: ${(err as Error).message}`);\n  }\n}\n\nexport function createConnection(db: Database): Connection {\n  const conn: Connection = {\n    async exec(sql: string): Promise<void> {\n      await db.exec(sql);\n    },\n    async prepare(sql: string): Promise<Statement> {\n      const rewritten = rewriteFunctions(sql);\n      const stmt = await db.prepare(rewritten);\n      try {\n        return new TursoStatementWrapper(db, rewritten, stmt);\n      } catch (error) {\n        await closeStatement(stmt, true, error);\n        throw error;\n      }\n    },\n    // Fold INSERTs into bounded multi-row statements in one transaction. UPDATE/DELETE keep\n    // the per-row loop; each native statement owns its finalization and cleanup turn.\n    async runBatch(sql: string, paramRows: unknown[][]): Promise<void> {\n      if (paramRows.length === 0) return;\n      await withTransaction(\n        conn,\n        async () => {\n          const shape = rewriteInsert(sql, 1);\n          const batchRows = shape ? Math.max(1, Math.floor(INSERT_BIND_BUDGET / shape.width)) : paramRows.length;\n          for (let offset = 0; offset < paramRows.length; offset += batchRows) {\n            const rows = shape ? paramRows.slice(offset, offset + batchRows) : paramRows;\n            const rewritten = shape ? rewriteInsert(sql, rows.length) : null;\n            const stmt = await db.prepare(rewritten?.sql ?? sql);\n            let failed = false;\n            let failure: unknown;\n            try {\n              if (rewritten) {\n                // Pass one array: spreading a wide tuple can exceed the JS argument limit.\n                await stmt.run(rows.flat());\n              } else {\n                for (const row of rows) await stmt.run(row);\n              }\n            } catch (error) {\n              failed = true;\n              failure = error;\n              throw error;\n            } finally {\n              await closeStatement(stmt, failed, failure);\n            }\n          }\n        },\n        BEGIN_WRITE\n      );\n    },\n  };\n  return conn;\n}\n"],"names":["INSERT_BIND_BUDGET","cacheFilePath","checkpointWal","createConnection","fileSize","reclaimSpace","closeStatement","stmt","failed","failure","cleanup","close","AggregateError","setImmediate","TursoStatementWrapper","db","sql","readBigInts","metadata","columns","acquire","retained","error","prepare","safeIntegers","execute","operation","run","params","get","all","iterate","setReadBigInts","enabled","err","exec","console","message","conn","rows","find","r","name","file","path","stat","size","turso","tursoApi","connect","CONNECT_OPTS","experimental","setMeta","String","rewritten","rewriteFunctions","runBatch","paramRows","length","withTransaction","shape","batchRows","offset","row","rewriteInsert","Math","max","floor","width","slice","flat","BEGIN_WRITE"],"mappings":"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"}

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

@@ -0,0 +1,9 @@
+import { type EnginePatch } from '../engine.js';
+export interface TursoFtsBuilders {
+    indexDdl(): readonly string[];
+    score(columns: string, literal: string): string;
+    match(columns: string, literal: string): string;
+}
+export declare const TURSO_FTS_BUILDERS: TursoFtsBuilders;
+export declare const TURSO_PATCHES: readonly EnginePatch<TursoFtsBuilders>[];
+export declare function tursoFts(): Promise<TursoFtsBuilders>;

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

@@ -0,0 +1,9 @@
+import { type EnginePatch } from '../engine.js';
+export interface TursoFtsBuilders {
+    indexDdl(): readonly string[];
+    score(columns: string, literal: string): string;
+    match(columns: string, literal: string): string;
+}
+export declare const TURSO_FTS_BUILDERS: TursoFtsBuilders;
+export declare const TURSO_PATCHES: readonly EnginePatch<TursoFtsBuilders>[];
+export declare function tursoFts(): Promise<TursoFtsBuilders>;