sensemaking 0.18.4 → 0.19.1

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

@@ -1 +1 @@
-{"version":3,"sources":["/Users/kevin/Dev/OpenSource/ai/sensemaking/src/store/sqlite/fieldStats.ts"],"sourcesContent":["import { quoteIdent } from '../shared.ts';\nimport type { Connection, FieldStat } from '../types.ts';\n\n// One aggregate query, one result row: COUNT + GROUP_CONCAT(DISTINCT typeof()) per column, so\n// the query stays O(columns) rather than O(rows x columns). typeof()'s output already is the\n// shared vocabulary (integer/real/text -- mapValue() never binds a boolean or blob), so no\n// mapping step is needed here (contrast duckdb/fieldStats.ts). GROUP_CONCAT(DISTINCT ...)'s\n// order is not guaranteed sorted (spike-verified: 3+ distinct types come back in insertion\n// order), so the type set is sorted in JS.\nexport async function fieldStats(conn: Connection, columns: string[], scopeWhere: string): Promise<FieldStat[]> {\n  const exprs = columns.map((name, i) => {\n    const quoted = quoteIdent(name);\n    return `COUNT(${quoted}) AS n${i}, GROUP_CONCAT(DISTINCT typeof(${quoted})) FILTER (WHERE ${quoted} IS NOT NULL) AS t${i}`;\n  });\n  const stmt = await conn.prepare(`SELECT ${exprs.join(', ')} FROM frontmatter ${scopeWhere}`);\n  const row = (await stmt.get()) as Record<string, number | string | null>;\n  return columns.map((name, i) => ({\n    field: name,\n    coverage: Number(row[`n${i}`] ?? 0),\n    type: [...new Set(((row[`t${i}`] as string) ?? '').split(',').filter(Boolean))].sort().join(','),\n  }));\n}\n"],"names":["fieldStats","conn","columns","scopeWhere","exprs","stmt","row","map","name","i","quoted","quoteIdent","prepare","join","get","field","coverage","Number","type","Set","split","filter","Boolean","sort"],"mappings":";;;;+BASsBA;;;eAAAA;;;wBATK;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AASpB,SAAeA,WAAWC,IAAgB,EAAEC,OAAiB,EAAEC,UAAkB;;YAChFC,OAIAC,MACAC;;;;oBALAF,QAAQF,QAAQK,GAAG,CAAC,SAACC,MAAMC;wBAC/B,IAAMC,SAASC,IAAAA,oBAAU,EAACH;wBAC1B,OAAO,AAAC,SAAuBC,OAAfC,QAAO,UAA2CA,OAAnCD,GAAE,mCAA2DC,OAA1BA,QAAO,qBAA8CD,OAA3BC,QAAO,sBAAsB,OAAFD;oBACzH;oBACa;;wBAAMR,KAAKW,OAAO,CAAC,AAAC,UAA8CT,OAArCC,MAAMS,IAAI,CAAC,OAAM,sBAA+B,OAAXV;;;oBAAzEE,OAAO;oBACA;;wBAAMA,KAAKS,GAAG;;;oBAArBR,MAAO;oBACb;;wBAAOJ,QAAQK,GAAG,CAAC,SAACC,MAAMC;gCAEPH,OACGA;mCAHW;gCAC/BS,OAAOP;gCACPQ,UAAUC,QAAOX,QAAAA,GAAG,CAAC,AAAC,IAAK,OAAFG,GAAI,cAAZH,mBAAAA,QAAgB;gCACjCY,MAAM,AAAC,qBAAG,IAAIC,IAAI,EAAEb,SAAAA,GAAG,CAAC,AAAC,IAAK,OAAFG,GAAI,cAAZH,oBAAAA,SAA2B,IAAIc,KAAK,CAAC,KAAKC,MAAM,CAACC,WAAWC,IAAI,GAAGV,IAAI,CAAC;4BAC9F;;;;;IACF"}
+{"version":3,"sources":["/Users/kevin/Dev/OpenSource/ai/sensemaking/src/store/sqlite/fieldStats.ts"],"sourcesContent":["import { quoteIdent } from '../shared.ts';\nimport type { Connection, FieldStat } from '../types.ts';\n\n// One aggregate query per column (COUNT + GROUP_CONCAT(DISTINCT typeof())), O(columns) not O(rows x columns);\n// typeof()'s output is already the shared vocabulary, and GROUP_CONCAT's order is unsorted, so JS sorts the type set.\nexport async function fieldStats(conn: Connection, columns: string[], scopeWhere: string): Promise<FieldStat[]> {\n  const exprs = columns.map((name, i) => {\n    const quoted = quoteIdent(name);\n    return `COUNT(${quoted}) AS n${i}, GROUP_CONCAT(DISTINCT typeof(${quoted})) FILTER (WHERE ${quoted} IS NOT NULL) AS t${i}`;\n  });\n  const stmt = await conn.prepare(`SELECT ${exprs.join(', ')} FROM frontmatter ${scopeWhere}`);\n  const row = (await stmt.get()) as Record<string, number | string | null>;\n  return columns.map((name, i) => ({\n    field: name,\n    coverage: Number(row[`n${i}`] ?? 0),\n    type: [...new Set(((row[`t${i}`] as string) ?? '').split(',').filter(Boolean))].sort().join(','),\n  }));\n}\n"],"names":["fieldStats","conn","columns","scopeWhere","exprs","stmt","row","map","name","i","quoted","quoteIdent","prepare","join","get","field","coverage","Number","type","Set","split","filter","Boolean","sort"],"mappings":";;;;+BAKsBA;;;eAAAA;;;wBALK;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAKpB,SAAeA,WAAWC,IAAgB,EAAEC,OAAiB,EAAEC,UAAkB;;YAChFC,OAIAC,MACAC;;;;oBALAF,QAAQF,QAAQK,GAAG,CAAC,SAACC,MAAMC;wBAC/B,IAAMC,SAASC,IAAAA,oBAAU,EAACH;wBAC1B,OAAO,AAAC,SAAuBC,OAAfC,QAAO,UAA2CA,OAAnCD,GAAE,mCAA2DC,OAA1BA,QAAO,qBAA8CD,OAA3BC,QAAO,sBAAsB,OAAFD;oBACzH;oBACa;;wBAAMR,KAAKW,OAAO,CAAC,AAAC,UAA8CT,OAArCC,MAAMS,IAAI,CAAC,OAAM,sBAA+B,OAAXV;;;oBAAzEE,OAAO;oBACA;;wBAAMA,KAAKS,GAAG;;;oBAArBR,MAAO;oBACb;;wBAAOJ,QAAQK,GAAG,CAAC,SAACC,MAAMC;gCAEPH,OACGA;mCAHW;gCAC/BS,OAAOP;gCACPQ,UAAUC,QAAOX,QAAAA,GAAG,CAAC,AAAC,IAAK,OAAFG,GAAI,cAAZH,mBAAAA,QAAgB;gCACjCY,MAAM,AAAC,qBAAG,IAAIC,IAAI,EAAEb,SAAAA,GAAG,CAAC,AAAC,IAAK,OAAFG,GAAI,cAAZH,oBAAAA,SAA2B,IAAIc,KAAK,CAAC,KAAKC,MAAM,CAACC,WAAWC,IAAI,GAAGV,IAAI,CAAC;4BAC9F;;;;;IACF"}

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

@@ -135,8 +135,7 @@ function _ts_generator(thisArg, body) {
     }
 }
 // snippet() re-tokenizes each candidate doc, superlinearly: ~10s for one 1MB doc
-// (benchmark/reports/2026-08-23-hub-release-battery.md). Past this bound, hit stays NULL for
-// the caller's JS excerpt fallback.
+// (benchmark/reports/2026-08-23-hub-release-battery.md); past this bound, hit stays NULL for the caller's JS excerpt fallback.
 var SNIPPET_BOUND = 16384;
 var WEIGHTED_BM25 = 'bm25(content, 10.0, 5.0, 1.0, 0, 10.0, 5.0, 1.0)';
 function queryLexical(conn, terms, opts, segmenting) {
@@ -147,9 +146,8 @@ function queryLexical(conn, terms, opts, segmenting) {
                 case 0:
                     whereJoin = opts.whereJoin, whereCond = opts.whereCond, scopeCond = opts.scopeCond, limit = opts.limit;
                     query = segmenting ? (0, _segmentts.segmentMatch)(terms) : terms;
-                    // A run of pure unspaced-script punctuation segments to nothing searchable (segmentField
-                    // drops empty groups the same way): an empty MATCH string is an FTS5 syntax error, not zero
-                    // rows, so this returns the zero rows directly rather than issuing it.
+                    // A run of pure unspaced-script punctuation segments to nothing searchable: an empty MATCH
+                    // string is an FTS5 syntax error, not zero rows, so return zero rows directly rather than issuing it.
                     if (query.trim() === '') return [
                         2,
                         []

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

@@ -1 +1 @@
-{"version":3,"sources":["/Users/kevin/Dev/OpenSource/ai/sensemaking/src/store/sqlite/lexical.ts"],"sourcesContent":["import { segmentMatch } from '../../text/segment.ts';\nimport type { Connection, LexicalHit, LexicalQueryOptions } from '../types.ts';\n\n// snippet() re-tokenizes each candidate doc, superlinearly: ~10s for one 1MB doc\n// (benchmark/reports/2026-08-23-hub-release-battery.md). Past this bound, hit stays NULL for\n// the caller's JS excerpt fallback.\nconst SNIPPET_BOUND = 16_384;\nconst WEIGHTED_BM25 = 'bm25(content, 10.0, 5.0, 1.0, 0, 10.0, 5.0, 1.0)';\n\n// Ranked BM25 word-match query with excerpt, scoped by the caller-built SQL fragments.\n// `segmenting` mirrors the predicate that decided whether the `_seg` sidecars were populated\n// (contentTokenize(cfg) === undefined, see sqlite/store.ts): an unspaced-script run in `terms`\n// becomes a quoted grapheme phrase against those sidecars only when they exist.\nexport async function queryLexical(conn: Connection, terms: string, opts: LexicalQueryOptions, segmenting: boolean): Promise<LexicalHit[]> {\n  const { whereJoin, whereCond, scopeCond, limit } = opts;\n  const query = segmenting ? segmentMatch(terms) : terms;\n  // A run of pure unspaced-script punctuation segments to nothing searchable (segmentField\n  // drops empty groups the same way): an empty MATCH string is an FTS5 syntax error, not zero\n  // rows, so this returns the zero rows directly rather than issuing it.\n  if (query.trim() === '') return [];\n  const sql = `SELECT content.path AS path, CASE WHEN length(content.text) <= ${SNIPPET_BOUND} THEN snippet(content, 2, '«', '»', '…', 10) ELSE NULL END AS hit FROM content ${whereJoin} WHERE content MATCH ? ${whereCond} ${scopeCond} ORDER BY ${WEIGHTED_BM25} LIMIT ${limit}`;\n  const stmt = await conn.prepare(sql);\n  return (await stmt.all(query)) as unknown as LexicalHit[];\n}\n"],"names":["queryLexical","SNIPPET_BOUND","WEIGHTED_BM25","conn","terms","opts","segmenting","whereJoin","whereCond","scopeCond","limit","query","sql","stmt","segmentMatch","trim","prepare","all"],"mappings":";;;;+BAasBA;;;eAAAA;;;yBAbO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAG7B,iFAAiF;AACjF,6FAA6F;AAC7F,oCAAoC;AACpC,IAAMC,gBAAgB;AACtB,IAAMC,gBAAgB;AAMf,SAAeF,aAAaG,IAAgB,EAAEC,KAAa,EAAEC,IAAyB,EAAEC,UAAmB;;YACxGC,WAAWC,WAAWC,WAAWC,OACnCC,OAKAC,KACAC;;;;oBAPEN,YAA2CF,KAA3CE,WAAWC,YAAgCH,KAAhCG,WAAWC,YAAqBJ,KAArBI,WAAWC,QAAUL,KAAVK;oBACnCC,QAAQL,aAAaQ,IAAAA,uBAAY,EAACV,SAASA;oBACjD,yFAAyF;oBACzF,4FAA4F;oBAC5F,uEAAuE;oBACvE,IAAIO,MAAMI,IAAI,OAAO,IAAI;;;;oBACnBH,MAAM,AAAC,kEAAgKL,OAA/FN,eAAc,yFAAoHO,OAAnCD,WAAU,2BAAsCE,OAAbD,WAAU,KAAyBN,OAAtBO,WAAU,cAAmCC,OAAvBR,eAAc,WAAe,OAANQ;oBAC7P;;wBAAMP,KAAKa,OAAO,CAACJ;;;oBAA1BC,OAAO;oBACL;;wBAAMA,KAAKI,GAAG,CAACN;;;oBAAvB;;wBAAQ;;;;IACV"}
+{"version":3,"sources":["/Users/kevin/Dev/OpenSource/ai/sensemaking/src/store/sqlite/lexical.ts"],"sourcesContent":["import { segmentMatch } from '../../text/segment.ts';\nimport type { Connection, LexicalHit, LexicalQueryOptions } from '../types.ts';\n\n// snippet() re-tokenizes each candidate doc, superlinearly: ~10s for one 1MB doc\n// (benchmark/reports/2026-08-23-hub-release-battery.md); past this bound, hit stays NULL for the caller's JS excerpt fallback.\nconst SNIPPET_BOUND = 16_384;\nconst WEIGHTED_BM25 = 'bm25(content, 10.0, 5.0, 1.0, 0, 10.0, 5.0, 1.0)';\n\n// Ranked BM25 word-match query with excerpt, scoped by the caller-built SQL fragments. `segmenting`\n// mirrors the predicate that populated the `_seg` sidecars (contentTokenize(cfg) === undefined): an unspaced-script run in `terms` becomes a quoted grapheme phrase against them only when they exist.\nexport async function queryLexical(conn: Connection, terms: string, opts: LexicalQueryOptions, segmenting: boolean): Promise<LexicalHit[]> {\n  const { whereJoin, whereCond, scopeCond, limit } = opts;\n  const query = segmenting ? segmentMatch(terms) : terms;\n  // A run of pure unspaced-script punctuation segments to nothing searchable: an empty MATCH\n  // string is an FTS5 syntax error, not zero rows, so return zero rows directly rather than issuing it.\n  if (query.trim() === '') return [];\n  const sql = `SELECT content.path AS path, CASE WHEN length(content.text) <= ${SNIPPET_BOUND} THEN snippet(content, 2, '«', '»', '…', 10) ELSE NULL END AS hit FROM content ${whereJoin} WHERE content MATCH ? ${whereCond} ${scopeCond} ORDER BY ${WEIGHTED_BM25} LIMIT ${limit}`;\n  const stmt = await conn.prepare(sql);\n  return (await stmt.all(query)) as unknown as LexicalHit[];\n}\n"],"names":["queryLexical","SNIPPET_BOUND","WEIGHTED_BM25","conn","terms","opts","segmenting","whereJoin","whereCond","scopeCond","limit","query","sql","stmt","segmentMatch","trim","prepare","all"],"mappings":";;;;+BAUsBA;;;eAAAA;;;yBAVO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAG7B,iFAAiF;AACjF,+HAA+H;AAC/H,IAAMC,gBAAgB;AACtB,IAAMC,gBAAgB;AAIf,SAAeF,aAAaG,IAAgB,EAAEC,KAAa,EAAEC,IAAyB,EAAEC,UAAmB;;YACxGC,WAAWC,WAAWC,WAAWC,OACnCC,OAIAC,KACAC;;;;oBANEN,YAA2CF,KAA3CE,WAAWC,YAAgCH,KAAhCG,WAAWC,YAAqBJ,KAArBI,WAAWC,QAAUL,KAAVK;oBACnCC,QAAQL,aAAaQ,IAAAA,uBAAY,EAACV,SAASA;oBACjD,2FAA2F;oBAC3F,sGAAsG;oBACtG,IAAIO,MAAMI,IAAI,OAAO,IAAI;;;;oBACnBH,MAAM,AAAC,kEAAgKL,OAA/FN,eAAc,yFAAoHO,OAAnCD,WAAU,2BAAsCE,OAAbD,WAAU,KAAyBN,OAAtBO,WAAU,cAAmCC,OAAvBR,eAAc,WAAe,OAANQ;oBAC7P;;wBAAMP,KAAKa,OAAO,CAACJ;;;oBAA1BC,OAAO;oBACL;;wBAAMA,KAAKI,GAAG,CAACN;;;oBAAvB;;wBAAQ;;;;IACV"}

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

@@ -11,4 +11,3 @@ export interface OpenResult {
 }
 export declare function openSqlite(cfg: ResolvedConfig): Promise<OpenResult>;
 export declare function docCount(store: Store): Promise<number>;
-export declare function clearCache(cfg: ResolvedConfig): void;

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

@@ -11,4 +11,3 @@ export interface OpenResult {
 }
 export declare function openSqlite(cfg: ResolvedConfig): Promise<OpenResult>;
 export declare function docCount(store: Store): Promise<number>;
-export declare function clearCache(cfg: ResolvedConfig): void;

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

@@ -17,9 +17,6 @@ _export(exports, {
     get SCHEMA_VERSION () {
         return SCHEMA_VERSION;
     },
-    get clearCache () {
-        return clearCache;
-    },
     get docCount () {
         return docCount;
     },
@@ -31,8 +28,10 @@ var _nodefs = require("node:fs");
 var _nodepath = require("node:path");
 var _nodesqlite = require("node:sqlite");
 var _indexts = require("../../config/index.js");
+var _handoffts = require("../../embed/handoff.js");
 var _errorsts = require("../../errors.js");
 var _indexts1 = require("../../features/index.js");
+var _cachets = require("../cache.js");
 var _sharedts = require("../shared.js");
 var _transactionts = require("../transaction.js");
 var _connectionts = require("./connection.js");
@@ -193,16 +192,11 @@ function _unsupported_iterable_to_array(o, minLen) {
 }
 var DB_FILENAME = 'cache.db';
 var SCHEMA_VERSION = '18';
-// Stemming is English-only, but the segmentation underneath it is what decides coverage:
-// unicode61 splits on spaces, so a language written without them (Chinese, Japanese, Thai)
-// indexes a whole run as one token and word search finds nothing. `content.tokenize` is how
-// such a tree picks trigram instead.
+// unicode61 splits on spaces, so a language written without them indexes a whole run as one
+// token and word search finds nothing; `content.tokenize` is how such a tree picks trigram.
 var DEFAULT_TOKENIZE = 'porter unicode61';
-// FTS5 takes its tokenizer as a string literal inside DDL, where nothing can bind, so a
-// configured value has to be concatenated. Probing a throwaway table is what makes that safe
-// and is also the whole validation: anything the linked SQLite accepts passes, anything else
-// fails here with SQLite's own message rather than against the real table. It means no table
-// of which version added which tokenizer has to be maintained.
+// FTS5 takes its tokenizer as a DDL string literal where nothing can bind, so the configured
+// value is concatenated; probing a throwaway table first is both the safety and the validation.
 function resolveTokenize(db, cfg) {
     var configured = (0, _indexts.contentTokenize)(cfg);
     if (configured === undefined) return DEFAULT_TOKENIZE;
@@ -224,11 +218,8 @@ function storedTokenize(db) {
     var m = row.sql.match(/tokenize = '((?:[^']|'')*)'/);
     return m ? m[1] : null;
 }
-// The three `_seg` sidecars are appended after path, never inserted: bm25(content, ...) and
-// snippet(content, 2, ...) are documented against the first three columns and keep working
-// (FTS5 defaults the weights it was not given). Each carries its field's exploded unspaced
-// runs for text that needs it, and an empty string for text that does not. Shared by
-// ensureSchema and the tokenize-only rebuild in connect(), so both create identical DDL.
+// 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, tokenize) {
     return _async_to_generator(function() {
         return _ts_generator(this, function(_state) {
@@ -381,6 +372,20 @@ function ensureSchema(conn, cfg, tokenize) {
         });
     })();
 }
+// Two processes opening the same fresh tree both try to convert it, and the loser gets SQLITE_BUSY
+// with no busy handler behind it. Bounded because a lock held past this is a real problem, not a race.
+function setJournalWal(db) {
+    var deadline = Date.now() + 5000;
+    for(;;){
+        try {
+            db.exec('PRAGMA journal_mode = WAL');
+            return;
+        } catch (err) {
+            if (Date.now() >= deadline || !/database is locked|busy/i.test(err.message)) throw err;
+            Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, 20);
+        }
+    }
+}
 function connect(cfg) {
     return _async_to_generator(function() {
         var stateDir, dbPath, db, closed, _ref, conn, tokenize, version, features, wantFeatures, tokenizeOnlyRebuild, changedKeys, changed, stored, rebuildWarnings, recordedMaxMs, _ref1, parsed, warnings, err;
@@ -393,9 +398,8 @@ function connect(cfg) {
                     });
                     dbPath = (0, _nodepath.join)(stateDir, DB_FILENAME);
                     db = new _nodesqlite.DatabaseSync(dbPath);
-                    // A throw below (tokenizer probe, schema, reconcile's COLUMN_LIMIT) must release this handle,
-                    // or on Windows the leaked WAL db is undeletable and scratch cleanup fails with EPERM/EBUSY.
-                    // closed marks the rebuild branches that close-and-recurse, so the catch never double-closes.
+                    // A throw below must release this handle, or on Windows the leaked WAL db is undeletable and
+                    // scratch cleanup fails with EPERM/EBUSY. `closed` keeps the catch from double-closing.
                     closed = false;
                     _state.label = 1;
                 case 1:
@@ -405,10 +409,12 @@ function connect(cfg) {
                         ,
                         16
                     ]);
-                    db.exec('PRAGMA journal_mode = WAL');
-                    // Covers a concurrent watcher's bulk reconcile (~5s for 500 files at 26k notes). A query
-                    // that outwaits it still fails loudly.
+                    // 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);
                     (0, _sqlfunctionsts.registerFunctions)(db, (0, _indexts.contentTokenize)(cfg) === undefined);
                     conn = (0, _connectionts.createConnection)(db);
                     db.exec('CREATE TABLE IF NOT EXISTS meta (key TEXT PRIMARY KEY, value TEXT)');
@@ -439,7 +445,7 @@ function connect(cfg) {
                         console.error('sense: cache format changed (new sensemaking version); rebuilding the index');
                         closed = true;
                         db.close();
-                        clearCache(cfg);
+                        (0, _cachets.clearCache)(cfg);
                         return [
                             2,
                             connect(cfg)
@@ -451,11 +457,8 @@ function connect(cfg) {
                         5
                     ];
                     console.error('sense: config change (content tokenizer) rebuilds the text index; vectors, links, and sections are kept');
-                    // Drop and recreate as one transaction: a crash before COMMIT rolls back to the table
-                    // that was there before (old tokenizer, still queryable), never to no table at all.
-                    // IF EXISTS also makes a retry after such a crash a no-op instead of a raw SQLite error --
-                    // meta.features is only updated once rebuildContentTable (below) finishes, so a retry
-                    // re-enters this branch and repopulates from scratch either way.
+                    // One transaction, so a crash before COMMIT rolls back to the old tokenizer's table rather
+                    // than to no table. IF EXISTS makes a retry after such a crash a no-op, not a raw error.
                     return [
                         4,
                         (0, _transactionts.withTransaction)(conn, function() {
@@ -481,7 +484,7 @@ function connect(cfg) {
                                     }
                                 });
                             })();
-                        })
+                        }, _transactionts.BEGIN_WRITE)
                     ];
                 case 4:
                     _state.sent();
@@ -513,30 +516,32 @@ function connect(cfg) {
                     console.error("sense: config change (".concat(changed, ") rebuilds the index"));
                     closed = true;
                     db.close();
-                    clearCache(cfg);
+                    (0, _cachets.clearCache)(cfg);
                     return [
                         2,
                         connect(cfg)
                     ];
                 case 8:
-                    // Meta can lie after a crash between table creation and the signature write; the table's
-                    // own DDL cannot. A mismatch here rebuilds no matter what meta says. A tokenize-only rebuild
-                    // already recreated content with this tokenize above, so stored already matches and this
-                    // guard is skipped naturally rather than needing its own case.
+                    // Meta can lie after a crash between table creation and the signature write; the table's own
+                    // DDL cannot, so a mismatch here rebuilds whatever meta says.
                     stored = storedTokenize(db);
                     if (stored !== null && stored !== tokenize) {
                         console.error('sense: cache was built with a different content tokenizer; rebuilding the index');
                         closed = true;
                         db.close();
-                        clearCache(cfg);
+                        (0, _cachets.clearCache)(cfg);
                         return [
                             2,
                             connect(cfg)
                         ];
                     }
+                    // One writer at a time: the feature hooks check a column then add it, so two cold opens racing
+                    // here both see it missing and the second ALTER fails with a duplicate column.
                     return [
                         4,
-                        ensureSchema(conn, cfg, tokenize)
+                        (0, _transactionts.withTransaction)(conn, function() {
+                            return ensureSchema(conn, cfg, tokenize);
+                        }, _transactionts.BEGIN_WRITE)
                     ];
                 case 9:
                     _state.sent();
@@ -599,7 +604,7 @@ function connect(cfg) {
 }
 function openSqlite(cfg) {
     return _async_to_generator(function() {
-        var _ref, db, conn, resolvedCfg, dbPath, parsed, warnings;
+        var _ref, db, conn, resolvedCfg, dbPath, parsed, warnings, store;
         return _ts_generator(this, function(_state) {
             switch(_state.label){
                 case 0:
@@ -609,10 +614,13 @@ function openSqlite(cfg) {
                     ];
                 case 1:
                     _ref = _state.sent(), db = _ref.db, conn = _ref.conn, resolvedCfg = _ref.cfg, dbPath = _ref.dbPath, parsed = _ref.parsed, warnings = _ref.warnings;
+                    store = (0, _storets.createStore)(db, conn, resolvedCfg, resolvedCfg.baseDir);
+                    // reconcile ran before this object existed, so its chunk text is keyed by the connection.
+                    (0, _handoffts.rekeyChunkText)(conn, store);
                     return [
                         2,
                         {
-                            store: (0, _storets.createStore)(db, conn, resolvedCfg, resolvedCfg.baseDir),
+                            store: store,
                             cfg: resolvedCfg,
                             dbPath: dbPath,
                             parsed: parsed,
@@ -648,10 +656,4 @@ function docCount(store) {
         });
     })();
 }
-function clearCache(cfg) {
-    (0, _nodefs.rmSync)((0, _nodepath.join)(cfg.baseDir, _indexts.STATE_DIR), {
-        recursive: true,
-        force: true
-    });
-}
 /* CJS INTEROP */ if (exports.__esModule && exports.default) { try { Object.defineProperty(exports.default, '__esModule', { value: true }); for (var key in exports) { exports.default[key] = exports[key]; } } catch (_) {}; module.exports = exports.default; }

package/dist/cjs/store/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 { mkdirSync, rmSync } from 'node:fs';\nimport { join } from 'node:path';\nimport { DatabaseSync } from 'node:sqlite';\nimport type { Config, ResolvedConfig } from '../../config/index.ts';\nimport { contentTokenize, featureSignature, STATE_DIR } from '../../config/index.ts';\nimport { SenseError } from '../../errors.ts';\nimport { activeFeatures, FEATURES } from '../../features/index.ts';\nimport { getMeta, setMeta } from '../shared.ts';\nimport { withTransaction } from '../transaction.ts';\nimport type { Connection, Store } from '../types.ts';\nimport { createConnection } from './connection.ts';\nimport { changedSignatureKeys, embedIdentityAdopted, rebuildContentTable, reconcile, signatureDiff } 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 = '18';\n\ninterface ConnectResult {\n  db: DatabaseSync;\n  conn: Connection;\n  cfg: ResolvedConfig;\n  dbPath: string;\n  parsed: number;\n  warnings: string[];\n}\n\nexport interface OpenResult {\n  store: Store;\n  cfg: ResolvedConfig;\n  dbPath: string;\n  parsed: number;\n  warnings: string[];\n}\n\n// Stemming is English-only, but the segmentation underneath it is what decides coverage:\n// unicode61 splits on spaces, so a language written without them (Chinese, Japanese, Thai)\n// indexes a whole run as one token and word search finds nothing. `content.tokenize` is how\n// such a tree picks trigram instead.\nconst DEFAULT_TOKENIZE = 'porter unicode61';\n\n// FTS5 takes its tokenizer as a string literal inside DDL, where nothing can bind, so a\n// configured value has to be concatenated. Probing a throwaway table is what makes that safe\n// and is also the whole validation: anything the linked SQLite accepts passes, anything else\n// fails here with SQLite's own message rather than against the real table. It means no table\n// of which version added which tokenizer has to be maintained.\nfunction resolveTokenize(db: DatabaseSync, cfg: Config): string {\n  const configured = contentTokenize(cfg);\n  if (configured === undefined) return DEFAULT_TOKENIZE;\n  const literal = configured.replace(/'/g, \"''\");\n  try {\n    db.exec('DROP TABLE IF EXISTS temp.sense_tokenize_probe');\n    db.exec(`CREATE VIRTUAL TABLE temp.sense_tokenize_probe USING fts5(x, tokenize = '${literal}')`);\n    db.exec('DROP TABLE IF EXISTS temp.sense_tokenize_probe');\n  } catch (err) {\n    throw new SenseError('CONFIG_INVALID', `content.tokenize \"${configured}\" is not a tokenizer this SQLite accepts (${(err as Error).message}); the built-in choices are unicode61, ascii, porter, and trigram, each with their own options`);\n  }\n  return literal;\n}\n\n// The tokenizer the content table was actually built with, from its own DDL -- the one\n// record that cannot desynchronize from the table. NULL when the table does not exist yet.\nfunction storedTokenize(db: DatabaseSync): string | null {\n  const row = db.prepare(`SELECT sql FROM sqlite_master WHERE name = 'content'`).get() as { sql: string } | undefined;\n  if (!row) return null;\n  const m = row.sql.match(/tokenize = '((?:[^']|'')*)'/);\n  return m ? m[1] : null;\n}\n\n// The three `_seg` sidecars are appended after path, never inserted: bm25(content, ...) and\n// snippet(content, 2, ...) are documented against the first three columns and keep working\n// (FTS5 defaults the weights it was not given). Each carries its field's exploded unspaced\n// runs for text that needs it, and an empty string for text that does not. Shared by\n// ensureSchema and the tokenize-only rebuild in connect(), so both create identical DDL.\nasync function createContentTable(conn: Connection, tokenize: string): 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 ensureSchema(conn: Connection, cfg: Config, tokenize: string): 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  // IF NOT EXISTS is safe against a tokenizer change: open() compares the table's own DDL\n  // against the resolved tokenizer before this runs, so a stale table is already gone by now.\n  await createContentTable(conn, tokenize);\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\nasync function connect(cfg: ResolvedConfig): Promise<ConnectResult> {\n  const stateDir = join(cfg.baseDir, STATE_DIR);\n  mkdirSync(stateDir, { recursive: true });\n  const dbPath = join(stateDir, DB_FILENAME);\n\n  const db = new DatabaseSync(dbPath);\n  // A throw below (tokenizer probe, schema, reconcile's COLUMN_LIMIT) must release this handle,\n  // or on Windows the leaked WAL db is undeletable and scratch cleanup fails with EPERM/EBUSY.\n  // closed marks the rebuild branches that close-and-recurse, so the catch never double-closes.\n  let closed = false;\n  try {\n    db.exec('PRAGMA journal_mode = WAL');\n    // Covers a concurrent watcher's bulk reconcile (~5s for 500 files at 26k notes). A query\n    // that outwaits it still fails loudly.\n    db.exec('PRAGMA busy_timeout = 30000');\n    registerFunctions(db, contentTokenize(cfg) === undefined);\n    const conn = createConnection(db);\n\n    db.exec('CREATE TABLE IF NOT EXISTS meta (key TEXT PRIMARY KEY, value TEXT)');\n\n    // Before the rebuild branch below, never after: that branch deletes the cache, so a typo'd\n    // tokenizer validated later would cost a full re-index (and re-embed) to reach its own error.\n    const tokenize = resolveTokenize(db, cfg);\n\n    // Schema-version or feature-set mismatch: reconcile only reparses changed files, so an\n    // old cache can't be patched incrementally -- rebuild instead (cheap: nothing expensive lives here).\n    const version = await getMeta(conn, 'schema_version');\n    const features = await getMeta(conn, 'features');\n    const wantFeatures = featureSignature(cfg, FEATURES);\n    let tokenizeOnlyRebuild = false;\n    if ((version !== null && version !== SCHEMA_VERSION) || (features !== null && features !== wantFeatures)) {\n      // Indexing derives from presets, so a config edit rebuilding the cache must say so and\n      // name what changed -- silent rebuilds make derived indexing look like a hang or a bug.\n      if (version !== null && version !== SCHEMA_VERSION) {\n        console.error('sense: cache format changed (new sensemaking version); rebuilding the index');\n        closed = true;\n        db.close();\n        clearCache(cfg);\n        return connect(cfg);\n      }\n      const changedKeys = changedSignatureKeys(features ?? '', wantFeatures);\n      // Only the tokenizer moved: frontmatter, links, sections, and embeddings are file-derived\n      // and tokenizer-independent, so they don't need re-deriving. Everything else -- a preset\n      // edit, an embed model change -- still takes the full clear/reopen below.\n      if (changedKeys.size === 1 && changedKeys.has('tokenize')) {\n        console.error('sense: config change (content tokenizer) rebuilds the text index; vectors, links, and sections are kept');\n        // Drop and recreate as one transaction: a crash before COMMIT rolls back to the table\n        // that was there before (old tokenizer, still queryable), never to no table at all.\n        // IF EXISTS also makes a retry after such a crash a no-op instead of a raw SQLite error --\n        // meta.features is only updated once rebuildContentTable (below) finishes, so a retry\n        // re-enters this branch and repopulates from scratch either way.\n        await withTransaction(conn, async () => {\n          await conn.exec('DROP TABLE IF EXISTS content');\n          await createContentTable(conn, tokenize);\n        });\n        tokenizeOnlyRebuild = true;\n      } else if (changedKeys.size === 1 && changedKeys.has('embed') && embedIdentityAdopted(features ?? '', wantFeatures)) {\n        // First sight of a resolved weight identity: the model itself hasn't changed, so\n        // adopt it into meta with no rebuild and no re-embed, mirroring the tokenize precedent.\n        console.error(\"sense: recorded the embedding model's resolved identity; vectors are unaffected\");\n        await setMeta(conn, 'features', wantFeatures);\n      } else {\n        const changed = signatureDiff(features ?? '', wantFeatures);\n        console.error(`sense: config change (${changed}) rebuilds the index`);\n        closed = true;\n        db.close();\n        clearCache(cfg);\n        return connect(cfg);\n      }\n    }\n\n    // Meta can lie after a crash between table creation and the signature write; the table's\n    // own DDL cannot. A mismatch here rebuilds no matter what meta says. A tokenize-only rebuild\n    // already recreated content with this tokenize above, so stored already matches and this\n    // guard is skipped naturally rather than needing its own case.\n    const stored = storedTokenize(db);\n    if (stored !== null && stored !== tokenize) {\n      console.error('sense: cache was built with a different content tokenizer; rebuilding the index');\n      closed = true;\n      db.close();\n      clearCache(cfg);\n      return connect(cfg);\n    }\n\n    await ensureSchema(conn, cfg, tokenize);\n\n    let rebuildWarnings: string[] = [];\n    if (tokenizeOnlyRebuild) {\n      rebuildWarnings = await rebuildContentTable(conn, cfg, cfg.baseDir);\n      await setMeta(conn, 'features', wantFeatures);\n    }\n\n    // 3x the largest reconcile this cache has recorded, floored at 30s and capped at 10min.\n    // Installed before reconcile() -- that call is the one that races a watcher's transaction.\n    const recordedMaxMs = Number((await getMeta(conn, 'reconcile_max_ms')) ?? '0');\n    db.exec(`PRAGMA busy_timeout = ${Math.min(Math.max(30000, 3 * recordedMaxMs), 600_000)}`);\n\n    const { parsed, warnings } = await reconcile(conn, cfg, cfg.baseDir);\n\n    return { db, conn, cfg, dbPath, parsed, warnings: [...rebuildWarnings, ...warnings] };\n  } catch (err) {\n    if (!closed) db.close();\n    throw err;\n  }\n}\n\n// The sqlite store's open: connects synchronously (see connect() above), then wraps the\n// resulting connection in the async Store interface.\nexport async function openSqlite(cfg: ResolvedConfig): Promise<OpenResult> {\n  const { db, conn, cfg: resolvedCfg, dbPath, parsed, warnings } = await connect(cfg);\n  return { store: createStore(db, conn, resolvedCfg, resolvedCfg.baseDir), cfg: resolvedCfg, dbPath, parsed, warnings };\n}\n\nexport async function docCount(store: Store): Promise<number> {\n  const stmt = await store.prepare('SELECT COUNT(*) AS n FROM frontmatter');\n  return ((await stmt.get()) as { n: number }).n;\n}\n\n// Deletes the cache directory, and only that. The rebuild is not this function's job: the next\n// open() reconciles, which is what running any command already does, so a verb that bundled the\n// two described the half that was not its own. Manual reset for a doubted cache; the schema and\n// config-signature mismatches below reset themselves.\nexport function clearCache(cfg: ResolvedConfig): void {\n  rmSync(join(cfg.baseDir, STATE_DIR), { recursive: true, force: true });\n}\n"],"names":["DB_FILENAME","SCHEMA_VERSION","clearCache","docCount","openSqlite","DEFAULT_TOKENIZE","resolveTokenize","db","cfg","configured","contentTokenize","undefined","literal","replace","exec","err","SenseError","message","storedTokenize","row","prepare","get","m","sql","match","createContentTable","conn","tokenize","ensureSchema","feature","activeFeatures","schema","getMeta","setMeta","featureSignature","FEATURES","connect","stateDir","dbPath","closed","version","features","wantFeatures","tokenizeOnlyRebuild","changedKeys","changed","stored","rebuildWarnings","recordedMaxMs","parsed","warnings","join","baseDir","STATE_DIR","mkdirSync","recursive","DatabaseSync","registerFunctions","createConnection","console","error","close","changedSignatureKeys","size","has","withTransaction","embedIdentityAdopted","signatureDiff","rebuildContentTable","Number","Math","min","max","reconcile","resolvedCfg","store","createStore","stmt","n","rmSync","force"],"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 { mkdirSync } from 'node:fs';\nimport { join } from 'node:path';\nimport { DatabaseSync } from 'node:sqlite';\nimport type { Config, ResolvedConfig } from '../../config/index.ts';\nimport { contentTokenize, featureSignature, STATE_DIR } from '../../config/index.ts';\nimport { rekeyChunkText } from '../../embed/handoff.ts';\nimport { SenseError } from '../../errors.ts';\nimport { activeFeatures, FEATURES } from '../../features/index.ts';\nimport { clearCache } from '../cache.ts';\nimport { getMeta, setMeta } from '../shared.ts';\nimport { BEGIN_WRITE, withTransaction } from '../transaction.ts';\nimport type { Connection, Store } from '../types.ts';\nimport { createConnection } from './connection.ts';\nimport { changedSignatureKeys, embedIdentityAdopted, rebuildContentTable, reconcile, signatureDiff } 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 = '18';\n\ninterface ConnectResult {\n  db: DatabaseSync;\n  conn: Connection;\n  cfg: ResolvedConfig;\n  dbPath: string;\n  parsed: number;\n  warnings: string[];\n}\n\nexport interface OpenResult {\n  store: Store;\n  cfg: ResolvedConfig;\n  dbPath: string;\n  parsed: number;\n  warnings: string[];\n}\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; `content.tokenize` is how such a tree picks trigram.\nconst DEFAULT_TOKENIZE = 'porter unicode61';\n\n// FTS5 takes its tokenizer as a DDL string literal where nothing can bind, so the configured\n// value is concatenated; probing a throwaway table first is both the safety and the validation.\nfunction resolveTokenize(db: DatabaseSync, cfg: Config): string {\n  const configured = contentTokenize(cfg);\n  if (configured === undefined) return DEFAULT_TOKENIZE;\n  const literal = configured.replace(/'/g, \"''\");\n  try {\n    db.exec('DROP TABLE IF EXISTS temp.sense_tokenize_probe');\n    db.exec(`CREATE VIRTUAL TABLE temp.sense_tokenize_probe USING fts5(x, tokenize = '${literal}')`);\n    db.exec('DROP TABLE IF EXISTS temp.sense_tokenize_probe');\n  } catch (err) {\n    throw new SenseError('CONFIG_INVALID', `content.tokenize \"${configured}\" is not a tokenizer this SQLite accepts (${(err as Error).message}); the built-in choices are unicode61, ascii, porter, and trigram, each with their own options`);\n  }\n  return literal;\n}\n\n// The tokenizer the content table was actually built with, from its own DDL -- the one\n// record that cannot desynchronize from the table. NULL when the table does not exist yet.\nfunction storedTokenize(db: DatabaseSync): string | null {\n  const row = db.prepare(`SELECT sql FROM sqlite_master WHERE name = 'content'`).get() as { sql: string } | undefined;\n  if (!row) return null;\n  const m = row.sql.match(/tokenize = '((?:[^']|'')*)'/);\n  return m ? m[1] : null;\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, tokenize: string): 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 ensureSchema(conn: Connection, cfg: Config, tokenize: string): 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  // IF NOT EXISTS is safe against a tokenizer change: open() compares the table's own DDL\n  // against the resolved tokenizer before this runs, so a stale table is already gone by now.\n  await createContentTable(conn, tokenize);\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(cfg: ResolvedConfig): Promise<ConnectResult> {\n  const stateDir = join(cfg.baseDir, STATE_DIR);\n  mkdirSync(stateDir, { recursive: true });\n  const dbPath = join(stateDir, DB_FILENAME);\n\n  const db = new DatabaseSync(dbPath);\n  // A throw below must release this handle, or on Windows the leaked WAL db is undeletable and\n  // scratch cleanup fails with EPERM/EBUSY. `closed` keeps the catch from double-closing.\n  let closed = false;\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, contentTokenize(cfg) === undefined);\n    const conn = createConnection(db);\n\n    db.exec('CREATE TABLE IF NOT EXISTS meta (key TEXT PRIMARY KEY, value TEXT)');\n\n    // Before the rebuild branch below, never after: that branch deletes the cache, so a typo'd\n    // tokenizer validated later would cost a full re-index (and re-embed) to reach its own error.\n    const tokenize = resolveTokenize(db, cfg);\n\n    // Schema-version or feature-set mismatch: reconcile only reparses changed files, so an\n    // old cache can't be patched incrementally -- rebuild instead (cheap: nothing expensive lives here).\n    const version = await getMeta(conn, 'schema_version');\n    const features = await getMeta(conn, 'features');\n    const wantFeatures = featureSignature(cfg, FEATURES);\n    let tokenizeOnlyRebuild = false;\n    if ((version !== null && version !== SCHEMA_VERSION) || (features !== null && features !== wantFeatures)) {\n      // Indexing derives from presets, so a config edit rebuilding the cache must say so and\n      // name what changed -- silent rebuilds make derived indexing look like a hang or a bug.\n      if (version !== null && version !== SCHEMA_VERSION) {\n        console.error('sense: cache format changed (new sensemaking version); rebuilding the index');\n        closed = true;\n        db.close();\n        clearCache(cfg);\n        return connect(cfg);\n      }\n      const changedKeys = changedSignatureKeys(features ?? '', wantFeatures);\n      // Only the tokenizer moved, and frontmatter, links, sections and embeddings are file-derived\n      // and tokenizer-independent. Any other signature change takes the full clear/reopen below.\n      if (changedKeys.size === 1 && changedKeys.has('tokenize')) {\n        console.error('sense: config change (content tokenizer) rebuilds the text index; vectors, links, and sections are kept');\n        // One transaction, so a crash before COMMIT rolls back to the old tokenizer's table rather\n        // than to no table. IF EXISTS makes a retry after such a crash a no-op, not a raw error.\n        await withTransaction(\n          conn,\n          async () => {\n            await conn.exec('DROP TABLE IF EXISTS content');\n            await createContentTable(conn, tokenize);\n          },\n          BEGIN_WRITE\n        );\n        tokenizeOnlyRebuild = true;\n      } else if (changedKeys.size === 1 && changedKeys.has('embed') && embedIdentityAdopted(features ?? '', wantFeatures)) {\n        // First sight of a resolved weight identity: the model itself hasn't changed, so\n        // adopt it into meta with no rebuild and no re-embed, mirroring the tokenize precedent.\n        console.error(\"sense: recorded the embedding model's resolved identity; vectors are unaffected\");\n        await setMeta(conn, 'features', wantFeatures);\n      } else {\n        const changed = signatureDiff(features ?? '', wantFeatures);\n        console.error(`sense: config change (${changed}) rebuilds the index`);\n        closed = true;\n        db.close();\n        clearCache(cfg);\n        return connect(cfg);\n      }\n    }\n\n    // Meta can lie after a crash between table creation and the signature write; the table's own\n    // DDL cannot, so a mismatch here rebuilds whatever meta says.\n    const stored = storedTokenize(db);\n    if (stored !== null && stored !== tokenize) {\n      console.error('sense: cache was built with a different content tokenizer; rebuilding the index');\n      closed = true;\n      db.close();\n      clearCache(cfg);\n      return connect(cfg);\n    }\n\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, () => ensureSchema(conn, cfg, tokenize), BEGIN_WRITE);\n\n    let rebuildWarnings: string[] = [];\n    if (tokenizeOnlyRebuild) {\n      rebuildWarnings = await rebuildContentTable(conn, cfg, cfg.baseDir);\n      await setMeta(conn, 'features', wantFeatures);\n    }\n\n    // 3x the largest reconcile this cache has recorded, floored at 30s and capped at 10min.\n    // Installed before reconcile() -- that call is the one that races a watcher's transaction.\n    const recordedMaxMs = Number((await getMeta(conn, 'reconcile_max_ms')) ?? '0');\n    db.exec(`PRAGMA busy_timeout = ${Math.min(Math.max(30000, 3 * recordedMaxMs), 600_000)}`);\n\n    const { parsed, warnings } = await reconcile(conn, cfg, cfg.baseDir);\n\n    return { db, conn, cfg, dbPath, parsed, warnings: [...rebuildWarnings, ...warnings] };\n  } catch (err) {\n    if (!closed) db.close();\n    throw err;\n  }\n}\n\n// The sqlite store's open: connects synchronously (see connect() above), then wraps the\n// resulting connection in the async Store interface.\nexport async function openSqlite(cfg: ResolvedConfig): Promise<OpenResult> {\n  const { db, conn, cfg: resolvedCfg, dbPath, parsed, warnings } = await connect(cfg);\n  const store = createStore(db, conn, resolvedCfg, resolvedCfg.baseDir);\n  // reconcile ran before this object existed, so its chunk text is keyed by the connection.\n  rekeyChunkText(conn, store);\n  return { store: store, cfg: resolvedCfg, dbPath, parsed, warnings };\n}\n\nexport async function docCount(store: Store): Promise<number> {\n  const stmt = await store.prepare('SELECT COUNT(*) AS n FROM frontmatter');\n  return ((await stmt.get()) as { n: number }).n;\n}\n"],"names":["DB_FILENAME","SCHEMA_VERSION","docCount","openSqlite","DEFAULT_TOKENIZE","resolveTokenize","db","cfg","configured","contentTokenize","undefined","literal","replace","exec","err","SenseError","message","storedTokenize","row","prepare","get","m","sql","match","createContentTable","conn","tokenize","ensureSchema","feature","activeFeatures","schema","getMeta","setMeta","featureSignature","FEATURES","setJournalWal","deadline","Date","now","test","Atomics","wait","Int32Array","SharedArrayBuffer","connect","stateDir","dbPath","closed","version","features","wantFeatures","tokenizeOnlyRebuild","changedKeys","changed","stored","rebuildWarnings","recordedMaxMs","parsed","warnings","join","baseDir","STATE_DIR","mkdirSync","recursive","DatabaseSync","registerFunctions","createConnection","console","error","close","clearCache","changedSignatureKeys","size","has","withTransaction","BEGIN_WRITE","embedIdentityAdopted","signatureDiff","rebuildContentTable","Number","Math","min","max","reconcile","resolvedCfg","store","createStore","rekeyChunkText","stmt","n"],"mappings":"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"}