sensemaking 0.7.2 → 0.9.0

package/dist/cjs/db.js

@@ -38,22 +38,57 @@ var _nodefs = require("node:fs");
 var _nodepath = require("node:path");
 var _nodesqlite = require("node:sqlite");
 var _configts = require("./config.js");
+var _errorsts = require("./errors.js");
 var _indexts = require("./features/index.js");
+var _progressts = require("./progress.js");
 var _scants = require("./scan.js");
 function _array_like_to_array(arr, len) {
     if (len == null || len > arr.length) len = arr.length;
     for(var i = 0, arr2 = new Array(len); i < len; i++)arr2[i] = arr[i];
     return arr2;
 }
+function _array_with_holes(arr) {
+    if (Array.isArray(arr)) return arr;
+}
 function _array_without_holes(arr) {
     if (Array.isArray(arr)) return _array_like_to_array(arr);
 }
 function _iterable_to_array(iter) {
     if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter);
 }
+function _iterable_to_array_limit(arr, i) {
+    var _i = arr == null ? null : typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"];
+    if (_i == null) return;
+    var _arr = [];
+    var _n = true;
+    var _d = false;
+    var _s, _e;
+    try {
+        for(_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true){
+            _arr.push(_s.value);
+            if (i && _arr.length === i) break;
+        }
+    } catch (err) {
+        _d = true;
+        _e = err;
+    } finally{
+        try {
+            if (!_n && _i["return"] != null) _i["return"]();
+        } finally{
+            if (_d) throw _e;
+        }
+    }
+    return _arr;
+}
+function _non_iterable_rest() {
+    throw new TypeError("Invalid attempt to destructure non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
 function _non_iterable_spread() {
     throw new TypeError("Invalid attempt to spread non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
 }
+function _sliced_to_array(arr, i) {
+    return _array_with_holes(arr) || _iterable_to_array_limit(arr, i) || _unsupported_iterable_to_array(arr, i) || _non_iterable_rest();
+}
 function _to_consumable_array(arr) {
     return _array_without_holes(arr) || _iterable_to_array(arr) || _unsupported_iterable_to_array(arr) || _non_iterable_spread();
 }
@@ -65,8 +100,20 @@ function _unsupported_iterable_to_array(o, minLen) {
     if (n === "Map" || n === "Set") return Array.from(n);
     if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _array_like_to_array(o, minLen);
 }
+// path/_mtime/_size are core: every reparse legitimately rewrites them. Every other
+// RESERVED_COLUMNS entry that shows up as a real frontmatter column (currently only
+// rank's `_rank`) is feature-owned -- scan.ts already refuses to let frontmatter set it,
+// so it must never appear in the upsert below, or a reparse would blow its last computed
+// value away with NULL on every touch, not just the reconciles that recompute it.
+var CORE_FRONTMATTER_COLUMNS = new Set([
+    'path',
+    '_mtime',
+    '_size'
+]);
 var DB_FILENAME = 'cache.db';
-var SCHEMA_VERSION = '4'; // 4: frontmatter scalars store as INTEGER/REAL/TEXT by YAML type (was: all numbers REAL)
+var SCHEMA_VERSION = '8';
+// SQLite's compile-time SQLITE_MAX_COLUMN, default 2000 (https://www.sqlite.org/limits.html).
+var MAX_FRONTMATTER_COLUMNS = 2000;
 function quoteIdent(name) {
     return '"'.concat(name.split('"').join('""'), '"');
 }
@@ -105,6 +152,14 @@ function getColumns(db) {
 function ensureSchema(db, cfg) {
     db.exec('CREATE TABLE IF NOT EXISTS frontmatter ("path" TEXT PRIMARY KEY, "_mtime" REAL, "_size" INTEGER)');
     db.exec("CREATE VIRTUAL TABLE IF NOT EXISTS content USING fts5(title, summary, text, path UNINDEXED, tokenize = 'porter unicode61')");
+    // Coverage, not ownership: a path can appear under several presets. Rebuilt per-file
+    // alongside frontmatter/content at reconcile so status/map can report matched/embedded
+    // counts per preset without recomputing globs at read time.
+    // path leads the PK so the per-doc delete in reconcile is an index hit -- keyed the other
+    // way it scans the whole table per doc, which made cold builds quadratic (measured 3x cost
+    // per note-count doubling at 13k/26k). Coverage-by-preset reads get their own index.
+    db.exec('CREATE TABLE IF NOT EXISTS preset_files ("path" TEXT, preset TEXT, PRIMARY KEY ("path", preset))');
+    db.exec('CREATE INDEX IF NOT EXISTS preset_files_preset ON preset_files(preset)');
     var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
     try {
         for(var _iterator = (0, _indexts.activeFeatures)(cfg)[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
@@ -173,16 +228,26 @@ function reconcile(db, cfg, baseDir) {
     var newColumns = [];
     var parsedDocs = [];
     var warnings = [];
+    // Bulk reparses (a sync, a cold build) are the long silences a query can hit; short
+    // reconciles stay silent (progress() has a threshold).
+    var report = (0, _progressts.progress)('reparsing files', toReparse.length);
+    var parsedCount = 0;
     var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
     try {
-        for(var _iterator = toReparse[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+        var _loop = function() {
             var file = _step.value;
             var _warnings;
-            var _parseFile = (0, _scants.parseFile)(file, features), doc = _parseFile.doc, fileWarnings = _parseFile.warnings;
+            // A doc only gets extract/store from features that apply to it (currently: embed, via
+            // FileStat.embed -- true iff a covering preset has semantic on).
+            var fileFeatures = features.filter(function(feature) {
+                return !feature.enabledForFile || feature.enabledForFile(cfg, file);
+            });
+            var _parseFile = (0, _scants.parseFile)(file, fileFeatures), doc = _parseFile.doc, fileWarnings = _parseFile.warnings;
+            report.tick(++parsedCount);
             (_warnings = warnings).push.apply(_warnings, _to_consumable_array(fileWarnings));
-            var _iteratorNormalCompletion1 = true, _didIteratorError1 = false, _iteratorError1 = undefined;
+            var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
             try {
-                for(var _iterator1 = Object.keys(doc.data)[Symbol.iterator](), _step1; !(_iteratorNormalCompletion1 = (_step1 = _iterator1.next()).done); _iteratorNormalCompletion1 = true){
+                for(var _iterator = Object.keys(doc.data)[Symbol.iterator](), _step1; !(_iteratorNormalCompletion = (_step1 = _iterator.next()).done); _iteratorNormalCompletion = true){
                     var key = _step1.value;
                     if (!seenColumns.has(key)) {
                         seenColumns.add(key);
@@ -190,21 +255,22 @@ function reconcile(db, cfg, baseDir) {
                     }
                 }
             } catch (err) {
-                _didIteratorError1 = true;
-                _iteratorError1 = err;
+                _didIteratorError = true;
+                _iteratorError = err;
             } finally{
                 try {
-                    if (!_iteratorNormalCompletion1 && _iterator1.return != null) {
-                        _iterator1.return();
+                    if (!_iteratorNormalCompletion && _iterator.return != null) {
+                        _iterator.return();
                     }
                 } finally{
-                    if (_didIteratorError1) {
-                        throw _iteratorError1;
+                    if (_didIteratorError) {
+                        throw _iteratorError;
                     }
                 }
             }
             parsedDocs.push(doc);
-        }
+        };
+        for(var _iterator = toReparse[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true)_loop();
     } catch (err) {
         _didIteratorError = true;
         _iteratorError = err;
@@ -219,90 +285,129 @@ function reconcile(db, cfg, baseDir) {
             }
         }
     }
+    report.finish();
     var allColumns = _to_consumable_array(seenColumns);
-    var insertSql = "INSERT OR REPLACE INTO frontmatter (".concat(allColumns.map(quoteIdent).join(', '), ") VALUES (").concat(allColumns.map(function() {
+    // Fence before ALTERing: SQLite's own failure past this point is a raw
+    // "too many columns on sqlite_altertab_frontmatter" with no indication of the boundary or the levers.
+    if (allColumns.length > MAX_FRONTMATTER_COLUMNS) {
+        throw new _errorsts.SenseError('COLUMN_LIMIT', "frontmatter would need ".concat(allColumns.length, " columns, crossing SQLite's compile-time SQLITE_MAX_COLUMN limit (default ").concat(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."));
+    }
+    // Columns the frontmatter upsert actually writes: core + parsed frontmatter keys, never a
+    // feature-owned reserved column (see CORE_FRONTMATTER_COLUMNS above).
+    var writableColumns = allColumns.filter(function(c) {
+        return CORE_FRONTMATTER_COLUMNS.has(c) || !_scants.RESERVED_COLUMNS.has(c);
+    });
+    // ON CONFLICT UPDATE (not OR REPLACE) keeps the row's rowid stable across reparses --
+    // content rows are coupled to that rowid below.
+    var insertSql = "INSERT INTO frontmatter (".concat(writableColumns.map(quoteIdent).join(', '), ") VALUES (").concat(writableColumns.map(function() {
         return '?';
-    }).join(', '), ")");
+    }).join(', '), ') ON CONFLICT("path") DO UPDATE SET ').concat(writableColumns.filter(function(c) {
+        return c !== 'path';
+    }).map(function(c) {
+        return "".concat(quoteIdent(c), " = excluded.").concat(quoteIdent(c));
+    }).join(', '));
+    var added = toReparse.filter(function(f) {
+        return !existing.has(f.relPath);
+    }).map(function(f) {
+        return f.relPath;
+    });
+    var delta = {
+        files: files,
+        reparsed: parsedDocs.map(function(d) {
+            return d.relPath;
+        }),
+        added: added,
+        vanished: vanished
+    };
+    var txStart = Date.now();
     db.exec('BEGIN');
     try {
         var _feature_afterReconcile;
-        var _iteratorNormalCompletion2 = true, _didIteratorError2 = false, _iteratorError2 = undefined;
+        var _iteratorNormalCompletion1 = true, _didIteratorError1 = false, _iteratorError1 = undefined;
         try {
-            for(var _iterator2 = newColumns[Symbol.iterator](), _step2; !(_iteratorNormalCompletion2 = (_step2 = _iterator2.next()).done); _iteratorNormalCompletion2 = true){
-                var col = _step2.value;
+            for(var _iterator1 = newColumns[Symbol.iterator](), _step1; !(_iteratorNormalCompletion1 = (_step1 = _iterator1.next()).done); _iteratorNormalCompletion1 = true){
+                var col = _step1.value;
                 db.exec("ALTER TABLE frontmatter ADD COLUMN ".concat(quoteIdent(col)));
             }
         } catch (err) {
-            _didIteratorError2 = true;
-            _iteratorError2 = err;
+            _didIteratorError1 = true;
+            _iteratorError1 = err;
         } finally{
             try {
-                if (!_iteratorNormalCompletion2 && _iterator2.return != null) {
-                    _iterator2.return();
+                if (!_iteratorNormalCompletion1 && _iterator1.return != null) {
+                    _iterator1.return();
                 }
             } finally{
-                if (_didIteratorError2) {
-                    throw _iteratorError2;
+                if (_didIteratorError1) {
+                    throw _iteratorError1;
                 }
             }
         }
-        // FTS5 has no upsert, so delete-before-insert into `content`.
-        var delBody = db.prepare('DELETE FROM content WHERE "path" = ?');
+        // FTS5 has no upsert, so delete-before-insert into `content`; coupled to the
+        // frontmatter rowid (indexed via its PRIMARY KEY) instead of the UNINDEXED `path`
+        // column, which a per-row DELETE would otherwise scan the whole table to find.
+        var delBody = db.prepare('DELETE FROM content WHERE rowid = (SELECT rowid FROM frontmatter WHERE "path" = ?)');
+        var delPresetFiles = db.prepare('DELETE FROM preset_files WHERE "path" = ?');
+        var insertPresetFile = db.prepare('INSERT INTO preset_files ("path", preset) VALUES (?, ?)');
         if (vanished.length > 0) {
             var del = db.prepare('DELETE FROM frontmatter WHERE "path" = ?');
-            var _iteratorNormalCompletion3 = true, _didIteratorError3 = false, _iteratorError3 = undefined;
+            var _iteratorNormalCompletion2 = true, _didIteratorError2 = false, _iteratorError2 = undefined;
             try {
-                for(var _iterator3 = vanished[Symbol.iterator](), _step3; !(_iteratorNormalCompletion3 = (_step3 = _iterator3.next()).done); _iteratorNormalCompletion3 = true){
-                    var path = _step3.value;
+                for(var _iterator2 = vanished[Symbol.iterator](), _step2; !(_iteratorNormalCompletion2 = (_step2 = _iterator2.next()).done); _iteratorNormalCompletion2 = true){
+                    var path = _step2.value;
                     var _feature_remove;
-                    del.run(path);
+                    // content delete must run first: it looks up the frontmatter rowid by path, which
+                    // the frontmatter delete below would otherwise have already removed.
                     delBody.run(path);
-                    var _iteratorNormalCompletion4 = true, _didIteratorError4 = false, _iteratorError4 = undefined;
+                    del.run(path);
+                    delPresetFiles.run(path);
+                    var _iteratorNormalCompletion3 = true, _didIteratorError3 = false, _iteratorError3 = undefined;
                     try {
-                        for(var _iterator4 = features[Symbol.iterator](), _step4; !(_iteratorNormalCompletion4 = (_step4 = _iterator4.next()).done); _iteratorNormalCompletion4 = true){
-                            var feature = _step4.value;
-                            (_feature_remove = feature.remove) === null || _feature_remove === void 0 ? void 0 : _feature_remove.call(feature, db, path);
+                        for(var _iterator3 = features[Symbol.iterator](), _step3; !(_iteratorNormalCompletion3 = (_step3 = _iterator3.next()).done); _iteratorNormalCompletion3 = true){
+                            var feature = _step3.value;
+                            (_feature_remove = feature.remove) === null || _feature_remove === void 0 ? void 0 : _feature_remove.call(feature, db, path, delta);
                         }
                     } catch (err) {
-                        _didIteratorError4 = true;
-                        _iteratorError4 = err;
+                        _didIteratorError3 = true;
+                        _iteratorError3 = err;
                     } finally{
                         try {
-                            if (!_iteratorNormalCompletion4 && _iterator4.return != null) {
-                                _iterator4.return();
+                            if (!_iteratorNormalCompletion3 && _iterator3.return != null) {
+                                _iterator3.return();
                             }
                         } finally{
-                            if (_didIteratorError4) {
-                                throw _iteratorError4;
+                            if (_didIteratorError3) {
+                                throw _iteratorError3;
                             }
                         }
                     }
                 }
             } catch (err) {
-                _didIteratorError3 = true;
-                _iteratorError3 = err;
+                _didIteratorError2 = true;
+                _iteratorError2 = err;
             } finally{
                 try {
-                    if (!_iteratorNormalCompletion3 && _iterator3.return != null) {
-                        _iterator3.return();
+                    if (!_iteratorNormalCompletion2 && _iterator2.return != null) {
+                        _iterator2.return();
                     }
                 } finally{
-                    if (_didIteratorError3) {
-                        throw _iteratorError3;
+                    if (_didIteratorError2) {
+                        throw _iteratorError2;
                     }
                 }
             }
         }
         if (parsedDocs.length > 0) {
             var insert = db.prepare(insertSql);
-            var insertBody = db.prepare('INSERT INTO content (title, summary, text, "path") VALUES (?, ?, ?, ?)');
-            var _iteratorNormalCompletion5 = true, _didIteratorError5 = false, _iteratorError5 = undefined;
+            var insertBody = db.prepare('INSERT INTO content (rowid, title, summary, text, "path") VALUES ((SELECT rowid FROM frontmatter WHERE "path" = ?), ?, ?, ?, ?)');
+            var _iteratorNormalCompletion4 = true, _didIteratorError4 = false, _iteratorError4 = undefined;
             try {
-                var _loop = function() {
-                    var doc = _step5.value;
-                    var _insert;
+                var _loop1 = function() {
+                    var doc = _step4.value;
+                    var // Frontmatter upsert first: content's rowid lookup below depends on this row existing.
+                    _insert;
                     var _feature_store;
-                    var values = allColumns.map(function(col) {
+                    var values = writableColumns.map(function(col) {
                         var _doc_data_col;
                         if (col === 'path') return doc.relPath;
                         if (col === '_mtime') return doc.mtimeMs;
@@ -310,9 +415,9 @@ function reconcile(db, cfg, baseDir) {
                         return (_doc_data_col = doc.data[col]) !== null && _doc_data_col !== void 0 ? _doc_data_col : null;
                     });
                     (_insert = insert).run.apply(_insert, _to_consumable_array(values));
-                    // Delete-before-insert only for docs that have rows: an FTS5 DELETE by column
-                    // cannot use an index and scans the whole table, so running it per doc on a
-                    // cold build (empty table, nothing to delete) made the crawl quadratic --
+                    // Delete-before-insert only for docs that have rows: an FTS5 DELETE by rowid on a
+                    // cold build (empty table, nothing to delete) is wasted work, and doing it
+                    // unconditionally previously made the crawl quadratic when it scanned by column --
                     // measured 4x time per note-count doubling at 13k/26k notes.
                     if (existing.has(doc.relPath)) {
                         var _feature_remove;
@@ -321,7 +426,7 @@ function reconcile(db, cfg, baseDir) {
                         try {
                             for(var _iterator = features[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
                                 var feature = _step.value;
-                                (_feature_remove = feature.remove) === null || _feature_remove === void 0 ? void 0 : _feature_remove.call(feature, db, doc.relPath);
+                                (_feature_remove = feature.remove) === null || _feature_remove === void 0 ? void 0 : _feature_remove.call(feature, db, doc.relPath, delta);
                             }
                         } catch (err) {
                             _didIteratorError = true;
@@ -338,12 +443,17 @@ function reconcile(db, cfg, baseDir) {
                             }
                         }
                     }
-                    insertBody.run(doc.search.title, doc.search.summary, doc.search.text, doc.relPath);
+                    insertBody.run(doc.relPath, doc.search.title, doc.search.summary, doc.search.text, doc.relPath);
+                    // Coverage is glob-derived, not content-derived, but only reparsed/added docs are
+                    // touched here: a preset edit changes featureSignature and forces a full rebuild
+                    // (see open()), so an unchanged doc's coverage is already correct on disk. New docs
+                    // have no rows to clear -- skipping the delete keeps cold builds linear.
+                    if (existing.has(doc.relPath)) delPresetFiles.run(doc.relPath);
                     var _iteratorNormalCompletion1 = true, _didIteratorError1 = false, _iteratorError1 = undefined;
                     try {
-                        for(var _iterator1 = features[Symbol.iterator](), _step1; !(_iteratorNormalCompletion1 = (_step1 = _iterator1.next()).done); _iteratorNormalCompletion1 = true){
-                            var feature1 = _step1.value;
-                            (_feature_store = feature1.store) === null || _feature_store === void 0 ? void 0 : _feature_store.call(feature1, db, doc.relPath, doc.extracted[feature1.name]);
+                        for(var _iterator1 = doc.presets[Symbol.iterator](), _step1; !(_iteratorNormalCompletion1 = (_step1 = _iterator1.next()).done); _iteratorNormalCompletion1 = true){
+                            var presetName = _step1.value;
+                            insertPresetFile.run(doc.relPath, presetName);
                         }
                     } catch (err) {
                         _didIteratorError1 = true;
@@ -359,40 +469,60 @@ function reconcile(db, cfg, baseDir) {
                             }
                         }
                     }
+                    var _iteratorNormalCompletion2 = true, _didIteratorError2 = false, _iteratorError2 = undefined;
+                    try {
+                        for(var _iterator2 = features[Symbol.iterator](), _step2; !(_iteratorNormalCompletion2 = (_step2 = _iterator2.next()).done); _iteratorNormalCompletion2 = true){
+                            var feature1 = _step2.value;
+                            (_feature_store = feature1.store) === null || _feature_store === void 0 ? void 0 : _feature_store.call(feature1, db, doc.relPath, doc.extracted[feature1.name], delta);
+                        }
+                    } catch (err) {
+                        _didIteratorError2 = true;
+                        _iteratorError2 = err;
+                    } finally{
+                        try {
+                            if (!_iteratorNormalCompletion2 && _iterator2.return != null) {
+                                _iterator2.return();
+                            }
+                        } finally{
+                            if (_didIteratorError2) {
+                                throw _iteratorError2;
+                            }
+                        }
+                    }
                 };
-                for(var _iterator5 = parsedDocs[Symbol.iterator](), _step5; !(_iteratorNormalCompletion5 = (_step5 = _iterator5.next()).done); _iteratorNormalCompletion5 = true)_loop();
+                for(var _iterator4 = parsedDocs[Symbol.iterator](), _step4; !(_iteratorNormalCompletion4 = (_step4 = _iterator4.next()).done); _iteratorNormalCompletion4 = true)_loop1();
             } catch (err) {
-                _didIteratorError5 = true;
-                _iteratorError5 = err;
+                _didIteratorError4 = true;
+                _iteratorError4 = err;
             } finally{
                 try {
-                    if (!_iteratorNormalCompletion5 && _iterator5.return != null) {
-                        _iterator5.return();
+                    if (!_iteratorNormalCompletion4 && _iterator4.return != null) {
+                        _iterator4.return();
                     }
                 } finally{
-                    if (_didIteratorError5) {
-                        throw _iteratorError5;
+                    if (_didIteratorError4) {
+                        throw _iteratorError4;
                     }
                 }
             }
         }
-        var _iteratorNormalCompletion6 = true, _didIteratorError6 = false, _iteratorError6 = undefined;
+        var _iteratorNormalCompletion5 = true, _didIteratorError5 = false, _iteratorError5 = undefined;
         try {
-            for(var _iterator6 = features[Symbol.iterator](), _step6; !(_iteratorNormalCompletion6 = (_step6 = _iterator6.next()).done); _iteratorNormalCompletion6 = true){
-                var feature1 = _step6.value;
-                (_feature_afterReconcile = feature1.afterReconcile) === null || _feature_afterReconcile === void 0 ? void 0 : _feature_afterReconcile.call(feature1, db, files);
+            for(var _iterator5 = features[Symbol.iterator](), _step5; !(_iteratorNormalCompletion5 = (_step5 = _iterator5.next()).done); _iteratorNormalCompletion5 = true){
+                var feature1 = _step5.value;
+                (_feature_afterReconcile = feature1.afterReconcile) === null || _feature_afterReconcile === void 0 ? void 0 : _feature_afterReconcile.call(feature1, db, delta);
             }
         } catch (err) {
-            _didIteratorError6 = true;
-            _iteratorError6 = err;
+            _didIteratorError5 = true;
+            _iteratorError5 = err;
         } finally{
             try {
-                if (!_iteratorNormalCompletion6 && _iterator6.return != null) {
-                    _iterator6.return();
+                if (!_iteratorNormalCompletion5 && _iterator5.return != null) {
+                    _iterator5.return();
                 }
             } finally{
-                if (_didIteratorError6) {
-                    throw _iteratorError6;
+                if (_didIteratorError5) {
+                    throw _iteratorError5;
                 }
             }
         }
@@ -401,12 +531,84 @@ function reconcile(db, cfg, baseDir) {
         db.exec('ROLLBACK');
         throw err;
     }
+    // Reconcile's own write-transaction duration, for open()'s derived busy_timeout (F):
+    // keep the observed max so a big watcher reconcile's lock hold is what the next open bounds its wait against.
+    var durationMs = Date.now() - txStart;
+    var prevRaw = getMeta(db, 'reconcile_max_ms');
+    // -1, not 0, so a genuinely 0ms first reconcile (sub-millisecond, common on a tiny tree)
+    // still gets recorded instead of losing to the "nothing recorded yet" default.
+    var prevMax = prevRaw === null ? -1 : Number(prevRaw);
+    if (durationMs > prevMax) setMeta(db, 'reconcile_max_ms', String(durationMs));
     return {
         parsed: parsedDocs.length,
         warnings: warnings
     };
 }
+// Names what moved between two feature signatures (see config.featureSignature's format:
+// global features, embed provider, then one segment per preset) for the rebuild notice.
+function signatureDiff(before, after) {
+    // Segment keys: `features`, `embed`, `preset:<name>` (config.featureSignature's format).
+    var keyOf = function keyOf(part) {
+        return part.startsWith('preset:') ? part.split(':').slice(0, 2).join(':') : part.split(':')[0];
+    };
+    var parse = function parse(sig) {
+        return new Map(sig.split('|').map(function(part) {
+            return [
+                keyOf(part),
+                part
+            ];
+        }));
+    };
+    var a = parse(before);
+    var b = parse(after);
+    var changed = new Set();
+    var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+    try {
+        for(var _iterator = b[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+            var _step_value = _sliced_to_array(_step.value, 2), key = _step_value[0], val = _step_value[1];
+            if (a.get(key) !== val) changed.add(key);
+        }
+    } catch (err) {
+        _didIteratorError = true;
+        _iteratorError = err;
+    } finally{
+        try {
+            if (!_iteratorNormalCompletion && _iterator.return != null) {
+                _iterator.return();
+            }
+        } finally{
+            if (_didIteratorError) {
+                throw _iteratorError;
+            }
+        }
+    }
+    var _iteratorNormalCompletion1 = true, _didIteratorError1 = false, _iteratorError1 = undefined;
+    try {
+        for(var _iterator1 = a.keys()[Symbol.iterator](), _step1; !(_iteratorNormalCompletion1 = (_step1 = _iterator1.next()).done); _iteratorNormalCompletion1 = true){
+            var key1 = _step1.value;
+            if (!b.has(key1)) changed.add(key1);
+        }
+    } catch (err) {
+        _didIteratorError1 = true;
+        _iteratorError1 = err;
+    } finally{
+        try {
+            if (!_iteratorNormalCompletion1 && _iterator1.return != null) {
+                _iterator1.return();
+            }
+        } finally{
+            if (_didIteratorError1) {
+                throw _iteratorError1;
+            }
+        }
+    }
+    var label = function label(key) {
+        return key === 'embed' ? 'embed settings' : key.startsWith('preset:') ? 'preset "'.concat(key.slice(7), '"') : 'features';
+    };
+    return changed.size === 0 ? 'features' : _to_consumable_array(changed).map(label).join(', ');
+}
 function open(cfg) {
+    var _getMeta;
     var stateDir = (0, _nodepath.join)(cfg.baseDir, _configts.STATE_DIR);
     (0, _nodefs.mkdirSync)(stateDir, {
         recursive: true
@@ -427,6 +629,14 @@ function open(cfg) {
     var features = getMeta(db, 'features');
     var wantFeatures = (0, _configts.featureSignature)(cfg);
     if (version !== null && version !== SCHEMA_VERSION || features !== null && features !== wantFeatures) {
+        // Indexing derives from presets, so a config edit rebuilding the cache must say so and
+        // name what changed -- silent rebuilds make derived indexing look like a hang or a bug.
+        if (version !== null && version !== SCHEMA_VERSION) {
+            console.error('sense: cache format changed (new sensemaking version); rebuilding the index');
+        } else {
+            var changed = signatureDiff(features !== null && features !== void 0 ? features : '', wantFeatures);
+            console.error("sense: config change (".concat(changed, ") rebuilds the index"));
+        }
         db.close();
         (0, _nodefs.rmSync)(stateDir, {
             recursive: true,
@@ -435,6 +645,13 @@ function open(cfg) {
         return open(cfg);
     }
     ensureSchema(db, cfg);
+    // Derived from reconcile's own recorded max (F): 3x the largest reconcile this cache has
+    // ever held its write transaction for, floored at the 30s default and capped at 10min so
+    // one pathological build can't pin every later open to an unbounded wait. Installed
+    // before reconcile() below -- this open's own reconcile is exactly the operation that
+    // races a concurrent watcher's transaction and needs the derived wait.
+    var recordedMaxMs = Number((_getMeta = getMeta(db, 'reconcile_max_ms')) !== null && _getMeta !== void 0 ? _getMeta : '0');
+    db.exec("PRAGMA busy_timeout = ".concat(Math.min(Math.max(30000, 3 * recordedMaxMs), 600000)));
     var _reconcile = reconcile(db, cfg, cfg.baseDir), parsed = _reconcile.parsed, warnings = _reconcile.warnings;
     return {
         db: db,