sensemaking 0.25.0 → 0.26.0

package/dist/cjs/features/embed.js

@@ -10,6 +10,7 @@ Object.defineProperty(exports, "embed", {
 });
 var _indexts = require("../chunk/index.js");
 var _indexts1 = require("../config/index.js");
+var _endpointts = require("../embed/endpoint.js");
 var _handoffts = require("../embed/handoff.js");
 var _identityts = require("../embed/identity.js");
 var _frontmatterts = require("../scan/frontmatter.js");
@@ -139,6 +140,27 @@ function _ts_generator(thisArg, body) {
         };
     }
 }
+function _ts_values(o) {
+    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
+    if (m) {
+        return m.call(o);
+    }
+    if (o && typeof o.length === "number") {
+        return {
+            next: function() {
+                if (o && i >= o.length) {
+                    o = void 0;
+                }
+                return {
+                    value: o && o[i++],
+                    done: !o
+                };
+            }
+        };
+    }
+    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
+}
+var CHUNK_LOOKUP_PAGE = 512;
 // The title/summary prefix mirrors bm25 field weighting. Chunks the body, not the raw file, so
 // `offset` shifts line numbers back onto raw and a range stays a direct Read range.
 function chunksOf(blocks, body, search) {
@@ -168,7 +190,7 @@ var embed = {
                     case 0:
                         return [
                             4,
-                            db.exec('CREATE TABLE IF NOT EXISTS embeddings ("path" TEXT, chunk INTEGER, start_line INTEGER, end_line INTEGER, scale REAL, vector BLOB, PRIMARY KEY ("path", chunk))')
+                            db.exec('CREATE TABLE IF NOT EXISTS embeddings ("path" TEXT, chunk INTEGER, start_line INTEGER, end_line INTEGER, content_identity TEXT NOT NULL, scale REAL, vector BLOB, PRIMARY KEY ("path", chunk))')
                         ];
                     case 1:
                         _state.sent();
@@ -185,19 +207,24 @@ var embed = {
         // blocks comes from parseFile's shared parse; falls back to parsing body for a direct call.
         return chunksOf(blocks !== null && blocks !== void 0 ? blocks : (0, _indexts.parse)(body), body, search, (0, _frontmatterts.countLines)(raw) - (0, _frontmatterts.countLines)(body), cfg === null || cfg === void 0 ? void 0 : (_cfg_embed = cfg.embed) === null || _cfg_embed === void 0 ? void 0 : _cfg_embed.chunkTokens);
     },
-    remove: function remove(db, paths) {
+    remove: function remove(db, paths, delta) {
         return _async_to_generator(function() {
+            var vanishedSet, vanished;
             return _ts_generator(this, function(_state) {
                 switch(_state.label){
                     case 0:
-                        if (paths.length === 0) return [
+                        vanishedSet = new Set(delta.vanished);
+                        vanished = paths.filter(function(path) {
+                            return vanishedSet.has(path);
+                        });
+                        if (vanished.length === 0) return [
                             2
                         ];
                         return [
                             4,
-                            db.runBatch('DELETE FROM embeddings WHERE "path" = ?', paths.map(function(p) {
+                            db.runBatch('DELETE FROM embeddings WHERE "path" = ?', vanished.map(function(path) {
                                 return [
-                                    p
+                                    path
                                 ];
                             }))
                         ];
@@ -212,50 +239,268 @@ var embed = {
     },
     store: // A tree with no embedding model never had extract() run for the doc (reconcile.ts's per-file
     // filter skips it), so extracted is undefined here -- those docs contribute no rows.
-    function store(db, docs) {
+    function store(db, docs, delta) {
         return _async_to_generator(function() {
-            var rows, texts, _iteratorNormalCompletion, _didIteratorError, _iteratorError, _loop, _iterator, _step;
+            var rows, texts, added, firstPage, nextPage, _iteratorNormalCompletion, _didIteratorError, _iteratorError, _loop, _iterator, _step, err;
             return _ts_generator(this, function(_state) {
                 switch(_state.label){
                     case 0:
                         rows = [];
                         texts = new Map();
+                        added = new Set(delta.added);
                         _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+                        _state.label = 1;
+                    case 1:
+                        _state.trys.push([
+                            1,
+                            6,
+                            7,
+                            8
+                        ]);
+                        _loop = function() {
+                            var _step_value, path, extracted, chunks, identified, kept, cursor, page, _tmp, _tmp1, removed, moved, _iteratorNormalCompletion, _didIteratorError, _iteratorError, _iterator, _step1, old, index, chunk, before;
+                            return _ts_generator(this, function(_state) {
+                                switch(_state.label){
+                                    case 0:
+                                        _step_value = _step.value, path = _step_value.path, extracted = _step_value.extracted;
+                                        chunks = extracted !== null && extracted !== void 0 ? extracted : [];
+                                        if (!(chunks.length === 0)) return [
+                                            3,
+                                            3
+                                        ];
+                                        if (!!added.has(path)) return [
+                                            3,
+                                            2
+                                        ];
+                                        return [
+                                            4,
+                                            db.runBatch('DELETE FROM embeddings WHERE "path" = ?', [
+                                                [
+                                                    path
+                                                ]
+                                            ])
+                                        ];
+                                    case 1:
+                                        _state.sent();
+                                        _state.label = 2;
+                                    case 2:
+                                        return [
+                                            2,
+                                            "continue"
+                                        ];
+                                    case 3:
+                                        identified = chunks.map(function(chunk) {
+                                            return (0, _handoffts.identifyChunkText)(chunk.text);
+                                        });
+                                        kept = new Set();
+                                        if (!!added.has(path)) return [
+                                            3,
+                                            20
+                                        ];
+                                        cursor = void 0;
+                                        _state.label = 4;
+                                    case 4:
+                                        page = void 0;
+                                        if (!(cursor === undefined)) return [
+                                            3,
+                                            9
+                                        ];
+                                        if (!(firstPage !== null && firstPage !== void 0)) return [
+                                            3,
+                                            5
+                                        ];
+                                        _tmp = firstPage;
+                                        return [
+                                            3,
+                                            7
+                                        ];
+                                    case 5:
+                                        return [
+                                            4,
+                                            db.prepare('SELECT chunk, start_line, end_line, content_identity FROM embeddings WHERE "path" = ? ORDER BY chunk LIMIT '.concat(CHUNK_LOOKUP_PAGE))
+                                        ];
+                                    case 6:
+                                        _tmp = firstPage = _state.sent();
+                                        _state.label = 7;
+                                    case 7:
+                                        _tmp;
+                                        return [
+                                            4,
+                                            firstPage.all(path)
+                                        ];
+                                    case 8:
+                                        page = _state.sent();
+                                        return [
+                                            3,
+                                            14
+                                        ];
+                                    case 9:
+                                        if (!(nextPage !== null && nextPage !== void 0)) return [
+                                            3,
+                                            10
+                                        ];
+                                        _tmp1 = nextPage;
+                                        return [
+                                            3,
+                                            12
+                                        ];
+                                    case 10:
+                                        return [
+                                            4,
+                                            db.prepare('SELECT chunk, start_line, end_line, content_identity FROM embeddings WHERE "path" = ? AND chunk > ? ORDER BY chunk LIMIT '.concat(CHUNK_LOOKUP_PAGE))
+                                        ];
+                                    case 11:
+                                        _tmp1 = nextPage = _state.sent();
+                                        _state.label = 12;
+                                    case 12:
+                                        _tmp1;
+                                        return [
+                                            4,
+                                            nextPage.all(path, cursor)
+                                        ];
+                                    case 13:
+                                        page = _state.sent();
+                                        _state.label = 14;
+                                    case 14:
+                                        removed = [];
+                                        moved = [];
+                                        _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+                                        try {
+                                            for(_iterator = page[Symbol.iterator](); !(_iteratorNormalCompletion = (_step1 = _iterator.next()).done); _iteratorNormalCompletion = true){
+                                                old = _step1.value;
+                                                index = Number(old.chunk);
+                                                chunk = chunks[index];
+                                                if (!chunk || old.content_identity !== identified[index].identity) {
+                                                    removed.push([
+                                                        path,
+                                                        index
+                                                    ]);
+                                                } else {
+                                                    kept.add(index);
+                                                    if (Number(old.start_line) !== chunk.startLine || Number(old.end_line) !== chunk.endLine) moved.push([
+                                                        chunk.startLine,
+                                                        chunk.endLine,
+                                                        path,
+                                                        index
+                                                    ]);
+                                                }
+                                            }
+                                        } catch (err) {
+                                            _didIteratorError = true;
+                                            _iteratorError = err;
+                                        } finally{
+                                            try {
+                                                if (!_iteratorNormalCompletion && _iterator.return != null) {
+                                                    _iterator.return();
+                                                }
+                                            } finally{
+                                                if (_didIteratorError) {
+                                                    throw _iteratorError;
+                                                }
+                                            }
+                                        }
+                                        if (!(removed.length > 0)) return [
+                                            3,
+                                            16
+                                        ];
+                                        return [
+                                            4,
+                                            db.runBatch('DELETE FROM embeddings WHERE "path" = ? AND chunk = ?', removed)
+                                        ];
+                                    case 15:
+                                        _state.sent();
+                                        _state.label = 16;
+                                    case 16:
+                                        if (!(moved.length > 0)) return [
+                                            3,
+                                            18
+                                        ];
+                                        return [
+                                            4,
+                                            db.runBatch('UPDATE embeddings SET start_line = ?, end_line = ? WHERE "path" = ? AND chunk = ?', moved)
+                                        ];
+                                    case 17:
+                                        _state.sent();
+                                        _state.label = 18;
+                                    case 18:
+                                        if (page.length < CHUNK_LOOKUP_PAGE) return [
+                                            3,
+                                            20
+                                        ];
+                                        cursor = Number(page[page.length - 1].chunk);
+                                        _state.label = 19;
+                                    case 19:
+                                        return [
+                                            3,
+                                            4
+                                        ];
+                                    case 20:
+                                        before = rows.length;
+                                        chunks.forEach(function(chunk, index) {
+                                            if (!kept.has(index)) rows.push([
+                                                path,
+                                                index,
+                                                chunk.startLine,
+                                                chunk.endLine,
+                                                identified[index].identity
+                                            ]);
+                                        });
+                                        // No new pending rows means no retained handoff. Matching pending rows can use
+                                        // embedPending's exact indexed-source fallback, including after repeated store calls.
+                                        if (rows.length > before) texts.set(path, identified);
+                                        return [
+                                            2
+                                        ];
+                                }
+                            });
+                        };
+                        _iterator = docs[Symbol.iterator]();
+                        _state.label = 2;
+                    case 2:
+                        if (!!(_iteratorNormalCompletion = (_step = _iterator.next()).done)) return [
+                            3,
+                            5
+                        ];
+                        return [
+                            5,
+                            _ts_values(_loop())
+                        ];
+                    case 3:
+                        _state.sent();
+                        _state.label = 4;
+                    case 4:
+                        _iteratorNormalCompletion = true;
+                        return [
+                            3,
+                            2
+                        ];
+                    case 5:
+                        return [
+                            3,
+                            8
+                        ];
+                    case 6:
+                        err = _state.sent();
+                        _didIteratorError = true;
+                        _iteratorError = err;
+                        return [
+                            3,
+                            8
+                        ];
+                    case 7:
                         try {
-                            _loop = function() {
-                                var _step_value = _step.value, path = _step_value.path, extracted = _step_value.extracted;
-                                if (!extracted) return "continue";
-                                var chunks = extracted;
-                                chunks.forEach(function(c, idx) {
-                                    return rows.push([
-                                        path,
-                                        idx,
-                                        c.startLine,
-                                        c.endLine
-                                    ]);
-                                });
-                                texts.set(path, chunks.map(function(c) {
-                                    return c.text;
-                                }));
-                            };
-                            for(_iterator = docs[Symbol.iterator](); !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true)_loop();
-                        } catch (err) {
-                            _didIteratorError = true;
-                            _iteratorError = err;
+                            if (!_iteratorNormalCompletion && _iterator.return != null) {
+                                _iterator.return();
+                            }
                         } finally{
-                            try {
-                                if (!_iteratorNormalCompletion && _iterator.return != null) {
-                                    _iterator.return();
-                                }
-                            } finally{
-                                if (_didIteratorError) {
-                                    throw _iteratorError;
-                                }
+                            if (_didIteratorError) {
+                                throw _iteratorError;
                             }
                         }
-                        if (rows.length === 0) return [
-                            2
+                        return [
+                            7
                         ];
+                    case 8:
                         // scale and vector are written by the embed pass, not here, so they are not in the column list
                         // and take the table's own default on the append path.
                         return [
@@ -264,13 +509,13 @@ var embed = {
                                 'path',
                                 'chunk',
                                 'start_line',
-                                'end_line'
-                            ], 'INSERT INTO embeddings ("path", chunk, start_line, end_line, scale, vector) VALUES (?, ?, ?, ?, NULL, NULL)', rows)
+                                'end_line',
+                                'content_identity'
+                            ], 'INSERT INTO embeddings ("path", chunk, start_line, end_line, content_identity, scale, vector) VALUES (?, ?, ?, ?, ?, NULL, NULL)', rows)
                         ];
-                    case 1:
+                    case 9:
                         _state.sent();
-                        // The text extract() just computed, handed to the embed pass that follows in this same
-                        // process rather than re-derived from the file there (src/embed/handoff.ts).
+                        // Hand off only paths with new pending rows; missing entries use the indexed source.
                         (0, _handoffts.stashChunkText)(db, texts);
                         return [
                             2
@@ -293,7 +538,9 @@ var embed = {
         // W3b: chunkTokens rides the version token, since it's the one owner lever the chunker
         // itself takes -- changing or clearing it must rebuild exactly like a chunker version bump.
         var chunkVersion = e.chunkTokens !== undefined ? "".concat(_indexts.CHUNK_VERSION, ":").concat(e.chunkTokens) : _indexts.CHUNK_VERSION;
-        return "embed:".concat(e.provider, ":").concat(e.model, ":").concat(chunkVersion).concat(identity !== undefined ? "@".concat(identity) : '');
+        var endpoint = (0, _endpointts.embedEndpointIdentity)(e.provider, e.url);
+        var endpointPart = endpoint === undefined ? '' : ":endpoint=".concat(endpoint);
+        return "embed:".concat(e.provider, ":").concat(e.model).concat(endpointPart, ":").concat(chunkVersion).concat(identity !== undefined ? "@".concat(identity) : '');
     }
 };
 /* 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/features/embed.js.map

@@ -1 +1 @@
-{"version":3,"sources":["/Users/kevin/Dev/OpenSource/ai/sensemaking/src/features/embed.ts"],"sourcesContent":["import type { Block, Chunk } from '../chunk/index.ts';\nimport { CHUNK_VERSION, chunkFromBlocks, parse } from '../chunk/index.ts';\nimport { embedConfig } from '../config/index.ts';\nimport { stashChunkText } from '../embed/handoff.ts';\nimport { modelIdentity } from '../embed/identity.ts';\nimport { countLines } from '../scan/frontmatter.ts';\nimport { appendRows } from '../store/shared.ts';\nimport type { Feature } from './types.ts';\n\n// int8 vectors with a per-vector scale, NULL vector = not yet embedded: reconcile writes dirty\n// rows and build (or an authorised scoped CLI query) prepares them before semantic retrieval.\n\nexport type { Chunk };\n\n// The title/summary prefix mirrors bm25 field weighting. Chunks the body, not the raw file, so\n// `offset` shifts line numbers back onto raw and a range stays a direct Read range.\nfunction chunksOf(blocks: Block[], body: string, search?: { title: string; summary: string }, offset = 0, chunkTokens?: number): Chunk[] {\n  const prefix = [search?.title, search?.summary].filter(Boolean).join('\\n');\n  // A hardcoded option change here must bump src/chunk/version.ts's CHUNK_VERSION, the signature\n  // for every chunker input not already carried in config.\n  return chunkFromBlocks(blocks, body, chunkTokens !== undefined ? { targetTokens: chunkTokens } : undefined).map((c) => ({\n    startLine: c.startLine + offset,\n    endLine: c.endLine + offset,\n    text: prefix ? `${prefix}\\n${c.text}` : c.text,\n  }));\n}\n\nexport const embed: Feature = {\n  name: 'embed',\n  async schema(db) {\n    await db.exec(`CREATE TABLE IF NOT EXISTS embeddings (\"path\" TEXT, chunk INTEGER, start_line INTEGER, end_line INTEGER, scale REAL, vector BLOB, PRIMARY KEY (\"path\", chunk))`);\n  },\n  extract(raw, body, search, _data, cfg, blocks) {\n    // Lines the frontmatter occupies, so body line 1 maps back to its raw line number.\n    // blocks comes from parseFile's shared parse; falls back to parsing body for a direct call.\n    return chunksOf(blocks ?? parse(body), body, search, countLines(raw) - countLines(body), cfg?.embed?.chunkTokens);\n  },\n  async remove(db, paths) {\n    if (paths.length === 0) return;\n    await db.runBatch(\n      'DELETE FROM embeddings WHERE \"path\" = ?',\n      paths.map((p) => [p])\n    );\n  },\n  // A tree with no embedding model never had extract() run for the doc (reconcile.ts's per-file\n  // filter skips it), so extracted is undefined here -- those docs contribute no rows.\n  async store(db, docs) {\n    const rows: unknown[][] = [];\n    const texts = new Map<string, string[]>();\n    for (const { path, extracted } of docs) {\n      if (!extracted) continue;\n      const chunks = extracted as Chunk[];\n      chunks.forEach((c, idx) => rows.push([path, idx, c.startLine, c.endLine]));\n      texts.set(\n        path,\n        chunks.map((c) => c.text)\n      );\n    }\n    if (rows.length === 0) return;\n    // scale and vector are written by the embed pass, not here, so they are not in the column list\n    // and take the table's own default on the append path.\n    await appendRows(db, 'embeddings', ['path', 'chunk', 'start_line', 'end_line'], 'INSERT INTO embeddings (\"path\", chunk, start_line, end_line, scale, vector) VALUES (?, ?, ?, ?, NULL, NULL)', rows);\n    // The text extract() just computed, handed to the embed pass that follows in this same\n    // process rather than re-derived from the file there (src/embed/handoff.ts).\n    stashChunkText(db, texts);\n  },\n  enabledForFile(_cfg, file) {\n    return file.embed;\n  },\n  // Keyed so a rebuild notice can name it \"embed settings\". Driven by embedConfig(cfg) directly:\n  // a model can be configured with no preset yet using vectors.\n  signature(cfg) {\n    const e = embedConfig(cfg);\n    if (!e) return 'embed:off';\n    // Weight identity from identity.ts, no network: a static model's resolved sha or local\n    // size+mtime, appended once known so changed weights re-embed.\n    const identity = e.provider === 'static' ? modelIdentity(e.model) : undefined;\n    // W3b: chunkTokens rides the version token, since it's the one owner lever the chunker\n    // itself takes -- changing or clearing it must rebuild exactly like a chunker version bump.\n    const chunkVersion = e.chunkTokens !== undefined ? `${CHUNK_VERSION}:${e.chunkTokens}` : CHUNK_VERSION;\n    return `embed:${e.provider}:${e.model}:${chunkVersion}${identity !== undefined ? `@${identity}` : ''}`;\n  },\n};\n"],"names":["embed","chunksOf","blocks","body","search","offset","chunkTokens","prefix","title","summary","filter","Boolean","join","chunkFromBlocks","undefined","targetTokens","map","c","startLine","endLine","text","name","schema","db","exec","extract","raw","_data","cfg","parse","countLines","remove","paths","length","runBatch","p","store","docs","rows","texts","Map","path","extracted","chunks","forEach","idx","push","set","appendRows","stashChunkText","enabledForFile","_cfg","file","signature","e","embedConfig","identity","provider","modelIdentity","model","chunkVersion","CHUNK_VERSION"],"mappings":"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"}
+{"version":3,"sources":["/Users/kevin/Dev/OpenSource/ai/sensemaking/src/features/embed.ts"],"sourcesContent":["import type { Block, Chunk } from '../chunk/index.ts';\nimport { CHUNK_VERSION, chunkFromBlocks, parse } from '../chunk/index.ts';\nimport { embedConfig } from '../config/index.ts';\nimport { embedEndpointIdentity } from '../embed/endpoint.ts';\nimport { identifyChunkText, stashChunkText } from '../embed/handoff.ts';\nimport { modelIdentity } from '../embed/identity.ts';\nimport { countLines } from '../scan/frontmatter.ts';\nimport { appendRows } from '../store/shared.ts';\nimport type { Feature } from './types.ts';\n\n// int8 vectors with a per-vector scale, NULL vector = not yet embedded: reconcile writes dirty\n// rows and build (or an authorised scoped CLI query) prepares them before semantic retrieval.\n\nexport type { Chunk };\n\nconst CHUNK_LOOKUP_PAGE = 512;\ninterface ChunkRow {\n  chunk: number;\n  start_line: number;\n  end_line: number;\n  content_identity: string;\n}\n\n// The title/summary prefix mirrors bm25 field weighting. Chunks the body, not the raw file, so\n// `offset` shifts line numbers back onto raw and a range stays a direct Read range.\nfunction chunksOf(blocks: Block[], body: string, search?: { title: string; summary: string }, offset = 0, chunkTokens?: number): Chunk[] {\n  const prefix = [search?.title, search?.summary].filter(Boolean).join('\\n');\n  // A hardcoded option change here must bump src/chunk/version.ts's CHUNK_VERSION, the signature\n  // for every chunker input not already carried in config.\n  return chunkFromBlocks(blocks, body, chunkTokens !== undefined ? { targetTokens: chunkTokens } : undefined).map((c) => ({\n    startLine: c.startLine + offset,\n    endLine: c.endLine + offset,\n    text: prefix ? `${prefix}\\n${c.text}` : c.text,\n  }));\n}\n\nexport const embed: Feature = {\n  name: 'embed',\n  async schema(db) {\n    await db.exec(`CREATE TABLE IF NOT EXISTS embeddings (\"path\" TEXT, chunk INTEGER, start_line INTEGER, end_line INTEGER, content_identity TEXT NOT NULL, scale REAL, vector BLOB, PRIMARY KEY (\"path\", chunk))`);\n  },\n  extract(raw, body, search, _data, cfg, blocks) {\n    // Lines the frontmatter occupies, so body line 1 maps back to its raw line number.\n    // blocks comes from parseFile's shared parse; falls back to parsing body for a direct call.\n    return chunksOf(blocks ?? parse(body), body, search, countLines(raw) - countLines(body), cfg?.embed?.chunkTokens);\n  },\n  async remove(db, paths, delta) {\n    const vanishedSet = new Set(delta.vanished);\n    const vanished = paths.filter((path) => vanishedSet.has(path));\n    if (vanished.length === 0) return;\n    await db.runBatch(\n      'DELETE FROM embeddings WHERE \"path\" = ?',\n      vanished.map((path) => [path])\n    );\n  },\n  // A tree with no embedding model never had extract() run for the doc (reconcile.ts's per-file\n  // filter skips it), so extracted is undefined here -- those docs contribute no rows.\n  async store(db, docs, delta) {\n    const rows: unknown[][] = [];\n    const texts = new Map<string, ReturnType<typeof identifyChunkText>[]>();\n    const added = new Set(delta.added);\n    // Keyset pages bound comparison metadata without reading native vector payloads.\n    let firstPage: Awaited<ReturnType<typeof db.prepare>> | undefined;\n    let nextPage: Awaited<ReturnType<typeof db.prepare>> | undefined;\n    for (const { path, extracted } of docs) {\n      const chunks = (extracted as Chunk[] | undefined) ?? [];\n      if (chunks.length === 0) {\n        if (!added.has(path)) await db.runBatch('DELETE FROM embeddings WHERE \"path\" = ?', [[path]]);\n        continue;\n      }\n      const identified = chunks.map((chunk) => identifyChunkText(chunk.text));\n      const kept = new Set<number>();\n      if (!added.has(path)) {\n        let cursor: number | undefined;\n        for (;;) {\n          let page: ChunkRow[];\n          if (cursor === undefined) {\n            firstPage ??= await db.prepare(`SELECT chunk, start_line, end_line, content_identity FROM embeddings WHERE \"path\" = ? ORDER BY chunk LIMIT ${CHUNK_LOOKUP_PAGE}`);\n            page = (await firstPage.all(path)) as ChunkRow[];\n          } else {\n            nextPage ??= await db.prepare(`SELECT chunk, start_line, end_line, content_identity FROM embeddings WHERE \"path\" = ? AND chunk > ? ORDER BY chunk LIMIT ${CHUNK_LOOKUP_PAGE}`);\n            page = (await nextPage.all(path, cursor)) as ChunkRow[];\n          }\n          const removed: unknown[][] = [];\n          const moved: unknown[][] = [];\n          for (const old of page) {\n            const index = Number(old.chunk);\n            const chunk = chunks[index];\n            if (!chunk || old.content_identity !== identified[index].identity) {\n              removed.push([path, index]);\n            } else {\n              kept.add(index);\n              if (Number(old.start_line) !== chunk.startLine || Number(old.end_line) !== chunk.endLine) moved.push([chunk.startLine, chunk.endLine, path, index]);\n            }\n          }\n          if (removed.length > 0) await db.runBatch('DELETE FROM embeddings WHERE \"path\" = ? AND chunk = ?', removed);\n          if (moved.length > 0) await db.runBatch('UPDATE embeddings SET start_line = ?, end_line = ? WHERE \"path\" = ? AND chunk = ?', moved);\n          if (page.length < CHUNK_LOOKUP_PAGE) break;\n          cursor = Number(page[page.length - 1].chunk);\n        }\n      }\n      const before = rows.length;\n      chunks.forEach((chunk, index) => {\n        if (!kept.has(index)) rows.push([path, index, chunk.startLine, chunk.endLine, identified[index].identity]);\n      });\n      // No new pending rows means no retained handoff. Matching pending rows can use\n      // embedPending's exact indexed-source fallback, including after repeated store calls.\n      if (rows.length > before) texts.set(path, identified);\n    }\n    // scale and vector are written by the embed pass, not here, so they are not in the column list\n    // and take the table's own default on the append path.\n    await appendRows(db, 'embeddings', ['path', 'chunk', 'start_line', 'end_line', 'content_identity'], 'INSERT INTO embeddings (\"path\", chunk, start_line, end_line, content_identity, scale, vector) VALUES (?, ?, ?, ?, ?, NULL, NULL)', rows);\n    // Hand off only paths with new pending rows; missing entries use the indexed source.\n    stashChunkText(db, texts);\n  },\n  enabledForFile(_cfg, file) {\n    return file.embed;\n  },\n  // Keyed so a rebuild notice can name it \"embed settings\". Driven by embedConfig(cfg) directly:\n  // a model can be configured with no preset yet using vectors.\n  signature(cfg) {\n    const e = embedConfig(cfg);\n    if (!e) return 'embed:off';\n    // Weight identity from identity.ts, no network: a static model's resolved sha or local\n    // size+mtime, appended once known so changed weights re-embed.\n    const identity = e.provider === 'static' ? modelIdentity(e.model) : undefined;\n    // W3b: chunkTokens rides the version token, since it's the one owner lever the chunker\n    // itself takes -- changing or clearing it must rebuild exactly like a chunker version bump.\n    const chunkVersion = e.chunkTokens !== undefined ? `${CHUNK_VERSION}:${e.chunkTokens}` : CHUNK_VERSION;\n    const endpoint = embedEndpointIdentity(e.provider, e.url);\n    const endpointPart = endpoint === undefined ? '' : `:endpoint=${endpoint}`;\n    return `embed:${e.provider}:${e.model}${endpointPart}:${chunkVersion}${identity !== undefined ? `@${identity}` : ''}`;\n  },\n};\n"],"names":["embed","CHUNK_LOOKUP_PAGE","chunksOf","blocks","body","search","offset","chunkTokens","prefix","title","summary","filter","Boolean","join","chunkFromBlocks","undefined","targetTokens","map","c","startLine","endLine","text","name","schema","db","exec","extract","raw","_data","cfg","parse","countLines","remove","paths","delta","vanishedSet","vanished","Set","path","has","length","runBatch","store","docs","rows","texts","added","firstPage","nextPage","Map","extracted","chunks","identified","kept","cursor","page","removed","moved","old","index","chunk","before","identifyChunkText","prepare","all","Number","content_identity","identity","push","add","start_line","end_line","forEach","set","appendRows","stashChunkText","enabledForFile","_cfg","file","signature","e","embedConfig","provider","modelIdentity","model","chunkVersion","CHUNK_VERSION","endpoint","embedEndpointIdentity","url","endpointPart"],"mappings":"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"}

package/dist/cjs/graph/traverse.d.cts

@@ -1,8 +1,8 @@
 import type { Store } from '../store/types.js';
-interface FindPathOptions {
+export interface FindPathOptions {
     directed?: boolean;
     maxDepth?: number;
     allowed?: Set<string>;
 }
 export declare function findPath(store: Store, from: string, to: string, opts?: FindPathOptions): Promise<string[] | null>;
-export {};
+export declare function findPathInSnapshot(store: Store, from: string, to: string, opts: FindPathOptions): Promise<string[] | null>;

package/dist/cjs/graph/traverse.d.ts

@@ -1,8 +1,8 @@
 import type { Store } from '../store/types.js';
-interface FindPathOptions {
+export interface FindPathOptions {
     directed?: boolean;
     maxDepth?: number;
     allowed?: Set<string>;
 }
 export declare function findPath(store: Store, from: string, to: string, opts?: FindPathOptions): Promise<string[] | null>;
-export {};
+export declare function findPathInSnapshot(store: Store, from: string, to: string, opts: FindPathOptions): Promise<string[] | null>;

package/dist/cjs/graph/traverse.js

@@ -4,10 +4,18 @@
 Object.defineProperty(exports, "__esModule", {
     value: true
 });
-Object.defineProperty(exports, "findPath", {
-    enumerable: true,
-    get: function() {
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: Object.getOwnPropertyDescriptor(all, name).get
+    });
+}
+_export(exports, {
+    get findPath () {
         return findPath;
+    },
+    get findPathInSnapshot () {
+        return findPathInSnapshot;
     }
 });
 var _serialqueryts = require("../lib/serial-query.js");
@@ -283,10 +291,12 @@ function reconstructPath(store, to) {
 function findPath(store, from, to) {
     var opts = arguments.length > 3 && arguments[3] !== void 0 ? arguments[3] : {};
     return (0, _serialqueryts.serialQuery)(store, function() {
-        return findIndexedPath(store, from, to, opts);
+        return store.transaction(function() {
+            return findPathInSnapshot(store, from, to, opts);
+        });
     });
 }
-function findIndexedPath(store, from, to, opts) {
+function findPathInSnapshot(store, from, to, opts) {
     return _async_to_generator(function() {
         var _opts_maxDepth, direction, maxDepth, insertStart, stmt, ring, rows;
         return _ts_generator(this, function(_state) {

package/dist/cjs/graph/traverse.js.map

@@ -1 +1 @@
-{"version":3,"sources":["/Users/kevin/Dev/OpenSource/ai/sensemaking/src/graph/traverse.ts"],"sourcesContent":["// Frontier-by-frontier BFS through a temp visited table, one indexed anti-join per ring: a\n// local question touches a neighborhood, never the whole edge list.\n\nimport { serialQuery } from '../lib/serial-query.ts';\nimport type { Store } from '../store/types.ts';\n\ntype Direction = 'forward' | 'reverse' | 'both';\n\ninterface FindPathOptions {\n  directed?: boolean;\n  maxDepth?: number;\n  allowed?: Set<string>;\n}\n\nasync function resetVisited(store: Store): Promise<void> {\n  await store.exec('DROP TABLE IF EXISTS temp.visited');\n  await store.exec('CREATE TEMP TABLE visited (path TEXT PRIMARY KEY, depth INTEGER NOT NULL, pred TEXT)');\n}\n\n// Materializes the caller-resolved scope Set into a temp table so it joins like any other\n// indexed column. `extra`, when given, is always in scope -- findPath's `to` endpoint.\nasync function setupAllowed(store: Store, allowed: Set<string>, extra?: string): Promise<void> {\n  const all = new Set(allowed);\n  if (extra !== undefined) all.add(extra);\n  await store.exec('DROP TABLE IF EXISTS temp.allowed_nodes');\n  await store.exec('CREATE TEMP TABLE allowed_nodes (path TEXT PRIMARY KEY)');\n  await store.runBatch(\n    'INSERT INTO allowed_nodes (path) VALUES (?)',\n    [...all].map((p) => [p])\n  );\n}\n\n// Only resolved links (dst IS NOT NULL) are followed, in either direction.\nfunction candidateSelect(direction: Direction): string {\n  const forward = 'SELECT l.dst AS path, l.src AS pred FROM links l JOIN visited v ON v.path = l.src AND v.depth = ?1 WHERE l.dst IS NOT NULL';\n  const reverse = 'SELECT l.src AS path, l.dst AS pred FROM links l JOIN visited v ON v.path = l.dst AND v.depth = ?1 WHERE l.dst IS NOT NULL';\n  if (direction === 'forward') return forward;\n  if (direction === 'reverse') return reverse;\n  return `${forward} UNION ALL ${reverse}`;\n}\n\n// One ring: candidates adjacent to the previous ring's frontier (?1), anti-joined against\n// everything already visited, optionally filtered to the allowed set, inserted at the new depth (?2); RETURNING gives what this ring newly reached.\nfunction ringSql(direction: Direction, hasAllowed: boolean): string {\n  return `\nINSERT INTO visited (path, depth, pred)\nSELECT cand.path, ?2, MIN(cand.pred)\nFROM (${candidateSelect(direction)}) cand\nWHERE NOT EXISTS (SELECT 1 FROM visited v2 WHERE v2.path = cand.path)\n${hasAllowed ? 'AND EXISTS (SELECT 1 FROM allowed_nodes a WHERE a.path = cand.path)' : ''}\nGROUP BY cand.path\nORDER BY cand.path\nRETURNING path`;\n}\n\nasync function reconstructPath(store: Store, to: string): Promise<string[]> {\n  const lookup = await store.prepare('SELECT pred FROM visited WHERE path = ?');\n  const path: string[] = [];\n  let cur: string | null = to;\n  while (cur !== null) {\n    path.push(cur);\n    const row = (await lookup.get(cur)) as { pred: string | null } | undefined;\n    cur = row ? row.pred : null;\n  }\n  return path.reverse();\n}\n\n// One BFS from `from`, tracking a predecessor per node. Undirected by default, matching\n// personalizedRank; null when `to` is unreached within `maxDepth`.\nexport function findPath(store: Store, from: string, to: string, opts: FindPathOptions = {}): Promise<string[] | null> {\n  return serialQuery(store, () => findIndexedPath(store, from, to, opts));\n}\n\nasync function findIndexedPath(store: Store, from: string, to: string, opts: FindPathOptions): Promise<string[] | null> {\n  if (from === to) return [from];\n\n  const direction: Direction = opts.directed ? 'forward' : 'both';\n  const maxDepth = opts.maxDepth ?? Infinity;\n  if (maxDepth <= 0) return null;\n\n  await resetVisited(store);\n  const insertStart = await store.prepare('INSERT INTO visited (path, depth, pred) VALUES (?, 0, NULL)');\n  await insertStart.run(from);\n  if (opts.allowed) await setupAllowed(store, opts.allowed, to);\n\n  const stmt = await store.prepare(ringSql(direction, !!opts.allowed));\n  for (let ring = 1; ring <= maxDepth; ring++) {\n    const rows = (await stmt.all(ring - 1, ring)) as Array<{ path: string }>;\n    if (rows.length === 0) break;\n    if (rows.some((row) => row.path === to)) return reconstructPath(store, to);\n  }\n  return null;\n}\n"],"names":["findPath","resetVisited","store","exec","setupAllowed","allowed","extra","all","Set","undefined","add","runBatch","map","p","candidateSelect","direction","forward","reverse","ringSql","hasAllowed","reconstructPath","to","lookup","path","cur","row","prepare","push","get","pred","from","opts","serialQuery","findIndexedPath","maxDepth","insertStart","stmt","ring","rows","directed","Infinity","run","length","some"],"mappings":"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"}
+{"version":3,"sources":["/Users/kevin/Dev/OpenSource/ai/sensemaking/src/graph/traverse.ts"],"sourcesContent":["// Frontier-by-frontier BFS through a temp visited table, one indexed anti-join per ring: a\n// local question touches a neighborhood, never the whole edge list.\n\nimport { serialQuery } from '../lib/serial-query.ts';\nimport type { Store } from '../store/types.ts';\n\ntype Direction = 'forward' | 'reverse' | 'both';\n\nexport interface FindPathOptions {\n  directed?: boolean;\n  maxDepth?: number;\n  allowed?: Set<string>;\n}\n\nasync function resetVisited(store: Store): Promise<void> {\n  await store.exec('DROP TABLE IF EXISTS temp.visited');\n  await store.exec('CREATE TEMP TABLE visited (path TEXT PRIMARY KEY, depth INTEGER NOT NULL, pred TEXT)');\n}\n\n// Materializes the caller-resolved scope Set into a temp table so it joins like any other\n// indexed column. `extra`, when given, is always in scope -- findPath's `to` endpoint.\nasync function setupAllowed(store: Store, allowed: Set<string>, extra?: string): Promise<void> {\n  const all = new Set(allowed);\n  if (extra !== undefined) all.add(extra);\n  await store.exec('DROP TABLE IF EXISTS temp.allowed_nodes');\n  await store.exec('CREATE TEMP TABLE allowed_nodes (path TEXT PRIMARY KEY)');\n  await store.runBatch(\n    'INSERT INTO allowed_nodes (path) VALUES (?)',\n    [...all].map((p) => [p])\n  );\n}\n\n// Only resolved links (dst IS NOT NULL) are followed, in either direction.\nfunction candidateSelect(direction: Direction): string {\n  const forward = 'SELECT l.dst AS path, l.src AS pred FROM links l JOIN visited v ON v.path = l.src AND v.depth = ?1 WHERE l.dst IS NOT NULL';\n  const reverse = 'SELECT l.src AS path, l.dst AS pred FROM links l JOIN visited v ON v.path = l.dst AND v.depth = ?1 WHERE l.dst IS NOT NULL';\n  if (direction === 'forward') return forward;\n  if (direction === 'reverse') return reverse;\n  return `${forward} UNION ALL ${reverse}`;\n}\n\n// One ring: candidates adjacent to the previous ring's frontier (?1), anti-joined against\n// everything already visited, optionally filtered to the allowed set, inserted at the new depth (?2); RETURNING gives what this ring newly reached.\nfunction ringSql(direction: Direction, hasAllowed: boolean): string {\n  return `\nINSERT INTO visited (path, depth, pred)\nSELECT cand.path, ?2, MIN(cand.pred)\nFROM (${candidateSelect(direction)}) cand\nWHERE NOT EXISTS (SELECT 1 FROM visited v2 WHERE v2.path = cand.path)\n${hasAllowed ? 'AND EXISTS (SELECT 1 FROM allowed_nodes a WHERE a.path = cand.path)' : ''}\nGROUP BY cand.path\nORDER BY cand.path\nRETURNING path`;\n}\n\nasync function reconstructPath(store: Store, to: string): Promise<string[]> {\n  const lookup = await store.prepare('SELECT pred FROM visited WHERE path = ?');\n  const path: string[] = [];\n  let cur: string | null = to;\n  while (cur !== null) {\n    path.push(cur);\n    const row = (await lookup.get(cur)) as { pred: string | null } | undefined;\n    cur = row ? row.pred : null;\n  }\n  return path.reverse();\n}\n\n// One BFS from `from`, tracking a predecessor per node. Undirected by default, matching\n// personalizedRank; null when `to` is unreached within `maxDepth`.\nexport function findPath(store: Store, from: string, to: string, opts: FindPathOptions = {}): Promise<string[] | null> {\n  return serialQuery(store, () => store.transaction(() => findPathInSnapshot(store, from, to, opts)));\n}\n\n// Internal entry for the scoped command wrapper, whose transaction also owns endpoint resolution\n// and scope reads. Direct graph callers use findPath() above and receive the same snapshot rule.\nexport async function findPathInSnapshot(store: Store, from: string, to: string, opts: FindPathOptions): Promise<string[] | null> {\n  if (from === to) return [from];\n\n  const direction: Direction = opts.directed ? 'forward' : 'both';\n  const maxDepth = opts.maxDepth ?? Infinity;\n  if (maxDepth <= 0) return null;\n\n  await resetVisited(store);\n  const insertStart = await store.prepare('INSERT INTO visited (path, depth, pred) VALUES (?, 0, NULL)');\n  await insertStart.run(from);\n  if (opts.allowed) await setupAllowed(store, opts.allowed, to);\n\n  const stmt = await store.prepare(ringSql(direction, !!opts.allowed));\n  for (let ring = 1; ring <= maxDepth; ring++) {\n    const rows = (await stmt.all(ring - 1, ring)) as Array<{ path: string }>;\n    if (rows.length === 0) break;\n    if (rows.some((row) => row.path === to)) return reconstructPath(store, to);\n  }\n  return null;\n}\n"],"names":["findPath","findPathInSnapshot","resetVisited","store","exec","setupAllowed","allowed","extra","all","Set","undefined","add","runBatch","map","p","candidateSelect","direction","forward","reverse","ringSql","hasAllowed","reconstructPath","to","lookup","path","cur","row","prepare","push","get","pred","from","opts","serialQuery","transaction","maxDepth","insertStart","stmt","ring","rows","directed","Infinity","run","length","some"],"mappings":"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"}

package/dist/cjs/index.d.cts

@@ -1,5 +1,5 @@
-export type { Peek, PresetCoverage, SearchOptions, TreeMap } from './commands/index.js';
-export { mapTree, peek, presetCoverage, search } from './commands/index.js';
+export type { PathOptions, Peek, PeekSection, PresetCoverage, RelatedOptions, RelatedResult, SearchOptions, SearchResult, SearchResultVia, TreeMap, TreeMapField, TreeMapHub, TreeMapRecent } from './commands/index.js';
+export { findPath, mapTree, peek, presetCoverage, relatedNotes, search } from './commands/index.js';
 export type { Config, EmbedConfig, FeatureName, InitOverrides, LoadConfigOptions, Preset, ResolvedConfig, SavedQuery, SavedSearch, SearchOverrides, SignalName, SignalWeights, StoreName } from './config/index.js';
 export { CONFIG_FILENAME, initConfig, loadConfig, migrateConfig, SIGNAL_NAMES, STATE_DIR, STORE_NAMES, SUPPORTED_CONFIG_VERSION } from './config/index.js';
 export type { SenseErrorCode } from './errors.js';

package/dist/cjs/index.d.ts

@@ -1,5 +1,5 @@
-export type { Peek, PresetCoverage, SearchOptions, TreeMap } from './commands/index.js';
-export { mapTree, peek, presetCoverage, search } from './commands/index.js';
+export type { PathOptions, Peek, PeekSection, PresetCoverage, RelatedOptions, RelatedResult, SearchOptions, SearchResult, SearchResultVia, TreeMap, TreeMapField, TreeMapHub, TreeMapRecent } from './commands/index.js';
+export { findPath, mapTree, peek, presetCoverage, relatedNotes, search } from './commands/index.js';
 export type { Config, EmbedConfig, FeatureName, InitOverrides, LoadConfigOptions, Preset, ResolvedConfig, SavedQuery, SavedSearch, SearchOverrides, SignalName, SignalWeights, StoreName } from './config/index.js';
 export { CONFIG_FILENAME, initConfig, loadConfig, migrateConfig, SIGNAL_NAMES, STATE_DIR, STORE_NAMES, SUPPORTED_CONFIG_VERSION } from './config/index.js';
 export type { SenseErrorCode } from './errors.js';

package/dist/cjs/index.js

@@ -38,6 +38,9 @@ _export(exports, {
     get clearCache () {
         return _indexts2.clearCache;
     },
+    get findPath () {
+        return _indexts.findPath;
+    },
     get initConfig () {
         return _indexts1.initConfig;
     },
@@ -62,6 +65,9 @@ _export(exports, {
     get printRows () {
         return _outputts.printRows;
     },
+    get relatedNotes () {
+        return _indexts.relatedNotes;
+    },
     get runWatch () {
         return _watchts.runWatch;
     },

package/dist/cjs/index.js.map

@@ -1 +1 @@
-{"version":3,"sources":["/Users/kevin/Dev/OpenSource/ai/sensemaking/src/index.ts"],"sourcesContent":["// Public library API. Deliberately small: every export is a stability promise;\n// internals (feature registry, graph, scan, meta) stay module-private.\n\nexport type { Peek, PresetCoverage, SearchOptions, TreeMap } from './commands/index.ts';\nexport { mapTree, peek, presetCoverage, search } from './commands/index.ts';\nexport type { Config, EmbedConfig, FeatureName, InitOverrides, LoadConfigOptions, Preset, ResolvedConfig, SavedQuery, SavedSearch, SearchOverrides, SignalName, SignalWeights, StoreName } from './config/index.ts';\nexport { CONFIG_FILENAME, initConfig, loadConfig, migrateConfig, SIGNAL_NAMES, STATE_DIR, STORE_NAMES, SUPPORTED_CONFIG_VERSION } from './config/index.ts';\nexport type { SenseErrorCode } from './errors.ts';\nexport { SenseError } from './errors.ts';\nexport type { Format, Row, RowFormat } from './output/output.ts';\nexport { printRows } from './output/output.ts';\nexport type { BuildOptions, BuildResult, OpenOptions, OpenResult, Stages } from './store/index.ts';\nexport { buildIndex as build, CAPABILITY_NAMES, clearCache, openStore as open } from './store/index.ts';\nexport type { Capability, DocumentStore, FieldStat, LexicalHit, LexicalIndex, LexicalQueryOptions, RawStatement, RunResult, SqlSession, Statement, Store, VectorCandidate, VectorSimilar, VectorStore, VectorWriteRow } from './store/types.ts';\n\nexport type { WatchEvent, WatchOptions } from './watch.ts';\nexport { runWatch } from './watch.ts';\n"],"names":["CAPABILITY_NAMES","CONFIG_FILENAME","SIGNAL_NAMES","STATE_DIR","STORE_NAMES","SUPPORTED_CONFIG_VERSION","SenseError","build","buildIndex","clearCache","initConfig","loadConfig","mapTree","migrateConfig","open","openStore","peek","presetCoverage","printRows","runWatch","search"],"mappings":"AAAA,+EAA+E;AAC/E,uEAAuE;;;;;;;;;;;;QAWzCA;eAAAA,0BAAgB;;QANrCC;eAAAA,yBAAe;;QAAyCC;eAAAA,sBAAY;;QAAEC;eAAAA,mBAAS;;QAAEC;eAAAA,qBAAW;;QAAEC;eAAAA,kCAAwB;;QAEtHC;eAAAA,oBAAU;;QAIIC;eAAdC,oBAAU;;QAA6BC;eAAAA,oBAAU;;QANhCC;eAAAA,oBAAU;;QAAEC;eAAAA,oBAAU;;QAFvCC;eAAAA,gBAAO;;QAEkCC;eAAAA,uBAAa;;QAMUC;eAAbC,mBAAS;;QARnDC;eAAAA,aAAI;;QAAEC;eAAAA,uBAAc;;QAM7BC;eAAAA,mBAAS;;QAMTC;eAAAA,iBAAQ;;QAZuBC;eAAAA,eAAM;;;uBAAQ;wBAEiF;wBAE5G;wBAED;wBAE2D;uBAI5D"}
+{"version":3,"sources":["/Users/kevin/Dev/OpenSource/ai/sensemaking/src/index.ts"],"sourcesContent":["// Public library API. Deliberately small: every export is a stability promise;\n// internals (feature registry, graph, scan, meta) stay module-private.\n\nexport type { PathOptions, Peek, PeekSection, PresetCoverage, RelatedOptions, RelatedResult, SearchOptions, SearchResult, SearchResultVia, TreeMap, TreeMapField, TreeMapHub, TreeMapRecent } from './commands/index.ts';\nexport { findPath, mapTree, peek, presetCoverage, relatedNotes, search } from './commands/index.ts';\nexport type { Config, EmbedConfig, FeatureName, InitOverrides, LoadConfigOptions, Preset, ResolvedConfig, SavedQuery, SavedSearch, SearchOverrides, SignalName, SignalWeights, StoreName } from './config/index.ts';\nexport { CONFIG_FILENAME, initConfig, loadConfig, migrateConfig, SIGNAL_NAMES, STATE_DIR, STORE_NAMES, SUPPORTED_CONFIG_VERSION } from './config/index.ts';\nexport type { SenseErrorCode } from './errors.ts';\nexport { SenseError } from './errors.ts';\nexport type { Format, Row, RowFormat } from './output/output.ts';\nexport { printRows } from './output/output.ts';\nexport type { BuildOptions, BuildResult, OpenOptions, OpenResult, Stages } from './store/index.ts';\nexport { buildIndex as build, CAPABILITY_NAMES, clearCache, openStore as open } from './store/index.ts';\nexport type { Capability, DocumentStore, FieldStat, LexicalHit, LexicalIndex, LexicalQueryOptions, RawStatement, RunResult, SqlSession, Statement, Store, VectorCandidate, VectorSimilar, VectorStore, VectorWriteRow } from './store/types.ts';\n\nexport type { WatchEvent, WatchOptions } from './watch.ts';\nexport { runWatch } from './watch.ts';\n"],"names":["CAPABILITY_NAMES","CONFIG_FILENAME","SIGNAL_NAMES","STATE_DIR","STORE_NAMES","SUPPORTED_CONFIG_VERSION","SenseError","build","buildIndex","clearCache","findPath","initConfig","loadConfig","mapTree","migrateConfig","open","openStore","peek","presetCoverage","printRows","relatedNotes","runWatch","search"],"mappings":"AAAA,+EAA+E;AAC/E,uEAAuE;;;;;;;;;;;;QAWzCA;eAAAA,0BAAgB;;QANrCC;eAAAA,yBAAe;;QAAyCC;eAAAA,sBAAY;;QAAEC;eAAAA,mBAAS;;QAAEC;eAAAA,qBAAW;;QAAEC;eAAAA,kCAAwB;;QAEtHC;eAAAA,oBAAU;;QAIIC;eAAdC,oBAAU;;QAA6BC;eAAAA,oBAAU;;QARjDC;eAAAA,iBAAQ;;QAESC;eAAAA,oBAAU;;QAAEC;eAAAA,oBAAU;;QAF7BC;eAAAA,gBAAO;;QAEwBC;eAAAA,uBAAa;;QAMUC;eAAbC,mBAAS;;QARzCC;eAAAA,aAAI;;QAAEC;eAAAA,uBAAc;;QAMvCC;eAAAA,mBAAS;;QANgCC;eAAAA,qBAAY;;QAYrDC;eAAAA,iBAAQ;;QAZ+CC;eAAAA,eAAM;;;uBAAQ;wBAEyD;wBAE5G;wBAED;wBAE2D;uBAI5D"}