sensemaking 0.19.2 → 0.21.0

package/dist/cjs/store/duckdb/store.js

@@ -17,14 +17,12 @@ _export(exports, {
     }
 });
 var _typests = require("../../embed/types.js");
-var _reconcilets = require("../reconcile.js");
 var _sharedts = require("../shared.js");
 var _transactionts = require("../transaction.js");
 var _vectorsts = require("../vectors.js");
 var _connectionts = require("./connection.js");
 var _fieldStatsts = require("./fieldStats.js");
 var _lexicalts = require("./lexical.js");
-var _reconcilets1 = require("./reconcile.js");
 var _vectorsts1 = require("./vectors.js");
 function _array_like_to_array(arr, len) {
     if (len == null || len > arr.length) len = arr.length;
@@ -270,7 +268,7 @@ var CAPABILITIES = new Set([
     'vectors',
     'sql-functions'
 ]);
-function createStore(instance, duckdb, conn, cfg, baseDir) {
+function createStore(instance, duckdb, conn) {
     var lex = (0, _lexicalts.createLexicalIndex)(conn);
     return {
         name: 'duckdb',
@@ -331,29 +329,6 @@ function createStore(instance, duckdb, conn, cfg, baseDir) {
                 });
             })();
         },
-        reconcile: function reconcile() {
-            return _async_to_generator(function() {
-                var result;
-                return _ts_generator(this, function(_state) {
-                    switch(_state.label){
-                        case 0:
-                            return [
-                                4,
-                                (0, _reconcilets.reconcile)(conn, cfg, baseDir, _reconcilets1.duckdbDialect)
-                            ];
-                        case 1:
-                            result = _state.sent();
-                            // content may have changed; the fts index is rebuilt lazily, on the next lexical query
-                            // that needs it, not here (see lexical.ts's FtsIndexState).
-                            lex.markStale();
-                            return [
-                                2,
-                                result
-                            ];
-                    }
-                });
-            })();
-        },
         docs: {
             columns: function columns() {
                 return _async_to_generator(function() {

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

@@ -1 +1 @@
-{"version":3,"sources":["/Users/kevin/Dev/OpenSource/ai/sensemaking/src/store/duckdb/store.ts"],"sourcesContent":["import type { DuckDBConnection, DuckDBInstance } from '@duckdb/node-api';\nimport type { Config } from '../../config/index.ts';\nimport { STORE_DIMS } from '../../embed/types.ts';\nimport { reconcile } from '../reconcile.ts';\nimport { getColumns } from '../shared.ts';\nimport { withTransaction } from '../transaction.ts';\nimport type { Capability, Connection, Statement, Store } from '../types.ts';\nimport { hasVectorRow, pendingRows } from '../vectors.ts';\nimport { storeRowToJs } from './connection.ts';\nimport { fieldStats } from './fieldStats.ts';\nimport { createLexicalIndex } from './lexical.ts';\nimport { duckdbDialect } from './reconcile.ts';\nimport { scanCandidates, scanSimilar, writeVectorBatch } from './vectors.ts';\n\n// Portable surface, links/sections/tags/rank, raw sql passthrough, lexical (fts BM25 + contains(), lexical.ts), and vectors (native\n// FLOAT[N] + array_cosine_similarity, vectors.ts) are implemented. 'snippets' is declined (JS excerpt fallback handles it); 'phrases' means quoted-phrase only -- FTS5 operator syntax is rejected, not answered differently.\nexport const CAPABILITIES: ReadonlySet<Capability> = new Set(['lexical', 'phrases', 'vectors', 'sql-functions']);\n\n// Shares one Connection instance (conn) with open()'s own reconcile call so transaction depth (transaction.ts) is tracked against the same object everywhere.\n// The instance is the native handle that owns the WAL: close() must close it, not just disconnect, or DuckDB never checkpoints and the next open reads a mismatched WAL.\nexport function createStore(instance: DuckDBInstance, duckdb: DuckDBConnection, conn: Connection, cfg: Config, baseDir: string): Store {\n  const lex = createLexicalIndex(conn);\n  return {\n    name: 'duckdb',\n    capabilities: CAPABILITIES,\n    async exec(sql: string): Promise<void> {\n      await conn.exec(sql);\n    },\n    async prepare(sql: string): Promise<Statement> {\n      return conn.prepare(sql);\n    },\n    async runBatch(sql: string, paramRows: unknown[][]): Promise<void> {\n      await conn.runBatch(sql, paramRows);\n    },\n    async transaction<T>(fn: () => Promise<T>): Promise<T> {\n      return withTransaction(conn, fn);\n    },\n    async reconcile() {\n      const result = await reconcile(conn, cfg, baseDir, duckdbDialect);\n      // content may have changed; the fts index is rebuilt lazily, on the next lexical query\n      // that needs it, not here (see lexical.ts's FtsIndexState).\n      lex.markStale();\n      return result;\n    },\n    docs: {\n      async columns() {\n        return [...(await getColumns(conn))];\n      },\n      fieldStats: (columns, scopeWhere) => fieldStats(conn, columns, scopeWhere),\n    },\n    lexical: {\n      query: lex.query,\n    },\n    // The column's fixed DDL width (STORE_DIMS) is what every scan binds against, not the interface's per-call storeDims --\n    // see vectors.ts's padded() for why a shorter vector remains correct against a wider column.\n    vectors: {\n      pending: () => pendingRows(conn),\n      writeVectors: (rows) => writeVectorBatch(duckdb, conn, STORE_DIMS, rows),\n      candidates: (qv, _storeDims, fetch, allowed) => scanCandidates(duckdb, qv, STORE_DIMS, fetch, allowed),\n      similar: (path, opts) => scanSimilar(duckdb, conn, STORE_DIMS, path, opts),\n      hasVector: (path) => hasVectorRow(conn, path),\n    },\n    // No comparable setting to report yet.\n    async engineStatus() {\n      return {};\n    },\n    raw: {\n      async prepare(sql: string) {\n        const prepared = await duckdb.prepare(sql);\n        return {\n          columns: () => {\n            const out: Array<{ name: string }> = [];\n            for (let i = 0; i < prepared.columnCount; i++) out.push({ name: prepared.columnName(i) });\n            return out;\n          },\n          // Real incremental streaming: DuckDB reads its own result in row-group chunks, so\n          // each readUntil only fetches what isn't already in hand.\n          iterate: async function* (...params: unknown[]) {\n            if (params.length > 0) prepared.bind(params as Parameters<typeof prepared.bind>[0]);\n            const reader = await prepared.streamAndRead();\n            let yielded = 0;\n            do {\n              await reader.readUntil(reader.currentRowCount + 2048);\n              const rows = reader.getRowObjectsJS() as Array<Record<string, unknown>>;\n              for (; yielded < rows.length; yielded++) yield storeRowToJs(rows[yielded]);\n            } while (!reader.done);\n          },\n        };\n      },\n    },\n    async close() {\n      // Order matters: the connection must be gone before the instance closes the WAL.\n      duckdb.disconnectSync();\n      instance.closeSync();\n    },\n  };\n}\n"],"names":["CAPABILITIES","createStore","Set","instance","duckdb","conn","cfg","baseDir","lex","createLexicalIndex","name","capabilities","exec","sql","prepare","runBatch","paramRows","transaction","fn","withTransaction","reconcile","result","duckdbDialect","markStale","docs","columns","getColumns","fieldStats","scopeWhere","lexical","query","vectors","pending","pendingRows","writeVectors","rows","writeVectorBatch","STORE_DIMS","candidates","qv","_storeDims","fetch","allowed","scanCandidates","similar","path","opts","scanSimilar","hasVector","hasVectorRow","engineStatus","raw","prepared","out","i","columnCount","push","columnName","iterate","params","reader","yielded","length","bind","streamAndRead","readUntil","currentRowCount","getRowObjectsJS","storeRowToJs","done","close","disconnectSync","closeSync"],"mappings":"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"}
+{"version":3,"sources":["/Users/kevin/Dev/OpenSource/ai/sensemaking/src/store/duckdb/store.ts"],"sourcesContent":["import type { DuckDBConnection, DuckDBInstance } from '@duckdb/node-api';\nimport { STORE_DIMS } from '../../embed/types.ts';\nimport { getColumns } from '../shared.ts';\nimport { withTransaction } from '../transaction.ts';\nimport type { Capability, Connection, Statement, Store } from '../types.ts';\nimport { hasVectorRow, pendingRows } from '../vectors.ts';\nimport { storeRowToJs } from './connection.ts';\nimport { fieldStats } from './fieldStats.ts';\nimport { createLexicalIndex } from './lexical.ts';\nimport { scanCandidates, scanSimilar, writeVectorBatch } from './vectors.ts';\n\n// Portable surface, links/sections/tags/rank, raw sql passthrough, lexical (fts BM25 + contains(), lexical.ts), and vectors (native\n// FLOAT[N] + array_cosine_similarity, vectors.ts) are implemented. 'snippets' is declined (JS excerpt fallback handles it); 'phrases' means quoted-phrase only -- FTS5 operator syntax is rejected, not answered differently.\nexport const CAPABILITIES: ReadonlySet<Capability> = new Set(['lexical', 'phrases', 'vectors', 'sql-functions']);\n\n// Shares one Connection instance (conn) with the builder's own reconcile call so transaction depth (transaction.ts) is tracked against the same object everywhere.\n// The instance is the native handle that owns the WAL: close() must close it, not just disconnect, or DuckDB never checkpoints and the next open reads a mismatched WAL.\nexport function createStore(instance: DuckDBInstance, duckdb: DuckDBConnection, conn: Connection): Store {\n  const lex = createLexicalIndex(conn);\n  return {\n    name: 'duckdb',\n    capabilities: CAPABILITIES,\n    async exec(sql: string): Promise<void> {\n      await conn.exec(sql);\n    },\n    async prepare(sql: string): Promise<Statement> {\n      return conn.prepare(sql);\n    },\n    async runBatch(sql: string, paramRows: unknown[][]): Promise<void> {\n      await conn.runBatch(sql, paramRows);\n    },\n    async transaction<T>(fn: () => Promise<T>): Promise<T> {\n      return withTransaction(conn, fn);\n    },\n    docs: {\n      async columns() {\n        return [...(await getColumns(conn))];\n      },\n      fieldStats: (columns, scopeWhere) => fieldStats(conn, columns, scopeWhere),\n    },\n    lexical: {\n      query: lex.query,\n    },\n    // The column's fixed DDL width (STORE_DIMS) is what every scan binds against, not the interface's per-call storeDims --\n    // see vectors.ts's padded() for why a shorter vector remains correct against a wider column.\n    vectors: {\n      pending: () => pendingRows(conn),\n      writeVectors: (rows) => writeVectorBatch(duckdb, conn, STORE_DIMS, rows),\n      candidates: (qv, _storeDims, fetch, allowed) => scanCandidates(duckdb, qv, STORE_DIMS, fetch, allowed),\n      similar: (path, opts) => scanSimilar(duckdb, conn, STORE_DIMS, path, opts),\n      hasVector: (path) => hasVectorRow(conn, path),\n    },\n    // No comparable setting to report yet.\n    async engineStatus() {\n      return {};\n    },\n    raw: {\n      async prepare(sql: string) {\n        const prepared = await duckdb.prepare(sql);\n        return {\n          columns: () => {\n            const out: Array<{ name: string }> = [];\n            for (let i = 0; i < prepared.columnCount; i++) out.push({ name: prepared.columnName(i) });\n            return out;\n          },\n          // Real incremental streaming: DuckDB reads its own result in row-group chunks, so\n          // each readUntil only fetches what isn't already in hand.\n          iterate: async function* (...params: unknown[]) {\n            if (params.length > 0) prepared.bind(params as Parameters<typeof prepared.bind>[0]);\n            const reader = await prepared.streamAndRead();\n            let yielded = 0;\n            do {\n              await reader.readUntil(reader.currentRowCount + 2048);\n              const rows = reader.getRowObjectsJS() as Array<Record<string, unknown>>;\n              for (; yielded < rows.length; yielded++) yield storeRowToJs(rows[yielded]);\n            } while (!reader.done);\n          },\n        };\n      },\n    },\n    async close() {\n      // Order matters: the connection must be gone before the instance closes the WAL.\n      duckdb.disconnectSync();\n      instance.closeSync();\n    },\n  };\n}\n"],"names":["CAPABILITIES","createStore","Set","instance","duckdb","conn","lex","createLexicalIndex","name","capabilities","exec","sql","prepare","runBatch","paramRows","transaction","fn","withTransaction","docs","columns","getColumns","fieldStats","scopeWhere","lexical","query","vectors","pending","pendingRows","writeVectors","rows","writeVectorBatch","STORE_DIMS","candidates","qv","_storeDims","fetch","allowed","scanCandidates","similar","path","opts","scanSimilar","hasVector","hasVectorRow","engineStatus","raw","prepared","out","i","columnCount","push","columnName","iterate","params","reader","yielded","length","bind","streamAndRead","readUntil","currentRowCount","getRowObjectsJS","storeRowToJs","done","close","disconnectSync","closeSync"],"mappings":";;;;;;;;;;;QAaaA;eAAAA;;QAIGC;eAAAA;;;uBAhBW;wBACA;6BACK;yBAEU;4BACb;4BACF;yBACQ;0BAC2B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAIvD,IAAMD,eAAwC,IAAIE,IAAI;IAAC;IAAW;IAAW;IAAW;CAAgB;AAIxG,SAASD,YAAYE,QAAwB,EAAEC,MAAwB,EAAEC,IAAgB;IAC9F,IAAMC,MAAMC,IAAAA,6BAAkB,EAACF;IAC/B,OAAO;QACLG,MAAM;QACNC,cAAcT;QACRU,MAAN,SAAMA,KAAKC,GAAW;;;;;4BACpB;;gCAAMN,KAAKK,IAAI,CAACC;;;4BAAhB;;;;;;YACF;;QACMC,SAAN,SAAMA,QAAQD,GAAW;;;oBACvB;;wBAAON,KAAKO,OAAO,CAACD;;;YACtB;;QACME,UAAN,SAAMA,SAASF,GAAW,EAAEG,SAAsB;;;;;4BAChD;;gCAAMT,KAAKQ,QAAQ,CAACF,KAAKG;;;4BAAzB;;;;;;YACF;;QACMC,aAAN,SAAMA,YAAeC,EAAoB;;;oBACvC;;wBAAOC,IAAAA,8BAAe,EAACZ,MAAMW;;;YAC/B;;QACAE,MAAM;YACEC,SAAN,SAAMA;;;;;gCACQ;;oCAAMC,IAAAA,oBAAU,EAACf;;;gCAA7B;;oCAAQ;wCAAI;;;;;gBACd;;YACAgB,YAAY,SAAZA,WAAaF,SAASG;uBAAeD,IAAAA,wBAAU,EAAChB,MAAMc,SAASG;;QACjE;QACAC,SAAS;YACPC,OAAOlB,IAAIkB,KAAK;QAClB;QACA,wHAAwH;QACxH,6FAA6F;QAC7FC,SAAS;YACPC,SAAS,SAATA;uBAAeC,IAAAA,sBAAW,EAACtB;;YAC3BuB,cAAc,SAAdA,aAAeC;uBAASC,IAAAA,4BAAgB,EAAC1B,QAAQC,MAAM0B,mBAAU,EAAEF;;YACnEG,YAAY,SAAZA,WAAaC,IAAIC,YAAYC,OAAOC;uBAAYC,IAAAA,0BAAc,EAACjC,QAAQ6B,IAAIF,mBAAU,EAAEI,OAAOC;;YAC9FE,SAAS,SAATA,QAAUC,MAAMC;uBAASC,IAAAA,uBAAW,EAACrC,QAAQC,MAAM0B,mBAAU,EAAEQ,MAAMC;;YACrEE,WAAW,SAAXA,UAAYH;uBAASI,IAAAA,uBAAY,EAACtC,MAAMkC;;QAC1C;QAEMK,cADN,uCAAuC;QACvC,SAAMA;;;oBACJ;;wBAAO,CAAC;;;YACV;;QACAC,KAAK;YACGjC,SAAN,SAAMA,QAAQD,GAAW;;wBACjBmC;;;;gCAAW;;oCAAM1C,OAAOQ,OAAO,CAACD;;;gCAAhCmC,WAAW;gCACjB;;oCAAO;wCACL3B,SAAS,SAATA;4CACE,IAAM4B,MAA+B,EAAE;4CACvC,IAAK,IAAIC,IAAI,GAAGA,IAAIF,SAASG,WAAW,EAAED,IAAKD,IAAIG,IAAI,CAAC;gDAAE1C,MAAMsC,SAASK,UAAU,CAACH;4CAAG;4CACvF,OAAOD;wCACT;wCACA,kFAAkF;wCAClF,0DAA0D;wCAC1DK,SAAS,SAATA;4CAA0B,IAAA,IAAA,OAAA,UAAA,QAAA,AAAGC,SAAH,UAAA,OAAA,OAAA,GAAA,OAAA,MAAA;gDAAGA,OAAH,QAAA,SAAA,CAAA,KAAoB;;;oDAEtCC,QACFC,SAGI1B;;;;4DALR,IAAIwB,OAAOG,MAAM,GAAG,GAAGV,SAASW,IAAI,CAACJ;4DACtB;;gEAAA,uBAAMP,SAASY,aAAa;;;4DAArCJ,SAAS;4DACXC,UAAU;;;4DAEZ;;gEAAA,uBAAMD,OAAOK,SAAS,CAACL,OAAOM,eAAe,GAAG;;;4DAAhD;4DACM/B,OAAOyB,OAAOO,eAAe;;;iEAC5BN,CAAAA,UAAU1B,KAAK2B,MAAM,AAAD;;;;4DAAc;;gEAAMM,IAAAA,0BAAY,EAACjC,IAAI,CAAC0B,QAAQ;;;4DAAhC;;;4DAAXA;;;;;;gEACvB,CAACD,OAAOS,IAAI,EAAZ;;;;;;;;;;;4CACX;;oCACF;;;;gBACF;;QACF;QACMC,OAAN,SAAMA;;;oBACJ,iFAAiF;oBACjF5D,OAAO6D,cAAc;oBACrB9D,SAAS+D,SAAS;;;;;YACpB;;IACF;AACF"}

package/dist/cjs/store/embed-scope.d.cts

@@ -0,0 +1,2 @@
+export type EmbedChangeKind = 'model' | 'chunk';
+export declare function classifyEmbedChange(before: string, after: string): EmbedChangeKind | null;

package/dist/cjs/store/embed-scope.d.ts

@@ -0,0 +1,2 @@
+export type EmbedChangeKind = 'model' | 'chunk';
+export declare function classifyEmbedChange(before: string, after: string): EmbedChangeKind | null;

package/dist/cjs/store/embed-scope.js

@@ -0,0 +1,85 @@
+// Decomposition of the `embed:` featureSignature segment (config/access.ts's featureSignature,
+// features/embed.ts's signature()), for open()'s narrow embed-invalidation routing.
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "classifyEmbedChange", {
+    enumerable: true,
+    get: function() {
+        return classifyEmbedChange;
+    }
+});
+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 _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 _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 _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);
+}
+// One embed segment's provider/model/chunkVersion, ignoring any trailing `@identity`. `embed:off`
+// and any segment not in that exact shape return null, so the caller falls back to a full rebuild.
+function parseEmbedSegment(sig) {
+    var part = sig.split('|').find(function(p) {
+        return p.startsWith('embed:');
+    });
+    if (part === undefined || part === 'embed:off') return null;
+    var at = part.indexOf('@');
+    var body = at === -1 ? part : part.slice(0, at);
+    var match = /^embed:(static|openai|cohere):(.+):(chunk:v\d+(?::\d+)?)$/.exec(body);
+    if (!match) return null;
+    var _match = _sliced_to_array(match, 4), provider = _match[1], model = _match[2], chunkVersion = _match[3];
+    return {
+        provider: provider,
+        model: model,
+        chunkVersion: chunkVersion
+    };
+}
+function classifyEmbedChange(before, after) {
+    var b = parseEmbedSegment(before);
+    var a = parseEmbedSegment(after);
+    if (b === null || a === null) return null;
+    if (b.chunkVersion !== a.chunkVersion) return 'chunk';
+    if (b.provider !== a.provider || b.model !== a.model) return 'model';
+    return null;
+}
+/* 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/embed-scope.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["/Users/kevin/Dev/OpenSource/ai/sensemaking/src/store/embed-scope.ts"],"sourcesContent":["// Decomposition of the `embed:` featureSignature segment (config/access.ts's featureSignature,\n// features/embed.ts's signature()), for open()'s narrow embed-invalidation routing.\n\nexport type EmbedChangeKind = 'model' | 'chunk';\n\ninterface EmbedSegment {\n  provider: string;\n  model: string;\n  chunkVersion: string;\n}\n\n// One embed segment's provider/model/chunkVersion, ignoring any trailing `@identity`. `embed:off`\n// and any segment not in that exact shape return null, so the caller falls back to a full rebuild.\nfunction parseEmbedSegment(sig: string): EmbedSegment | null {\n  const part = sig.split('|').find((p) => p.startsWith('embed:'));\n  if (part === undefined || part === 'embed:off') return null;\n  const at = part.indexOf('@');\n  const body = at === -1 ? part : part.slice(0, at);\n  const match = /^embed:(static|openai|cohere):(.+):(chunk:v\\d+(?::\\d+)?)$/.exec(body);\n  if (!match) return null;\n  const [, provider, model, chunkVersion] = match;\n  return { provider, model, chunkVersion };\n}\n\n// 'chunk' when chunkTokens or the chunk version moved (boundaries changed, embeddings rebuild);\n// 'model' when only the provider or model moved (rows unchanged, values stale); null otherwise.\nexport function classifyEmbedChange(before: string, after: string): EmbedChangeKind | null {\n  const b = parseEmbedSegment(before);\n  const a = parseEmbedSegment(after);\n  if (b === null || a === null) return null;\n  if (b.chunkVersion !== a.chunkVersion) return 'chunk';\n  if (b.provider !== a.provider || b.model !== a.model) return 'model';\n  return null;\n}\n"],"names":["classifyEmbedChange","parseEmbedSegment","sig","part","split","find","p","startsWith","undefined","at","indexOf","body","slice","match","exec","provider","model","chunkVersion","before","after","b","a"],"mappings":"AAAA,+FAA+F;AAC/F,oFAAoF;;;;;+BAyBpEA;;;eAAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAfhB,kGAAkG;AAClG,mGAAmG;AACnG,SAASC,kBAAkBC,GAAW;IACpC,IAAMC,OAAOD,IAAIE,KAAK,CAAC,KAAKC,IAAI,CAAC,SAACC;eAAMA,EAAEC,UAAU,CAAC;;IACrD,IAAIJ,SAASK,aAAaL,SAAS,aAAa,OAAO;IACvD,IAAMM,KAAKN,KAAKO,OAAO,CAAC;IACxB,IAAMC,OAAOF,OAAO,CAAC,IAAIN,OAAOA,KAAKS,KAAK,CAAC,GAAGH;IAC9C,IAAMI,QAAQ,4DAA4DC,IAAI,CAACH;IAC/E,IAAI,CAACE,OAAO,OAAO;IACnB,IAA0CA,0BAAAA,WAAjCE,WAAiCF,WAAvBG,QAAuBH,WAAhBI,eAAgBJ;IAC1C,OAAO;QAAEE,UAAAA;QAAUC,OAAAA;QAAOC,cAAAA;IAAa;AACzC;AAIO,SAASjB,oBAAoBkB,MAAc,EAAEC,KAAa;IAC/D,IAAMC,IAAInB,kBAAkBiB;IAC5B,IAAMG,IAAIpB,kBAAkBkB;IAC5B,IAAIC,MAAM,QAAQC,MAAM,MAAM,OAAO;IACrC,IAAID,EAAEH,YAAY,KAAKI,EAAEJ,YAAY,EAAE,OAAO;IAC9C,IAAIG,EAAEL,QAAQ,KAAKM,EAAEN,QAAQ,IAAIK,EAAEJ,KAAK,KAAKK,EAAEL,KAAK,EAAE,OAAO;IAC7D,OAAO;AACT"}

package/dist/cjs/store/feature-scope.d.cts

@@ -0,0 +1,8 @@
+import type { FeatureName } from '../config/index.js';
+export declare const NARROW_FEATURE_TABLE: Readonly<Record<string, string>>;
+export interface FeatureToggle {
+    name: FeatureName;
+    turnedOn: boolean;
+}
+export declare function isFeatureOnlyChange(changedKeys: ReadonlySet<string>): boolean;
+export declare function classifyFeatureToggles(before: string, after: string, changedKeys: ReadonlySet<string>): FeatureToggle[] | null;

package/dist/cjs/store/feature-scope.d.ts

@@ -0,0 +1,8 @@
+import type { FeatureName } from '../config/index.js';
+export declare const NARROW_FEATURE_TABLE: Readonly<Record<string, string>>;
+export interface FeatureToggle {
+    name: FeatureName;
+    turnedOn: boolean;
+}
+export declare function isFeatureOnlyChange(changedKeys: ReadonlySet<string>): boolean;
+export declare function classifyFeatureToggles(before: string, after: string, changedKeys: ReadonlySet<string>): FeatureToggle[] | null;

package/dist/cjs/store/feature-scope.js

@@ -0,0 +1,107 @@
+"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 NARROW_FEATURE_TABLE () {
+        return NARROW_FEATURE_TABLE;
+    },
+    get classifyFeatureToggles () {
+        return classifyFeatureToggles;
+    },
+    get isFeatureOnlyChange () {
+        return isFeatureOnlyChange;
+    }
+});
+function _array_like_to_array(arr, len) {
+    if (len == null || len > arr.length) len = arr.length;
+    for(var i = 0, arr2 = new Array(len); i < len; i++)arr2[i] = arr[i];
+    return arr2;
+}
+function _array_without_holes(arr) {
+    if (Array.isArray(arr)) return _array_like_to_array(arr);
+}
+function _iterable_to_array(iter) {
+    if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) {
+        return Array.from(iter);
+    }
+}
+function _non_iterable_spread() {
+    throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+function _to_consumable_array(arr) {
+    return _array_without_holes(arr) || _iterable_to_array(arr) || _unsupported_iterable_to_array(arr) || _non_iterable_spread();
+}
+function _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);
+}
+var NARROW_FEATURE_TABLE = {
+    tags: 'tags',
+    sections: 'sections',
+    links: 'links'
+};
+// links feeds rank's afterReconcile pass, so a links toggle always co-changes the `feature:rank`
+// segment too (featureEnabled's dependency); both are narrow-supported and builder.ts applies
+// them together. A changed set naming any other feature falls through to the existing full clear.
+var NARROW_FEATURE_NAMES = new Set(_to_consumable_array(Object.keys(NARROW_FEATURE_TABLE)).concat([
+    'rank'
+]));
+function isFeatureOnlyChange(changedKeys) {
+    return changedKeys.size > 0 && _to_consumable_array(changedKeys).every(function(key) {
+        return key.startsWith('feature:') && NARROW_FEATURE_NAMES.has(key.slice('feature:'.length));
+    });
+}
+// One feature segment's old on/off, read back out of a stored `feature:<name>:on|off` segment.
+// Anything not in that exact shape returns null so the caller falls back to a full rebuild.
+function parseOnOff(sig, name) {
+    var part = sig.split('|').find(function(p) {
+        return p.startsWith("feature:".concat(name, ":"));
+    });
+    if (part === undefined) return null;
+    var fields = part.split(':');
+    if (fields.length !== 3 || fields[2] !== 'on' && fields[2] !== 'off') return null;
+    return fields[2] === 'on';
+}
+function classifyFeatureToggles(before, after, changedKeys) {
+    var toggles = [];
+    var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+    try {
+        for(var _iterator = changedKeys[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+            var key = _step.value;
+            var name = key.slice('feature:'.length);
+            var wasOn = parseOnOff(before, name);
+            var isOn = parseOnOff(after, name);
+            if (wasOn === null || isOn === null || wasOn === isOn) return null;
+            toggles.push({
+                name: name,
+                turnedOn: isOn
+            });
+        }
+    } catch (err) {
+        _didIteratorError = true;
+        _iteratorError = err;
+    } finally{
+        try {
+            if (!_iteratorNormalCompletion && _iterator.return != null) {
+                _iterator.return();
+            }
+        } finally{
+            if (_didIteratorError) {
+                throw _iteratorError;
+            }
+        }
+    }
+    return toggles;
+}
+/* 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/feature-scope.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["/Users/kevin/Dev/OpenSource/ai/sensemaking/src/store/feature-scope.ts"],"sourcesContent":["import type { FeatureName } from '../config/index.ts';\n\n// Decomposition of the `feature:<name>:<on|off>` featureSignature segments (config/access.ts's\n// featureSignature), for open()'s narrow feature-toggle invalidation routing.\n\n// Every narrow-supported feature but rank owns one dedicated table, dropped and (turning on)\n// fully re-derived. rank has no table -- it writes PageRank into frontmatter's own `_rank`\n// column -- so builder.ts handles it, and the links/rank pair, as special cases outside this map.\nexport const NARROW_FEATURE_TABLE: Readonly<Record<string, string>> = { tags: 'tags', sections: 'sections', links: 'links' };\n\n// links feeds rank's afterReconcile pass, so a links toggle always co-changes the `feature:rank`\n// segment too (featureEnabled's dependency); both are narrow-supported and builder.ts applies\n// them together. A changed set naming any other feature falls through to the existing full clear.\nconst NARROW_FEATURE_NAMES: ReadonlySet<string> = new Set([...Object.keys(NARROW_FEATURE_TABLE), 'rank']);\n\nexport interface FeatureToggle {\n  name: FeatureName;\n  // true: was off, now on (must fully re-derive). false: was on, now off (drop its rows).\n  turnedOn: boolean;\n}\n\n// Every changed key is a `feature:<name>` segment for a narrow-supported feature.\nexport function isFeatureOnlyChange(changedKeys: ReadonlySet<string>): boolean {\n  return changedKeys.size > 0 && [...changedKeys].every((key) => key.startsWith('feature:') && NARROW_FEATURE_NAMES.has(key.slice('feature:'.length)));\n}\n\n// One feature segment's old on/off, read back out of a stored `feature:<name>:on|off` segment.\n// Anything not in that exact shape returns null so the caller falls back to a full rebuild.\nfunction parseOnOff(sig: string, name: string): boolean | null {\n  const part = sig.split('|').find((p) => p.startsWith(`feature:${name}:`));\n  if (part === undefined) return null;\n  const fields = part.split(':');\n  if (fields.length !== 3 || (fields[2] !== 'on' && fields[2] !== 'off')) return null;\n  return fields[2] === 'on';\n}\n\n// Old-vs-new on/off for every changed feature key, or null when a segment can't be parsed back\n// out of `before` or `after`, or when it parses to the same state on both sides (should never\n// happen for a genuinely changed key) -- either way the caller takes the full rebuild.\nexport function classifyFeatureToggles(before: string, after: string, changedKeys: ReadonlySet<string>): FeatureToggle[] | null {\n  const toggles: FeatureToggle[] = [];\n  for (const key of changedKeys) {\n    const name = key.slice('feature:'.length) as FeatureName;\n    const wasOn = parseOnOff(before, name);\n    const isOn = parseOnOff(after, name);\n    if (wasOn === null || isOn === null || wasOn === isOn) return null;\n    toggles.push({ name, turnedOn: isOn });\n  }\n  return toggles;\n}\n"],"names":["NARROW_FEATURE_TABLE","classifyFeatureToggles","isFeatureOnlyChange","tags","sections","links","NARROW_FEATURE_NAMES","Set","Object","keys","changedKeys","size","every","key","startsWith","has","slice","length","parseOnOff","sig","name","part","split","find","p","undefined","fields","before","after","toggles","wasOn","isOn","push","turnedOn"],"mappings":";;;;;;;;;;;QAQaA;eAAAA;;QA+BGC;eAAAA;;QAjBAC;eAAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAdT,IAAMF,uBAAyD;IAAEG,MAAM;IAAQC,UAAU;IAAYC,OAAO;AAAQ;AAE3H,iGAAiG;AACjG,8FAA8F;AAC9F,kGAAkG;AAClG,IAAMC,uBAA4C,IAAIC,IAAI,AAAC,qBAAGC,OAAOC,IAAI,CAACT,8BAAhB;IAAuC;CAAO;AASjG,SAASE,oBAAoBQ,WAAgC;IAClE,OAAOA,YAAYC,IAAI,GAAG,KAAK,AAAC,qBAAGD,aAAaE,KAAK,CAAC,SAACC;eAAQA,IAAIC,UAAU,CAAC,eAAeR,qBAAqBS,GAAG,CAACF,IAAIG,KAAK,CAAC,WAAWC,MAAM;;AACnJ;AAEA,+FAA+F;AAC/F,4FAA4F;AAC5F,SAASC,WAAWC,GAAW,EAAEC,IAAY;IAC3C,IAAMC,OAAOF,IAAIG,KAAK,CAAC,KAAKC,IAAI,CAAC,SAACC;eAAMA,EAAEV,UAAU,CAAC,AAAC,WAAe,OAALM,MAAK;;IACrE,IAAIC,SAASI,WAAW,OAAO;IAC/B,IAAMC,SAASL,KAAKC,KAAK,CAAC;IAC1B,IAAII,OAAOT,MAAM,KAAK,KAAMS,MAAM,CAAC,EAAE,KAAK,QAAQA,MAAM,CAAC,EAAE,KAAK,OAAQ,OAAO;IAC/E,OAAOA,MAAM,CAAC,EAAE,KAAK;AACvB;AAKO,SAASzB,uBAAuB0B,MAAc,EAAEC,KAAa,EAAElB,WAAgC;IACpG,IAAMmB,UAA2B,EAAE;QAC9B,kCAAA,2BAAA;;QAAL,QAAK,YAAanB,gCAAb,SAAA,6BAAA,QAAA,yBAAA,iCAA0B;YAA1B,IAAMG,MAAN;YACH,IAAMO,OAAOP,IAAIG,KAAK,CAAC,WAAWC,MAAM;YACxC,IAAMa,QAAQZ,WAAWS,QAAQP;YACjC,IAAMW,OAAOb,WAAWU,OAAOR;YAC/B,IAAIU,UAAU,QAAQC,SAAS,QAAQD,UAAUC,MAAM,OAAO;YAC9DF,QAAQG,IAAI,CAAC;gBAAEZ,MAAAA;gBAAMa,UAAUF;YAAK;QACtC;;QANK;QAAA;;;iBAAA,6BAAA;gBAAA;;;gBAAA;sBAAA;;;;IAOL,OAAOF;AACT"}

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

@@ -1,10 +1,15 @@
 import type { ResolvedConfig } from '../config/index.js';
-import type { OpenResult } from './sqlite/open.js';
+import type { Builder } from './builder.js';
+import type { OpenResult } from './open.js';
 export declare function openStore(cfg: ResolvedConfig): Promise<OpenResult>;
+export declare function openStoreForWatch(cfg: ResolvedConfig): Promise<OpenResult & {
+    builder: Builder;
+}>;
 export declare function requireWatchConcurrency(cfg: ResolvedConfig): void;
 export { clearCache } from './cache.js';
+export type { OpenResult } from './open.js';
+export { docCount } from './open.js';
 export { getMeta, setMeta } from './shared.js';
-export type { OpenResult } from './sqlite/open.js';
-export { DB_FILENAME, docCount, SCHEMA_VERSION } from './sqlite/open.js';
+export { DB_FILENAME, SCHEMA_VERSION } from './sqlite/open.js';
 export type { Capability, Connection, DocumentStore, LexicalHit, LexicalIndex, LexicalQueryOptions, RawStatement, RunResult, SqlSession, Statement, Store, VectorCandidate, VectorSimilar, VectorStore, VectorWriteRow } from './types.js';
 export { CAPABILITY_NAMES } from './types.js';

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

@@ -1,10 +1,15 @@
 import type { ResolvedConfig } from '../config/index.js';
-import type { OpenResult } from './sqlite/open.js';
+import type { Builder } from './builder.js';
+import type { OpenResult } from './open.js';
 export declare function openStore(cfg: ResolvedConfig): Promise<OpenResult>;
+export declare function openStoreForWatch(cfg: ResolvedConfig): Promise<OpenResult & {
+    builder: Builder;
+}>;
 export declare function requireWatchConcurrency(cfg: ResolvedConfig): void;
 export { clearCache } from './cache.js';
+export type { OpenResult } from './open.js';
+export { docCount } from './open.js';
 export { getMeta, setMeta } from './shared.js';
-export type { OpenResult } from './sqlite/open.js';
-export { DB_FILENAME, docCount, SCHEMA_VERSION } from './sqlite/open.js';
+export { DB_FILENAME, SCHEMA_VERSION } from './sqlite/open.js';
 export type { Capability, Connection, DocumentStore, LexicalHit, LexicalIndex, LexicalQueryOptions, RawStatement, RunResult, SqlSession, Statement, Store, VectorCandidate, VectorSimilar, VectorStore, VectorWriteRow } from './types.js';
 export { CAPABILITY_NAMES } from './types.js';

package/dist/cjs/store/index.js

@@ -15,10 +15,10 @@ _export(exports, {
         return _typests.CAPABILITY_NAMES;
     },
     get DB_FILENAME () {
-        return _opents1.DB_FILENAME;
+        return _opents2.DB_FILENAME;
     },
     get SCHEMA_VERSION () {
-        return _opents1.SCHEMA_VERSION;
+        return _opents2.SCHEMA_VERSION;
     },
     get clearCache () {
         return _cachets.clearCache;
@@ -32,6 +32,9 @@ _export(exports, {
     get openStore () {
         return openStore;
     },
+    get openStoreForWatch () {
+        return openStoreForWatch;
+    },
     get requireWatchConcurrency () {
         return requireWatchConcurrency;
     },
@@ -43,9 +46,10 @@ var _indexts = require("../config/index.js");
 var _errorsts = require("../errors.js");
 var _opents = require("./duckdb/open.js");
 var _storets = require("./duckdb/store.js");
-var _opents1 = require("./sqlite/open.js");
+var _opents1 = require("./open.js");
+var _opents2 = require("./sqlite/open.js");
 var _storets1 = require("./sqlite/store.js");
-var _opents2 = require("./turso/open.js");
+var _opents3 = require("./turso/open.js");
 var _storets2 = require("./turso/store.js");
 var _cachets = require("./cache.js");
 var _sharedts = require("./shared.js");
@@ -180,15 +184,24 @@ function _ts_generator(thisArg, body) {
 var REGISTRY = {
     sqlite: {
         capabilities: _storets1.CAPABILITIES,
-        open: _opents1.openSqlite
+        open: _opents2.openSqlite,
+        openForWatch: function openForWatch(cfg) {
+            return (0, _opents1.openWithBuilder)(cfg, _opents2.sqliteOpenDialect);
+        }
     },
     duckdb: {
         capabilities: _storets.CAPABILITIES,
-        open: _opents.openDuckdb
+        open: _opents.openDuckdb,
+        openForWatch: function openForWatch(cfg) {
+            return (0, _opents1.openWithBuilder)(cfg, _opents.duckdbOpenDialect);
+        }
     },
     turso: {
         capabilities: _storets2.CAPABILITIES,
-        open: _opents2.openTurso
+        open: _opents3.openTurso,
+        openForWatch: function openForWatch(cfg) {
+            return (0, _opents1.openWithBuilder)(cfg, _opents3.tursoOpenDialect);
+        }
     }
 };
 function entryFor(name) {
@@ -214,6 +227,22 @@ function openStore(cfg) {
         });
     })();
 }
+function openStoreForWatch(cfg) {
+    return _async_to_generator(function() {
+        var name, entry;
+        return _ts_generator(this, function(_state) {
+            name = (0, _indexts.storeName)(cfg);
+            entry = entryFor(name);
+            if ((0, _indexts.anyPresetEmbeds)(cfg) && !entry.capabilities.has('vectors')) {
+                throw new _errorsts.SenseError('STORE_CAPABILITY_MISSING', 'store "'.concat(name, '" does not implement "vectors" in this build, but this config\'s "embed" block is in use by at least one preset; remove or narrow it, or set "store" to a store that supports vectors (sqlite)'));
+            }
+            return [
+                2,
+                entry.openForWatch(cfg)
+            ];
+        });
+    })();
+}
 function requireWatchConcurrency(cfg) {
     var name = (0, _indexts.storeName)(cfg);
     if (!entryFor(name).capabilities.has('watch-concurrency')) {

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

@@ -1 +1 @@
-{"version":3,"sources":["/Users/kevin/Dev/OpenSource/ai/sensemaking/src/store/index.ts"],"sourcesContent":["// Rows -> a backing store: registry + openStore(cfg). Parsing lives in scan.ts; everything\n// beyond frontmatter + content lives in src/features/.\n\nimport type { ResolvedConfig, StoreName } from '../config/index.ts';\nimport { anyPresetEmbeds, storeName } from '../config/index.ts';\nimport { SenseError } from '../errors.ts';\nimport { openDuckdb } from './duckdb/open.ts';\nimport { CAPABILITIES as DUCKDB_CAPABILITIES } from './duckdb/store.ts';\nimport type { OpenResult } from './sqlite/open.ts';\nimport { openSqlite } from './sqlite/open.ts';\nimport { CAPABILITIES as SQLITE_CAPABILITIES } from './sqlite/store.ts';\nimport { openTurso } from './turso/open.ts';\nimport { CAPABILITIES as TURSO_CAPABILITIES } from './turso/store.ts';\nimport type { Capability } from './types.ts';\n\ninterface StoreEntry {\n  capabilities: ReadonlySet<Capability>;\n  open: (cfg: ResolvedConfig) => Promise<OpenResult>;\n}\n\n// Capabilities are checked against the registry entry before opening (no wasted connect/reconcile\n// work for a config that cannot be satisfied), then the store itself opens.\nconst REGISTRY: Record<StoreName, StoreEntry> = {\n  sqlite: { capabilities: SQLITE_CAPABILITIES, open: openSqlite },\n  duckdb: { capabilities: DUCKDB_CAPABILITIES, open: openDuckdb },\n  turso: { capabilities: TURSO_CAPABILITIES, open: openTurso },\n};\n\nfunction entryFor(name: StoreName): StoreEntry {\n  const entry = REGISTRY[name];\n  if (!entry) throw new SenseError('STORE_UNKNOWN', `unknown backing store \"${name}\"; available: ${Object.keys(REGISTRY).join(', ')}`);\n  return entry;\n}\n\nexport async function openStore(cfg: ResolvedConfig): Promise<OpenResult> {\n  const name = storeName(cfg);\n  const entry = entryFor(name);\n\n  // The one unambiguous, config-level capability need: an embed block some preset actually uses\n  // for vectors. Lexical search has no such signal at this level (every preset defaults to \"words\"), so a store lacking it fails loudly at first use.\n  if (anyPresetEmbeds(cfg) && !entry.capabilities.has('vectors')) {\n    throw new SenseError('STORE_CAPABILITY_MISSING', `store \"${name}\" does not implement \"vectors\" in this build, but this config's \"embed\" block is in use by at least one preset; remove or narrow it, or set \"store\" to a store that supports vectors (sqlite)`);\n  }\n\n  return entry.open(cfg);\n}\n\n// watch keeps its connection open for the run, so a file-locking store would fail every\n// other command on the tree; check before open, as openStore does for \"vectors\".\nexport function requireWatchConcurrency(cfg: ResolvedConfig): void {\n  const name = storeName(cfg);\n  if (!entryFor(name).capabilities.has('watch-concurrency')) {\n    throw new SenseError('STORE_CAPABILITY_MISSING', `store \"${name}\" does not implement \"watch-concurrency\" in this build; sense watch holds the store open for its whole run, and this store locks the cache file, so every other command on this tree would fail to open; set \"store\" to \"sqlite\" in sense.config.json`);\n  }\n}\n\nexport { clearCache } from './cache.ts';\nexport { getMeta, setMeta } from './shared.ts';\nexport type { OpenResult } from './sqlite/open.ts';\nexport { DB_FILENAME, docCount, SCHEMA_VERSION } from './sqlite/open.ts';\nexport type { Capability, Connection, DocumentStore, LexicalHit, LexicalIndex, LexicalQueryOptions, RawStatement, RunResult, SqlSession, Statement, Store, VectorCandidate, VectorSimilar, VectorStore, VectorWriteRow } from './types.ts';\nexport { CAPABILITY_NAMES } from './types.ts';\n"],"names":["CAPABILITY_NAMES","DB_FILENAME","SCHEMA_VERSION","clearCache","docCount","getMeta","openStore","requireWatchConcurrency","setMeta","REGISTRY","sqlite","capabilities","SQLITE_CAPABILITIES","open","openSqlite","duckdb","DUCKDB_CAPABILITIES","openDuckdb","turso","TURSO_CAPABILITIES","openTurso","entryFor","name","entry","SenseError","Object","keys","join","cfg","storeName","anyPresetEmbeds","has"],"mappings":"AAAA,2FAA2F;AAC3F,uDAAuD;;;;;;;;;;;;QA4D9CA;eAAAA,yBAAgB;;QAFhBC;eAAAA,oBAAW;;QAAYC;eAAAA,uBAAc;;QAHrCC;eAAAA,mBAAU;;QAGGC;eAAAA,iBAAQ;;QAFrBC;eAAAA,iBAAO;;QAvBMC;eAAAA;;QAeNC;eAAAA;;QAQEC;eAAAA,iBAAO;;;uBArDkB;wBAChB;sBACA;uBACyB;uBAEzB;wBACyB;uBAC1B;wBACyB;uBA4CxB;wBACM;uBAIA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAzCjC,kGAAkG;AAClG,4EAA4E;AAC5E,IAAMC,WAA0C;IAC9CC,QAAQ;QAAEC,cAAcC,sBAAmB;QAAEC,MAAMC,mBAAU;IAAC;IAC9DC,QAAQ;QAAEJ,cAAcK,qBAAmB;QAAEH,MAAMI,kBAAU;IAAC;IAC9DC,OAAO;QAAEP,cAAcQ,sBAAkB;QAAEN,MAAMO,kBAAS;IAAC;AAC7D;AAEA,SAASC,SAASC,IAAe;IAC/B,IAAMC,QAAQd,QAAQ,CAACa,KAAK;IAC5B,IAAI,CAACC,OAAO,MAAM,IAAIC,oBAAU,CAAC,iBAAiB,AAAC,0BAA8CC,OAArBH,MAAK,kBAAiD,OAAjCG,OAAOC,IAAI,CAACjB,UAAUkB,IAAI,CAAC;IAC5H,OAAOJ;AACT;AAEO,SAAejB,UAAUsB,GAAmB;;YAC3CN,MACAC;;YADAD,OAAOO,IAAAA,kBAAS,EAACD;YACjBL,QAAQF,SAASC;YAEvB,8FAA8F;YAC9F,oJAAoJ;YACpJ,IAAIQ,IAAAA,wBAAe,EAACF,QAAQ,CAACL,MAAMZ,YAAY,CAACoB,GAAG,CAAC,YAAY;gBAC9D,MAAM,IAAIP,oBAAU,CAAC,4BAA4B,AAAC,UAAc,OAALF,MAAK;YAClE;YAEA;;gBAAOC,MAAMV,IAAI,CAACe;;;IACpB;;AAIO,SAASrB,wBAAwBqB,GAAmB;IACzD,IAAMN,OAAOO,IAAAA,kBAAS,EAACD;IACvB,IAAI,CAACP,SAASC,MAAMX,YAAY,CAACoB,GAAG,CAAC,sBAAsB;QACzD,MAAM,IAAIP,oBAAU,CAAC,4BAA4B,AAAC,UAAc,OAALF,MAAK;IAClE;AACF"}
+{"version":3,"sources":["/Users/kevin/Dev/OpenSource/ai/sensemaking/src/store/index.ts"],"sourcesContent":["// Rows -> a backing store: registry + openStore(cfg). Parsing lives in scan.ts; everything\n// beyond frontmatter + content lives in src/features/.\n\nimport type { ResolvedConfig, StoreName } from '../config/index.ts';\nimport { anyPresetEmbeds, storeName } from '../config/index.ts';\nimport { SenseError } from '../errors.ts';\nimport type { Builder } from './builder.ts';\nimport { duckdbOpenDialect, openDuckdb } from './duckdb/open.ts';\nimport { CAPABILITIES as DUCKDB_CAPABILITIES } from './duckdb/store.ts';\nimport type { OpenResult } from './open.ts';\nimport { openWithBuilder } from './open.ts';\nimport { openSqlite, sqliteOpenDialect } from './sqlite/open.ts';\nimport { CAPABILITIES as SQLITE_CAPABILITIES } from './sqlite/store.ts';\nimport { openTurso, tursoOpenDialect } from './turso/open.ts';\nimport { CAPABILITIES as TURSO_CAPABILITIES } from './turso/store.ts';\nimport type { Capability } from './types.ts';\n\ninterface StoreEntry {\n  capabilities: ReadonlySet<Capability>;\n  open: (cfg: ResolvedConfig) => Promise<OpenResult>;\n  // Same open, but keeps the builder's parse pool alive and hands it back: only a watcher, which\n  // reconciles repeatedly on the same connection, needs this.\n  openForWatch: (cfg: ResolvedConfig) => Promise<OpenResult & { builder: Builder }>;\n}\n\n// Capabilities are checked against the registry entry before opening (no wasted connect/reconcile\n// work for a config that cannot be satisfied), then the store itself opens.\nconst REGISTRY: Record<StoreName, StoreEntry> = {\n  sqlite: { capabilities: SQLITE_CAPABILITIES, open: openSqlite, openForWatch: (cfg) => openWithBuilder(cfg, sqliteOpenDialect) },\n  duckdb: { capabilities: DUCKDB_CAPABILITIES, open: openDuckdb, openForWatch: (cfg) => openWithBuilder(cfg, duckdbOpenDialect) },\n  turso: { capabilities: TURSO_CAPABILITIES, open: openTurso, openForWatch: (cfg) => openWithBuilder(cfg, tursoOpenDialect) },\n};\n\nfunction entryFor(name: StoreName): StoreEntry {\n  const entry = REGISTRY[name];\n  if (!entry) throw new SenseError('STORE_UNKNOWN', `unknown backing store \"${name}\"; available: ${Object.keys(REGISTRY).join(', ')}`);\n  return entry;\n}\n\nexport async function openStore(cfg: ResolvedConfig): Promise<OpenResult> {\n  const name = storeName(cfg);\n  const entry = entryFor(name);\n\n  // The one unambiguous, config-level capability need: an embed block some preset actually uses\n  // for vectors. Lexical search has no such signal at this level (every preset defaults to \"words\"), so a store lacking it fails loudly at first use.\n  if (anyPresetEmbeds(cfg) && !entry.capabilities.has('vectors')) {\n    throw new SenseError('STORE_CAPABILITY_MISSING', `store \"${name}\" does not implement \"vectors\" in this build, but this config's \"embed\" block is in use by at least one preset; remove or narrow it, or set \"store\" to a store that supports vectors (sqlite)`);\n  }\n\n  return entry.open(cfg);\n}\n\n// Same capability-checked open as openStore, but for a caller (only src/watch.ts) that must\n// reconcile again later: keeps the builder's pool warm and hands it back instead of closing it.\nexport async function openStoreForWatch(cfg: ResolvedConfig): Promise<OpenResult & { builder: Builder }> {\n  const name = storeName(cfg);\n  const entry = entryFor(name);\n\n  if (anyPresetEmbeds(cfg) && !entry.capabilities.has('vectors')) {\n    throw new SenseError('STORE_CAPABILITY_MISSING', `store \"${name}\" does not implement \"vectors\" in this build, but this config's \"embed\" block is in use by at least one preset; remove or narrow it, or set \"store\" to a store that supports vectors (sqlite)`);\n  }\n\n  return entry.openForWatch(cfg);\n}\n\n// watch keeps its connection open for the run, so a file-locking store would fail every\n// other command on the tree; check before open, as openStore does for \"vectors\".\nexport function requireWatchConcurrency(cfg: ResolvedConfig): void {\n  const name = storeName(cfg);\n  if (!entryFor(name).capabilities.has('watch-concurrency')) {\n    throw new SenseError('STORE_CAPABILITY_MISSING', `store \"${name}\" does not implement \"watch-concurrency\" in this build; sense watch holds the store open for its whole run, and this store locks the cache file, so every other command on this tree would fail to open; set \"store\" to \"sqlite\" in sense.config.json`);\n  }\n}\n\nexport { clearCache } from './cache.ts';\nexport type { OpenResult } from './open.ts';\nexport { docCount } from './open.ts';\nexport { getMeta, setMeta } from './shared.ts';\nexport { DB_FILENAME, SCHEMA_VERSION } from './sqlite/open.ts';\nexport type { Capability, Connection, DocumentStore, LexicalHit, LexicalIndex, LexicalQueryOptions, RawStatement, RunResult, SqlSession, Statement, Store, VectorCandidate, VectorSimilar, VectorStore, VectorWriteRow } from './types.ts';\nexport { CAPABILITY_NAMES } from './types.ts';\n"],"names":["CAPABILITY_NAMES","DB_FILENAME","SCHEMA_VERSION","clearCache","docCount","getMeta","openStore","openStoreForWatch","requireWatchConcurrency","setMeta","REGISTRY","sqlite","capabilities","SQLITE_CAPABILITIES","open","openSqlite","openForWatch","cfg","openWithBuilder","sqliteOpenDialect","duckdb","DUCKDB_CAPABILITIES","openDuckdb","duckdbOpenDialect","turso","TURSO_CAPABILITIES","openTurso","tursoOpenDialect","entryFor","name","entry","SenseError","Object","keys","join","storeName","anyPresetEmbeds","has"],"mappings":"AAAA,2FAA2F;AAC3F,uDAAuD;;;;;;;;;;;;QA+E9CA;eAAAA,yBAAgB;;QAFhBC;eAAAA,oBAAW;;QAAEC;eAAAA,uBAAc;;QAJ3BC;eAAAA,mBAAU;;QAEVC;eAAAA,iBAAQ;;QACRC;eAAAA,iBAAO;;QAtCMC;eAAAA;;QAeAC;eAAAA;;QAaNC;eAAAA;;QAUEC;eAAAA,iBAAO;;;uBAzEkB;wBAChB;sBAEmB;uBACM;uBAEpB;uBACc;wBACM;uBACR;wBACO;uBA4DxB;wBAGM;uBAGA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAvDjC,kGAAkG;AAClG,4EAA4E;AAC5E,IAAMC,WAA0C;IAC9CC,QAAQ;QAAEC,cAAcC,sBAAmB;QAAEC,MAAMC,mBAAU;QAAEC,cAAc,SAAdA,aAAeC;mBAAQC,IAAAA,wBAAe,EAACD,KAAKE,0BAAiB;;IAAE;IAC9HC,QAAQ;QAAER,cAAcS,qBAAmB;QAAEP,MAAMQ,kBAAU;QAAEN,cAAc,SAAdA,aAAeC;mBAAQC,IAAAA,wBAAe,EAACD,KAAKM,yBAAiB;;IAAE;IAC9HC,OAAO;QAAEZ,cAAca,sBAAkB;QAAEX,MAAMY,kBAAS;QAAEV,cAAc,SAAdA,aAAeC;mBAAQC,IAAAA,wBAAe,EAACD,KAAKU,yBAAgB;;IAAE;AAC5H;AAEA,SAASC,SAASC,IAAe;IAC/B,IAAMC,QAAQpB,QAAQ,CAACmB,KAAK;IAC5B,IAAI,CAACC,OAAO,MAAM,IAAIC,oBAAU,CAAC,iBAAiB,AAAC,0BAA8CC,OAArBH,MAAK,kBAAiD,OAAjCG,OAAOC,IAAI,CAACvB,UAAUwB,IAAI,CAAC;IAC5H,OAAOJ;AACT;AAEO,SAAexB,UAAUW,GAAmB;;YAC3CY,MACAC;;YADAD,OAAOM,IAAAA,kBAAS,EAAClB;YACjBa,QAAQF,SAASC;YAEvB,8FAA8F;YAC9F,oJAAoJ;YACpJ,IAAIO,IAAAA,wBAAe,EAACnB,QAAQ,CAACa,MAAMlB,YAAY,CAACyB,GAAG,CAAC,YAAY;gBAC9D,MAAM,IAAIN,oBAAU,CAAC,4BAA4B,AAAC,UAAc,OAALF,MAAK;YAClE;YAEA;;gBAAOC,MAAMhB,IAAI,CAACG;;;IACpB;;AAIO,SAAeV,kBAAkBU,GAAmB;;YACnDY,MACAC;;YADAD,OAAOM,IAAAA,kBAAS,EAAClB;YACjBa,QAAQF,SAASC;YAEvB,IAAIO,IAAAA,wBAAe,EAACnB,QAAQ,CAACa,MAAMlB,YAAY,CAACyB,GAAG,CAAC,YAAY;gBAC9D,MAAM,IAAIN,oBAAU,CAAC,4BAA4B,AAAC,UAAc,OAALF,MAAK;YAClE;YAEA;;gBAAOC,MAAMd,YAAY,CAACC;;;IAC5B;;AAIO,SAAST,wBAAwBS,GAAmB;IACzD,IAAMY,OAAOM,IAAAA,kBAAS,EAAClB;IACvB,IAAI,CAACW,SAASC,MAAMjB,YAAY,CAACyB,GAAG,CAAC,sBAAsB;QACzD,MAAM,IAAIN,oBAAU,CAAC,4BAA4B,AAAC,UAAc,OAALF,MAAK;IAClE;AACF"}

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

@@ -0,0 +1,15 @@
+import type { ResolvedConfig } from '../config/index.js';
+import type { Builder } from './builder.js';
+import type { OpenDialect, Store } from './types.js';
+export interface OpenResult {
+    store: Store;
+    cfg: ResolvedConfig;
+    dbPath: string;
+    parsed: number;
+    warnings: string[];
+}
+export declare function openWithDialect<Handle>(cfg: ResolvedConfig, dialect: OpenDialect<Handle>): Promise<OpenResult>;
+export declare function openWithBuilder<Handle>(cfg: ResolvedConfig, dialect: OpenDialect<Handle>): Promise<OpenResult & {
+    builder: Builder;
+}>;
+export declare function docCount(store: Store): Promise<number>;

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

@@ -0,0 +1,15 @@
+import type { ResolvedConfig } from '../config/index.js';
+import type { Builder } from './builder.js';
+import type { OpenDialect, Store } from './types.js';
+export interface OpenResult {
+    store: Store;
+    cfg: ResolvedConfig;
+    dbPath: string;
+    parsed: number;
+    warnings: string[];
+}
+export declare function openWithDialect<Handle>(cfg: ResolvedConfig, dialect: OpenDialect<Handle>): Promise<OpenResult>;
+export declare function openWithBuilder<Handle>(cfg: ResolvedConfig, dialect: OpenDialect<Handle>): Promise<OpenResult & {
+    builder: Builder;
+}>;
+export declare function docCount(store: Store): Promise<number>;