sensemaking 0.19.1 → 0.20.0

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

@@ -0,0 +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 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":";;;;+BAqBsBA;;;eAAAA;;;uBApBS;0BAEN;wBACmB;yBAEf;wBACU;6BACP;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAGhC,gGAAgG;AAChG,gGAAgG;AAChG,qGAAqG;AACrG,6FAA6F;AAC7F,gFAAgF;AAEhF,6FAA6F;AAC7F,4EAA4E;AAC5E,IAAMC,2BAA2B,IAAIC,IAAI;IAAC;IAAQ;IAAU;IAAU;IAAS;CAAe;AAEvF,SAAeF,UAAUG,IAAgB,EAAEC,GAAW,EAAEC,OAAe,EAAEC,OAAyB,EAAEC,IAAgB;;YACnHC,OACAC,YAEAC,cACAC,cACAC,UACAC,UAEAC,WAOAC,UACAC,aAIAC,QAC6C,MAArCC,YAAYC,UAAUC,YAE/B,2BAAA,mBAAA,gBAAA,WAAA,OAAMC,KAELC,YAMAC,iBAGAC,WAKAC,OACAC,OACAC,UACAC,kBAGAC,SAEAC,SAyDAC;;;;oBAxGAvB,QAAQwB,IAAAA,mBAAS,EAAC5B,KAAKC;oBACvBI,aAAa,IAAIP,IAAIM,MAAMyB,GAAG,CAAC,SAACC;+BAAMA,EAAEC,OAAO;;oBAEhC;;wBAAMhC,KAAKiC,OAAO,CAAC;;;oBAAlC1B,eAAe;oBACC;;wBAAMA,aAAa2B,GAAG;;;oBAAtC1B,eAAgB;oBAChBC,WAAW,IAAI0B,IAAI3B,aAAasB,GAAG,CAAC,SAACM;+BAAM;4BAACA,EAAEC,IAAI;4BAAED;yBAAE;;oBACtD1B,WAAWF,aAAa8B,MAAM,CAAC,SAACF;+BAAM,CAAC9B,WAAWiC,GAAG,CAACH,EAAEC,IAAI;uBAAGP,GAAG,CAAC,SAACM;+BAAMA,EAAEC,IAAI;;oBAEhF1B,YAAYN,MAAMiC,MAAM,CAAC,SAACP;wBAC9B,IAAMS,MAAM/B,SAASgC,GAAG,CAACV,EAAEC,OAAO;wBAClC,OAAO,CAACQ,OAAOA,IAAIE,MAAM,KAAKX,EAAEY,OAAO,IAAIH,IAAII,KAAK,KAAKb,EAAEc,IAAI;oBACjE;oBAEA,IAAInC,SAASoC,MAAM,KAAK,KAAKnC,UAAUmC,MAAM,KAAK,GAAG;;wBAAO;4BAAEC,QAAQ;4BAAG/B,QAAQ;wBAAK;;oBAEhFJ,WAAWoC,IAAAA,uBAAc,EAAC/C;oBACZ;;wBAAMgD,IAAAA,oBAAU,EAACjD;;;oBAA/Ba,cAAc;oBAEpB,oFAAoF;oBACpF,uDAAuD;oBACjDC,SAASoC,IAAAA,oBAAQ,EAAC,mBAAmBvC,UAAUmC,MAAM;oBACR;;wBAAMK,IAAAA,uBAAY,EAACxC,WAAWC,UAAUX,KAAKY,aAAaC,OAAOsC,IAAI,EAAE;4BAAEhD,MAAAA;wBAAK;;;oBAA9E,OAAA,eAArCW,aAAqC,KAA3CsC,MAAkBrC,WAAyB,KAAzBA,UAAUC,aAAe,KAAfA;oBACpCH,OAAOwC,MAAM;oBACR,kCAAA,2BAAA;;wBAAL,IAAK,YAAarC,iCAAb,6BAAA,QAAA,yBAAA;4BAAMC,MAAN;4BAAyBL,YAAY0C,GAAG,CAACrC;;;wBAAzC;wBAAA;;;iCAAA,6BAAA;gCAAA;;;gCAAA;sCAAA;;;;oBAECC,aAAc,qBAAGN;oBACvB,yFAAyF;oBACzF,iGAAiG;oBACjGV,QAAQqD,gBAAgB,CAACrC,WAAW2B,MAAM;oBAC1C,0FAA0F;oBAC1F,sEAAsE;oBAChE1B,kBAAkBD,WAAWmB,MAAM,CAAC,SAACmB;+BAAM3D,yBAAyByC,GAAG,CAACkB,MAAM,CAACC,0BAAgB,CAACnB,GAAG,CAACkB;;oBAC1G,yFAAyF;oBACzF,mDAAmD;oBAC7CpC,YAAY,AAAC,4BAAkFD,OAAvDA,gBAAgBU,GAAG,CAAC6B,oBAAU,EAAEC,IAAI,CAAC,OAAM,cAA4FxC,OAAhFA,gBAAgBU,GAAG,CAAC;+BAAM;uBAAK8B,IAAI,CAAC,OAAM,wCAGjI,OAHuKxC,gBAClLkB,MAAM,CAAC,SAACmB;+BAAMA,MAAM;uBACpB3B,GAAG,CAAC,SAAC2B;+BAAM,AAAC,GAA8BE,OAA5BA,IAAAA,oBAAU,EAACF,IAAG,gBAA4B,OAAdE,IAAAA,oBAAU,EAACF;uBACrDG,IAAI,CAAC;oBAEFtC,QAAQX,UAAU2B,MAAM,CAAC,SAACP;+BAAM,CAACtB,SAAS8B,GAAG,CAACR,EAAEC,OAAO;uBAAGF,GAAG,CAAC,SAACC;+BAAMA,EAAEC,OAAO;;oBAC9ET,QAAwB;wBAAElB,OAAAA;wBAAOwD,UAAU9C,WAAWe,GAAG,CAAC,SAACgC;mCAAMA,EAAE9B,OAAO;;wBAAGV,OAAAA;wBAAOZ,UAAAA;oBAAS;oBAC7Fc,WAAW,IAAIzB,IAAIuB;oBACnBG,mBAAmBV,WAAWe,GAAG,CAAC,SAACgC;+BAAMA,EAAE9B,OAAO;uBAAEM,MAAM,CAAC,SAACyB;+BAAM,CAACvC,SAASe,GAAG,CAACwB;;oBACtF,+FAA+F;oBAC/F,0EAA0E;oBACpErC,UAAU,AAAC,qBAAGhB,iBAAU,qBAAGe;oBAE3BE,UAAUqC,KAAKC,GAAG;oBACxB;;wBAAMC,IAAAA,8BAAe,EACnBlE,MACA;;oCA4CgEmE,iBAKxBA,yBA9ChCC,SACD,2BAAA,mBAAA,gBAAA,WAAA,OAAMlD,UAGHmD,MAyBFC,YAC6B,4BAAA,oBAAA,iBAA9B,4BAAA,oBAAA,iBAAA,YAAA,QAAMC,KAAwB,YAAA,QAAMC,YAWZ,4BAAA,oBAAA,iBAAA,YAAA,QAAML,cAC9B,4BAAA,oBAAA,wBAAA,YAAA,aAIA,4BAAA,oBAAA,iBAAA,YAAA,QAAMA;;;;4CA9CK;;gDAAMlB,IAAAA,oBAAU,EAACjD;;;4CAA3BoE,UAAU;4CACX,kCAAA,2BAAA;;;;;;;;;4CAAA,YAAanD;;;mDAAb,6BAAA,QAAA;;;;4CAAMC,MAAN;iDAA6B,CAACkD,QAAQ7B,GAAG,CAACrB,MAAb;;;;4CAAmB;;gDAAMlB,KAAKyE,IAAI,CAAC,AAAC,sCAAuDtE,OAAlBwD,IAAAA,oBAAU,EAACzC,MAAkC,OAA3Bf,QAAQuE,gBAAgB;;;4CAAhG;;;4CAAhD;;;;;;;;;;;;4CAAA;4CAAA;;;;;;;qDAAA,6BAAA;oDAAA;;;oDAAA;0DAAA;;;;;;;iDAED3D,CAAAA,WAAW+B,MAAM,GAAG,CAAA,GAApB/B;;;;4CACIsD,OAAOtD,WAAWe,GAAG,CAAC,SAACyC;uDAC3BnD,gBAAgBU,GAAG,CAAC,SAACZ;wDAOZqD;oDANP,IAAIrD,QAAQ,QAAQ,OAAOqD,IAAIvC,OAAO;oDACtC,IAAId,QAAQ,UAAU,OAAOqD,IAAI5B,OAAO;oDACxC,IAAIzB,QAAQ,UAAU,OAAOqD,IAAII,OAAO;oDACxC,IAAIzD,QAAQ,SAAS,OAAOqD,IAAI1B,IAAI;oDACpC,mFAAmF;oDACnF,IAAI3B,QAAQ,gBAAgB,OAAOqD,IAAIK,UAAU;oDACjD,QAAOL,gBAAAA,IAAIM,IAAI,CAAC3D,IAAI,cAAbqD,2BAAAA,gBAAiB;gDAC1B;;4CAEF;;gDAAMvE,KAAK8E,QAAQ,CAACzD,WAAWgD;;;4CAA/B;;;4CAGF,wFAAwF;4CACxF,2FAA2F;4CAC3F;;gDAAMlE,QAAQ4E,gBAAgB,CAAC/E,MAAM0B,SAASX,YAAYQ,OAAOtB;;;4CAAjE;iDAIIyB,CAAAA,QAAQoB,MAAM,GAAG,CAAA,GAAjBpB;;;;4CACF;;gDAAM1B,KAAK8E,QAAQ,CACjB,6CACApD,QAAQI,GAAG,CAAC,SAACiC;2DAAM;wDAACA;qDAAE;;;;4CAFxB;;;4CAIIO;4CAC6B,mCAAA,4BAAA,6BAA9B,mCAAA,4BAAA;;gDAAL,IAAK,aAAavD,iCAAb,8BAAA,SAAA,0BAAA;oDAAMwD,MAAN;;wDAAyB,IAAK,aAAoBA,IAAIS,OAAO,uBAA/B,8BAAA,SAAA,0BAAA;4DAAMR,aAAN;4DAAiCF,WAAWW,IAAI;gEAAEV,IAAIvC,OAAO;gEAAEwC;;;;wDAA/D;wDAAA;;;iEAAA,8BAAA;gEAAA;;;gEAAA;sEAAA;;;;;;gDAA9B;gDAAA;;;yDAAA,8BAAA;wDAAA;;;wDAAA;8DAAA;;;;iDACDF,CAAAA,WAAWxB,MAAM,GAAG,CAAA,GAApBwB;;;;4CAAuB;;gDAAMtE,KAAK8E,QAAQ,CAAC,2DAA2DR;;;4CAA/E;;;iDAIvB5D,CAAAA,SAASoC,MAAM,GAAG,CAAA,GAAlBpC;;;;4CACF;;gDAAMV,KAAK8E,QAAQ,CACjB,4CACApE,SAASoB,GAAG,CAAC,SAACiC;2DAAM;wDAACA;qDAAE;;;;4CAFzB;;;4CAK2B,mCAAA,4BAAA;iDAAzBrC,CAAAA,QAAQoB,MAAM,GAAG,CAAA,GAAjBpB;;;;;;;;;;;;4CAAyB,aAAiBd;;;mDAAjB,8BAAA,SAAA;;;;4CAAMuD,UAAN;4CAA2B;;iDAAMA,kBAAAA,QAAQe,MAAM,cAAdf,sCAAAA,qBAAAA,SAAiBnE,MAAM0B,SAASH;;;4CAAtC;;;4CAA3B;;;;;;;;;;;;4CAAA;4CAAA;;;;;;;qDAAA,8BAAA;oDAAA;;;oDAAA;0DAAA;;;;;;;4CACxB,mCAAA,4BAAA;;;;;;;;;;oDAAM4C,SAEHA,gBADAgB;;;;4DADGhB,UAAN;4DACGgB,iBAAiCpE,WAAWe,GAAG,CAAC,SAACyC;uEAAS;oEAAElC,MAAMkC,IAAIvC,OAAO;oEAAEoD,WAAWb,IAAIa,SAAS,CAACjB,QAAQkB,IAAI,CAAC;gEAAC;;4DAC5H;;iEAAMlB,iBAAAA,QAAQmB,KAAK,cAAbnB,qCAAAA,oBAAAA,SAAgBnE,MAAMmF,gBAAgB5D;;;4DAA5C;;;;;;4CACF;4CAHK,aAAiBX;;;mDAAjB,8BAAA,SAAA;;;;;;;;;;;;4CAAA;;;;;;;;;;;;4CAAA;4CAAA;;;;;;;qDAAA,8BAAA;oDAAA;;;oDAAA;0DAAA;;;;;;;4CAIA,mCAAA,4BAAA;;;;;;;;;4CAAA,aAAiBA;;;mDAAjB,8BAAA,SAAA;;;;4CAAMuD,WAAN;4CAA2B;;iDAAMA,0BAAAA,SAAQoB,cAAc,cAAtBpB,8CAAAA,6BAAAA,UAAyBnE,MAAMuB;;;4CAArC;;;4CAA3B;;;;;;;;;;;;4CAAA;4CAAA;;;;;;;qDAAA,8BAAA;oDAAA;;;oDAAA;0DAAA;;;;;;;;;;;;4BACP;2BACApB,QAAQqF,SAAS;;;oBArDnB;oBAwDM5D,aAAaoC,KAAKC,GAAG,KAAKtC;yBAC5BxB,QAAQsF,cAAc,EAAtBtF;;;;oBAAwB;;wBAAMA,QAAQsF,cAAc,CAACzF,MAAM4B;;;oBAAnC;;;oBAE5B;;wBAAO;4BAAEmB,QAAQhC,WAAW+B,MAAM;4BAAE9B,UAAAA;wBAAS;;;;IAC/C"}

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

@@ -3,3 +3,4 @@ export declare function quoteIdent(name: string): string;
 export declare function getColumns(conn: Connection): Promise<Set<string>>;
 export declare function getMeta(conn: Connection, key: string): Promise<string | null>;
 export declare function setMeta(conn: Connection, key: string, value: string | null): Promise<void>;
+export declare function recordReconcileDuration(conn: Connection, ms: number): Promise<void>;

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

@@ -3,3 +3,4 @@ export declare function quoteIdent(name: string): string;
 export declare function getColumns(conn: Connection): Promise<Set<string>>;
 export declare function getMeta(conn: Connection, key: string): Promise<string | null>;
 export declare function setMeta(conn: Connection, key: string, value: string | null): Promise<void>;
+export declare function recordReconcileDuration(conn: Connection, ms: number): Promise<void>;

package/dist/cjs/store/shared.js

@@ -18,6 +18,9 @@ _export(exports, {
     get quoteIdent () {
         return quoteIdent;
     },
+    get recordReconcileDuration () {
+        return recordReconcileDuration;
+    },
     get setMeta () {
         return setMeta;
     }
@@ -249,4 +252,38 @@ function setMeta(conn, key, value) {
         });
     })();
 }
+function recordReconcileDuration(conn, ms) {
+    return _async_to_generator(function() {
+        var prevRaw, prevMax;
+        return _ts_generator(this, function(_state) {
+            switch(_state.label){
+                case 0:
+                    return [
+                        4,
+                        getMeta(conn, 'reconcile_max_ms')
+                    ];
+                case 1:
+                    prevRaw = _state.sent();
+                    // -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.
+                    prevMax = prevRaw === null ? -1 : Number(prevRaw);
+                    if (!(ms > prevMax)) return [
+                        3,
+                        3
+                    ];
+                    return [
+                        4,
+                        setMeta(conn, 'reconcile_max_ms', String(ms))
+                    ];
+                case 2:
+                    _state.sent();
+                    _state.label = 3;
+                case 3:
+                    return [
+                        2
+                    ];
+            }
+        });
+    })();
+}
 /* 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/shared.js.map

@@ -1 +1 @@
-{"version":3,"sources":["/Users/kevin/Dev/OpenSource/ai/sensemaking/src/store/shared.ts"],"sourcesContent":["import type { Connection } from './types.ts';\n\n// SQL and meta-table primitives both stores' open()/reconcile() need. Engine-neutral: both\n// stores' Connection satisfies the same async exec/prepare/runBatch shape (types.ts).\n\nexport function quoteIdent(name: string): string {\n  return `\"${name.split('\"').join('\"\"')}\"`;\n}\n\nexport async function getColumns(conn: Connection): Promise<Set<string>> {\n  const stmt = await conn.prepare('PRAGMA table_info(frontmatter)');\n  const rows = (await stmt.all()) as Array<{ name: string }>;\n  return new Set(rows.map((r) => r.name));\n}\n\nexport async function getMeta(conn: Connection, key: string): Promise<string | null> {\n  const stmt = await conn.prepare('SELECT value FROM meta WHERE key = ?');\n  const row = (await stmt.get(key)) as { value: string } | undefined;\n  return row ? row.value : null;\n}\n\nexport async function setMeta(conn: Connection, key: string, value: string | null): Promise<void> {\n  if (value === null) {\n    const stmt = await conn.prepare('DELETE FROM meta WHERE key = ?');\n    await stmt.run(key);\n    return;\n  }\n  const stmt = await conn.prepare('INSERT INTO meta (key, value) VALUES (?, ?) ON CONFLICT(key) DO UPDATE SET value = excluded.value');\n  await stmt.run(key, value);\n}\n"],"names":["getColumns","getMeta","quoteIdent","setMeta","name","split","join","conn","stmt","rows","prepare","all","Set","map","r","key","row","get","value","run"],"mappings":";;;;;;;;;;;QASsBA;eAAAA;;QAMAC;eAAAA;;QAVNC;eAAAA;;QAgBMC;eAAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAhBf,SAASD,WAAWE,IAAY;IACrC,OAAO,AAAC,IAA8B,OAA3BA,KAAKC,KAAK,CAAC,KAAKC,IAAI,CAAC,OAAM;AACxC;AAEO,SAAeN,WAAWO,IAAgB;;YACzCC,MACAC;;;;oBADO;;wBAAMF,KAAKG,OAAO,CAAC;;;oBAA1BF,OAAO;oBACC;;wBAAMA,KAAKG,GAAG;;;oBAAtBF,OAAQ;oBACd;;wBAAO,IAAIG,IAAIH,KAAKI,GAAG,CAAC,SAACC;mCAAMA,EAAEV,IAAI;;;;;IACvC;;AAEO,SAAeH,QAAQM,IAAgB,EAAEQ,GAAW;;YACnDP,MACAQ;;;;oBADO;;wBAAMT,KAAKG,OAAO,CAAC;;;oBAA1BF,OAAO;oBACA;;wBAAMA,KAAKS,GAAG,CAACF;;;oBAAtBC,MAAO;oBACb;;wBAAOA,MAAMA,IAAIE,KAAK,GAAG;;;;IAC3B;;AAEO,SAAef,QAAQI,IAAgB,EAAEQ,GAAW,EAAEG,KAAoB;;YAEvEV,MAIFA;;;;yBALFU,CAAAA,UAAU,IAAG,GAAbA;;;;oBACW;;wBAAMX,KAAKG,OAAO,CAAC;;;oBAA1BF,OAAO;oBACb;;wBAAMA,KAAKW,GAAG,CAACJ;;;oBAAf;oBACA;;;;oBAEW;;wBAAMR,KAAKG,OAAO,CAAC;;;oBAA1BF,QAAO;oBACb;;wBAAMA,MAAKW,GAAG,CAACJ,KAAKG;;;oBAApB;;;;;;IACF"}
+{"version":3,"sources":["/Users/kevin/Dev/OpenSource/ai/sensemaking/src/store/shared.ts"],"sourcesContent":["import type { Connection } from './types.ts';\n\n// SQL and meta-table primitives both stores' open()/reconcile() need. Engine-neutral: both\n// stores' Connection satisfies the same async exec/prepare/runBatch shape (types.ts).\n\nexport function quoteIdent(name: string): string {\n  return `\"${name.split('\"').join('\"\"')}\"`;\n}\n\nexport async function getColumns(conn: Connection): Promise<Set<string>> {\n  const stmt = await conn.prepare('PRAGMA table_info(frontmatter)');\n  const rows = (await stmt.all()) as Array<{ name: string }>;\n  return new Set(rows.map((r) => r.name));\n}\n\nexport async function getMeta(conn: Connection, key: string): Promise<string | null> {\n  const stmt = await conn.prepare('SELECT value FROM meta WHERE key = ?');\n  const row = (await stmt.get(key)) as { value: string } | undefined;\n  return row ? row.value : null;\n}\n\nexport async function setMeta(conn: Connection, key: string, value: string | null): Promise<void> {\n  if (value === null) {\n    const stmt = await conn.prepare('DELETE FROM meta WHERE key = ?');\n    await stmt.run(key);\n    return;\n  }\n  const stmt = await conn.prepare('INSERT INTO meta (key, value) VALUES (?, ?) ON CONFLICT(key) DO UPDATE SET value = excluded.value');\n  await stmt.run(key, value);\n}\n\n// Reconcile's own write-transaction duration, for open()'s derived busy_timeout: keep the\n// observed max so a big watcher reconcile's lock hold is what the next open bounds its wait against.\nexport async function recordReconcileDuration(conn: Connection, ms: number): Promise<void> {\n  const prevRaw = await getMeta(conn, 'reconcile_max_ms');\n  // -1, not 0, so a genuinely 0ms first reconcile (sub-millisecond, common on a tiny tree)\n  // still gets recorded instead of losing to the \"nothing recorded yet\" default.\n  const prevMax = prevRaw === null ? -1 : Number(prevRaw);\n  if (ms > prevMax) await setMeta(conn, 'reconcile_max_ms', String(ms));\n}\n"],"names":["getColumns","getMeta","quoteIdent","recordReconcileDuration","setMeta","name","split","join","conn","stmt","rows","prepare","all","Set","map","r","key","row","get","value","run","ms","prevRaw","prevMax","Number","String"],"mappings":";;;;;;;;;;;QASsBA;eAAAA;;QAMAC;eAAAA;;QAVNC;eAAAA;;QA4BMC;eAAAA;;QAZAC;eAAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAhBf,SAASF,WAAWG,IAAY;IACrC,OAAO,AAAC,IAA8B,OAA3BA,KAAKC,KAAK,CAAC,KAAKC,IAAI,CAAC,OAAM;AACxC;AAEO,SAAeP,WAAWQ,IAAgB;;YACzCC,MACAC;;;;oBADO;;wBAAMF,KAAKG,OAAO,CAAC;;;oBAA1BF,OAAO;oBACC;;wBAAMA,KAAKG,GAAG;;;oBAAtBF,OAAQ;oBACd;;wBAAO,IAAIG,IAAIH,KAAKI,GAAG,CAAC,SAACC;mCAAMA,EAAEV,IAAI;;;;;IACvC;;AAEO,SAAeJ,QAAQO,IAAgB,EAAEQ,GAAW;;YACnDP,MACAQ;;;;oBADO;;wBAAMT,KAAKG,OAAO,CAAC;;;oBAA1BF,OAAO;oBACA;;wBAAMA,KAAKS,GAAG,CAACF;;;oBAAtBC,MAAO;oBACb;;wBAAOA,MAAMA,IAAIE,KAAK,GAAG;;;;IAC3B;;AAEO,SAAef,QAAQI,IAAgB,EAAEQ,GAAW,EAAEG,KAAoB;;YAEvEV,MAIFA;;;;yBALFU,CAAAA,UAAU,IAAG,GAAbA;;;;oBACW;;wBAAMX,KAAKG,OAAO,CAAC;;;oBAA1BF,OAAO;oBACb;;wBAAMA,KAAKW,GAAG,CAACJ;;;oBAAf;oBACA;;;;oBAEW;;wBAAMR,KAAKG,OAAO,CAAC;;;oBAA1BF,QAAO;oBACb;;wBAAMA,MAAKW,GAAG,CAACJ,KAAKG;;;oBAApB;;;;;;IACF;;AAIO,SAAehB,wBAAwBK,IAAgB,EAAEa,EAAU;;YAClEC,SAGAC;;;;oBAHU;;wBAAMtB,QAAQO,MAAM;;;oBAA9Bc,UAAU;oBAChB,yFAAyF;oBACzF,+EAA+E;oBACzEC,UAAUD,YAAY,OAAO,CAAC,IAAIE,OAAOF;yBAC3CD,CAAAA,KAAKE,OAAM,GAAXF;;;;oBAAc;;wBAAMjB,QAAQI,MAAM,oBAAoBiB,OAAOJ;;;oBAA/C;;;;;;;;IACpB"}

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

@@ -0,0 +1,3 @@
+export declare function changedSignatureKeys(before: string, after: string): Set<string>;
+export declare function embedIdentityAdopted(before: string, after: string): boolean;
+export declare function signatureDiff(before: string, after: string): string;

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

@@ -0,0 +1,3 @@
+export declare function changedSignatureKeys(before: string, after: string): Set<string>;
+export declare function embedIdentityAdopted(before: string, after: string): boolean;
+export declare function signatureDiff(before: string, after: string): string;

package/dist/cjs/store/signature.js

@@ -0,0 +1,162 @@
+// Feature-signature comparison for open()'s rebuild-vs-adopt decision (config.featureSignature's
+// format: global features, embed provider, tokenize, then one segment per preset). Pure string
+// comparison, no SQL, shared by every store's open dialect.
+// Segment keys that moved between two feature signatures.
+"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 changedSignatureKeys () {
+        return changedSignatureKeys;
+    },
+    get embedIdentityAdopted () {
+        return embedIdentityAdopted;
+    },
+    get signatureDiff () {
+        return signatureDiff;
+    }
+});
+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();
+}
+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 changedSignatureKeys(before, after) {
+    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;
+            }
+        }
+    }
+    return changed;
+}
+function embedIdentityAdopted(before, after) {
+    var embedPart = function embedPart(sig) {
+        return sig.split('|').find(function(p) {
+            return p.startsWith('embed:');
+        });
+    };
+    var b = embedPart(before);
+    var a = embedPart(after);
+    if (b === undefined || a === undefined) return false;
+    var at = a.indexOf('@');
+    return b.indexOf('@') === -1 && at !== -1 && a.slice(0, at) === b;
+}
+function signatureDiff(before, after) {
+    var changed = changedSignatureKeys(before, after);
+    var label = function label(key) {
+        return key === 'embed' ? 'embed settings' : key === 'tokenize' ? 'content tokenizer' : key.startsWith('preset:') ? 'preset "'.concat(key.slice(7), '"') : 'features';
+    };
+    return changed.size === 0 ? 'features' : _to_consumable_array(changed).map(label).join(', ');
+}
+/* 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/signature.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["/Users/kevin/Dev/OpenSource/ai/sensemaking/src/store/signature.ts"],"sourcesContent":["// Feature-signature comparison for open()'s rebuild-vs-adopt decision (config.featureSignature's\n// format: global features, embed provider, tokenize, then one segment per preset). Pure string\n// comparison, no SQL, shared by every store's open dialect.\n\n// Segment keys that moved between two feature signatures.\nexport function changedSignatureKeys(before: string, after: string): Set<string> {\n  const keyOf = (part: string) => (part.startsWith('preset:') ? part.split(':').slice(0, 2).join(':') : part.split(':')[0]);\n  const parse = (sig: string) => new Map(sig.split('|').map((part) => [keyOf(part), part]));\n  const a = parse(before);\n  const b = parse(after);\n  const changed = new Set<string>();\n  for (const [key, val] of b) if (a.get(key) !== val) changed.add(key);\n  for (const key of a.keys()) if (!b.has(key)) changed.add(key);\n  return changed;\n}\n\n// Whether the embed segment only gained its resolved weight identity: same provider and\n// model, no identity recorded before, one now -- adopted into meta without a rebuild.\nexport function embedIdentityAdopted(before: string, after: string): boolean {\n  const embedPart = (sig: string) => sig.split('|').find((p) => p.startsWith('embed:'));\n  const b = embedPart(before);\n  const a = embedPart(after);\n  if (b === undefined || a === undefined) return false;\n  const at = a.indexOf('@');\n  return b.indexOf('@') === -1 && at !== -1 && a.slice(0, at) === b;\n}\n\n// Names what moved, for the rebuild notice.\nexport function signatureDiff(before: string, after: string): string {\n  const changed = changedSignatureKeys(before, after);\n  const label = (key: string) => (key === 'embed' ? 'embed settings' : key === 'tokenize' ? 'content tokenizer' : key.startsWith('preset:') ? `preset \"${key.slice(7)}\"` : 'features');\n  return changed.size === 0 ? 'features' : [...changed].map(label).join(', ');\n}\n"],"names":["changedSignatureKeys","embedIdentityAdopted","signatureDiff","before","after","keyOf","part","startsWith","split","slice","join","parse","sig","Map","map","a","b","changed","Set","key","val","get","add","keys","has","embedPart","find","p","undefined","at","indexOf","label","size"],"mappings":"AAAA,iGAAiG;AACjG,+FAA+F;AAC/F,4DAA4D;AAE5D,0DAA0D;;;;;;;;;;;;QAC1CA;eAAAA;;QAaAC;eAAAA;;QAUAC;eAAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAvBT,SAASF,qBAAqBG,MAAc,EAAEC,KAAa;IAChE,IAAMC,QAAQ,eAACC;eAAkBA,KAAKC,UAAU,CAAC,aAAaD,KAAKE,KAAK,CAAC,KAAKC,KAAK,CAAC,GAAG,GAAGC,IAAI,CAAC,OAAOJ,KAAKE,KAAK,CAAC,IAAI,CAAC,EAAE;;IACxH,IAAMG,QAAQ,eAACC;eAAgB,IAAIC,IAAID,IAAIJ,KAAK,CAAC,KAAKM,GAAG,CAAC,SAACR;mBAAS;gBAACD,MAAMC;gBAAOA;aAAK;;;IACvF,IAAMS,IAAIJ,MAAMR;IAChB,IAAMa,IAAIL,MAAMP;IAChB,IAAMa,UAAU,IAAIC;QACf,kCAAA,2BAAA;;QAAL,QAAK,YAAoBF,sBAApB,SAAA,6BAAA,QAAA,yBAAA;YAAA,mCAAA,iBAAOG,sBAAKC;YAAW,IAAIL,EAAEM,GAAG,CAACF,SAASC,KAAKH,QAAQK,GAAG,CAACH;;;QAA3D;QAAA;;;iBAAA,6BAAA;gBAAA;;;gBAAA;sBAAA;;;;QACA,mCAAA,4BAAA;;QAAL,QAAK,aAAaJ,EAAEQ,IAAI,uBAAnB,UAAA,8BAAA,SAAA,0BAAA;YAAA,IAAMJ,OAAN;YAAuB,IAAI,CAACH,EAAEQ,GAAG,CAACL,OAAMF,QAAQK,GAAG,CAACH;;;QAApD;QAAA;;;iBAAA,8BAAA;gBAAA;;;gBAAA;sBAAA;;;;IACL,OAAOF;AACT;AAIO,SAAShB,qBAAqBE,MAAc,EAAEC,KAAa;IAChE,IAAMqB,YAAY,mBAACb;eAAgBA,IAAIJ,KAAK,CAAC,KAAKkB,IAAI,CAAC,SAACC;mBAAMA,EAAEpB,UAAU,CAAC;;;IAC3E,IAAMS,IAAIS,UAAUtB;IACpB,IAAMY,IAAIU,UAAUrB;IACpB,IAAIY,MAAMY,aAAab,MAAMa,WAAW,OAAO;IAC/C,IAAMC,KAAKd,EAAEe,OAAO,CAAC;IACrB,OAAOd,EAAEc,OAAO,CAAC,SAAS,CAAC,KAAKD,OAAO,CAAC,KAAKd,EAAEN,KAAK,CAAC,GAAGoB,QAAQb;AAClE;AAGO,SAASd,cAAcC,MAAc,EAAEC,KAAa;IACzD,IAAMa,UAAUjB,qBAAqBG,QAAQC;IAC7C,IAAM2B,QAAQ,eAACZ;eAAiBA,QAAQ,UAAU,mBAAmBA,QAAQ,aAAa,sBAAsBA,IAAIZ,UAAU,CAAC,aAAa,AAAC,WAAuB,OAAbY,IAAIV,KAAK,CAAC,IAAG,OAAK;;IACzK,OAAOQ,QAAQe,IAAI,KAAK,IAAI,aAAa,AAAC,qBAAGf,SAASH,GAAG,CAACiB,OAAOrB,IAAI,CAAC;AACxE"}

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

@@ -1,13 +1,13 @@
+import { DatabaseSync } from 'node:sqlite';
 import type { ResolvedConfig } from '../../config/index.js';
-import type { Store } from '../types.js';
+import type { OpenResult } from '../open.js';
+import type { OpenDialect } from '../types.js';
 export declare const DB_FILENAME = "cache.db";
-export declare const SCHEMA_VERSION = "18";
-export interface OpenResult {
-    store: Store;
-    cfg: ResolvedConfig;
-    dbPath: string;
-    parsed: number;
-    warnings: string[];
+export declare const SCHEMA_VERSION = "19";
+export type { OpenResult };
+interface SqliteHandle {
+    db: DatabaseSync;
+    tokenize: string;
 }
+export declare const sqliteOpenDialect: OpenDialect<SqliteHandle>;
 export declare function openSqlite(cfg: ResolvedConfig): Promise<OpenResult>;
-export declare function docCount(store: Store): Promise<number>;

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

@@ -1,13 +1,13 @@
+import { DatabaseSync } from 'node:sqlite';
 import type { ResolvedConfig } from '../../config/index.js';
-import type { Store } from '../types.js';
+import type { OpenResult } from '../open.js';
+import type { OpenDialect } from '../types.js';
 export declare const DB_FILENAME = "cache.db";
-export declare const SCHEMA_VERSION = "18";
-export interface OpenResult {
-    store: Store;
-    cfg: ResolvedConfig;
-    dbPath: string;
-    parsed: number;
-    warnings: string[];
+export declare const SCHEMA_VERSION = "19";
+export type { OpenResult };
+interface SqliteHandle {
+    db: DatabaseSync;
+    tokenize: string;
 }
+export declare const sqliteOpenDialect: OpenDialect<SqliteHandle>;
 export declare function openSqlite(cfg: ResolvedConfig): Promise<OpenResult>;
-export declare function docCount(store: Store): Promise<number>;