sensemaking 0.27.0 → 0.28.0

package/dist/cjs/commands/peek.js.map

@@ -1 +1 @@
-{"version":3,"sources":["/Users/kevin/Dev/OpenSource/ai/sensemaking/src/commands/peek.ts"],"sourcesContent":["import posix from 'node:path/posix';\nimport { estimateTokens } from '../chunk/index.ts';\nimport type { FeatureName, ResolvedConfig, SearchOverrides } from '../config/index.ts';\nimport { featureEnabled } from '../config/index.ts';\nimport { SenseError } from '../errors.ts';\nimport { serialQuery } from '../lib/serial-query.ts';\nimport type { Row } from '../output/output.ts';\nimport type { Store } from '../store/types.ts';\nimport { INTERNAL_COLUMNS, materializeScope, scopedPaths } from './scope.ts';\nimport { assertQuerySnapshot } from './snapshot.ts';\n\n// Note resolution shared by peek and path: an exact path, or a unique basename (case\n// insensitive, .md stripped).\nexport function resolveNote(paths: string[], arg: string): string {\n  const exact = paths.find((p) => p === arg);\n  if (exact) return exact;\n  const base = posix.basename(arg).replace(/\\.md$/i, '').toLowerCase();\n  const matches = paths.filter((p) => posix.basename(p).replace(/\\.md$/i, '').toLowerCase() === base);\n  if (matches.length === 1) return matches[0];\n  if (matches.length > 1) throw new SenseError('NOTE_AMBIGUOUS', `\"${arg}\" is ambiguous: ${matches.join(', ')}`);\n  throw new SenseError('NOTE_NOT_FOUND', `no note matches \"${arg}\"`);\n}\n\n/** Structured, bounded metadata returned by the root {@link peek} API. */\nexport interface Peek {\n  path: string;\n  tokens: number;\n  frontmatter: Row;\n  /** Set when frontmatter parsing failed, distinguishing that case from an empty block. */\n  parseError: string | null;\n  sections: PeekSection[];\n  outbound: string[];\n  backlinks: string[];\n  unresolved: string[];\n  /** Totals before each bounded list is truncated. */\n  sectionsTotal: number;\n  outboundTotal: number;\n  backlinksTotal: number;\n  unresolvedTotal: number;\n  /** Disabled features whose result blocks are omitted rather than returned empty. */\n  off: FeatureName[];\n}\n\n/** A section description, with an inclusive source line range and token estimate, not section prose. */\nexport interface PeekSection {\n  level: number;\n  heading: string;\n  start_line: number;\n  end_line: number;\n  tokens: number;\n}\n\n/** Options for the root {@link peek} API. */\nexport interface PeekOptions extends SearchOverrides {\n  /** Maximum section descriptions. Defaults to 20; must be a positive safe integer. */\n  sectionCountLimit?: number;\n  /** Maximum entries in each link group independently. Defaults to 20; must be a positive safe integer. */\n  linkCountLimit?: number;\n}\n\nconst PEEK_COUNT_LIMIT = 20;\n\n/**\n * Returns indexed metadata for a note in scope. Exact excluded paths fail before scoped basename\n * resolution; resolved neighbors stay in scope, while unresolved written targets remain visible.\n */\nexport function peek(store: Store, cfg: ResolvedConfig, pathArg: string, overrides: PeekOptions = {}): Promise<Peek> {\n  return serialQuery(store, () => peekIndexed(store, cfg, pathArg, overrides));\n}\n\nasync function peekIndexed(store: Store, cfg: ResolvedConfig, pathArg: string, overrides: PeekOptions): Promise<Peek> {\n  for (const name of ['sectionCountLimit', 'linkCountLimit'] as const) {\n    const value = overrides[name];\n    if (value !== undefined && (!Number.isSafeInteger(value) || value <= 0)) {\n      throw new SenseError('SEARCH_OPTION_INVALID', `peek option \"${name}\" must be a positive safe integer, got ${String(value)}`);\n    }\n  }\n  const sectionCountLimit = overrides.sectionCountLimit ?? PEEK_COUNT_LIMIT;\n  const linkCountLimit = overrides.linkCountLimit ?? PEEK_COUNT_LIMIT;\n  return store.transaction(async () => {\n    await assertQuerySnapshot(store, cfg);\n    const pathsStmt = await store.prepare('SELECT \"path\" FROM frontmatter');\n    const paths = ((await pathsStmt.all()) as Array<{ path: string }>).map((r) => r.path);\n    const allowed = await scopedPaths(store, cfg, overrides);\n    if (paths.includes(pathArg) && !allowed.has(pathArg)) {\n      throw new SenseError('NOTE_NOT_FOUND', `note \"${pathArg}\" exists but is outside the current scope; change the preset, include/exclude patterns, or where condition`);\n    }\n    let path: string;\n    try {\n      path = resolveNote([...allowed], pathArg);\n    } catch (err) {\n      if (err instanceof SenseError && err.code === 'NOTE_NOT_FOUND') {\n        let excludedPath: string;\n        try {\n          excludedPath = resolveNote(paths, pathArg);\n        } catch (unscopedErr) {\n          if (unscopedErr instanceof SenseError && unscopedErr.code === 'NOTE_AMBIGUOUS') {\n            throw new SenseError('NOTE_NOT_FOUND', `no note in the current scope matches \"${pathArg}\"; indexed matches exist outside the scope, so change the preset, include/exclude patterns, or where condition`);\n          }\n          throw err;\n        }\n        throw new SenseError('NOTE_NOT_FOUND', `note \"${excludedPath}\" exists but is outside the current scope; change the preset, include/exclude patterns, or where condition`);\n      }\n      throw err;\n    }\n\n    const rowStmt = await store.prepare('SELECT * FROM frontmatter WHERE \"path\" = ?');\n    const row = (await rowStmt.get(path)) as Row;\n    const parseError = (row._parse_error as string | null) ?? null;\n    const frontmatter: Row = {};\n    for (const [key, value] of Object.entries(row)) {\n      if (!INTERNAL_COLUMNS.has(key) && value !== null) frontmatter[key] = value;\n    }\n\n    let sectionsTotal = 0;\n    let sections: PeekSection[] = [];\n    if (featureEnabled(cfg, 'sections')) {\n      sectionsTotal = ((await (await store.prepare('SELECT COUNT(*) AS n FROM sections WHERE \"path\" = ?')).get(path)) as { n: number }).n;\n      sections = (await (await store.prepare('SELECT level, heading, start_line, end_line, tokens FROM sections WHERE \"path\" = ? ORDER BY idx LIMIT ?')).all(path, sectionCountLimit)) as PeekSection[];\n    }\n\n    let outbound: string[] = [];\n    let backlinks: string[] = [];\n    let unresolved: string[] = [];\n    let outboundTotal = 0;\n    let backlinksTotal = 0;\n    let unresolvedTotal = 0;\n    if (featureEnabled(cfg, 'links')) {\n      await materializeScope(store, '_peek_scope', allowed);\n      outboundTotal = ((await (await store.prepare('SELECT COUNT(DISTINCT dst) AS n FROM links WHERE src = ? AND dst != src AND dst IN (SELECT \"path\" FROM _peek_scope)')).get(path)) as { n: number }).n;\n      // The first written target determines each resolved destination's position.\n      outbound = ((await (await store.prepare('SELECT dst FROM links WHERE src = ? AND dst != src AND dst IN (SELECT \"path\" FROM _peek_scope) GROUP BY dst ORDER BY MIN(target) LIMIT ?')).all(path, linkCountLimit)) as Array<{ dst: string }>).map((r) => r.dst);\n      unresolvedTotal = ((await (await store.prepare('SELECT COUNT(*) AS n FROM links WHERE src = ? AND dst IS NULL')).get(path)) as { n: number }).n;\n      unresolved = ((await (await store.prepare('SELECT target FROM links WHERE src = ? AND dst IS NULL ORDER BY target LIMIT ?')).all(path, linkCountLimit)) as Array<{ target: string }>).map((r) => r.target);\n      backlinksTotal = ((await (await store.prepare('SELECT COUNT(DISTINCT src) AS n FROM links WHERE dst = ? AND src != dst AND src IN (SELECT \"path\" FROM _peek_scope)')).get(path)) as { n: number }).n;\n      backlinks = ((await (await store.prepare('SELECT DISTINCT src FROM links WHERE dst = ? AND src != dst AND src IN (SELECT \"path\" FROM _peek_scope) ORDER BY src LIMIT ?')).all(path, linkCountLimit)) as Array<{ src: string }>).map((r) => r.src);\n    }\n\n    // content.text is the stripped body already computed at reconcile time (no extra file read),\n    // floored by the byte/4 estimate so stripped-away syntax and frontmatter can't vanish from the price.\n    const body = ((await (await store.prepare('SELECT text FROM content WHERE \"path\" = ?')).get(path)) as { text: string } | undefined)?.text;\n    const byteTokens = Math.ceil(((row._size as number) ?? 0) / 4);\n    const tokens = body !== undefined ? Math.max(Math.ceil(estimateTokens(body)), byteTokens) : byteTokens;\n\n    return {\n      path,\n      tokens,\n      frontmatter,\n      parseError,\n      sections,\n      outbound,\n      backlinks,\n      unresolved,\n      sectionsTotal,\n      outboundTotal,\n      backlinksTotal,\n      unresolvedTotal,\n      off: (['sections', 'links'] as FeatureName[]).filter((name) => !featureEnabled(cfg, name)),\n    };\n  });\n}\n"],"names":["peek","resolveNote","paths","arg","exact","find","p","base","posix","basename","replace","toLowerCase","matches","filter","length","SenseError","join","PEEK_COUNT_LIMIT","store","cfg","pathArg","overrides","serialQuery","peekIndexed","name","value","sectionCountLimit","linkCountLimit","undefined","Number","isSafeInteger","String","transaction","row","pathsStmt","allowed","path","excludedPath","rowStmt","parseError","frontmatter","key","sectionsTotal","sections","outbound","backlinks","unresolved","outboundTotal","backlinksTotal","unresolvedTotal","body","byteTokens","tokens","assertQuerySnapshot","prepare","all","map","r","scopedPaths","includes","has","err","code","unscopedErr","get","_parse_error","Object","entries","INTERNAL_COLUMNS","featureEnabled","n","materializeScope","dst","target","src","text","Math","ceil","_size","max","estimateTokens","off"],"mappings":"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"}
+{"version":3,"sources":["/Users/kevin/Dev/open-source/ai/sensemaking/src/commands/peek.ts"],"sourcesContent":["import posix from 'node:path/posix';\nimport { estimateTokens } from '../chunk/index.ts';\nimport type { FeatureName, ResolvedConfig, SearchOverrides } from '../config/index.ts';\nimport { featureEnabled } from '../config/index.ts';\nimport { SenseError } from '../errors.ts';\nimport { serialQuery } from '../lib/serial-query.ts';\nimport type { Row } from '../output/output.ts';\nimport type { Store } from '../store/types.ts';\nimport { INTERNAL_COLUMNS, materializeScope, scopedPaths } from './scope.ts';\nimport { assertQuerySnapshot } from './snapshot.ts';\n\n// Note resolution shared by peek and path: an exact path, or a unique basename (case\n// insensitive, .md stripped).\nexport function resolveNote(paths: string[], arg: string): string {\n  const exact = paths.find((p) => p === arg);\n  if (exact) return exact;\n  const base = posix.basename(arg).replace(/\\.md$/i, '').toLowerCase();\n  const matches = paths.filter((p) => posix.basename(p).replace(/\\.md$/i, '').toLowerCase() === base);\n  if (matches.length === 1) return matches[0];\n  if (matches.length > 1) throw new SenseError('NOTE_AMBIGUOUS', `\"${arg}\" is ambiguous: ${matches.join(', ')}`);\n  throw new SenseError('NOTE_NOT_FOUND', `no note matches \"${arg}\"`);\n}\n\n/** Structured, bounded metadata returned by the root {@link peek} API. */\nexport interface Peek {\n  path: string;\n  tokens: number;\n  frontmatter: Row;\n  /** Set when frontmatter parsing failed, distinguishing that case from an empty block. */\n  parseError: string | null;\n  sections: PeekSection[];\n  outbound: string[];\n  backlinks: string[];\n  unresolved: string[];\n  /** Totals before each bounded list is truncated. */\n  sectionsTotal: number;\n  outboundTotal: number;\n  backlinksTotal: number;\n  unresolvedTotal: number;\n  /** Disabled features whose result blocks are omitted rather than returned empty. */\n  off: FeatureName[];\n}\n\n/** A section description, with an inclusive source line range and token estimate, not section prose. */\nexport interface PeekSection {\n  level: number;\n  heading: string;\n  start_line: number;\n  end_line: number;\n  tokens: number;\n}\n\n/** Options for the root {@link peek} API. */\nexport interface PeekOptions extends SearchOverrides {\n  /** Maximum section descriptions. Defaults to 20; must be a positive safe integer. */\n  sectionCountLimit?: number;\n  /** Maximum entries in each link group independently. Defaults to 20; must be a positive safe integer. */\n  linkCountLimit?: number;\n}\n\nconst PEEK_COUNT_LIMIT = 20;\n\n/**\n * Returns indexed metadata for a note in scope. Exact excluded paths fail before scoped basename\n * resolution; resolved neighbors stay in scope, while unresolved written targets remain visible.\n */\nexport function peek(store: Store, cfg: ResolvedConfig, pathArg: string, overrides: PeekOptions = {}): Promise<Peek> {\n  return serialQuery(store, () => peekIndexed(store, cfg, pathArg, overrides));\n}\n\nasync function peekIndexed(store: Store, cfg: ResolvedConfig, pathArg: string, overrides: PeekOptions): Promise<Peek> {\n  for (const name of ['sectionCountLimit', 'linkCountLimit'] as const) {\n    const value = overrides[name];\n    if (value !== undefined && (!Number.isSafeInteger(value) || value <= 0)) {\n      throw new SenseError('SEARCH_OPTION_INVALID', `peek option \"${name}\" must be a positive safe integer, got ${String(value)}`);\n    }\n  }\n  const sectionCountLimit = overrides.sectionCountLimit ?? PEEK_COUNT_LIMIT;\n  const linkCountLimit = overrides.linkCountLimit ?? PEEK_COUNT_LIMIT;\n  return store.transaction(async () => {\n    await assertQuerySnapshot(store, cfg);\n    const pathsStmt = await store.prepare('SELECT \"path\" FROM frontmatter');\n    const paths = ((await pathsStmt.all()) as Array<{ path: string }>).map((r) => r.path);\n    const allowed = await scopedPaths(store, cfg, overrides);\n    if (paths.includes(pathArg) && !allowed.has(pathArg)) {\n      throw new SenseError('NOTE_NOT_FOUND', `note \"${pathArg}\" exists but is outside the current scope; change the preset, include/exclude patterns, or where condition`);\n    }\n    let path: string;\n    try {\n      path = resolveNote([...allowed], pathArg);\n    } catch (err) {\n      if (err instanceof SenseError && err.code === 'NOTE_NOT_FOUND') {\n        let excludedPath: string;\n        try {\n          excludedPath = resolveNote(paths, pathArg);\n        } catch (unscopedErr) {\n          if (unscopedErr instanceof SenseError && unscopedErr.code === 'NOTE_AMBIGUOUS') {\n            throw new SenseError('NOTE_NOT_FOUND', `no note in the current scope matches \"${pathArg}\"; indexed matches exist outside the scope, so change the preset, include/exclude patterns, or where condition`);\n          }\n          throw err;\n        }\n        throw new SenseError('NOTE_NOT_FOUND', `note \"${excludedPath}\" exists but is outside the current scope; change the preset, include/exclude patterns, or where condition`);\n      }\n      throw err;\n    }\n\n    const rowStmt = await store.prepare('SELECT * FROM frontmatter WHERE \"path\" = ?');\n    const row = (await rowStmt.get(path)) as Row;\n    const parseError = (row._parse_error as string | null) ?? null;\n    const frontmatter: Row = {};\n    for (const [key, value] of Object.entries(row)) {\n      if (!INTERNAL_COLUMNS.has(key) && value !== null) frontmatter[key] = value;\n    }\n\n    let sectionsTotal = 0;\n    let sections: PeekSection[] = [];\n    if (featureEnabled(cfg, 'sections')) {\n      sectionsTotal = ((await (await store.prepare('SELECT COUNT(*) AS n FROM sections WHERE \"path\" = ?')).get(path)) as { n: number }).n;\n      sections = (await (await store.prepare('SELECT level, heading, start_line, end_line, tokens FROM sections WHERE \"path\" = ? ORDER BY idx LIMIT ?')).all(path, sectionCountLimit)) as PeekSection[];\n    }\n\n    let outbound: string[] = [];\n    let backlinks: string[] = [];\n    let unresolved: string[] = [];\n    let outboundTotal = 0;\n    let backlinksTotal = 0;\n    let unresolvedTotal = 0;\n    if (featureEnabled(cfg, 'links')) {\n      await materializeScope(store, '_peek_scope', allowed);\n      outboundTotal = ((await (await store.prepare('SELECT COUNT(DISTINCT dst) AS n FROM links WHERE src = ? AND dst != src AND dst IN (SELECT \"path\" FROM _peek_scope)')).get(path)) as { n: number }).n;\n      // The first written target determines each resolved destination's position.\n      outbound = ((await (await store.prepare('SELECT dst FROM links WHERE src = ? AND dst != src AND dst IN (SELECT \"path\" FROM _peek_scope) GROUP BY dst ORDER BY MIN(target) LIMIT ?')).all(path, linkCountLimit)) as Array<{ dst: string }>).map((r) => r.dst);\n      unresolvedTotal = ((await (await store.prepare('SELECT COUNT(*) AS n FROM links WHERE src = ? AND dst IS NULL')).get(path)) as { n: number }).n;\n      unresolved = ((await (await store.prepare('SELECT target FROM links WHERE src = ? AND dst IS NULL ORDER BY target LIMIT ?')).all(path, linkCountLimit)) as Array<{ target: string }>).map((r) => r.target);\n      backlinksTotal = ((await (await store.prepare('SELECT COUNT(DISTINCT src) AS n FROM links WHERE dst = ? AND src != dst AND src IN (SELECT \"path\" FROM _peek_scope)')).get(path)) as { n: number }).n;\n      backlinks = ((await (await store.prepare('SELECT DISTINCT src FROM links WHERE dst = ? AND src != dst AND src IN (SELECT \"path\" FROM _peek_scope) ORDER BY src LIMIT ?')).all(path, linkCountLimit)) as Array<{ src: string }>).map((r) => r.src);\n    }\n\n    // content.text is the stripped body already computed at reconcile time (no extra file read),\n    // floored by the byte/4 estimate so stripped-away syntax and frontmatter can't vanish from the price.\n    const body = ((await (await store.prepare('SELECT text FROM content WHERE \"path\" = ?')).get(path)) as { text: string } | undefined)?.text;\n    const byteTokens = Math.ceil(((row._size as number) ?? 0) / 4);\n    const tokens = body !== undefined ? Math.max(Math.ceil(estimateTokens(body)), byteTokens) : byteTokens;\n\n    return {\n      path,\n      tokens,\n      frontmatter,\n      parseError,\n      sections,\n      outbound,\n      backlinks,\n      unresolved,\n      sectionsTotal,\n      outboundTotal,\n      backlinksTotal,\n      unresolvedTotal,\n      off: (['sections', 'links'] as FeatureName[]).filter((name) => !featureEnabled(cfg, name)),\n    };\n  });\n}\n"],"names":["peek","resolveNote","paths","arg","exact","find","p","base","posix","basename","replace","toLowerCase","matches","filter","length","SenseError","join","PEEK_COUNT_LIMIT","store","cfg","pathArg","overrides","serialQuery","peekIndexed","name","value","sectionCountLimit","linkCountLimit","undefined","Number","isSafeInteger","String","transaction","row","pathsStmt","allowed","path","excludedPath","rowStmt","parseError","frontmatter","key","sectionsTotal","sections","outbound","backlinks","unresolved","outboundTotal","backlinksTotal","unresolvedTotal","body","byteTokens","tokens","assertQuerySnapshot","prepare","all","map","r","scopedPaths","includes","has","err","code","unscopedErr","get","_parse_error","Object","entries","INTERNAL_COLUMNS","featureEnabled","n","materializeScope","dst","target","src","text","Math","ceil","_size","max","estimateTokens","off"],"mappings":"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"}

package/dist/cjs/commands/related.js.map

@@ -1 +1 @@
-{"version":3,"sources":["/Users/kevin/Dev/OpenSource/ai/sensemaking/src/commands/related.ts"],"sourcesContent":["import type { ResolvedConfig, SearchOverrides } from '../config/index.ts';\nimport { embedConfig, embedEnabled, resolveSearch } from '../config/index.ts';\nimport { ensureDocumentEmbeddings, hasEmbedding, similarNotes } from '../embed/query.ts';\nimport { localModelMissing, MODEL_FILENAMES } from '../embed/store.ts';\nimport { SenseError } from '../errors.ts';\nimport { serialQuery } from '../lib/serial-query.ts';\nimport type { Store } from '../store/types.ts';\nimport { resolveNote } from './peek.ts';\nimport { scopedPaths, scopeHasEmbeddings, withMaterializedVectorScope } from './scope.ts';\nimport { assertQuerySnapshot } from './snapshot.ts';\n\nexport const RELATED_DEFAULT_K = 5;\n\n/**\n * Options for {@link relatedNotes}. Scope fields filter result candidates, not the seed note;\n * `k` defaults to 5, matching the CLI.\n */\nexport interface RelatedOptions extends SearchOverrides {\n  k?: number;\n}\n\nexport type RelatedResult = {\n  path: string;\n  similarity: number;\n};\n\nexport async function resolveRelatedSeed(store: Store, pathArg: string): Promise<string> {\n  const paths = ((await (await store.prepare('SELECT \"path\" FROM frontmatter')).all()) as Array<{ path: string }>).map((row) => row.path);\n  return resolveNote(paths, pathArg);\n}\n\n/**\n * Returns the notes most similar to an indexed seed, excluding the seed and notes linked either\n * way. The seed resolves across the indexed tree even when it is outside the candidate scope.\n */\nexport function relatedNotes(store: Store, cfg: ResolvedConfig, pathArg: string, options: RelatedOptions = {}): Promise<RelatedResult[]> {\n  return serialQuery(store, () => relatedIndexed(store, cfg, pathArg, options, options.k ?? RELATED_DEFAULT_K));\n}\n\nasync function relatedIndexed(store: Store, cfg: ResolvedConfig, pathArg: string, overrides: RelatedOptions, k: number): Promise<RelatedResult[]> {\n  if (!Number.isFinite(k) || !Number.isInteger(k) || k <= 0) {\n    throw new SenseError('SEARCH_OPTION_INVALID', `related option \"k\" must be a positive finite integer, got ${String(k)}`);\n  }\n  // Vectors are the only signal `related` has, so every way of not having them is an error\n  // naming the cause; an empty result means one thing, nothing near in meaning.\n  const effective = resolveSearch(cfg, overrides);\n  if (!embedEnabled(cfg)) {\n    throw new SenseError('EMBED_DISABLED', 'related ranks notes by meaning, and this tree has no embedding model; add an \"embed\" block naming one to sense.config.json (a Hugging Face id fetches automatically at first use; `sense download` prefetches it) -- search works without it, on words and links');\n  }\n  // search gates on the same signal, so a preset's declared signals mean one thing: without\n  // this check an overlapping vectors-on preset would answer for a scope that declined them.\n  if (effective.signals.vectors === undefined) {\n    throw new SenseError('PRESET_NOT_SEMANTIC', `preset \"${effective.presetName}\" has no \"vectors\" signal, so this scope has no vectors and related has no other signal; search it instead (words and links), or add \"vectors\" to that preset's signals`);\n  }\n  // A downloadable HF id can be fetched by preparation. Only a local path with missing files\n  // can never fetch itself.\n  const e = embedConfig(cfg); // embedEnabled(cfg) above guarantees this is set\n  if (localModelMissing(e)) {\n    throw new SenseError('EMBED_MODEL_MISSING', `related ranks notes by meaning, so it needs the embedding model, but the local model path \"${e.model}\" is missing ${MODEL_FILENAMES}; point embed.model at a directory containing them (search still works without it, on words and links)`);\n  }\n\n  return store.transaction(async () => {\n    await assertQuerySnapshot(store, cfg);\n    // Repeat effective preset validation inside the snapshot that supplies its durable scope.\n    const current = resolveSearch(cfg, overrides);\n    if (current.signals.vectors === undefined) {\n      throw new SenseError('PRESET_NOT_SEMANTIC', `preset \"${current.presetName}\" has no \"vectors\" signal, so this scope has no vectors and related has no other signal; search it instead (words and links), or add \"vectors\" to that preset's signals`);\n    }\n\n    const path = await resolveRelatedSeed(store, pathArg);\n    const outbound = ((await (await store.prepare('SELECT DISTINCT dst FROM links WHERE src = ? AND dst IS NOT NULL AND dst != src')).all(path)) as Array<{ dst: string }>).map((r) => r.dst);\n    const backlinks = ((await (await store.prepare('SELECT DISTINCT src FROM links WHERE dst = ? AND src != dst')).all(path)) as Array<{ src: string }>).map((r) => r.src);\n    const exclude = new Set([path, ...outbound, ...backlinks]);\n    const allowed = await scopedPaths(store, cfg, overrides);\n    // The seed may sit outside a narrowed candidate scope; both it and every eligible result must\n    // be ready, while pending vectors in unrelated notes do not block this operation.\n    await ensureDocumentEmbeddings(store, cfg, new Set([...allowed, path]));\n    if (!(await hasEmbedding(store, path))) {\n      throw new SenseError('NOTE_NOT_EMBEDDED', `${path} has no indexed text to compare -- a note that is frontmatter only, or empty, has nothing to rank by meaning`);\n    }\n    if (!(await scopeHasEmbeddings(store, cfg, allowed))) return [];\n    return withMaterializedVectorScope(store, allowed, () => similarNotes(store, cfg, path, { exclude, allowed, k }));\n  });\n}\n"],"names":["RELATED_DEFAULT_K","relatedNotes","resolveRelatedSeed","store","pathArg","paths","prepare","all","map","row","path","resolveNote","cfg","options","serialQuery","relatedIndexed","k","overrides","effective","e","Number","isFinite","isInteger","SenseError","String","resolveSearch","embedEnabled","signals","vectors","undefined","presetName","embedConfig","localModelMissing","MODEL_FILENAMES","model","transaction","current","outbound","backlinks","exclude","allowed","assertQuerySnapshot","r","dst","src","Set","scopedPaths","ensureDocumentEmbeddings","hasEmbedding","scopeHasEmbeddings","withMaterializedVectorScope","similarNotes"],"mappings":"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"}
+{"version":3,"sources":["/Users/kevin/Dev/open-source/ai/sensemaking/src/commands/related.ts"],"sourcesContent":["import type { ResolvedConfig, SearchOverrides } from '../config/index.ts';\nimport { embedConfig, embedEnabled, resolveSearch } from '../config/index.ts';\nimport { ensureDocumentEmbeddings, hasEmbedding, similarNotes } from '../embed/query.ts';\nimport { localModelMissing, MODEL_FILENAMES } from '../embed/store.ts';\nimport { SenseError } from '../errors.ts';\nimport { serialQuery } from '../lib/serial-query.ts';\nimport type { Store } from '../store/types.ts';\nimport { resolveNote } from './peek.ts';\nimport { scopedPaths, scopeHasEmbeddings, withMaterializedVectorScope } from './scope.ts';\nimport { assertQuerySnapshot } from './snapshot.ts';\n\nexport const RELATED_DEFAULT_K = 5;\n\n/**\n * Options for {@link relatedNotes}. Scope fields filter result candidates, not the seed note;\n * `k` defaults to 5, matching the CLI.\n */\nexport interface RelatedOptions extends SearchOverrides {\n  k?: number;\n}\n\nexport type RelatedResult = {\n  path: string;\n  similarity: number;\n};\n\nexport async function resolveRelatedSeed(store: Store, pathArg: string): Promise<string> {\n  const paths = ((await (await store.prepare('SELECT \"path\" FROM frontmatter')).all()) as Array<{ path: string }>).map((row) => row.path);\n  return resolveNote(paths, pathArg);\n}\n\n/**\n * Returns the notes most similar to an indexed seed, excluding the seed and notes linked either\n * way. The seed resolves across the indexed tree even when it is outside the candidate scope.\n */\nexport function relatedNotes(store: Store, cfg: ResolvedConfig, pathArg: string, options: RelatedOptions = {}): Promise<RelatedResult[]> {\n  return serialQuery(store, () => relatedIndexed(store, cfg, pathArg, options, options.k ?? RELATED_DEFAULT_K));\n}\n\nasync function relatedIndexed(store: Store, cfg: ResolvedConfig, pathArg: string, overrides: RelatedOptions, k: number): Promise<RelatedResult[]> {\n  if (!Number.isFinite(k) || !Number.isInteger(k) || k <= 0) {\n    throw new SenseError('SEARCH_OPTION_INVALID', `related option \"k\" must be a positive finite integer, got ${String(k)}`);\n  }\n  // Vectors are the only signal `related` has, so every way of not having them is an error\n  // naming the cause; an empty result means one thing, nothing near in meaning.\n  const effective = resolveSearch(cfg, overrides);\n  if (!embedEnabled(cfg)) {\n    throw new SenseError('EMBED_DISABLED', 'related ranks notes by meaning, and this tree has no embedding model; add an \"embed\" block naming one to sense.config.json (a Hugging Face id fetches automatically at first use; `sense download` prefetches it) -- search works without it, on words and links');\n  }\n  // search gates on the same signal, so a preset's declared signals mean one thing: without\n  // this check an overlapping vectors-on preset would answer for a scope that declined them.\n  if (effective.signals.vectors === undefined) {\n    throw new SenseError('PRESET_NOT_SEMANTIC', `preset \"${effective.presetName}\" has no \"vectors\" signal, so this scope has no vectors and related has no other signal; search it instead (words and links), or add \"vectors\" to that preset's signals`);\n  }\n  // A downloadable HF id can be fetched by preparation. Only a local path with missing files\n  // can never fetch itself.\n  const e = embedConfig(cfg); // embedEnabled(cfg) above guarantees this is set\n  if (localModelMissing(e)) {\n    throw new SenseError('EMBED_MODEL_MISSING', `related ranks notes by meaning, so it needs the embedding model, but the local model path \"${e.model}\" is missing ${MODEL_FILENAMES}; point embed.model at a directory containing them (search still works without it, on words and links)`);\n  }\n\n  return store.transaction(async () => {\n    await assertQuerySnapshot(store, cfg);\n    // Repeat effective preset validation inside the snapshot that supplies its durable scope.\n    const current = resolveSearch(cfg, overrides);\n    if (current.signals.vectors === undefined) {\n      throw new SenseError('PRESET_NOT_SEMANTIC', `preset \"${current.presetName}\" has no \"vectors\" signal, so this scope has no vectors and related has no other signal; search it instead (words and links), or add \"vectors\" to that preset's signals`);\n    }\n\n    const path = await resolveRelatedSeed(store, pathArg);\n    const outbound = ((await (await store.prepare('SELECT DISTINCT dst FROM links WHERE src = ? AND dst IS NOT NULL AND dst != src')).all(path)) as Array<{ dst: string }>).map((r) => r.dst);\n    const backlinks = ((await (await store.prepare('SELECT DISTINCT src FROM links WHERE dst = ? AND src != dst')).all(path)) as Array<{ src: string }>).map((r) => r.src);\n    const exclude = new Set([path, ...outbound, ...backlinks]);\n    const allowed = await scopedPaths(store, cfg, overrides);\n    // The seed may sit outside a narrowed candidate scope; both it and every eligible result must\n    // be ready, while pending vectors in unrelated notes do not block this operation.\n    await ensureDocumentEmbeddings(store, cfg, new Set([...allowed, path]));\n    if (!(await hasEmbedding(store, path))) {\n      throw new SenseError('NOTE_NOT_EMBEDDED', `${path} has no indexed text to compare -- a note that is frontmatter only, or empty, has nothing to rank by meaning`);\n    }\n    if (!(await scopeHasEmbeddings(store, cfg, allowed))) return [];\n    return withMaterializedVectorScope(store, allowed, () => similarNotes(store, cfg, path, { exclude, allowed, k }));\n  });\n}\n"],"names":["RELATED_DEFAULT_K","relatedNotes","resolveRelatedSeed","store","pathArg","paths","prepare","all","map","row","path","resolveNote","cfg","options","serialQuery","relatedIndexed","k","overrides","effective","e","Number","isFinite","isInteger","SenseError","String","resolveSearch","embedEnabled","signals","vectors","undefined","presetName","embedConfig","localModelMissing","MODEL_FILENAMES","model","transaction","current","outbound","backlinks","exclude","allowed","assertQuerySnapshot","r","dst","src","Set","scopedPaths","ensureDocumentEmbeddings","hasEmbedding","scopeHasEmbeddings","withMaterializedVectorScope","similarNotes"],"mappings":"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"}

package/dist/cjs/commands/scope.js.map

@@ -1 +1 @@
-{"version":3,"sources":["/Users/kevin/Dev/OpenSource/ai/sensemaking/src/commands/scope.ts"],"sourcesContent":["import { matchesGlob } from 'node:path';\nimport type { ResolvedConfig, SearchOverrides } from '../config/index.ts';\nimport { anyPresetEmbeds, resolveSearch } from '../config/index.ts';\nimport { columnHint } from '../output/column-hint.ts';\nimport type { Store } from '../store/types.ts';\nimport { NATIVE_VECTOR_SCOPE_TABLE, reserveNativeVectorScope } from '../store/vectors.ts';\n\nexport const INTERNAL_COLUMNS = new Set(['path', '_mtime', '_ctime', '_size', '_rank', '_parse_error']);\n\n// node:path's matchesGlob is experimental (stable behind an unstable-API flag) at the\n// Node >=22.20 engines floor; used here in JS rather than a directory walk in the query path.\nexport function inScope(path: string, include: string[], exclude?: string[]): boolean {\n  if (!include.some((g) => matchesGlob(path, g))) return false;\n  if (exclude?.some((g) => matchesGlob(path, g))) return false;\n  return true;\n}\n\nexport async function scopeHasEmbeddings(store: Store, cfg: ResolvedConfig, scopedPaths: Set<string>): Promise<boolean> {\n  if (!anyPresetEmbeds(cfg)) return false; // the embeddings table doesn't exist at all in this case\n  const stmt = await store.prepare('SELECT DISTINCT \"path\" FROM embeddings WHERE vector IS NOT NULL');\n  const rows = (await stmt.all()) as Array<{ path: string }>;\n  return rows.some((r) => scopedPaths.has(r.path));\n}\n\n// Scope only (no --where): preset_files for a named preset, JS glob matching for an ad hoc\n// include/exclude override. Shared by scopedPaths() and search()'s candidate-pool sizing.\nexport async function rawScope(store: Store, cfg: ResolvedConfig, overrides: SearchOverrides, allPaths?: string[]): Promise<Set<string>> {\n  const effective = resolveSearch(cfg, overrides);\n  const { include, exclude } = effective;\n  const adHocScope = overrides.include !== undefined || overrides.exclude !== undefined || overrides.noExclude === true;\n  if (!adHocScope) {\n    const stmt = await store.prepare('SELECT \"path\" FROM preset_files WHERE preset = ?');\n    return new Set(((await stmt.all(effective.presetName)) as Array<{ path: string }>).map((r) => r.path));\n  }\n  const paths = allPaths ?? (await allFrontmatterPaths(store));\n  return new Set(paths.filter((p) => inScope(p, include, exclude)));\n}\n\nasync function allFrontmatterPaths(store: Store): Promise<string[]> {\n  const stmt = await store.prepare('SELECT \"path\" FROM frontmatter');\n  return ((await stmt.all()) as Array<{ path: string }>).map((r) => r.path);\n}\n\nexport async function narrowByWhere(store: Store, paths: Set<string>, where: string | undefined): Promise<Set<string>> {\n  if (!where) return paths;\n  let whereRows: Array<{ path: string }>;\n  try {\n    const stmt = await store.prepare(`SELECT \"path\" FROM frontmatter f WHERE (${where})`);\n    whereRows = (await stmt.all()) as Array<{ path: string }>;\n  } catch (err) {\n    throw columnHint(await store.docs.columns(), err as Error);\n  }\n  const wherePaths = new Set(whereRows.map((r) => r.path));\n  return new Set([...paths].filter((p) => wherePaths.has(p)));\n}\n\n// The scope resolver for non-search commands (path, peek, map): same coverage rule search()\n// applies, then narrowed by the resolved `where`.\nexport async function scopedPaths(store: Store, cfg: ResolvedConfig, overrides: SearchOverrides): Promise<Set<string>> {\n  const effective = resolveSearch(cfg, overrides);\n  return narrowByWhere(store, await rawScope(store, cfg, overrides), effective.where);\n}\n\n// Materializes a path set into a named temp table (same shape as traverse.ts's allowed_nodes)\n// so a query can join/filter against it cheaply instead of binding a parameter per path.\nexport async function materializeScope(store: Store, table: string, paths: Set<string>): Promise<void> {\n  await store.exec(`DROP TABLE IF EXISTS ${table}`);\n  await store.exec(`CREATE TEMP TABLE ${table} (\"path\" TEXT PRIMARY KEY)`);\n  await store.runBatch(\n    `INSERT INTO ${table} (\"path\") VALUES (?)`,\n    [...paths].map((p) => [p])\n  );\n}\n\n// Native vector adapters can consume a small exact scope through their connection-local temp\n// table. The reservation is tied to this Store's VectorStore wrapper, so another Store cannot\n// activate it by receiving the same Set object.\nexport async function withMaterializedVectorScope<T>(store: Store, allowed: Set<string>, callback: () => Promise<T>, knownTotal?: number): Promise<T> {\n  const reservation = reserveNativeVectorScope(store.vectors, allowed);\n  if (!reservation) return callback();\n\n  if (allowed.size === 0) {\n    reservation.invalidate();\n    return callback();\n  }\n\n  let total = knownTotal;\n  if (total === undefined) {\n    try {\n      const stmt = await store.prepare('SELECT COUNT(*) AS count FROM frontmatter');\n      const row = (await stmt.get()) as { count: number | bigint };\n      total = Number(row.count);\n    } catch (err) {\n      reservation.invalidate();\n      throw err;\n    }\n  }\n  // Materialization only buys work when this is a nonempty true narrowing and the allowed side\n  // is no larger than its complement. Direct adapter calls and broader scopes retain JS filtering.\n  if (allowed.size >= total || allowed.size > total - allowed.size) {\n    reservation.invalidate();\n    return callback();\n  }\n\n  let operationFailed = false;\n  let operationError: unknown;\n  let result!: T;\n  try {\n    await materializeScope(store, NATIVE_VECTOR_SCOPE_TABLE, allowed);\n    reservation.activate();\n    result = await callback();\n  } catch (err) {\n    operationFailed = true;\n    operationError = err;\n  }\n\n  let cleanupFailed = false;\n  let cleanupError: unknown;\n  try {\n    reservation.deactivate();\n    await store.exec(`DROP TABLE IF EXISTS ${NATIVE_VECTOR_SCOPE_TABLE}`);\n  } catch (err) {\n    cleanupFailed = true;\n    cleanupError = err;\n  } finally {\n    reservation.invalidate();\n  }\n\n  if (operationFailed && cleanupFailed) throw new AggregateError([operationError, cleanupError], 'native vector scope operation and cleanup failed');\n  if (operationFailed) throw operationError;\n  if (cleanupFailed) throw cleanupError;\n  return result;\n}\n\nexport async function setupMapScope(store: Store, paths: Set<string>): Promise<void> {\n  await materializeScope(store, '_map_scope', paths);\n}\n"],"names":["INTERNAL_COLUMNS","inScope","materializeScope","narrowByWhere","rawScope","scopeHasEmbeddings","scopedPaths","setupMapScope","withMaterializedVectorScope","Set","path","include","exclude","some","g","matchesGlob","store","cfg","stmt","rows","anyPresetEmbeds","prepare","all","r","has","overrides","allPaths","effective","adHocScope","paths","resolveSearch","undefined","noExclude","presetName","map","allFrontmatterPaths","filter","p","where","whereRows","err","wherePaths","docs","columns","columnHint","table","exec","runBatch","allowed","callback","knownTotal","reservation","total","row","operationFailed","operationError","result","cleanupFailed","cleanupError","reserveNativeVectorScope","vectors","size","invalidate","get","Number","count","NATIVE_VECTOR_SCOPE_TABLE","activate","deactivate","AggregateError"],"mappings":"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"}
+{"version":3,"sources":["/Users/kevin/Dev/open-source/ai/sensemaking/src/commands/scope.ts"],"sourcesContent":["import { matchesGlob } from 'node:path';\nimport type { ResolvedConfig, SearchOverrides } from '../config/index.ts';\nimport { anyPresetEmbeds, resolveSearch } from '../config/index.ts';\nimport { columnHint } from '../output/column-hint.ts';\nimport type { Store } from '../store/types.ts';\nimport { NATIVE_VECTOR_SCOPE_TABLE, reserveNativeVectorScope } from '../store/vectors.ts';\n\nexport const INTERNAL_COLUMNS = new Set(['path', '_mtime', '_ctime', '_size', '_rank', '_parse_error']);\n\n// node:path's matchesGlob is experimental (stable behind an unstable-API flag) at the\n// Node >=22.20 engines floor; used here in JS rather than a directory walk in the query path.\nexport function inScope(path: string, include: string[], exclude?: string[]): boolean {\n  if (!include.some((g) => matchesGlob(path, g))) return false;\n  if (exclude?.some((g) => matchesGlob(path, g))) return false;\n  return true;\n}\n\nexport async function scopeHasEmbeddings(store: Store, cfg: ResolvedConfig, scopedPaths: Set<string>): Promise<boolean> {\n  if (!anyPresetEmbeds(cfg)) return false; // the embeddings table doesn't exist at all in this case\n  const stmt = await store.prepare('SELECT DISTINCT \"path\" FROM embeddings WHERE vector IS NOT NULL');\n  const rows = (await stmt.all()) as Array<{ path: string }>;\n  return rows.some((r) => scopedPaths.has(r.path));\n}\n\n// Scope only (no --where): preset_files for a named preset, JS glob matching for an ad hoc\n// include/exclude override. Shared by scopedPaths() and search()'s candidate-pool sizing.\nexport async function rawScope(store: Store, cfg: ResolvedConfig, overrides: SearchOverrides, allPaths?: string[]): Promise<Set<string>> {\n  const effective = resolveSearch(cfg, overrides);\n  const { include, exclude } = effective;\n  const adHocScope = overrides.include !== undefined || overrides.exclude !== undefined || overrides.noExclude === true;\n  if (!adHocScope) {\n    const stmt = await store.prepare('SELECT \"path\" FROM preset_files WHERE preset = ?');\n    return new Set(((await stmt.all(effective.presetName)) as Array<{ path: string }>).map((r) => r.path));\n  }\n  const paths = allPaths ?? (await allFrontmatterPaths(store));\n  return new Set(paths.filter((p) => inScope(p, include, exclude)));\n}\n\nasync function allFrontmatterPaths(store: Store): Promise<string[]> {\n  const stmt = await store.prepare('SELECT \"path\" FROM frontmatter');\n  return ((await stmt.all()) as Array<{ path: string }>).map((r) => r.path);\n}\n\nexport async function narrowByWhere(store: Store, paths: Set<string>, where: string | undefined): Promise<Set<string>> {\n  if (!where) return paths;\n  let whereRows: Array<{ path: string }>;\n  try {\n    const stmt = await store.prepare(`SELECT \"path\" FROM frontmatter f WHERE (${where})`);\n    whereRows = (await stmt.all()) as Array<{ path: string }>;\n  } catch (err) {\n    throw columnHint(await store.docs.columns(), err as Error);\n  }\n  const wherePaths = new Set(whereRows.map((r) => r.path));\n  return new Set([...paths].filter((p) => wherePaths.has(p)));\n}\n\n// The scope resolver for non-search commands (path, peek, map): same coverage rule search()\n// applies, then narrowed by the resolved `where`.\nexport async function scopedPaths(store: Store, cfg: ResolvedConfig, overrides: SearchOverrides): Promise<Set<string>> {\n  const effective = resolveSearch(cfg, overrides);\n  return narrowByWhere(store, await rawScope(store, cfg, overrides), effective.where);\n}\n\n// Materializes a path set into a named temp table (same shape as traverse.ts's allowed_nodes)\n// so a query can join/filter against it cheaply instead of binding a parameter per path.\nexport async function materializeScope(store: Store, table: string, paths: Set<string>): Promise<void> {\n  await store.exec(`DROP TABLE IF EXISTS ${table}`);\n  await store.exec(`CREATE TEMP TABLE ${table} (\"path\" TEXT PRIMARY KEY)`);\n  await store.runBatch(\n    `INSERT INTO ${table} (\"path\") VALUES (?)`,\n    [...paths].map((p) => [p])\n  );\n}\n\n// Native vector adapters can consume a small exact scope through their connection-local temp\n// table. The reservation is tied to this Store's VectorStore wrapper, so another Store cannot\n// activate it by receiving the same Set object.\nexport async function withMaterializedVectorScope<T>(store: Store, allowed: Set<string>, callback: () => Promise<T>, knownTotal?: number): Promise<T> {\n  const reservation = reserveNativeVectorScope(store.vectors, allowed);\n  if (!reservation) return callback();\n\n  if (allowed.size === 0) {\n    reservation.invalidate();\n    return callback();\n  }\n\n  let total = knownTotal;\n  if (total === undefined) {\n    try {\n      const stmt = await store.prepare('SELECT COUNT(*) AS count FROM frontmatter');\n      const row = (await stmt.get()) as { count: number | bigint };\n      total = Number(row.count);\n    } catch (err) {\n      reservation.invalidate();\n      throw err;\n    }\n  }\n  // Materialization only buys work when this is a nonempty true narrowing and the allowed side\n  // is no larger than its complement. Direct adapter calls and broader scopes retain JS filtering.\n  if (allowed.size >= total || allowed.size > total - allowed.size) {\n    reservation.invalidate();\n    return callback();\n  }\n\n  let operationFailed = false;\n  let operationError: unknown;\n  let result!: T;\n  try {\n    await materializeScope(store, NATIVE_VECTOR_SCOPE_TABLE, allowed);\n    reservation.activate();\n    result = await callback();\n  } catch (err) {\n    operationFailed = true;\n    operationError = err;\n  }\n\n  let cleanupFailed = false;\n  let cleanupError: unknown;\n  try {\n    reservation.deactivate();\n    await store.exec(`DROP TABLE IF EXISTS ${NATIVE_VECTOR_SCOPE_TABLE}`);\n  } catch (err) {\n    cleanupFailed = true;\n    cleanupError = err;\n  } finally {\n    reservation.invalidate();\n  }\n\n  if (operationFailed && cleanupFailed) throw new AggregateError([operationError, cleanupError], 'native vector scope operation and cleanup failed');\n  if (operationFailed) throw operationError;\n  if (cleanupFailed) throw cleanupError;\n  return result;\n}\n\nexport async function setupMapScope(store: Store, paths: Set<string>): Promise<void> {\n  await materializeScope(store, '_map_scope', paths);\n}\n"],"names":["INTERNAL_COLUMNS","inScope","materializeScope","narrowByWhere","rawScope","scopeHasEmbeddings","scopedPaths","setupMapScope","withMaterializedVectorScope","Set","path","include","exclude","some","g","matchesGlob","store","cfg","stmt","rows","anyPresetEmbeds","prepare","all","r","has","overrides","allPaths","effective","adHocScope","paths","resolveSearch","undefined","noExclude","presetName","map","allFrontmatterPaths","filter","p","where","whereRows","err","wherePaths","docs","columns","columnHint","table","exec","runBatch","allowed","callback","knownTotal","reservation","total","row","operationFailed","operationError","result","cleanupFailed","cleanupError","reserveNativeVectorScope","vectors","size","invalidate","get","Number","count","NATIVE_VECTOR_SCOPE_TABLE","activate","deactivate","AggregateError"],"mappings":"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"}

package/dist/cjs/commands/search.js.map

@@ -1 +1 @@
-{"version":3,"sources":["/Users/kevin/Dev/OpenSource/ai/sensemaking/src/commands/search.ts"],"sourcesContent":["import { channel } from 'node:diagnostics_channel';\nimport { stemmer } from 'stemmer';\nimport type { EffectiveSearch, ResolvedConfig } from '../config/index.ts';\nimport { embedConfig, featureEnabled, resolveSearch } from '../config/index.ts';\nimport type { PreparedSemanticQuery } from '../embed/query.ts';\nimport { ensureDocumentEmbeddings, prepareSemanticQuery } from '../embed/query.ts';\nimport { localModelMissing, MODEL_FILENAMES } from '../embed/store.ts';\nimport { SenseError } from '../errors.ts';\nimport { serialQuery } from '../lib/serial-query.ts';\nimport { bareTermSyntaxError, searchError } from '../output/search-error.ts';\nimport type { LexicalHit, Store } from '../store/types.ts';\nimport { foldForSearch, hasUnspacedRun, searchTokens, unspacedRuns } from '../text/segment.ts';\nimport { materializeScope, narrowByWhere, rawScope, scopeHasEmbeddings } from './scope.ts';\nimport type { Candidates, SearchResultVia, SearchSignalContribution } from './signals.ts';\nimport { linksCandidates, vectorsCandidates, wordsCandidates } from './signals.ts';\nimport { assertQuerySnapshot } from './snapshot.ts';\n\nexport type { SearchResultVia, SearchSignalContribution } from './signals.ts';\n\n// Default budget behind --snippet-char-limit/--snippet-count-limit: the limit is whatever the\n// caller passes, these only say what happens when they pass nothing (DESIGN.md \"Search snippets\").\nexport const SNIPPET_CHAR_LIMIT_DEFAULT = 80;\nexport const SNIPPET_COUNT_LIMIT_DEFAULT = 1;\n\nconst searchCandidatesRead = channel('sensemaking.search.candidates-read');\n\n// Bare terms from an FTS5 query string: strips operators/quoting, not real terms, so the\n// snippet scan matches what the query matched -- FTS5 operators are uppercase-only, so this is too.\nfunction extractBareTerms(query: string): string[] {\n  const cleaned = query\n    .replace(/\"/g, ' ')\n    .replace(/[()*]/g, ' ')\n    .replace(/\\b(AND|OR|NOT|NEAR)\\b(\\/\\d+)?/g, ' ');\n  return cleaned\n    .split(/\\s+/)\n    .map((tok) => tok.replace(/^[A-Za-z_]\\w*:/, '')) // column filter, e.g. title:term\n    .flatMap((tok) => searchTokens(tok).map(({ text }) => text))\n    .map((tok) => tok.toLowerCase().trim())\n    .filter((tok) => tok.length > 0);\n}\n\n// House convention (src/chunk/group.ts): Intl.Segmenter word boundaries, not a bare \\b, which\n// is ASCII-only. Built on first use: construction is a few ms, paid only when a term matches.\nlet wordSegmenter: Intl.Segmenter | undefined;\n\nfunction findOccurrences(text: string, terms: string[]): Array<{ start: number; end: number; term: string }> {\n  const occ: Array<{ start: number; end: number; term: string }> = [];\n  const textLower = text.toLowerCase();\n\n  // Unspaced scripts (UNSPACED_SCRIPTS) mark no word boundaries: the sense-setup skill promises\n  // substring semantics there, so a matching term is found wherever it occurs in the run.\n  const unspacedTerms = terms.filter(hasUnspacedRun);\n  if (unspacedTerms.length > 0) {\n    for (const run of unspacedRuns(text)) {\n      const runLower = textLower.slice(run.start, run.end);\n      for (const term of unspacedTerms) {\n        let idx = 0;\n        for (;;) {\n          const found = runLower.indexOf(term, idx);\n          if (found === -1) break;\n          occ.push({ start: run.start + found, end: run.start + found + term.length, term });\n          idx = found + term.length;\n        }\n      }\n    }\n  }\n\n  // Spaced scripts: a word is marked when its porter stem equals a query term's stem, the same\n  // algorithm both indexes tokenize with (sqlite's TOKENIZE = 'porter unicode61'; duckdb's fts default).\n  const spacedTerms = terms.filter((t) => !hasUnspacedRun(t));\n  if (spacedTerms.length > 0) {\n    const termByStem = new Map(spacedTerms.map((t) => [stemmer(foldForSearch(t)), t]));\n    const stemInitials = new Set(Array.from(termByStem.keys(), (term) => term[0]));\n    for (const match of searchTokens(text)) {\n      const segment = match.text;\n      if (match.unspaced) continue;\n      const folded = foldForSearch(segment);\n      // Porter stemming changes suffixes only, so a different initial cannot match a query stem.\n      if (!stemInitials.has(folded[0])) continue;\n      const term = termByStem.get(stemmer(folded));\n      if (term !== undefined) occ.push({ start: match.start, end: match.end, term });\n    }\n  }\n\n  return occ.sort((a, b) => a.start - b.start || b.end - a.end);\n}\n\n// Segment boundaries of the whole text, word granularity: the only cut points a snippet edge\n// may land on. One rule for every script (DESIGN.md \"Cutting\") -- a regex \\b is ASCII-only and\n// would mis-cut Japanese, Chinese and Thai, which Intl.Segmenter divides by dictionary instead.\nfunction wordBoundaries(text: string): number[] {\n  wordSegmenter ??= new Intl.Segmenter('en', { granularity: 'word' });\n  const bounds = [0];\n  for (const { index, segment } of wordSegmenter.segment(text)) bounds.push(index + segment.length);\n  return bounds;\n}\n\n// bounds is sorted: snaps are binary searches, since each runs once per candidate window.\nfunction snapForward(bounds: number[], pos: number): number {\n  let lo = 0;\n  let hi = bounds.length - 1;\n  while (lo < hi) {\n    const mid = (lo + hi) >> 1;\n    if (bounds[mid] < pos) lo = mid + 1;\n    else hi = mid;\n  }\n  return bounds[lo];\n}\n\nfunction snapBackward(bounds: number[], pos: number): number {\n  let lo = 0;\n  let hi = bounds.length - 1;\n  let result = bounds[0];\n  while (lo < hi) {\n    const mid = (lo + hi + 1) >> 1;\n    if (bounds[mid] <= pos) {\n      lo = mid;\n      result = bounds[mid];\n    } else hi = mid - 1;\n  }\n  return result;\n}\n\nfunction firstBoundAfter(bounds: number[], pos: number): number | undefined {\n  let lo = 0;\n  let hi = bounds.length;\n  while (lo < hi) {\n    const mid = (lo + hi) >> 1;\n    if (bounds[mid] <= pos) lo = mid + 1;\n    else hi = mid;\n  }\n  return bounds[lo];\n}\n\n// A raw, unmarked upper bound: [start, end) inside [anchor, anchor+charLimit), edges on\n// boundaries. Markup (guillemets, ellipses) added on top of this can push the rendered result\n// past charLimit, which is what fitEnd() below corrects for; this is only the starting guess.\n// A single segment spanning the whole target window (a word longer than the char limit) is the\n// one case where holding the boundary rule means the budget is not a hard ceiling.\nfunction cutWindow(text: string, bounds: number[], anchor: number, charLimit: number): { start: number; end: number } {\n  const rawEnd = Math.min(text.length, anchor + charLimit);\n  const start = snapForward(bounds, anchor);\n  let end = snapBackward(bounds, rawEnd);\n  if (end <= start) end = firstBoundAfter(bounds, start) ?? text.length;\n  return { start, end: Math.min(end, text.length) };\n}\n\n// The largest boundary <= upperBound, > floor, whose rendered [*, end) fits charLimit. Markup\n// only ever adds characters as end grows, so rendered length is non-decreasing in end and\n// shrinking from upperBound is guaranteed to find the true fit rather than guess at it.\n// `floor` is the one end this never shrinks past (the anchor's own marked word, or the first\n// word in the unmarked fallback): DESIGN.md's budget is a ceiling except here, where returning\n// nothing is worse than a single word that overruns it.\nfunction fitEnd(render: (end: number) => string, bounds: number[], floor: number, upperBound: number, charLimit: number): number {\n  let lo = 0;\n  let hi = bounds.length - 1;\n  while (lo < hi) {\n    const mid = (lo + hi + 1) >> 1;\n    if (bounds[mid] <= upperBound) lo = mid;\n    else hi = mid - 1;\n  }\n  for (; lo >= 0 && bounds[lo] > floor; lo--) {\n    if (render(bounds[lo]).length <= charLimit) return bounds[lo];\n  }\n  return floor;\n}\n\ninterface Span {\n  start: number;\n  end: number;\n}\n\ninterface SnippetWindow extends Span {\n  distinct: number;\n  count: number;\n}\n\n// occ is start-sorted: a window's first candidate occurrence is a binary search, not a walk.\nfunction firstOccAtOrAfter(occ: Array<{ start: number; end: number; term: string }>, pos: number): number {\n  let lo = 0;\n  let hi = occ.length;\n  while (lo < hi) {\n    const mid = (lo + hi) >> 1;\n    if (occ[mid].start < pos) lo = mid + 1;\n    else hi = mid;\n  }\n  return lo;\n}\n\nfunction renderWindow(text: string, occ: Array<{ start: number; end: number; term: string }>, win: Span): string {\n  let out = '';\n  let cursor = win.start;\n  for (let i = firstOccAtOrAfter(occ, win.start); i < occ.length && occ[i].start < win.end; i++) {\n    const o = occ[i];\n    if (o.end > win.end) continue;\n    // Occurrences of duplicate or substring-overlapping terms (\"test tests\") can overlap;\n    // emitting each would duplicate document text. Keep the first, absorb the rest.\n    if (o.start < cursor) continue;\n    out += `${text.slice(cursor, o.start)}«${text.slice(o.start, o.end)}»`;\n    cursor = o.end;\n  }\n  out += text.slice(cursor, win.end);\n  const prefix = win.start > 0 ? '…' : '';\n  const suffix = win.end < text.length ? '…' : '';\n  return `${prefix}${out.replace(/\\s+/g, ' ')}${suffix}`;\n}\n\n// Scores every occurrence-anchored candidate window: most distinct terms wins, ties broken by\n// most total hits -- coverage now that occurrences are real words, not the false-fragment counts\n// a substring scan produced. Selection itself is unevaluated (DESIGN.md \"Selection, unsettled\").\n// The window's `end` is fitted to the *rendered* text, markup included, not the raw span: a\n// window dense with marks (every guillemet pair adds two characters) shrinks to fit the same\n// budget a sparse one fills almost exactly.\nfunction scoreWindows(occ: Array<{ start: number; end: number; term: string }>, bounds: number[], text: string, charLimit: number): SnippetWindow[] {\n  const candidates: SnippetWindow[] = [];\n  for (let i = 0; i < occ.length; i++) {\n    const winEnd = occ[i].start + charLimit;\n    const seen = new Set<string>();\n    let count = 0;\n    for (let j = i; j < occ.length && occ[j].start < winEnd; j++) {\n      seen.add(occ[j].term);\n      count++;\n    }\n    const start = snapForward(bounds, occ[i].start);\n    const floor = Math.max(start, occ[i].end);\n    const upperBound = Math.max(floor, cutWindow(text, bounds, occ[i].start, charLimit).end);\n    const end = fitEnd((e) => renderWindow(text, occ, { start, end: e }), bounds, floor, upperBound, charLimit);\n    candidates.push({ start, end, distinct: seen.size, count });\n  }\n  return candidates;\n}\n\nfunction overlaps(a: Span, b: Span): boolean {\n  return a.start < b.end && b.start < a.end;\n}\n\n// Same scoring function as a single snippet, kept rather than discarded (DESIGN.md \"Several\n// snippets per note\"): rank by score, take the top non-overlapping windows, then reorder to the\n// note's own order, since several passages from one note read as an abridged note.\nfunction selectWindows(candidates: SnippetWindow[], countLimit: number): { chosen: SnippetWindow[]; best: SnippetWindow } {\n  const ranked = candidates.slice().sort((a, b) => b.distinct - a.distinct || b.count - a.count);\n  const chosen: SnippetWindow[] = [];\n  for (const c of ranked) {\n    if (chosen.length >= countLimit) break;\n    if (chosen.some((s) => overlaps(s, c))) continue;\n    chosen.push(c);\n  }\n  chosen.sort((a, b) => a.start - b.start);\n  return { chosen, best: ranked[0] };\n}\n\n// Builds bounded marked passages and returns the best window's offset for section lookup.\nexport function computeSnippets(text: string, terms: string[], charLimit: number, countLimit: number): { snippets: string[]; offset: number } {\n  const occ = findOccurrences(text, terms);\n  const bounds = wordBoundaries(text);\n  if (occ.length === 0) {\n    // A term matched only via title/summary, not this body text, finds no occurrence here;\n    // fall back to the doc's start, unmarked.\n    const render = (end: number): string => `${text.slice(0, end).replace(/\\s+/g, ' ').trim()}${end < text.length ? '…' : ''}`;\n    const floor = bounds.find((b) => b > 0) ?? text.length;\n    const upperBound = Math.max(floor, cutWindow(text, bounds, 0, charLimit).end);\n    const end = fitEnd(render, bounds, floor, upperBound, charLimit);\n    return { snippets: [render(end)], offset: 0 };\n  }\n  const candidates = scoreWindows(occ, bounds, text, charLimit);\n  const { chosen, best } = selectWindows(candidates, countLimit);\n  return { snippets: chosen.map((win) => renderWindow(text, occ, win)), offset: best.start };\n}\n\n// Converts an offset in the original text to its one-based line number.\nexport function lineNumberAt(text: string, offset: number): number {\n  let line = 1;\n  for (let i = 0; i < offset; i++) if (text.charCodeAt(i) === 10) line++;\n  return line;\n}\n\nasync function lineRangeFor(store: Store, path: string, line: number): Promise<string | null> {\n  const stmt = await store.prepare('SELECT start_line, end_line FROM sections WHERE \"path\" = ? AND start_line <= ? AND end_line >= ? ORDER BY start_line DESC LIMIT 1');\n  const row = (await stmt.get(path, line, line)) as { start_line: number; end_line: number } | undefined;\n  return row ? `L${row.start_line}-${row.end_line}` : null;\n}\n\n/** Options for the root {@link search} API. */\nexport interface SearchOptions {\n  k?: number;\n  /** Collects ranking contributions for returned candidates; omitted or false preserves ordinary output. */\n  explain?: boolean;\n  where?: string; // SQL fragment against frontmatter alias `f`, e.g. \"f.status = 'active'\"\n  preset?: string; // named preset; unknown name throws listing declared presets, undefined -> \"default\"\n  include?: string[]; // ad hoc scope override (repeatable --include); independent of exclude\n  exclude?: string[]; // ad hoc scope override (repeatable --exclude); independent of include\n  noExclude?: boolean; // --no-exclude: drop the preset's exclude for this command\n  snippetCharLimit?: number; // --snippet-char-limit; defaults to SNIPPET_CHAR_LIMIT_DEFAULT\n  snippetCountLimit?: number; // --snippet-count-limit; defaults to SNIPPET_COUNT_LIMIT_DEFAULT\n  /** Cancels supported provider I/O and stops between phases after active native work finishes. */\n  signal?: AbortSignal;\n}\n\nexport type SearchResult = {\n  path: string;\n  title: string;\n  summary: string;\n  snippets: string[];\n  via: SearchResultVia;\n  score: number;\n  lines: string | null;\n  similarity?: number | null;\n  /** Present only with explain: true, in words/links/vectors order; contributions can differ from via labels. */\n  explanation?: SearchSignalContribution[];\n};\n\nexport interface SearchHydrationRow {\n  path: string;\n  snippets?: string[];\n  lines?: string | null;\n}\n\nfunction validateSearchOptions(opts: SearchOptions): void {\n  if (opts.explain !== undefined && typeof opts.explain !== 'boolean') {\n    throw new SenseError('SEARCH_OPTION_INVALID', `search option \"explain\" must be a boolean, got ${String(opts.explain)}`);\n  }\n  for (const [name, value] of [\n    ['k', opts.k],\n    ['snippetCharLimit', opts.snippetCharLimit],\n    ['snippetCountLimit', opts.snippetCountLimit],\n  ] as const) {\n    if (value !== undefined && (!Number.isFinite(value) || !Number.isInteger(value) || value <= 0)) {\n      throw new SenseError('SEARCH_OPTION_INVALID', `search option \"${name}\" must be a positive finite integer, got ${String(value)}`);\n    }\n  }\n}\n\n// Hydrates already-ranked rows with snippets and containing-section ranges without reranking.\nexport async function hydrateSearchRows(store: Store, cfg: ResolvedConfig, rows: SearchHydrationRow[], matchedPaths: Set<string>, terms: string, opts: Pick<SearchOptions, 'snippetCharLimit' | 'snippetCountLimit'> = {}): Promise<void> {\n  if (matchedPaths.size === 0) return;\n  const bareTerms = extractBareTerms(terms);\n  const charLimit = opts.snippetCharLimit ?? SNIPPET_CHAR_LIMIT_DEFAULT;\n  const countLimit = opts.snippetCountLimit ?? SNIPPET_COUNT_LIMIT_DEFAULT;\n  const sourceStmt = await store.prepare('SELECT text FROM indexed_sources WHERE \"path\" = ?');\n  for (const row of rows) {\n    if (!matchedPaths.has(row.path)) continue;\n    const source = (await sourceStmt.get(row.path)) as { text: string } | undefined;\n    if (!source) throw new SenseError('INDEX_NOT_READY', `indexed source text is missing for ${String(row.path)}; run \\`sense build --force\\` (or library build(config, { force: true })) before querying`);\n    const text = source.text;\n    const { snippets, offset } = computeSnippets(text, bareTerms, charLimit, countLimit);\n    row.snippets = snippets;\n    if (row.lines == null) row.lines = featureEnabled(cfg, 'sections') ? await lineRangeFor(store, row.path, lineNumberAt(text, offset)) : null;\n  }\n}\n\n/**\n * Searches one committed published generation. Provider work precedes the final read transaction;\n * cancellation waits for active native work and transaction cleanup before rejection.\n */\nexport function search(store: Store, cfg: ResolvedConfig, terms: string, opts: SearchOptions = {}): Promise<SearchResult[]> {\n  if (opts.signal?.aborted) return Promise.reject(opts.signal.reason);\n  return serialQuery(store, () => searchIndexed(store, cfg, terms, opts));\n}\n\ninterface SearchScope {\n  signature: string;\n  effective: EffectiveSearch;\n  allPaths: string[];\n  scopePaths: Set<string>;\n  allowedPaths: Set<string>;\n  semanticEligible: boolean;\n}\n\nasync function readSearchScope(store: Store, cfg: ResolvedConfig, terms: string, opts: SearchOptions): Promise<SearchScope> {\n  const signature = await assertQuerySnapshot(store, cfg);\n  const effective = resolveSearch(cfg, opts);\n  const allPaths = ((await (await store.prepare('SELECT \"path\" FROM frontmatter')).all()) as Array<{ path: string }>).map((r) => r.path);\n  const scopePaths = await rawScope(store, cfg, opts, allPaths);\n  let allowedPaths: Set<string>;\n  try {\n    allowedPaths = await narrowByWhere(store, scopePaths, effective.where);\n  } catch (err) {\n    throw searchError(err as Error, terms, effective.where);\n  }\n  const wantsVectors = effective.signals.vectors !== undefined;\n  if (wantsVectors) await ensureDocumentEmbeddings(store, cfg, allowedPaths);\n  const semanticEligible = wantsVectors && (await scopeHasEmbeddings(store, cfg, allowedPaths));\n  return { signature, effective, allPaths, scopePaths, allowedPaths, semanticEligible };\n}\n\ninterface SemanticPreparationNeeded {\n  signature: string;\n}\n\nfunction needsSemanticPreparation(result: SearchResult[] | SemanticPreparationNeeded): result is SemanticPreparationNeeded {\n  return !Array.isArray(result);\n}\n\nasync function searchIndexed(store: Store, cfg: ResolvedConfig, terms: string, opts: SearchOptions): Promise<SearchResult[]> {\n  validateSearchOptions(opts);\n  const initial = resolveSearch(cfg, opts);\n  opts.signal?.throwIfAborted();\n  // A downloadable HF id proceeds -- getProvider fetches it lazily on consent. Only a\n  // local path with missing files errors here, since nothing will ever fetch it for itself.\n  const wantsVectors = initial.signals.vectors !== undefined;\n  if (wantsVectors) {\n    const e = embedConfig(cfg); // validate.ts guarantees this is set whenever \"vectors\" is declared\n    if (localModelMissing(e)) {\n      throw new SenseError('EMBED_MODEL_MISSING', `preset \"${initial.presetName}\" searches with vectors, but the local model path \"${e.model}\" is missing ${MODEL_FILENAMES}; point embed.model at a directory containing them, or drop \"vectors\" from that preset's signals to search without them`);\n    }\n  }\n\n  let prepared: PreparedSemanticQuery | undefined;\n  let preparedSignature: string | undefined;\n  if (wantsVectors) {\n    // This first snapshot only decides whether a semantic query can contribute. It closes before\n    // provider/model work, and the complete scope/readiness decision is repeated below.\n    const preflight = await store.transaction(() => readSearchScope(store, cfg, terms, opts));\n    opts.signal?.throwIfAborted();\n    if (preflight.semanticEligible) {\n      preparedSignature = preflight.signature;\n      prepared = await prepareSemanticQuery(cfg, terms, { signal: opts.signal });\n      opts.signal?.throwIfAborted();\n    }\n  }\n\n  opts.signal?.throwIfAborted();\n  let result = await store.transaction(() => searchSnapshot(store, cfg, terms, opts, prepared, preparedSignature));\n  opts.signal?.throwIfAborted();\n  if (!needsSemanticPreparation(result)) return result;\n\n  // The scope became vector-eligible after an empty/ineligible preflight. Leave that snapshot,\n  // prepare once, then take a fresh final snapshot rather than waiting on the provider inside it.\n  preparedSignature = result.signature;\n  prepared = await prepareSemanticQuery(cfg, terms, { signal: opts.signal });\n  opts.signal?.throwIfAborted();\n  result = await store.transaction(() => searchSnapshot(store, cfg, terms, opts, prepared, preparedSignature));\n  opts.signal?.throwIfAborted();\n  if (needsSemanticPreparation(result)) throw new SenseError('INDEX_NOT_READY', 'the semantic search scope changed while its query was being prepared; retry the search against a stable published index');\n  return result;\n}\n\nasync function searchSnapshot(store: Store, cfg: ResolvedConfig, terms: string, opts: SearchOptions, prepared: PreparedSemanticQuery | undefined, preparedSignature: string | undefined): Promise<SearchResult[] | SemanticPreparationNeeded> {\n  const { signature, effective, allPaths, scopePaths, allowedPaths, semanticEligible } = await readSearchScope(store, cfg, terms, opts);\n  if (prepared !== undefined && signature !== preparedSignature) {\n    throw new SenseError('INDEX_NOT_READY', 'the index configuration changed while the semantic query was being prepared; retry after the current build finishes, or rebuild the index for this configuration');\n  }\n  if (semanticEligible && prepared === undefined) return { signature };\n\n  const { k, signals } = effective;\n  const fetch = Math.max(k * 3, 30);\n  const scopeActive = scopePaths.size < allPaths.length;\n  const semanticEnabled = semanticEligible && prepared !== undefined;\n\n  // --where applies inside the candidate query (a post-filter would drop matches ranked past\n  // the pool) and again on the final select, for link-derived rows.\n  const scope = effective.where;\n  const whereJoin = scope ? `JOIN frontmatter f ON f.\"path\" = content.path` : '';\n  const whereCond = scope ? `AND (${scope})` : '';\n  // Filtered before LIMIT, not after, or scoped notes ranking below the global top-`fetch`\n  // never reach the filter; joined against a temp table since real scopes exceed SQLITE_MAX_VARIABLE_NUMBER.\n  if (scopeActive) await materializeScope(store, '_search_scope', scopePaths);\n  const scopeCond = scopeActive ? `AND content.path IN (SELECT \"path\" FROM _search_scope)` : '';\n\n  const candidates: Candidates = new Map();\n  let matchRows: LexicalHit[] = [];\n  const hasEmptyPhrase = [...terms.matchAll(/\"([^\"]*)\"/g)].some((match) => !/[\\p{L}\\p{N}_]/u.test(match[1]));\n  const hasBareSyntaxOnly = /[()]/u.test(terms.replace(/\"[^\"]*\"/g, ' '));\n  // A query that is only whitespace or punctuation has no lexical rows; other declared signals\n  // compose normally. In particular, unspaced-script punctuation can rewrite to an empty MATCH.\n  if (signals.words !== undefined && terms.trim() !== '' && (/[\\p{L}\\p{N}_]/u.test(terms) || hasBareSyntaxOnly) && !hasEmptyPhrase) {\n    const syntaxError = bareTermSyntaxError(terms);\n    if (syntaxError) throw syntaxError;\n    try {\n      matchRows = await wordsCandidates(store, candidates, terms, whereJoin, whereCond, scopeCond, fetch, signals.words, opts.explain);\n    } catch (err) {\n      throw searchError(err as Error, terms, scope);\n    }\n  }\n  // Every store's lexical `snippets` is NULL; the snippet text is always computed below.\n  // Distinguish from via='link' rows, which never appear in matchRows.\n  const matchedPaths = new Set(matchRows.map((r) => r.path));\n\n  if (signals.links !== undefined) await linksCandidates(store, candidates, matchRows, allPaths, allowedPaths, fetch, signals.links, opts.explain);\n\n  let chunkLines = new Map<string, string>();\n  let chunkSimilarity = new Map<string, number>();\n  if (semanticEnabled && signals.vectors !== undefined && prepared !== undefined) {\n    ({ chunkLines, chunkSimilarity } = await vectorsCandidates(store, prepared, candidates, fetch, allowedPaths, allPaths.length, signals.vectors, opts.explain));\n  }\n\n  await store.exec('DROP TABLE IF EXISTS _search');\n  // DOUBLE, not REAL: sqlite's REAL is an 8-byte double but duckdb's is a 4-byte float, and the\n  // rounded score/similarity are printed at full precision in rows.\n  await store.exec('CREATE TEMP TABLE _search (\"path\" TEXT PRIMARY KEY, score DOUBLE, via TEXT, lines TEXT, similarity DOUBLE)');\n  if (candidates.size > 0) {\n    await store.runBatch(\n      'INSERT INTO _search (\"path\", score, via, lines, similarity) VALUES (?, ?, ?, ?, ?)',\n      [...candidates].map(([path, c]) => [path, c.score, c.via, chunkLines.get(path) ?? null, chunkSimilarity.get(path) ?? null])\n    );\n  }\n\n  // Reapplies --where even though _search is already scope+where filtered, since the join to\n  // frontmatter is already needed for the path column.\n  const where = scope ? `WHERE (${scope})` : '';\n  // lines: semantic rows carry their chunk's range, lexical rows gain one below,\n  // everything else stays null; similarity stays semantic-only.\n  const similarityCol = semanticEnabled ? ', _search.similarity' : '';\n  // NULL AS snippets holds this column's position (between summary and via) for every row;\n  // overwritten below, always to an array, never left null (DESIGN.md).\n  const selectStmt = await store.prepare(\n    `SELECT f.\"path\" AS path, content.title, content.summary, NULL AS snippets, _search.via, round(_search.score, 4) AS score, _search.lines${similarityCol}\n       FROM _search JOIN frontmatter f ON f.\"path\" = _search.\"path\" JOIN content ON content.path = _search.\"path\"\n       ${where} ORDER BY _search.score DESC, _search.\"path\" ASC LIMIT ?`\n  );\n  const rows = (await selectStmt.all(k)) as SearchResult[];\n  if (searchCandidatesRead.hasSubscribers) searchCandidatesRead.publish({ paths: rows.map((row) => row.path) });\n  for (const row of rows) row.snippets = [];\n\n  await hydrateSearchRows(store, cfg, rows, matchedPaths, terms, opts);\n  if (opts.explain) {\n    for (const row of rows) row.explanation = candidates.get(row.path)?.explanation ?? [];\n  }\n\n  return rows;\n}\n"],"names":["SNIPPET_CHAR_LIMIT_DEFAULT","SNIPPET_COUNT_LIMIT_DEFAULT","computeSnippets","hydrateSearchRows","lineNumberAt","search","searchCandidatesRead","channel","extractBareTerms","query","cleaned","replace","split","map","tok","flatMap","searchTokens","text","toLowerCase","trim","filter","length","wordSegmenter","findOccurrences","terms","occ","textLower","unspacedTerms","hasUnspacedRun","unspacedRuns","run","runLower","slice","start","end","term","idx","found","indexOf","push","spacedTerms","t","termByStem","Map","stemmer","foldForSearch","stemInitials","Set","Array","from","keys","match","segment","unspaced","folded","has","get","undefined","sort","a","b","wordBoundaries","Intl","Segmenter","granularity","bounds","index","snapForward","pos","lo","hi","mid","snapBackward","result","firstBoundAfter","cutWindow","anchor","charLimit","rawEnd","Math","min","fitEnd","render","floor","upperBound","firstOccAtOrAfter","renderWindow","win","out","cursor","i","o","prefix","suffix","scoreWindows","winEnd","seen","count","j","add","max","e","candidates","distinct","size","overlaps","selectWindows","countLimit","ranked","chosen","c","some","s","best","find","snippets","offset","line","charCodeAt","lineRangeFor","store","path","stmt","row","prepare","start_line","end_line","validateSearchOptions","opts","explain","SenseError","String","k","snippetCharLimit","snippetCountLimit","name","value","Number","isFinite","isInteger","cfg","rows","matchedPaths","bareTerms","sourceStmt","source","lines","featureEnabled","signal","aborted","Promise","reject","reason","serialQuery","searchIndexed","readSearchScope","signature","effective","allPaths","scopePaths","allowedPaths","err","wantsVectors","semanticEligible","assertQuerySnapshot","resolveSearch","all","r","rawScope","narrowByWhere","where","searchError","signals","vectors","ensureDocumentEmbeddings","scopeHasEmbeddings","needsSemanticPreparation","isArray","initial","prepared","preparedSignature","preflight","throwIfAborted","embedConfig","localModelMissing","presetName","MODEL_FILENAMES","model","transaction","prepareSemanticQuery","searchSnapshot","fetch","scopeActive","semanticEnabled","scope","whereJoin","whereCond","scopeCond","matchRows","hasEmptyPhrase","hasBareSyntaxOnly","syntaxError","chunkLines","chunkSimilarity","similarityCol","selectStmt","materializeScope","matchAll","test","words","bareTermSyntaxError","wordsCandidates","links","linksCandidates","vectorsCandidates","exec","runBatch","score","via","hasSubscribers","publish","paths","explanation"],"mappings":"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"}
+{"version":3,"sources":["/Users/kevin/Dev/open-source/ai/sensemaking/src/commands/search.ts"],"sourcesContent":["import { channel } from 'node:diagnostics_channel';\nimport { stemmer } from 'stemmer';\nimport type { EffectiveSearch, ResolvedConfig } from '../config/index.ts';\nimport { embedConfig, featureEnabled, resolveSearch } from '../config/index.ts';\nimport type { PreparedSemanticQuery } from '../embed/query.ts';\nimport { ensureDocumentEmbeddings, prepareSemanticQuery } from '../embed/query.ts';\nimport { localModelMissing, MODEL_FILENAMES } from '../embed/store.ts';\nimport { SenseError } from '../errors.ts';\nimport { serialQuery } from '../lib/serial-query.ts';\nimport { bareTermSyntaxError, searchError } from '../output/search-error.ts';\nimport type { LexicalHit, Store } from '../store/types.ts';\nimport { foldForSearch, hasUnspacedRun, searchTokens, unspacedRuns } from '../text/segment.ts';\nimport { materializeScope, narrowByWhere, rawScope, scopeHasEmbeddings } from './scope.ts';\nimport type { Candidates, SearchResultVia, SearchSignalContribution } from './signals.ts';\nimport { linksCandidates, vectorsCandidates, wordsCandidates } from './signals.ts';\nimport { assertQuerySnapshot } from './snapshot.ts';\n\nexport type { SearchResultVia, SearchSignalContribution } from './signals.ts';\n\n// Default budget behind --snippet-char-limit/--snippet-count-limit: the limit is whatever the\n// caller passes, these only say what happens when they pass nothing (DESIGN.md \"Search snippets\").\nexport const SNIPPET_CHAR_LIMIT_DEFAULT = 80;\nexport const SNIPPET_COUNT_LIMIT_DEFAULT = 1;\n\nconst searchCandidatesRead = channel('sensemaking.search.candidates-read');\n\n// Bare terms from an FTS5 query string: strips operators/quoting, not real terms, so the\n// snippet scan matches what the query matched -- FTS5 operators are uppercase-only, so this is too.\nfunction extractBareTerms(query: string): string[] {\n  const cleaned = query\n    .replace(/\"/g, ' ')\n    .replace(/[()*]/g, ' ')\n    .replace(/\\b(AND|OR|NOT|NEAR)\\b(\\/\\d+)?/g, ' ');\n  return cleaned\n    .split(/\\s+/)\n    .map((tok) => tok.replace(/^[A-Za-z_]\\w*:/, '')) // column filter, e.g. title:term\n    .flatMap((tok) => searchTokens(tok).map(({ text }) => text))\n    .map((tok) => tok.toLowerCase().trim())\n    .filter((tok) => tok.length > 0);\n}\n\n// House convention (src/chunk/group.ts): Intl.Segmenter word boundaries, not a bare \\b, which\n// is ASCII-only. Built on first use: construction is a few ms, paid only when a term matches.\nlet wordSegmenter: Intl.Segmenter | undefined;\n\nfunction findOccurrences(text: string, terms: string[]): Array<{ start: number; end: number; term: string }> {\n  const occ: Array<{ start: number; end: number; term: string }> = [];\n  const textLower = text.toLowerCase();\n\n  // Unspaced scripts (UNSPACED_SCRIPTS) mark no word boundaries: the sense-setup skill promises\n  // substring semantics there, so a matching term is found wherever it occurs in the run.\n  const unspacedTerms = terms.filter(hasUnspacedRun);\n  if (unspacedTerms.length > 0) {\n    for (const run of unspacedRuns(text)) {\n      const runLower = textLower.slice(run.start, run.end);\n      for (const term of unspacedTerms) {\n        let idx = 0;\n        for (;;) {\n          const found = runLower.indexOf(term, idx);\n          if (found === -1) break;\n          occ.push({ start: run.start + found, end: run.start + found + term.length, term });\n          idx = found + term.length;\n        }\n      }\n    }\n  }\n\n  // Spaced scripts: a word is marked when its porter stem equals a query term's stem, the same\n  // algorithm both indexes tokenize with (sqlite's TOKENIZE = 'porter unicode61'; duckdb's fts default).\n  const spacedTerms = terms.filter((t) => !hasUnspacedRun(t));\n  if (spacedTerms.length > 0) {\n    const termByStem = new Map(spacedTerms.map((t) => [stemmer(foldForSearch(t)), t]));\n    const stemInitials = new Set(Array.from(termByStem.keys(), (term) => term[0]));\n    for (const match of searchTokens(text)) {\n      const segment = match.text;\n      if (match.unspaced) continue;\n      const folded = foldForSearch(segment);\n      // Porter stemming changes suffixes only, so a different initial cannot match a query stem.\n      if (!stemInitials.has(folded[0])) continue;\n      const term = termByStem.get(stemmer(folded));\n      if (term !== undefined) occ.push({ start: match.start, end: match.end, term });\n    }\n  }\n\n  return occ.sort((a, b) => a.start - b.start || b.end - a.end);\n}\n\n// Segment boundaries of the whole text, word granularity: the only cut points a snippet edge\n// may land on. One rule for every script (DESIGN.md \"Cutting\") -- a regex \\b is ASCII-only and\n// would mis-cut Japanese, Chinese and Thai, which Intl.Segmenter divides by dictionary instead.\nfunction wordBoundaries(text: string): number[] {\n  wordSegmenter ??= new Intl.Segmenter('en', { granularity: 'word' });\n  const bounds = [0];\n  for (const { index, segment } of wordSegmenter.segment(text)) bounds.push(index + segment.length);\n  return bounds;\n}\n\n// bounds is sorted: snaps are binary searches, since each runs once per candidate window.\nfunction snapForward(bounds: number[], pos: number): number {\n  let lo = 0;\n  let hi = bounds.length - 1;\n  while (lo < hi) {\n    const mid = (lo + hi) >> 1;\n    if (bounds[mid] < pos) lo = mid + 1;\n    else hi = mid;\n  }\n  return bounds[lo];\n}\n\nfunction snapBackward(bounds: number[], pos: number): number {\n  let lo = 0;\n  let hi = bounds.length - 1;\n  let result = bounds[0];\n  while (lo < hi) {\n    const mid = (lo + hi + 1) >> 1;\n    if (bounds[mid] <= pos) {\n      lo = mid;\n      result = bounds[mid];\n    } else hi = mid - 1;\n  }\n  return result;\n}\n\nfunction firstBoundAfter(bounds: number[], pos: number): number | undefined {\n  let lo = 0;\n  let hi = bounds.length;\n  while (lo < hi) {\n    const mid = (lo + hi) >> 1;\n    if (bounds[mid] <= pos) lo = mid + 1;\n    else hi = mid;\n  }\n  return bounds[lo];\n}\n\n// A raw, unmarked upper bound: [start, end) inside [anchor, anchor+charLimit), edges on\n// boundaries. Markup (guillemets, ellipses) added on top of this can push the rendered result\n// past charLimit, which is what fitEnd() below corrects for; this is only the starting guess.\n// A single segment spanning the whole target window (a word longer than the char limit) is the\n// one case where holding the boundary rule means the budget is not a hard ceiling.\nfunction cutWindow(text: string, bounds: number[], anchor: number, charLimit: number): { start: number; end: number } {\n  const rawEnd = Math.min(text.length, anchor + charLimit);\n  const start = snapForward(bounds, anchor);\n  let end = snapBackward(bounds, rawEnd);\n  if (end <= start) end = firstBoundAfter(bounds, start) ?? text.length;\n  return { start, end: Math.min(end, text.length) };\n}\n\n// The largest boundary <= upperBound, > floor, whose rendered [*, end) fits charLimit. Markup\n// only ever adds characters as end grows, so rendered length is non-decreasing in end and\n// shrinking from upperBound is guaranteed to find the true fit rather than guess at it.\n// `floor` is the one end this never shrinks past (the anchor's own marked word, or the first\n// word in the unmarked fallback): DESIGN.md's budget is a ceiling except here, where returning\n// nothing is worse than a single word that overruns it.\nfunction fitEnd(render: (end: number) => string, bounds: number[], floor: number, upperBound: number, charLimit: number): number {\n  let lo = 0;\n  let hi = bounds.length - 1;\n  while (lo < hi) {\n    const mid = (lo + hi + 1) >> 1;\n    if (bounds[mid] <= upperBound) lo = mid;\n    else hi = mid - 1;\n  }\n  for (; lo >= 0 && bounds[lo] > floor; lo--) {\n    if (render(bounds[lo]).length <= charLimit) return bounds[lo];\n  }\n  return floor;\n}\n\ninterface Span {\n  start: number;\n  end: number;\n}\n\ninterface SnippetWindow extends Span {\n  distinct: number;\n  count: number;\n}\n\n// occ is start-sorted: a window's first candidate occurrence is a binary search, not a walk.\nfunction firstOccAtOrAfter(occ: Array<{ start: number; end: number; term: string }>, pos: number): number {\n  let lo = 0;\n  let hi = occ.length;\n  while (lo < hi) {\n    const mid = (lo + hi) >> 1;\n    if (occ[mid].start < pos) lo = mid + 1;\n    else hi = mid;\n  }\n  return lo;\n}\n\nfunction renderWindow(text: string, occ: Array<{ start: number; end: number; term: string }>, win: Span): string {\n  let out = '';\n  let cursor = win.start;\n  for (let i = firstOccAtOrAfter(occ, win.start); i < occ.length && occ[i].start < win.end; i++) {\n    const o = occ[i];\n    if (o.end > win.end) continue;\n    // Occurrences of duplicate or substring-overlapping terms (\"test tests\") can overlap;\n    // emitting each would duplicate document text. Keep the first, absorb the rest.\n    if (o.start < cursor) continue;\n    out += `${text.slice(cursor, o.start)}«${text.slice(o.start, o.end)}»`;\n    cursor = o.end;\n  }\n  out += text.slice(cursor, win.end);\n  const prefix = win.start > 0 ? '…' : '';\n  const suffix = win.end < text.length ? '…' : '';\n  return `${prefix}${out.replace(/\\s+/g, ' ')}${suffix}`;\n}\n\n// Scores every occurrence-anchored candidate window: most distinct terms wins, ties broken by\n// most total hits -- coverage now that occurrences are real words, not the false-fragment counts\n// a substring scan produced. Selection itself is unevaluated (DESIGN.md \"Selection, unsettled\").\n// The window's `end` is fitted to the *rendered* text, markup included, not the raw span: a\n// window dense with marks (every guillemet pair adds two characters) shrinks to fit the same\n// budget a sparse one fills almost exactly.\nfunction scoreWindows(occ: Array<{ start: number; end: number; term: string }>, bounds: number[], text: string, charLimit: number): SnippetWindow[] {\n  const candidates: SnippetWindow[] = [];\n  for (let i = 0; i < occ.length; i++) {\n    const winEnd = occ[i].start + charLimit;\n    const seen = new Set<string>();\n    let count = 0;\n    for (let j = i; j < occ.length && occ[j].start < winEnd; j++) {\n      seen.add(occ[j].term);\n      count++;\n    }\n    const start = snapForward(bounds, occ[i].start);\n    const floor = Math.max(start, occ[i].end);\n    const upperBound = Math.max(floor, cutWindow(text, bounds, occ[i].start, charLimit).end);\n    const end = fitEnd((e) => renderWindow(text, occ, { start, end: e }), bounds, floor, upperBound, charLimit);\n    candidates.push({ start, end, distinct: seen.size, count });\n  }\n  return candidates;\n}\n\nfunction overlaps(a: Span, b: Span): boolean {\n  return a.start < b.end && b.start < a.end;\n}\n\n// Same scoring function as a single snippet, kept rather than discarded (DESIGN.md \"Several\n// snippets per note\"): rank by score, take the top non-overlapping windows, then reorder to the\n// note's own order, since several passages from one note read as an abridged note.\nfunction selectWindows(candidates: SnippetWindow[], countLimit: number): { chosen: SnippetWindow[]; best: SnippetWindow } {\n  const ranked = candidates.slice().sort((a, b) => b.distinct - a.distinct || b.count - a.count);\n  const chosen: SnippetWindow[] = [];\n  for (const c of ranked) {\n    if (chosen.length >= countLimit) break;\n    if (chosen.some((s) => overlaps(s, c))) continue;\n    chosen.push(c);\n  }\n  chosen.sort((a, b) => a.start - b.start);\n  return { chosen, best: ranked[0] };\n}\n\n// Builds bounded marked passages and returns the best window's offset for section lookup.\nexport function computeSnippets(text: string, terms: string[], charLimit: number, countLimit: number): { snippets: string[]; offset: number } {\n  const occ = findOccurrences(text, terms);\n  const bounds = wordBoundaries(text);\n  if (occ.length === 0) {\n    // A term matched only via title/summary, not this body text, finds no occurrence here;\n    // fall back to the doc's start, unmarked.\n    const render = (end: number): string => `${text.slice(0, end).replace(/\\s+/g, ' ').trim()}${end < text.length ? '…' : ''}`;\n    const floor = bounds.find((b) => b > 0) ?? text.length;\n    const upperBound = Math.max(floor, cutWindow(text, bounds, 0, charLimit).end);\n    const end = fitEnd(render, bounds, floor, upperBound, charLimit);\n    return { snippets: [render(end)], offset: 0 };\n  }\n  const candidates = scoreWindows(occ, bounds, text, charLimit);\n  const { chosen, best } = selectWindows(candidates, countLimit);\n  return { snippets: chosen.map((win) => renderWindow(text, occ, win)), offset: best.start };\n}\n\n// Converts an offset in the original text to its one-based line number.\nexport function lineNumberAt(text: string, offset: number): number {\n  let line = 1;\n  for (let i = 0; i < offset; i++) if (text.charCodeAt(i) === 10) line++;\n  return line;\n}\n\nasync function lineRangeFor(store: Store, path: string, line: number): Promise<string | null> {\n  const stmt = await store.prepare('SELECT start_line, end_line FROM sections WHERE \"path\" = ? AND start_line <= ? AND end_line >= ? ORDER BY start_line DESC LIMIT 1');\n  const row = (await stmt.get(path, line, line)) as { start_line: number; end_line: number } | undefined;\n  return row ? `L${row.start_line}-${row.end_line}` : null;\n}\n\n/** Options for the root {@link search} API. */\nexport interface SearchOptions {\n  k?: number;\n  /** Collects ranking contributions for returned candidates; omitted or false preserves ordinary output. */\n  explain?: boolean;\n  where?: string; // SQL fragment against frontmatter alias `f`, e.g. \"f.status = 'active'\"\n  preset?: string; // named preset; unknown name throws listing declared presets, undefined -> \"default\"\n  include?: string[]; // ad hoc scope override (repeatable --include); independent of exclude\n  exclude?: string[]; // ad hoc scope override (repeatable --exclude); independent of include\n  noExclude?: boolean; // --no-exclude: drop the preset's exclude for this command\n  snippetCharLimit?: number; // --snippet-char-limit; defaults to SNIPPET_CHAR_LIMIT_DEFAULT\n  snippetCountLimit?: number; // --snippet-count-limit; defaults to SNIPPET_COUNT_LIMIT_DEFAULT\n  /** Cancels supported provider I/O and stops between phases after active native work finishes. */\n  signal?: AbortSignal;\n}\n\nexport type SearchResult = {\n  path: string;\n  title: string;\n  summary: string;\n  snippets: string[];\n  via: SearchResultVia;\n  score: number;\n  lines: string | null;\n  similarity?: number | null;\n  /** Present only with explain: true, in words/links/vectors order; contributions can differ from via labels. */\n  explanation?: SearchSignalContribution[];\n};\n\nexport interface SearchHydrationRow {\n  path: string;\n  snippets?: string[];\n  lines?: string | null;\n}\n\nfunction validateSearchOptions(opts: SearchOptions): void {\n  if (opts.explain !== undefined && typeof opts.explain !== 'boolean') {\n    throw new SenseError('SEARCH_OPTION_INVALID', `search option \"explain\" must be a boolean, got ${String(opts.explain)}`);\n  }\n  for (const [name, value] of [\n    ['k', opts.k],\n    ['snippetCharLimit', opts.snippetCharLimit],\n    ['snippetCountLimit', opts.snippetCountLimit],\n  ] as const) {\n    if (value !== undefined && (!Number.isFinite(value) || !Number.isInteger(value) || value <= 0)) {\n      throw new SenseError('SEARCH_OPTION_INVALID', `search option \"${name}\" must be a positive finite integer, got ${String(value)}`);\n    }\n  }\n}\n\n// Hydrates already-ranked rows with snippets and containing-section ranges without reranking.\nexport async function hydrateSearchRows(store: Store, cfg: ResolvedConfig, rows: SearchHydrationRow[], matchedPaths: Set<string>, terms: string, opts: Pick<SearchOptions, 'snippetCharLimit' | 'snippetCountLimit'> = {}): Promise<void> {\n  if (matchedPaths.size === 0) return;\n  const bareTerms = extractBareTerms(terms);\n  const charLimit = opts.snippetCharLimit ?? SNIPPET_CHAR_LIMIT_DEFAULT;\n  const countLimit = opts.snippetCountLimit ?? SNIPPET_COUNT_LIMIT_DEFAULT;\n  const sourceStmt = await store.prepare('SELECT text FROM indexed_sources WHERE \"path\" = ?');\n  for (const row of rows) {\n    if (!matchedPaths.has(row.path)) continue;\n    const source = (await sourceStmt.get(row.path)) as { text: string } | undefined;\n    if (!source) throw new SenseError('INDEX_NOT_READY', `indexed source text is missing for ${String(row.path)}; run \\`sense build --force\\` (or library build(config, { force: true })) before querying`);\n    const text = source.text;\n    const { snippets, offset } = computeSnippets(text, bareTerms, charLimit, countLimit);\n    row.snippets = snippets;\n    if (row.lines == null) row.lines = featureEnabled(cfg, 'sections') ? await lineRangeFor(store, row.path, lineNumberAt(text, offset)) : null;\n  }\n}\n\n/**\n * Searches one committed published generation. Provider work precedes the final read transaction;\n * cancellation waits for active native work and transaction cleanup before rejection.\n */\nexport function search(store: Store, cfg: ResolvedConfig, terms: string, opts: SearchOptions = {}): Promise<SearchResult[]> {\n  if (opts.signal?.aborted) return Promise.reject(opts.signal.reason);\n  return serialQuery(store, () => searchIndexed(store, cfg, terms, opts));\n}\n\ninterface SearchScope {\n  signature: string;\n  effective: EffectiveSearch;\n  allPaths: string[];\n  scopePaths: Set<string>;\n  allowedPaths: Set<string>;\n  semanticEligible: boolean;\n}\n\nasync function readSearchScope(store: Store, cfg: ResolvedConfig, terms: string, opts: SearchOptions): Promise<SearchScope> {\n  const signature = await assertQuerySnapshot(store, cfg);\n  const effective = resolveSearch(cfg, opts);\n  const allPaths = ((await (await store.prepare('SELECT \"path\" FROM frontmatter')).all()) as Array<{ path: string }>).map((r) => r.path);\n  const scopePaths = await rawScope(store, cfg, opts, allPaths);\n  let allowedPaths: Set<string>;\n  try {\n    allowedPaths = await narrowByWhere(store, scopePaths, effective.where);\n  } catch (err) {\n    throw searchError(err as Error, terms, effective.where);\n  }\n  const wantsVectors = effective.signals.vectors !== undefined;\n  if (wantsVectors) await ensureDocumentEmbeddings(store, cfg, allowedPaths);\n  const semanticEligible = wantsVectors && (await scopeHasEmbeddings(store, cfg, allowedPaths));\n  return { signature, effective, allPaths, scopePaths, allowedPaths, semanticEligible };\n}\n\ninterface SemanticPreparationNeeded {\n  signature: string;\n}\n\nfunction needsSemanticPreparation(result: SearchResult[] | SemanticPreparationNeeded): result is SemanticPreparationNeeded {\n  return !Array.isArray(result);\n}\n\nasync function searchIndexed(store: Store, cfg: ResolvedConfig, terms: string, opts: SearchOptions): Promise<SearchResult[]> {\n  validateSearchOptions(opts);\n  const initial = resolveSearch(cfg, opts);\n  opts.signal?.throwIfAborted();\n  // A downloadable HF id proceeds -- getProvider fetches it lazily on consent. Only a\n  // local path with missing files errors here, since nothing will ever fetch it for itself.\n  const wantsVectors = initial.signals.vectors !== undefined;\n  if (wantsVectors) {\n    const e = embedConfig(cfg); // validate.ts guarantees this is set whenever \"vectors\" is declared\n    if (localModelMissing(e)) {\n      throw new SenseError('EMBED_MODEL_MISSING', `preset \"${initial.presetName}\" searches with vectors, but the local model path \"${e.model}\" is missing ${MODEL_FILENAMES}; point embed.model at a directory containing them, or drop \"vectors\" from that preset's signals to search without them`);\n    }\n  }\n\n  let prepared: PreparedSemanticQuery | undefined;\n  let preparedSignature: string | undefined;\n  if (wantsVectors) {\n    // This first snapshot only decides whether a semantic query can contribute. It closes before\n    // provider/model work, and the complete scope/readiness decision is repeated below.\n    const preflight = await store.transaction(() => readSearchScope(store, cfg, terms, opts));\n    opts.signal?.throwIfAborted();\n    if (preflight.semanticEligible) {\n      preparedSignature = preflight.signature;\n      prepared = await prepareSemanticQuery(cfg, terms, { signal: opts.signal });\n      opts.signal?.throwIfAborted();\n    }\n  }\n\n  opts.signal?.throwIfAborted();\n  let result = await store.transaction(() => searchSnapshot(store, cfg, terms, opts, prepared, preparedSignature));\n  opts.signal?.throwIfAborted();\n  if (!needsSemanticPreparation(result)) return result;\n\n  // The scope became vector-eligible after an empty/ineligible preflight. Leave that snapshot,\n  // prepare once, then take a fresh final snapshot rather than waiting on the provider inside it.\n  preparedSignature = result.signature;\n  prepared = await prepareSemanticQuery(cfg, terms, { signal: opts.signal });\n  opts.signal?.throwIfAborted();\n  result = await store.transaction(() => searchSnapshot(store, cfg, terms, opts, prepared, preparedSignature));\n  opts.signal?.throwIfAborted();\n  if (needsSemanticPreparation(result)) throw new SenseError('INDEX_NOT_READY', 'the semantic search scope changed while its query was being prepared; retry the search against a stable published index');\n  return result;\n}\n\nasync function searchSnapshot(store: Store, cfg: ResolvedConfig, terms: string, opts: SearchOptions, prepared: PreparedSemanticQuery | undefined, preparedSignature: string | undefined): Promise<SearchResult[] | SemanticPreparationNeeded> {\n  const { signature, effective, allPaths, scopePaths, allowedPaths, semanticEligible } = await readSearchScope(store, cfg, terms, opts);\n  if (prepared !== undefined && signature !== preparedSignature) {\n    throw new SenseError('INDEX_NOT_READY', 'the index configuration changed while the semantic query was being prepared; retry after the current build finishes, or rebuild the index for this configuration');\n  }\n  if (semanticEligible && prepared === undefined) return { signature };\n\n  const { k, signals } = effective;\n  const fetch = Math.max(k * 3, 30);\n  const scopeActive = scopePaths.size < allPaths.length;\n  const semanticEnabled = semanticEligible && prepared !== undefined;\n\n  // --where applies inside the candidate query (a post-filter would drop matches ranked past\n  // the pool) and again on the final select, for link-derived rows.\n  const scope = effective.where;\n  const whereJoin = scope ? `JOIN frontmatter f ON f.\"path\" = content.path` : '';\n  const whereCond = scope ? `AND (${scope})` : '';\n  // Filtered before LIMIT, not after, or scoped notes ranking below the global top-`fetch`\n  // never reach the filter; joined against a temp table since real scopes exceed SQLITE_MAX_VARIABLE_NUMBER.\n  if (scopeActive) await materializeScope(store, '_search_scope', scopePaths);\n  const scopeCond = scopeActive ? `AND content.path IN (SELECT \"path\" FROM _search_scope)` : '';\n\n  const candidates: Candidates = new Map();\n  let matchRows: LexicalHit[] = [];\n  const hasEmptyPhrase = [...terms.matchAll(/\"([^\"]*)\"/g)].some((match) => !/[\\p{L}\\p{N}_]/u.test(match[1]));\n  const hasBareSyntaxOnly = /[()]/u.test(terms.replace(/\"[^\"]*\"/g, ' '));\n  // A query that is only whitespace or punctuation has no lexical rows; other declared signals\n  // compose normally. In particular, unspaced-script punctuation can rewrite to an empty MATCH.\n  if (signals.words !== undefined && terms.trim() !== '' && (/[\\p{L}\\p{N}_]/u.test(terms) || hasBareSyntaxOnly) && !hasEmptyPhrase) {\n    const syntaxError = bareTermSyntaxError(terms);\n    if (syntaxError) throw syntaxError;\n    try {\n      matchRows = await wordsCandidates(store, candidates, terms, whereJoin, whereCond, scopeCond, fetch, signals.words, opts.explain);\n    } catch (err) {\n      throw searchError(err as Error, terms, scope);\n    }\n  }\n  // Every store's lexical `snippets` is NULL; the snippet text is always computed below.\n  // Distinguish from via='link' rows, which never appear in matchRows.\n  const matchedPaths = new Set(matchRows.map((r) => r.path));\n\n  if (signals.links !== undefined) await linksCandidates(store, candidates, matchRows, allPaths, allowedPaths, fetch, signals.links, opts.explain);\n\n  let chunkLines = new Map<string, string>();\n  let chunkSimilarity = new Map<string, number>();\n  if (semanticEnabled && signals.vectors !== undefined && prepared !== undefined) {\n    ({ chunkLines, chunkSimilarity } = await vectorsCandidates(store, prepared, candidates, fetch, allowedPaths, allPaths.length, signals.vectors, opts.explain));\n  }\n\n  await store.exec('DROP TABLE IF EXISTS _search');\n  // DOUBLE, not REAL: sqlite's REAL is an 8-byte double but duckdb's is a 4-byte float, and the\n  // rounded score/similarity are printed at full precision in rows.\n  await store.exec('CREATE TEMP TABLE _search (\"path\" TEXT PRIMARY KEY, score DOUBLE, via TEXT, lines TEXT, similarity DOUBLE)');\n  if (candidates.size > 0) {\n    await store.runBatch(\n      'INSERT INTO _search (\"path\", score, via, lines, similarity) VALUES (?, ?, ?, ?, ?)',\n      [...candidates].map(([path, c]) => [path, c.score, c.via, chunkLines.get(path) ?? null, chunkSimilarity.get(path) ?? null])\n    );\n  }\n\n  // Reapplies --where even though _search is already scope+where filtered, since the join to\n  // frontmatter is already needed for the path column.\n  const where = scope ? `WHERE (${scope})` : '';\n  // lines: semantic rows carry their chunk's range, lexical rows gain one below,\n  // everything else stays null; similarity stays semantic-only.\n  const similarityCol = semanticEnabled ? ', _search.similarity' : '';\n  // NULL AS snippets holds this column's position (between summary and via) for every row;\n  // overwritten below, always to an array, never left null (DESIGN.md).\n  const selectStmt = await store.prepare(\n    `SELECT f.\"path\" AS path, content.title, content.summary, NULL AS snippets, _search.via, round(_search.score, 4) AS score, _search.lines${similarityCol}\n       FROM _search JOIN frontmatter f ON f.\"path\" = _search.\"path\" JOIN content ON content.path = _search.\"path\"\n       ${where} ORDER BY _search.score DESC, _search.\"path\" ASC LIMIT ?`\n  );\n  const rows = (await selectStmt.all(k)) as SearchResult[];\n  if (searchCandidatesRead.hasSubscribers) searchCandidatesRead.publish({ paths: rows.map((row) => row.path) });\n  for (const row of rows) row.snippets = [];\n\n  await hydrateSearchRows(store, cfg, rows, matchedPaths, terms, opts);\n  if (opts.explain) {\n    for (const row of rows) row.explanation = candidates.get(row.path)?.explanation ?? [];\n  }\n\n  return rows;\n}\n"],"names":["SNIPPET_CHAR_LIMIT_DEFAULT","SNIPPET_COUNT_LIMIT_DEFAULT","computeSnippets","hydrateSearchRows","lineNumberAt","search","searchCandidatesRead","channel","extractBareTerms","query","cleaned","replace","split","map","tok","flatMap","searchTokens","text","toLowerCase","trim","filter","length","wordSegmenter","findOccurrences","terms","occ","textLower","unspacedTerms","hasUnspacedRun","unspacedRuns","run","runLower","slice","start","end","term","idx","found","indexOf","push","spacedTerms","t","termByStem","Map","stemmer","foldForSearch","stemInitials","Set","Array","from","keys","match","segment","unspaced","folded","has","get","undefined","sort","a","b","wordBoundaries","Intl","Segmenter","granularity","bounds","index","snapForward","pos","lo","hi","mid","snapBackward","result","firstBoundAfter","cutWindow","anchor","charLimit","rawEnd","Math","min","fitEnd","render","floor","upperBound","firstOccAtOrAfter","renderWindow","win","out","cursor","i","o","prefix","suffix","scoreWindows","winEnd","seen","count","j","add","max","e","candidates","distinct","size","overlaps","selectWindows","countLimit","ranked","chosen","c","some","s","best","find","snippets","offset","line","charCodeAt","lineRangeFor","store","path","stmt","row","prepare","start_line","end_line","validateSearchOptions","opts","explain","SenseError","String","k","snippetCharLimit","snippetCountLimit","name","value","Number","isFinite","isInteger","cfg","rows","matchedPaths","bareTerms","sourceStmt","source","lines","featureEnabled","signal","aborted","Promise","reject","reason","serialQuery","searchIndexed","readSearchScope","signature","effective","allPaths","scopePaths","allowedPaths","err","wantsVectors","semanticEligible","assertQuerySnapshot","resolveSearch","all","r","rawScope","narrowByWhere","where","searchError","signals","vectors","ensureDocumentEmbeddings","scopeHasEmbeddings","needsSemanticPreparation","isArray","initial","prepared","preparedSignature","preflight","throwIfAborted","embedConfig","localModelMissing","presetName","MODEL_FILENAMES","model","transaction","prepareSemanticQuery","searchSnapshot","fetch","scopeActive","semanticEnabled","scope","whereJoin","whereCond","scopeCond","matchRows","hasEmptyPhrase","hasBareSyntaxOnly","syntaxError","chunkLines","chunkSimilarity","similarityCol","selectStmt","materializeScope","matchAll","test","words","bareTermSyntaxError","wordsCandidates","links","linksCandidates","vectorsCandidates","exec","runBatch","score","via","hasSubscribers","publish","paths","explanation"],"mappings":"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"}

package/dist/cjs/commands/signals.js.map

@@ -1 +1 @@
-{"version":3,"sources":["/Users/kevin/Dev/OpenSource/ai/sensemaking/src/commands/signals.ts"],"sourcesContent":["import type { SignalName } from '../config/index.ts';\nimport type { PreparedSemanticQuery } from '../embed/query.ts';\nimport { semanticCandidates } from '../embed/query.ts';\nimport { LINK_EDGES_SQL, toEdges } from '../features/index.ts';\nimport { personalizedRank } from '../graph/graph.ts';\nimport type { LexicalHit, Store } from '../store/types.ts';\nimport { withMaterializedVectorScope } from './scope.ts';\n\n// RRF composes whatever the preset declares; the constant lives here since it belongs to\n// the fusion these three functions share, not to search() itself.\nconst RRF_K = 60;\n\nexport type SearchResultVia = 'match' | 'match+link' | 'link' | 'match+vector' | 'match+link+vector' | 'link+vector' | 'vector';\n\n/** One participating signal's contribution captured during the existing ranking computation. */\nexport interface SearchSignalContribution {\n  signal: SignalName;\n  /** One-based position; fusion uses weight / (60 + rank - 1). */\n  rank: number;\n  /** Effective weight from the selected preset. */\n  weight: number;\n  /** Unrounded value added to the fused score, independent of the rounded public score and via label. */\n  contribution: number;\n}\n\ninterface Candidate {\n  score: number;\n  via: SearchResultVia;\n  explanation?: SearchSignalContribution[];\n}\n\nexport type Candidates = Map<string, Candidate>;\n\nfunction withVector(via: SearchResultVia): SearchResultVia {\n  if (via === 'match') return 'match+vector';\n  if (via === 'match+link') return 'match+link+vector';\n  if (via === 'link') return 'link+vector';\n  return via;\n}\n\n// BM25 match rows (store.lexical.query), folded into `candidates` by reciprocal rank scaled by\n// the preset's declared weight for this signal. Every other signal is seeded from its output.\nexport async function wordsCandidates(store: Store, candidates: Candidates, query: string, whereJoin: string, whereCond: string, scopeCond: string, fetch: number, weight: number, explain = false): Promise<LexicalHit[]> {\n  const matchRows = await store.lexical.query(query, { whereJoin, whereCond, scopeCond, limit: fetch });\n  matchRows.forEach((r, i) => {\n    const contribution = weight / (RRF_K + i);\n    const candidate: Candidate = { score: contribution, via: 'match' };\n    if (explain) candidate.explanation = [{ signal: 'words', rank: i + 1, weight, contribution }];\n    candidates.set(r.path, candidate);\n  });\n  return matchRows;\n}\n\n// Personalized-PageRank expansion from the word-match seeds, folded into `candidates` at this\n// signal's weight. A no-op when there is nothing to seed from (matchRows empty).\nexport async function linksCandidates(store: Store, candidates: Candidates, matchRows: LexicalHit[], allPaths: string[], allowedPaths: Set<string>, fetch: number, weight: number, explain = false): Promise<void> {\n  if (matchRows.length === 0) return;\n  const stmt = await store.prepare(LINK_EDGES_SQL);\n  const edges = toEdges((await stmt.all()) as Array<{ src: string; dst: string }>);\n  if (edges.length === 0) return;\n  // Gates the label only, not the score: restart mass ranks every seed without an incident\n  // edge, but dropping it from the score reweights fusion (FEVER hit@10 0.997 -> 0.907).\n  const linked = new Set(edges.flat());\n  const seeds = new Map(matchRows.map((r, i) => [r.path, 1 / (i + 1)]));\n  const ranked = [...personalizedRank(allPaths, edges, seeds)]\n    .filter(([path, score]) => score > 1e-9 && allowedPaths.has(path))\n    .sort((a, b) => b[1] - a[1] || Buffer.compare(Buffer.from(a[0]), Buffer.from(b[0])))\n    .slice(0, fetch);\n  ranked.forEach(([path], i) => {\n    const contribution = weight / (RRF_K + i);\n    const existing = candidates.get(path);\n    if (existing) {\n      existing.score += contribution;\n      if (explain) {\n        existing.explanation ??= [];\n        existing.explanation.push({ signal: 'links', rank: i + 1, weight, contribution });\n      }\n      if (linked.has(path)) existing.via = 'match+link';\n    } else {\n      const candidate: Candidate = { score: contribution, via: 'link' };\n      if (explain) candidate.explanation = [{ signal: 'links', rank: i + 1, weight, contribution }];\n      candidates.set(path, candidate);\n    }\n  });\n}\n\n// Vector expansion at the swept flat-region constants (pool = fetch), folded into `candidates`\n// at this signal's weight; each row also carries its best chunk's line range and similarity.\nexport async function vectorsCandidates(store: Store, prepared: PreparedSemanticQuery, candidates: Candidates, fetch: number, allowedPaths: Set<string>, totalPaths: number, weight: number, explain = false): Promise<{ chunkLines: Map<string, string>; chunkSimilarity: Map<string, number> }> {\n  const chunkLines = new Map<string, string>();\n  const chunkSimilarity = new Map<string, number>();\n  const vec = await withMaterializedVectorScope(store, allowedPaths, () => semanticCandidates(store, prepared, fetch, allowedPaths), totalPaths);\n  vec.forEach(({ path, lines, similarity }, i) => {\n    const contribution = weight / (RRF_K + i);\n    chunkLines.set(path, lines);\n    chunkSimilarity.set(path, similarity);\n    const existing = candidates.get(path);\n    if (existing) {\n      existing.score += contribution;\n      if (explain) {\n        existing.explanation ??= [];\n        existing.explanation.push({ signal: 'vectors', rank: i + 1, weight, contribution });\n      }\n      existing.via = withVector(existing.via);\n    } else {\n      const candidate: Candidate = { score: contribution, via: 'vector' };\n      if (explain) candidate.explanation = [{ signal: 'vectors', rank: i + 1, weight, contribution }];\n      candidates.set(path, candidate);\n    }\n  });\n  return { chunkLines, chunkSimilarity };\n}\n"],"names":["linksCandidates","vectorsCandidates","wordsCandidates","RRF_K","withVector","via","store","candidates","query","whereJoin","whereCond","scopeCond","fetch","weight","explain","matchRows","lexical","limit","forEach","r","i","contribution","candidate","score","explanation","signal","rank","set","path","allPaths","allowedPaths","stmt","edges","linked","seeds","ranked","length","prepare","LINK_EDGES_SQL","all","toEdges","Set","flat","Map","map","personalizedRank","filter","has","sort","a","b","Buffer","compare","from","slice","existing","get","push","prepared","totalPaths","chunkLines","chunkSimilarity","vec","withMaterializedVectorScope","semanticCandidates","lines","similarity"],"mappings":";;;;;;;;;;;QAuDsBA;eAAAA;;QAiCAC;eAAAA;;QA9CAC;eAAAA;;;uBAxCa;uBACK;uBACP;uBAEW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAE5C,yFAAyF;AACzF,kEAAkE;AAClE,IAAMC,QAAQ;AAuBd,SAASC,WAAWC,GAAoB;IACtC,IAAIA,QAAQ,SAAS,OAAO;IAC5B,IAAIA,QAAQ,cAAc,OAAO;IACjC,IAAIA,QAAQ,QAAQ,OAAO;IAC3B,OAAOA;AACT;AAIO,SAAeH,gBAAgBI,KAAY,EAAEC,UAAsB,EAAEC,KAAa,EAAEC,SAAiB,EAAEC,SAAiB,EAAEC,SAAiB,EAAEC,KAAa,EAAEC,MAAc;QAAEC,UAAAA,iEAAU;;YACrLC;;;;oBAAY;;wBAAMT,MAAMU,OAAO,CAACR,KAAK,CAACA,OAAO;4BAAEC,WAAAA;4BAAWC,WAAAA;4BAAWC,WAAAA;4BAAWM,OAAOL;wBAAM;;;oBAA7FG,YAAY;oBAClBA,UAAUG,OAAO,CAAC,SAACC,GAAGC;wBACpB,IAAMC,eAAeR,SAAUV,CAAAA,QAAQiB,CAAAA;wBACvC,IAAME,YAAuB;4BAAEC,OAAOF;4BAAchB,KAAK;wBAAQ;wBACjE,IAAIS,SAASQ,UAAUE,WAAW,GAAG;4BAAC;gCAAEC,QAAQ;gCAASC,MAAMN,IAAI;gCAAGP,QAAAA;gCAAQQ,cAAAA;4BAAa;yBAAE;wBAC7Fd,WAAWoB,GAAG,CAACR,EAAES,IAAI,EAAEN;oBACzB;oBACA;;wBAAOP;;;;IACT;;AAIO,SAAef,gBAAgBM,KAAY,EAAEC,UAAsB,EAAEQ,SAAuB,EAAEc,QAAkB,EAAEC,YAAyB,EAAElB,KAAa,EAAEC,MAAc;QAAEC,UAAAA,iEAAU;;YAErLiB,MACAC,OAIAC,QACAC,OACAC;;;;oBARN,IAAIpB,UAAUqB,MAAM,KAAK,GAAG;;;oBACf;;wBAAM9B,MAAM+B,OAAO,CAACC,uBAAc;;;oBAAzCP,OAAO;oBACU;;wBAAMA,KAAKQ,GAAG;;;oBAA/BP,QAAQQ,gBAAO;wBAAE;;oBACvB,IAAIR,MAAMI,MAAM,KAAK,GAAG;;;oBACxB,yFAAyF;oBACzF,uFAAuF;oBACjFH,SAAS,IAAIQ,IAAIT,MAAMU,IAAI;oBAC3BR,QAAQ,IAAIS,IAAI5B,UAAU6B,GAAG,CAAC,SAACzB,GAAGC;+BAAM;4BAACD,EAAES,IAAI;4BAAE,IAAKR,CAAAA,IAAI,CAAA;yBAAG;;oBAC7De,SAAS,AAAC,qBAAGU,IAAAA,yBAAgB,EAAChB,UAAUG,OAAOE,QAClDY,MAAM,CAAC;iEAAElB,kBAAML;+BAAWA,QAAQ,QAAQO,aAAaiB,GAAG,CAACnB;uBAC3DoB,IAAI,CAAC,SAACC,GAAGC;+BAAMA,CAAC,CAAC,EAAE,GAAGD,CAAC,CAAC,EAAE,IAAIE,OAAOC,OAAO,CAACD,OAAOE,IAAI,CAACJ,CAAC,CAAC,EAAE,GAAGE,OAAOE,IAAI,CAACH,CAAC,CAAC,EAAE;uBAChFI,KAAK,CAAC,GAAG1C;oBACZuB,OAAOjB,OAAO,CAAC,gBAASE;iEAAPQ;wBACf,IAAMP,eAAeR,SAAUV,CAAAA,QAAQiB,CAAAA;wBACvC,IAAMmC,WAAWhD,WAAWiD,GAAG,CAAC5B;wBAChC,IAAI2B,UAAU;4BACZA,SAAShC,KAAK,IAAIF;4BAClB,IAAIP,SAAS;oCACXyC,WAAAA;iCAAAA,eAAAA,CAAAA,YAAAA,UAAS/B,WAAW,cAApB+B,0BAAAA,eAAAA,UAAS/B,WAAW,GAAK,EAAE;gCAC3B+B,SAAS/B,WAAW,CAACiC,IAAI,CAAC;oCAAEhC,QAAQ;oCAASC,MAAMN,IAAI;oCAAGP,QAAAA;oCAAQQ,cAAAA;gCAAa;4BACjF;4BACA,IAAIY,OAAOc,GAAG,CAACnB,OAAO2B,SAASlD,GAAG,GAAG;wBACvC,OAAO;4BACL,IAAMiB,YAAuB;gCAAEC,OAAOF;gCAAchB,KAAK;4BAAO;4BAChE,IAAIS,SAASQ,UAAUE,WAAW,GAAG;gCAAC;oCAAEC,QAAQ;oCAASC,MAAMN,IAAI;oCAAGP,QAAAA;oCAAQQ,cAAAA;gCAAa;6BAAE;4BAC7Fd,WAAWoB,GAAG,CAACC,MAAMN;wBACvB;oBACF;;;;;;IACF;;AAIO,SAAerB,kBAAkBK,KAAY,EAAEoD,QAA+B,EAAEnD,UAAsB,EAAEK,KAAa,EAAEkB,YAAyB,EAAE6B,UAAkB,EAAE9C,MAAc;QAAEC,UAAAA,iEAAU;;YAC/L8C,YACAC,iBACAC;;;;oBAFAF,aAAa,IAAIjB;oBACjBkB,kBAAkB,IAAIlB;oBAChB;;wBAAMoB,IAAAA,oCAA2B,EAACzD,OAAOwB,cAAc;mCAAMkC,IAAAA,2BAAkB,EAAC1D,OAAOoD,UAAU9C,OAAOkB;2BAAe6B;;;oBAA7HG,MAAM;oBACZA,IAAI5C,OAAO,CAAC,gBAA8BE;4BAA3BQ,aAAAA,MAAMqC,cAAAA,OAAOC,mBAAAA;wBAC1B,IAAM7C,eAAeR,SAAUV,CAAAA,QAAQiB,CAAAA;wBACvCwC,WAAWjC,GAAG,CAACC,MAAMqC;wBACrBJ,gBAAgBlC,GAAG,CAACC,MAAMsC;wBAC1B,IAAMX,WAAWhD,WAAWiD,GAAG,CAAC5B;wBAChC,IAAI2B,UAAU;4BACZA,SAAShC,KAAK,IAAIF;4BAClB,IAAIP,SAAS;oCACXyC,WAAAA;iCAAAA,eAAAA,CAAAA,YAAAA,UAAS/B,WAAW,cAApB+B,0BAAAA,eAAAA,UAAS/B,WAAW,GAAK,EAAE;gCAC3B+B,SAAS/B,WAAW,CAACiC,IAAI,CAAC;oCAAEhC,QAAQ;oCAAWC,MAAMN,IAAI;oCAAGP,QAAAA;oCAAQQ,cAAAA;gCAAa;4BACnF;4BACAkC,SAASlD,GAAG,GAAGD,WAAWmD,SAASlD,GAAG;wBACxC,OAAO;4BACL,IAAMiB,YAAuB;gCAAEC,OAAOF;gCAAchB,KAAK;4BAAS;4BAClE,IAAIS,SAASQ,UAAUE,WAAW,GAAG;gCAAC;oCAAEC,QAAQ;oCAAWC,MAAMN,IAAI;oCAAGP,QAAAA;oCAAQQ,cAAAA;gCAAa;6BAAE;4BAC/Fd,WAAWoB,GAAG,CAACC,MAAMN;wBACvB;oBACF;oBACA;;wBAAO;4BAAEsC,YAAAA;4BAAYC,iBAAAA;wBAAgB;;;;IACvC"}
+{"version":3,"sources":["/Users/kevin/Dev/open-source/ai/sensemaking/src/commands/signals.ts"],"sourcesContent":["import type { SignalName } from '../config/index.ts';\nimport type { PreparedSemanticQuery } from '../embed/query.ts';\nimport { semanticCandidates } from '../embed/query.ts';\nimport { LINK_EDGES_SQL, toEdges } from '../features/index.ts';\nimport { personalizedRank } from '../graph/graph.ts';\nimport type { LexicalHit, Store } from '../store/types.ts';\nimport { withMaterializedVectorScope } from './scope.ts';\n\n// RRF composes whatever the preset declares; the constant lives here since it belongs to\n// the fusion these three functions share, not to search() itself.\nconst RRF_K = 60;\n\nexport type SearchResultVia = 'match' | 'match+link' | 'link' | 'match+vector' | 'match+link+vector' | 'link+vector' | 'vector';\n\n/** One participating signal's contribution captured during the existing ranking computation. */\nexport interface SearchSignalContribution {\n  signal: SignalName;\n  /** One-based position; fusion uses weight / (60 + rank - 1). */\n  rank: number;\n  /** Effective weight from the selected preset. */\n  weight: number;\n  /** Unrounded value added to the fused score, independent of the rounded public score and via label. */\n  contribution: number;\n}\n\ninterface Candidate {\n  score: number;\n  via: SearchResultVia;\n  explanation?: SearchSignalContribution[];\n}\n\nexport type Candidates = Map<string, Candidate>;\n\nfunction withVector(via: SearchResultVia): SearchResultVia {\n  if (via === 'match') return 'match+vector';\n  if (via === 'match+link') return 'match+link+vector';\n  if (via === 'link') return 'link+vector';\n  return via;\n}\n\n// BM25 match rows (store.lexical.query), folded into `candidates` by reciprocal rank scaled by\n// the preset's declared weight for this signal. Every other signal is seeded from its output.\nexport async function wordsCandidates(store: Store, candidates: Candidates, query: string, whereJoin: string, whereCond: string, scopeCond: string, fetch: number, weight: number, explain = false): Promise<LexicalHit[]> {\n  const matchRows = await store.lexical.query(query, { whereJoin, whereCond, scopeCond, limit: fetch });\n  matchRows.forEach((r, i) => {\n    const contribution = weight / (RRF_K + i);\n    const candidate: Candidate = { score: contribution, via: 'match' };\n    if (explain) candidate.explanation = [{ signal: 'words', rank: i + 1, weight, contribution }];\n    candidates.set(r.path, candidate);\n  });\n  return matchRows;\n}\n\n// Personalized-PageRank expansion from the word-match seeds, folded into `candidates` at this\n// signal's weight. A no-op when there is nothing to seed from (matchRows empty).\nexport async function linksCandidates(store: Store, candidates: Candidates, matchRows: LexicalHit[], allPaths: string[], allowedPaths: Set<string>, fetch: number, weight: number, explain = false): Promise<void> {\n  if (matchRows.length === 0) return;\n  const stmt = await store.prepare(LINK_EDGES_SQL);\n  const edges = toEdges((await stmt.all()) as Array<{ src: string; dst: string }>);\n  if (edges.length === 0) return;\n  // Gates the label only, not the score: restart mass ranks every seed without an incident\n  // edge, but dropping it from the score reweights fusion (FEVER hit@10 0.997 -> 0.907).\n  const linked = new Set(edges.flat());\n  const seeds = new Map(matchRows.map((r, i) => [r.path, 1 / (i + 1)]));\n  const ranked = [...personalizedRank(allPaths, edges, seeds)]\n    .filter(([path, score]) => score > 1e-9 && allowedPaths.has(path))\n    .sort((a, b) => b[1] - a[1] || Buffer.compare(Buffer.from(a[0]), Buffer.from(b[0])))\n    .slice(0, fetch);\n  ranked.forEach(([path], i) => {\n    const contribution = weight / (RRF_K + i);\n    const existing = candidates.get(path);\n    if (existing) {\n      existing.score += contribution;\n      if (explain) {\n        existing.explanation ??= [];\n        existing.explanation.push({ signal: 'links', rank: i + 1, weight, contribution });\n      }\n      if (linked.has(path)) existing.via = 'match+link';\n    } else {\n      const candidate: Candidate = { score: contribution, via: 'link' };\n      if (explain) candidate.explanation = [{ signal: 'links', rank: i + 1, weight, contribution }];\n      candidates.set(path, candidate);\n    }\n  });\n}\n\n// Vector expansion at the swept flat-region constants (pool = fetch), folded into `candidates`\n// at this signal's weight; each row also carries its best chunk's line range and similarity.\nexport async function vectorsCandidates(store: Store, prepared: PreparedSemanticQuery, candidates: Candidates, fetch: number, allowedPaths: Set<string>, totalPaths: number, weight: number, explain = false): Promise<{ chunkLines: Map<string, string>; chunkSimilarity: Map<string, number> }> {\n  const chunkLines = new Map<string, string>();\n  const chunkSimilarity = new Map<string, number>();\n  const vec = await withMaterializedVectorScope(store, allowedPaths, () => semanticCandidates(store, prepared, fetch, allowedPaths), totalPaths);\n  vec.forEach(({ path, lines, similarity }, i) => {\n    const contribution = weight / (RRF_K + i);\n    chunkLines.set(path, lines);\n    chunkSimilarity.set(path, similarity);\n    const existing = candidates.get(path);\n    if (existing) {\n      existing.score += contribution;\n      if (explain) {\n        existing.explanation ??= [];\n        existing.explanation.push({ signal: 'vectors', rank: i + 1, weight, contribution });\n      }\n      existing.via = withVector(existing.via);\n    } else {\n      const candidate: Candidate = { score: contribution, via: 'vector' };\n      if (explain) candidate.explanation = [{ signal: 'vectors', rank: i + 1, weight, contribution }];\n      candidates.set(path, candidate);\n    }\n  });\n  return { chunkLines, chunkSimilarity };\n}\n"],"names":["linksCandidates","vectorsCandidates","wordsCandidates","RRF_K","withVector","via","store","candidates","query","whereJoin","whereCond","scopeCond","fetch","weight","explain","matchRows","lexical","limit","forEach","r","i","contribution","candidate","score","explanation","signal","rank","set","path","allPaths","allowedPaths","stmt","edges","linked","seeds","ranked","length","prepare","LINK_EDGES_SQL","all","toEdges","Set","flat","Map","map","personalizedRank","filter","has","sort","a","b","Buffer","compare","from","slice","existing","get","push","prepared","totalPaths","chunkLines","chunkSimilarity","vec","withMaterializedVectorScope","semanticCandidates","lines","similarity"],"mappings":"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"}

package/dist/cjs/commands/snapshot.js.map

@@ -1 +1 @@
-{"version":3,"sources":["/Users/kevin/Dev/OpenSource/ai/sensemaking/src/commands/snapshot.ts"],"sourcesContent":["import type { ResolvedConfig } from '../config/index.ts';\nimport { featureSignature } from '../config/index.ts';\nimport { SenseError } from '../errors.ts';\nimport { FEATURES } from '../features/index.ts';\nimport { CORE_READY_META_KEY, FEATURE_SIGNATURE_META_KEY, isCoreReady, isPublishedFeatureSignature } from '../store/readiness.ts';\nimport type { Store } from '../store/types.ts';\n\n// Read-only policy check for a caller-owned transaction. The store readiness module owns the\n// durable keys and compatibility rules; commands only require one published generation before\n// reading scope, candidates, graph state, and result details from that same snapshot.\nexport async function assertQuerySnapshot(store: Store, cfg: ResolvedConfig): Promise<string> {\n  const stmt = await store.prepare('SELECT key, value FROM meta WHERE key IN (?, ?)');\n  const rows = (await stmt.all(CORE_READY_META_KEY, FEATURE_SIGNATURE_META_KEY)) as Array<{ key: string; value: string }>;\n  const values = new Map(rows.map((row) => [row.key, row.value]));\n  if (!isCoreReady(values.get(CORE_READY_META_KEY) ?? null)) {\n    throw new SenseError('INDEX_NOT_READY', 'the index has no complete published generation; wait for the active build to finish, or run `sense build` (or library build(config)) to recover it');\n  }\n\n  const actual = values.get(FEATURE_SIGNATURE_META_KEY) ?? null;\n  const expected = featureSignature(cfg, FEATURES);\n  if (actual === null || !isPublishedFeatureSignature(actual, expected)) {\n    throw new SenseError('INDEX_NOT_READY', 'the published index was built for different configuration features; rebuild it with `sense build` (or library build(config)) before querying');\n  }\n  return actual;\n}\n"],"names":["assertQuerySnapshot","store","cfg","values","stmt","rows","actual","expected","prepare","all","CORE_READY_META_KEY","FEATURE_SIGNATURE_META_KEY","Map","map","row","key","value","isCoreReady","get","SenseError","featureSignature","FEATURES","isPublishedFeatureSignature"],"mappings":";;;;+BAUsBA;;;eAAAA;;;uBATW;wBACN;wBACF;2BACiF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAMnG,SAAeA,oBAAoBC,KAAY,EAAEC,GAAmB;;YAIxDC,aAIFA,cAPTC,MACAC,MACAF,QAKAG,QACAC;;;;oBARO;;wBAAMN,MAAMO,OAAO,CAAC;;;oBAA3BJ,OAAO;oBACC;;wBAAMA,KAAKK,GAAG,CAACC,gCAAmB,EAAEC,uCAA0B;;;oBAAtEN,OAAQ;oBACRF,SAAS,IAAIS,IAAIP,KAAKQ,GAAG,CAAC,SAACC;+BAAQ;4BAACA,IAAIC,GAAG;4BAAED,IAAIE,KAAK;yBAAC;;oBAC7D,IAAI,CAACC,IAAAA,wBAAW,GAACd,cAAAA,OAAOe,GAAG,CAACR,gCAAmB,eAA9BP,yBAAAA,cAAmC,OAAO;wBACzD,MAAM,IAAIgB,oBAAU,CAAC,mBAAmB;oBAC1C;oBAEMb,UAASH,eAAAA,OAAOe,GAAG,CAACP,uCAA0B,eAArCR,0BAAAA,eAA0C;oBACnDI,WAAWa,IAAAA,yBAAgB,EAAClB,KAAKmB,kBAAQ;oBAC/C,IAAIf,WAAW,QAAQ,CAACgB,IAAAA,wCAA2B,EAAChB,QAAQC,WAAW;wBACrE,MAAM,IAAIY,oBAAU,CAAC,mBAAmB;oBAC1C;oBACA;;wBAAOb;;;;IACT"}
+{"version":3,"sources":["/Users/kevin/Dev/open-source/ai/sensemaking/src/commands/snapshot.ts"],"sourcesContent":["import type { ResolvedConfig } from '../config/index.ts';\nimport { featureSignature } from '../config/index.ts';\nimport { SenseError } from '../errors.ts';\nimport { FEATURES } from '../features/index.ts';\nimport { CORE_READY_META_KEY, FEATURE_SIGNATURE_META_KEY, isCoreReady, isPublishedFeatureSignature } from '../store/readiness.ts';\nimport type { Store } from '../store/types.ts';\n\n// Read-only policy check for a caller-owned transaction. The store readiness module owns the\n// durable keys and compatibility rules; commands only require one published generation before\n// reading scope, candidates, graph state, and result details from that same snapshot.\nexport async function assertQuerySnapshot(store: Store, cfg: ResolvedConfig): Promise<string> {\n  const stmt = await store.prepare('SELECT key, value FROM meta WHERE key IN (?, ?)');\n  const rows = (await stmt.all(CORE_READY_META_KEY, FEATURE_SIGNATURE_META_KEY)) as Array<{ key: string; value: string }>;\n  const values = new Map(rows.map((row) => [row.key, row.value]));\n  if (!isCoreReady(values.get(CORE_READY_META_KEY) ?? null)) {\n    throw new SenseError('INDEX_NOT_READY', 'the index has no complete published generation; wait for the active build to finish, or run `sense build` (or library build(config)) to recover it');\n  }\n\n  const actual = values.get(FEATURE_SIGNATURE_META_KEY) ?? null;\n  const expected = featureSignature(cfg, FEATURES);\n  if (actual === null || !isPublishedFeatureSignature(actual, expected)) {\n    throw new SenseError('INDEX_NOT_READY', 'the published index was built for different configuration features; rebuild it with `sense build` (or library build(config)) before querying');\n  }\n  return actual;\n}\n"],"names":["assertQuerySnapshot","store","cfg","values","stmt","rows","actual","expected","prepare","all","CORE_READY_META_KEY","FEATURE_SIGNATURE_META_KEY","Map","map","row","key","value","isCoreReady","get","SenseError","featureSignature","FEATURES","isPublishedFeatureSignature"],"mappings":";;;;+BAUsBA;;;eAAAA;;;uBATW;wBACN;wBACF;2BACiF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAMnG,SAAeA,oBAAoBC,KAAY,EAAEC,GAAmB;;YAIxDC,aAIFA,cAPTC,MACAC,MACAF,QAKAG,QACAC;;;;oBARO;;wBAAMN,MAAMO,OAAO,CAAC;;;oBAA3BJ,OAAO;oBACC;;wBAAMA,KAAKK,GAAG,CAACC,gCAAmB,EAAEC,uCAA0B;;;oBAAtEN,OAAQ;oBACRF,SAAS,IAAIS,IAAIP,KAAKQ,GAAG,CAAC,SAACC;+BAAQ;4BAACA,IAAIC,GAAG;4BAAED,IAAIE,KAAK;yBAAC;;oBAC7D,IAAI,CAACC,IAAAA,wBAAW,GAACd,cAAAA,OAAOe,GAAG,CAACR,gCAAmB,eAA9BP,yBAAAA,cAAmC,OAAO;wBACzD,MAAM,IAAIgB,oBAAU,CAAC,mBAAmB;oBAC1C;oBAEMb,UAASH,eAAAA,OAAOe,GAAG,CAACP,uCAA0B,eAArCR,0BAAAA,eAA0C;oBACnDI,WAAWa,IAAAA,yBAAgB,EAAClB,KAAKmB,kBAAQ;oBAC/C,IAAIf,WAAW,QAAQ,CAACgB,IAAAA,wCAA2B,EAAChB,QAAQC,WAAW;wBACrE,MAAM,IAAIY,oBAAU,CAAC,mBAAmB;oBAC1C;oBACA;;wBAAOb;;;;IACT"}

package/dist/cjs/commands/status.js.map

@@ -1 +1 @@
-{"version":3,"sources":["/Users/kevin/Dev/OpenSource/ai/sensemaking/src/commands/status.ts"],"sourcesContent":["import type { ResolvedConfig, SignalWeights } from '../config/index.ts';\nimport { anyPresetEmbeds, presetNames, presetSignals } from '../config/index.ts';\nimport type { Store } from '../store/types.ts';\n\nexport interface PresetCoverage {\n  name: string;\n  files: number;\n  embedded: number;\n  // Reported so 0 embedded reads as \"this scope declined vectors\" rather than \"not yet built\".\n  signals: SignalWeights;\n}\n\n// Indexing derives from presets, so the derivation stays visible. Read from preset_files, not\n// recomputed from globs, so it reflects the cache rather than the config.\nexport async function presetCoverage(store: Store, cfg: ResolvedConfig): Promise<PresetCoverage[]> {\n  const embedActive = anyPresetEmbeds(cfg);\n  const filesStmt = await store.prepare('SELECT COUNT(*) AS n FROM preset_files WHERE preset = ?');\n  const embeddedStmt = embedActive ? await store.prepare('SELECT COUNT(*) AS n FROM preset_files pf WHERE pf.preset = ? AND EXISTS (SELECT 1 FROM embeddings e WHERE e.\"path\" = pf.\"path\" AND e.vector IS NOT NULL)') : null;\n  // Sequential, not Promise.all: both statements are reused across presets, and a store's\n  // prepared statement is not safe to bind/run concurrently with itself.\n  const rows: PresetCoverage[] = [];\n  for (const name of presetNames(cfg)) {\n    const files = ((await filesStmt.get(name)) as { n: number }).n;\n    const embedded = embeddedStmt ? ((await embeddedStmt.get(name)) as { n: number }).n : 0;\n    rows.push({ name, files, embedded, signals: presetSignals(cfg, name) });\n  }\n  return rows;\n}\n"],"names":["presetCoverage","store","cfg","embedActive","filesStmt","embeddedStmt","rows","name","files","embedded","anyPresetEmbeds","prepare","presetNames","get","n","push","signals","presetSignals"],"mappings":";;;;+BAcsBA;;;eAAAA;;;uBAbsC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAarD,SAAeA,eAAeC,KAAY,EAAEC,GAAmB;;YAC9DC,aACAC,WACAC,oBAGAC,MACD,2BAAA,mBAAA,gBAAA,WAAA,OAAMC,MACHC,OACAC;;;;oBARFN,cAAcO,IAAAA,wBAAe,EAACR;oBAClB;;wBAAMD,MAAMU,OAAO,CAAC;;;oBAAhCP,YAAY;yBACGD,aAAAA;;;;oBAAc;;wBAAMF,MAAMU,OAAO,CAAC;;;2BAApB;;;;;;2BAAmL;;;oBAAhNN;oBACN,wFAAwF;oBACxF,uEAAuE;oBACjEC;oBACD,kCAAA,2BAAA;;;;;;;;;oBAAA,YAAcM,IAAAA,oBAAW,EAACV;;;2BAA1B,6BAAA,QAAA;;;;oBAAMK,OAAN;oBACa;;wBAAMH,UAAUS,GAAG,CAACN;;;oBAA9BC,QAAQ,AAAE,cAA6CM,CAAC;yBAC7CT,cAAAA;;;;oBAAiB;;wBAAMA,aAAaQ,GAAG,CAACN;;;4BAAzB,AAAE,cAAgDO,CAAC;;;;;;4BAAG;;;oBAAhFL;oBACNH,KAAKS,IAAI,CAAC;wBAAER,MAAAA;wBAAMC,OAAAA;wBAAOC,UAAAA;wBAAUO,SAASC,IAAAA,sBAAa,EAACf,KAAKK;oBAAM;;;oBAHlE;;;;;;;;;;;;oBAAA;oBAAA;;;;;;;6BAAA,6BAAA;4BAAA;;;4BAAA;kCAAA;;;;;;;oBAKL;;wBAAOD;;;;IACT"}
+{"version":3,"sources":["/Users/kevin/Dev/open-source/ai/sensemaking/src/commands/status.ts"],"sourcesContent":["import type { ResolvedConfig, SignalWeights } from '../config/index.ts';\nimport { anyPresetEmbeds, presetNames, presetSignals } from '../config/index.ts';\nimport type { Store } from '../store/types.ts';\n\nexport interface PresetCoverage {\n  name: string;\n  files: number;\n  embedded: number;\n  // Reported so 0 embedded reads as \"this scope declined vectors\" rather than \"not yet built\".\n  signals: SignalWeights;\n}\n\n// Indexing derives from presets, so the derivation stays visible. Read from preset_files, not\n// recomputed from globs, so it reflects the cache rather than the config.\nexport async function presetCoverage(store: Store, cfg: ResolvedConfig): Promise<PresetCoverage[]> {\n  const embedActive = anyPresetEmbeds(cfg);\n  const filesStmt = await store.prepare('SELECT COUNT(*) AS n FROM preset_files WHERE preset = ?');\n  const embeddedStmt = embedActive ? await store.prepare('SELECT COUNT(*) AS n FROM preset_files pf WHERE pf.preset = ? AND EXISTS (SELECT 1 FROM embeddings e WHERE e.\"path\" = pf.\"path\" AND e.vector IS NOT NULL)') : null;\n  // Sequential, not Promise.all: both statements are reused across presets, and a store's\n  // prepared statement is not safe to bind/run concurrently with itself.\n  const rows: PresetCoverage[] = [];\n  for (const name of presetNames(cfg)) {\n    const files = ((await filesStmt.get(name)) as { n: number }).n;\n    const embedded = embeddedStmt ? ((await embeddedStmt.get(name)) as { n: number }).n : 0;\n    rows.push({ name, files, embedded, signals: presetSignals(cfg, name) });\n  }\n  return rows;\n}\n"],"names":["presetCoverage","store","cfg","embedActive","filesStmt","embeddedStmt","rows","name","files","embedded","anyPresetEmbeds","prepare","presetNames","get","n","push","signals","presetSignals"],"mappings":";;;;+BAcsBA;;;eAAAA;;;uBAbsC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAarD,SAAeA,eAAeC,KAAY,EAAEC,GAAmB;;YAC9DC,aACAC,WACAC,oBAGAC,MACD,2BAAA,mBAAA,gBAAA,WAAA,OAAMC,MACHC,OACAC;;;;oBARFN,cAAcO,IAAAA,wBAAe,EAACR;oBAClB;;wBAAMD,MAAMU,OAAO,CAAC;;;oBAAhCP,YAAY;yBACGD,aAAAA;;;;oBAAc;;wBAAMF,MAAMU,OAAO,CAAC;;;2BAApB;;;;;;2BAAmL;;;oBAAhNN;oBACN,wFAAwF;oBACxF,uEAAuE;oBACjEC;oBACD,kCAAA,2BAAA;;;;;;;;;oBAAA,YAAcM,IAAAA,oBAAW,EAACV;;;2BAA1B,6BAAA,QAAA;;;;oBAAMK,OAAN;oBACa;;wBAAMH,UAAUS,GAAG,CAACN;;;oBAA9BC,QAAQ,AAAE,cAA6CM,CAAC;yBAC7CT,cAAAA;;;;oBAAiB;;wBAAMA,aAAaQ,GAAG,CAACN;;;4BAAzB,AAAE,cAAgDO,CAAC;;;;;;4BAAG;;;oBAAhFL;oBACNH,KAAKS,IAAI,CAAC;wBAAER,MAAAA;wBAAMC,OAAAA;wBAAOC,UAAAA;wBAAUO,SAASC,IAAAA,sBAAa,EAACf,KAAKK;oBAAM;;;oBAHlE;;;;;;;;;;;;oBAAA;oBAAA;;;;;;;6BAAA,6BAAA;4BAAA;;;4BAAA;kCAAA;;;;;;;oBAKL;;wBAAOD;;;;IACT"}

package/dist/cjs/config/access.js.map

@@ -1 +1 @@
-{"version":3,"sources":["/Users/kevin/Dev/OpenSource/ai/sensemaking/src/config/access.ts"],"sourcesContent":["import type { Feature } from '../features/types.ts';\nimport type { SignalName, SignalWeights } from './signals.ts';\nimport { type Config, type EmbedConfig, FEATURE_NAMES, type FeatureName, type StoreName } from './types.ts';\n\nexport function presetNames(cfg: Config): string[] {\n  return Object.keys(cfg.presets);\n}\n\n// The backing store engine this tree uses; absent means the default.\nexport function storeName(cfg: Config): StoreName {\n  return cfg.store ?? 'sqlite';\n}\n\n// Whether the tree names a model at all.\nexport function embedEnabled(cfg: Config): boolean {\n  return typeof cfg.embed?.model === 'string' && cfg.embed.model.length > 0;\n}\n\n// A preset's effective signal weights: declared exhaustively when `signals` is present, else\n// every signal whose prerequisite holds at weight 1 (words always, links when on, vectors when a model is named).\nexport function presetSignals(cfg: Config, name: string): SignalWeights {\n  const declared = cfg.presets[name]?.signals;\n  if (declared) return declared;\n  const signals: SignalWeights = { words: 1 };\n  if (cfg.features?.links !== false) signals.links = 1;\n  if (embedEnabled(cfg)) signals.vectors = 1;\n  return signals;\n}\n\nexport function presetHasSignal(cfg: Config, name: string, signal: SignalName): boolean {\n  return presetSignals(cfg, name)[signal] !== undefined;\n}\n\n// Whether embedding needs to run: a model is named AND some preset's effective signals include vectors.\nexport function anyPresetEmbeds(cfg: Config): boolean {\n  return presetNames(cfg).some((name) => presetHasSignal(cfg, name, 'vectors'));\n}\n\n// Opt-out features (default on): absent block or key means enabled. `rank` additionally requires\n// `links`. `embed` is derived (not a features-block member): on iff some preset's signals include vectors.\nexport function featureEnabled(cfg: Config, name: FeatureName): boolean {\n  if (name === 'embed') return anyPresetEmbeds(cfg);\n  const enabled = cfg.features?.[name] !== false;\n  if (name === 'rank') return enabled && featureEnabled(cfg, 'links');\n  return enabled;\n}\n\nexport function enabledFeatures(cfg: Config): FeatureName[] {\n  return FEATURE_NAMES.filter((name) => featureEnabled(cfg, name));\n}\n\n// Feature states, so \"off\" and \"empty\" stay distinguishable in output. `embed` is excluded:\n// it is not a features-block toggle, and `status` reports it on its own line.\nexport function featureStates(cfg: Config): { on: FeatureName[]; off: FeatureName[] } {\n  const reported = FEATURE_NAMES.filter((name) => name !== 'embed');\n  return {\n    on: reported.filter((name) => featureEnabled(cfg, name)),\n    off: reported.filter((name) => !featureEnabled(cfg, name)),\n  };\n}\n\n// Resolved embed provider settings, or null when the config names no model. No fallback to\n// DEFAULT_EMBED_MODEL: that's a template constant `init` and the v4 migration write into the file, never a runtime default.\nexport function embedConfig(cfg: Config): { model: string; provider: 'static' | 'openai' | 'cohere'; url?: string; key?: string; languages?: string[]; chunkTokens?: number } | null {\n  if (!embedEnabled(cfg)) return null;\n  const e = cfg.embed as EmbedConfig;\n  return { model: e.model as string, provider: e.provider ?? 'static', url: e.url, key: e.key, languages: e.languages, chunkTokens: e.chunkTokens };\n}\n\n// Cache key over everything indexing derives from, so any change to those inputs rebuilds.\n// Segment order is fixed (one `feature:<name>:on|off` per FEATURE_NAMES entry but embed, then\n// `features` in registry order, then presets) since reordering alone would fire a spurious\n// rebuild; presets stay here because no Feature module owns it.\nexport function featureSignature(cfg: Config, features: Feature[]): string {\n  // One segment per toggle (not one lumped csv) so store/signature.ts's changedSignatureKeys can\n  // tell which feature moved -- store/feature-scope.ts routes a recognised toggle to a narrow\n  // per-table invalidation instead of the full clear.\n  const togglesPart = FEATURE_NAMES.filter((name) => name !== 'embed').map((name) => `feature:${name}:${featureEnabled(cfg, name) ? 'on' : 'off'}`);\n  const featureParts = features.map((feature) => feature.signature?.(cfg)).filter((part): part is string => part !== undefined);\n  // One keyed segment per preset so a rebuild notice can name exactly which preset moved.\n  const presetsPart = [...presetNames(cfg)]\n    .sort()\n    .map((name) => {\n      const p = cfg.presets[name];\n      const include = [...p.include].sort().join('+');\n      const exclude = [...(p.exclude ?? [])].sort().join('+');\n      return `preset:${name}:${include}:${exclude}:${presetHasSignal(cfg, name, 'vectors') ? 'on' : 'off'}`;\n    })\n    .join('|');\n  // A configured root changes every filesystem input while retaining the cache under the\n  // config directory. Its own segment therefore forces the safe full-rebuild path. Omission\n  // intentionally preserves the pre-root signature and cache behavior.\n  const rootPart = cfg.root === undefined ? [] : [`root:${cfg.root}`];\n  return [...togglesPart, ...featureParts, ...rootPart, presetsPart].join('|');\n}\n"],"names":["anyPresetEmbeds","embedConfig","embedEnabled","enabledFeatures","featureEnabled","featureSignature","featureStates","presetHasSignal","presetNames","presetSignals","storeName","cfg","Object","keys","presets","store","embed","model","length","name","declared","signals","words","features","links","vectors","signal","undefined","some","enabled","FEATURE_NAMES","filter","reported","on","off","e","provider","url","key","languages","chunkTokens","togglesPart","map","featureParts","feature","signature","part","presetsPart","sort","p","include","join","exclude","rootPart","root"],"mappings":";;;;;;;;;;;QAkCgBA;eAAAA;;QA6BAC;eAAAA;;QAjDAC;eAAAA;;QAiCAC;eAAAA;;QAPAC;eAAAA;;QAiCAC;eAAAA;;QApBAC;eAAAA;;QAxBAC;eAAAA;;QAzBAC;eAAAA;;QAgBAC;eAAAA;;QAXAC;eAAAA;;;uBAP+E;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAExF,SAASF,YAAYG,GAAW;IACrC,OAAOC,OAAOC,IAAI,CAACF,IAAIG,OAAO;AAChC;AAGO,SAASJ,UAAUC,GAAW;QAC5BA;IAAP,QAAOA,aAAAA,IAAII,KAAK,cAATJ,wBAAAA,aAAa;AACtB;AAGO,SAAST,aAAaS,GAAW;QACxBA;IAAd,OAAO,SAAOA,aAAAA,IAAIK,KAAK,cAATL,iCAAAA,WAAWM,KAAK,MAAK,YAAYN,IAAIK,KAAK,CAACC,KAAK,CAACC,MAAM,GAAG;AAC1E;AAIO,SAAST,cAAcE,GAAW,EAAEQ,IAAY;QACpCR,mBAGbA;IAHJ,IAAMS,YAAWT,oBAAAA,IAAIG,OAAO,CAACK,KAAK,cAAjBR,wCAAAA,kBAAmBU,OAAO;IAC3C,IAAID,UAAU,OAAOA;IACrB,IAAMC,UAAyB;QAAEC,OAAO;IAAE;IAC1C,IAAIX,EAAAA,gBAAAA,IAAIY,QAAQ,cAAZZ,oCAAAA,cAAca,KAAK,MAAK,OAAOH,QAAQG,KAAK,GAAG;IACnD,IAAItB,aAAaS,MAAMU,QAAQI,OAAO,GAAG;IACzC,OAAOJ;AACT;AAEO,SAASd,gBAAgBI,GAAW,EAAEQ,IAAY,EAAEO,MAAkB;IAC3E,OAAOjB,cAAcE,KAAKQ,KAAK,CAACO,OAAO,KAAKC;AAC9C;AAGO,SAAS3B,gBAAgBW,GAAW;IACzC,OAAOH,YAAYG,KAAKiB,IAAI,CAAC,SAACT;eAASZ,gBAAgBI,KAAKQ,MAAM;;AACpE;AAIO,SAASf,eAAeO,GAAW,EAAEQ,IAAiB;QAE3CR;IADhB,IAAIQ,SAAS,SAAS,OAAOnB,gBAAgBW;IAC7C,IAAMkB,UAAUlB,EAAAA,gBAAAA,IAAIY,QAAQ,cAAZZ,oCAAAA,aAAc,CAACQ,KAAK,MAAK;IACzC,IAAIA,SAAS,QAAQ,OAAOU,WAAWzB,eAAeO,KAAK;IAC3D,OAAOkB;AACT;AAEO,SAAS1B,gBAAgBQ,GAAW;IACzC,OAAOmB,sBAAa,CAACC,MAAM,CAAC,SAACZ;eAASf,eAAeO,KAAKQ;;AAC5D;AAIO,SAASb,cAAcK,GAAW;IACvC,IAAMqB,WAAWF,sBAAa,CAACC,MAAM,CAAC,SAACZ;eAASA,SAAS;;IACzD,OAAO;QACLc,IAAID,SAASD,MAAM,CAAC,SAACZ;mBAASf,eAAeO,KAAKQ;;QAClDe,KAAKF,SAASD,MAAM,CAAC,SAACZ;mBAAS,CAACf,eAAeO,KAAKQ;;IACtD;AACF;AAIO,SAASlB,YAAYU,GAAW;QAGQwB;IAF7C,IAAI,CAACjC,aAAaS,MAAM,OAAO;IAC/B,IAAMwB,IAAIxB,IAAIK,KAAK;IACnB,OAAO;QAAEC,OAAOkB,EAAElB,KAAK;QAAYmB,QAAQ,GAAED,cAAAA,EAAEC,QAAQ,cAAVD,yBAAAA,cAAc;QAAUE,KAAKF,EAAEE,GAAG;QAAEC,KAAKH,EAAEG,GAAG;QAAEC,WAAWJ,EAAEI,SAAS;QAAEC,aAAaL,EAAEK,WAAW;IAAC;AAClJ;AAMO,SAASnC,iBAAiBM,GAAW,EAAEY,QAAmB;IAC/D,+FAA+F;IAC/F,4FAA4F;IAC5F,oDAAoD;IACpD,IAAMkB,cAAcX,sBAAa,CAACC,MAAM,CAAC,SAACZ;eAASA,SAAS;OAASuB,GAAG,CAAC,SAACvB;eAAS,AAAC,WAAkBf,OAARe,MAAK,KAA4C,OAAzCf,eAAeO,KAAKQ,QAAQ,OAAO;;IACzI,IAAMwB,eAAepB,SAASmB,GAAG,CAAC,SAACE;YAAYA;gBAAAA,qBAAAA,QAAQC,SAAS,cAAjBD,yCAAAA,wBAAAA,SAAoBjC;OAAMoB,MAAM,CAAC,SAACe;eAAyBA,SAASnB;;IACnH,wFAAwF;IACxF,IAAMoB,cAAc,AAAC,qBAAGvC,YAAYG,MACjCqC,IAAI,GACJN,GAAG,CAAC,SAACvB;YAGiB8B;QAFrB,IAAMA,IAAItC,IAAIG,OAAO,CAACK,KAAK;QAC3B,IAAM+B,UAAU,AAAC,qBAAGD,EAAEC,OAAO,EAAEF,IAAI,GAAGG,IAAI,CAAC;QAC3C,IAAMC,UAAU,AAAC,sBAAIH,aAAAA,EAAEG,OAAO,cAATH,wBAAAA,aAAa,EAAE,EAAGD,IAAI,GAAGG,IAAI,CAAC;QACnD,OAAO,AAAC,UAAiBD,OAAR/B,MAAK,KAAciC,OAAXF,SAAQ,KAAc3C,OAAX6C,SAAQ,KAAwD,OAArD7C,gBAAgBI,KAAKQ,MAAM,aAAa,OAAO;IAChG,GACCgC,IAAI,CAAC;IACR,uFAAuF;IACvF,0FAA0F;IAC1F,qEAAqE;IACrE,IAAME,WAAW1C,IAAI2C,IAAI,KAAK3B,YAAY,EAAE,GAAG;QAAE,QAAgB,OAAThB,IAAI2C,IAAI;KAAG;IACnE,OAAO,AAAC,qBAAGb,oBAAa,qBAAGE,eAAc,qBAAGU,WAArC;QAA+CN;KAAY,EAACI,IAAI,CAAC;AAC1E"}
+{"version":3,"sources":["/Users/kevin/Dev/open-source/ai/sensemaking/src/config/access.ts"],"sourcesContent":["import type { Feature } from '../features/types.ts';\nimport type { SignalName, SignalWeights } from './signals.ts';\nimport { type Config, type EmbedConfig, FEATURE_NAMES, type FeatureName, type StoreName } from './types.ts';\n\nexport function presetNames(cfg: Config): string[] {\n  return Object.keys(cfg.presets);\n}\n\n// The backing store engine this tree uses; absent means the default.\nexport function storeName(cfg: Config): StoreName {\n  return cfg.store ?? 'sqlite';\n}\n\n// Whether the tree names a model at all.\nexport function embedEnabled(cfg: Config): boolean {\n  return typeof cfg.embed?.model === 'string' && cfg.embed.model.length > 0;\n}\n\n// A preset's effective signal weights: declared exhaustively when `signals` is present, else\n// every signal whose prerequisite holds at weight 1 (words always, links when on, vectors when a model is named).\nexport function presetSignals(cfg: Config, name: string): SignalWeights {\n  const declared = cfg.presets[name]?.signals;\n  if (declared) return declared;\n  const signals: SignalWeights = { words: 1 };\n  if (cfg.features?.links !== false) signals.links = 1;\n  if (embedEnabled(cfg)) signals.vectors = 1;\n  return signals;\n}\n\nexport function presetHasSignal(cfg: Config, name: string, signal: SignalName): boolean {\n  return presetSignals(cfg, name)[signal] !== undefined;\n}\n\n// Whether embedding needs to run: a model is named AND some preset's effective signals include vectors.\nexport function anyPresetEmbeds(cfg: Config): boolean {\n  return presetNames(cfg).some((name) => presetHasSignal(cfg, name, 'vectors'));\n}\n\n// Opt-out features (default on): absent block or key means enabled. `rank` additionally requires\n// `links`. `embed` is derived (not a features-block member): on iff some preset's signals include vectors.\nexport function featureEnabled(cfg: Config, name: FeatureName): boolean {\n  if (name === 'embed') return anyPresetEmbeds(cfg);\n  const enabled = cfg.features?.[name] !== false;\n  if (name === 'rank') return enabled && featureEnabled(cfg, 'links');\n  return enabled;\n}\n\nexport function enabledFeatures(cfg: Config): FeatureName[] {\n  return FEATURE_NAMES.filter((name) => featureEnabled(cfg, name));\n}\n\n// Feature states, so \"off\" and \"empty\" stay distinguishable in output. `embed` is excluded:\n// it is not a features-block toggle, and `status` reports it on its own line.\nexport function featureStates(cfg: Config): { on: FeatureName[]; off: FeatureName[] } {\n  const reported = FEATURE_NAMES.filter((name) => name !== 'embed');\n  return {\n    on: reported.filter((name) => featureEnabled(cfg, name)),\n    off: reported.filter((name) => !featureEnabled(cfg, name)),\n  };\n}\n\n// Resolved embed provider settings, or null when the config names no model. No fallback to\n// DEFAULT_EMBED_MODEL: that's a template constant `init` and the v4 migration write into the file, never a runtime default.\nexport function embedConfig(cfg: Config): { model: string; provider: 'static' | 'openai' | 'cohere'; url?: string; key?: string; languages?: string[]; chunkTokens?: number } | null {\n  if (!embedEnabled(cfg)) return null;\n  const e = cfg.embed as EmbedConfig;\n  return { model: e.model as string, provider: e.provider ?? 'static', url: e.url, key: e.key, languages: e.languages, chunkTokens: e.chunkTokens };\n}\n\n// Cache key over everything indexing derives from, so any change to those inputs rebuilds.\n// Segment order is fixed (one `feature:<name>:on|off` per FEATURE_NAMES entry but embed, then\n// `features` in registry order, then presets) since reordering alone would fire a spurious\n// rebuild; presets stay here because no Feature module owns it.\nexport function featureSignature(cfg: Config, features: Feature[]): string {\n  // One segment per toggle (not one lumped csv) so store/signature.ts's changedSignatureKeys can\n  // tell which feature moved -- store/feature-scope.ts routes a recognised toggle to a narrow\n  // per-table invalidation instead of the full clear.\n  const togglesPart = FEATURE_NAMES.filter((name) => name !== 'embed').map((name) => `feature:${name}:${featureEnabled(cfg, name) ? 'on' : 'off'}`);\n  const featureParts = features.map((feature) => feature.signature?.(cfg)).filter((part): part is string => part !== undefined);\n  // One keyed segment per preset so a rebuild notice can name exactly which preset moved.\n  const presetsPart = [...presetNames(cfg)]\n    .sort()\n    .map((name) => {\n      const p = cfg.presets[name];\n      const include = [...p.include].sort().join('+');\n      const exclude = [...(p.exclude ?? [])].sort().join('+');\n      return `preset:${name}:${include}:${exclude}:${presetHasSignal(cfg, name, 'vectors') ? 'on' : 'off'}`;\n    })\n    .join('|');\n  // A configured root changes every filesystem input while retaining the cache under the\n  // config directory. Its own segment therefore forces the safe full-rebuild path. Omission\n  // intentionally preserves the pre-root signature and cache behavior.\n  const rootPart = cfg.root === undefined ? [] : [`root:${cfg.root}`];\n  return [...togglesPart, ...featureParts, ...rootPart, presetsPart].join('|');\n}\n"],"names":["anyPresetEmbeds","embedConfig","embedEnabled","enabledFeatures","featureEnabled","featureSignature","featureStates","presetHasSignal","presetNames","presetSignals","storeName","cfg","Object","keys","presets","store","embed","model","length","name","declared","signals","words","features","links","vectors","signal","undefined","some","enabled","FEATURE_NAMES","filter","reported","on","off","e","provider","url","key","languages","chunkTokens","togglesPart","map","featureParts","feature","signature","part","presetsPart","sort","p","include","join","exclude","rootPart","root"],"mappings":"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"}

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

@@ -1 +1 @@
-{"version":3,"sources":["/Users/kevin/Dev/OpenSource/ai/sensemaking/src/config/index.ts"],"sourcesContent":["export { anyPresetEmbeds, embedConfig, embedEnabled, enabledFeatures, featureEnabled, featureSignature, featureStates, presetHasSignal, presetNames, presetSignals, storeName } from './access.ts';\nexport type { InitOverrides, LoadConfigOptions } from './load.ts';\nexport { findConfigPath, initConfig, loadConfig, migrateConfig } from './load.ts';\nexport { resolvePreset, resolveSearch } from './resolve.ts';\nexport type { SignalName, SignalWeights } from './signals.ts';\nexport { SIGNAL_NAMES, SIGNAL_PREREQUISITES } from './signals.ts';\nexport type { Config, EffectiveSearch, EmbedConfig, FeatureName, Preset, ResolvedConfig, SavedQuery, SavedSearch, SearchOverrides, StoreName } from './types.ts';\nexport { CONFIG_FILENAME, DEFAULT_EMBED_MODEL, STATE_DIR, STORE_NAMES, SUPPORTED_CONFIG_VERSION } from './types.ts';\nexport { KNOWN_EMBED_KEYS } from './validate.ts';\n"],"names":["CONFIG_FILENAME","DEFAULT_EMBED_MODEL","KNOWN_EMBED_KEYS","SIGNAL_NAMES","SIGNAL_PREREQUISITES","STATE_DIR","STORE_NAMES","SUPPORTED_CONFIG_VERSION","anyPresetEmbeds","embedConfig","embedEnabled","enabledFeatures","featureEnabled","featureSignature","featureStates","findConfigPath","initConfig","loadConfig","migrateConfig","presetHasSignal","presetNames","presetSignals","resolvePreset","resolveSearch","storeName"],"mappings":";;;;;;;;;;;QAOSA;eAAAA,wBAAe;;QAAEC;eAAAA,4BAAmB;;QACpCC;eAAAA,4BAAgB;;QAHhBC;eAAAA,uBAAY;;QAAEC;eAAAA,+BAAoB;;QAEIC;eAAAA,kBAAS;;QAAEC;eAAAA,oBAAW;;QAAEC;eAAAA,iCAAwB;;QAPtFC;eAAAA,yBAAe;;QAAEC;eAAAA,qBAAW;;QAAEC;eAAAA,sBAAY;;QAAEC;eAAAA,yBAAe;;QAAEC;eAAAA,wBAAc;;QAAEC;eAAAA,0BAAgB;;QAAEC;eAAAA,uBAAa;;QAE5GC;eAAAA,sBAAc;;QAAEC;eAAAA,kBAAU;;QAAEC;eAAAA,kBAAU;;QAAEC;eAAAA,qBAAa;;QAFyDC;eAAAA,yBAAe;;QAAEC;eAAAA,qBAAW;;QAAEC;eAAAA,uBAAa;;QAGzJC;eAAAA,wBAAa;;QAAEC;eAAAA,wBAAa;;QAH+HC;eAAAA,mBAAS;;;wBAAQ;sBAE/G;yBACzB;yBAEM;uBAEoD;0BACtE"}
+{"version":3,"sources":["/Users/kevin/Dev/open-source/ai/sensemaking/src/config/index.ts"],"sourcesContent":["export { anyPresetEmbeds, embedConfig, embedEnabled, enabledFeatures, featureEnabled, featureSignature, featureStates, presetHasSignal, presetNames, presetSignals, storeName } from './access.ts';\nexport type { InitOverrides, LoadConfigOptions } from './load.ts';\nexport { findConfigPath, initConfig, loadConfig, migrateConfig } from './load.ts';\nexport { resolvePreset, resolveSearch } from './resolve.ts';\nexport type { SignalName, SignalWeights } from './signals.ts';\nexport { SIGNAL_NAMES, SIGNAL_PREREQUISITES } from './signals.ts';\nexport type { Config, EffectiveSearch, EmbedConfig, FeatureName, Preset, ResolvedConfig, SavedQuery, SavedSearch, SearchOverrides, StoreName } from './types.ts';\nexport { CONFIG_FILENAME, DEFAULT_EMBED_MODEL, STATE_DIR, STORE_NAMES, SUPPORTED_CONFIG_VERSION } from './types.ts';\nexport { KNOWN_EMBED_KEYS } from './validate.ts';\n"],"names":["CONFIG_FILENAME","DEFAULT_EMBED_MODEL","KNOWN_EMBED_KEYS","SIGNAL_NAMES","SIGNAL_PREREQUISITES","STATE_DIR","STORE_NAMES","SUPPORTED_CONFIG_VERSION","anyPresetEmbeds","embedConfig","embedEnabled","enabledFeatures","featureEnabled","featureSignature","featureStates","findConfigPath","initConfig","loadConfig","migrateConfig","presetHasSignal","presetNames","presetSignals","resolvePreset","resolveSearch","storeName"],"mappings":";;;;;;;;;;;QAOSA;eAAAA,wBAAe;;QAAEC;eAAAA,4BAAmB;;QACpCC;eAAAA,4BAAgB;;QAHhBC;eAAAA,uBAAY;;QAAEC;eAAAA,+BAAoB;;QAEIC;eAAAA,kBAAS;;QAAEC;eAAAA,oBAAW;;QAAEC;eAAAA,iCAAwB;;QAPtFC;eAAAA,yBAAe;;QAAEC;eAAAA,qBAAW;;QAAEC;eAAAA,sBAAY;;QAAEC;eAAAA,yBAAe;;QAAEC;eAAAA,wBAAc;;QAAEC;eAAAA,0BAAgB;;QAAEC;eAAAA,uBAAa;;QAE5GC;eAAAA,sBAAc;;QAAEC;eAAAA,kBAAU;;QAAEC;eAAAA,kBAAU;;QAAEC;eAAAA,qBAAa;;QAFyDC;eAAAA,yBAAe;;QAAEC;eAAAA,qBAAW;;QAAEC;eAAAA,uBAAa;;QAGzJC;eAAAA,wBAAa;;QAAEC;eAAAA,wBAAa;;QAH+HC;eAAAA,mBAAS;;;wBAAQ;sBAE/G;yBACzB;yBAEM;uBAEoD;0BACtE"}