sensemaking 0.19.1 → 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":"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"}

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

@@ -0,0 +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, pool?: ParsePool): Promise<{
+    parsed: number;
+    warnings: string[];
+}>;

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

@@ -0,0 +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, pool?: ParsePool): Promise<{
+    parsed: number;
+    warnings: string[];
+}>;