sensemaking 0.17.0 → 0.18.0

package/dist/esm/features/rank.js.map

@@ -1 +1 @@
-{"version":3,"sources":["/Users/kevin/Dev/OpenSource/ai/sensemaking/src/features/rank.ts"],"sourcesContent":["import { pagerank } from '../graph/graph.ts';\nimport { linkEdges } from './links.ts';\nimport type { Feature } from './types.ts';\n\n// frontmatter._rank: PageRank over resolved links -- a static \"how load-bearing is this\n// note\" prior. Depends on links (enforced in config.featureEnabled).\n\nexport const rank: Feature = {\n  name: 'rank',\n  schema(db) {\n    const columns = db.prepare('PRAGMA table_info(frontmatter)').all() as Array<{ name: string }>;\n    if (!columns.some((c) => c.name === '_rank')) db.exec('ALTER TABLE frontmatter ADD COLUMN \"_rank\" REAL');\n  },\n  afterReconcile(db, delta) {\n    // Only an explicit linksChanged:false skips. Rank also depends on the node set, so any\n    // add or vanish recomputes -- otherwise a new linkless note keeps _rank NULL.\n    if (delta.linksChanged === false && delta.added.length === 0 && delta.vanished.length === 0) return;\n    const nodes = (db.prepare('SELECT \"path\" FROM frontmatter').all() as Array<{ path: string }>).map((r) => r.path);\n    const ranks = pagerank(nodes, linkEdges(db));\n    const update = db.prepare('UPDATE frontmatter SET \"_rank\" = ? WHERE \"path\" = ?');\n    for (const [path, value] of ranks) update.run(value, path);\n  },\n};\n"],"names":["pagerank","linkEdges","rank","name","schema","db","columns","prepare","all","some","c","exec","afterReconcile","delta","linksChanged","added","length","vanished","nodes","map","r","path","ranks","update","value","run"],"mappings":"AAAA,SAASA,QAAQ,QAAQ,oBAAoB;AAC7C,SAASC,SAAS,QAAQ,aAAa;AAGvC,wFAAwF;AACxF,qEAAqE;AAErE,OAAO,MAAMC,OAAgB;IAC3BC,MAAM;IACNC,QAAOC,EAAE;QACP,MAAMC,UAAUD,GAAGE,OAAO,CAAC,kCAAkCC,GAAG;QAChE,IAAI,CAACF,QAAQG,IAAI,CAAC,CAACC,IAAMA,EAAEP,IAAI,KAAK,UAAUE,GAAGM,IAAI,CAAC;IACxD;IACAC,gBAAeP,EAAE,EAAEQ,KAAK;QACtB,uFAAuF;QACvF,8EAA8E;QAC9E,IAAIA,MAAMC,YAAY,KAAK,SAASD,MAAME,KAAK,CAACC,MAAM,KAAK,KAAKH,MAAMI,QAAQ,CAACD,MAAM,KAAK,GAAG;QAC7F,MAAME,QAAQ,AAACb,GAAGE,OAAO,CAAC,kCAAkCC,GAAG,GAA+BW,GAAG,CAAC,CAACC,IAAMA,EAAEC,IAAI;QAC/G,MAAMC,QAAQtB,SAASkB,OAAOjB,UAAUI;QACxC,MAAMkB,SAASlB,GAAGE,OAAO,CAAC;QAC1B,KAAK,MAAM,CAACc,MAAMG,MAAM,IAAIF,MAAOC,OAAOE,GAAG,CAACD,OAAOH;IACvD;AACF,EAAE"}
+{"version":3,"sources":["/Users/kevin/Dev/OpenSource/ai/sensemaking/src/features/rank.ts"],"sourcesContent":["import { pagerank } from '../graph/graph.ts';\nimport { linkEdges } from './links.ts';\nimport type { Feature } from './types.ts';\n\n// frontmatter._rank: PageRank over resolved links -- a static \"how load-bearing is this\n// note\" prior. Depends on links (enforced in config.featureEnabled).\n\nexport const rank: Feature = {\n  name: 'rank',\n  async schema(db) {\n    const stmt = await db.prepare('PRAGMA table_info(frontmatter)');\n    const columns = (await stmt.all()) as Array<{ name: string }>;\n    if (!columns.some((c) => c.name === '_rank')) await db.exec('ALTER TABLE frontmatter ADD COLUMN \"_rank\" REAL');\n  },\n  async afterReconcile(db, delta) {\n    // Only an explicit linksChanged:false skips. Rank also depends on the node set, so any\n    // add or vanish recomputes -- otherwise a new linkless note keeps _rank NULL.\n    if (delta.linksChanged === false && delta.added.length === 0 && delta.vanished.length === 0) return;\n    const pathsStmt = await db.prepare('SELECT \"path\" FROM frontmatter');\n    const nodes = ((await pathsStmt.all()) as Array<{ path: string }>).map((r) => r.path);\n    const ranks = pagerank(nodes, await linkEdges(db));\n    if (ranks.size === 0) return;\n    await db.runBatch(\n      'UPDATE frontmatter SET \"_rank\" = ? WHERE \"path\" = ?',\n      [...ranks].map(([path, value]) => [value, path])\n    );\n  },\n};\n"],"names":["pagerank","linkEdges","rank","name","schema","db","stmt","prepare","columns","all","some","c","exec","afterReconcile","delta","linksChanged","added","length","vanished","pathsStmt","nodes","map","r","path","ranks","size","runBatch","value"],"mappings":"AAAA,SAASA,QAAQ,QAAQ,oBAAoB;AAC7C,SAASC,SAAS,QAAQ,aAAa;AAGvC,wFAAwF;AACxF,qEAAqE;AAErE,OAAO,MAAMC,OAAgB;IAC3BC,MAAM;IACN,MAAMC,QAAOC,EAAE;QACb,MAAMC,OAAO,MAAMD,GAAGE,OAAO,CAAC;QAC9B,MAAMC,UAAW,MAAMF,KAAKG,GAAG;QAC/B,IAAI,CAACD,QAAQE,IAAI,CAAC,CAACC,IAAMA,EAAER,IAAI,KAAK,UAAU,MAAME,GAAGO,IAAI,CAAC;IAC9D;IACA,MAAMC,gBAAeR,EAAE,EAAES,KAAK;QAC5B,uFAAuF;QACvF,8EAA8E;QAC9E,IAAIA,MAAMC,YAAY,KAAK,SAASD,MAAME,KAAK,CAACC,MAAM,KAAK,KAAKH,MAAMI,QAAQ,CAACD,MAAM,KAAK,GAAG;QAC7F,MAAME,YAAY,MAAMd,GAAGE,OAAO,CAAC;QACnC,MAAMa,QAAQ,AAAE,CAAA,MAAMD,UAAUV,GAAG,EAAC,EAA+BY,GAAG,CAAC,CAACC,IAAMA,EAAEC,IAAI;QACpF,MAAMC,QAAQxB,SAASoB,OAAO,MAAMnB,UAAUI;QAC9C,IAAImB,MAAMC,IAAI,KAAK,GAAG;QACtB,MAAMpB,GAAGqB,QAAQ,CACf,uDACA;eAAIF;SAAM,CAACH,GAAG,CAAC,CAAC,CAACE,MAAMI,MAAM,GAAK;gBAACA;gBAAOJ;aAAK;IAEnD;AACF,EAAE"}

package/dist/esm/features/sections.js

@@ -26,15 +26,28 @@ function extract(raw) {
 }
 export const sections = {
     name: 'sections',
-    schema (db) {
-        db.exec(`CREATE TABLE IF NOT EXISTS sections ("path" TEXT, idx INTEGER, level INTEGER, heading TEXT, start_line INTEGER, end_line INTEGER, tokens INTEGER, PRIMARY KEY ("path", idx))`);
+    async schema (db) {
+        await db.exec(`CREATE TABLE IF NOT EXISTS sections ("path" TEXT, idx INTEGER, level INTEGER, heading TEXT, start_line INTEGER, end_line INTEGER, tokens INTEGER, PRIMARY KEY ("path", idx))`);
     },
     extract,
-    remove (db, path) {
-        db.prepare('DELETE FROM sections WHERE "path" = ?').run(path);
+    async remove (db, paths) {
+        if (paths.length === 0) return;
+        await db.runBatch('DELETE FROM sections WHERE "path" = ?', paths.map((p)=>[
+                p
+            ]));
     },
-    store (db, path, extracted) {
-        const insert = db.prepare('INSERT INTO sections ("path", idx, level, heading, start_line, end_line, tokens) VALUES (?, ?, ?, ?, ?, ?, ?)');
-        extracted.forEach((s, idx)=>insert.run(path, idx, s.level, s.heading, s.startLine, s.endLine, s.tokens));
+    async store (db, docs) {
+        const rows = [];
+        for (const { path, extracted } of docs)extracted.forEach((s, idx)=>rows.push([
+                path,
+                idx,
+                s.level,
+                s.heading,
+                s.startLine,
+                s.endLine,
+                s.tokens
+            ]));
+        if (rows.length === 0) return;
+        await db.runBatch('INSERT INTO sections ("path", idx, level, heading, start_line, end_line, tokens) VALUES (?, ?, ?, ?, ?, ?, ?)', rows);
     }
 };

package/dist/esm/features/sections.js.map

@@ -1 +1 @@
-{"version":3,"sources":["/Users/kevin/Dev/OpenSource/ai/sensemaking/src/features/sections.ts"],"sourcesContent":["import { estimateTokens } from '../chunk/index.ts';\nimport { fenceTracker } from './fences.ts';\nimport type { Feature } from './types.ts';\n\n// sections(path, idx, level, heading, start_line, end_line, tokens): the heading outline,\n// 1-indexed over the raw file so a row is a direct Read range; tokens is estimateTokens (D5),\n// CJK-aware rather than a flat chars/4.\n\nexport interface Section {\n  level: number;\n  heading: string;\n  startLine: number;\n  endLine: number;\n  tokens: number;\n}\n\n// Headings outside fenced code blocks.\nfunction extract(raw: string): Section[] {\n  const lines = raw.split('\\n');\n  const found: Section[] = [];\n  const fence = fenceTracker();\n  for (let i = 0; i < lines.length; i++) {\n    if (fence.feed(lines[i])) continue;\n    if (fence.inFence) continue;\n    const m = lines[i].match(/^(#{1,6}) +(.*)/);\n    if (m) found.push({ level: m[1].length, heading: m[2].trim(), startLine: i + 1, endLine: lines.length, tokens: 0 });\n  }\n  for (let s = 0; s < found.length; s++) {\n    if (s + 1 < found.length) found[s].endLine = found[s + 1].startLine - 1;\n    const text = lines.slice(found[s].startLine - 1, found[s].endLine).join('\\n');\n    found[s].tokens = Math.ceil(estimateTokens(text));\n  }\n  return found;\n}\n\nexport const sections: Feature = {\n  name: 'sections',\n  schema(db) {\n    db.exec(`CREATE TABLE IF NOT EXISTS sections (\"path\" TEXT, idx INTEGER, level INTEGER, heading TEXT, start_line INTEGER, end_line INTEGER, tokens INTEGER, PRIMARY KEY (\"path\", idx))`);\n  },\n  extract,\n  remove(db, path) {\n    db.prepare('DELETE FROM sections WHERE \"path\" = ?').run(path);\n  },\n  store(db, path, extracted) {\n    const insert = db.prepare('INSERT INTO sections (\"path\", idx, level, heading, start_line, end_line, tokens) VALUES (?, ?, ?, ?, ?, ?, ?)');\n    (extracted as Section[]).forEach((s, idx) => insert.run(path, idx, s.level, s.heading, s.startLine, s.endLine, s.tokens));\n  },\n};\n"],"names":["estimateTokens","fenceTracker","extract","raw","lines","split","found","fence","i","length","feed","inFence","m","match","push","level","heading","trim","startLine","endLine","tokens","s","text","slice","join","Math","ceil","sections","name","schema","db","exec","remove","path","prepare","run","store","extracted","insert","forEach","idx"],"mappings":"AAAA,SAASA,cAAc,QAAQ,oBAAoB;AACnD,SAASC,YAAY,QAAQ,cAAc;AAe3C,uCAAuC;AACvC,SAASC,QAAQC,GAAW;IAC1B,MAAMC,QAAQD,IAAIE,KAAK,CAAC;IACxB,MAAMC,QAAmB,EAAE;IAC3B,MAAMC,QAAQN;IACd,IAAK,IAAIO,IAAI,GAAGA,IAAIJ,MAAMK,MAAM,EAAED,IAAK;QACrC,IAAID,MAAMG,IAAI,CAACN,KAAK,CAACI,EAAE,GAAG;QAC1B,IAAID,MAAMI,OAAO,EAAE;QACnB,MAAMC,IAAIR,KAAK,CAACI,EAAE,CAACK,KAAK,CAAC;QACzB,IAAID,GAAGN,MAAMQ,IAAI,CAAC;YAAEC,OAAOH,CAAC,CAAC,EAAE,CAACH,MAAM;YAAEO,SAASJ,CAAC,CAAC,EAAE,CAACK,IAAI;YAAIC,WAAWV,IAAI;YAAGW,SAASf,MAAMK,MAAM;YAAEW,QAAQ;QAAE;IACnH;IACA,IAAK,IAAIC,IAAI,GAAGA,IAAIf,MAAMG,MAAM,EAAEY,IAAK;QACrC,IAAIA,IAAI,IAAIf,MAAMG,MAAM,EAAEH,KAAK,CAACe,EAAE,CAACF,OAAO,GAAGb,KAAK,CAACe,IAAI,EAAE,CAACH,SAAS,GAAG;QACtE,MAAMI,OAAOlB,MAAMmB,KAAK,CAACjB,KAAK,CAACe,EAAE,CAACH,SAAS,GAAG,GAAGZ,KAAK,CAACe,EAAE,CAACF,OAAO,EAAEK,IAAI,CAAC;QACxElB,KAAK,CAACe,EAAE,CAACD,MAAM,GAAGK,KAAKC,IAAI,CAAC1B,eAAesB;IAC7C;IACA,OAAOhB;AACT;AAEA,OAAO,MAAMqB,WAAoB;IAC/BC,MAAM;IACNC,QAAOC,EAAE;QACPA,GAAGC,IAAI,CAAC,CAAC,4KAA4K,CAAC;IACxL;IACA7B;IACA8B,QAAOF,EAAE,EAAEG,IAAI;QACbH,GAAGI,OAAO,CAAC,yCAAyCC,GAAG,CAACF;IAC1D;IACAG,OAAMN,EAAE,EAAEG,IAAI,EAAEI,SAAS;QACvB,MAAMC,SAASR,GAAGI,OAAO,CAAC;QACzBG,UAAwBE,OAAO,CAAC,CAAClB,GAAGmB,MAAQF,OAAOH,GAAG,CAACF,MAAMO,KAAKnB,EAAEN,KAAK,EAAEM,EAAEL,OAAO,EAAEK,EAAEH,SAAS,EAAEG,EAAEF,OAAO,EAAEE,EAAED,MAAM;IACzH;AACF,EAAE"}
+{"version":3,"sources":["/Users/kevin/Dev/OpenSource/ai/sensemaking/src/features/sections.ts"],"sourcesContent":["import { estimateTokens } from '../chunk/index.ts';\nimport { fenceTracker } from './fences.ts';\nimport type { Feature } from './types.ts';\n\n// sections(path, idx, level, heading, start_line, end_line, tokens): the heading outline,\n// 1-indexed over the raw file so a row is a direct Read range; tokens is estimateTokens (D5),\n// CJK-aware rather than a flat chars/4.\n\nexport interface Section {\n  level: number;\n  heading: string;\n  startLine: number;\n  endLine: number;\n  tokens: number;\n}\n\n// Headings outside fenced code blocks.\nfunction extract(raw: string): Section[] {\n  const lines = raw.split('\\n');\n  const found: Section[] = [];\n  const fence = fenceTracker();\n  for (let i = 0; i < lines.length; i++) {\n    if (fence.feed(lines[i])) continue;\n    if (fence.inFence) continue;\n    const m = lines[i].match(/^(#{1,6}) +(.*)/);\n    if (m) found.push({ level: m[1].length, heading: m[2].trim(), startLine: i + 1, endLine: lines.length, tokens: 0 });\n  }\n  for (let s = 0; s < found.length; s++) {\n    if (s + 1 < found.length) found[s].endLine = found[s + 1].startLine - 1;\n    const text = lines.slice(found[s].startLine - 1, found[s].endLine).join('\\n');\n    found[s].tokens = Math.ceil(estimateTokens(text));\n  }\n  return found;\n}\n\nexport const sections: Feature = {\n  name: 'sections',\n  async schema(db) {\n    await db.exec(`CREATE TABLE IF NOT EXISTS sections (\"path\" TEXT, idx INTEGER, level INTEGER, heading TEXT, start_line INTEGER, end_line INTEGER, tokens INTEGER, PRIMARY KEY (\"path\", idx))`);\n  },\n  extract,\n  async remove(db, paths) {\n    if (paths.length === 0) return;\n    await db.runBatch(\n      'DELETE FROM sections WHERE \"path\" = ?',\n      paths.map((p) => [p])\n    );\n  },\n  async store(db, docs) {\n    const rows: unknown[][] = [];\n    for (const { path, extracted } of docs) (extracted as Section[]).forEach((s, idx) => rows.push([path, idx, s.level, s.heading, s.startLine, s.endLine, s.tokens]));\n    if (rows.length === 0) return;\n    await db.runBatch('INSERT INTO sections (\"path\", idx, level, heading, start_line, end_line, tokens) VALUES (?, ?, ?, ?, ?, ?, ?)', rows);\n  },\n};\n"],"names":["estimateTokens","fenceTracker","extract","raw","lines","split","found","fence","i","length","feed","inFence","m","match","push","level","heading","trim","startLine","endLine","tokens","s","text","slice","join","Math","ceil","sections","name","schema","db","exec","remove","paths","runBatch","map","p","store","docs","rows","path","extracted","forEach","idx"],"mappings":"AAAA,SAASA,cAAc,QAAQ,oBAAoB;AACnD,SAASC,YAAY,QAAQ,cAAc;AAe3C,uCAAuC;AACvC,SAASC,QAAQC,GAAW;IAC1B,MAAMC,QAAQD,IAAIE,KAAK,CAAC;IACxB,MAAMC,QAAmB,EAAE;IAC3B,MAAMC,QAAQN;IACd,IAAK,IAAIO,IAAI,GAAGA,IAAIJ,MAAMK,MAAM,EAAED,IAAK;QACrC,IAAID,MAAMG,IAAI,CAACN,KAAK,CAACI,EAAE,GAAG;QAC1B,IAAID,MAAMI,OAAO,EAAE;QACnB,MAAMC,IAAIR,KAAK,CAACI,EAAE,CAACK,KAAK,CAAC;QACzB,IAAID,GAAGN,MAAMQ,IAAI,CAAC;YAAEC,OAAOH,CAAC,CAAC,EAAE,CAACH,MAAM;YAAEO,SAASJ,CAAC,CAAC,EAAE,CAACK,IAAI;YAAIC,WAAWV,IAAI;YAAGW,SAASf,MAAMK,MAAM;YAAEW,QAAQ;QAAE;IACnH;IACA,IAAK,IAAIC,IAAI,GAAGA,IAAIf,MAAMG,MAAM,EAAEY,IAAK;QACrC,IAAIA,IAAI,IAAIf,MAAMG,MAAM,EAAEH,KAAK,CAACe,EAAE,CAACF,OAAO,GAAGb,KAAK,CAACe,IAAI,EAAE,CAACH,SAAS,GAAG;QACtE,MAAMI,OAAOlB,MAAMmB,KAAK,CAACjB,KAAK,CAACe,EAAE,CAACH,SAAS,GAAG,GAAGZ,KAAK,CAACe,EAAE,CAACF,OAAO,EAAEK,IAAI,CAAC;QACxElB,KAAK,CAACe,EAAE,CAACD,MAAM,GAAGK,KAAKC,IAAI,CAAC1B,eAAesB;IAC7C;IACA,OAAOhB;AACT;AAEA,OAAO,MAAMqB,WAAoB;IAC/BC,MAAM;IACN,MAAMC,QAAOC,EAAE;QACb,MAAMA,GAAGC,IAAI,CAAC,CAAC,4KAA4K,CAAC;IAC9L;IACA7B;IACA,MAAM8B,QAAOF,EAAE,EAAEG,KAAK;QACpB,IAAIA,MAAMxB,MAAM,KAAK,GAAG;QACxB,MAAMqB,GAAGI,QAAQ,CACf,yCACAD,MAAME,GAAG,CAAC,CAACC,IAAM;gBAACA;aAAE;IAExB;IACA,MAAMC,OAAMP,EAAE,EAAEQ,IAAI;QAClB,MAAMC,OAAoB,EAAE;QAC5B,KAAK,MAAM,EAAEC,IAAI,EAAEC,SAAS,EAAE,IAAIH,KAAM,AAACG,UAAwBC,OAAO,CAAC,CAACrB,GAAGsB,MAAQJ,KAAKzB,IAAI,CAAC;gBAAC0B;gBAAMG;gBAAKtB,EAAEN,KAAK;gBAAEM,EAAEL,OAAO;gBAAEK,EAAEH,SAAS;gBAAEG,EAAEF,OAAO;gBAAEE,EAAED,MAAM;aAAC;QAChK,IAAImB,KAAK9B,MAAM,KAAK,GAAG;QACvB,MAAMqB,GAAGI,QAAQ,CAAC,iHAAiHK;IACrI;AACF,EAAE"}

package/dist/esm/features/tags.js

@@ -60,26 +60,27 @@ function extract(_raw, body, _search, data) {
 }
 export const tags = {
     name: 'tags',
-    schema (db) {
-        db.exec('CREATE TABLE IF NOT EXISTS tags ("path" TEXT, tag TEXT, PRIMARY KEY ("path", tag))');
-        db.exec('CREATE INDEX IF NOT EXISTS tags_tag ON tags(tag)');
+    async schema (db) {
+        await db.exec('CREATE TABLE IF NOT EXISTS tags ("path" TEXT, tag TEXT, PRIMARY KEY ("path", tag))');
+        await db.exec('CREATE INDEX IF NOT EXISTS tags_tag ON tags(tag)');
     },
     extract,
-    // Per-file rows with nothing else to resolve, so only a vanished file needs a delete here;
-    // store() below handles a reparse's stale rows itself.
-    remove (db, path, delta) {
-        if (!delta.vanished.includes(path)) return;
-        db.prepare('DELETE FROM tags WHERE "path" = ?').run(path);
+    // Blanket clear-then-reinsert (store() below always writes the full found list back), so
+    // remove() covers both a vanished file and a reparsed one that already had rows -- no
+    // per-file NOT IN diffing, which cannot be expressed as one statement shared across files.
+    async remove (db, paths) {
+        if (paths.length === 0) return;
+        await db.runBatch('DELETE FROM tags WHERE "path" = ?', paths.map((p)=>[
+                p
+            ]));
     },
-    store (db, path, extracted) {
-        const found = extracted;
-        if (found.length === 0) {
-            db.prepare('DELETE FROM tags WHERE "path" = ?').run(path);
-        } else {
-            const placeholders = found.map(()=>'?').join(', ');
-            db.prepare(`DELETE FROM tags WHERE "path" = ? AND tag NOT IN (${placeholders})`).run(path, ...found);
-        }
-        const insert = db.prepare('INSERT OR IGNORE INTO tags ("path", tag) VALUES (?, ?)');
-        for (const tag of found)insert.run(path, tag);
+    async store (db, docs) {
+        const rows = [];
+        for (const { path, extracted } of docs)for (const tag of extracted)rows.push([
+            path,
+            tag
+        ]);
+        if (rows.length === 0) return;
+        await db.runBatch('INSERT OR IGNORE INTO tags ("path", tag) VALUES (?, ?)', rows);
     }
 };

package/dist/esm/features/tags.js.map

@@ -1 +1 @@
-{"version":3,"sources":["/Users/kevin/Dev/OpenSource/ai/sensemaking/src/features/tags.ts"],"sourcesContent":["import { maskRegions } from './fences.ts';\nimport type { Feature } from './types.ts';\n\n// tags(path, tag): Obsidian's file.tags grain -- frontmatter list/string tags plus inline\n// #tags from the prose, deduplicated, source not distinguished. Nested tags store full\n// (book/scifi); `tag = 'book' OR tag LIKE 'book/%'` is how a caller matches the parent too.\n\n// Obsidian treats [[#Heading]] as a same-note link, not a tag.\nconst WIKILINK_RE = /\\[\\[.*?\\]\\]/g; // to the first ]], so a heading holding a lone ] still masks\n// Obsidian doesn't read tags inside HTML markup.\nconst HTML_TAG_RE = /<\\/?[a-zA-Z][^>]*>/g; // tag-shaped only: a comparison's `< 5` must not open a span\n// Anchors on start-of-line or a preceding whitespace/(/[ so `a#b` and URL fragments don't count.\nconst INLINE_TAG_RE = /(?:^|[\\s([])#([\\p{L}\\p{N}_/-]+)/gu;\n// A markdown link destination `](...)` -- `[text](#anchor)` is a same-page link, not a tag.\nconst LINK_DEST_RE = /\\]\\((?:[^()]|\\([^()]*\\))*\\)/g; // one paren-nesting level, as CommonMark destinations allow: (https://x/a_(b)#frag)\n\n// Strips a leading # (frontmatter entries may carry one) and a trailing /; rejects an\n// all-digit result -- a tag needs at least one non-digit character.\nfunction normalizeTag(raw: string): string | null {\n  const stripped = raw.replace(/^#/, '').replace(/\\/+$/, '');\n  if (!stripped || /^\\d+$/.test(stripped)) return null;\n  return stripped;\n}\n\n// data.tags: a YAML list (Obsidian also accepts a bare string). Null members and non-string\n// members are skipped rather than throwing -- `tags:\\n  -` parses to [null].\nfunction frontmatterTags(data?: Record<string, unknown>): string[] {\n  const raw = data?.tags;\n  const list = Array.isArray(raw) ? raw : typeof raw === 'string' ? [raw] : [];\n  const found: string[] = [];\n  for (const item of list) {\n    if (typeof item !== 'string') continue;\n    const tag = normalizeTag(item);\n    if (tag) found.push(tag);\n  }\n  return found;\n}\n\n// #tag tokens outside fenced code blocks, inline code spans, wikilinks, HTML tags, HTML blocks,\n// <!-- --> comments, and link destinations. maskRegions() handles all of those region-level\n// concerns (and code spans, masked once there); this loop only does per-line tag extraction.\nfunction inlineTags(body: string): string[] {\n  const found: string[] = [];\n  for (const line of maskRegions(body).split('\\n')) {\n    if (!line.includes('#')) continue; // most lines; skip the regex work\n    let cleaned = line;\n    if (cleaned.includes('[[')) cleaned = cleaned.replace(WIKILINK_RE, (m) => ' '.repeat(m.length));\n    if (cleaned.includes('](')) cleaned = cleaned.replace(LINK_DEST_RE, (m) => ' '.repeat(m.length));\n    if (cleaned.includes('<')) cleaned = cleaned.replace(HTML_TAG_RE, (m) => ' '.repeat(m.length));\n    for (const m of cleaned.matchAll(INLINE_TAG_RE)) {\n      const tag = normalizeTag(m[1]);\n      if (tag) found.push(tag);\n    }\n  }\n  return found;\n}\n\nfunction extract(_raw: string, body: string, _search?: { title: string; summary: string }, data?: Record<string, unknown>): string[] {\n  return [...new Set([...frontmatterTags(data), ...inlineTags(body)])].sort();\n}\n\nexport const tags: Feature = {\n  name: 'tags',\n  schema(db) {\n    db.exec('CREATE TABLE IF NOT EXISTS tags (\"path\" TEXT, tag TEXT, PRIMARY KEY (\"path\", tag))');\n    db.exec('CREATE INDEX IF NOT EXISTS tags_tag ON tags(tag)');\n  },\n  extract,\n  // Per-file rows with nothing else to resolve, so only a vanished file needs a delete here;\n  // store() below handles a reparse's stale rows itself.\n  remove(db, path, delta) {\n    if (!delta.vanished.includes(path)) return;\n    db.prepare('DELETE FROM tags WHERE \"path\" = ?').run(path);\n  },\n  store(db, path, extracted) {\n    const found = extracted as string[];\n    if (found.length === 0) {\n      db.prepare('DELETE FROM tags WHERE \"path\" = ?').run(path);\n    } else {\n      const placeholders = found.map(() => '?').join(', ');\n      db.prepare(`DELETE FROM tags WHERE \"path\" = ? AND tag NOT IN (${placeholders})`).run(path, ...found);\n    }\n    const insert = db.prepare('INSERT OR IGNORE INTO tags (\"path\", tag) VALUES (?, ?)');\n    for (const tag of found) insert.run(path, tag);\n  },\n};\n"],"names":["maskRegions","WIKILINK_RE","HTML_TAG_RE","INLINE_TAG_RE","LINK_DEST_RE","normalizeTag","raw","stripped","replace","test","frontmatterTags","data","tags","list","Array","isArray","found","item","tag","push","inlineTags","body","line","split","includes","cleaned","m","repeat","length","matchAll","extract","_raw","_search","Set","sort","name","schema","db","exec","remove","path","delta","vanished","prepare","run","store","extracted","placeholders","map","join","insert"],"mappings":"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"}
+{"version":3,"sources":["/Users/kevin/Dev/OpenSource/ai/sensemaking/src/features/tags.ts"],"sourcesContent":["import { maskRegions } from './fences.ts';\nimport type { Feature } from './types.ts';\n\n// tags(path, tag): Obsidian's file.tags grain -- frontmatter list/string tags plus inline\n// #tags from the prose, deduplicated, source not distinguished. Nested tags store full\n// (book/scifi); `tag = 'book' OR tag LIKE 'book/%'` is how a caller matches the parent too.\n\n// Obsidian treats [[#Heading]] as a same-note link, not a tag.\nconst WIKILINK_RE = /\\[\\[.*?\\]\\]/g; // to the first ]], so a heading holding a lone ] still masks\n// Obsidian doesn't read tags inside HTML markup.\nconst HTML_TAG_RE = /<\\/?[a-zA-Z][^>]*>/g; // tag-shaped only: a comparison's `< 5` must not open a span\n// Anchors on start-of-line or a preceding whitespace/(/[ so `a#b` and URL fragments don't count.\nconst INLINE_TAG_RE = /(?:^|[\\s([])#([\\p{L}\\p{N}_/-]+)/gu;\n// A markdown link destination `](...)` -- `[text](#anchor)` is a same-page link, not a tag.\nconst LINK_DEST_RE = /\\]\\((?:[^()]|\\([^()]*\\))*\\)/g; // one paren-nesting level, as CommonMark destinations allow: (https://x/a_(b)#frag)\n\n// Strips a leading # (frontmatter entries may carry one) and a trailing /; rejects an\n// all-digit result -- a tag needs at least one non-digit character.\nfunction normalizeTag(raw: string): string | null {\n  const stripped = raw.replace(/^#/, '').replace(/\\/+$/, '');\n  if (!stripped || /^\\d+$/.test(stripped)) return null;\n  return stripped;\n}\n\n// data.tags: a YAML list (Obsidian also accepts a bare string). Null members and non-string\n// members are skipped rather than throwing -- `tags:\\n  -` parses to [null].\nfunction frontmatterTags(data?: Record<string, unknown>): string[] {\n  const raw = data?.tags;\n  const list = Array.isArray(raw) ? raw : typeof raw === 'string' ? [raw] : [];\n  const found: string[] = [];\n  for (const item of list) {\n    if (typeof item !== 'string') continue;\n    const tag = normalizeTag(item);\n    if (tag) found.push(tag);\n  }\n  return found;\n}\n\n// #tag tokens outside fenced code blocks, inline code spans, wikilinks, HTML tags, HTML blocks,\n// <!-- --> comments, and link destinations. maskRegions() handles all of those region-level\n// concerns (and code spans, masked once there); this loop only does per-line tag extraction.\nfunction inlineTags(body: string): string[] {\n  const found: string[] = [];\n  for (const line of maskRegions(body).split('\\n')) {\n    if (!line.includes('#')) continue; // most lines; skip the regex work\n    let cleaned = line;\n    if (cleaned.includes('[[')) cleaned = cleaned.replace(WIKILINK_RE, (m) => ' '.repeat(m.length));\n    if (cleaned.includes('](')) cleaned = cleaned.replace(LINK_DEST_RE, (m) => ' '.repeat(m.length));\n    if (cleaned.includes('<')) cleaned = cleaned.replace(HTML_TAG_RE, (m) => ' '.repeat(m.length));\n    for (const m of cleaned.matchAll(INLINE_TAG_RE)) {\n      const tag = normalizeTag(m[1]);\n      if (tag) found.push(tag);\n    }\n  }\n  return found;\n}\n\nfunction extract(_raw: string, body: string, _search?: { title: string; summary: string }, data?: Record<string, unknown>): string[] {\n  return [...new Set([...frontmatterTags(data), ...inlineTags(body)])].sort();\n}\n\nexport const tags: Feature = {\n  name: 'tags',\n  async schema(db) {\n    await db.exec('CREATE TABLE IF NOT EXISTS tags (\"path\" TEXT, tag TEXT, PRIMARY KEY (\"path\", tag))');\n    await db.exec('CREATE INDEX IF NOT EXISTS tags_tag ON tags(tag)');\n  },\n  extract,\n  // Blanket clear-then-reinsert (store() below always writes the full found list back), so\n  // remove() covers both a vanished file and a reparsed one that already had rows -- no\n  // per-file NOT IN diffing, which cannot be expressed as one statement shared across files.\n  async remove(db, paths) {\n    if (paths.length === 0) return;\n    await db.runBatch(\n      'DELETE FROM tags WHERE \"path\" = ?',\n      paths.map((p) => [p])\n    );\n  },\n  async store(db, docs) {\n    const rows: unknown[][] = [];\n    for (const { path, extracted } of docs) for (const tag of extracted as string[]) rows.push([path, tag]);\n    if (rows.length === 0) return;\n    await db.runBatch('INSERT OR IGNORE INTO tags (\"path\", tag) VALUES (?, ?)', rows);\n  },\n};\n"],"names":["maskRegions","WIKILINK_RE","HTML_TAG_RE","INLINE_TAG_RE","LINK_DEST_RE","normalizeTag","raw","stripped","replace","test","frontmatterTags","data","tags","list","Array","isArray","found","item","tag","push","inlineTags","body","line","split","includes","cleaned","m","repeat","length","matchAll","extract","_raw","_search","Set","sort","name","schema","db","exec","remove","paths","runBatch","map","p","store","docs","rows","path","extracted"],"mappings":"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"}

package/dist/esm/features/types.d.ts

@@ -1,7 +1,7 @@
-import type { DatabaseSync } from 'node:sqlite';
 import type { Block } from '../chunk/index.js';
 import type { Config, FeatureName } from '../config/index.js';
 import type { FileStat } from '../scan/index.js';
+import type { Connection } from '../store/types.js';
 export interface ReconcileDelta {
     files: FileStat[];
     reparsed: string[];
@@ -9,16 +9,20 @@ export interface ReconcileDelta {
     vanished: string[];
     linksChanged?: boolean;
 }
+export interface ExtractedDoc {
+    path: string;
+    extracted: unknown;
+}
 export interface Feature {
     name: FeatureName;
-    schema(db: DatabaseSync): void;
+    schema(db: Connection): Promise<void>;
     extract?(raw: string, body: string, search?: {
         title: string;
         summary: string;
     }, data?: Record<string, unknown>, cfg?: Config, blocks?: Block[]): unknown;
-    remove?(db: DatabaseSync, path: string, delta: ReconcileDelta): void;
-    store?(db: DatabaseSync, path: string, extracted: unknown, delta: ReconcileDelta): void;
-    afterReconcile?(db: DatabaseSync, delta: ReconcileDelta): void;
+    remove?(db: Connection, paths: string[], delta: ReconcileDelta): Promise<void>;
+    store?(db: Connection, docs: ExtractedDoc[], delta: ReconcileDelta): Promise<void>;
+    afterReconcile?(db: Connection, delta: ReconcileDelta): Promise<void>;
     enabledForFile?(cfg: Config, file: FileStat): boolean;
     signature?(cfg: Config): string | undefined;
 }

package/dist/esm/features/types.js

@@ -1,3 +1,3 @@
-// A feature owns its schema, per-file extraction/storage, and any whole-tree pass.
+// A feature owns its schema, per-file extraction, batched storage, and any whole-tree pass.
 // Adding a feature = one module here + one entry in the registry (index.ts).
 export { };

package/dist/esm/features/types.js.map

@@ -1 +1 @@
-{"version":3,"sources":["/Users/kevin/Dev/OpenSource/ai/sensemaking/src/features/types.ts"],"sourcesContent":["import type { DatabaseSync } from 'node:sqlite';\nimport type { Block } from '../chunk/index.ts';\nimport type { Config, FeatureName } from '../config/index.ts';\nimport type { FileStat } from '../scan/index.ts';\n\n// What changed this reconcile, so hooks act on the delta rather than re-reading the tree.\n// `added` is the brand-new subset of `reparsed`. Hooks communicate through this one object.\nexport interface ReconcileDelta {\n  files: FileStat[];\n  reparsed: string[];\n  added: string[];\n  vanished: string[];\n  // Set by the links feature: the resolved edge set may differ from before this reconcile.\n  linksChanged?: boolean;\n}\n\n// A feature owns its schema, per-file extraction/storage, and any whole-tree pass.\n// Adding a feature = one module here + one entry in the registry (index.ts).\nexport interface Feature {\n  name: FeatureName;\n  schema(db: DatabaseSync): void;\n  // Pure, per file: raw is the full file, body the prose after frontmatter, search the\n  // normalized title/summary strings, data the parsed frontmatter, cfg the resolved config\n  // (mirrors enabledForFile's own cfg argument, for a feature whose extraction is config-tunable),\n  // blocks the body already parsed once by parseFile, shared with a feature needing a parse tree.\n  extract?(raw: string, body: string, search?: { title: string; summary: string }, data?: Record<string, unknown>, cfg?: Config, blocks?: Block[]): unknown;\n  remove?(db: DatabaseSync, path: string, delta: ReconcileDelta): void;\n  store?(db: DatabaseSync, path: string, extracted: unknown, delta: ReconcileDelta): void;\n  // After all rows are current, inside the reconcile transaction (resolution, rank).\n  // Hooks run in registry order and communicate through fields on `delta`.\n  afterReconcile?(db: DatabaseSync, delta: ReconcileDelta): void;\n  // Per-file opt-out (currently only embed, via FileStat.embed): absent means the feature\n  // applies to every file it's otherwise on for. Checked per file before extract/store so a\n  // doc in a tree with no embedding model gets no rows for it at all.\n  enabledForFile?(cfg: Config, file: FileStat): boolean;\n  // This feature's cache-identity segment for config.featureSignature, or undefined to\n  // contribute nothing. Composed by access.ts in registry order (features/index.ts's FEATURES).\n  signature?(cfg: Config): string | undefined;\n}\n"],"names":[],"mappings":"AAgBA,mFAAmF;AACnF,6EAA6E;AAC7E,WAoBC"}
+{"version":3,"sources":["/Users/kevin/Dev/OpenSource/ai/sensemaking/src/features/types.ts"],"sourcesContent":["import type { Block } from '../chunk/index.ts';\nimport type { Config, FeatureName } from '../config/index.ts';\nimport type { FileStat } from '../scan/index.ts';\nimport type { Connection } from '../store/types.ts';\n\n// What changed this reconcile, so hooks act on the delta rather than re-reading the tree.\n// `added` is the brand-new subset of `reparsed`. Hooks communicate through this one object.\nexport interface ReconcileDelta {\n  files: FileStat[];\n  reparsed: string[];\n  added: string[];\n  vanished: string[];\n  // Set by the links feature: the resolved edge set may differ from before this reconcile.\n  linksChanged?: boolean;\n}\n\n// One doc's per-feature extracted value, as store()/remove() see it (reconcile.ts assembles\n// these from ParsedDoc.extracted before calling a feature, once for the whole batch).\nexport interface ExtractedDoc {\n  path: string;\n  extracted: unknown;\n}\n\n// A feature owns its schema, per-file extraction, batched storage, and any whole-tree pass.\n// Adding a feature = one module here + one entry in the registry (index.ts).\nexport interface Feature {\n  name: FeatureName;\n  schema(db: Connection): Promise<void>;\n  // Pure, per file: raw is the full file, body the prose after frontmatter, search the\n  // normalized title/summary strings, data the parsed frontmatter, cfg the resolved config\n  // (mirrors enabledForFile's own cfg argument, for a feature whose extraction is config-tunable),\n  // blocks the body already parsed once by parseFile, shared with a feature needing a parse tree.\n  extract?(raw: string, body: string, search?: { title: string; summary: string }, data?: Record<string, unknown>, cfg?: Config, blocks?: Block[]): unknown;\n  // Called once per reconcile (not per file) with every path whose rows need clearing: vanished\n  // files, plus reparsed files that already had rows (a feature that diffs its own stale rows\n  // in store() instead, e.g. links/tags, filters this list down to just delta.vanished itself).\n  remove?(db: Connection, paths: string[], delta: ReconcileDelta): Promise<void>;\n  // Called once per reconcile with every freshly parsed doc's extracted value, so a feature\n  // writes its rows through one Connection.runBatch call instead of looping per file.\n  store?(db: Connection, docs: ExtractedDoc[], delta: ReconcileDelta): Promise<void>;\n  // After all rows are current, inside the reconcile transaction (resolution, rank).\n  // Hooks run in registry order and communicate through fields on `delta`.\n  afterReconcile?(db: Connection, delta: ReconcileDelta): Promise<void>;\n  // Per-file opt-out (currently only embed, via FileStat.embed): absent means the feature\n  // applies to every file it's otherwise on for. Checked per file before extract/store so a\n  // doc in a tree with no embedding model gets no rows for it at all.\n  enabledForFile?(cfg: Config, file: FileStat): boolean;\n  // This feature's cache-identity segment for config.featureSignature, or undefined to\n  // contribute nothing. Composed by access.ts in registry order (features/index.ts's FEATURES).\n  signature?(cfg: Config): string | undefined;\n}\n"],"names":[],"mappings":"AAuBA,4FAA4F;AAC5F,6EAA6E;AAC7E,WAyBC"}

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

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

package/dist/esm/graph/traverse.js

@@ -1,18 +1,21 @@
 // Frontier-by-frontier BFS through a temp visited table, one indexed anti-join per ring: a
 // local question touches a neighborhood, never the whole edge list.
-function resetVisited(db) {
-    db.exec('DROP TABLE IF EXISTS temp.visited');
-    db.exec('CREATE TEMP TABLE visited (path TEXT PRIMARY KEY, depth INTEGER NOT NULL, pred TEXT)');
+async function resetVisited(store) {
+    await store.exec('DROP TABLE IF EXISTS temp.visited');
+    await store.exec('CREATE TEMP TABLE visited (path TEXT PRIMARY KEY, depth INTEGER NOT NULL, pred TEXT)');
 }
 // Materializes the caller-resolved scope Set into a temp table so it joins like any other
 // indexed column. `extra`, when given, is always in scope -- findPath's `to` endpoint.
-function setupAllowed(db, allowed, extra) {
-    db.exec('DROP TABLE IF EXISTS temp.allowed_nodes');
-    db.exec('CREATE TEMP TABLE allowed_nodes (path TEXT PRIMARY KEY)');
-    db.prepare('INSERT INTO allowed_nodes SELECT DISTINCT value FROM json_each(?1)').run(JSON.stringify([
-        ...allowed
-    ]));
-    if (extra !== undefined) db.prepare('INSERT OR IGNORE INTO allowed_nodes VALUES (?)').run(extra);
+async function setupAllowed(store, allowed, extra) {
+    const all = new Set(allowed);
+    if (extra !== undefined) all.add(extra);
+    await store.exec('DROP TABLE IF EXISTS temp.allowed_nodes');
+    await store.exec('CREATE TEMP TABLE allowed_nodes (path TEXT PRIMARY KEY)');
+    await store.runBatch('INSERT INTO allowed_nodes (path) VALUES (?)', [
+        ...all
+    ].map((p)=>[
+            p
+        ]));
 }
 // Only resolved links (dst IS NOT NULL) are followed, in either direction.
 function candidateSelect(direction) {
@@ -23,8 +26,8 @@ function candidateSelect(direction) {
     return `${forward} UNION ALL ${reverse}`;
 }
 // One ring: candidates adjacent to the previous ring's frontier (?1), anti-joined against
-// everything already visited, optionally filtered to the allowed set, capped (?3) and
-// inserted at the new depth (?2). RETURNING hands back exactly what this ring newly reached.
+// everything already visited, optionally filtered to the allowed set, and inserted at the
+// new depth (?2). RETURNING hands back exactly what this ring newly reached.
 function ringSql(direction, hasAllowed) {
     return `
 INSERT INTO visited (path, depth, pred)
@@ -34,23 +37,22 @@ WHERE NOT EXISTS (SELECT 1 FROM visited v2 WHERE v2.path = cand.path)
 ${hasAllowed ? 'AND EXISTS (SELECT 1 FROM allowed_nodes a WHERE a.path = cand.path)' : ''}
 GROUP BY cand.path
 ORDER BY cand.path
-LIMIT ?3
 RETURNING path`;
 }
-function reconstructPath(db, to) {
-    const lookup = db.prepare('SELECT pred FROM visited WHERE path = ?');
+async function reconstructPath(store, to) {
+    const lookup = await store.prepare('SELECT pred FROM visited WHERE path = ?');
     const path = [];
     let cur = to;
     while(cur !== null){
         path.push(cur);
-        const row = lookup.get(cur);
+        const row = await lookup.get(cur);
         cur = row ? row.pred : null;
     }
     return path.reverse();
 }
 // One BFS from `from`, tracking a predecessor per node. Undirected by default, matching
 // personalizedRank; null when `to` is unreached within `maxDepth`.
-export function findPath(db, from, to, opts = {}) {
+export async function findPath(store, from, to, opts = {}) {
     var _opts_maxDepth;
     if (from === to) return [
         from
@@ -58,14 +60,15 @@ export function findPath(db, from, to, opts = {}) {
     const direction = opts.directed ? 'forward' : 'both';
     const maxDepth = (_opts_maxDepth = opts.maxDepth) !== null && _opts_maxDepth !== void 0 ? _opts_maxDepth : Infinity;
     if (maxDepth <= 0) return null;
-    resetVisited(db);
-    db.prepare('INSERT INTO visited (path, depth, pred) VALUES (?, 0, NULL)').run(from);
-    if (opts.allowed) setupAllowed(db, opts.allowed, to);
-    const stmt = db.prepare(ringSql(direction, !!opts.allowed));
+    await resetVisited(store);
+    const insertStart = await store.prepare('INSERT INTO visited (path, depth, pred) VALUES (?, 0, NULL)');
+    await insertStart.run(from);
+    if (opts.allowed) await setupAllowed(store, opts.allowed, to);
+    const stmt = await store.prepare(ringSql(direction, !!opts.allowed));
     for(let ring = 1; ring <= maxDepth; ring++){
-        const rows = stmt.all(ring - 1, ring, -1);
+        const rows = await stmt.all(ring - 1, ring);
         if (rows.length === 0) break;
-        if (rows.some((row)=>row.path === to)) return reconstructPath(db, to);
+        if (rows.some((row)=>row.path === to)) return reconstructPath(store, to);
     }
     return null;
 }

package/dist/esm/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.\nimport type { DatabaseSync } from 'node:sqlite';\n\ntype Direction = 'forward' | 'reverse' | 'both';\n\ninterface FindPathOptions {\n  directed?: boolean;\n  maxDepth?: number;\n  allowed?: Set<string>;\n}\n\nfunction resetVisited(db: DatabaseSync): void {\n  db.exec('DROP TABLE IF EXISTS temp.visited');\n  db.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.\nfunction setupAllowed(db: DatabaseSync, allowed: Set<string>, extra?: string): void {\n  db.exec('DROP TABLE IF EXISTS temp.allowed_nodes');\n  db.exec('CREATE TEMP TABLE allowed_nodes (path TEXT PRIMARY KEY)');\n  db.prepare('INSERT INTO allowed_nodes SELECT DISTINCT value FROM json_each(?1)').run(JSON.stringify([...allowed]));\n  if (extra !== undefined) db.prepare('INSERT OR IGNORE INTO allowed_nodes VALUES (?)').run(extra);\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, capped (?3) and\n// inserted at the new depth (?2). RETURNING hands back exactly 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\nLIMIT ?3\nRETURNING path`;\n}\n\nfunction reconstructPath(db: DatabaseSync, to: string): string[] {\n  const lookup = db.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 = 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(db: DatabaseSync, from: string, to: string, opts: FindPathOptions = {}): 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  resetVisited(db);\n  db.prepare('INSERT INTO visited (path, depth, pred) VALUES (?, 0, NULL)').run(from);\n  if (opts.allowed) setupAllowed(db, opts.allowed, to);\n\n  const stmt = db.prepare(ringSql(direction, !!opts.allowed));\n  for (let ring = 1; ring <= maxDepth; ring++) {\n    const rows = stmt.all(ring - 1, ring, -1) as Array<{ path: string }>;\n    if (rows.length === 0) break;\n    if (rows.some((row) => row.path === to)) return reconstructPath(db, to);\n  }\n  return null;\n}\n"],"names":["resetVisited","db","exec","setupAllowed","allowed","extra","prepare","run","JSON","stringify","undefined","candidateSelect","direction","forward","reverse","ringSql","hasAllowed","reconstructPath","to","lookup","path","cur","push","row","get","pred","findPath","from","opts","directed","maxDepth","Infinity","stmt","ring","rows","all","length","some"],"mappings":"AAAA,2FAA2F;AAC3F,oEAAoE;AAWpE,SAASA,aAAaC,EAAgB;IACpCA,GAAGC,IAAI,CAAC;IACRD,GAAGC,IAAI,CAAC;AACV;AAEA,0FAA0F;AAC1F,uFAAuF;AACvF,SAASC,aAAaF,EAAgB,EAAEG,OAAoB,EAAEC,KAAc;IAC1EJ,GAAGC,IAAI,CAAC;IACRD,GAAGC,IAAI,CAAC;IACRD,GAAGK,OAAO,CAAC,sEAAsEC,GAAG,CAACC,KAAKC,SAAS,CAAC;WAAIL;KAAQ;IAChH,IAAIC,UAAUK,WAAWT,GAAGK,OAAO,CAAC,kDAAkDC,GAAG,CAACF;AAC5F;AAEA,2EAA2E;AAC3E,SAASM,gBAAgBC,SAAoB;IAC3C,MAAMC,UAAU;IAChB,MAAMC,UAAU;IAChB,IAAIF,cAAc,WAAW,OAAOC;IACpC,IAAID,cAAc,WAAW,OAAOE;IACpC,OAAO,GAAGD,QAAQ,WAAW,EAAEC,SAAS;AAC1C;AAEA,0FAA0F;AAC1F,sFAAsF;AACtF,6FAA6F;AAC7F,SAASC,QAAQH,SAAoB,EAAEI,UAAmB;IACxD,OAAO,CAAC;;;MAGJ,EAAEL,gBAAgBC,WAAW;;AAEnC,EAAEI,aAAa,wEAAwE,GAAG;;;;cAI5E,CAAC;AACf;AAEA,SAASC,gBAAgBhB,EAAgB,EAAEiB,EAAU;IACnD,MAAMC,SAASlB,GAAGK,OAAO,CAAC;IAC1B,MAAMc,OAAiB,EAAE;IACzB,IAAIC,MAAqBH;IACzB,MAAOG,QAAQ,KAAM;QACnBD,KAAKE,IAAI,CAACD;QACV,MAAME,MAAMJ,OAAOK,GAAG,CAACH;QACvBA,MAAME,MAAMA,IAAIE,IAAI,GAAG;IACzB;IACA,OAAOL,KAAKN,OAAO;AACrB;AAEA,wFAAwF;AACxF,mEAAmE;AACnE,OAAO,SAASY,SAASzB,EAAgB,EAAE0B,IAAY,EAAET,EAAU,EAAEU,OAAwB,CAAC,CAAC;QAI5EA;IAHjB,IAAID,SAAST,IAAI,OAAO;QAACS;KAAK;IAE9B,MAAMf,YAAuBgB,KAAKC,QAAQ,GAAG,YAAY;IACzD,MAAMC,YAAWF,iBAAAA,KAAKE,QAAQ,cAAbF,4BAAAA,iBAAiBG;IAClC,IAAID,YAAY,GAAG,OAAO;IAE1B9B,aAAaC;IACbA,GAAGK,OAAO,CAAC,+DAA+DC,GAAG,CAACoB;IAC9E,IAAIC,KAAKxB,OAAO,EAAED,aAAaF,IAAI2B,KAAKxB,OAAO,EAAEc;IAEjD,MAAMc,OAAO/B,GAAGK,OAAO,CAACS,QAAQH,WAAW,CAAC,CAACgB,KAAKxB,OAAO;IACzD,IAAK,IAAI6B,OAAO,GAAGA,QAAQH,UAAUG,OAAQ;QAC3C,MAAMC,OAAOF,KAAKG,GAAG,CAACF,OAAO,GAAGA,MAAM,CAAC;QACvC,IAAIC,KAAKE,MAAM,KAAK,GAAG;QACvB,IAAIF,KAAKG,IAAI,CAAC,CAACd,MAAQA,IAAIH,IAAI,KAAKF,KAAK,OAAOD,gBAAgBhB,IAAIiB;IACtE;IACA,OAAO;AACT"}
+{"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.\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, and inserted at the\n// new depth (?2). RETURNING hands back exactly 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 async function findPath(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":["resetVisited","store","exec","setupAllowed","allowed","extra","all","Set","undefined","add","runBatch","map","p","candidateSelect","direction","forward","reverse","ringSql","hasAllowed","reconstructPath","to","lookup","prepare","path","cur","push","row","get","pred","findPath","from","opts","directed","maxDepth","Infinity","insertStart","run","stmt","ring","rows","length","some"],"mappings":"AAAA,2FAA2F;AAC3F,oEAAoE;AAWpE,eAAeA,aAAaC,KAAY;IACtC,MAAMA,MAAMC,IAAI,CAAC;IACjB,MAAMD,MAAMC,IAAI,CAAC;AACnB;AAEA,0FAA0F;AAC1F,uFAAuF;AACvF,eAAeC,aAAaF,KAAY,EAAEG,OAAoB,EAAEC,KAAc;IAC5E,MAAMC,MAAM,IAAIC,IAAIH;IACpB,IAAIC,UAAUG,WAAWF,IAAIG,GAAG,CAACJ;IACjC,MAAMJ,MAAMC,IAAI,CAAC;IACjB,MAAMD,MAAMC,IAAI,CAAC;IACjB,MAAMD,MAAMS,QAAQ,CAClB,+CACA;WAAIJ;KAAI,CAACK,GAAG,CAAC,CAACC,IAAM;YAACA;SAAE;AAE3B;AAEA,2EAA2E;AAC3E,SAASC,gBAAgBC,SAAoB;IAC3C,MAAMC,UAAU;IAChB,MAAMC,UAAU;IAChB,IAAIF,cAAc,WAAW,OAAOC;IACpC,IAAID,cAAc,WAAW,OAAOE;IACpC,OAAO,GAAGD,QAAQ,WAAW,EAAEC,SAAS;AAC1C;AAEA,0FAA0F;AAC1F,0FAA0F;AAC1F,6EAA6E;AAC7E,SAASC,QAAQH,SAAoB,EAAEI,UAAmB;IACxD,OAAO,CAAC;;;MAGJ,EAAEL,gBAAgBC,WAAW;;AAEnC,EAAEI,aAAa,wEAAwE,GAAG;;;cAG5E,CAAC;AACf;AAEA,eAAeC,gBAAgBlB,KAAY,EAAEmB,EAAU;IACrD,MAAMC,SAAS,MAAMpB,MAAMqB,OAAO,CAAC;IACnC,MAAMC,OAAiB,EAAE;IACzB,IAAIC,MAAqBJ;IACzB,MAAOI,QAAQ,KAAM;QACnBD,KAAKE,IAAI,CAACD;QACV,MAAME,MAAO,MAAML,OAAOM,GAAG,CAACH;QAC9BA,MAAME,MAAMA,IAAIE,IAAI,GAAG;IACzB;IACA,OAAOL,KAAKP,OAAO;AACrB;AAEA,wFAAwF;AACxF,mEAAmE;AACnE,OAAO,eAAea,SAAS5B,KAAY,EAAE6B,IAAY,EAAEV,EAAU,EAAEW,OAAwB,CAAC,CAAC;QAI9EA;IAHjB,IAAID,SAASV,IAAI,OAAO;QAACU;KAAK;IAE9B,MAAMhB,YAAuBiB,KAAKC,QAAQ,GAAG,YAAY;IACzD,MAAMC,YAAWF,iBAAAA,KAAKE,QAAQ,cAAbF,4BAAAA,iBAAiBG;IAClC,IAAID,YAAY,GAAG,OAAO;IAE1B,MAAMjC,aAAaC;IACnB,MAAMkC,cAAc,MAAMlC,MAAMqB,OAAO,CAAC;IACxC,MAAMa,YAAYC,GAAG,CAACN;IACtB,IAAIC,KAAK3B,OAAO,EAAE,MAAMD,aAAaF,OAAO8B,KAAK3B,OAAO,EAAEgB;IAE1D,MAAMiB,OAAO,MAAMpC,MAAMqB,OAAO,CAACL,QAAQH,WAAW,CAAC,CAACiB,KAAK3B,OAAO;IAClE,IAAK,IAAIkC,OAAO,GAAGA,QAAQL,UAAUK,OAAQ;QAC3C,MAAMC,OAAQ,MAAMF,KAAK/B,GAAG,CAACgC,OAAO,GAAGA;QACvC,IAAIC,KAAKC,MAAM,KAAK,GAAG;QACvB,IAAID,KAAKE,IAAI,CAAC,CAACf,MAAQA,IAAIH,IAAI,KAAKH,KAAK,OAAOD,gBAAgBlB,OAAOmB;IACzE;IACA,OAAO;AACT"}

package/dist/esm/index.d.ts

@@ -2,11 +2,12 @@ export type { Peek, PresetCoverage, SearchOptions, TreeMap } from './commands/in
 export { mapTree, peek, presetCoverage, search } from './commands/index.js';
 export type { Config, EmbedConfig, FeatureName, InitOverrides, Preset, ResolvedConfig, SavedQuery, SavedSearch, SearchOverrides, SignalName, SignalWeights } from './config/index.js';
 export { CONFIG_FILENAME, initConfig, loadConfig, migrateConfig, SIGNAL_NAMES, STATE_DIR, SUPPORTED_CONFIG_VERSION } from './config/index.js';
-export type { OpenResult } from './db/index.js';
-export { clearCache, open } from './db/index.js';
 export type { SenseErrorCode } from './errors.js';
 export { SenseError } from './errors.js';
 export type { Format, Row, RowFormat } from './output/output.js';
 export { printRows } from './output/output.js';
+export type { OpenResult } from './store/index.js';
+export { clearCache, openStore as open } from './store/index.js';
+export type { Capability, DocumentStore, LexicalHit, LexicalIndex, LexicalQueryOptions, RawStatement, RunResult, SqlSession, Statement, Store, VectorCandidate, VectorSimilar, VectorStore, VectorWriteRow } from './store/types.js';
 export type { WatchEvent, WatchOptions } from './watch.js';
 export { runWatch } from './watch.js';

package/dist/esm/index.js

@@ -2,7 +2,7 @@
 // internals (feature registry, graph, scan, meta) stay module-private.
 export { mapTree, peek, presetCoverage, search } from './commands/index.js';
 export { CONFIG_FILENAME, initConfig, loadConfig, migrateConfig, SIGNAL_NAMES, STATE_DIR, SUPPORTED_CONFIG_VERSION } from './config/index.js';
-export { clearCache, open } from './db/index.js';
 export { SenseError } from './errors.js';
 export { printRows } from './output/output.js';
+export { clearCache, openStore as open } from './store/index.js';
 export { runWatch } from './watch.js';

package/dist/esm/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, Preset, ResolvedConfig, SavedQuery, SavedSearch, SearchOverrides, SignalName, SignalWeights } from './config/index.ts';\nexport { CONFIG_FILENAME, initConfig, loadConfig, migrateConfig, SIGNAL_NAMES, STATE_DIR, SUPPORTED_CONFIG_VERSION } from './config/index.ts';\nexport type { OpenResult } from './db/index.ts';\nexport { clearCache, open } from './db/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';\n\nexport type { WatchEvent, WatchOptions } from './watch.ts';\nexport { runWatch } from './watch.ts';\n"],"names":["mapTree","peek","presetCoverage","search","CONFIG_FILENAME","initConfig","loadConfig","migrateConfig","SIGNAL_NAMES","STATE_DIR","SUPPORTED_CONFIG_VERSION","clearCache","open","SenseError","printRows","runWatch"],"mappings":"AAAA,+EAA+E;AAC/E,uEAAuE;AAGvE,SAASA,OAAO,EAAEC,IAAI,EAAEC,cAAc,EAAEC,MAAM,QAAQ,sBAAsB;AAE5E,SAASC,eAAe,EAAEC,UAAU,EAAEC,UAAU,EAAEC,aAAa,EAAEC,YAAY,EAAEC,SAAS,EAAEC,wBAAwB,QAAQ,oBAAoB;AAE9I,SAASC,UAAU,EAAEC,IAAI,QAAQ,gBAAgB;AAEjD,SAASC,UAAU,QAAQ,cAAc;AAEzC,SAASC,SAAS,QAAQ,qBAAqB;AAG/C,SAASC,QAAQ,QAAQ,aAAa"}
+{"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, Preset, ResolvedConfig, SavedQuery, SavedSearch, SearchOverrides, SignalName, SignalWeights } from './config/index.ts';\nexport { CONFIG_FILENAME, initConfig, loadConfig, migrateConfig, SIGNAL_NAMES, STATE_DIR, 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 { OpenResult } from './store/index.ts';\nexport { clearCache, openStore as open } from './store/index.ts';\nexport type { Capability, DocumentStore, 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":["mapTree","peek","presetCoverage","search","CONFIG_FILENAME","initConfig","loadConfig","migrateConfig","SIGNAL_NAMES","STATE_DIR","SUPPORTED_CONFIG_VERSION","SenseError","printRows","clearCache","openStore","open","runWatch"],"mappings":"AAAA,+EAA+E;AAC/E,uEAAuE;AAGvE,SAASA,OAAO,EAAEC,IAAI,EAAEC,cAAc,EAAEC,MAAM,QAAQ,sBAAsB;AAE5E,SAASC,eAAe,EAAEC,UAAU,EAAEC,UAAU,EAAEC,aAAa,EAAEC,YAAY,EAAEC,SAAS,EAAEC,wBAAwB,QAAQ,oBAAoB;AAE9I,SAASC,UAAU,QAAQ,cAAc;AAEzC,SAASC,SAAS,QAAQ,qBAAqB;AAE/C,SAASC,UAAU,EAAEC,aAAaC,IAAI,QAAQ,mBAAmB;AAIjE,SAASC,QAAQ,QAAQ,aAAa"}

package/dist/esm/lib/guarded-tick.d.ts

@@ -0,0 +1 @@
+export declare function guardedTick(fn: () => Promise<void>, skip: () => boolean): () => void;

package/dist/esm/lib/guarded-tick.js

@@ -0,0 +1,8 @@
+// Wraps an async interval tick so a rejection (e.g. a store closed mid-await) never
+// escapes as an unhandled rejection, and so a skip() guard can suppress the call entirely.
+export function guardedTick(fn, skip) {
+    return ()=>{
+        if (skip()) return;
+        fn().catch(()=>{});
+    };
+}

package/dist/esm/lib/guarded-tick.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["/Users/kevin/Dev/OpenSource/ai/sensemaking/src/lib/guarded-tick.ts"],"sourcesContent":["// Wraps an async interval tick so a rejection (e.g. a store closed mid-await) never\n// escapes as an unhandled rejection, and so a skip() guard can suppress the call entirely.\nexport function guardedTick(fn: () => Promise<void>, skip: () => boolean): () => void {\n  return () => {\n    if (skip()) return;\n    fn().catch(() => {});\n  };\n}\n"],"names":["guardedTick","fn","skip","catch"],"mappings":"AAAA,oFAAoF;AACpF,2FAA2F;AAC3F,OAAO,SAASA,YAAYC,EAAuB,EAAEC,IAAmB;IACtE,OAAO;QACL,IAAIA,QAAQ;QACZD,KAAKE,KAAK,CAAC,KAAO;IACpB;AACF"}

package/dist/esm/output/column-hint.d.ts

@@ -1,2 +1 @@
-import type { DatabaseSync } from 'node:sqlite';
-export declare function columnHint(db: DatabaseSync, err: Error): Error;
+export declare function columnHint(columns: string[], err: Error): Error;

package/dist/esm/output/column-hint.js

@@ -5,7 +5,9 @@
 function startsWithBoundary(name, prefix) {
     return name.length > prefix.length && name.startsWith(prefix) && /\W/.test(name[prefix.length]);
 }
-export function columnHint(db, err) {
+// columns: the tree's frontmatter columns (store.docs.columns()), read by the caller so this
+// stays a pure function rather than a store dependency.
+export function columnHint(columns, err) {
     const match = /no such column: (\S+)/.exec(err.message);
     if (!match) return err;
     const token = match[1];
@@ -17,7 +19,6 @@ export function columnHint(db, err) {
         token,
         aliasStripped
     ]);
-    const columns = db.prepare('PRAGMA table_info(frontmatter)').all().map((c)=>c.name);
     const candidates = new Set();
     for (const name of columns){
         for (const form of forms){

package/dist/esm/output/column-hint.js.map

@@ -1 +1 @@
-{"version":3,"sources":["/Users/kevin/Dev/OpenSource/ai/sensemaking/src/output/column-hint.ts"],"sourcesContent":["import type { DatabaseSync } from 'node:sqlite';\n\n// A frontmatter key with punctuation (`plugin-id`, `a.b`) is a real column, but naming it\n// unquoted in SQL parses as an expression: `plugin-id` is `plugin - id`, and SQLite's error\n// names a fragment (`plugin`) the user never wrote. This maps that fragment back to the\n// columns it could have come from, so the error names the actual fix instead.\n\nfunction startsWithBoundary(name: string, prefix: string): boolean {\n  return name.length > prefix.length && name.startsWith(prefix) && /\\W/.test(name[prefix.length]);\n}\n\nexport function columnHint(db: DatabaseSync, err: Error): Error {\n  const match = /no such column: (\\S+)/.exec(err.message);\n  if (!match) return err;\n  const token = match[1];\n  // `f.plugin` -> `plugin`; left as-is when there's no leading alias segment, which also\n  // covers a column literally named `a.b` -- the full-token check below matches that case\n  // directly, so stripping here never needs to special-case it.\n  const aliasStripped = token.replace(/^[A-Za-z_]\\w*\\./, '');\n  const forms = new Set([token, aliasStripped]);\n  const columns = (db.prepare('PRAGMA table_info(frontmatter)').all() as Array<{ name: string }>).map((c) => c.name);\n  const candidates = new Set<string>();\n  for (const name of columns) {\n    for (const form of forms) {\n      if (name === form || startsWithBoundary(name, form)) candidates.add(name);\n    }\n  }\n  if (candidates.size === 0) return err;\n  const quoted = [...candidates].map((name) => `\"${name.split('\"').join('\"\"')}\"`).join(', ');\n  return new Error(`${err.message} -- ${quoted} needs double quotes in SQL: unquoted, SQLite parses the punctuation as an operator instead of column syntax.`);\n}\n"],"names":["startsWithBoundary","name","prefix","length","startsWith","test","columnHint","db","err","match","exec","message","token","aliasStripped","replace","forms","Set","columns","prepare","all","map","c","candidates","form","add","size","quoted","split","join","Error"],"mappings":"AAEA,0FAA0F;AAC1F,4FAA4F;AAC5F,wFAAwF;AACxF,8EAA8E;AAE9E,SAASA,mBAAmBC,IAAY,EAAEC,MAAc;IACtD,OAAOD,KAAKE,MAAM,GAAGD,OAAOC,MAAM,IAAIF,KAAKG,UAAU,CAACF,WAAW,KAAKG,IAAI,CAACJ,IAAI,CAACC,OAAOC,MAAM,CAAC;AAChG;AAEA,OAAO,SAASG,WAAWC,EAAgB,EAAEC,GAAU;IACrD,MAAMC,QAAQ,wBAAwBC,IAAI,CAACF,IAAIG,OAAO;IACtD,IAAI,CAACF,OAAO,OAAOD;IACnB,MAAMI,QAAQH,KAAK,CAAC,EAAE;IACtB,uFAAuF;IACvF,wFAAwF;IACxF,8DAA8D;IAC9D,MAAMI,gBAAgBD,MAAME,OAAO,CAAC,mBAAmB;IACvD,MAAMC,QAAQ,IAAIC,IAAI;QAACJ;QAAOC;KAAc;IAC5C,MAAMI,UAAU,AAACV,GAAGW,OAAO,CAAC,kCAAkCC,GAAG,GAA+BC,GAAG,CAAC,CAACC,IAAMA,EAAEpB,IAAI;IACjH,MAAMqB,aAAa,IAAIN;IACvB,KAAK,MAAMf,QAAQgB,QAAS;QAC1B,KAAK,MAAMM,QAAQR,MAAO;YACxB,IAAId,SAASsB,QAAQvB,mBAAmBC,MAAMsB,OAAOD,WAAWE,GAAG,CAACvB;QACtE;IACF;IACA,IAAIqB,WAAWG,IAAI,KAAK,GAAG,OAAOjB;IAClC,MAAMkB,SAAS;WAAIJ;KAAW,CAACF,GAAG,CAAC,CAACnB,OAAS,CAAC,CAAC,EAAEA,KAAK0B,KAAK,CAAC,KAAKC,IAAI,CAAC,MAAM,CAAC,CAAC,EAAEA,IAAI,CAAC;IACrF,OAAO,IAAIC,MAAM,GAAGrB,IAAIG,OAAO,CAAC,IAAI,EAAEe,OAAO,6GAA6G,CAAC;AAC7J"}
+{"version":3,"sources":["/Users/kevin/Dev/OpenSource/ai/sensemaking/src/output/column-hint.ts"],"sourcesContent":["// A frontmatter key with punctuation (`plugin-id`, `a.b`) is a real column, but naming it\n// unquoted in SQL parses as an expression: `plugin-id` is `plugin - id`, and SQLite's error\n// names a fragment (`plugin`) the user never wrote. This maps that fragment back to the\n// columns it could have come from, so the error names the actual fix instead.\n\nfunction startsWithBoundary(name: string, prefix: string): boolean {\n  return name.length > prefix.length && name.startsWith(prefix) && /\\W/.test(name[prefix.length]);\n}\n\n// columns: the tree's frontmatter columns (store.docs.columns()), read by the caller so this\n// stays a pure function rather than a store dependency.\nexport function columnHint(columns: string[], err: Error): Error {\n  const match = /no such column: (\\S+)/.exec(err.message);\n  if (!match) return err;\n  const token = match[1];\n  // `f.plugin` -> `plugin`; left as-is when there's no leading alias segment, which also\n  // covers a column literally named `a.b` -- the full-token check below matches that case\n  // directly, so stripping here never needs to special-case it.\n  const aliasStripped = token.replace(/^[A-Za-z_]\\w*\\./, '');\n  const forms = new Set([token, aliasStripped]);\n  const candidates = new Set<string>();\n  for (const name of columns) {\n    for (const form of forms) {\n      if (name === form || startsWithBoundary(name, form)) candidates.add(name);\n    }\n  }\n  if (candidates.size === 0) return err;\n  const quoted = [...candidates].map((name) => `\"${name.split('\"').join('\"\"')}\"`).join(', ');\n  return new Error(`${err.message} -- ${quoted} needs double quotes in SQL: unquoted, SQLite parses the punctuation as an operator instead of column syntax.`);\n}\n"],"names":["startsWithBoundary","name","prefix","length","startsWith","test","columnHint","columns","err","match","exec","message","token","aliasStripped","replace","forms","Set","candidates","form","add","size","quoted","map","split","join","Error"],"mappings":"AAAA,0FAA0F;AAC1F,4FAA4F;AAC5F,wFAAwF;AACxF,8EAA8E;AAE9E,SAASA,mBAAmBC,IAAY,EAAEC,MAAc;IACtD,OAAOD,KAAKE,MAAM,GAAGD,OAAOC,MAAM,IAAIF,KAAKG,UAAU,CAACF,WAAW,KAAKG,IAAI,CAACJ,IAAI,CAACC,OAAOC,MAAM,CAAC;AAChG;AAEA,6FAA6F;AAC7F,wDAAwD;AACxD,OAAO,SAASG,WAAWC,OAAiB,EAAEC,GAAU;IACtD,MAAMC,QAAQ,wBAAwBC,IAAI,CAACF,IAAIG,OAAO;IACtD,IAAI,CAACF,OAAO,OAAOD;IACnB,MAAMI,QAAQH,KAAK,CAAC,EAAE;IACtB,uFAAuF;IACvF,wFAAwF;IACxF,8DAA8D;IAC9D,MAAMI,gBAAgBD,MAAME,OAAO,CAAC,mBAAmB;IACvD,MAAMC,QAAQ,IAAIC,IAAI;QAACJ;QAAOC;KAAc;IAC5C,MAAMI,aAAa,IAAID;IACvB,KAAK,MAAMf,QAAQM,QAAS;QAC1B,KAAK,MAAMW,QAAQH,MAAO;YACxB,IAAId,SAASiB,QAAQlB,mBAAmBC,MAAMiB,OAAOD,WAAWE,GAAG,CAAClB;QACtE;IACF;IACA,IAAIgB,WAAWG,IAAI,KAAK,GAAG,OAAOZ;IAClC,MAAMa,SAAS;WAAIJ;KAAW,CAACK,GAAG,CAAC,CAACrB,OAAS,CAAC,CAAC,EAAEA,KAAKsB,KAAK,CAAC,KAAKC,IAAI,CAAC,MAAM,CAAC,CAAC,EAAEA,IAAI,CAAC;IACrF,OAAO,IAAIC,MAAM,GAAGjB,IAAIG,OAAO,CAAC,IAAI,EAAEU,OAAO,6GAA6G,CAAC;AAC7J"}

package/dist/esm/output/output.d.ts

@@ -1,8 +1,9 @@
 export type Row = Record<string, unknown>;
 export type Format = 'table' | 'json';
 export type RowFormat = Format | 'csv';
+export declare function stringifyJson(value: unknown, indent?: number): string;
 export declare function printRows(rows: Row[], format: RowFormat, columns?: string[]): void;
-export declare function printRowStream(rows: Iterable<Row>, format: RowFormat, columns: string[]): void;
+export declare function printRowStream(rows: AsyncIterable<Row>, format: RowFormat, columns: string[]): Promise<void>;
 export declare function featureOffHint(name: string): string;
 export declare function featuresLine(features: {
     on: string[];

package/dist/esm/output/output.js

@@ -24,6 +24,14 @@ function warnOversize(bytes, rowCount) {
 // b's value under both headers. `columns` is the fallback that labels a 0-row result, and with
 // no rows and no statement (a bounded command that found nothing) csv writes nothing at all --
 // a bare newline would read to a csv parser as one empty record.
+// JSON.stringify throws on BigInt, and stores return int64 as BigInt (DuckDB does). A value
+// that fits a safe integer stays a number; a larger one becomes its decimal string, since a
+// JSON number cannot carry it losslessly.
+const MAX_SAFE = BigInt(Number.MAX_SAFE_INTEGER);
+const bigintSafe = (_key, value)=>typeof value === 'bigint' ? value >= -MAX_SAFE && value <= MAX_SAFE ? Number(value) : value.toString() : value;
+export function stringifyJson(value, indent) {
+    return JSON.stringify(value, bigintSafe, indent);
+}
 export function printRows(rows, format, columns) {
     if (format === 'csv') {
         // Collapsed the same way a row object collapses them, so a statement naming a column
@@ -45,25 +53,26 @@ export function printRows(rows, format, columns) {
     console.log(rendered);
     warnOversize(Buffer.byteLength(rendered), rows.length);
 }
-// Streaming counterpart for the one unbounded caller, `sense sql`: rows arrive from an
-// iterator, so a large result is never held here as rows and again as a rendered string.
-// Table buffers by necessity (a column is as wide as its widest cell, which the last row can
-// change); json and csv write row by row. The writes are synchronous, so when stdout is a pipe
-// Node buffers what the reader has not taken yet -- the saving is this module's copies, not
-// the operating system's.
-export function printRowStream(rows, format, columns) {
-    const iterator = rows[Symbol.iterator]();
+// Streaming counterpart for the one unbounded caller, `sense sql`: rows arrive from an async
+// iterator (raw.prepare().iterate(), one microtask for the whole statement, not per row), so a
+// large result is never held here as rows and again as a rendered string. Table buffers by
+// necessity (a column is as wide as its widest cell, which the last row can change); json and
+// csv write row by row. The writes are synchronous, so when stdout is a pipe Node buffers what
+// the reader has not taken yet -- the saving is this module's copies, not the operating system's.
+export async function printRowStream(rows, format, columns) {
+    const iterator = rows[Symbol.asyncIterator]();
     // One step before any write. FTS5 parses a MATCH expression at step time rather than at
     // prepare time, so a bad search string throws here, with stdout still clean for the error.
-    const first = iterator.next();
+    const first = await iterator.next();
     const rest = {
-        [Symbol.iterator]: ()=>iterator
+        [Symbol.asyncIterator]: ()=>iterator
     };
     if (format === 'table') {
-        printRows(first.done ? [] : [
-            first.value,
-            ...rest
-        ], format, columns);
+        const collected = first.done ? [] : [
+            first.value
+        ];
+        for await (const row of rest)collected.push(row);
+        printRows(collected, format, columns);
         return;
     }
     let bytes = 0;
@@ -76,19 +85,14 @@ export function printRowStream(rows, format, columns) {
     if (format === 'json') {
         // Byte-identical to JSON.stringify(rows, null, 2) + newline: each row re-indented one
         // level, comma-joined, inside the array brackets written here.
-        // JSON.stringify throws on BigInt, so a row with an int64 past 2^53 (setReadBigInts) is
-        // converted via the replacer: a value that fits a safe integer stays a number, a larger one
-        // becomes its decimal string, since a JSON number cannot carry it losslessly.
-        const MAX_SAFE = BigInt(Number.MAX_SAFE_INTEGER);
-        const bigintSafe = (_key, value)=>typeof value === 'bigint' ? value >= -MAX_SAFE && value <= MAX_SAFE ? Number(value) : value.toString() : value;
-        const indent = (row)=>JSON.stringify(row, bigintSafe, 2).split('\n').map((line)=>`  ${line}`).join('\n');
+        const indent = (row)=>stringifyJson(row, 2).split('\n').map((line)=>`  ${line}`).join('\n');
         if (first.done) {
             write('[]\n');
         } else {
             write('[\n');
             write(indent(first.value));
             rowCount = 1;
-            for (const row of rest){
+            for await (const row of rest){
                 write(',\n');
                 write(indent(row));
                 rowCount++;
@@ -105,7 +109,7 @@ export function printRowStream(rows, format, columns) {
         write(`${csvLine(names)}\n`);
         write(`${csvLine(names.map((name)=>first.value[name]))}\n`);
         rowCount = 1;
-        for (const row of rest){
+        for await (const row of rest){
             write(`${csvLine(names.map((name)=>row[name]))}\n`);
             rowCount++;
         }
@@ -130,7 +134,7 @@ function fitWidths(widths, limit) {
     }
 }
 function renderRows(rows, format, width = process.stdout.columns) {
-    if (format === 'json') return JSON.stringify(rows, null, 2);
+    if (format === 'json') return stringifyJson(rows, 2);
     if (rows.length === 0) return '(0 rows)';
     const columns = Object.keys(rows[0]);
     const cells = rows.map((row)=>columns.map((col)=>cell(row[col])));