sensemaking 0.22.1 → 0.22.2

package/README.md

@@ -93,7 +93,7 @@ ORDER BY bm25(content, 10.0, 5.0, 1.0) LIMIT 10
 |---|---|
 | `presets` | named bundles of `include`/`exclude` globs, `k` (result count), `signals` (which engines this scope searches with, `words`, `links`, `vectors`; every signal whose prerequisites hold, unless the preset lists them exhaustively), `where` (a standing SQL filter). A file is indexed if any preset includes it, embedded if a model is named and some covering preset's `signals` include `vectors`; `status` shows each preset's coverage. |
 | `embed` | the model vectors are built with. Naming one gives the tree vectors; omitting the block means none at all, whatever the presets say. `sense download` fetches it. |
-| `store` | backing store engine: `sqlite` (default, zero-dependency, Node's built-in SQLite), or the experimental `duckdb` and `turso`. The first command that opens such a tree installs that engine's package on its own (`@duckdb/node-api`, a one-time native download of ~110 MB; `@tursodatabase/database`, much smaller). The same commands and table names run on all three; what does not port is FTS5 syntax. Under `duckdb` and `turso`, `search` text and raw `MATCH` reject FTS5's prefix (`foo*`), boolean (`AND`/`OR`/`NOT`), `NEAR`, initial-token (`^`), and column-filter (`title:foo`) operators with a named error that says how to rephrase or set `store` to `sqlite`; bare words and quoted phrases work on all three. Raw `sql` is a per-store dialect: the tables are portable, but sqlite's FTS5 `MATCH`/`snippet()`/`bm25()` do not run under `duckdb` or `turso`, so saved queries written in FTS5 syntax are sqlite dialect, and `has`/`basename`/`segment` are registered on `sqlite` and `duckdb` but not `turso`, whose client cannot register SQL functions. `sense watch` runs on all three; on `duckdb` and `turso`, which lock the cache file per connection, a concurrent command waits out the watcher's current cycle instead of failing. Each store keeps its own cache file (`.sense/cache.db`, `.sense/cache.duckdb`, `.sense/cache.turso.db`); switching stores is a rebuild, not a migration. |
+| `store` | backing store engine: `sqlite` (default, zero-dependency, Node's built-in SQLite), or the experimental `duckdb` and `turso`. The first command that opens such a tree installs that engine's package on its own (`@duckdb/node-api`, a one-time native download of ~110 MB; `@tursodatabase/database`, much smaller). The same commands and table names run on all three; what does not port is FTS5 syntax. Under `duckdb` and `turso`, `search` text and raw `MATCH` reject FTS5's prefix (`foo*`), boolean (`AND`/`OR`/`NOT`), `NEAR`, initial-token (`^`), and column-filter (`title:foo`) operators with a named error that says how to rephrase or set `store` to `sqlite`; bare words and quoted phrases work on all three. Raw `sql` is a per-store dialect: the tables are portable, but sqlite's FTS5 `MATCH`/`snippet()`/`bm25()` do not run under `duckdb` or `turso`, so saved queries written in FTS5 syntax are sqlite dialect, and `has`/`basename`/`segment` are registered on `sqlite` and `duckdb` but not `turso`, whose client cannot register SQL functions. `sense watch` runs on all three; on `duckdb` and `turso`, which lock the cache file per connection, a concurrent command waits out the watcher's current cycle instead of failing. Each store keeps its own cache file (`.sense/cache.db`, `.sense/cache.duckdb`, `.sense/cache.turso.db`); switching stores is a rebuild, not a migration. Indexing speed is the other axis, and it does not follow from any of the above: sqlite builds a cold index fastest and turso slowest, by a wide margin on a large tree, and no setting closes that gap, since turso's engine costs more per write and more again to maintain each index. What turso buys instead is concurrent writers, non-blocking I/O and encryption, none of which a one-shot command uses, so reach for it for those rather than for speed. Per-store figures: [BENCHMARKING.md](BENCHMARKING.md). |
 | `queries` | entries runnable as `sense <name>`, each naming the verb it runs: `{ sql }` for SQL (`?` binds positional args) or `{ search }` for a ranked search with its settings baked in, so `sense hot` needs no flags. Running an entry validates it: a typo'd column errors and exits nonzero, and a parameterised entry validates with any argument, since preparing precedes binding. |
 | `version` | schema version; older configs auto-migrate on load, noted on stderr. |
 

package/dist/cjs/features/links.js

@@ -508,45 +508,6 @@ function writeResolved(db, rows) {
         });
     })();
 }
-// A new or deleted file can change any note's resolution, so re-resolve the whole table.
-// Fallback for cold builds and large deltas -- see afterReconcile's threshold.
-function resolveAll(db, files) {
-    return _async_to_generator(function() {
-        var pathSet, byBase, stmt, rows, changed;
-        return _ts_generator(this, function(_state) {
-            switch(_state.label){
-                case 0:
-                    pathSet = new Set(files.map(function(f) {
-                        return f.relPath;
-                    }));
-                    byBase = buildByBase(files);
-                    return [
-                        4,
-                        db.prepare('SELECT src, target, dst, embed FROM links')
-                    ];
-                case 1:
-                    stmt = _state.sent();
-                    return [
-                        4,
-                        stmt.all()
-                    ];
-                case 2:
-                    rows = _state.sent();
-                    changed = resolveRows(rows, pathSet, byBase);
-                    return [
-                        4,
-                        writeResolved(db, changed)
-                    ];
-                case 3:
-                    _state.sent();
-                    return [
-                        2,
-                        changed.length > 0
-                    ];
-            }
-        });
-    })();
-}
 // Chunked so a large-but-under-threshold delta never exceeds SQLite's bound-variable limit
 // (SQLITE_MAX_VARIABLE_NUMBER, 32766); harmless headroom on DuckDB, which has no such cap.
 function selectIn(db, column, keys) {
@@ -757,8 +718,11 @@ function linkEdges(db) {
 // Records whether remove()/store() deleted any link row, since afterReconcile runs after both
 // and dstChanged alone misses the reparsed-to-zero-links case. Keyed on delta so state dies with it.
 var removedWithLinks = new WeakMap();
-// dst is written by resolution, not by store(), so it is absent from the column list and takes the
-// table's default on the append path.
+// Cold build only: whether store() resolved at least one row to a non-null dst, so afterReconcile
+// can report linksChanged without re-reading the table it just wrote.
+var coldResolved = new WeakMap();
+// dst stays NULL here on an incremental store (resolution runs afterward); a cold build resolves
+// it inline in store() instead, through the *_RESOLVED column list and SQL below.
 var LINK_COLUMNS = [
     'src',
     'target',
@@ -766,6 +730,14 @@ var LINK_COLUMNS = [
     'embed'
 ];
 var UPSERT_LINK_SQL = 'INSERT INTO links (src, target, target_base, dst, embed) VALUES (?, ?, ?, NULL, ?) ON CONFLICT(src, target, embed) DO UPDATE SET target_base = excluded.target_base';
+var LINK_COLUMNS_RESOLVED = [
+    'src',
+    'target',
+    'target_base',
+    'dst',
+    'embed'
+];
+var UPSERT_LINK_SQL_RESOLVED = 'INSERT INTO links (src, target, target_base, dst, embed) VALUES (?, ?, ?, ?, ?) ON CONFLICT(src, target, embed) DO UPDATE SET target_base = excluded.target_base';
 var links = {
     name: 'links',
     schema: function schema(db) {
@@ -840,7 +812,7 @@ var links = {
     },
     store: function store(db, docs, delta) {
         return _async_to_generator(function() {
-            var byPath, addedSet, reparsedExisting, existingRows, staleRows, appendable, upsertRows, _iteratorNormalCompletion, _didIteratorError, _iteratorError, _iterator, _step, _step_value, path, targets, _iteratorNormalCompletion1, _didIteratorError1, _iteratorError1, _iterator1, _step1, _step_value1, target, embed, row;
+            var byPath, addedSet, reparsedExisting, existingRows, staleRows, cold, resolveNew, pathSet, byBase, resolvedLink, appendable, upsertRows, _iteratorNormalCompletion, _didIteratorError, _iteratorError, _iterator, _step, _step_value, path, targets, _iteratorNormalCompletion1, _didIteratorError1, _iteratorError1, _iterator1, _step1, _step_value1, target, embed, targetBase, dst;
             return _ts_generator(this, function(_state) {
                 switch(_state.label){
                     case 0:
@@ -888,8 +860,21 @@ var links = {
                         removedWithLinks.set(delta, true);
                         _state.label = 3;
                     case 3:
-                        // Upsert preserves dst on surviving rows; only new rows start at NULL. A same-note anchor
-                        // gets no target_base, so SQL's `IN` excludes it from resolveIncremental's lookup.
+                        // Cold build: every path is in `added`, so pathSet/byBase cover the same complete tree
+                        // afterReconcile's large branch would otherwise re-derive; resolve dst here instead.
+                        cold = delta.files.length === 0 || delta.added.length === delta.files.length;
+                        if (cold) {
+                            pathSet = new Set(delta.files.map(function(f) {
+                                return f.relPath;
+                            }));
+                            byBase = buildByBase(delta.files);
+                            resolveNew = function resolveNew(src, target) {
+                                return resolveTarget(src, target, pathSet, byBase);
+                            };
+                        }
+                        resolvedLink = false;
+                        // Upsert preserves dst on surviving rows; a cold build resolves new rows, else they start NULL.
+                        // A same-note anchor gets no target_base, so SQL's `IN` excludes it from resolveIncremental's lookup.
                         // Split, unlike the other features: this hook has no remove() pass behind it (see above), so
                         // only a path in `added` is guaranteed to have no row yet. The rest genuinely conflict and the
                         // upsert is what preserves their `dst`.
@@ -903,14 +888,34 @@ var links = {
                                 try {
                                     for(_iterator1 = targets[Symbol.iterator](); !(_iteratorNormalCompletion1 = (_step1 = _iterator1.next()).done); _iteratorNormalCompletion1 = true){
                                         _step_value1 = _step1.value, target = _step_value1.target, embed = _step_value1.embed;
-                                        row = [
+                                        targetBase = target.startsWith('#') ? null : baseKey(cleanTarget(target));
+                                        if (!addedSet.has(path)) {
+                                            upsertRows.push([
+                                                path,
+                                                target,
+                                                targetBase,
+                                                embed ? 1 : 0
+                                            ]);
+                                            continue;
+                                        }
+                                        if (!resolveNew) {
+                                            appendable.push([
+                                                path,
+                                                target,
+                                                targetBase,
+                                                embed ? 1 : 0
+                                            ]);
+                                            continue;
+                                        }
+                                        dst = resolveNew(path, target);
+                                        if (dst !== null) resolvedLink = true;
+                                        appendable.push([
                                             path,
                                             target,
-                                            target.startsWith('#') ? null : baseKey(cleanTarget(target)),
+                                            targetBase,
+                                            dst,
                                             embed ? 1 : 0
-                                        ];
-                                        if (addedSet.has(path)) appendable.push(row);
-                                        else upsertRows.push(row);
+                                        ]);
                                     }
                                 } catch (err) {
                                     _didIteratorError1 = true;
@@ -943,7 +948,7 @@ var links = {
                         }
                         return [
                             4,
-                            (0, _sharedts.appendRows)(db, 'links', LINK_COLUMNS, UPSERT_LINK_SQL, appendable)
+                            (0, _sharedts.appendRows)(db, 'links', resolveNew ? LINK_COLUMNS_RESOLVED : LINK_COLUMNS, resolveNew ? UPSERT_LINK_SQL_RESOLVED : UPSERT_LINK_SQL, appendable)
                         ];
                     case 4:
                         _state.sent();
@@ -959,6 +964,7 @@ var links = {
                         _state.sent();
                         _state.label = 6;
                     case 6:
+                        if (cold) coldResolved.set(delta, resolvedLink);
                         return [
                             2
                         ];
@@ -968,7 +974,7 @@ var links = {
     },
     afterReconcile: function afterReconcile(db, delta) {
         return _async_to_generator(function() {
-            var _removedWithLinks_get, removeHadLinks, large, dstChanged, _tmp;
+            var _removedWithLinks_get, removeHadLinks, large, _coldResolved_get, dstChanged;
             return _ts_generator(this, function(_state) {
                 switch(_state.label){
                     case 0:
@@ -978,30 +984,20 @@ var links = {
                         // A cold build is the only case a full pass wins. Measured 2026-09-01 on 6,566 notes, resolve
                         // time alone: full is flat near 90ms at any churn, incremental 7ms at 10 files and 30ms at 2,000.
                         large = delta.files.length === 0 || delta.added.length === delta.files.length;
-                        if (!large) return [
-                            3,
-                            2
-                        ];
-                        return [
-                            4,
-                            resolveAll(db, delta.files)
-                        ];
-                    case 1:
-                        _tmp = _state.sent();
-                        return [
-                            3,
-                            4
-                        ];
-                    case 2:
+                        // store() already resolved dst inline on this cold build (same test), so nothing is left to update.
+                        if (large) {
+                            ;
+                            delta.linksChanged = ((_coldResolved_get = coldResolved.get(delta)) !== null && _coldResolved_get !== void 0 ? _coldResolved_get : false) || removeHadLinks;
+                            return [
+                                2
+                            ];
+                        }
                         return [
                             4,
                             resolveIncremental(db, delta)
                         ];
-                    case 3:
-                        _tmp = _state.sent();
-                        _state.label = 4;
-                    case 4:
-                        dstChanged = _tmp;
+                    case 1:
+                        dstChanged = _state.sent();
                         delta.linksChanged = dstChanged || removeHadLinks;
                         return [
                             2

package/dist/cjs/features/links.js.map

@@ -1 +1 @@
-{"version":3,"sources":["/Users/kevin/Dev/OpenSource/ai/sensemaking/src/features/links.ts"],"sourcesContent":["import posix from 'node:path/posix';\nimport type { FileStat } from '../scan/index.ts';\nimport { appendRows } from '../store/shared.ts';\nimport type { Connection } from '../store/types.ts';\nimport { maskRegions } from './fences.ts';\nimport type { ExtractedDoc, Feature, ReconcileDelta } from './types.ts';\n\n// links(src, target, target_base, dst, embed): target as written, target_base its indexed baseKey, dst the resolved path or NULL (a queryable dead link).\n// embed distinguishes `![[x]]`/`![](x.md)` from `[[x]]`/`[](x.md)` -- Obsidian's grain: a target both linked and embedded in one note is two rows.\n\n// Alias stripped after |; a leading # keeps the anchor as the target (self-link needs a\n// heading name), else the anchor splits off. Null = not a link.\nfunction parseWikilinkInner(inner: string): string | null {\n  const beforeAlias = inner.split('|')[0].trim();\n  if (beforeAlias.startsWith('#')) return beforeAlias.length > 1 ? beforeAlias : null;\n  const target = beforeAlias.split('#')[0].trim();\n  return target || null;\n}\n\n// A frontmatter value counts only when it is exactly a wikilink (\"[[X]]\") -- mid-string and\n// ![[...]] forms don't count there, per Obsidian's rule (probe-verified).\nfunction extract(_raw: string, rawBody: string, _search?: { title: string; summary: string }, data?: Record<string, unknown>): Array<{ target: string; embed: boolean }> {\n  const body = /\\[\\[|\\]\\(/.test(rawBody) ? maskRegions(rawBody) : rawBody;\n  const seen = new Set<string>();\n  const results: Array<{ target: string; embed: boolean }> = [];\n  const add = (target: string, embed: boolean) => {\n    const key = `${target}\\0${embed ? '1' : '0'}`;\n    if (seen.has(key)) return;\n    seen.add(key);\n    results.push({ target, embed });\n  };\n  // To the first ]], as Obsidian parses it, so a heading or alias holding a lone ] still\n  // matches; anchor and alias split off in parseWikilinkInner.\n  for (const m of body.matchAll(/\\[\\[(.*?)\\]\\]/g)) {\n    const target = parseWikilinkInner(m[1]);\n    if (target) add(target, body[(m.index ?? 0) - 1] === '!');\n  }\n  // Any internal destination, not only .md-suffixed: \\](Zektor) resolves like [[Zektor]] and\n  // \\](#anchor) is a self-edge. External URLs and titled links (dest stops at whitespace) skip.\n  for (const m of body.matchAll(/(!)?\\[[^\\]]*\\]\\(((?:[^()\\s]|\\([^()\\s]*\\))+)(?:\\s+(?:\"[^)]*\"|'[^)]*'))?\\)/g)) {\n    const dest = m[2].trim();\n    // External: a URI scheme prefix (mailto:, tel:, data:, https:...), protocol-relative\n    // //host, a www. shorthand, or a scheme anywhere (the malformed double-paren case).\n    if (!dest || dest.includes('://')) continue;\n    if (/^([a-z][a-z0-9+.-]*:|\\/\\/|www\\.)/i.test(dest)) continue;\n    const target = dest.startsWith('#') ? dest : dest.split('#')[0];\n    if (target) add(target, m[1] === '!');\n  }\n  for (const value of Object.values(data ?? {})) {\n    for (const item of Array.isArray(value) ? value : [value]) {\n      if (typeof item !== 'string') continue;\n      const m = /^\\[\\[(.*)\\]\\]$/.exec(item.trim());\n      if (!m) continue;\n      const target = parseWikilinkInner(m[1]);\n      if (target) add(target, false);\n    }\n  }\n  return results;\n}\n\nfunction cleanTarget(target: string): string {\n  return target.replace(/\\\\/g, '/').replace(/^\\.\\//, '');\n}\n\nfunction baseKey(path: string): string {\n  return posix.basename(path).replace(/\\.md$/i, '').toLowerCase();\n}\n\n// Obsidian-style: exact relative path (with/without .md), path relative to the linking note's\n// directory, then basename match (shortest path wins ties, verified against a cold-loaded vault).\nfunction resolveTarget(src: string, target: string, pathSet: Set<string>, byBase: Map<string, string[]>): string | null {\n  // [[#Heading]]: a same-note anchor, always the note itself -- never depends on other files.\n  if (target.startsWith('#')) return src;\n  const clean = cleanTarget(target);\n  const fromSrc = posix.normalize(posix.join(posix.dirname(src), clean));\n  for (const candidate of [clean, `${clean}.md`, fromSrc, `${fromSrc}.md`]) {\n    if (pathSet.has(candidate)) return candidate;\n  }\n  const candidates = byBase.get(baseKey(clean));\n  if (!candidates) return null;\n  // The linking note itself wins a basename collision (Obsidian resolves to self before the\n  // shortest-path rule -- cold-load verified on the hub corpus).\n  return candidates.includes(src) ? src : candidates[0];\n}\n\n// Shortest path wins a basename collision; equal lengths fall back to lexicographic, our own\n// deterministic tiebreak for a case Obsidian itself leaves registration-order-dependent.\nfunction buildByBase(files: FileStat[]): Map<string, string[]> {\n  const byBase = new Map<string, string[]>();\n  const paths = files.map((f) => f.relPath).sort((a, b) => a.length - b.length || (a < b ? -1 : a > b ? 1 : 0));\n  for (const path of paths) {\n    const key = baseKey(path);\n    const list = byBase.get(key);\n    if (list) list.push(path);\n    else byBase.set(key, [path]);\n  }\n  return byBase;\n}\n\ninterface LinkRow {\n  src: string;\n  target: string;\n  dst: string | null;\n  embed: number;\n}\n\n// resolveTarget applied to `rows`, returning only the rows whose dst changed, so the caller\n// can write them in one runBatch call.\nfunction resolveRows(rows: LinkRow[], pathSet: Set<string>, byBase: Map<string, string[]>): LinkRow[] {\n  const changed: LinkRow[] = [];\n  for (const row of rows) {\n    const dst = resolveTarget(row.src, row.target, pathSet, byBase);\n    if (dst !== row.dst) changed.push({ ...row, dst });\n  }\n  return changed;\n}\n\nasync function writeResolved(db: Connection, rows: LinkRow[]): Promise<void> {\n  if (rows.length === 0) return;\n  await db.runBatch(\n    'UPDATE links SET dst = ? WHERE src = ? AND target = ?',\n    rows.map((r) => [r.dst, r.src, r.target])\n  );\n}\n\n// A new or deleted file can change any note's resolution, so re-resolve the whole table.\n// Fallback for cold builds and large deltas -- see afterReconcile's threshold.\nasync function resolveAll(db: Connection, files: FileStat[]): Promise<boolean> {\n  const pathSet = new Set(files.map((f) => f.relPath));\n  const byBase = buildByBase(files);\n  const stmt = await db.prepare('SELECT src, target, dst, embed FROM links');\n  const rows = (await stmt.all()) as unknown as LinkRow[];\n  const changed = resolveRows(rows, pathSet, byBase);\n  await writeResolved(db, changed);\n  return changed.length > 0;\n}\n\n// Chunked so a large-but-under-threshold delta never exceeds SQLite's bound-variable limit\n// (SQLITE_MAX_VARIABLE_NUMBER, 32766); harmless headroom on DuckDB, which has no such cap.\nasync function selectIn(db: Connection, column: string, keys: string[]): Promise<LinkRow[]> {\n  const rows: LinkRow[] = [];\n  for (let i = 0; i < keys.length; i += 500) {\n    const chunk = keys.slice(i, i + 500);\n    const stmt = await db.prepare(`SELECT src, target, dst, embed FROM links WHERE ${column} IN (${chunk.map(() => '?').join(', ')})`);\n    rows.push(...((await stmt.all(...chunk)) as unknown as LinkRow[]));\n  }\n  return rows;\n}\n\n// Re-resolves only what this reconcile could have touched: re-stored sources, links whose\n// target basename matches an added/vanished file, and links whose dst vanished -- all indexed.\nasync function resolveIncremental(db: Connection, delta: ReconcileDelta): Promise<boolean> {\n  const pathSet = new Set(delta.files.map((f) => f.relPath));\n  const byBase = buildByBase(delta.files);\n\n  const changedBasenames = new Set<string>();\n  for (const p of delta.added) changedBasenames.add(baseKey(p));\n  for (const p of delta.vanished) changedBasenames.add(baseKey(p));\n\n  // \\0 can't appear in a path or target, so the key never collides; a space can.\n  const candidates = new Map<string, LinkRow>();\n  const collect = (rows: LinkRow[]) => {\n    for (const row of rows) candidates.set(`${row.src}\\0${row.target}\\0${row.embed}`, row);\n  };\n  collect(await selectIn(db, 'src', delta.reparsed));\n  collect(await selectIn(db, 'target_base', [...changedBasenames]));\n  collect(await selectIn(db, 'dst', delta.vanished));\n\n  const changed = resolveRows([...candidates.values()], pathSet, byBase);\n  await writeResolved(db, changed);\n  return changed.length > 0;\n}\n\n// One edge per (src, target); an embed row is excluded only when the same pair also exists as\n// a link. Self-edges are dropped so PageRank mass is not self-recycled.\nexport const LINK_EDGES_SQL = `SELECT src, dst FROM links WHERE dst IS NOT NULL AND embed = 0 AND src != dst\n    UNION ALL\n    SELECT src, dst FROM links l WHERE dst IS NOT NULL AND embed = 1 AND src != dst\n      AND NOT EXISTS (SELECT 1 FROM links l0 WHERE l0.src = l.src AND l0.target = l.target AND l0.embed = 0)`;\n\nexport function toEdges(rows: Array<{ src: string; dst: string }>): [string, string][] {\n  return rows.map((r) => [r.src, r.dst]);\n}\n\n// Resolved edges, for rank (inside reconcile's afterReconcile pass).\nexport async function linkEdges(db: Connection): Promise<[string, string][]> {\n  const stmt = await db.prepare(LINK_EDGES_SQL);\n  return toEdges((await stmt.all()) as Array<{ src: string; dst: string }>);\n}\n\n// Records whether remove()/store() deleted any link row, since afterReconcile runs after both\n// and dstChanged alone misses the reparsed-to-zero-links case. Keyed on delta so state dies with it.\nconst removedWithLinks = new WeakMap<ReconcileDelta, boolean>();\n\n// dst is written by resolution, not by store(), so it is absent from the column list and takes the\n// table's default on the append path.\nconst LINK_COLUMNS = ['src', 'target', 'target_base', 'embed'];\nconst UPSERT_LINK_SQL = 'INSERT INTO links (src, target, target_base, dst, embed) VALUES (?, ?, ?, NULL, ?) ON CONFLICT(src, target, embed) DO UPDATE SET target_base = excluded.target_base';\n\nexport const links: Feature = {\n  name: 'links',\n  async schema(db) {\n    await db.exec('CREATE TABLE IF NOT EXISTS links (src TEXT, target TEXT, target_base TEXT, dst TEXT, embed INTEGER, PRIMARY KEY (src, target, embed))');\n    await db.exec('CREATE INDEX IF NOT EXISTS links_dst ON links(dst)');\n    await db.exec('CREATE INDEX IF NOT EXISTS links_target_base ON links(target_base)');\n  },\n  extract,\n  // Reparsed docs are diffed in store() instead of wiped here: delete-and-reinsert resets dst\n  // to NULL, making every touch-only reparse look like an edge change and recompute PageRank.\n  async remove(db, paths, delta) {\n    const vanishedSet = new Set(delta.vanished);\n    const vanished = paths.filter((p) => vanishedSet.has(p));\n    if (vanished.length === 0) return;\n    const existingRows = await selectIn(db, 'src', vanished);\n    await db.runBatch(\n      'DELETE FROM links WHERE src = ?',\n      vanished.map((p) => [p])\n    );\n    if (existingRows.length > 0) removedWithLinks.set(delta, true);\n  },\n  async store(db, docs: ExtractedDoc[], delta) {\n    const byPath = new Map(docs.map((d) => [d.path, d.extracted as Array<{ target: string; embed: boolean }>]));\n    const addedSet = new Set(delta.added);\n    const reparsedExisting = docs.map((d) => d.path).filter((p) => !addedSet.has(p));\n\n    // Stale rows (target/embed pairs missing from the new parse) are diffed in JS from one\n    // bulk SELECT, so this pass costs one query plus one batched DELETE regardless of file count.\n    const existingRows = await selectIn(db, 'src', reparsedExisting);\n    const staleRows = existingRows.filter((row) => {\n      const targets = byPath.get(row.src) ?? [];\n      return !targets.some((t) => t.target === row.target && (t.embed ? 1 : 0) === row.embed);\n    });\n    if (staleRows.length > 0) {\n      await db.runBatch(\n        'DELETE FROM links WHERE src = ? AND target = ? AND embed = ?',\n        staleRows.map((r) => [r.src, r.target, r.embed])\n      );\n      removedWithLinks.set(delta, true);\n    }\n\n    // Upsert preserves dst on surviving rows; only new rows start at NULL. A same-note anchor\n    // gets no target_base, so SQL's `IN` excludes it from resolveIncremental's lookup.\n    // Split, unlike the other features: this hook has no remove() pass behind it (see above), so\n    // only a path in `added` is guaranteed to have no row yet. The rest genuinely conflict and the\n    // upsert is what preserves their `dst`.\n    const appendable: unknown[][] = [];\n    const upsertRows: unknown[][] = [];\n    for (const [path, targets] of byPath) {\n      for (const { target, embed } of targets) {\n        const row = [path, target, target.startsWith('#') ? null : baseKey(cleanTarget(target)), embed ? 1 : 0];\n        if (addedSet.has(path)) appendable.push(row);\n        else upsertRows.push(row);\n      }\n    }\n    await appendRows(db, 'links', LINK_COLUMNS, UPSERT_LINK_SQL, appendable);\n    if (upsertRows.length > 0) await db.runBatch(UPSERT_LINK_SQL, upsertRows);\n  },\n  async afterReconcile(db, delta) {\n    // Any deleted rows mean the edge set shrank -- whether the file vanished or was reparsed\n    // down to fewer/no links.\n    const removeHadLinks = removedWithLinks.get(delta) ?? false;\n\n    // A cold build is the only case a full pass wins. Measured 2026-09-01 on 6,566 notes, resolve\n    // time alone: full is flat near 90ms at any churn, incremental 7ms at 10 files and 30ms at 2,000.\n    const large = delta.files.length === 0 || delta.added.length === delta.files.length;\n\n    const dstChanged = large ? await resolveAll(db, delta.files) : await resolveIncremental(db, delta);\n    delta.linksChanged = dstChanged || removeHadLinks;\n  },\n};\n"],"names":["LINK_EDGES_SQL","linkEdges","links","toEdges","parseWikilinkInner","inner","beforeAlias","split","trim","startsWith","length","target","extract","_raw","rawBody","_search","data","body","test","maskRegions","seen","Set","results","add","embed","key","has","push","matchAll","m","index","dest","includes","Object","values","value","Array","isArray","item","exec","cleanTarget","replace","baseKey","path","posix","basename","toLowerCase","resolveTarget","src","pathSet","byBase","clean","fromSrc","normalize","join","dirname","candidate","candidates","get","buildByBase","files","Map","paths","map","f","relPath","sort","a","b","list","set","resolveRows","rows","changed","row","dst","writeResolved","db","runBatch","r","resolveAll","stmt","prepare","all","selectIn","column","keys","i","chunk","slice","resolveIncremental","delta","changedBasenames","p","collect","added","vanished","reparsed","removedWithLinks","WeakMap","LINK_COLUMNS","UPSERT_LINK_SQL","name","schema","remove","vanishedSet","existingRows","filter","store","docs","byPath","addedSet","reparsedExisting","staleRows","appendable","upsertRows","targets","d","extracted","some","t","appendRows","afterReconcile","removeHadLinks","large","dstChanged","linksChanged"],"mappings":";;;;;;;;;;;QA+KaA;eAAAA;;QAUSC;eAAAA;;QAcTC;eAAAA;;QAnBGC;eAAAA;;;4DApLE;wBAES;wBAEC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAG5B,0JAA0J;AAC1J,mJAAmJ;AAEnJ,wFAAwF;AACxF,gEAAgE;AAChE,SAASC,mBAAmBC,KAAa;IACvC,IAAMC,cAAcD,MAAME,KAAK,CAAC,IAAI,CAAC,EAAE,CAACC,IAAI;IAC5C,IAAIF,YAAYG,UAAU,CAAC,MAAM,OAAOH,YAAYI,MAAM,GAAG,IAAIJ,cAAc;IAC/E,IAAMK,SAASL,YAAYC,KAAK,CAAC,IAAI,CAAC,EAAE,CAACC,IAAI;IAC7C,OAAOG,UAAU;AACnB;AAEA,4FAA4F;AAC5F,0EAA0E;AAC1E,SAASC,QAAQC,IAAY,EAAEC,OAAe,EAAEC,OAA4C,EAAEC,IAA8B;IAC1H,IAAMC,OAAO,YAAYC,IAAI,CAACJ,WAAWK,IAAAA,qBAAW,EAACL,WAAWA;IAChE,IAAMM,OAAO,IAAIC;IACjB,IAAMC,UAAqD,EAAE;IAC7D,IAAMC,MAAM,aAACZ,QAAgBa;QAC3B,IAAMC,MAAM,AAAC,GAAaD,OAAXb,QAAO,MAAsB,OAAlBa,QAAQ,MAAM;QACxC,IAAIJ,KAAKM,GAAG,CAACD,MAAM;QACnBL,KAAKG,GAAG,CAACE;QACTH,QAAQK,IAAI,CAAC;YAAEhB,QAAAA;YAAQa,OAAAA;QAAM;IAC/B;QAGK,kCAAA,2BAAA;;QAFL,uFAAuF;QACvF,6DAA6D;QAC7D,QAAK,YAAWP,KAAKW,QAAQ,CAAC,sCAAzB,SAAA,6BAAA,QAAA,yBAAA,iCAA4C;YAA5C,IAAMC,IAAN;gBAE2BA;YAD9B,IAAMlB,SAASP,mBAAmByB,CAAC,CAAC,EAAE;YACtC,IAAIlB,QAAQY,IAAIZ,QAAQM,IAAI,CAAC,EAACY,WAAAA,EAAEC,KAAK,cAAPD,sBAAAA,WAAW,KAAK,EAAE,KAAK;QACvD;;QAHK;QAAA;;;iBAAA,6BAAA;gBAAA;;;gBAAA;sBAAA;;;;QAMA,mCAAA,4BAAA;;QAFL,2FAA2F;QAC3F,8FAA8F;QAC9F,QAAK,aAAWZ,KAAKW,QAAQ,CAAC,iGAAzB,UAAA,8BAAA,SAAA,0BAAA,kCAAuG;YAAvG,IAAMC,KAAN;YACH,IAAME,OAAOF,EAAC,CAAC,EAAE,CAACrB,IAAI;YACtB,qFAAqF;YACrF,oFAAoF;YACpF,IAAI,CAACuB,QAAQA,KAAKC,QAAQ,CAAC,QAAQ;YACnC,IAAI,oCAAoCd,IAAI,CAACa,OAAO;YACpD,IAAMpB,UAASoB,KAAKtB,UAAU,CAAC,OAAOsB,OAAOA,KAAKxB,KAAK,CAAC,IAAI,CAAC,EAAE;YAC/D,IAAII,SAAQY,IAAIZ,SAAQkB,EAAC,CAAC,EAAE,KAAK;QACnC;;QARK;QAAA;;;iBAAA,8BAAA;gBAAA;;;gBAAA;sBAAA;;;;QASA,mCAAA,4BAAA;;QAAL,QAAK,aAAeI,OAAOC,MAAM,CAAClB,iBAAAA,kBAAAA,OAAQ,CAAC,uBAAtC,UAAA,8BAAA,SAAA,0BAAA,kCAA0C;YAA1C,IAAMmB,QAAN;gBACE,mCAAA,4BAAA;;gBAAL,QAAK,aAAcC,CAAAA,MAAMC,OAAO,CAACF,SAASA,QAAQ;oBAACA;iBAAM,AAAD,sBAAnD,UAAA,8BAAA,SAAA,0BAAA,kCAAsD;oBAAtD,IAAMG,OAAN;oBACH,IAAI,OAAOA,SAAS,UAAU;oBAC9B,IAAMT,KAAI,iBAAiBU,IAAI,CAACD,KAAK9B,IAAI;oBACzC,IAAI,CAACqB,IAAG;oBACR,IAAMlB,UAASP,mBAAmByB,EAAC,CAAC,EAAE;oBACtC,IAAIlB,SAAQY,IAAIZ,SAAQ;gBAC1B;;gBANK;gBAAA;;;yBAAA,8BAAA;wBAAA;;;wBAAA;8BAAA;;;;QAOP;;QARK;QAAA;;;iBAAA,8BAAA;gBAAA;;;gBAAA;sBAAA;;;;IASL,OAAOW;AACT;AAEA,SAASkB,YAAY7B,MAAc;IACjC,OAAOA,OAAO8B,OAAO,CAAC,OAAO,KAAKA,OAAO,CAAC,SAAS;AACrD;AAEA,SAASC,QAAQC,IAAY;IAC3B,OAAOC,cAAK,CAACC,QAAQ,CAACF,MAAMF,OAAO,CAAC,UAAU,IAAIK,WAAW;AAC/D;AAEA,8FAA8F;AAC9F,kGAAkG;AAClG,SAASC,cAAcC,GAAW,EAAErC,MAAc,EAAEsC,OAAoB,EAAEC,MAA6B;IACrG,4FAA4F;IAC5F,IAAIvC,OAAOF,UAAU,CAAC,MAAM,OAAOuC;IACnC,IAAMG,QAAQX,YAAY7B;IAC1B,IAAMyC,UAAUR,cAAK,CAACS,SAAS,CAACT,cAAK,CAACU,IAAI,CAACV,cAAK,CAACW,OAAO,CAACP,MAAMG;IAC/D,gBAAwB,QAAA;QAACA;QAAQ,GAAQ,OAANA,OAAM;QAAMC;QAAU,GAAU,OAARA,SAAQ;KAAK,OAAhD,mBAAkD;YAA/DI,YAAa;QACtB,IAAIP,QAAQvB,GAAG,CAAC8B,YAAY,OAAOA;IACrC;IACA,IAAMC,aAAaP,OAAOQ,GAAG,CAAChB,QAAQS;IACtC,IAAI,CAACM,YAAY,OAAO;IACxB,0FAA0F;IAC1F,+DAA+D;IAC/D,OAAOA,WAAWzB,QAAQ,CAACgB,OAAOA,MAAMS,UAAU,CAAC,EAAE;AACvD;AAEA,6FAA6F;AAC7F,yFAAyF;AACzF,SAASE,YAAYC,KAAiB;IACpC,IAAMV,SAAS,IAAIW;IACnB,IAAMC,QAAQF,MAAMG,GAAG,CAAC,SAACC;eAAMA,EAAEC,OAAO;OAAEC,IAAI,CAAC,SAACC,GAAGC;eAAMD,EAAEzD,MAAM,GAAG0D,EAAE1D,MAAM,IAAKyD,CAAAA,IAAIC,IAAI,CAAC,IAAID,IAAIC,IAAI,IAAI,CAAA;;QACrG,kCAAA,2BAAA;;QAAL,QAAK,YAAcN,0BAAd,SAAA,6BAAA,QAAA,yBAAA,iCAAqB;YAArB,IAAMnB,OAAN;YACH,IAAMlB,MAAMiB,QAAQC;YACpB,IAAM0B,OAAOnB,OAAOQ,GAAG,CAACjC;YACxB,IAAI4C,MAAMA,KAAK1C,IAAI,CAACgB;iBACfO,OAAOoB,GAAG,CAAC7C,KAAK;gBAACkB;aAAK;QAC7B;;QALK;QAAA;;;iBAAA,6BAAA;gBAAA;;;gBAAA;sBAAA;;;;IAML,OAAOO;AACT;AASA,4FAA4F;AAC5F,uCAAuC;AACvC,SAASqB,YAAYC,IAAe,EAAEvB,OAAoB,EAAEC,MAA6B;IACvF,IAAMuB,UAAqB,EAAE;QACxB,kCAAA,2BAAA;;QAAL,QAAK,YAAaD,yBAAb,SAAA,6BAAA,QAAA,yBAAA,iCAAmB;YAAnB,IAAME,MAAN;YACH,IAAMC,MAAM5B,cAAc2B,IAAI1B,GAAG,EAAE0B,IAAI/D,MAAM,EAAEsC,SAASC;YACxD,IAAIyB,QAAQD,IAAIC,GAAG,EAAEF,QAAQ9C,IAAI,CAAC,wCAAK+C;gBAAKC,KAAAA;;QAC9C;;QAHK;QAAA;;;iBAAA,6BAAA;gBAAA;;;gBAAA;sBAAA;;;;IAIL,OAAOF;AACT;AAEA,SAAeG,cAAcC,EAAc,EAAEL,IAAe;;;;;oBAC1D,IAAIA,KAAK9D,MAAM,KAAK,GAAG;;;oBACvB;;wBAAMmE,GAAGC,QAAQ,CACf,yDACAN,KAAKT,GAAG,CAAC,SAACgB;mCAAM;gCAACA,EAAEJ,GAAG;gCAAEI,EAAE/B,GAAG;gCAAE+B,EAAEpE,MAAM;6BAAC;;;;oBAF1C;;;;;;IAIF;;AAEA,yFAAyF;AACzF,+EAA+E;AAC/E,SAAeqE,WAAWH,EAAc,EAAEjB,KAAiB;;YACnDX,SACAC,QACA+B,MACAT,MACAC;;;;oBAJAxB,UAAU,IAAI5B,IAAIuC,MAAMG,GAAG,CAAC,SAACC;+BAAMA,EAAEC,OAAO;;oBAC5Cf,SAASS,YAAYC;oBACd;;wBAAMiB,GAAGK,OAAO,CAAC;;;oBAAxBD,OAAO;oBACC;;wBAAMA,KAAKE,GAAG;;;oBAAtBX,OAAQ;oBACRC,UAAUF,YAAYC,MAAMvB,SAASC;oBAC3C;;wBAAM0B,cAAcC,IAAIJ;;;oBAAxB;oBACA;;wBAAOA,QAAQ/D,MAAM,GAAG;;;;IAC1B;;AAEA,2FAA2F;AAC3F,2FAA2F;AAC3F,SAAe0E,SAASP,EAAc,EAAEQ,MAAc,EAAEC,IAAc;;YAC9Dd,MACGe,GAGcN,OAArBT,OAFMgB,OACAP;;;;oBAHFT;oBACGe,IAAI;;;yBAAGA,CAAAA,IAAID,KAAK5E,MAAM,AAAD;;;;oBACtB8E,QAAQF,KAAKG,KAAK,CAACF,GAAGA,IAAI;oBACnB;;wBAAMV,GAAGK,OAAO,CAAC,AAAC,mDAAgEM,OAAdH,QAAO,SAAuC,OAAhCG,MAAMzB,GAAG,CAAC;mCAAM;2BAAKT,IAAI,CAAC,OAAM;;;oBAAzH2B,OAAO;8BACbT,CAAAA,QAAAA,MAAK7C,IAAI;;wBAAT6C;;oBAAe;;wBAAMS,CAAAA,QAAAA,MAAKE,GAAG,OAARF,OAAS,qBAAGO;;;oBAAjChB;wBAAU;4BAAK;;;;;oBAHgBe,KAAK;;;;;;oBAKtC;;wBAAOf;;;;IACT;;AAEA,0FAA0F;AAC1F,+FAA+F;AAC/F,SAAekB,mBAAmBb,EAAc,EAAEc,KAAqB;;YAC/D1C,SACAC,QAEA0C,kBACD,2BAAA,mBAAA,gBAAA,WAAA,OAAMC,GACN,4BAAA,oBAAA,iBAAA,YAAA,QAAMA,IAGLpC,YACAqC,SAOArB;;;;oBAhBAxB,UAAU,IAAI5B,IAAIsE,MAAM/B,KAAK,CAACG,GAAG,CAAC,SAACC;+BAAMA,EAAEC,OAAO;;oBAClDf,SAASS,YAAYgC,MAAM/B,KAAK;oBAEhCgC,mBAAmB,IAAIvE;oBACxB,kCAAA,2BAAA;;wBAAL,IAAK,YAAWsE,MAAMI,KAAK,uBAAtB,6BAAA,QAAA,yBAAA;4BAAMF,IAAN;4BAAwBD,iBAAiBrE,GAAG,CAACmB,QAAQmD;;;wBAArD;wBAAA;;;iCAAA,6BAAA;gCAAA;;;gCAAA;sCAAA;;;;oBACA,mCAAA,4BAAA;;wBAAL,IAAK,aAAWF,MAAMK,QAAQ,uBAAzB,8BAAA,SAAA,0BAAA;4BAAMH,KAAN;4BAA2BD,iBAAiBrE,GAAG,CAACmB,QAAQmD;;;wBAAxD;wBAAA;;;iCAAA,8BAAA;gCAAA;;;gCAAA;sCAAA;;;;oBAEL,+EAA+E;oBACzEpC,aAAa,IAAII;oBACjBiC,UAAU,iBAACtB;4BACV,kCAAA,2BAAA;;4BAAL,QAAK,YAAaA,yBAAb,SAAA,6BAAA,QAAA,yBAAA;gCAAA,IAAME,MAAN;gCAAmBjB,WAAWa,GAAG,CAAC,AAAC,GAAcI,OAAZA,IAAI1B,GAAG,EAAC,MAAmB0B,OAAfA,IAAI/D,MAAM,EAAC,MAAc,OAAV+D,IAAIlD,KAAK,GAAIkD;;;4BAA7E;4BAAA;;;qCAAA,6BAAA;oCAAA;;;oCAAA;0CAAA;;;;oBACP;oBACQ;;wBAAMU,SAASP,IAAI,OAAOc,MAAMM,QAAQ;;;oBAAhDH;wBAAQ;;oBACA;;wBAAMV,SAASP,IAAI,eAAgB,qBAAGe;;;oBAA9CE;wBAAQ;;oBACA;;wBAAMV,SAASP,IAAI,OAAOc,MAAMK,QAAQ;;;oBAAhDF;wBAAQ;;oBAEFrB,UAAUF,YAAa,qBAAGd,WAAWvB,MAAM,KAAKe,SAASC;oBAC/D;;wBAAM0B,cAAcC,IAAIJ;;;oBAAxB;oBACA;;wBAAOA,QAAQ/D,MAAM,GAAG;;;;IAC1B;;AAIO,IAAMV,iBAAiB;AAKvB,SAASG,QAAQqE,IAAyC;IAC/D,OAAOA,KAAKT,GAAG,CAAC,SAACgB;eAAM;YAACA,EAAE/B,GAAG;YAAE+B,EAAEJ,GAAG;SAAC;;AACvC;AAGO,SAAe1E,UAAU4E,EAAc;;YACtCI;;;;oBAAO;;wBAAMJ,GAAGK,OAAO,CAAClF;;;oBAAxBiF,OAAO;oBACG;;wBAAMA,KAAKE,GAAG;;;oBAA9B;;wBAAOhF;4BAAS;;;;;IAClB;;AAEA,8FAA8F;AAC9F,qGAAqG;AACrG,IAAM+F,mBAAmB,IAAIC;AAE7B,mGAAmG;AACnG,sCAAsC;AACtC,IAAMC,eAAe;IAAC;IAAO;IAAU;IAAe;CAAQ;AAC9D,IAAMC,kBAAkB;AAEjB,IAAMnG,QAAiB;IAC5BoG,MAAM;IACAC,QAAN,SAAMA,OAAO1B,EAAE;;;;;wBACb;;4BAAMA,GAAGtC,IAAI,CAAC;;;wBAAd;wBACA;;4BAAMsC,GAAGtC,IAAI,CAAC;;;wBAAd;wBACA;;4BAAMsC,GAAGtC,IAAI,CAAC;;;wBAAd;;;;;;QACF;;IACA3B,SAAAA;IAGM4F,QAFN,4FAA4F;IAC5F,4FAA4F;IAC5F,SAAMA,OAAO3B,EAAE,EAAEf,KAAK,EAAE6B,KAAK;;gBACrBc,aACAT,UAEAU;;;;wBAHAD,cAAc,IAAIpF,IAAIsE,MAAMK,QAAQ;wBACpCA,WAAWlC,MAAM6C,MAAM,CAAC,SAACd;mCAAMY,YAAY/E,GAAG,CAACmE;;wBACrD,IAAIG,SAAStF,MAAM,KAAK,GAAG;;;wBACN;;4BAAM0E,SAASP,IAAI,OAAOmB;;;wBAAzCU,eAAe;wBACrB;;4BAAM7B,GAAGC,QAAQ,CACf,mCACAkB,SAASjC,GAAG,CAAC,SAAC8B;uCAAM;oCAACA;iCAAE;;;;wBAFzB;wBAIA,IAAIa,aAAahG,MAAM,GAAG,GAAGwF,iBAAiB5B,GAAG,CAACqB,OAAO;;;;;;QAC3D;;IACMiB,OAAN,SAAMA,MAAM/B,EAAE,EAAEgC,IAAoB,EAAElB,KAAK;;gBACnCmB,QACAC,UACAC,kBAIAN,cACAO,WAiBAC,YACAC,YACD,2BAAA,mBAAA,gBAAA,WAAA,oBAAOxE,MAAMyE,SACX,4BAAA,oBAAA,iBAAA,YAAA,sBAAQzG,QAAQa,OACbkD;;;;wBA5BJoC,SAAS,IAAIjD,IAAIgD,KAAK9C,GAAG,CAAC,SAACsD;mCAAM;gCAACA,EAAE1E,IAAI;gCAAE0E,EAAEC,SAAS;6BAA8C;;wBACnGP,WAAW,IAAI1F,IAAIsE,MAAMI,KAAK;wBAC9BiB,mBAAmBH,KAAK9C,GAAG,CAAC,SAACsD;mCAAMA,EAAE1E,IAAI;2BAAEgE,MAAM,CAAC,SAACd;mCAAM,CAACkB,SAASrF,GAAG,CAACmE;;wBAIxD;;4BAAMT,SAASP,IAAI,OAAOmC;;;wBAAzCN,eAAe;wBACfO,YAAYP,aAAaC,MAAM,CAAC,SAACjC;gCACrBoC;4BAAhB,IAAMM,WAAUN,cAAAA,OAAOpD,GAAG,CAACgB,IAAI1B,GAAG,eAAlB8D,yBAAAA,cAAuB,EAAE;4BACzC,OAAO,CAACM,QAAQG,IAAI,CAAC,SAACC;uCAAMA,EAAE7G,MAAM,KAAK+D,IAAI/D,MAAM,IAAI,AAAC6G,CAAAA,EAAEhG,KAAK,GAAG,IAAI,CAAA,MAAOkD,IAAIlD,KAAK;;wBACxF;6BACIyF,CAAAA,UAAUvG,MAAM,GAAG,CAAA,GAAnBuG;;;;wBACF;;4BAAMpC,GAAGC,QAAQ,CACf,gEACAmC,UAAUlD,GAAG,CAAC,SAACgB;uCAAM;oCAACA,EAAE/B,GAAG;oCAAE+B,EAAEpE,MAAM;oCAAEoE,EAAEvD,KAAK;iCAAC;;;;wBAFjD;wBAIA0E,iBAAiB5B,GAAG,CAACqB,OAAO;;;wBAG9B,0FAA0F;wBAC1F,mFAAmF;wBACnF,6FAA6F;wBAC7F,+FAA+F;wBAC/F,wCAAwC;wBAClCuB;wBACAC;wBACD,kCAAA,2BAAA;;4BAAL,IAAK,YAAyBL,6BAAzB,6BAAA,QAAA,yBAAA,iCAAiC;+DAAjC,iBAAOnE,uBAAMyE;gCACX,mCAAA,4BAAA;;oCAAL,IAAK,aAA2BA,8BAA3B,8BAAA,SAAA,0BAAA,kCAAoC;uDAApC,cAAQzG,sBAAAA,QAAQa,qBAAAA;wCACbkD;4CAAO/B;4CAAMhC;4CAAQA,OAAOF,UAAU,CAAC,OAAO,OAAOiC,QAAQF,YAAY7B;4CAAUa,QAAQ,IAAI;;wCACrG,IAAIuF,SAASrF,GAAG,CAACiB,OAAOuE,WAAWvF,IAAI,CAAC+C;6CACnCyC,WAAWxF,IAAI,CAAC+C;oCACvB;;oCAJK;oCAAA;;;6CAAA,8BAAA;4CAAA;;;4CAAA;kDAAA;;;;4BAKP;;4BANK;4BAAA;;;qCAAA,6BAAA;oCAAA;;;oCAAA;0CAAA;;;;wBAOL;;4BAAM+C,IAAAA,oBAAU,EAAC5C,IAAI,SAASuB,cAAcC,iBAAiBa;;;wBAA7D;6BACIC,CAAAA,WAAWzG,MAAM,GAAG,CAAA,GAApByG;;;;wBAAuB;;4BAAMtC,GAAGC,QAAQ,CAACuB,iBAAiBc;;;wBAAnC;;;;;;;;QAC7B;;IACMO,gBAAN,SAAMA,eAAe7C,EAAE,EAAEc,KAAK;;gBAGLO,uBAAjByB,gBAIAC,OAEAC;;;;wBARN,yFAAyF;wBACzF,0BAA0B;wBACpBF,kBAAiBzB,wBAAAA,iBAAiBxC,GAAG,CAACiC,oBAArBO,mCAAAA,wBAA+B;wBAEtD,8FAA8F;wBAC9F,kGAAkG;wBAC5F0B,QAAQjC,MAAM/B,KAAK,CAAClD,MAAM,KAAK,KAAKiF,MAAMI,KAAK,CAACrF,MAAM,KAAKiF,MAAM/B,KAAK,CAAClD,MAAM;6BAEhEkH,OAAAA;;;;wBAAQ;;4BAAM5C,WAAWH,IAAIc,MAAM/B,KAAK;;;+BAAhC;;;;;;wBAAoC;;4BAAM8B,mBAAmBb,IAAIc;;;+BAA7B;;;wBAAzDkC;wBACNlC,MAAMmC,YAAY,GAAGD,cAAcF;;;;;;QACrC;;AACF"}
+{"version":3,"sources":["/Users/kevin/Dev/OpenSource/ai/sensemaking/src/features/links.ts"],"sourcesContent":["import posix from 'node:path/posix';\nimport type { FileStat } from '../scan/index.ts';\nimport { appendRows } from '../store/shared.ts';\nimport type { Connection } from '../store/types.ts';\nimport { maskRegions } from './fences.ts';\nimport type { ExtractedDoc, Feature, ReconcileDelta } from './types.ts';\n\n// links(src, target, target_base, dst, embed): target as written, target_base its indexed baseKey, dst the resolved path or NULL (a queryable dead link).\n// embed distinguishes `![[x]]`/`![](x.md)` from `[[x]]`/`[](x.md)` -- Obsidian's grain: a target both linked and embedded in one note is two rows.\n\n// Alias stripped after |; a leading # keeps the anchor as the target (self-link needs a\n// heading name), else the anchor splits off. Null = not a link.\nfunction parseWikilinkInner(inner: string): string | null {\n  const beforeAlias = inner.split('|')[0].trim();\n  if (beforeAlias.startsWith('#')) return beforeAlias.length > 1 ? beforeAlias : null;\n  const target = beforeAlias.split('#')[0].trim();\n  return target || null;\n}\n\n// A frontmatter value counts only when it is exactly a wikilink (\"[[X]]\") -- mid-string and\n// ![[...]] forms don't count there, per Obsidian's rule (probe-verified).\nfunction extract(_raw: string, rawBody: string, _search?: { title: string; summary: string }, data?: Record<string, unknown>): Array<{ target: string; embed: boolean }> {\n  const body = /\\[\\[|\\]\\(/.test(rawBody) ? maskRegions(rawBody) : rawBody;\n  const seen = new Set<string>();\n  const results: Array<{ target: string; embed: boolean }> = [];\n  const add = (target: string, embed: boolean) => {\n    const key = `${target}\\0${embed ? '1' : '0'}`;\n    if (seen.has(key)) return;\n    seen.add(key);\n    results.push({ target, embed });\n  };\n  // To the first ]], as Obsidian parses it, so a heading or alias holding a lone ] still\n  // matches; anchor and alias split off in parseWikilinkInner.\n  for (const m of body.matchAll(/\\[\\[(.*?)\\]\\]/g)) {\n    const target = parseWikilinkInner(m[1]);\n    if (target) add(target, body[(m.index ?? 0) - 1] === '!');\n  }\n  // Any internal destination, not only .md-suffixed: \\](Zektor) resolves like [[Zektor]] and\n  // \\](#anchor) is a self-edge. External URLs and titled links (dest stops at whitespace) skip.\n  for (const m of body.matchAll(/(!)?\\[[^\\]]*\\]\\(((?:[^()\\s]|\\([^()\\s]*\\))+)(?:\\s+(?:\"[^)]*\"|'[^)]*'))?\\)/g)) {\n    const dest = m[2].trim();\n    // External: a URI scheme prefix (mailto:, tel:, data:, https:...), protocol-relative\n    // //host, a www. shorthand, or a scheme anywhere (the malformed double-paren case).\n    if (!dest || dest.includes('://')) continue;\n    if (/^([a-z][a-z0-9+.-]*:|\\/\\/|www\\.)/i.test(dest)) continue;\n    const target = dest.startsWith('#') ? dest : dest.split('#')[0];\n    if (target) add(target, m[1] === '!');\n  }\n  for (const value of Object.values(data ?? {})) {\n    for (const item of Array.isArray(value) ? value : [value]) {\n      if (typeof item !== 'string') continue;\n      const m = /^\\[\\[(.*)\\]\\]$/.exec(item.trim());\n      if (!m) continue;\n      const target = parseWikilinkInner(m[1]);\n      if (target) add(target, false);\n    }\n  }\n  return results;\n}\n\nfunction cleanTarget(target: string): string {\n  return target.replace(/\\\\/g, '/').replace(/^\\.\\//, '');\n}\n\nfunction baseKey(path: string): string {\n  return posix.basename(path).replace(/\\.md$/i, '').toLowerCase();\n}\n\n// Obsidian-style: exact relative path (with/without .md), path relative to the linking note's\n// directory, then basename match (shortest path wins ties, verified against a cold-loaded vault).\nfunction resolveTarget(src: string, target: string, pathSet: Set<string>, byBase: Map<string, string[]>): string | null {\n  // [[#Heading]]: a same-note anchor, always the note itself -- never depends on other files.\n  if (target.startsWith('#')) return src;\n  const clean = cleanTarget(target);\n  const fromSrc = posix.normalize(posix.join(posix.dirname(src), clean));\n  for (const candidate of [clean, `${clean}.md`, fromSrc, `${fromSrc}.md`]) {\n    if (pathSet.has(candidate)) return candidate;\n  }\n  const candidates = byBase.get(baseKey(clean));\n  if (!candidates) return null;\n  // The linking note itself wins a basename collision (Obsidian resolves to self before the\n  // shortest-path rule -- cold-load verified on the hub corpus).\n  return candidates.includes(src) ? src : candidates[0];\n}\n\n// Shortest path wins a basename collision; equal lengths fall back to lexicographic, our own\n// deterministic tiebreak for a case Obsidian itself leaves registration-order-dependent.\nfunction buildByBase(files: FileStat[]): Map<string, string[]> {\n  const byBase = new Map<string, string[]>();\n  const paths = files.map((f) => f.relPath).sort((a, b) => a.length - b.length || (a < b ? -1 : a > b ? 1 : 0));\n  for (const path of paths) {\n    const key = baseKey(path);\n    const list = byBase.get(key);\n    if (list) list.push(path);\n    else byBase.set(key, [path]);\n  }\n  return byBase;\n}\n\ninterface LinkRow {\n  src: string;\n  target: string;\n  dst: string | null;\n  embed: number;\n}\n\n// resolveTarget applied to `rows`, returning only the rows whose dst changed, so the caller\n// can write them in one runBatch call.\nfunction resolveRows(rows: LinkRow[], pathSet: Set<string>, byBase: Map<string, string[]>): LinkRow[] {\n  const changed: LinkRow[] = [];\n  for (const row of rows) {\n    const dst = resolveTarget(row.src, row.target, pathSet, byBase);\n    if (dst !== row.dst) changed.push({ ...row, dst });\n  }\n  return changed;\n}\n\nasync function writeResolved(db: Connection, rows: LinkRow[]): Promise<void> {\n  if (rows.length === 0) return;\n  await db.runBatch(\n    'UPDATE links SET dst = ? WHERE src = ? AND target = ?',\n    rows.map((r) => [r.dst, r.src, r.target])\n  );\n}\n\n// Chunked so a large-but-under-threshold delta never exceeds SQLite's bound-variable limit\n// (SQLITE_MAX_VARIABLE_NUMBER, 32766); harmless headroom on DuckDB, which has no such cap.\nasync function selectIn(db: Connection, column: string, keys: string[]): Promise<LinkRow[]> {\n  const rows: LinkRow[] = [];\n  for (let i = 0; i < keys.length; i += 500) {\n    const chunk = keys.slice(i, i + 500);\n    const stmt = await db.prepare(`SELECT src, target, dst, embed FROM links WHERE ${column} IN (${chunk.map(() => '?').join(', ')})`);\n    rows.push(...((await stmt.all(...chunk)) as unknown as LinkRow[]));\n  }\n  return rows;\n}\n\n// Re-resolves only what this reconcile could have touched: re-stored sources, links whose\n// target basename matches an added/vanished file, and links whose dst vanished -- all indexed.\nasync function resolveIncremental(db: Connection, delta: ReconcileDelta): Promise<boolean> {\n  const pathSet = new Set(delta.files.map((f) => f.relPath));\n  const byBase = buildByBase(delta.files);\n\n  const changedBasenames = new Set<string>();\n  for (const p of delta.added) changedBasenames.add(baseKey(p));\n  for (const p of delta.vanished) changedBasenames.add(baseKey(p));\n\n  // \\0 can't appear in a path or target, so the key never collides; a space can.\n  const candidates = new Map<string, LinkRow>();\n  const collect = (rows: LinkRow[]) => {\n    for (const row of rows) candidates.set(`${row.src}\\0${row.target}\\0${row.embed}`, row);\n  };\n  collect(await selectIn(db, 'src', delta.reparsed));\n  collect(await selectIn(db, 'target_base', [...changedBasenames]));\n  collect(await selectIn(db, 'dst', delta.vanished));\n\n  const changed = resolveRows([...candidates.values()], pathSet, byBase);\n  await writeResolved(db, changed);\n  return changed.length > 0;\n}\n\n// One edge per (src, target); an embed row is excluded only when the same pair also exists as\n// a link. Self-edges are dropped so PageRank mass is not self-recycled.\nexport const LINK_EDGES_SQL = `SELECT src, dst FROM links WHERE dst IS NOT NULL AND embed = 0 AND src != dst\n    UNION ALL\n    SELECT src, dst FROM links l WHERE dst IS NOT NULL AND embed = 1 AND src != dst\n      AND NOT EXISTS (SELECT 1 FROM links l0 WHERE l0.src = l.src AND l0.target = l.target AND l0.embed = 0)`;\n\nexport function toEdges(rows: Array<{ src: string; dst: string }>): [string, string][] {\n  return rows.map((r) => [r.src, r.dst]);\n}\n\n// Resolved edges, for rank (inside reconcile's afterReconcile pass).\nexport async function linkEdges(db: Connection): Promise<[string, string][]> {\n  const stmt = await db.prepare(LINK_EDGES_SQL);\n  return toEdges((await stmt.all()) as Array<{ src: string; dst: string }>);\n}\n\n// Records whether remove()/store() deleted any link row, since afterReconcile runs after both\n// and dstChanged alone misses the reparsed-to-zero-links case. Keyed on delta so state dies with it.\nconst removedWithLinks = new WeakMap<ReconcileDelta, boolean>();\n\n// Cold build only: whether store() resolved at least one row to a non-null dst, so afterReconcile\n// can report linksChanged without re-reading the table it just wrote.\nconst coldResolved = new WeakMap<ReconcileDelta, boolean>();\n\n// dst stays NULL here on an incremental store (resolution runs afterward); a cold build resolves\n// it inline in store() instead, through the *_RESOLVED column list and SQL below.\nconst LINK_COLUMNS = ['src', 'target', 'target_base', 'embed'];\nconst UPSERT_LINK_SQL = 'INSERT INTO links (src, target, target_base, dst, embed) VALUES (?, ?, ?, NULL, ?) ON CONFLICT(src, target, embed) DO UPDATE SET target_base = excluded.target_base';\nconst LINK_COLUMNS_RESOLVED = ['src', 'target', 'target_base', 'dst', 'embed'];\nconst UPSERT_LINK_SQL_RESOLVED = 'INSERT INTO links (src, target, target_base, dst, embed) VALUES (?, ?, ?, ?, ?) ON CONFLICT(src, target, embed) DO UPDATE SET target_base = excluded.target_base';\n\nexport const links: Feature = {\n  name: 'links',\n  async schema(db) {\n    await db.exec('CREATE TABLE IF NOT EXISTS links (src TEXT, target TEXT, target_base TEXT, dst TEXT, embed INTEGER, PRIMARY KEY (src, target, embed))');\n    await db.exec('CREATE INDEX IF NOT EXISTS links_dst ON links(dst)');\n    await db.exec('CREATE INDEX IF NOT EXISTS links_target_base ON links(target_base)');\n  },\n  extract,\n  // Reparsed docs are diffed in store() instead of wiped here: delete-and-reinsert resets dst\n  // to NULL, making every touch-only reparse look like an edge change and recompute PageRank.\n  async remove(db, paths, delta) {\n    const vanishedSet = new Set(delta.vanished);\n    const vanished = paths.filter((p) => vanishedSet.has(p));\n    if (vanished.length === 0) return;\n    const existingRows = await selectIn(db, 'src', vanished);\n    await db.runBatch(\n      'DELETE FROM links WHERE src = ?',\n      vanished.map((p) => [p])\n    );\n    if (existingRows.length > 0) removedWithLinks.set(delta, true);\n  },\n  async store(db, docs: ExtractedDoc[], delta) {\n    const byPath = new Map(docs.map((d) => [d.path, d.extracted as Array<{ target: string; embed: boolean }>]));\n    const addedSet = new Set(delta.added);\n    const reparsedExisting = docs.map((d) => d.path).filter((p) => !addedSet.has(p));\n\n    // Stale rows (target/embed pairs missing from the new parse) are diffed in JS from one\n    // bulk SELECT, so this pass costs one query plus one batched DELETE regardless of file count.\n    const existingRows = await selectIn(db, 'src', reparsedExisting);\n    const staleRows = existingRows.filter((row) => {\n      const targets = byPath.get(row.src) ?? [];\n      return !targets.some((t) => t.target === row.target && (t.embed ? 1 : 0) === row.embed);\n    });\n    if (staleRows.length > 0) {\n      await db.runBatch(\n        'DELETE FROM links WHERE src = ? AND target = ? AND embed = ?',\n        staleRows.map((r) => [r.src, r.target, r.embed])\n      );\n      removedWithLinks.set(delta, true);\n    }\n\n    // Cold build: every path is in `added`, so pathSet/byBase cover the same complete tree\n    // afterReconcile's large branch would otherwise re-derive; resolve dst here instead.\n    const cold = delta.files.length === 0 || delta.added.length === delta.files.length;\n    let resolveNew: ((src: string, target: string) => string | null) | undefined;\n    if (cold) {\n      const pathSet = new Set(delta.files.map((f) => f.relPath));\n      const byBase = buildByBase(delta.files);\n      resolveNew = (src, target) => resolveTarget(src, target, pathSet, byBase);\n    }\n    let resolvedLink = false;\n\n    // Upsert preserves dst on surviving rows; a cold build resolves new rows, else they start NULL.\n    // A same-note anchor gets no target_base, so SQL's `IN` excludes it from resolveIncremental's lookup.\n    // Split, unlike the other features: this hook has no remove() pass behind it (see above), so\n    // only a path in `added` is guaranteed to have no row yet. The rest genuinely conflict and the\n    // upsert is what preserves their `dst`.\n    const appendable: unknown[][] = [];\n    const upsertRows: unknown[][] = [];\n    for (const [path, targets] of byPath) {\n      for (const { target, embed } of targets) {\n        const targetBase = target.startsWith('#') ? null : baseKey(cleanTarget(target));\n        if (!addedSet.has(path)) {\n          upsertRows.push([path, target, targetBase, embed ? 1 : 0]);\n          continue;\n        }\n        if (!resolveNew) {\n          appendable.push([path, target, targetBase, embed ? 1 : 0]);\n          continue;\n        }\n        const dst = resolveNew(path, target);\n        if (dst !== null) resolvedLink = true;\n        appendable.push([path, target, targetBase, dst, embed ? 1 : 0]);\n      }\n    }\n    await appendRows(db, 'links', resolveNew ? LINK_COLUMNS_RESOLVED : LINK_COLUMNS, resolveNew ? UPSERT_LINK_SQL_RESOLVED : UPSERT_LINK_SQL, appendable);\n    if (upsertRows.length > 0) await db.runBatch(UPSERT_LINK_SQL, upsertRows);\n    if (cold) coldResolved.set(delta, resolvedLink);\n  },\n  async afterReconcile(db, delta) {\n    // Any deleted rows mean the edge set shrank -- whether the file vanished or was reparsed\n    // down to fewer/no links.\n    const removeHadLinks = removedWithLinks.get(delta) ?? false;\n\n    // A cold build is the only case a full pass wins. Measured 2026-09-01 on 6,566 notes, resolve\n    // time alone: full is flat near 90ms at any churn, incremental 7ms at 10 files and 30ms at 2,000.\n    const large = delta.files.length === 0 || delta.added.length === delta.files.length;\n    // store() already resolved dst inline on this cold build (same test), so nothing is left to update.\n    if (large) {\n      delta.linksChanged = (coldResolved.get(delta) ?? false) || removeHadLinks;\n      return;\n    }\n\n    const dstChanged = await resolveIncremental(db, delta);\n    delta.linksChanged = dstChanged || removeHadLinks;\n  },\n};\n"],"names":["LINK_EDGES_SQL","linkEdges","links","toEdges","parseWikilinkInner","inner","beforeAlias","split","trim","startsWith","length","target","extract","_raw","rawBody","_search","data","body","test","maskRegions","seen","Set","results","add","embed","key","has","push","matchAll","m","index","dest","includes","Object","values","value","Array","isArray","item","exec","cleanTarget","replace","baseKey","path","posix","basename","toLowerCase","resolveTarget","src","pathSet","byBase","clean","fromSrc","normalize","join","dirname","candidate","candidates","get","buildByBase","files","Map","paths","map","f","relPath","sort","a","b","list","set","resolveRows","rows","changed","row","dst","writeResolved","db","runBatch","r","selectIn","column","keys","i","stmt","chunk","slice","prepare","all","resolveIncremental","delta","changedBasenames","p","collect","added","vanished","reparsed","removedWithLinks","WeakMap","coldResolved","LINK_COLUMNS","UPSERT_LINK_SQL","LINK_COLUMNS_RESOLVED","UPSERT_LINK_SQL_RESOLVED","name","schema","remove","vanishedSet","existingRows","filter","store","docs","byPath","addedSet","reparsedExisting","staleRows","cold","resolveNew","resolvedLink","appendable","upsertRows","targets","targetBase","d","extracted","some","t","appendRows","afterReconcile","removeHadLinks","large","dstChanged","linksChanged"],"mappings":"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"}

package/dist/cjs/store/builder.js

@@ -323,9 +323,8 @@ function invalidateFeatureTable(conn, cfg, baseDir, dialect, pool, toggle) {
                     paths = docs.map(function(d) {
                         return d.relPath;
                     });
-                    // Every path counts as added, not just touched: the table was just dropped, so there is nothing
-                    // stale to diff against, and links' own afterReconcile takes its cold-build (resolveAll) path
-                    // only when added.length equals files.length.
+                    // Every path counts as added, not just touched: nothing stale to diff against. Links resolves
+                    // dst inside store() itself when added.length equals files.length (a cold build).
                     delta = {
                         files: files,
                         reparsed: paths,

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

@@ -1 +1 @@
-{"version":3,"sources":["/Users/kevin/Dev/OpenSource/ai/sensemaking/src/store/builder.ts"],"sourcesContent":["import type { Config } from '../config/index.ts';\nimport { embed } from '../features/embed.ts';\nimport { FEATURES } from '../features/index.ts';\nimport { rank } from '../features/rank.ts';\nimport type { ReconcileDelta } from '../features/types.ts';\nimport { listFiles } from '../scan/index.ts';\nimport { ParsePool } from '../scan/pool.ts';\nimport { reparseFiles } from '../scan/reparse.ts';\nimport type { EmbedChangeKind } from './embed-scope.ts';\nimport type { FeatureToggle } from './feature-scope.ts';\nimport { NARROW_FEATURE_TABLE } from './feature-scope.ts';\nimport { reconcile } from './reconcile.ts';\nimport { getColumns } from './shared.ts';\nimport type { Stages } from './stages.ts';\nimport { withTransaction } from './transaction.ts';\nimport type { Connection, ReconcileDialect } from './types.ts';\n\n// Owns bringing a store's index current: the write half `Store` (types.ts) deliberately does not\n// carry. A one-shot open calls build() once; a watcher calls it repeatedly on the same instance.\nexport interface Builder {\n  // forcedPaths (open.ts's preset-only narrow rebuild) applies to this call alone, not future ones.\n  build(forcedPaths?: ReadonlySet<string>): Promise<{ parsed: number; warnings: string[]; stages: Stages }>;\n  // Narrow embed invalidation (open.ts, embed-scope.ts's classifyEmbedChange): 'model' nulls every\n  // vector/scale in place; 'chunk' rebuilds every embedding row. Neither touches another table.\n  invalidate(kind: EmbedChangeKind): Promise<{ parsed: number }>;\n  // Narrow feature-toggle invalidation (open.ts, feature-scope.ts's classifyFeatureToggles): a\n  // toggle drops (or, turning back on, fully re-derives) that feature's own table; rank instead\n  // nulls or recomputes its `_rank` column, since rows written while a feature was off are\n  // untrustworthy (reconcile.ts's activeFeatures skips a disabled feature's hooks entirely).\n  invalidateFeatures(toggles: FeatureToggle[]): Promise<{ parsed: number }>;\n  // Releases the parse worker pool, if this lifetime ever created one; never the connection.\n  close(): Promise<void>;\n  // Pools this lifetime has constructed, so reuse is observable rather than inferred.\n  readonly poolsCreated: number;\n}\n\n// 'model': the provider or model name moved but chunk boundaries did not, so only the vector\n// values are stale. No reparse, and no table but embeddings is touched.\nasync function nullEmbedVectors(conn: Connection, dialect: ReconcileDialect): Promise<{ parsed: number }> {\n  await withTransaction(conn, () => conn.exec('UPDATE embeddings SET vector = NULL, scale = NULL'), dialect.beginMode());\n  return { parsed: 0 };\n}\n\n// 'chunk': chunkTokens or the chunk version moved, so chunk boundaries genuinely changed. Rebuilds\n// every embedding row through the embed feature's own remove/store, touching no other table.\nasync function rebuildEmbeddings(conn: Connection, cfg: Config, baseDir: string, dialect: ReconcileDialect, pool: ParsePool): Promise<{ parsed: number }> {\n  const existingStmt = await conn.prepare('SELECT \"path\" FROM frontmatter');\n  const existingPaths = new Set((await existingStmt.all()).map((r) => (r as { path: string }).path));\n  // A file added since the last build has no row yet; leaving it for build() to insert avoids a\n  // primary-key collision between this INSERT and build()'s own insert for the same new file.\n  const files = listFiles(cfg, baseDir).filter((f) => f.embed && existingPaths.has(f.relPath));\n  if (files.length === 0) return { parsed: 0 };\n\n  const { docs } = await reparseFiles(files, [embed], cfg, new Set(), undefined, { pool });\n  const paths = docs.map((d) => d.relPath);\n  const delta: ReconcileDelta = { files, reparsed: paths, added: [], vanished: [] };\n  await withTransaction(\n    conn,\n    async () => {\n      await embed.remove?.(conn, paths, delta);\n      await embed.store?.(\n        conn,\n        docs.map((d) => ({ path: d.relPath, extracted: d.extracted.embed })),\n        delta\n      );\n    },\n    dialect.beginMode()\n  );\n  return { parsed: docs.length };\n}\n\n// One feature's own table, dropped and (turning on) fully re-derived across every indexed file.\n// Rows left over from before this feature was disabled are untrustworthy by construction (files\n// added, edited, or deleted got no remove/store for it), so this never diffs against them --\n// dropping every row and reparsing the whole tree is the only safe path back to consistent state.\nasync function invalidateFeatureTable(conn: Connection, cfg: Config, baseDir: string, dialect: ReconcileDialect, pool: ParsePool, toggle: FeatureToggle): Promise<{ parsed: number }> {\n  const table = NARROW_FEATURE_TABLE[toggle.name];\n  const feature = FEATURES.find((f) => f.name === toggle.name);\n  if (!feature) throw new Error(`invalidateFeatureTable: no registered feature named \"${toggle.name}\"`);\n\n  if (!toggle.turnedOn) {\n    await withTransaction(conn, () => conn.exec(`DELETE FROM ${table}`), dialect.beginMode());\n    return { parsed: 0 };\n  }\n\n  const files = listFiles(cfg, baseDir);\n  const { docs } = await reparseFiles(files, [feature], cfg, new Set(), undefined, { pool });\n  const docsForFeature = docs.map((d) => ({ path: d.relPath, extracted: d.extracted[feature.name] }));\n  const paths = docs.map((d) => d.relPath);\n  // Every path counts as added, not just touched: the table was just dropped, so there is nothing\n  // stale to diff against, and links' own afterReconcile takes its cold-build (resolveAll) path\n  // only when added.length equals files.length.\n  const delta: ReconcileDelta = { files, reparsed: paths, added: paths, vanished: [] };\n  await withTransaction(\n    conn,\n    async () => {\n      await conn.exec(`DELETE FROM ${table}`);\n      await feature.store?.(conn, docsForFeature, delta);\n      await feature.afterReconcile?.(conn, delta);\n    },\n    dialect.beginMode()\n  );\n  return { parsed: docs.length };\n}\n\n// rank has no table of its own: frontmatter._rank is the only state it owns. Guarded on column\n// presence, since links can toggle off while rank has never been enabled for this tree.\nasync function nullRank(conn: Connection, dialect: ReconcileDialect): Promise<void> {\n  const columns = await getColumns(conn);\n  if (!columns.has('_rank')) return;\n  await withTransaction(conn, () => conn.exec('UPDATE frontmatter SET \"_rank\" = NULL'), dialect.beginMode());\n}\n\n// Whole-tree and reparse-free: PageRank is computed from the links table, not from files, so\n// turning rank back on needs no reparseFiles pass at all.\nasync function rerunRank(conn: Connection, dialect: ReconcileDialect): Promise<void> {\n  const delta: ReconcileDelta = { files: [], reparsed: [], added: [], vanished: [] };\n  await withTransaction(\n    conn,\n    async () => {\n      await rank.afterReconcile?.(conn, delta);\n    },\n    dialect.beginMode()\n  );\n}\n\nasync function invalidateFeatureToggles(conn: Connection, cfg: Config, baseDir: string, dialect: ReconcileDialect, pool: ParsePool, toggles: FeatureToggle[]): Promise<{ parsed: number }> {\n  const byName = new Map(toggles.map((toggle) => [toggle.name, toggle]));\n  let parsed = 0;\n\n  // links first, if present: rank's rerun below (whether from its own toggle or the co-change\n  // rankToggle carries) must read the links table after it is back in its new state.\n  const linksToggle = byName.get('links');\n  if (linksToggle) {\n    parsed += (await invalidateFeatureTable(conn, cfg, baseDir, dialect, pool, linksToggle)).parsed;\n    // Unconditional, per rank's dependency on links: nulling is a no-op (guarded) when rank was\n    // never enabled for this tree, so this is safe even when no feature:rank segment changed.\n    if (!linksToggle.turnedOn) await nullRank(conn, dialect);\n  }\n\n  // rank's effective on/off (featureEnabled's links dependency) only appears as a changed\n  // `feature:rank` segment when it actually flips -- whether that's rank's own config or a\n  // links toggle taking it along -- so honoring it here is complete on its own.\n  const rankToggle = byName.get('rank');\n  if (rankToggle) {\n    if (rankToggle.turnedOn) await rerunRank(conn, dialect);\n    else await nullRank(conn, dialect);\n  }\n\n  for (const toggle of toggles) {\n    if (toggle.name === 'links' || toggle.name === 'rank') continue;\n    parsed += (await invalidateFeatureTable(conn, cfg, baseDir, dialect, pool, toggle)).parsed;\n  }\n  return { parsed };\n}\n\n// The pool is created at most once, lazily, on whichever build() or invalidate() call first\n// needs it, and reused by every later call on this instance.\nexport function createBuilder(conn: Connection, cfg: Config, baseDir: string, dialect: ReconcileDialect): Builder {\n  const pool = new ParsePool();\n  return {\n    build: (forcedPaths) => reconcile(conn, cfg, baseDir, dialect, pool, forcedPaths),\n    invalidate: (kind) => (kind === 'model' ? nullEmbedVectors(conn, dialect) : rebuildEmbeddings(conn, cfg, baseDir, dialect, pool)),\n    invalidateFeatures: (toggles) => invalidateFeatureToggles(conn, cfg, baseDir, dialect, pool, toggles),\n    close: () => pool.close(),\n    get poolsCreated() {\n      return pool.poolsCreated;\n    },\n  };\n}\n"],"names":["createBuilder","nullEmbedVectors","conn","dialect","withTransaction","exec","beginMode","parsed","rebuildEmbeddings","cfg","baseDir","pool","existingStmt","existingPaths","files","docs","paths","delta","prepare","Set","all","map","r","path","listFiles","filter","f","embed","has","relPath","length","reparseFiles","undefined","d","reparsed","added","vanished","remove","store","extracted","invalidateFeatureTable","toggle","table","feature","docsForFeature","NARROW_FEATURE_TABLE","name","FEATURES","find","Error","turnedOn","afterReconcile","nullRank","columns","getColumns","rerunRank","rank","invalidateFeatureToggles","toggles","byName","linksToggle","rankToggle","Map","get","ParsePool","build","forcedPaths","reconcile","invalidate","kind","invalidateFeatures","close","poolsCreated"],"mappings":"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"}
+{"version":3,"sources":["/Users/kevin/Dev/OpenSource/ai/sensemaking/src/store/builder.ts"],"sourcesContent":["import type { Config } from '../config/index.ts';\nimport { embed } from '../features/embed.ts';\nimport { FEATURES } from '../features/index.ts';\nimport { rank } from '../features/rank.ts';\nimport type { ReconcileDelta } from '../features/types.ts';\nimport { listFiles } from '../scan/index.ts';\nimport { ParsePool } from '../scan/pool.ts';\nimport { reparseFiles } from '../scan/reparse.ts';\nimport type { EmbedChangeKind } from './embed-scope.ts';\nimport type { FeatureToggle } from './feature-scope.ts';\nimport { NARROW_FEATURE_TABLE } from './feature-scope.ts';\nimport { reconcile } from './reconcile.ts';\nimport { getColumns } from './shared.ts';\nimport type { Stages } from './stages.ts';\nimport { withTransaction } from './transaction.ts';\nimport type { Connection, ReconcileDialect } from './types.ts';\n\n// Owns bringing a store's index current: the write half `Store` (types.ts) deliberately does not\n// carry. A one-shot open calls build() once; a watcher calls it repeatedly on the same instance.\nexport interface Builder {\n  // forcedPaths (open.ts's preset-only narrow rebuild) applies to this call alone, not future ones.\n  build(forcedPaths?: ReadonlySet<string>): Promise<{ parsed: number; warnings: string[]; stages: Stages }>;\n  // Narrow embed invalidation (open.ts, embed-scope.ts's classifyEmbedChange): 'model' nulls every\n  // vector/scale in place; 'chunk' rebuilds every embedding row. Neither touches another table.\n  invalidate(kind: EmbedChangeKind): Promise<{ parsed: number }>;\n  // Narrow feature-toggle invalidation (open.ts, feature-scope.ts's classifyFeatureToggles): a\n  // toggle drops (or, turning back on, fully re-derives) that feature's own table; rank instead\n  // nulls or recomputes its `_rank` column, since rows written while a feature was off are\n  // untrustworthy (reconcile.ts's activeFeatures skips a disabled feature's hooks entirely).\n  invalidateFeatures(toggles: FeatureToggle[]): Promise<{ parsed: number }>;\n  // Releases the parse worker pool, if this lifetime ever created one; never the connection.\n  close(): Promise<void>;\n  // Pools this lifetime has constructed, so reuse is observable rather than inferred.\n  readonly poolsCreated: number;\n}\n\n// 'model': the provider or model name moved but chunk boundaries did not, so only the vector\n// values are stale. No reparse, and no table but embeddings is touched.\nasync function nullEmbedVectors(conn: Connection, dialect: ReconcileDialect): Promise<{ parsed: number }> {\n  await withTransaction(conn, () => conn.exec('UPDATE embeddings SET vector = NULL, scale = NULL'), dialect.beginMode());\n  return { parsed: 0 };\n}\n\n// 'chunk': chunkTokens or the chunk version moved, so chunk boundaries genuinely changed. Rebuilds\n// every embedding row through the embed feature's own remove/store, touching no other table.\nasync function rebuildEmbeddings(conn: Connection, cfg: Config, baseDir: string, dialect: ReconcileDialect, pool: ParsePool): Promise<{ parsed: number }> {\n  const existingStmt = await conn.prepare('SELECT \"path\" FROM frontmatter');\n  const existingPaths = new Set((await existingStmt.all()).map((r) => (r as { path: string }).path));\n  // A file added since the last build has no row yet; leaving it for build() to insert avoids a\n  // primary-key collision between this INSERT and build()'s own insert for the same new file.\n  const files = listFiles(cfg, baseDir).filter((f) => f.embed && existingPaths.has(f.relPath));\n  if (files.length === 0) return { parsed: 0 };\n\n  const { docs } = await reparseFiles(files, [embed], cfg, new Set(), undefined, { pool });\n  const paths = docs.map((d) => d.relPath);\n  const delta: ReconcileDelta = { files, reparsed: paths, added: [], vanished: [] };\n  await withTransaction(\n    conn,\n    async () => {\n      await embed.remove?.(conn, paths, delta);\n      await embed.store?.(\n        conn,\n        docs.map((d) => ({ path: d.relPath, extracted: d.extracted.embed })),\n        delta\n      );\n    },\n    dialect.beginMode()\n  );\n  return { parsed: docs.length };\n}\n\n// One feature's own table, dropped and (turning on) fully re-derived across every indexed file.\n// Rows left over from before this feature was disabled are untrustworthy by construction (files\n// added, edited, or deleted got no remove/store for it), so this never diffs against them --\n// dropping every row and reparsing the whole tree is the only safe path back to consistent state.\nasync function invalidateFeatureTable(conn: Connection, cfg: Config, baseDir: string, dialect: ReconcileDialect, pool: ParsePool, toggle: FeatureToggle): Promise<{ parsed: number }> {\n  const table = NARROW_FEATURE_TABLE[toggle.name];\n  const feature = FEATURES.find((f) => f.name === toggle.name);\n  if (!feature) throw new Error(`invalidateFeatureTable: no registered feature named \"${toggle.name}\"`);\n\n  if (!toggle.turnedOn) {\n    await withTransaction(conn, () => conn.exec(`DELETE FROM ${table}`), dialect.beginMode());\n    return { parsed: 0 };\n  }\n\n  const files = listFiles(cfg, baseDir);\n  const { docs } = await reparseFiles(files, [feature], cfg, new Set(), undefined, { pool });\n  const docsForFeature = docs.map((d) => ({ path: d.relPath, extracted: d.extracted[feature.name] }));\n  const paths = docs.map((d) => d.relPath);\n  // Every path counts as added, not just touched: nothing stale to diff against. Links resolves\n  // dst inside store() itself when added.length equals files.length (a cold build).\n  const delta: ReconcileDelta = { files, reparsed: paths, added: paths, vanished: [] };\n  await withTransaction(\n    conn,\n    async () => {\n      await conn.exec(`DELETE FROM ${table}`);\n      await feature.store?.(conn, docsForFeature, delta);\n      await feature.afterReconcile?.(conn, delta);\n    },\n    dialect.beginMode()\n  );\n  return { parsed: docs.length };\n}\n\n// rank has no table of its own: frontmatter._rank is the only state it owns. Guarded on column\n// presence, since links can toggle off while rank has never been enabled for this tree.\nasync function nullRank(conn: Connection, dialect: ReconcileDialect): Promise<void> {\n  const columns = await getColumns(conn);\n  if (!columns.has('_rank')) return;\n  await withTransaction(conn, () => conn.exec('UPDATE frontmatter SET \"_rank\" = NULL'), dialect.beginMode());\n}\n\n// Whole-tree and reparse-free: PageRank is computed from the links table, not from files, so\n// turning rank back on needs no reparseFiles pass at all.\nasync function rerunRank(conn: Connection, dialect: ReconcileDialect): Promise<void> {\n  const delta: ReconcileDelta = { files: [], reparsed: [], added: [], vanished: [] };\n  await withTransaction(\n    conn,\n    async () => {\n      await rank.afterReconcile?.(conn, delta);\n    },\n    dialect.beginMode()\n  );\n}\n\nasync function invalidateFeatureToggles(conn: Connection, cfg: Config, baseDir: string, dialect: ReconcileDialect, pool: ParsePool, toggles: FeatureToggle[]): Promise<{ parsed: number }> {\n  const byName = new Map(toggles.map((toggle) => [toggle.name, toggle]));\n  let parsed = 0;\n\n  // links first, if present: rank's rerun below (whether from its own toggle or the co-change\n  // rankToggle carries) must read the links table after it is back in its new state.\n  const linksToggle = byName.get('links');\n  if (linksToggle) {\n    parsed += (await invalidateFeatureTable(conn, cfg, baseDir, dialect, pool, linksToggle)).parsed;\n    // Unconditional, per rank's dependency on links: nulling is a no-op (guarded) when rank was\n    // never enabled for this tree, so this is safe even when no feature:rank segment changed.\n    if (!linksToggle.turnedOn) await nullRank(conn, dialect);\n  }\n\n  // rank's effective on/off (featureEnabled's links dependency) only appears as a changed\n  // `feature:rank` segment when it actually flips -- whether that's rank's own config or a\n  // links toggle taking it along -- so honoring it here is complete on its own.\n  const rankToggle = byName.get('rank');\n  if (rankToggle) {\n    if (rankToggle.turnedOn) await rerunRank(conn, dialect);\n    else await nullRank(conn, dialect);\n  }\n\n  for (const toggle of toggles) {\n    if (toggle.name === 'links' || toggle.name === 'rank') continue;\n    parsed += (await invalidateFeatureTable(conn, cfg, baseDir, dialect, pool, toggle)).parsed;\n  }\n  return { parsed };\n}\n\n// The pool is created at most once, lazily, on whichever build() or invalidate() call first\n// needs it, and reused by every later call on this instance.\nexport function createBuilder(conn: Connection, cfg: Config, baseDir: string, dialect: ReconcileDialect): Builder {\n  const pool = new ParsePool();\n  return {\n    build: (forcedPaths) => reconcile(conn, cfg, baseDir, dialect, pool, forcedPaths),\n    invalidate: (kind) => (kind === 'model' ? nullEmbedVectors(conn, dialect) : rebuildEmbeddings(conn, cfg, baseDir, dialect, pool)),\n    invalidateFeatures: (toggles) => invalidateFeatureToggles(conn, cfg, baseDir, dialect, pool, toggles),\n    close: () => pool.close(),\n    get poolsCreated() {\n      return pool.poolsCreated;\n    },\n  };\n}\n"],"names":["createBuilder","nullEmbedVectors","conn","dialect","withTransaction","exec","beginMode","parsed","rebuildEmbeddings","cfg","baseDir","pool","existingStmt","existingPaths","files","docs","paths","delta","prepare","Set","all","map","r","path","listFiles","filter","f","embed","has","relPath","length","reparseFiles","undefined","d","reparsed","added","vanished","remove","store","extracted","invalidateFeatureTable","toggle","table","feature","docsForFeature","NARROW_FEATURE_TABLE","name","FEATURES","find","Error","turnedOn","afterReconcile","nullRank","columns","getColumns","rerunRank","rank","invalidateFeatureToggles","toggles","byName","linksToggle","rankToggle","Map","get","ParsePool","build","forcedPaths","reconcile","invalidate","kind","invalidateFeatures","close","poolsCreated"],"mappings":"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"}

package/dist/cjs/store/turso/connection.d.cts

@@ -1,3 +1,4 @@
 import type { Database } from '@tursodatabase/database';
 import type { Connection } from '../types.js';
+export declare function checkpointWal(db: Database): Promise<void>;
 export declare function createConnection(db: Database): Connection;

package/dist/cjs/store/turso/connection.d.ts

@@ -1,3 +1,4 @@
 import type { Database } from '@tursodatabase/database';
 import type { Connection } from '../types.js';
+export declare function checkpointWal(db: Database): Promise<void>;
 export declare function createConnection(db: Database): Connection;