sensemaking 0.17.0 → 0.18.0

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 { DatabaseSync } from 'node:sqlite';\nimport type { FileStat } from '../scan/index.ts';\nimport { maskRegions } from './fences.ts';\nimport type { Feature, ReconcileDelta } from './types.ts';\n\n// links(src, target, target_base, dst, embed): target as written, target_base its baseKey\n// (indexed, for the incremental resolve below), dst the resolved path or NULL (a\n// queryable dead link), embed whether it's `![[x]]`/`![](x.md)` rather than `[[x]]`/`[](x.md)`\n// -- Obsidian's grain: a target both linked and embedded in the same note is two rows.\n\n// Wikilinks ([[target]], [[target#anchor|alias]], embeds), internal markdown links, and\n// frontmatter values that are exactly a wikilink (\"[[X]]\"; mid-string and ![[...]] forms are\n// not links there -- Obsidian's rule, probe-verified).\n// One rule for [[inner]] text wherever it appears: alias stripped after |, a leading #\n// keeps the anchor as the target (a same-note self-link needs a heading name), otherwise\n// 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\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: Obsidian gives markdown links full\n  // linkpath resolution, so \\](Zektor) resolves like [[Zektor]] and \\](#anchor) is a\n  // self-edge. External URLs (a scheme anywhere survives the malformed double-paren case)\n  // and titled links (dest stops at whitespace) are skipped.\n  // A space in the destination is only valid ahead of a quoted title; a domain-shaped first\n  // segment (www.example.com/...) is external even without a scheme.\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\n// note's directory, then basename match (shortest path wins on ties -- verified against a\n// cold-loaded Obsidian vault on 6+ real collision pairs; byBase's lists are pre-sorted that way).\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// Applies resolveTarget to `rows`, writing only rows whose dst actually changes. The UPDATE\n// keys on (src, target): a link/embed sibling pair shares one resolution, so either row's\n// mismatch rewrites both.\nfunction resolveRows(db: DatabaseSync, rows: LinkRow[], pathSet: Set<string>, byBase: Map<string, string[]>): boolean {\n  const update = db.prepare('UPDATE links SET dst = ? WHERE src = ? AND target = ?');\n  let changed = false;\n  for (const row of rows) {\n    const dst = resolveTarget(row.src, row.target, pathSet, byBase);\n    if (dst !== row.dst) {\n      update.run(dst, row.src, row.target);\n      changed = true;\n    }\n  }\n  return changed;\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.\nfunction resolveAll(db: DatabaseSync, files: FileStat[]): boolean {\n  const pathSet = new Set(files.map((f) => f.relPath));\n  const byBase = buildByBase(files);\n  const rows = db.prepare('SELECT src, target, dst, embed FROM links').all() as unknown as LinkRow[];\n  return resolveRows(db, rows, pathSet, byBase);\n}\n\n// Re-resolve only what this reconcile could have touched: re-stored sources, links whose\n// target basename matches an added/vanished file, and links whose dst just vanished. All\n// three are indexed lookups, so this never reads the whole table.\nfunction resolveIncremental(db: DatabaseSync, delta: ReconcileDelta): 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  // Chunked so a large-but-under-threshold delta never exceeds SQLite's bound-variable\n  // limit (SQLITE_MAX_VARIABLE_NUMBER, 32766).\n  const collectIn = (column: string, keys: string[]) => {\n    for (let i = 0; i < keys.length; i += 500) {\n      const chunk = keys.slice(i, i + 500);\n      const placeholders = chunk.map(() => '?').join(', ');\n      collect(db.prepare(`SELECT src, target, dst, embed FROM links WHERE ${column} IN (${placeholders})`).all(...chunk) as unknown as LinkRow[]);\n    }\n  };\n\n  collectIn('src', delta.reparsed);\n  collectIn('target_base', [...changedBasenames]);\n  collectIn('dst', delta.vanished);\n\n  return resolveRows(db, [...candidates.values()], pathSet, byBase);\n}\n\n// Resolved edges, for rank and for search's graph expansion.\nexport function linkEdges(db: DatabaseSync): [string, string][] {\n  // One edge per row, as 0.12's grain always had it -- two written targets resolving to one\n  // dst stay two edges (a weight the fusion evals were gated on). The only exclusion is an\n  // embed whose exact (src, target) also exists as a link: that second row is new with the\n  // embed grain and would double an edge that used to be one row. The NOT EXISTS probes the\n  // primary key and fires only for embed rows; both branches still scan the table.\n  // Self-edges (same-note anchors) are excluded here so PageRank mass is not self-recycled --\n  // Obsidian's own graph view hides self-loops too. The rows themselves stay in the table for\n  // backlinks/peek.\n  const 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  return (db.prepare(sql).all() as Array<{ src: string; dst: string }>).map((r) => [r.src, r.dst]);\n}\n\n// remove() has already deleted the rows by the time afterReconcile runs, so it records here\n// whether they carried edges. Keyed on the delta object, so the state dies with the reconcile.\nconst removedWithLinks = new WeakMap<ReconcileDelta, Set<string>>();\n\nfunction recordRemoved(delta: ReconcileDelta, path: string): void {\n  let set = removedWithLinks.get(delta);\n  if (!set) {\n    set = new Set();\n    removedWithLinks.set(delta, set);\n  }\n  set.add(path);\n}\n\n// remove() runs per path; the vanished list is an array, so cache the Set per delta.\nconst vanishedSets = new WeakMap<ReconcileDelta, Set<string>>();\nfunction vanishedSet(delta: ReconcileDelta): Set<string> {\n  let set = vanishedSets.get(delta);\n  if (!set) {\n    set = new Set(delta.vanished);\n    vanishedSets.set(delta, set);\n  }\n  return set;\n}\n\nexport const links: Feature = {\n  name: 'links',\n  schema(db) {\n    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    db.exec('CREATE INDEX IF NOT EXISTS links_dst ON links(dst)');\n    db.exec('CREATE INDEX IF NOT EXISTS links_target_base ON links(target_base)');\n  },\n  extract,\n  // Reparsed docs are diffed in store() below instead of wiped here: deleting and\n  // re-inserting resets dst to NULL, which made every touch-only reparse read as an edge\n  // change and recompute PageRank -- measured as most of the remaining update cost.\n  remove(db, path, delta) {\n    if (!vanishedSet(delta).has(path)) return;\n    const result = db.prepare('DELETE FROM links WHERE src = ?').run(path);\n    if (Number(result.changes) > 0) recordRemoved(delta, path);\n  },\n  store(db, path, extracted, delta) {\n    const targets = extracted as Array<{ target: string; embed: boolean }>;\n    // Stale rows (target/embed pairs the new parse no longer contains) are real edge removals.\n    // \\0 can't appear in a target, so the composite key never collides.\n    let stale: ReturnType<ReturnType<DatabaseSync['prepare']>['run']>;\n    if (targets.length === 0) {\n      stale = db.prepare('DELETE FROM links WHERE src = ?').run(path);\n    } else {\n      const placeholders = targets.map(() => '?').join(', ');\n      const keys = targets.map((t) => `${t.target}\\0${t.embed ? '1' : '0'}`);\n      stale = db.prepare(`DELETE FROM links WHERE src = ? AND (target || char(0) || embed) NOT IN (${placeholders})`).run(path, ...keys);\n    }\n    if (Number(stale.changes) > 0) recordRemoved(delta, path);\n    // Upsert preserves dst on surviving rows, so an unchanged link resolves to the same\n    // value and reports no change; only genuinely new rows start at NULL.\n    const insert = db.prepare('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    // A same-note anchor's dst is always its own src, never another file's basename, so it\n    // gets no target_base -- SQL's `IN` never matches NULL, keeping it out of\n    // resolveIncremental's cross-file collectIn('target_base', ...) entirely.\n    for (const { target, embed } of targets) insert.run(path, target, target.startsWith('#') ? null : baseKey(cleanTarget(target)), embed ? 1 : 0);\n  },\n  afterReconcile(db, delta) {\n    // Any deleted rows that carried edges mean the edge set shrank -- whether the file\n    // vanished or was reparsed down to fewer/no links. dstChanged alone misses the\n    // reparsed-to-zero-links case (no surviving rows to re-resolve).\n    const removeHadLinks = (removedWithLinks.get(delta)?.size ?? 0) > 0;\n\n    const churn = delta.reparsed.length + delta.vanished.length;\n    // Past this share of the tree, a full pass is the only one guaranteed to match\n    // resolveTarget's ambiguity rules. A cold build clears the threshold on its own.\n    const large = delta.files.length === 0 || churn > 0.2 * delta.files.length;\n\n    const dstChanged = large ? resolveAll(db, delta.files) : resolveIncremental(db, delta);\n    delta.linksChanged = dstChanged || removeHadLinks;\n  },\n};\n"],"names":["linkEdges","links","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","db","rows","update","prepare","changed","row","dst","run","resolveAll","all","resolveIncremental","delta","changedBasenames","added","p","vanished","collect","collectIn","column","keys","i","chunk","slice","placeholders","reparsed","sql","r","removedWithLinks","WeakMap","recordRemoved","vanishedSets","vanishedSet","name","schema","remove","result","Number","changes","store","extracted","targets","stale","t","insert","afterReconcile","removeHadLinks","size","churn","large","dstChanged","linksChanged"],"mappings":"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"}
+{"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 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 baseKey\n// (indexed, for the incremental resolve below), dst the resolved path or NULL (a\n// queryable dead link), embed whether it's `![[x]]`/`![](x.md)` rather than `[[x]]`/`[](x.md)`\n// -- Obsidian's grain: a target both linked and embedded in the same note is two rows.\n\n// Wikilinks ([[target]], [[target#anchor|alias]], embeds), internal markdown links, and\n// frontmatter values that are exactly a wikilink (\"[[X]]\"; mid-string and ![[...]] forms are\n// not links there -- Obsidian's rule, probe-verified).\n// One rule for [[inner]] text wherever it appears: alias stripped after |, a leading #\n// keeps the anchor as the target (a same-note self-link needs a heading name), otherwise\n// 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\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: Obsidian gives markdown links full\n  // linkpath resolution, so \\](Zektor) resolves like [[Zektor]] and \\](#anchor) is a\n  // self-edge. External URLs (a scheme anywhere survives the malformed double-paren case)\n  // and titled links (dest stops at whitespace) are skipped.\n  // A space in the destination is only valid ahead of a quoted title; a domain-shaped first\n  // segment (www.example.com/...) is external even without a scheme.\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\n// note's directory, then basename match (shortest path wins on ties -- verified against a\n// cold-loaded Obsidian vault on 6+ real collision pairs; byBase's lists are pre-sorted that way).\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 just the rows whose dst actually changed -- the\n// caller writes those in one runBatch call, keyed on (src, target) so a link/embed sibling\n// pair sharing one resolution rewrites both.\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-resolve only what this reconcile could have touched: re-stored sources, links whose\n// target basename matches an added/vanished file, and links whose dst just vanished. All\n// three are indexed lookups, so this never reads the whole table.\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 row, as 0.12's grain always had it -- two written targets resolving to one\n// dst stay two edges (a weight the fusion evals were gated on). The only exclusion is an\n// embed whose exact (src, target) also exists as a link: that second row is new with the\n// embed grain and would double an edge that used to be one row. The NOT EXISTS probes the\n// primary key and fires only for embed rows; both branches still scan the table.\n// Self-edges (same-note anchors) are excluded here so PageRank mass is not self-recycled --\n// Obsidian's own graph view hides self-loops too. The rows themselves stay in the table for\n// backlinks/peek. Exported (not just linkEdges below) so commands/signals.ts's async caller,\n// which only has the Store's prepare(), can run the identical statement itself.\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// remove()/store() have already deleted rows by the time afterReconcile runs, so this records\n// whether any reconcile pass deleted at least one link row -- whether a file vanished, or a\n// reparse's stale rows shrank. dstChanged alone misses the reparsed-to-zero-links case (no\n// surviving rows to re-resolve). Keyed on the delta object, so the state dies with the reconcile.\nconst removedWithLinks = new WeakMap<ReconcileDelta, boolean>();\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() below instead of wiped here: deleting and re-inserting\n  // resets dst to NULL, which made every touch-only reparse read as an edge change and\n  // recompute PageRank -- measured as most of the remaining update cost. Only genuinely\n  // vanished files clear here.\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 (existing target/embed pairs the new parse no longer contains) are real edge\n    // removals; diffed in JS from one bulk SELECT rather than a per-file NOT IN statement, so\n    // this whole 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, so an unchanged link resolves to the same value\n    // and reports no change; only genuinely new rows start at NULL. A same-note anchor's dst is\n    // always its own src, never another file's basename, so it gets no target_base -- SQL's\n    // `IN` never matches NULL, keeping it out of resolveIncremental's target_base lookup.\n    const upsertRows: unknown[][] = [];\n    for (const [path, targets] of byPath) {\n      for (const { target, embed } of targets) upsertRows.push([path, target, target.startsWith('#') ? null : baseKey(cleanTarget(target)), embed ? 1 : 0]);\n    }\n    if (upsertRows.length > 0) {\n      await db.runBatch('INSERT INTO links (src, target, target_base, dst, embed) VALUES (?, ?, ?, NULL, ?) ON CONFLICT(src, target, embed) DO UPDATE SET target_base = excluded.target_base', upsertRows);\n    }\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    const churn = delta.reparsed.length + delta.vanished.length;\n    // Past this share of the tree, a full pass is the only one guaranteed to match\n    // resolveTarget's ambiguity rules. A cold build clears the threshold on its own.\n    const large = delta.files.length === 0 || churn > 0.2 * 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","name","schema","remove","vanishedSet","existingRows","filter","store","docs","byPath","addedSet","reparsedExisting","staleRows","upsertRows","targets","d","extracted","some","t","afterReconcile","removeHadLinks","churn","large","dstChanged","linksChanged"],"mappings":";;;;;;;;;;;QAgMaA;eAAAA;;QAUSC;eAAAA;;QAWTC;eAAAA;;QAhBGC;eAAAA;;;4DArME;wBAGU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAG5B,0FAA0F;AAC1F,iFAAiF;AACjF,+FAA+F;AAC/F,uFAAuF;AAEvF,wFAAwF;AACxF,6FAA6F;AAC7F,uDAAuD;AACvD,uFAAuF;AACvF,yFAAyF;AACzF,4CAA4C;AAC5C,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,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;;;;QAUA,mCAAA,4BAAA;;QANL,sFAAsF;QACtF,mFAAmF;QACnF,wFAAwF;QACxF,2DAA2D;QAC3D,0FAA0F;QAC1F,mEAAmE;QACnE,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,uFAAuF;AACvF,0FAA0F;AAC1F,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,6FAA6F;AAC7F,2FAA2F;AAC3F,6CAA6C;AAC7C,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,yFAAyF;AACzF,yFAAyF;AACzF,kEAAkE;AAClE,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;;AAWO,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,4FAA4F;AAC5F,2FAA2F;AAC3F,kGAAkG;AAClG,IAAM+F,mBAAmB,IAAIC;AAEtB,IAAMjG,QAAiB;IAC5BkG,MAAM;IACAC,QAAN,SAAMA,OAAOxB,EAAE;;;;;wBACb;;4BAAMA,GAAGtC,IAAI,CAAC;;;wBAAd;wBACA;;4BAAMsC,GAAGtC,IAAI,CAAC;;;wBAAd;wBACA;;4BAAMsC,GAAGtC,IAAI,CAAC;;;wBAAd;;;;;;QACF;;IACA3B,SAAAA;IAKM0F,QAJN,6FAA6F;IAC7F,qFAAqF;IACrF,sFAAsF;IACtF,6BAA6B;IAC7B,SAAMA,OAAOzB,EAAE,EAAEf,KAAK,EAAE6B,KAAK;;gBACrBY,aACAP,UAEAQ;;;;wBAHAD,cAAc,IAAIlF,IAAIsE,MAAMK,QAAQ;wBACpCA,WAAWlC,MAAM2C,MAAM,CAAC,SAACZ;mCAAMU,YAAY7E,GAAG,CAACmE;;wBACrD,IAAIG,SAAStF,MAAM,KAAK,GAAG;;;wBACN;;4BAAM0E,SAASP,IAAI,OAAOmB;;;wBAAzCQ,eAAe;wBACrB;;4BAAM3B,GAAGC,QAAQ,CACf,mCACAkB,SAASjC,GAAG,CAAC,SAAC8B;uCAAM;oCAACA;iCAAE;;;;wBAFzB;wBAIA,IAAIW,aAAa9F,MAAM,GAAG,GAAGwF,iBAAiB5B,GAAG,CAACqB,OAAO;;;;;;QAC3D;;IACMe,OAAN,SAAMA,MAAM7B,EAAE,EAAE8B,IAAoB,EAAEhB,KAAK;;gBACnCiB,QACAC,UACAC,kBAKAN,cACAO,WAgBAC,YACD,2BAAA,mBAAA,gBAAA,WAAA,oBAAOrE,MAAMsE,SACX,4BAAA,oBAAA,iBAAA,YAAA,sBAAQtG,QAAQa;;;;wBA1BjBoF,SAAS,IAAI/C,IAAI8C,KAAK5C,GAAG,CAAC,SAACmD;mCAAM;gCAACA,EAAEvE,IAAI;gCAAEuE,EAAEC,SAAS;6BAA8C;;wBACnGN,WAAW,IAAIxF,IAAIsE,MAAMI,KAAK;wBAC9Be,mBAAmBH,KAAK5C,GAAG,CAAC,SAACmD;mCAAMA,EAAEvE,IAAI;2BAAE8D,MAAM,CAAC,SAACZ;mCAAM,CAACgB,SAASnF,GAAG,CAACmE;;wBAKxD;;4BAAMT,SAASP,IAAI,OAAOiC;;;wBAAzCN,eAAe;wBACfO,YAAYP,aAAaC,MAAM,CAAC,SAAC/B;gCACrBkC;4BAAhB,IAAMK,WAAUL,cAAAA,OAAOlD,GAAG,CAACgB,IAAI1B,GAAG,eAAlB4D,yBAAAA,cAAuB,EAAE;4BACzC,OAAO,CAACK,QAAQG,IAAI,CAAC,SAACC;uCAAMA,EAAE1G,MAAM,KAAK+D,IAAI/D,MAAM,IAAI,AAAC0G,CAAAA,EAAE7F,KAAK,GAAG,IAAI,CAAA,MAAOkD,IAAIlD,KAAK;;wBACxF;6BACIuF,CAAAA,UAAUrG,MAAM,GAAG,CAAA,GAAnBqG;;;;wBACF;;4BAAMlC,GAAGC,QAAQ,CACf,gEACAiC,UAAUhD,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,4FAA4F;wBAC5F,wFAAwF;wBACxF,sFAAsF;wBAChFqB;wBACD,kCAAA,2BAAA;;4BAAL,IAAK,YAAyBJ,6BAAzB,6BAAA,QAAA,yBAAA,iCAAiC;+DAAjC,iBAAOjE,uBAAMsE;gCACX,mCAAA,4BAAA;;oCAAL,IAAK,aAA2BA,8BAA3B,8BAAA,SAAA,0BAAA;uDAAA,cAAQtG,sBAAAA,QAAQa,qBAAAA;wCAAoBwF,WAAWrF,IAAI;4CAAEgB;4CAAMhC;4CAAQA,OAAOF,UAAU,CAAC,OAAO,OAAOiC,QAAQF,YAAY7B;4CAAUa,QAAQ,IAAI;;;;oCAA7I;oCAAA;;;6CAAA,8BAAA;4CAAA;;;4CAAA;kDAAA;;;;4BACP;;4BAFK;4BAAA;;;qCAAA,6BAAA;oCAAA;;;oCAAA;0CAAA;;;;6BAGDwF,CAAAA,WAAWtG,MAAM,GAAG,CAAA,GAApBsG;;;;wBACF;;4BAAMnC,GAAGC,QAAQ,CAAC,uKAAuKkC;;;wBAAzL;;;;;;;;QAEJ;;IACMM,gBAAN,SAAMA,eAAezC,EAAE,EAAEc,KAAK;;gBAGLO,uBAAjBqB,gBAEAC,OAGAC,OAEAC;;;;wBATN,yFAAyF;wBACzF,0BAA0B;wBACpBH,kBAAiBrB,wBAAAA,iBAAiBxC,GAAG,CAACiC,oBAArBO,mCAAAA,wBAA+B;wBAEhDsB,QAAQ7B,MAAMM,QAAQ,CAACvF,MAAM,GAAGiF,MAAMK,QAAQ,CAACtF,MAAM;wBAC3D,+EAA+E;wBAC/E,iFAAiF;wBAC3E+G,QAAQ9B,MAAM/B,KAAK,CAAClD,MAAM,KAAK,KAAK8G,QAAQ,MAAM7B,MAAM/B,KAAK,CAAClD,MAAM;6BAEvD+G,OAAAA;;;;wBAAQ;;4BAAMzC,WAAWH,IAAIc,MAAM/B,KAAK;;;+BAAhC;;;;;;wBAAoC;;4BAAM8B,mBAAmBb,IAAIc;;;+BAA7B;;;wBAAzD+B;wBACN/B,MAAMgC,YAAY,GAAGD,cAAcH;;;;;;QACrC;;AACF"}

package/dist/cjs/features/rank.js

@@ -18,6 +18,40 @@ function _array_like_to_array(arr, len) {
 function _array_with_holes(arr) {
     if (Array.isArray(arr)) return arr;
 }
+function _array_without_holes(arr) {
+    if (Array.isArray(arr)) return _array_like_to_array(arr);
+}
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
+    try {
+        var info = gen[key](arg);
+        var value = info.value;
+    } catch (error) {
+        reject(error);
+        return;
+    }
+    if (info.done) resolve(value);
+    else Promise.resolve(value).then(_next, _throw);
+}
+function _async_to_generator(fn) {
+    return function() {
+        var self = this, args = arguments;
+        return new Promise(function(resolve, reject) {
+            var gen = fn.apply(self, args);
+            function _next(value) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
+            }
+            function _throw(err) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
+            }
+            _next(undefined);
+        });
+    };
+}
+function _iterable_to_array(iter) {
+    if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) {
+        return Array.from(iter);
+    }
+}
 function _iterable_to_array_limit(arr, i) {
     var _i = arr == null ? null : typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"];
     if (_i == null) return;
@@ -45,9 +79,114 @@ function _iterable_to_array_limit(arr, i) {
 function _non_iterable_rest() {
     throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
 }
+function _non_iterable_spread() {
+    throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
 function _sliced_to_array(arr, i) {
     return _array_with_holes(arr) || _iterable_to_array_limit(arr, i) || _unsupported_iterable_to_array(arr, i) || _non_iterable_rest();
 }
+function _to_consumable_array(arr) {
+    return _array_without_holes(arr) || _iterable_to_array(arr) || _unsupported_iterable_to_array(arr) || _non_iterable_spread();
+}
+function _ts_generator(thisArg, body) {
+    var f, y, t, _ = {
+        label: 0,
+        sent: function() {
+            if (t[0] & 1) throw t[1];
+            return t[1];
+        },
+        trys: [],
+        ops: []
+    }, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype), d = Object.defineProperty;
+    return d(g, "next", {
+        value: verb(0)
+    }), d(g, "throw", {
+        value: verb(1)
+    }), d(g, "return", {
+        value: verb(2)
+    }), typeof Symbol === "function" && d(g, Symbol.iterator, {
+        value: function() {
+            return this;
+        }
+    }), g;
+    function verb(n) {
+        return function(v) {
+            return step([
+                n,
+                v
+            ]);
+        };
+    }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while(g && (g = 0, op[0] && (_ = 0)), _)try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [
+                op[0] & 2,
+                t.value
+            ];
+            switch(op[0]){
+                case 0:
+                case 1:
+                    t = op;
+                    break;
+                case 4:
+                    _.label++;
+                    return {
+                        value: op[1],
+                        done: false
+                    };
+                case 5:
+                    _.label++;
+                    y = op[1];
+                    op = [
+                        0
+                    ];
+                    continue;
+                case 7:
+                    op = _.ops.pop();
+                    _.trys.pop();
+                    continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) {
+                        _ = 0;
+                        continue;
+                    }
+                    if (op[0] === 3 && (!t || op[1] > t[0] && op[1] < t[3])) {
+                        _.label = op[1];
+                        break;
+                    }
+                    if (op[0] === 6 && _.label < t[1]) {
+                        _.label = t[1];
+                        t = op;
+                        break;
+                    }
+                    if (t && _.label < t[2]) {
+                        _.label = t[2];
+                        _.ops.push(op);
+                        break;
+                    }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop();
+                    continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) {
+            op = [
+                6,
+                e
+            ];
+            y = 0;
+        } finally{
+            f = t = 0;
+        }
+        if (op[0] & 5) throw op[1];
+        return {
+            value: op[0] ? op[1] : void 0,
+            done: true
+        };
+    }
+}
 function _unsupported_iterable_to_array(o, minLen) {
     if (!o) return;
     if (typeof o === "string") return _array_like_to_array(o, minLen);
@@ -59,40 +198,101 @@ function _unsupported_iterable_to_array(o, minLen) {
 var rank = {
     name: 'rank',
     schema: function schema(db) {
-        var columns = db.prepare('PRAGMA table_info(frontmatter)').all();
-        if (!columns.some(function(c) {
-            return c.name === '_rank';
-        })) db.exec('ALTER TABLE frontmatter ADD COLUMN "_rank" REAL');
+        return _async_to_generator(function() {
+            var stmt, columns;
+            return _ts_generator(this, function(_state) {
+                switch(_state.label){
+                    case 0:
+                        return [
+                            4,
+                            db.prepare('PRAGMA table_info(frontmatter)')
+                        ];
+                    case 1:
+                        stmt = _state.sent();
+                        return [
+                            4,
+                            stmt.all()
+                        ];
+                    case 2:
+                        columns = _state.sent();
+                        if (!!columns.some(function(c) {
+                            return c.name === '_rank';
+                        })) return [
+                            3,
+                            4
+                        ];
+                        return [
+                            4,
+                            db.exec('ALTER TABLE frontmatter ADD COLUMN "_rank" REAL')
+                        ];
+                    case 3:
+                        _state.sent();
+                        _state.label = 4;
+                    case 4:
+                        return [
+                            2
+                        ];
+                }
+            });
+        })();
     },
     afterReconcile: function afterReconcile(db, delta) {
-        // Only an explicit linksChanged:false skips. Rank also depends on the node set, so any
-        // add or vanish recomputes -- otherwise a new linkless note keeps _rank NULL.
-        if (delta.linksChanged === false && delta.added.length === 0 && delta.vanished.length === 0) return;
-        var nodes = db.prepare('SELECT "path" FROM frontmatter').all().map(function(r) {
-            return r.path;
-        });
-        var ranks = (0, _graphts.pagerank)(nodes, (0, _linksts.linkEdges)(db));
-        var update = db.prepare('UPDATE frontmatter SET "_rank" = ? WHERE "path" = ?');
-        var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
-        try {
-            for(var _iterator = ranks[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
-                var _step_value = _sliced_to_array(_step.value, 2), path = _step_value[0], value = _step_value[1];
-                update.run(value, path);
-            }
-        } catch (err) {
-            _didIteratorError = true;
-            _iteratorError = err;
-        } finally{
-            try {
-                if (!_iteratorNormalCompletion && _iterator.return != null) {
-                    _iterator.return();
+        return _async_to_generator(function() {
+            var pathsStmt, nodes, ranks, _tmp;
+            return _ts_generator(this, function(_state) {
+                switch(_state.label){
+                    case 0:
+                        // Only an explicit linksChanged:false skips. Rank also depends on the node set, so any
+                        // add or vanish recomputes -- otherwise a new linkless note keeps _rank NULL.
+                        if (delta.linksChanged === false && delta.added.length === 0 && delta.vanished.length === 0) return [
+                            2
+                        ];
+                        return [
+                            4,
+                            db.prepare('SELECT "path" FROM frontmatter')
+                        ];
+                    case 1:
+                        pathsStmt = _state.sent();
+                        return [
+                            4,
+                            pathsStmt.all()
+                        ];
+                    case 2:
+                        nodes = _state.sent().map(function(r) {
+                            return r.path;
+                        });
+                        _tmp = [
+                            nodes
+                        ];
+                        return [
+                            4,
+                            (0, _linksts.linkEdges)(db)
+                        ];
+                    case 3:
+                        ranks = _graphts.pagerank.apply(void 0, _tmp.concat([
+                            _state.sent()
+                        ]));
+                        if (ranks.size === 0) return [
+                            2
+                        ];
+                        return [
+                            4,
+                            db.runBatch('UPDATE frontmatter SET "_rank" = ? WHERE "path" = ?', _to_consumable_array(ranks).map(function(param) {
+                                var _param = _sliced_to_array(param, 2), path = _param[0], value = _param[1];
+                                return [
+                                    value,
+                                    path
+                                ];
+                            }))
+                        ];
+                    case 4:
+                        _state.sent();
+                        return [
+                            2
+                        ];
                 }
-            } finally{
-                if (_didIteratorError) {
-                    throw _iteratorError;
-                }
-            }
-        }
+            });
+        })();
     }
 };
 /* CJS INTEROP */ if (exports.__esModule && exports.default) { try { Object.defineProperty(exports.default, '__esModule', { value: true }); for (var key in exports) { exports.default[key] = exports[key]; } } catch (_) {}; module.exports = exports.default; }

package/dist/cjs/features/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":["rank","name","schema","db","columns","prepare","all","some","c","exec","afterReconcile","delta","linksChanged","added","length","vanished","nodes","map","r","path","ranks","pagerank","linkEdges","update","value","run"],"mappings":";;;;+BAOaA;;;eAAAA;;;uBAPY;uBACC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAMnB,IAAMA,OAAgB;IAC3BC,MAAM;IACNC,QAAAA,SAAAA,OAAOC,EAAE;QACP,IAAMC,UAAUD,GAAGE,OAAO,CAAC,kCAAkCC,GAAG;QAChE,IAAI,CAACF,QAAQG,IAAI,CAAC,SAACC;mBAAMA,EAAEP,IAAI,KAAK;YAAUE,GAAGM,IAAI,CAAC;IACxD;IACAC,gBAAAA,SAAAA,eAAeP,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,IAAME,QAAQ,AAACb,GAAGE,OAAO,CAAC,kCAAkCC,GAAG,GAA+BW,GAAG,CAAC,SAACC;mBAAMA,EAAEC,IAAI;;QAC/G,IAAMC,QAAQC,IAAAA,iBAAQ,EAACL,OAAOM,IAAAA,kBAAS,EAACnB;QACxC,IAAMoB,SAASpB,GAAGE,OAAO,CAAC;YACrB,kCAAA,2BAAA;;YAAL,QAAK,YAAuBe,0BAAvB,SAAA,6BAAA,QAAA,yBAAA;gBAAA,mCAAA,iBAAOD,uBAAMK;gBAAiBD,OAAOE,GAAG,CAACD,OAAOL;;;YAAhD;YAAA;;;qBAAA,6BAAA;oBAAA;;;oBAAA;0BAAA;;;;IACP;AACF"}
+{"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":["rank","name","schema","db","stmt","columns","prepare","all","some","c","exec","afterReconcile","delta","pathsStmt","nodes","ranks","linksChanged","added","length","vanished","map","r","path","linkEdges","pagerank","size","runBatch","value"],"mappings":";;;;+BAOaA;;;eAAAA;;;uBAPY;uBACC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAMnB,IAAMA,OAAgB;IAC3BC,MAAM;IACAC,QAAN,SAAMA,OAAOC,EAAE;;gBACPC,MACAC;;;;wBADO;;4BAAMF,GAAGG,OAAO,CAAC;;;wBAAxBF,OAAO;wBACI;;4BAAMA,KAAKG,GAAG;;;wBAAzBF,UAAW;6BACb,CAACA,QAAQG,IAAI,CAAC,SAACC;mCAAMA,EAAER,IAAI,KAAK;4BAAhC;;;;wBAA0C;;4BAAME,GAAGO,IAAI,CAAC;;;wBAAd;;;;;;;;QAChD;;IACMC,gBAAN,SAAMA,eAAeR,EAAE,EAAES,KAAK;;gBAItBC,WACAC,OACAC;;;;wBALN,uFAAuF;wBACvF,8EAA8E;wBAC9E,IAAIH,MAAMI,YAAY,KAAK,SAASJ,MAAMK,KAAK,CAACC,MAAM,KAAK,KAAKN,MAAMO,QAAQ,CAACD,MAAM,KAAK,GAAG;;;wBAC3E;;4BAAMf,GAAGG,OAAO,CAAC;;;wBAA7BO,YAAY;wBACF;;4BAAMA,UAAUN,GAAG;;;wBAA7BO,QAAQ,AAAE,cAAmDM,GAAG,CAAC,SAACC;mCAAMA,EAAEC,IAAI;;;4BAC7DR;;wBAAO;;4BAAMS,IAAAA,kBAAS,EAACpB;;;wBAAxCY,QAAQS,iBAAQ;4BAAQ;;wBAC9B,IAAIT,MAAMU,IAAI,KAAK,GAAG;;;wBACtB;;4BAAMtB,GAAGuB,QAAQ,CACf,uDACA,AAAC,qBAAGX,OAAOK,GAAG,CAAC;yEAAEE,kBAAMK;uCAAW;oCAACA;oCAAOL;iCAAK;;;;wBAFjD;;;;;;QAIF;;AACF"}