sensemaking 0.19.2 → 0.20.0

package/dist/cjs/store/open.js

@@ -0,0 +1,516 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: Object.getOwnPropertyDescriptor(all, name).get
+    });
+}
+_export(exports, {
+    get docCount () {
+        return docCount;
+    },
+    get openWithBuilder () {
+        return openWithBuilder;
+    },
+    get openWithDialect () {
+        return openWithDialect;
+    }
+});
+var _nodefs = require("node:fs");
+var _nodepath = require("node:path");
+var _indexts = require("../config/index.js");
+var _handoffts = require("../embed/handoff.js");
+var _indexts1 = require("../features/index.js");
+var _builderts = require("./builder.js");
+var _cachets = require("./cache.js");
+var _sharedts = require("./shared.js");
+var _signaturets = require("./signature.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_without_holes(arr) {
+    if (Array.isArray(arr)) return _array_like_to_array(arr);
+}
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
+    try {
+        var info = gen[key](arg);
+        var value = info.value;
+    } catch (error) {
+        reject(error);
+        return;
+    }
+    if (info.done) resolve(value);
+    else Promise.resolve(value).then(_next, _throw);
+}
+function _async_to_generator(fn) {
+    return function() {
+        var self = this, args = arguments;
+        return new Promise(function(resolve, reject) {
+            var gen = fn.apply(self, args);
+            function _next(value) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
+            }
+            function _throw(err) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
+            }
+            _next(undefined);
+        });
+    };
+}
+function _iterable_to_array(iter) {
+    if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) {
+        return Array.from(iter);
+    }
+}
+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 _to_consumable_array(arr) {
+    return _array_without_holes(arr) || _iterable_to_array(arr) || _unsupported_iterable_to_array(arr) || _non_iterable_spread();
+}
+function _ts_generator(thisArg, body) {
+    var f, y, t, _ = {
+        label: 0,
+        sent: function() {
+            if (t[0] & 1) throw t[1];
+            return t[1];
+        },
+        trys: [],
+        ops: []
+    }, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype), d = Object.defineProperty;
+    return d(g, "next", {
+        value: verb(0)
+    }), d(g, "throw", {
+        value: verb(1)
+    }), d(g, "return", {
+        value: verb(2)
+    }), typeof Symbol === "function" && d(g, Symbol.iterator, {
+        value: function() {
+            return this;
+        }
+    }), g;
+    function verb(n) {
+        return function(v) {
+            return step([
+                n,
+                v
+            ]);
+        };
+    }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while(g && (g = 0, op[0] && (_ = 0)), _)try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [
+                op[0] & 2,
+                t.value
+            ];
+            switch(op[0]){
+                case 0:
+                case 1:
+                    t = op;
+                    break;
+                case 4:
+                    _.label++;
+                    return {
+                        value: op[1],
+                        done: false
+                    };
+                case 5:
+                    _.label++;
+                    y = op[1];
+                    op = [
+                        0
+                    ];
+                    continue;
+                case 7:
+                    op = _.ops.pop();
+                    _.trys.pop();
+                    continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) {
+                        _ = 0;
+                        continue;
+                    }
+                    if (op[0] === 3 && (!t || op[1] > t[0] && op[1] < t[3])) {
+                        _.label = op[1];
+                        break;
+                    }
+                    if (op[0] === 6 && _.label < t[1]) {
+                        _.label = t[1];
+                        t = op;
+                        break;
+                    }
+                    if (t && _.label < t[2]) {
+                        _.label = t[2];
+                        _.ops.push(op);
+                        break;
+                    }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop();
+                    continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) {
+            op = [
+                6,
+                e
+            ];
+            y = 0;
+        } finally{
+            f = t = 0;
+        }
+        if (op[0] & 5) throw op[1];
+        return {
+            value: op[0] ? op[1] : void 0,
+            done: true
+        };
+    }
+}
+function _unsupported_iterable_to_array(o, minLen) {
+    if (!o) return;
+    if (typeof o === "string") return _array_like_to_array(o, minLen);
+    var n = Object.prototype.toString.call(o).slice(8, -1);
+    if (n === "Object" && o.constructor) n = o.constructor.name;
+    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);
+}
+function connectWithDialect(cfg, dialect, keepBuilderOpen) {
+    return _async_to_generator(function() {
+        var stateDir, dbPath, _ref, handle, conn, closed, builder, version, features, wantFeatures, tokenizeOnlyRebuild, changedKeys, _tmp, changed, extraReason, rebuildWarnings, _ref1, recordedMaxMs, _ref2, parsed, warnings, err;
+        return _ts_generator(this, function(_state) {
+            switch(_state.label){
+                case 0:
+                    stateDir = (0, _nodepath.join)(cfg.baseDir, _indexts.STATE_DIR);
+                    (0, _nodefs.mkdirSync)(stateDir, {
+                        recursive: true
+                    });
+                    dbPath = (0, _nodepath.join)(stateDir, dialect.filename);
+                    return [
+                        4,
+                        dialect.connect(dbPath, cfg)
+                    ];
+                case 1:
+                    _ref = _state.sent(), handle = _ref.handle, conn = _ref.conn;
+                    // A throw below must release this handle, or the leaked WAL makes the cache file undeletable on
+                    // Windows. `closed` keeps the catch from double-closing a handle a rebuild branch already closed.
+                    closed = false;
+                    // Created here, not inside reconcile(): its pool must survive across every build() call this
+                    // connection sees (a watcher's repeated ticks), not just the one below.
+                    builder = (0, _builderts.createBuilder)(conn, cfg, cfg.baseDir, dialect.reconcileDialect);
+                    _state.label = 2;
+                case 2:
+                    _state.trys.push([
+                        2,
+                        26,
+                        ,
+                        30
+                    ]);
+                    return [
+                        4,
+                        conn.exec('CREATE TABLE IF NOT EXISTS meta (key TEXT PRIMARY KEY, value TEXT)')
+                    ];
+                case 3:
+                    _state.sent();
+                    return [
+                        4,
+                        (0, _sharedts.getMeta)(conn, 'schema_version')
+                    ];
+                case 4:
+                    version = _state.sent();
+                    return [
+                        4,
+                        (0, _sharedts.getMeta)(conn, 'features')
+                    ];
+                case 5:
+                    features = _state.sent();
+                    wantFeatures = (0, _indexts.featureSignature)(cfg, _indexts1.FEATURES);
+                    tokenizeOnlyRebuild = false;
+                    if (!(version !== null && version !== dialect.schemaVersion || features !== null && features !== wantFeatures)) return [
+                        3,
+                        14
+                    ];
+                    if (!(version !== null && version !== dialect.schemaVersion)) return [
+                        3,
+                        7
+                    ];
+                    console.error('sense: cache format changed (new sensemaking version); rebuilding the index');
+                    // Close before clearCache deletes the files out from under the still-open handle.
+                    closed = true;
+                    return [
+                        4,
+                        dialect.close(handle)
+                    ];
+                case 6:
+                    _state.sent();
+                    (0, _cachets.clearCache)(cfg);
+                    return [
+                        2,
+                        connectWithDialect(cfg, dialect, keepBuilderOpen)
+                    ];
+                case 7:
+                    changedKeys = (0, _signaturets.changedSignatureKeys)(features !== null && features !== void 0 ? features : '', wantFeatures);
+                    _tmp = dialect.partialRebuild;
+                    if (!_tmp) return [
+                        3,
+                        9
+                    ];
+                    return [
+                        4,
+                        dialect.partialRebuild(handle, conn, cfg, changedKeys)
+                    ];
+                case 8:
+                    _tmp = _state.sent();
+                    _state.label = 9;
+                case 9:
+                    if (!_tmp) return [
+                        3,
+                        10
+                    ];
+                    tokenizeOnlyRebuild = true;
+                    return [
+                        3,
+                        14
+                    ];
+                case 10:
+                    if (!(changedKeys.size === 1 && changedKeys.has('embed') && (0, _signaturets.embedIdentityAdopted)(features !== null && features !== void 0 ? features : '', wantFeatures))) return [
+                        3,
+                        12
+                    ];
+                    // First sight of a resolved weight identity: the model itself hasn't changed, so
+                    // adopt it into meta with no rebuild and no re-embed, mirroring the tokenize precedent.
+                    console.error("sense: recorded the embedding model's resolved identity; vectors are unaffected");
+                    return [
+                        4,
+                        (0, _sharedts.setMeta)(conn, 'features', wantFeatures)
+                    ];
+                case 11:
+                    _state.sent();
+                    return [
+                        3,
+                        14
+                    ];
+                case 12:
+                    changed = (0, _signaturets.signatureDiff)(features !== null && features !== void 0 ? features : '', wantFeatures);
+                    console.error("sense: config change (".concat(changed, ") rebuilds the index"));
+                    closed = true;
+                    return [
+                        4,
+                        dialect.close(handle)
+                    ];
+                case 13:
+                    _state.sent();
+                    (0, _cachets.clearCache)(cfg);
+                    return [
+                        2,
+                        connectWithDialect(cfg, dialect, keepBuilderOpen)
+                    ];
+                case 14:
+                    // A rebuild trigger independent of the signature comparison above (sqlite: the content
+                    // table's own DDL no longer matches the resolved tokenizer).
+                    extraReason = dialect.extraRebuildReason ? dialect.extraRebuildReason(handle) : null;
+                    if (!(extraReason !== null)) return [
+                        3,
+                        16
+                    ];
+                    console.error("sense: ".concat(extraReason, "; rebuilding the index"));
+                    closed = true;
+                    return [
+                        4,
+                        dialect.close(handle)
+                    ];
+                case 15:
+                    _state.sent();
+                    (0, _cachets.clearCache)(cfg);
+                    return [
+                        2,
+                        connectWithDialect(cfg, dialect, keepBuilderOpen)
+                    ];
+                case 16:
+                    return [
+                        4,
+                        dialect.ensureSchema(handle, conn, cfg)
+                    ];
+                case 17:
+                    _state.sent();
+                    rebuildWarnings = [];
+                    if (!(tokenizeOnlyRebuild && dialect.postSchemaRebuild)) return [
+                        3,
+                        19
+                    ];
+                    return [
+                        4,
+                        dialect.postSchemaRebuild(handle, conn, cfg, cfg.baseDir, wantFeatures)
+                    ];
+                case 18:
+                    rebuildWarnings = _state.sent();
+                    _state.label = 19;
+                case 19:
+                    if (!dialect.setDerivedBusyTimeout) return [
+                        3,
+                        22
+                    ];
+                    return [
+                        4,
+                        (0, _sharedts.getMeta)(conn, 'reconcile_max_ms')
+                    ];
+                case 20:
+                    recordedMaxMs = Number.apply(void 0, [
+                        (_ref1 = _state.sent()) !== null && _ref1 !== void 0 ? _ref1 : '0'
+                    ]);
+                    return [
+                        4,
+                        dialect.setDerivedBusyTimeout(handle, conn, Math.min(Math.max(30000, 3 * recordedMaxMs), 600000))
+                    ];
+                case 21:
+                    _state.sent();
+                    _state.label = 22;
+                case 22:
+                    return [
+                        4,
+                        builder.build()
+                    ];
+                case 23:
+                    _ref2 = _state.sent(), parsed = _ref2.parsed, warnings = _ref2.warnings;
+                    if (!!keepBuilderOpen) return [
+                        3,
+                        25
+                    ];
+                    return [
+                        4,
+                        builder.close()
+                    ];
+                case 24:
+                    _state.sent();
+                    _state.label = 25;
+                case 25:
+                    return [
+                        2,
+                        {
+                            handle: handle,
+                            conn: conn,
+                            cfg: cfg,
+                            dbPath: dbPath,
+                            parsed: parsed,
+                            warnings: _to_consumable_array(rebuildWarnings).concat(_to_consumable_array(warnings)),
+                            builder: builder
+                        }
+                    ];
+                case 26:
+                    err = _state.sent();
+                    return [
+                        4,
+                        builder.close()
+                    ];
+                case 27:
+                    _state.sent();
+                    if (!!closed) return [
+                        3,
+                        29
+                    ];
+                    return [
+                        4,
+                        dialect.close(handle)
+                    ];
+                case 28:
+                    _state.sent();
+                    _state.label = 29;
+                case 29:
+                    throw err;
+                case 30:
+                    return [
+                        2
+                    ];
+            }
+        });
+    })();
+}
+function openWithDialect(cfg, dialect) {
+    return _async_to_generator(function() {
+        var _ref, handle, conn, resolvedCfg, dbPath, parsed, warnings, store;
+        return _ts_generator(this, function(_state) {
+            switch(_state.label){
+                case 0:
+                    return [
+                        4,
+                        connectWithDialect(cfg, dialect, false)
+                    ];
+                case 1:
+                    _ref = _state.sent(), handle = _ref.handle, conn = _ref.conn, resolvedCfg = _ref.cfg, dbPath = _ref.dbPath, parsed = _ref.parsed, warnings = _ref.warnings;
+                    store = dialect.createStore(handle, conn, resolvedCfg);
+                    // reconcile ran before this object existed, so its chunk text is keyed by the connection.
+                    (0, _handoffts.rekeyChunkText)(conn, store);
+                    return [
+                        2,
+                        {
+                            store: store,
+                            cfg: resolvedCfg,
+                            dbPath: dbPath,
+                            parsed: parsed,
+                            warnings: warnings
+                        }
+                    ];
+            }
+        });
+    })();
+}
+function openWithBuilder(cfg, dialect) {
+    return _async_to_generator(function() {
+        var _ref, handle, conn, resolvedCfg, dbPath, parsed, warnings, builder, store;
+        return _ts_generator(this, function(_state) {
+            switch(_state.label){
+                case 0:
+                    return [
+                        4,
+                        connectWithDialect(cfg, dialect, true)
+                    ];
+                case 1:
+                    _ref = _state.sent(), handle = _ref.handle, conn = _ref.conn, resolvedCfg = _ref.cfg, dbPath = _ref.dbPath, parsed = _ref.parsed, warnings = _ref.warnings, builder = _ref.builder;
+                    store = dialect.createStore(handle, conn, resolvedCfg);
+                    (0, _handoffts.rekeyChunkText)(conn, store);
+                    return [
+                        2,
+                        {
+                            store: store,
+                            cfg: resolvedCfg,
+                            dbPath: dbPath,
+                            parsed: parsed,
+                            warnings: warnings,
+                            builder: builder
+                        }
+                    ];
+            }
+        });
+    })();
+}
+function docCount(store) {
+    return _async_to_generator(function() {
+        var stmt;
+        return _ts_generator(this, function(_state) {
+            switch(_state.label){
+                case 0:
+                    return [
+                        4,
+                        store.prepare('SELECT COUNT(*) AS n FROM frontmatter')
+                    ];
+                case 1:
+                    stmt = _state.sent();
+                    return [
+                        4,
+                        stmt.get()
+                    ];
+                case 2:
+                    return [
+                        2,
+                        _state.sent().n
+                    ];
+            }
+        });
+    })();
+}
+/* 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/open.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["/Users/kevin/Dev/OpenSource/ai/sensemaking/src/store/open.ts"],"sourcesContent":["import { mkdirSync } from 'node:fs';\nimport { join } from 'node:path';\nimport type { ResolvedConfig } from '../config/index.ts';\nimport { featureSignature, STATE_DIR } from '../config/index.ts';\nimport { rekeyChunkText } from '../embed/handoff.ts';\nimport { FEATURES } from '../features/index.ts';\nimport type { Builder } from './builder.ts';\nimport { createBuilder } from './builder.ts';\nimport { clearCache } from './cache.ts';\nimport { getMeta, setMeta } from './shared.ts';\nimport { changedSignatureKeys, embedIdentityAdopted, signatureDiff } from './signature.ts';\nimport type { Connection, OpenDialect, Store } from './types.ts';\n\n// One open algorithm shared by every store, parameterised by a per-engine OpenDialect (types.ts).\n// Ordering is universal, not a dialect concern: connect, meta table, schema-version and\n// feature-signature comparison (rebuild, adopt, or partial rebuild), any extra rebuild trigger,\n// ensureSchema, the derived busy_timeout PRAGMA, reconcile, then the store itself.\n\nexport interface OpenResult {\n  store: Store;\n  cfg: ResolvedConfig;\n  dbPath: string;\n  parsed: number;\n  warnings: string[];\n}\n\ninterface ConnectResult<Handle> {\n  handle: Handle;\n  conn: Connection;\n  cfg: ResolvedConfig;\n  dbPath: string;\n  parsed: number;\n  warnings: string[];\n  // Closed already unless `keepBuilderOpen` was set: a one-shot open reconciles once and is done\n  // with it, a watcher keeps calling build() on the same instance across its whole run.\n  builder: Builder;\n}\n\nasync function connectWithDialect<Handle>(cfg: ResolvedConfig, dialect: OpenDialect<Handle>, keepBuilderOpen: boolean): Promise<ConnectResult<Handle>> {\n  const stateDir = join(cfg.baseDir, STATE_DIR);\n  mkdirSync(stateDir, { recursive: true });\n  const dbPath = join(stateDir, dialect.filename);\n\n  const { handle, conn } = await dialect.connect(dbPath, cfg);\n  // A throw below must release this handle, or the leaked WAL makes the cache file undeletable on\n  // Windows. `closed` keeps the catch from double-closing a handle a rebuild branch already closed.\n  let closed = false;\n  // Created here, not inside reconcile(): its pool must survive across every build() call this\n  // connection sees (a watcher's repeated ticks), not just the one below.\n  const builder = createBuilder(conn, cfg, cfg.baseDir, dialect.reconcileDialect);\n  try {\n    await conn.exec('CREATE TABLE IF NOT EXISTS meta (key TEXT PRIMARY KEY, value TEXT)');\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 !== dialect.schemaVersion) || (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 !== dialect.schemaVersion) {\n        console.error('sense: cache format changed (new sensemaking version); rebuilding the index');\n        // Close before clearCache deletes the files out from under the still-open handle.\n        closed = true;\n        await dialect.close(handle);\n        clearCache(cfg);\n        return connectWithDialect(cfg, dialect, keepBuilderOpen);\n      }\n      const changedKeys = changedSignatureKeys(features ?? '', wantFeatures);\n      // Only a dialect-owned carve-out (sqlite's tokenizer) skips the rebuild below with its own\n      // partial DDL swap; every other single- or multi-segment change takes it.\n      if (dialect.partialRebuild && (await dialect.partialRebuild(handle, conn, cfg, changedKeys))) {\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        await dialect.close(handle);\n        clearCache(cfg);\n        return connectWithDialect(cfg, dialect, keepBuilderOpen);\n      }\n    }\n\n    // A rebuild trigger independent of the signature comparison above (sqlite: the content\n    // table's own DDL no longer matches the resolved tokenizer).\n    const extraReason = dialect.extraRebuildReason ? dialect.extraRebuildReason(handle) : null;\n    if (extraReason !== null) {\n      console.error(`sense: ${extraReason}; rebuilding the index`);\n      closed = true;\n      await dialect.close(handle);\n      clearCache(cfg);\n      return connectWithDialect(cfg, dialect, keepBuilderOpen);\n    }\n\n    await dialect.ensureSchema(handle, conn, cfg);\n\n    let rebuildWarnings: string[] = [];\n    if (tokenizeOnlyRebuild && dialect.postSchemaRebuild) {\n      rebuildWarnings = await dialect.postSchemaRebuild(handle, conn, cfg, cfg.baseDir, wantFeatures);\n    }\n\n    // 3x the largest reconcile this cache has recorded, floored at 30s and capped at 10min.\n    // Installed before build() -- that call is the one that races a watcher's transaction.\n    if (dialect.setDerivedBusyTimeout) {\n      const recordedMaxMs = Number((await getMeta(conn, 'reconcile_max_ms')) ?? '0');\n      await dialect.setDerivedBusyTimeout(handle, conn, Math.min(Math.max(30000, 3 * recordedMaxMs), 600_000));\n    }\n\n    const { parsed, warnings } = await builder.build();\n    // A one-shot open is done reconciling for good; a watcher keeps `builder` alive across its run.\n    if (!keepBuilderOpen) await builder.close();\n\n    return { handle, conn, cfg, dbPath, parsed, warnings: [...rebuildWarnings, ...warnings], builder };\n  } catch (err) {\n    await builder.close();\n    if (!closed) await dialect.close(handle);\n    throw err;\n  }\n}\n\n// A store's open(): connects (see connectWithDialect above), then wraps the resulting connection\n// in the Store interface. The builder's pool closes right after the initial build.\nexport async function openWithDialect<Handle>(cfg: ResolvedConfig, dialect: OpenDialect<Handle>): Promise<OpenResult> {\n  const { handle, conn, cfg: resolvedCfg, dbPath, parsed, warnings } = await connectWithDialect(cfg, dialect, false);\n  const store = dialect.createStore(handle, conn, resolvedCfg);\n  // reconcile ran before this object existed, so its chunk text is keyed by the connection.\n  rekeyChunkText(conn, store);\n  return { store, cfg: resolvedCfg, dbPath, parsed, warnings };\n}\n\n// Same connect+build as openWithDialect, but keeps the builder's pool alive and hands it back\n// alongside the store, for a caller (a watcher) that reconciles repeatedly on this connection.\nexport async function openWithBuilder<Handle>(cfg: ResolvedConfig, dialect: OpenDialect<Handle>): Promise<OpenResult & { builder: Builder }> {\n  const { handle, conn, cfg: resolvedCfg, dbPath, parsed, warnings, builder } = await connectWithDialect(cfg, dialect, true);\n  const store = dialect.createStore(handle, conn, resolvedCfg);\n  rekeyChunkText(conn, store);\n  return { store, cfg: resolvedCfg, dbPath, parsed, warnings, builder };\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":["docCount","openWithBuilder","openWithDialect","connectWithDialect","cfg","dialect","keepBuilderOpen","stateDir","dbPath","handle","conn","closed","builder","version","features","wantFeatures","tokenizeOnlyRebuild","changedKeys","changed","extraReason","rebuildWarnings","recordedMaxMs","parsed","warnings","err","join","baseDir","STATE_DIR","mkdirSync","recursive","filename","connect","createBuilder","reconcileDialect","exec","getMeta","featureSignature","FEATURES","schemaVersion","console","error","close","clearCache","changedSignatureKeys","partialRebuild","size","has","embedIdentityAdopted","setMeta","signatureDiff","extraRebuildReason","ensureSchema","postSchemaRebuild","setDerivedBusyTimeout","Number","Math","min","max","build","resolvedCfg","store","createStore","rekeyChunkText","stmt","prepare","get","n"],"mappings":";;;;;;;;;;;QAkJsBA;eAAAA;;QAPAC;eAAAA;;QAVAC;eAAAA;;;sBAjII;wBACL;uBAEuB;yBACb;wBACN;yBAEK;uBACH;wBACM;2BACyC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA4B1E,SAAeC,mBAA2BC,GAAmB,EAAEC,OAA4B,EAAEC,eAAwB;;YAC7GC,UAEAC,QAEmB,MAAjBC,QAAQC,MAGZC,QAGEC,SAMEC,SACAC,UACAC,cACFC,qBAYIC,mBAWEC,SAWJC,aAWFC,iBAQ4B,OAAxBC,eAIqB,OAArBC,QAAQC,UAKTC;;;;oBAjFHjB,WAAWkB,IAAAA,cAAI,EAACrB,IAAIsB,OAAO,EAAEC,kBAAS;oBAC5CC,IAAAA,iBAAS,EAACrB,UAAU;wBAAEsB,WAAW;oBAAK;oBAChCrB,SAASiB,IAAAA,cAAI,EAAClB,UAAUF,QAAQyB,QAAQ;oBAErB;;wBAAMzB,QAAQ0B,OAAO,CAACvB,QAAQJ;;;oBAA9B,OAAA,eAAjBK,SAAiB,KAAjBA,QAAQC,OAAS,KAATA;oBAChB,gGAAgG;oBAChG,kGAAkG;oBAC9FC,SAAS;oBACb,6FAA6F;oBAC7F,wEAAwE;oBAClEC,UAAUoB,IAAAA,wBAAa,EAACtB,MAAMN,KAAKA,IAAIsB,OAAO,EAAErB,QAAQ4B,gBAAgB;;;;;;;;;oBAE5E;;wBAAMvB,KAAKwB,IAAI,CAAC;;;oBAAhB;oBAIgB;;wBAAMC,IAAAA,iBAAO,EAACzB,MAAM;;;oBAA9BG,UAAU;oBACC;;wBAAMsB,IAAAA,iBAAO,EAACzB,MAAM;;;oBAA/BI,WAAW;oBACXC,eAAeqB,IAAAA,yBAAgB,EAAChC,KAAKiC,kBAAQ;oBAC/CrB,sBAAsB;yBACtB,CAAA,AAACH,YAAY,QAAQA,YAAYR,QAAQiC,aAAa,IAAMxB,aAAa,QAAQA,aAAaC,YAAY,GAA1G;;;;yBAGEF,CAAAA,YAAY,QAAQA,YAAYR,QAAQiC,aAAa,AAAD,GAApDzB;;;;oBACF0B,QAAQC,KAAK,CAAC;oBACd,kFAAkF;oBAClF7B,SAAS;oBACT;;wBAAMN,QAAQoC,KAAK,CAAChC;;;oBAApB;oBACAiC,IAAAA,mBAAU,EAACtC;oBACX;;wBAAOD,mBAAmBC,KAAKC,SAASC;;;oBAEpCW,cAAc0B,IAAAA,iCAAoB,EAAC7B,qBAAAA,sBAAAA,WAAY,IAAIC;2BAGrDV,QAAQuC,cAAc;+BAAtBvC;;;;oBAA2B;;wBAAMA,QAAQuC,cAAc,CAACnC,QAAQC,MAAMN,KAAKa;;;2BAAhD;;;;;;;oBAC7BD,sBAAsB;;;;;;yBACbC,CAAAA,YAAY4B,IAAI,KAAK,KAAK5B,YAAY6B,GAAG,CAAC,YAAYC,IAAAA,iCAAoB,EAACjC,qBAAAA,sBAAAA,WAAY,IAAIC,aAAY,GAAvGE;;;;oBACT,iFAAiF;oBACjF,wFAAwF;oBACxFsB,QAAQC,KAAK,CAAC;oBACd;;wBAAMQ,IAAAA,iBAAO,EAACtC,MAAM,YAAYK;;;oBAAhC;;;;;;oBAEMG,UAAU+B,IAAAA,0BAAa,EAACnC,qBAAAA,sBAAAA,WAAY,IAAIC;oBAC9CwB,QAAQC,KAAK,CAAC,AAAC,yBAAgC,OAARtB,SAAQ;oBAC/CP,SAAS;oBACT;;wBAAMN,QAAQoC,KAAK,CAAChC;;;oBAApB;oBACAiC,IAAAA,mBAAU,EAACtC;oBACX;;wBAAOD,mBAAmBC,KAAKC,SAASC;;;oBAI5C,uFAAuF;oBACvF,6DAA6D;oBACvDa,cAAcd,QAAQ6C,kBAAkB,GAAG7C,QAAQ6C,kBAAkB,CAACzC,UAAU;yBAClFU,CAAAA,gBAAgB,IAAG,GAAnBA;;;;oBACFoB,QAAQC,KAAK,CAAC,AAAC,UAAqB,OAAZrB,aAAY;oBACpCR,SAAS;oBACT;;wBAAMN,QAAQoC,KAAK,CAAChC;;;oBAApB;oBACAiC,IAAAA,mBAAU,EAACtC;oBACX;;wBAAOD,mBAAmBC,KAAKC,SAASC;;;oBAG1C;;wBAAMD,QAAQ8C,YAAY,CAAC1C,QAAQC,MAAMN;;;oBAAzC;oBAEIgB;yBACAJ,CAAAA,uBAAuBX,QAAQ+C,iBAAiB,AAAD,GAA/CpC;;;;oBACgB;;wBAAMX,QAAQ+C,iBAAiB,CAAC3C,QAAQC,MAAMN,KAAKA,IAAIsB,OAAO,EAAEX;;;oBAAlFK,kBAAkB;;;yBAKhBf,QAAQgD,qBAAqB,EAA7BhD;;;;oBAC4B;;wBAAM8B,IAAAA,iBAAO,EAACzB,MAAM;;;oBAA5CW,gBAAgBiC;yBAAQ,QAAA,2BAAA,mBAAA,QAA4C;;oBAC1E;;wBAAMjD,QAAQgD,qBAAqB,CAAC5C,QAAQC,MAAM6C,KAAKC,GAAG,CAACD,KAAKE,GAAG,CAAC,OAAO,IAAIpC,gBAAgB;;;oBAA/F;;;oBAG2B;;wBAAMT,QAAQ8C,KAAK;;;oBAAnB,QAAA,eAArBpC,SAAqB,MAArBA,QAAQC,WAAa,MAAbA;yBAEZ,CAACjB,iBAAD;;;;oBAAkB;;wBAAMM,QAAQ6B,KAAK;;;oBAAnB;;;oBAEtB;;wBAAO;4BAAEhC,QAAAA;4BAAQC,MAAAA;4BAAMN,KAAAA;4BAAKI,QAAAA;4BAAQc,QAAAA;4BAAQC,UAAU,AAAC,qBAAGH,wBAAiB,qBAAGG;4BAAWX,SAAAA;wBAAQ;;;oBAC1FY;oBACP;;wBAAMZ,QAAQ6B,KAAK;;;oBAAnB;yBACI,CAAC9B,QAAD;;;;oBAAS;;wBAAMN,QAAQoC,KAAK,CAAChC;;;oBAApB;;;oBACb,MAAMe;;;;;;;IAEV;;AAIO,SAAetB,gBAAwBE,GAAmB,EAAEC,OAA4B;;YACxB,MAA7DI,QAAQC,MAAWiD,aAAanD,QAAQc,QAAQC,UAClDqC;;;;oBAD+D;;wBAAMzD,mBAAmBC,KAAKC,SAAS;;;oBAAvC,OAAA,eAA7DI,SAA6D,KAA7DA,QAAQC,OAAqD,KAArDA,MAAWiD,cAA0C,KAA/CvD,KAAkBI,SAA6B,KAA7BA,QAAQc,SAAqB,KAArBA,QAAQC,WAAa,KAAbA;oBAClDqC,QAAQvD,QAAQwD,WAAW,CAACpD,QAAQC,MAAMiD;oBAChD,0FAA0F;oBAC1FG,IAAAA,yBAAc,EAACpD,MAAMkD;oBACrB;;wBAAO;4BAAEA,OAAAA;4BAAOxD,KAAKuD;4BAAanD,QAAAA;4BAAQc,QAAAA;4BAAQC,UAAAA;wBAAS;;;;IAC7D;;AAIO,SAAetB,gBAAwBG,GAAmB,EAAEC,OAA4B;;YACf,MAAtEI,QAAQC,MAAWiD,aAAanD,QAAQc,QAAQC,UAAUX,SAC5DgD;;;;oBADwE;;wBAAMzD,mBAAmBC,KAAKC,SAAS;;;oBAAvC,OAAA,eAAtEI,SAAsE,KAAtEA,QAAQC,OAA8D,KAA9DA,MAAWiD,cAAmD,KAAxDvD,KAAkBI,SAAsC,KAAtCA,QAAQc,SAA8B,KAA9BA,QAAQC,WAAsB,KAAtBA,UAAUX,UAAY,KAAZA;oBAC5DgD,QAAQvD,QAAQwD,WAAW,CAACpD,QAAQC,MAAMiD;oBAChDG,IAAAA,yBAAc,EAACpD,MAAMkD;oBACrB;;wBAAO;4BAAEA,OAAAA;4BAAOxD,KAAKuD;4BAAanD,QAAAA;4BAAQc,QAAAA;4BAAQC,UAAAA;4BAAUX,SAAAA;wBAAQ;;;;IACtE;;AAEO,SAAeZ,SAAS4D,KAAY;;YACnCG;;;;oBAAO;;wBAAMH,MAAMI,OAAO,CAAC;;;oBAA3BD,OAAO;oBACJ;;wBAAMA,KAAKE,GAAG;;;oBAAvB;;wBAAS,cAAoCC,CAAC;;;;IAChD"}

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

@@ -1,6 +1,7 @@
 import type { Config } from '../config/index.js';
+import type { ParsePool } from '../scan/pool.js';
 import type { Connection, ReconcileDialect } from './types.js';
-export declare function reconcile(conn: Connection, cfg: Config, baseDir: string, dialect: ReconcileDialect): Promise<{
+export declare function reconcile(conn: Connection, cfg: Config, baseDir: string, dialect: ReconcileDialect, pool?: ParsePool): Promise<{
     parsed: number;
     warnings: string[];
 }>;

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

@@ -1,6 +1,7 @@
 import type { Config } from '../config/index.js';
+import type { ParsePool } from '../scan/pool.js';
 import type { Connection, ReconcileDialect } from './types.js';
-export declare function reconcile(conn: Connection, cfg: Config, baseDir: string, dialect: ReconcileDialect): Promise<{
+export declare function reconcile(conn: Connection, cfg: Config, baseDir: string, dialect: ReconcileDialect, pool?: ParsePool): Promise<{
     parsed: number;
     warnings: string[];
 }>;

package/dist/cjs/store/reconcile.js

@@ -200,7 +200,7 @@ var CORE_FRONTMATTER_COLUMNS = new Set([
     '_size',
     '_parse_error'
 ]);
-function reconcile(conn, cfg, baseDir, dialect) {
+function reconcile(conn, cfg, baseDir, dialect, pool) {
     return _async_to_generator(function() {
         var files, currentSet, existingStmt, existingRows, existing, vanished, toReparse, features, seenColumns, report, _ref, parsedDocs, warnings, newColumns, _iteratorNormalCompletion, _didIteratorError, _iteratorError, _iterator, _step, col, allColumns, writableColumns, insertSql, added, delta, addedSet, reparsedExisting, touched, txStart, durationMs;
         return _ts_generator(this, function(_state) {
@@ -256,7 +256,9 @@ function reconcile(conn, cfg, baseDir, dialect) {
                     report = (0, _progressts.progress)('reparsing files', toReparse.length);
                     return [
                         4,
-                        (0, _reparsets.reparseFiles)(toReparse, features, cfg, seenColumns, report.tick)
+                        (0, _reparsets.reparseFiles)(toReparse, features, cfg, seenColumns, report.tick, {
+                            pool: pool
+                        })
                     ];
                 case 4:
                     _ref = _state.sent(), parsedDocs = _ref.docs, warnings = _ref.warnings, newColumns = _ref.newColumns;

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

@@ -1 +1 @@
-{"version":3,"sources":["/Users/kevin/Dev/OpenSource/ai/sensemaking/src/store/reconcile.ts"],"sourcesContent":["import type { Config } from '../config/index.ts';\nimport { activeFeatures } from '../features/index.ts';\nimport type { ExtractedDoc, ReconcileDelta } from '../features/types.ts';\nimport { progress } from '../output/progress.ts';\nimport { listFiles, RESERVED_COLUMNS } from '../scan/index.ts';\nimport { reparseFiles } from '../scan/reparse.ts';\nimport { getColumns, quoteIdent } from './shared.ts';\nimport { withTransaction } from './transaction.ts';\nimport type { Connection, ReconcileDialect } from './types.ts';\n\n// One reconcile algorithm shared by every store, parameterised by a per-engine ReconcileDialect\n// (types.ts). Ordering is universal, not a dialect concern: ALTER, then the frontmatter upsert,\n// then reconcileContent, then preset_files, then the vanished-frontmatter delete, then feature hooks\n// -- a vanished path's content delete (inside reconcileContent) must precede its frontmatter\n// delete, since sqlite's delete SQL resolves the row via its frontmatter rowid.\n\n// Feature-owned columns (`_rank`) must stay out of the upsert: a reparse would null the last\n// computed value on every touch, not just the reconciles that recompute it.\nconst CORE_FRONTMATTER_COLUMNS = new Set(['path', '_mtime', '_ctime', '_size', '_parse_error']);\n\nexport async function reconcile(conn: Connection, cfg: Config, baseDir: string, dialect: ReconcileDialect): Promise<{ parsed: number; warnings: string[] }> {\n  const files = listFiles(cfg, baseDir);\n  const currentSet = new Set(files.map((f) => f.relPath));\n\n  const existingStmt = await conn.prepare('SELECT \"path\", \"_mtime\", \"_size\" FROM frontmatter');\n  const existingRows = (await existingStmt.all()) as Array<{ path: string; _mtime: number; _size: number }>;\n  const existing = new Map(existingRows.map((r) => [r.path, r]));\n  const vanished = existingRows.filter((r) => !currentSet.has(r.path)).map((r) => r.path);\n\n  const toReparse = files.filter((f) => {\n    const row = existing.get(f.relPath);\n    return !row || row._mtime !== f.mtimeMs || row._size !== f.size;\n  });\n\n  if (vanished.length === 0 && toReparse.length === 0) return { parsed: 0, warnings: [] };\n\n  const features = activeFeatures(cfg);\n  const seenColumns = await getColumns(conn);\n\n  // Bulk reparses (a sync, a cold build) are the long silences a query can hit; short\n  // reconciles stay silent (progress() has a threshold).\n  const report = progress('reparsing files', toReparse.length);\n  const { docs: parsedDocs, warnings, newColumns } = await reparseFiles(toReparse, features, cfg, seenColumns, report.tick);\n  report.finish();\n  for (const col of newColumns) seenColumns.add(col);\n\n  const allColumns = [...seenColumns];\n  // Fence before ALTERing: a store's own failure past this point is a raw, engine-specific\n  // error with no indication of the boundary or the levers -- dialect.checkColumnLimit names both.\n  dialect.checkColumnLimit(allColumns.length);\n  // Columns the frontmatter upsert actually writes: core + parsed frontmatter keys, never a\n  // feature-owned reserved column (see CORE_FRONTMATTER_COLUMNS above).\n  const writableColumns = allColumns.filter((c) => CORE_FRONTMATTER_COLUMNS.has(c) || !RESERVED_COLUMNS.has(c));\n  // ON CONFLICT DO UPDATE (not OR REPLACE) keeps the row's rowid stable across reparses --\n  // sqlite's content rows are coupled to that rowid.\n  const insertSql = `INSERT INTO frontmatter (${writableColumns.map(quoteIdent).join(', ')}) VALUES (${writableColumns.map(() => '?').join(', ')}) ON CONFLICT(\"path\") DO UPDATE SET ${writableColumns\n    .filter((c) => c !== 'path')\n    .map((c) => `${quoteIdent(c)} = excluded.${quoteIdent(c)}`)\n    .join(', ')}`;\n\n  const added = toReparse.filter((f) => !existing.has(f.relPath)).map((f) => f.relPath);\n  const delta: ReconcileDelta = { files, reparsed: parsedDocs.map((d) => d.relPath), added, vanished };\n  const addedSet = new Set(added);\n  const reparsedExisting = parsedDocs.map((d) => d.relPath).filter((p) => !addedSet.has(p));\n  // Paths whose content (and, per feature, other rows) need clearing: gone entirely, or about to\n  // be reinserted fresh. Disjoint from `added`, which has nothing to clear.\n  const touched = [...vanished, ...reparsedExisting];\n\n  const txStart = Date.now();\n  await withTransaction(\n    conn,\n    async () => {\n      // Re-read inside the write transaction: newColumns came from a read taken before it opened, so a\n      // concurrent reconcile may have added some of them since. ALTER has no IF NOT EXISTS.\n      const present = await getColumns(conn);\n      for (const col of newColumns) if (!present.has(col)) await conn.exec(`ALTER TABLE frontmatter ADD COLUMN ${quoteIdent(col)}${dialect.columnTypeSuffix()}`);\n\n      if (parsedDocs.length > 0) {\n        const rows = parsedDocs.map((doc) =>\n          writableColumns.map((col) => {\n            if (col === 'path') return doc.relPath;\n            if (col === '_mtime') return doc.mtimeMs;\n            if (col === '_ctime') return doc.ctimeMs;\n            if (col === '_size') return doc.size;\n            // Written per parse, unlike _rank, which a feature pass owns and the upsert skips.\n            if (col === '_parse_error') return doc.parseError;\n            return doc.data[col] ?? null;\n          })\n        );\n        await conn.runBatch(insertSql, rows);\n      }\n\n      // After the upsert, so every doc already has the frontmatter row sqlite's content rowid\n      // couples to. ON CONFLICT DO UPDATE preserves that rowid, so a reparse keeps its identity.\n      await dialect.reconcileContent(conn, touched, parsedDocs, delta, cfg);\n\n      // A preset edit forces a full rebuild, so an unchanged doc's coverage is already correct;\n      // new docs have nothing to clear, which keeps cold builds linear.\n      if (touched.length > 0)\n        await conn.runBatch(\n          'DELETE FROM preset_files WHERE \"path\" = ?',\n          touched.map((p) => [p])\n        );\n      const presetRows: unknown[][] = [];\n      for (const doc of parsedDocs) for (const presetName of doc.presets) presetRows.push([doc.relPath, presetName]);\n      if (presetRows.length > 0) await conn.runBatch('INSERT INTO preset_files (\"path\", preset) VALUES (?, ?)', presetRows);\n\n      // Before the feature hooks, never after: rank's afterReconcile reads frontmatter as PageRank's\n      // node set, so a lingering vanished row would dilute rank mass across every surviving note.\n      if (vanished.length > 0)\n        await conn.runBatch(\n          'DELETE FROM frontmatter WHERE \"path\" = ?',\n          vanished.map((p) => [p])\n        );\n\n      if (touched.length > 0) for (const feature of features) await feature.remove?.(conn, touched, delta);\n      for (const feature of features) {\n        const docsForFeature: ExtractedDoc[] = parsedDocs.map((doc) => ({ path: doc.relPath, extracted: doc.extracted[feature.name] }));\n        await feature.store?.(conn, docsForFeature, delta);\n      }\n      for (const feature of features) await feature.afterReconcile?.(conn, delta);\n    },\n    dialect.beginMode()\n  );\n\n  const durationMs = Date.now() - txStart;\n  if (dialect.recordDuration) await dialect.recordDuration(conn, durationMs);\n\n  return { parsed: parsedDocs.length, warnings };\n}\n"],"names":["reconcile","CORE_FRONTMATTER_COLUMNS","Set","conn","cfg","baseDir","dialect","files","currentSet","existingStmt","existingRows","existing","vanished","toReparse","features","seenColumns","report","parsedDocs","warnings","newColumns","col","allColumns","writableColumns","insertSql","added","delta","addedSet","reparsedExisting","touched","txStart","durationMs","listFiles","map","f","relPath","prepare","all","Map","r","path","filter","has","row","get","_mtime","mtimeMs","_size","size","length","parsed","activeFeatures","getColumns","progress","reparseFiles","tick","docs","finish","add","checkColumnLimit","c","RESERVED_COLUMNS","quoteIdent","join","reparsed","d","p","Date","now","withTransaction","feature","present","rows","presetRows","doc","presetName","exec","columnTypeSuffix","ctimeMs","parseError","data","runBatch","reconcileContent","presets","push","remove","docsForFeature","extracted","name","store","afterReconcile","beginMode","recordDuration"],"mappings":"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"}
+{"version":3,"sources":["/Users/kevin/Dev/OpenSource/ai/sensemaking/src/store/reconcile.ts"],"sourcesContent":["import type { Config } from '../config/index.ts';\nimport { activeFeatures } from '../features/index.ts';\nimport type { ExtractedDoc, ReconcileDelta } from '../features/types.ts';\nimport { progress } from '../output/progress.ts';\nimport { listFiles, RESERVED_COLUMNS } from '../scan/index.ts';\nimport type { ParsePool } from '../scan/pool.ts';\nimport { reparseFiles } from '../scan/reparse.ts';\nimport { getColumns, quoteIdent } from './shared.ts';\nimport { withTransaction } from './transaction.ts';\nimport type { Connection, ReconcileDialect } from './types.ts';\n\n// One reconcile algorithm shared by every store, parameterised by a per-engine ReconcileDialect\n// (types.ts). Ordering is universal, not a dialect concern: ALTER, then the frontmatter upsert,\n// then reconcileContent, then preset_files, then the vanished-frontmatter delete, then feature hooks\n// -- a vanished path's content delete (inside reconcileContent) must precede its frontmatter\n// delete, since sqlite's delete SQL resolves the row via its frontmatter rowid.\n\n// Feature-owned columns (`_rank`) must stay out of the upsert: a reparse would null the last\n// computed value on every touch, not just the reconciles that recompute it.\nconst CORE_FRONTMATTER_COLUMNS = new Set(['path', '_mtime', '_ctime', '_size', '_parse_error']);\n\nexport async function reconcile(conn: Connection, cfg: Config, baseDir: string, dialect: ReconcileDialect, pool?: ParsePool): Promise<{ parsed: number; warnings: string[] }> {\n  const files = listFiles(cfg, baseDir);\n  const currentSet = new Set(files.map((f) => f.relPath));\n\n  const existingStmt = await conn.prepare('SELECT \"path\", \"_mtime\", \"_size\" FROM frontmatter');\n  const existingRows = (await existingStmt.all()) as Array<{ path: string; _mtime: number; _size: number }>;\n  const existing = new Map(existingRows.map((r) => [r.path, r]));\n  const vanished = existingRows.filter((r) => !currentSet.has(r.path)).map((r) => r.path);\n\n  const toReparse = files.filter((f) => {\n    const row = existing.get(f.relPath);\n    return !row || row._mtime !== f.mtimeMs || row._size !== f.size;\n  });\n\n  if (vanished.length === 0 && toReparse.length === 0) return { parsed: 0, warnings: [] };\n\n  const features = activeFeatures(cfg);\n  const seenColumns = await getColumns(conn);\n\n  // Bulk reparses (a sync, a cold build) are the long silences a query can hit; short\n  // reconciles stay silent (progress() has a threshold).\n  const report = progress('reparsing files', toReparse.length);\n  const { docs: parsedDocs, warnings, newColumns } = await reparseFiles(toReparse, features, cfg, seenColumns, report.tick, { pool });\n  report.finish();\n  for (const col of newColumns) seenColumns.add(col);\n\n  const allColumns = [...seenColumns];\n  // Fence before ALTERing: a store's own failure past this point is a raw, engine-specific\n  // error with no indication of the boundary or the levers -- dialect.checkColumnLimit names both.\n  dialect.checkColumnLimit(allColumns.length);\n  // Columns the frontmatter upsert actually writes: core + parsed frontmatter keys, never a\n  // feature-owned reserved column (see CORE_FRONTMATTER_COLUMNS above).\n  const writableColumns = allColumns.filter((c) => CORE_FRONTMATTER_COLUMNS.has(c) || !RESERVED_COLUMNS.has(c));\n  // ON CONFLICT DO UPDATE (not OR REPLACE) keeps the row's rowid stable across reparses --\n  // sqlite's content rows are coupled to that rowid.\n  const insertSql = `INSERT INTO frontmatter (${writableColumns.map(quoteIdent).join(', ')}) VALUES (${writableColumns.map(() => '?').join(', ')}) ON CONFLICT(\"path\") DO UPDATE SET ${writableColumns\n    .filter((c) => c !== 'path')\n    .map((c) => `${quoteIdent(c)} = excluded.${quoteIdent(c)}`)\n    .join(', ')}`;\n\n  const added = toReparse.filter((f) => !existing.has(f.relPath)).map((f) => f.relPath);\n  const delta: ReconcileDelta = { files, reparsed: parsedDocs.map((d) => d.relPath), added, vanished };\n  const addedSet = new Set(added);\n  const reparsedExisting = parsedDocs.map((d) => d.relPath).filter((p) => !addedSet.has(p));\n  // Paths whose content (and, per feature, other rows) need clearing: gone entirely, or about to\n  // be reinserted fresh. Disjoint from `added`, which has nothing to clear.\n  const touched = [...vanished, ...reparsedExisting];\n\n  const txStart = Date.now();\n  await withTransaction(\n    conn,\n    async () => {\n      // Re-read inside the write transaction: newColumns came from a read taken before it opened, so a\n      // concurrent reconcile may have added some of them since. ALTER has no IF NOT EXISTS.\n      const present = await getColumns(conn);\n      for (const col of newColumns) if (!present.has(col)) await conn.exec(`ALTER TABLE frontmatter ADD COLUMN ${quoteIdent(col)}${dialect.columnTypeSuffix()}`);\n\n      if (parsedDocs.length > 0) {\n        const rows = parsedDocs.map((doc) =>\n          writableColumns.map((col) => {\n            if (col === 'path') return doc.relPath;\n            if (col === '_mtime') return doc.mtimeMs;\n            if (col === '_ctime') return doc.ctimeMs;\n            if (col === '_size') return doc.size;\n            // Written per parse, unlike _rank, which a feature pass owns and the upsert skips.\n            if (col === '_parse_error') return doc.parseError;\n            return doc.data[col] ?? null;\n          })\n        );\n        await conn.runBatch(insertSql, rows);\n      }\n\n      // After the upsert, so every doc already has the frontmatter row sqlite's content rowid\n      // couples to. ON CONFLICT DO UPDATE preserves that rowid, so a reparse keeps its identity.\n      await dialect.reconcileContent(conn, touched, parsedDocs, delta, cfg);\n\n      // A preset edit forces a full rebuild, so an unchanged doc's coverage is already correct;\n      // new docs have nothing to clear, which keeps cold builds linear.\n      if (touched.length > 0)\n        await conn.runBatch(\n          'DELETE FROM preset_files WHERE \"path\" = ?',\n          touched.map((p) => [p])\n        );\n      const presetRows: unknown[][] = [];\n      for (const doc of parsedDocs) for (const presetName of doc.presets) presetRows.push([doc.relPath, presetName]);\n      if (presetRows.length > 0) await conn.runBatch('INSERT INTO preset_files (\"path\", preset) VALUES (?, ?)', presetRows);\n\n      // Before the feature hooks, never after: rank's afterReconcile reads frontmatter as PageRank's\n      // node set, so a lingering vanished row would dilute rank mass across every surviving note.\n      if (vanished.length > 0)\n        await conn.runBatch(\n          'DELETE FROM frontmatter WHERE \"path\" = ?',\n          vanished.map((p) => [p])\n        );\n\n      if (touched.length > 0) for (const feature of features) await feature.remove?.(conn, touched, delta);\n      for (const feature of features) {\n        const docsForFeature: ExtractedDoc[] = parsedDocs.map((doc) => ({ path: doc.relPath, extracted: doc.extracted[feature.name] }));\n        await feature.store?.(conn, docsForFeature, delta);\n      }\n      for (const feature of features) await feature.afterReconcile?.(conn, delta);\n    },\n    dialect.beginMode()\n  );\n\n  const durationMs = Date.now() - txStart;\n  if (dialect.recordDuration) await dialect.recordDuration(conn, durationMs);\n\n  return { parsed: parsedDocs.length, warnings };\n}\n"],"names":["reconcile","CORE_FRONTMATTER_COLUMNS","Set","conn","cfg","baseDir","dialect","pool","files","currentSet","existingStmt","existingRows","existing","vanished","toReparse","features","seenColumns","report","parsedDocs","warnings","newColumns","col","allColumns","writableColumns","insertSql","added","delta","addedSet","reparsedExisting","touched","txStart","durationMs","listFiles","map","f","relPath","prepare","all","Map","r","path","filter","has","row","get","_mtime","mtimeMs","_size","size","length","parsed","activeFeatures","getColumns","progress","reparseFiles","tick","docs","finish","add","checkColumnLimit","c","RESERVED_COLUMNS","quoteIdent","join","reparsed","d","p","Date","now","withTransaction","feature","present","rows","presetRows","doc","presetName","exec","columnTypeSuffix","ctimeMs","parseError","data","runBatch","reconcileContent","presets","push","remove","docsForFeature","extracted","name","store","afterReconcile","beginMode","recordDuration"],"mappings":"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"}