sensemaking 0.19.0 → 0.19.2

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 { 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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"}

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/sqlite/connection.js

@@ -495,7 +495,7 @@ function createConnection(db) {
                                             ];
                                         });
                                     })();
-                                })
+                                }, _transactionts.BEGIN_WRITE)
                             ];
                         case 1:
                             _state.sent();

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

@@ -1 +1 @@
-{"version":3,"sources":["/Users/kevin/Dev/OpenSource/ai/sensemaking/src/store/sqlite/connection.ts"],"sourcesContent":["import type { DatabaseSync, StatementSync } from 'node:sqlite';\nimport { withTransaction } from '../transaction.ts';\nimport type { Connection, RunResult, Statement } from '../types.ts';\n\n// Wraps node:sqlite's synchronous DatabaseSync in the async Connection/Statement shape every store presents. Every method does its real\n// work synchronously and returns an already-resolved promise, so reconcile's loop, the feature hooks, and runBatch never cross an async boundary internally.\nclass SqliteStatement implements Statement {\n  private stmt: StatementSync;\n\n  constructor(stmt: StatementSync) {\n    this.stmt = stmt;\n  }\n\n  async run(...params: unknown[]): Promise<RunResult> {\n    return this.stmt.run(...(params as Parameters<StatementSync['run']>));\n  }\n\n  async get(...params: unknown[]): Promise<unknown> {\n    return this.stmt.get(...(params as Parameters<StatementSync['get']>));\n  }\n\n  async all(...params: unknown[]): Promise<unknown[]> {\n    return this.stmt.all(...(params as Parameters<StatementSync['all']>));\n  }\n\n  async *iterate(...params: unknown[]): AsyncIterable<unknown> {\n    yield* this.stmt.iterate(...(params as Parameters<StatementSync['iterate']>));\n  }\n\n  columns(): Array<{ name: string }> {\n    return this.stmt.columns();\n  }\n\n  setReadBigInts(enabled: boolean): void {\n    this.stmt.setReadBigInts(enabled);\n  }\n}\n\nexport function createConnection(db: DatabaseSync): Connection {\n  const conn: Connection = {\n    async exec(sql: string): Promise<void> {\n      db.exec(sql);\n    },\n    async prepare(sql: string): Promise<Statement> {\n      return new SqliteStatement(db.prepare(sql));\n    },\n    // Prepares once and loops synchronously, wrapped as one async call so features share one\n    // Connection contract with DuckDB. Joins the caller's transaction when there is one (reconcile); otherwise opens its own, so a standalone batch stays atomic and commits once, not per row.\n    async runBatch(sql: string, paramRows: unknown[][]): Promise<void> {\n      if (paramRows.length === 0) return;\n      await withTransaction(conn, async () => {\n        const stmt = db.prepare(sql);\n        for (const row of paramRows) stmt.run(...(row as Parameters<StatementSync['run']>));\n      });\n    },\n  };\n  return conn;\n}\n"],"names":["createConnection","SqliteStatement","stmt","run","params","get","all","iterate","columns","setReadBigInts","enabled","db","conn","exec","sql","prepare","runBatch","paramRows","length","withTransaction","row"],"mappings":"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"}
+{"version":3,"sources":["/Users/kevin/Dev/OpenSource/ai/sensemaking/src/store/sqlite/connection.ts"],"sourcesContent":["import type { DatabaseSync, StatementSync } from 'node:sqlite';\nimport { BEGIN_WRITE, withTransaction } from '../transaction.ts';\nimport type { Connection, RunResult, Statement } from '../types.ts';\n\n// Wraps node:sqlite's synchronous DatabaseSync in the async Connection/Statement shape every store presents. Every method does its real\n// work synchronously and returns an already-resolved promise, so reconcile's loop, the feature hooks, and runBatch never cross an async boundary internally.\nclass SqliteStatement implements Statement {\n  private stmt: StatementSync;\n\n  constructor(stmt: StatementSync) {\n    this.stmt = stmt;\n  }\n\n  async run(...params: unknown[]): Promise<RunResult> {\n    return this.stmt.run(...(params as Parameters<StatementSync['run']>));\n  }\n\n  async get(...params: unknown[]): Promise<unknown> {\n    return this.stmt.get(...(params as Parameters<StatementSync['get']>));\n  }\n\n  async all(...params: unknown[]): Promise<unknown[]> {\n    return this.stmt.all(...(params as Parameters<StatementSync['all']>));\n  }\n\n  async *iterate(...params: unknown[]): AsyncIterable<unknown> {\n    yield* this.stmt.iterate(...(params as Parameters<StatementSync['iterate']>));\n  }\n\n  columns(): Array<{ name: string }> {\n    return this.stmt.columns();\n  }\n\n  setReadBigInts(enabled: boolean): void {\n    this.stmt.setReadBigInts(enabled);\n  }\n}\n\nexport function createConnection(db: DatabaseSync): Connection {\n  const conn: Connection = {\n    async exec(sql: string): Promise<void> {\n      db.exec(sql);\n    },\n    async prepare(sql: string): Promise<Statement> {\n      return new SqliteStatement(db.prepare(sql));\n    },\n    // Prepares once and loops synchronously, wrapped as one async call so features share one\n    // Connection contract with DuckDB. Joins the caller's transaction when there is one (reconcile); otherwise opens its own, so a standalone batch stays atomic and commits once, not per row.\n    async runBatch(sql: string, paramRows: unknown[][]): Promise<void> {\n      if (paramRows.length === 0) return;\n      await withTransaction(\n        conn,\n        async () => {\n          const stmt = db.prepare(sql);\n          for (const row of paramRows) stmt.run(...(row as Parameters<StatementSync['run']>));\n        },\n        BEGIN_WRITE\n      );\n    },\n  };\n  return conn;\n}\n"],"names":["createConnection","SqliteStatement","stmt","run","params","get","all","iterate","columns","setReadBigInts","enabled","db","conn","exec","sql","prepare","runBatch","paramRows","length","withTransaction","row","BEGIN_WRITE"],"mappings":"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"}

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

@@ -32,10 +32,12 @@ var _handoffts = require("../../embed/handoff.js");
 var _errorsts = require("../../errors.js");
 var _indexts1 = require("../../features/index.js");
 var _cachets = require("../cache.js");
+var _reconcilets = require("../reconcile.js");
 var _sharedts = require("../shared.js");
 var _transactionts = require("../transaction.js");
 var _connectionts = require("./connection.js");
-var _reconcilets = require("./reconcile.js");
+var _reconcilets1 = require("./reconcile.js");
+var _signaturets = require("./signature.js");
 var _sqlfunctionsts = require("./sql-functions.js");
 var _storets = require("./store.js");
 function _array_like_to_array(arr, len) {
@@ -372,6 +374,20 @@ function ensureSchema(conn, cfg, tokenize) {
         });
     })();
 }
+// Two processes opening the same fresh tree both try to convert it, and the loser gets SQLITE_BUSY
+// with no busy handler behind it. Bounded because a lock held past this is a real problem, not a race.
+function setJournalWal(db) {
+    var deadline = Date.now() + 5000;
+    for(;;){
+        try {
+            db.exec('PRAGMA journal_mode = WAL');
+            return;
+        } catch (err) {
+            if (Date.now() >= deadline || !/database is locked|busy/i.test(err.message)) throw err;
+            Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, 20);
+        }
+    }
+}
 function connect(cfg) {
     return _async_to_generator(function() {
         var stateDir, dbPath, db, closed, _ref, conn, tokenize, version, features, wantFeatures, tokenizeOnlyRebuild, changedKeys, changed, stored, rebuildWarnings, recordedMaxMs, _ref1, parsed, warnings, err;
@@ -395,10 +411,12 @@ function connect(cfg) {
                         ,
                         16
                     ]);
-                    db.exec('PRAGMA journal_mode = WAL');
-                    // Covers a concurrent watcher's bulk reconcile (~5s for 500 files at 26k notes). A query
-                    // that outwaits it still fails loudly.
+                    // Before journal_mode, not after: converting a fresh database to WAL takes a brief exclusive
+                    // lock, and with no timeout set yet a second process opening the same tree fails in 1ms.
                     db.exec('PRAGMA busy_timeout = 30000');
+                    // busy_timeout does not cover the WAL conversion itself: SQLite does not invoke the busy
+                    // handler for it, so a concurrent cold open needs its own bounded wait.
+                    setJournalWal(db);
                     (0, _sqlfunctionsts.registerFunctions)(db, (0, _indexts.contentTokenize)(cfg) === undefined);
                     conn = (0, _connectionts.createConnection)(db);
                     db.exec('CREATE TABLE IF NOT EXISTS meta (key TEXT PRIMARY KEY, value TEXT)');
@@ -435,7 +453,7 @@ function connect(cfg) {
                             connect(cfg)
                         ];
                     }
-                    changedKeys = (0, _reconcilets.changedSignatureKeys)(features !== null && features !== void 0 ? features : '', wantFeatures);
+                    changedKeys = (0, _signaturets.changedSignatureKeys)(features !== null && features !== void 0 ? features : '', wantFeatures);
                     if (!(changedKeys.size === 1 && changedKeys.has('tokenize'))) return [
                         3,
                         5
@@ -468,7 +486,7 @@ function connect(cfg) {
                                     }
                                 });
                             })();
-                        })
+                        }, _transactionts.BEGIN_WRITE)
                     ];
                 case 4:
                     _state.sent();
@@ -478,7 +496,7 @@ function connect(cfg) {
                         8
                     ];
                 case 5:
-                    if (!(changedKeys.size === 1 && changedKeys.has('embed') && (0, _reconcilets.embedIdentityAdopted)(features !== null && features !== void 0 ? features : '', wantFeatures))) return [
+                    if (!(changedKeys.size === 1 && changedKeys.has('embed') && (0, _signaturets.embedIdentityAdopted)(features !== null && features !== void 0 ? features : '', wantFeatures))) return [
                         3,
                         7
                     ];
@@ -496,7 +514,7 @@ function connect(cfg) {
                         8
                     ];
                 case 7:
-                    changed = (0, _reconcilets.signatureDiff)(features !== null && features !== void 0 ? features : '', wantFeatures);
+                    changed = (0, _signaturets.signatureDiff)(features !== null && features !== void 0 ? features : '', wantFeatures);
                     console.error("sense: config change (".concat(changed, ") rebuilds the index"));
                     closed = true;
                     db.close();
@@ -519,9 +537,13 @@ function connect(cfg) {
                             connect(cfg)
                         ];
                     }
+                    // One writer at a time: the feature hooks check a column then add it, so two cold opens racing
+                    // here both see it missing and the second ALTER fails with a duplicate column.
                     return [
                         4,
-                        ensureSchema(conn, cfg, tokenize)
+                        (0, _transactionts.withTransaction)(conn, function() {
+                            return ensureSchema(conn, cfg, tokenize);
+                        }, _transactionts.BEGIN_WRITE)
                     ];
                 case 9:
                     _state.sent();
@@ -532,7 +554,7 @@ function connect(cfg) {
                     ];
                     return [
                         4,
-                        (0, _reconcilets.rebuildContentTable)(conn, cfg, cfg.baseDir)
+                        (0, _signaturets.rebuildContentTable)(conn, cfg, cfg.baseDir)
                     ];
                 case 10:
                     rebuildWarnings = _state.sent();
@@ -555,7 +577,7 @@ function connect(cfg) {
                     db.exec("PRAGMA busy_timeout = ".concat(Math.min(Math.max(30000, 3 * recordedMaxMs), 600000)));
                     return [
                         4,
-                        (0, _reconcilets.reconcile)(conn, cfg, cfg.baseDir)
+                        (0, _reconcilets.reconcile)(conn, cfg, cfg.baseDir, _reconcilets1.sqliteDialect)
                     ];
                 case 14:
                     _ref1 = _state.sent(), parsed = _ref1.parsed, warnings = _ref1.warnings;

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

@@ -1 +1 @@
-{"version":3,"sources":["/Users/kevin/Dev/OpenSource/ai/sensemaking/src/store/sqlite/open.ts"],"sourcesContent":["// The Node floor (>=22.20) is explained here and nowhere else: 22.20 is the first release with\n// both FTS5 and row-returning INSERT ... RETURNING. Raise it only for a load-bearing capability.\nimport { mkdirSync } from 'node:fs';\nimport { join } from 'node:path';\nimport { DatabaseSync } from 'node:sqlite';\nimport type { Config, ResolvedConfig } from '../../config/index.ts';\nimport { contentTokenize, featureSignature, STATE_DIR } from '../../config/index.ts';\nimport { rekeyChunkText } from '../../embed/handoff.ts';\nimport { SenseError } from '../../errors.ts';\nimport { activeFeatures, FEATURES } from '../../features/index.ts';\nimport { clearCache } from '../cache.ts';\nimport { getMeta, setMeta } from '../shared.ts';\nimport { withTransaction } from '../transaction.ts';\nimport type { Connection, Store } from '../types.ts';\nimport { createConnection } from './connection.ts';\nimport { changedSignatureKeys, embedIdentityAdopted, rebuildContentTable, reconcile, signatureDiff } from './reconcile.ts';\nimport { registerFunctions } from './sql-functions.ts';\nimport { createStore } from './store.ts';\n\nexport const DB_FILENAME = 'cache.db';\n// Cache shape version, independent of the config's own `version`. Bumping it rebuilds\n// existing trees on first query.\nexport const SCHEMA_VERSION = '18';\n\ninterface ConnectResult {\n  db: DatabaseSync;\n  conn: Connection;\n  cfg: ResolvedConfig;\n  dbPath: string;\n  parsed: number;\n  warnings: string[];\n}\n\nexport interface OpenResult {\n  store: Store;\n  cfg: ResolvedConfig;\n  dbPath: string;\n  parsed: number;\n  warnings: string[];\n}\n\n// unicode61 splits on spaces, so a language written without them indexes a whole run as one\n// token and word search finds nothing; `content.tokenize` is how such a tree picks trigram.\nconst DEFAULT_TOKENIZE = 'porter unicode61';\n\n// FTS5 takes its tokenizer as a DDL string literal where nothing can bind, so the configured\n// value is concatenated; probing a throwaway table first is both the safety and the validation.\nfunction resolveTokenize(db: DatabaseSync, cfg: Config): string {\n  const configured = contentTokenize(cfg);\n  if (configured === undefined) return DEFAULT_TOKENIZE;\n  const literal = configured.replace(/'/g, \"''\");\n  try {\n    db.exec('DROP TABLE IF EXISTS temp.sense_tokenize_probe');\n    db.exec(`CREATE VIRTUAL TABLE temp.sense_tokenize_probe USING fts5(x, tokenize = '${literal}')`);\n    db.exec('DROP TABLE IF EXISTS temp.sense_tokenize_probe');\n  } catch (err) {\n    throw new SenseError('CONFIG_INVALID', `content.tokenize \"${configured}\" is not a tokenizer this SQLite accepts (${(err as Error).message}); the built-in choices are unicode61, ascii, porter, and trigram, each with their own options`);\n  }\n  return literal;\n}\n\n// The tokenizer the content table was actually built with, from its own DDL -- the one\n// record that cannot desynchronize from the table. NULL when the table does not exist yet.\nfunction storedTokenize(db: DatabaseSync): string | null {\n  const row = db.prepare(`SELECT sql FROM sqlite_master WHERE name = 'content'`).get() as { sql: string } | undefined;\n  if (!row) return null;\n  const m = row.sql.match(/tokenize = '((?:[^']|'')*)'/);\n  return m ? m[1] : null;\n}\n\n// The `_seg` sidecars are appended after path, never inserted: bm25() and snippet(content, 2)\n// are documented against the first three columns. Each holds its field's exploded unspaced runs.\nasync function createContentTable(conn: Connection, tokenize: string): Promise<void> {\n  await conn.exec(`CREATE VIRTUAL TABLE IF NOT EXISTS content USING fts5(title, summary, text, path UNINDEXED, title_seg, summary_seg, text_seg, tokenize = '${tokenize}')`);\n}\n\n// Content is a separate table (not a column on frontmatter) so `SELECT * FROM frontmatter`\n// can't dump file text into context. Features add their own tables after the core ones.\nasync function ensureSchema(conn: Connection, cfg: Config, tokenize: string): Promise<void> {\n  await conn.exec(`CREATE TABLE IF NOT EXISTS frontmatter (\"path\" TEXT PRIMARY KEY, \"_mtime\" REAL, \"_ctime\" REAL, \"_size\" INTEGER, \"_parse_error\" TEXT)`);\n  // IF NOT EXISTS is safe against a tokenizer change: open() compares the table's own DDL\n  // against the resolved tokenizer before this runs, so a stale table is already gone by now.\n  await createContentTable(conn, tokenize);\n  // Coverage, not ownership: a path can appear under several presets. path leads the PK so the\n  // per-doc delete is an index hit -- keyed the other way, cold builds went quadratic.\n  await conn.exec(`CREATE TABLE IF NOT EXISTS preset_files (\"path\" TEXT, preset TEXT, PRIMARY KEY (\"path\", preset))`);\n  await conn.exec('CREATE INDEX IF NOT EXISTS preset_files_preset ON preset_files(preset)');\n  for (const feature of activeFeatures(cfg)) await feature.schema(conn);\n  if ((await getMeta(conn, 'schema_version')) === null) await setMeta(conn, 'schema_version', SCHEMA_VERSION);\n  if ((await getMeta(conn, 'features')) === null) await setMeta(conn, 'features', featureSignature(cfg, FEATURES));\n}\n\nasync function connect(cfg: ResolvedConfig): Promise<ConnectResult> {\n  const stateDir = join(cfg.baseDir, STATE_DIR);\n  mkdirSync(stateDir, { recursive: true });\n  const dbPath = join(stateDir, DB_FILENAME);\n\n  const db = new DatabaseSync(dbPath);\n  // A throw below must release this handle, or on Windows the leaked WAL db is undeletable and\n  // scratch cleanup fails with EPERM/EBUSY. `closed` keeps the catch from double-closing.\n  let closed = false;\n  try {\n    db.exec('PRAGMA journal_mode = WAL');\n    // Covers a concurrent watcher's bulk reconcile (~5s for 500 files at 26k notes). A query\n    // that outwaits it still fails loudly.\n    db.exec('PRAGMA busy_timeout = 30000');\n    registerFunctions(db, contentTokenize(cfg) === undefined);\n    const conn = createConnection(db);\n\n    db.exec('CREATE TABLE IF NOT EXISTS meta (key TEXT PRIMARY KEY, value TEXT)');\n\n    // Before the rebuild branch below, never after: that branch deletes the cache, so a typo'd\n    // tokenizer validated later would cost a full re-index (and re-embed) to reach its own error.\n    const tokenize = resolveTokenize(db, cfg);\n\n    // Schema-version or feature-set mismatch: reconcile only reparses changed files, so an\n    // old cache can't be patched incrementally -- rebuild instead (cheap: nothing expensive lives here).\n    const version = await getMeta(conn, 'schema_version');\n    const features = await getMeta(conn, 'features');\n    const wantFeatures = featureSignature(cfg, FEATURES);\n    let tokenizeOnlyRebuild = false;\n    if ((version !== null && version !== SCHEMA_VERSION) || (features !== null && features !== wantFeatures)) {\n      // Indexing derives from presets, so a config edit rebuilding the cache must say so and\n      // name what changed -- silent rebuilds make derived indexing look like a hang or a bug.\n      if (version !== null && version !== SCHEMA_VERSION) {\n        console.error('sense: cache format changed (new sensemaking version); rebuilding the index');\n        closed = true;\n        db.close();\n        clearCache(cfg);\n        return connect(cfg);\n      }\n      const changedKeys = changedSignatureKeys(features ?? '', wantFeatures);\n      // Only the tokenizer moved, and frontmatter, links, sections and embeddings are file-derived\n      // and tokenizer-independent. Any other signature change takes the full clear/reopen below.\n      if (changedKeys.size === 1 && changedKeys.has('tokenize')) {\n        console.error('sense: config change (content tokenizer) rebuilds the text index; vectors, links, and sections are kept');\n        // One transaction, so a crash before COMMIT rolls back to the old tokenizer's table rather\n        // than to no table. IF EXISTS makes a retry after such a crash a no-op, not a raw error.\n        await withTransaction(conn, async () => {\n          await conn.exec('DROP TABLE IF EXISTS content');\n          await createContentTable(conn, tokenize);\n        });\n        tokenizeOnlyRebuild = true;\n      } else if (changedKeys.size === 1 && changedKeys.has('embed') && embedIdentityAdopted(features ?? '', wantFeatures)) {\n        // First sight of a resolved weight identity: the model itself hasn't changed, so\n        // adopt it into meta with no rebuild and no re-embed, mirroring the tokenize precedent.\n        console.error(\"sense: recorded the embedding model's resolved identity; vectors are unaffected\");\n        await setMeta(conn, 'features', wantFeatures);\n      } else {\n        const changed = signatureDiff(features ?? '', wantFeatures);\n        console.error(`sense: config change (${changed}) rebuilds the index`);\n        closed = true;\n        db.close();\n        clearCache(cfg);\n        return connect(cfg);\n      }\n    }\n\n    // Meta can lie after a crash between table creation and the signature write; the table's own\n    // DDL cannot, so a mismatch here rebuilds whatever meta says.\n    const stored = storedTokenize(db);\n    if (stored !== null && stored !== tokenize) {\n      console.error('sense: cache was built with a different content tokenizer; rebuilding the index');\n      closed = true;\n      db.close();\n      clearCache(cfg);\n      return connect(cfg);\n    }\n\n    await ensureSchema(conn, cfg, tokenize);\n\n    let rebuildWarnings: string[] = [];\n    if (tokenizeOnlyRebuild) {\n      rebuildWarnings = await rebuildContentTable(conn, cfg, cfg.baseDir);\n      await setMeta(conn, 'features', wantFeatures);\n    }\n\n    // 3x the largest reconcile this cache has recorded, floored at 30s and capped at 10min.\n    // Installed before reconcile() -- that call is the one that races a watcher's transaction.\n    const recordedMaxMs = Number((await getMeta(conn, 'reconcile_max_ms')) ?? '0');\n    db.exec(`PRAGMA busy_timeout = ${Math.min(Math.max(30000, 3 * recordedMaxMs), 600_000)}`);\n\n    const { parsed, warnings } = await reconcile(conn, cfg, cfg.baseDir);\n\n    return { db, conn, cfg, dbPath, parsed, warnings: [...rebuildWarnings, ...warnings] };\n  } catch (err) {\n    if (!closed) db.close();\n    throw err;\n  }\n}\n\n// The sqlite store's open: connects synchronously (see connect() above), then wraps the\n// resulting connection in the async Store interface.\nexport async function openSqlite(cfg: ResolvedConfig): Promise<OpenResult> {\n  const { db, conn, cfg: resolvedCfg, dbPath, parsed, warnings } = await connect(cfg);\n  const store = createStore(db, conn, resolvedCfg, resolvedCfg.baseDir);\n  // reconcile ran before this object existed, so its chunk text is keyed by the connection.\n  rekeyChunkText(conn, store);\n  return { store: store, cfg: resolvedCfg, dbPath, parsed, warnings };\n}\n\nexport async function docCount(store: Store): Promise<number> {\n  const stmt = await store.prepare('SELECT COUNT(*) AS n FROM frontmatter');\n  return ((await stmt.get()) as { n: number }).n;\n}\n"],"names":["DB_FILENAME","SCHEMA_VERSION","docCount","openSqlite","DEFAULT_TOKENIZE","resolveTokenize","db","cfg","configured","contentTokenize","undefined","literal","replace","exec","err","SenseError","message","storedTokenize","row","prepare","get","m","sql","match","createContentTable","conn","tokenize","ensureSchema","feature","activeFeatures","schema","getMeta","setMeta","featureSignature","FEATURES","connect","stateDir","dbPath","closed","version","features","wantFeatures","tokenizeOnlyRebuild","changedKeys","changed","stored","rebuildWarnings","recordedMaxMs","parsed","warnings","join","baseDir","STATE_DIR","mkdirSync","recursive","DatabaseSync","registerFunctions","createConnection","console","error","close","clearCache","changedSignatureKeys","size","has","withTransaction","embedIdentityAdopted","signatureDiff","rebuildContentTable","Number","Math","min","max","reconcile","resolvedCfg","store","createStore","rekeyChunkText","stmt","n"],"mappings":"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"}
+{"version":3,"sources":["/Users/kevin/Dev/OpenSource/ai/sensemaking/src/store/sqlite/open.ts"],"sourcesContent":["// The Node floor (>=22.20) is explained here and nowhere else: 22.20 is the first release with\n// both FTS5 and row-returning INSERT ... RETURNING. Raise it only for a load-bearing capability.\nimport { mkdirSync } from 'node:fs';\nimport { join } from 'node:path';\nimport { DatabaseSync } from 'node:sqlite';\nimport type { Config, ResolvedConfig } from '../../config/index.ts';\nimport { contentTokenize, featureSignature, STATE_DIR } from '../../config/index.ts';\nimport { rekeyChunkText } from '../../embed/handoff.ts';\nimport { SenseError } from '../../errors.ts';\nimport { activeFeatures, FEATURES } from '../../features/index.ts';\nimport { clearCache } from '../cache.ts';\nimport { reconcile } from '../reconcile.ts';\nimport { getMeta, setMeta } from '../shared.ts';\nimport { BEGIN_WRITE, withTransaction } from '../transaction.ts';\nimport type { Connection, Store } from '../types.ts';\nimport { createConnection } from './connection.ts';\nimport { sqliteDialect } from './reconcile.ts';\nimport { changedSignatureKeys, embedIdentityAdopted, rebuildContentTable, signatureDiff } from './signature.ts';\nimport { registerFunctions } from './sql-functions.ts';\nimport { createStore } from './store.ts';\n\nexport const DB_FILENAME = 'cache.db';\n// Cache shape version, independent of the config's own `version`. Bumping it rebuilds\n// existing trees on first query.\nexport const SCHEMA_VERSION = '18';\n\ninterface ConnectResult {\n  db: DatabaseSync;\n  conn: Connection;\n  cfg: ResolvedConfig;\n  dbPath: string;\n  parsed: number;\n  warnings: string[];\n}\n\nexport interface OpenResult {\n  store: Store;\n  cfg: ResolvedConfig;\n  dbPath: string;\n  parsed: number;\n  warnings: string[];\n}\n\n// unicode61 splits on spaces, so a language written without them indexes a whole run as one\n// token and word search finds nothing; `content.tokenize` is how such a tree picks trigram.\nconst DEFAULT_TOKENIZE = 'porter unicode61';\n\n// FTS5 takes its tokenizer as a DDL string literal where nothing can bind, so the configured\n// value is concatenated; probing a throwaway table first is both the safety and the validation.\nfunction resolveTokenize(db: DatabaseSync, cfg: Config): string {\n  const configured = contentTokenize(cfg);\n  if (configured === undefined) return DEFAULT_TOKENIZE;\n  const literal = configured.replace(/'/g, \"''\");\n  try {\n    db.exec('DROP TABLE IF EXISTS temp.sense_tokenize_probe');\n    db.exec(`CREATE VIRTUAL TABLE temp.sense_tokenize_probe USING fts5(x, tokenize = '${literal}')`);\n    db.exec('DROP TABLE IF EXISTS temp.sense_tokenize_probe');\n  } catch (err) {\n    throw new SenseError('CONFIG_INVALID', `content.tokenize \"${configured}\" is not a tokenizer this SQLite accepts (${(err as Error).message}); the built-in choices are unicode61, ascii, porter, and trigram, each with their own options`);\n  }\n  return literal;\n}\n\n// The tokenizer the content table was actually built with, from its own DDL -- the one\n// record that cannot desynchronize from the table. NULL when the table does not exist yet.\nfunction storedTokenize(db: DatabaseSync): string | null {\n  const row = db.prepare(`SELECT sql FROM sqlite_master WHERE name = 'content'`).get() as { sql: string } | undefined;\n  if (!row) return null;\n  const m = row.sql.match(/tokenize = '((?:[^']|'')*)'/);\n  return m ? m[1] : null;\n}\n\n// The `_seg` sidecars are appended after path, never inserted: bm25() and snippet(content, 2)\n// are documented against the first three columns. Each holds its field's exploded unspaced runs.\nasync function createContentTable(conn: Connection, tokenize: string): Promise<void> {\n  await conn.exec(`CREATE VIRTUAL TABLE IF NOT EXISTS content USING fts5(title, summary, text, path UNINDEXED, title_seg, summary_seg, text_seg, tokenize = '${tokenize}')`);\n}\n\n// Content is a separate table (not a column on frontmatter) so `SELECT * FROM frontmatter`\n// can't dump file text into context. Features add their own tables after the core ones.\nasync function ensureSchema(conn: Connection, cfg: Config, tokenize: string): Promise<void> {\n  await conn.exec(`CREATE TABLE IF NOT EXISTS frontmatter (\"path\" TEXT PRIMARY KEY, \"_mtime\" REAL, \"_ctime\" REAL, \"_size\" INTEGER, \"_parse_error\" TEXT)`);\n  // IF NOT EXISTS is safe against a tokenizer change: open() compares the table's own DDL\n  // against the resolved tokenizer before this runs, so a stale table is already gone by now.\n  await createContentTable(conn, tokenize);\n  // Coverage, not ownership: a path can appear under several presets. path leads the PK so the\n  // per-doc delete is an index hit -- keyed the other way, cold builds went quadratic.\n  await conn.exec(`CREATE TABLE IF NOT EXISTS preset_files (\"path\" TEXT, preset TEXT, PRIMARY KEY (\"path\", preset))`);\n  await conn.exec('CREATE INDEX IF NOT EXISTS preset_files_preset ON preset_files(preset)');\n  for (const feature of activeFeatures(cfg)) await feature.schema(conn);\n  if ((await getMeta(conn, 'schema_version')) === null) await setMeta(conn, 'schema_version', SCHEMA_VERSION);\n  if ((await getMeta(conn, 'features')) === null) await setMeta(conn, 'features', featureSignature(cfg, FEATURES));\n}\n\n// Two processes opening the same fresh tree both try to convert it, and the loser gets SQLITE_BUSY\n// with no busy handler behind it. Bounded because a lock held past this is a real problem, not a race.\nfunction setJournalWal(db: DatabaseSync): void {\n  const deadline = Date.now() + 5000;\n  for (;;) {\n    try {\n      db.exec('PRAGMA journal_mode = WAL');\n      return;\n    } catch (err) {\n      if (Date.now() >= deadline || !/database is locked|busy/i.test((err as Error).message)) throw err;\n      Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, 20);\n    }\n  }\n}\n\nasync function connect(cfg: ResolvedConfig): Promise<ConnectResult> {\n  const stateDir = join(cfg.baseDir, STATE_DIR);\n  mkdirSync(stateDir, { recursive: true });\n  const dbPath = join(stateDir, DB_FILENAME);\n\n  const db = new DatabaseSync(dbPath);\n  // A throw below must release this handle, or on Windows the leaked WAL db is undeletable and\n  // scratch cleanup fails with EPERM/EBUSY. `closed` keeps the catch from double-closing.\n  let closed = false;\n  try {\n    // Before journal_mode, not after: converting a fresh database to WAL takes a brief exclusive\n    // lock, and with no timeout set yet a second process opening the same tree fails in 1ms.\n    db.exec('PRAGMA busy_timeout = 30000');\n    // busy_timeout does not cover the WAL conversion itself: SQLite does not invoke the busy\n    // handler for it, so a concurrent cold open needs its own bounded wait.\n    setJournalWal(db);\n    registerFunctions(db, contentTokenize(cfg) === undefined);\n    const conn = createConnection(db);\n\n    db.exec('CREATE TABLE IF NOT EXISTS meta (key TEXT PRIMARY KEY, value TEXT)');\n\n    // Before the rebuild branch below, never after: that branch deletes the cache, so a typo'd\n    // tokenizer validated later would cost a full re-index (and re-embed) to reach its own error.\n    const tokenize = resolveTokenize(db, cfg);\n\n    // Schema-version or feature-set mismatch: reconcile only reparses changed files, so an\n    // old cache can't be patched incrementally -- rebuild instead (cheap: nothing expensive lives here).\n    const version = await getMeta(conn, 'schema_version');\n    const features = await getMeta(conn, 'features');\n    const wantFeatures = featureSignature(cfg, FEATURES);\n    let tokenizeOnlyRebuild = false;\n    if ((version !== null && version !== SCHEMA_VERSION) || (features !== null && features !== wantFeatures)) {\n      // Indexing derives from presets, so a config edit rebuilding the cache must say so and\n      // name what changed -- silent rebuilds make derived indexing look like a hang or a bug.\n      if (version !== null && version !== SCHEMA_VERSION) {\n        console.error('sense: cache format changed (new sensemaking version); rebuilding the index');\n        closed = true;\n        db.close();\n        clearCache(cfg);\n        return connect(cfg);\n      }\n      const changedKeys = changedSignatureKeys(features ?? '', wantFeatures);\n      // Only the tokenizer moved, and frontmatter, links, sections and embeddings are file-derived\n      // and tokenizer-independent. Any other signature change takes the full clear/reopen below.\n      if (changedKeys.size === 1 && changedKeys.has('tokenize')) {\n        console.error('sense: config change (content tokenizer) rebuilds the text index; vectors, links, and sections are kept');\n        // One transaction, so a crash before COMMIT rolls back to the old tokenizer's table rather\n        // than to no table. IF EXISTS makes a retry after such a crash a no-op, not a raw error.\n        await withTransaction(\n          conn,\n          async () => {\n            await conn.exec('DROP TABLE IF EXISTS content');\n            await createContentTable(conn, tokenize);\n          },\n          BEGIN_WRITE\n        );\n        tokenizeOnlyRebuild = true;\n      } else if (changedKeys.size === 1 && changedKeys.has('embed') && embedIdentityAdopted(features ?? '', wantFeatures)) {\n        // First sight of a resolved weight identity: the model itself hasn't changed, so\n        // adopt it into meta with no rebuild and no re-embed, mirroring the tokenize precedent.\n        console.error(\"sense: recorded the embedding model's resolved identity; vectors are unaffected\");\n        await setMeta(conn, 'features', wantFeatures);\n      } else {\n        const changed = signatureDiff(features ?? '', wantFeatures);\n        console.error(`sense: config change (${changed}) rebuilds the index`);\n        closed = true;\n        db.close();\n        clearCache(cfg);\n        return connect(cfg);\n      }\n    }\n\n    // Meta can lie after a crash between table creation and the signature write; the table's own\n    // DDL cannot, so a mismatch here rebuilds whatever meta says.\n    const stored = storedTokenize(db);\n    if (stored !== null && stored !== tokenize) {\n      console.error('sense: cache was built with a different content tokenizer; rebuilding the index');\n      closed = true;\n      db.close();\n      clearCache(cfg);\n      return connect(cfg);\n    }\n\n    // One writer at a time: the feature hooks check a column then add it, so two cold opens racing\n    // here both see it missing and the second ALTER fails with a duplicate column.\n    await withTransaction(conn, () => ensureSchema(conn, cfg, tokenize), BEGIN_WRITE);\n\n    let rebuildWarnings: string[] = [];\n    if (tokenizeOnlyRebuild) {\n      rebuildWarnings = await rebuildContentTable(conn, cfg, cfg.baseDir);\n      await setMeta(conn, 'features', wantFeatures);\n    }\n\n    // 3x the largest reconcile this cache has recorded, floored at 30s and capped at 10min.\n    // Installed before reconcile() -- that call is the one that races a watcher's transaction.\n    const recordedMaxMs = Number((await getMeta(conn, 'reconcile_max_ms')) ?? '0');\n    db.exec(`PRAGMA busy_timeout = ${Math.min(Math.max(30000, 3 * recordedMaxMs), 600_000)}`);\n\n    const { parsed, warnings } = await reconcile(conn, cfg, cfg.baseDir, sqliteDialect);\n\n    return { db, conn, cfg, dbPath, parsed, warnings: [...rebuildWarnings, ...warnings] };\n  } catch (err) {\n    if (!closed) db.close();\n    throw err;\n  }\n}\n\n// The sqlite store's open: connects synchronously (see connect() above), then wraps the\n// resulting connection in the async Store interface.\nexport async function openSqlite(cfg: ResolvedConfig): Promise<OpenResult> {\n  const { db, conn, cfg: resolvedCfg, dbPath, parsed, warnings } = await connect(cfg);\n  const store = createStore(db, conn, resolvedCfg, resolvedCfg.baseDir);\n  // reconcile ran before this object existed, so its chunk text is keyed by the connection.\n  rekeyChunkText(conn, store);\n  return { store: store, cfg: resolvedCfg, dbPath, parsed, warnings };\n}\n\nexport async function docCount(store: Store): Promise<number> {\n  const stmt = await store.prepare('SELECT COUNT(*) AS n FROM frontmatter');\n  return ((await stmt.get()) as { n: number }).n;\n}\n"],"names":["DB_FILENAME","SCHEMA_VERSION","docCount","openSqlite","DEFAULT_TOKENIZE","resolveTokenize","db","cfg","configured","contentTokenize","undefined","literal","replace","exec","err","SenseError","message","storedTokenize","row","prepare","get","m","sql","match","createContentTable","conn","tokenize","ensureSchema","feature","activeFeatures","schema","getMeta","setMeta","featureSignature","FEATURES","setJournalWal","deadline","Date","now","test","Atomics","wait","Int32Array","SharedArrayBuffer","connect","stateDir","dbPath","closed","version","features","wantFeatures","tokenizeOnlyRebuild","changedKeys","changed","stored","rebuildWarnings","recordedMaxMs","parsed","warnings","join","baseDir","STATE_DIR","mkdirSync","recursive","DatabaseSync","registerFunctions","createConnection","console","error","close","clearCache","changedSignatureKeys","size","has","withTransaction","BEGIN_WRITE","embedIdentityAdopted","signatureDiff","rebuildContentTable","Number","Math","min","max","reconcile","sqliteDialect","resolvedCfg","store","createStore","rekeyChunkText","stmt","n"],"mappings":"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"}

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

@@ -1,10 +1,5 @@
-import type { Config } from '../../config/index.js';
-import type { Connection } from '../types.js';
-export declare function reconcile(conn: Connection, cfg: Config, baseDir: string): Promise<{
-    parsed: number;
-    warnings: string[];
-}>;
-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;
-export declare function rebuildContentTable(conn: Connection, cfg: Config, baseDir: string): Promise<string[]>;
+import type { ParsedDoc } from '../../scan/index.js';
+import type { ReconcileDialect } from '../types.js';
+export declare const INSERT_CONTENT_SQL = "INSERT INTO content (rowid, title, summary, text, \"path\", title_seg, summary_seg, text_seg) VALUES ((SELECT rowid FROM frontmatter WHERE \"path\" = ?), ?, ?, ?, ?, ?, ?, ?)";
+export declare function contentRow(doc: ParsedDoc, segmenting: boolean): unknown[];
+export declare const sqliteDialect: ReconcileDialect;

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

@@ -1,10 +1,5 @@
-import type { Config } from '../../config/index.js';
-import type { Connection } from '../types.js';
-export declare function reconcile(conn: Connection, cfg: Config, baseDir: string): Promise<{
-    parsed: number;
-    warnings: string[];
-}>;
-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;
-export declare function rebuildContentTable(conn: Connection, cfg: Config, baseDir: string): Promise<string[]>;
+import type { ParsedDoc } from '../../scan/index.js';
+import type { ReconcileDialect } from '../types.js';
+export declare const INSERT_CONTENT_SQL = "INSERT INTO content (rowid, title, summary, text, \"path\", title_seg, summary_seg, text_seg) VALUES ((SELECT rowid FROM frontmatter WHERE \"path\" = ?), ?, ?, ?, ?, ?, ?, ?)";
+export declare function contentRow(doc: ParsedDoc, segmenting: boolean): unknown[];
+export declare const sqliteDialect: ReconcileDialect;