sensemaking 0.13.2 → 0.15.0

package/dist/cjs/cli/shared.js

@@ -47,6 +47,7 @@ _export(exports, {
     }
 });
 var _nodeutil = require("node:util");
+var _columnhintts = require("../column-hint.js");
 var _indexts = require("../config/index.js");
 var _indexts1 = require("../db/index.js");
 var _outputts = require("../output.js");
@@ -466,12 +467,13 @@ function runSql(cfg, sql, params, format, label, preset) {
         });
         (0, _outputts.printRowStream)((_statement = statement).iterate.apply(_statement, _to_consumable_array(params)), format, columns);
     } catch (err) {
+        var hinted = (0, _columnhintts.columnHint)(db, err); // pragma needs the db still open
         db.close();
         // A saved query or ad-hoc SQL can carry `content MATCH ?` too, so the same FTS5
         // punctuation trap applies -- the bound parameters are the search terms there. SQL
         // without MATCH gets its error verbatim; search advice on a plain typo would mislead.
-        if (/\bMATCH\b/i.test(sql)) throw (0, _searcherrorts.searchError)(err, params.join(' '));
-        throw err;
+        if (/\bMATCH\b/i.test(sql)) throw (0, _searcherrorts.searchError)(hinted, params.join(' '));
+        throw hinted;
     }
     db.close();
 }

package/dist/cjs/cli/shared.js.map

@@ -1 +1 @@
-{"version":3,"sources":["/Users/kevin/Dev/OpenSource/ai/sensemaking/src/cli/shared.ts"],"sourcesContent":["import type { ParseArgsOptionsConfig } from 'node:util';\nimport { parseArgs } from 'node:util';\nimport type { ResolvedConfig, SearchOverrides } from '../config/index.ts';\nimport { resolvePreset } from '../config/index.ts';\nimport type { OpenResult } from '../db/index.ts';\nimport { open } from '../db/index.ts';\nimport type { Row, RowFormat } from '../output.ts';\nimport { printRowStream } from '../output.ts';\nimport { searchError } from '../search-error.ts';\nimport type { Ctx } from './types.ts';\n\n// Spreadable option fragments -- one flag name keeps one meaning across every command's table.\nexport const FORMAT: ParseArgsOptionsConfig = { format: { type: 'string', default: 'table' } };\nexport const CONFIG: ParseArgsOptionsConfig = { config: { type: 'string' } };\n// The scope vocabulary every scoped command shares: named preset, ad hoc include/exclude\n// globs, a where SQL condition. search adds k on top.\nexport const SCOPE: ParseArgsOptionsConfig = {\n  where: { type: 'string' },\n  preset: { type: 'string' },\n  include: { type: 'string', multiple: true },\n  exclude: { type: 'string', multiple: true },\n  // Widening, which no other flag can express: --include and --exclude each override their\n  // own side of the preset, so neither can drop an exclusion the preset declares.\n  'no-exclude': { type: 'boolean', default: false },\n};\nexport const SEARCH_FLAGS: ParseArgsOptionsConfig = { ...SCOPE, k: { type: 'string' } };\n\ntype Values = Record<string, string | boolean | string[] | undefined>;\n\n// The SCOPE fragment's parsed values as the overrides every scoped command passes down. One\n// place to read them, so a new scope field is added to the fragment and here, not in each\n// command's call.\nexport function scopeOf(values: Values): SearchOverrides {\n  return {\n    preset: values.preset as string | undefined,\n    include: values.include as string[] | undefined,\n    exclude: values.exclude as string[] | undefined,\n    where: values.where as string | undefined,\n    noExclude: values['no-exclude'] === true,\n  };\n}\n\n// An unrecognised value used to fall through to `table`, so a typo looked like it worked.\n// parseArgs is strict about flag names; this is the same strictness for the value.\nfunction pickFormat<T extends string>(values: Values, allowed: readonly T[]): T {\n  const format = String(values.format);\n  if ((allowed as readonly string[]).includes(format)) return format as T;\n  console.error(`unknown --format \"${format}\"; expected ${allowed.join(', ')}`);\n  process.exit(2);\n}\n\nexport function formatOf(values: Values): 'table' | 'json' {\n  return pickFormat(values, ['table', 'json'] as const);\n}\n\n// csv is a row set rendered as rows; map, peek, status, and path render structures instead,\n// and take formatOf.\nexport function rowFormatOf(values: Values): RowFormat {\n  return pickFormat(values, ['table', 'json', 'csv'] as const);\n}\n\n// Per-command parseArgs: strict (a foreign flag exits 2), and every table gets --help for free.\nexport function parse(argv: string[], usage: string, options: ParseArgsOptionsConfig): { values: Values; positionals: string[] } {\n  let values: Values;\n  let positionals: string[];\n  try {\n    ({ values, positionals } = parseArgs({\n      args: argv,\n      options: { ...options, help: { type: 'boolean', default: false, short: 'h' } },\n      strict: true,\n      allowPositionals: true,\n    }));\n  } catch (err) {\n    console.error((err as Error).message);\n    console.error(usage);\n    process.exit(2);\n  }\n  if (values.help) {\n    console.log(usage);\n    process.exit(0);\n  }\n  return { values, positionals };\n}\n\n// --k must be a positive integer: SQLite reads a bound LIMIT of -1 as \"unlimited\" and 0 as\n// \"nothing\", and parseInt would silently truncate \"5.9\" -- all three are caller mistakes\n// worth a usage error, matching the config-level SavedSearch validation.\nexport function parseK(k: string | undefined, usageError: (message: string) => never): number | undefined {\n  if (k === undefined) return undefined;\n  const parsed = Number(k);\n  if (!Number.isInteger(parsed) || parsed <= 0) usageError(`--k expects a positive integer, got \"${k}\"`);\n  return parsed;\n}\n\n// Shared open-query-close envelope for commands that touch the tree.\n\nexport function printWarnings(warnings: string[]): void {\n  for (const w of warnings) console.warn(w);\n}\n\nexport async function withDb(ctx: Ctx, configPath: string | undefined, fn: (db: OpenResult['db'], cfg: ResolvedConfig) => void | Promise<void>): Promise<void> {\n  const cfg = ctx.resolveConfig(configPath);\n  const { db, warnings } = open(cfg);\n  printWarnings(warnings);\n  try {\n    await fn(db, cfg);\n  } finally {\n    db.close();\n  }\n}\n\n// `--preset` on SQL binds the scope rather than applying it: the statement joins `scope`\n// itself. Filtering behind the query's back is not available -- the obvious version, temp views\n// shadowing the base tables, cannot cover `content`, because FTS5 `MATCH` uses the table name\n// as a hidden column and a view has none. A flag that silently scoped three tables of four\n// would look scoped and not be.\nfunction bindScope(db: OpenResult['db'], cfg: ResolvedConfig, preset: string): void {\n  const { name } = resolvePreset(cfg, preset); // unknown names throw, listing what is declared\n  db.exec('DROP TABLE IF EXISTS temp.scope');\n  db.exec('CREATE TEMP TABLE scope (\"path\" TEXT PRIMARY KEY)');\n  db.prepare('INSERT INTO temp.scope (\"path\") SELECT \"path\" FROM preset_files WHERE preset = ?').run(name);\n}\n\n// An unbound `?` silently binds NULL, so mismatched param counts fail loudly instead.\nexport function runSql(cfg: ResolvedConfig, sql: string, params: string[], format: RowFormat, label: string, preset?: string): void {\n  const placeholderCount = (sql.match(/\\?/g) ?? []).length;\n  if (params.length !== placeholderCount) {\n    console.error(`${label} expects ${placeholderCount} parameter(s), got ${params.length}`);\n    process.exit(2);\n  }\n  // Naming a preset and never joining it would return the whole index while reading as scoped,\n  // which is the one hazard of binding rather than applying. Refuse instead.\n  if (preset !== undefined && !/\\bscope\\b/i.test(sql)) {\n    console.error(`--preset binds a temporary \"scope\" table of the preset's paths, and ${label} never joins it, so the preset would have no effect`);\n    console.error(`add: JOIN scope ON scope.\"path\" = <table>.\"path\"`);\n    process.exit(2);\n  }\n  const { db, warnings } = open(cfg);\n  printWarnings(warnings);\n  if (preset !== undefined) bindScope(db, cfg, preset);\n  // Streamed rather than collected: `sql` is the one caller whose result size is the\n  // statement's business, not this package's, so the rows are never held here in bulk.\n  // columns() reads the statement's own metadata, so a 0-row csv still has its header.\n  // A mid-stream SQLite error (e.g. SQLITE_BUSY outlasting busy_timeout) can still leave\n  // partial output; the nonzero exit code is the caller's signal, output completeness is not\n  // guaranteed on failure.\n  try {\n    const statement = db.prepare(sql);\n    statement.setReadBigInts(true); // int64 past 2^53 arrives as BigInt instead of throwing at step time\n    const columns = statement.columns().map((c) => c.name);\n    printRowStream(statement.iterate(...params) as Iterable<Row>, format, columns);\n  } catch (err) {\n    db.close();\n    // A saved query or ad-hoc SQL can carry `content MATCH ?` too, so the same FTS5\n    // punctuation trap applies -- the bound parameters are the search terms there. SQL\n    // without MATCH gets its error verbatim; search advice on a plain typo would mislead.\n    if (/\\bMATCH\\b/i.test(sql)) throw searchError(err as Error, params.join(' '));\n    throw err;\n  }\n  db.close();\n}\n"],"names":["CONFIG","FORMAT","SCOPE","SEARCH_FLAGS","formatOf","parse","parseK","printWarnings","rowFormatOf","runSql","scopeOf","withDb","format","type","default","config","where","preset","include","multiple","exclude","k","values","noExclude","pickFormat","allowed","String","includes","console","error","join","process","exit","argv","usage","options","positionals","parseArgs","args","help","short","strict","allowPositionals","err","message","log","usageError","undefined","parsed","Number","isInteger","warnings","w","warn","ctx","configPath","fn","cfg","open","db","resolveConfig","close","bindScope","name","resolvePreset","exec","prepare","run","sql","params","label","placeholderCount","match","length","test","statement","setReadBigInts","columns","map","c","printRowStream","iterate","searchError"],"mappings":"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"}
+{"version":3,"sources":["/Users/kevin/Dev/OpenSource/ai/sensemaking/src/cli/shared.ts"],"sourcesContent":["import type { ParseArgsOptionsConfig } from 'node:util';\nimport { parseArgs } from 'node:util';\nimport { columnHint } from '../column-hint.ts';\nimport type { ResolvedConfig, SearchOverrides } from '../config/index.ts';\nimport { resolvePreset } from '../config/index.ts';\nimport type { OpenResult } from '../db/index.ts';\nimport { open } from '../db/index.ts';\nimport type { Row, RowFormat } from '../output.ts';\nimport { printRowStream } from '../output.ts';\nimport { searchError } from '../search-error.ts';\nimport type { Ctx } from './types.ts';\n\n// Spreadable option fragments -- one flag name keeps one meaning across every command's table.\nexport const FORMAT: ParseArgsOptionsConfig = { format: { type: 'string', default: 'table' } };\nexport const CONFIG: ParseArgsOptionsConfig = { config: { type: 'string' } };\n// The scope vocabulary every scoped command shares: named preset, ad hoc include/exclude\n// globs, a where SQL condition. search adds k on top.\nexport const SCOPE: ParseArgsOptionsConfig = {\n  where: { type: 'string' },\n  preset: { type: 'string' },\n  include: { type: 'string', multiple: true },\n  exclude: { type: 'string', multiple: true },\n  // Widening, which no other flag can express: --include and --exclude each override their\n  // own side of the preset, so neither can drop an exclusion the preset declares.\n  'no-exclude': { type: 'boolean', default: false },\n};\nexport const SEARCH_FLAGS: ParseArgsOptionsConfig = { ...SCOPE, k: { type: 'string' } };\n\ntype Values = Record<string, string | boolean | string[] | undefined>;\n\n// The SCOPE fragment's parsed values as the overrides every scoped command passes down. One\n// place to read them, so a new scope field is added to the fragment and here, not in each\n// command's call.\nexport function scopeOf(values: Values): SearchOverrides {\n  return {\n    preset: values.preset as string | undefined,\n    include: values.include as string[] | undefined,\n    exclude: values.exclude as string[] | undefined,\n    where: values.where as string | undefined,\n    noExclude: values['no-exclude'] === true,\n  };\n}\n\n// An unrecognised value used to fall through to `table`, so a typo looked like it worked.\n// parseArgs is strict about flag names; this is the same strictness for the value.\nfunction pickFormat<T extends string>(values: Values, allowed: readonly T[]): T {\n  const format = String(values.format);\n  if ((allowed as readonly string[]).includes(format)) return format as T;\n  console.error(`unknown --format \"${format}\"; expected ${allowed.join(', ')}`);\n  process.exit(2);\n}\n\nexport function formatOf(values: Values): 'table' | 'json' {\n  return pickFormat(values, ['table', 'json'] as const);\n}\n\n// csv is a row set rendered as rows; map, peek, status, and path render structures instead,\n// and take formatOf.\nexport function rowFormatOf(values: Values): RowFormat {\n  return pickFormat(values, ['table', 'json', 'csv'] as const);\n}\n\n// Per-command parseArgs: strict (a foreign flag exits 2), and every table gets --help for free.\nexport function parse(argv: string[], usage: string, options: ParseArgsOptionsConfig): { values: Values; positionals: string[] } {\n  let values: Values;\n  let positionals: string[];\n  try {\n    ({ values, positionals } = parseArgs({\n      args: argv,\n      options: { ...options, help: { type: 'boolean', default: false, short: 'h' } },\n      strict: true,\n      allowPositionals: true,\n    }));\n  } catch (err) {\n    console.error((err as Error).message);\n    console.error(usage);\n    process.exit(2);\n  }\n  if (values.help) {\n    console.log(usage);\n    process.exit(0);\n  }\n  return { values, positionals };\n}\n\n// --k must be a positive integer: SQLite reads a bound LIMIT of -1 as \"unlimited\" and 0 as\n// \"nothing\", and parseInt would silently truncate \"5.9\" -- all three are caller mistakes\n// worth a usage error, matching the config-level SavedSearch validation.\nexport function parseK(k: string | undefined, usageError: (message: string) => never): number | undefined {\n  if (k === undefined) return undefined;\n  const parsed = Number(k);\n  if (!Number.isInteger(parsed) || parsed <= 0) usageError(`--k expects a positive integer, got \"${k}\"`);\n  return parsed;\n}\n\n// Shared open-query-close envelope for commands that touch the tree.\n\nexport function printWarnings(warnings: string[]): void {\n  for (const w of warnings) console.warn(w);\n}\n\nexport async function withDb(ctx: Ctx, configPath: string | undefined, fn: (db: OpenResult['db'], cfg: ResolvedConfig) => void | Promise<void>): Promise<void> {\n  const cfg = ctx.resolveConfig(configPath);\n  const { db, warnings } = open(cfg);\n  printWarnings(warnings);\n  try {\n    await fn(db, cfg);\n  } finally {\n    db.close();\n  }\n}\n\n// `--preset` on SQL binds the scope rather than applying it: the statement joins `scope`\n// itself. Filtering behind the query's back is not available -- the obvious version, temp views\n// shadowing the base tables, cannot cover `content`, because FTS5 `MATCH` uses the table name\n// as a hidden column and a view has none. A flag that silently scoped three tables of four\n// would look scoped and not be.\nfunction bindScope(db: OpenResult['db'], cfg: ResolvedConfig, preset: string): void {\n  const { name } = resolvePreset(cfg, preset); // unknown names throw, listing what is declared\n  db.exec('DROP TABLE IF EXISTS temp.scope');\n  db.exec('CREATE TEMP TABLE scope (\"path\" TEXT PRIMARY KEY)');\n  db.prepare('INSERT INTO temp.scope (\"path\") SELECT \"path\" FROM preset_files WHERE preset = ?').run(name);\n}\n\n// An unbound `?` silently binds NULL, so mismatched param counts fail loudly instead.\nexport function runSql(cfg: ResolvedConfig, sql: string, params: string[], format: RowFormat, label: string, preset?: string): void {\n  const placeholderCount = (sql.match(/\\?/g) ?? []).length;\n  if (params.length !== placeholderCount) {\n    console.error(`${label} expects ${placeholderCount} parameter(s), got ${params.length}`);\n    process.exit(2);\n  }\n  // Naming a preset and never joining it would return the whole index while reading as scoped,\n  // which is the one hazard of binding rather than applying. Refuse instead.\n  if (preset !== undefined && !/\\bscope\\b/i.test(sql)) {\n    console.error(`--preset binds a temporary \"scope\" table of the preset's paths, and ${label} never joins it, so the preset would have no effect`);\n    console.error(`add: JOIN scope ON scope.\"path\" = <table>.\"path\"`);\n    process.exit(2);\n  }\n  const { db, warnings } = open(cfg);\n  printWarnings(warnings);\n  if (preset !== undefined) bindScope(db, cfg, preset);\n  // Streamed rather than collected: `sql` is the one caller whose result size is the\n  // statement's business, not this package's, so the rows are never held here in bulk.\n  // columns() reads the statement's own metadata, so a 0-row csv still has its header.\n  // A mid-stream SQLite error (e.g. SQLITE_BUSY outlasting busy_timeout) can still leave\n  // partial output; the nonzero exit code is the caller's signal, output completeness is not\n  // guaranteed on failure.\n  try {\n    const statement = db.prepare(sql);\n    statement.setReadBigInts(true); // int64 past 2^53 arrives as BigInt instead of throwing at step time\n    const columns = statement.columns().map((c) => c.name);\n    printRowStream(statement.iterate(...params) as Iterable<Row>, format, columns);\n  } catch (err) {\n    const hinted = columnHint(db, err as Error); // pragma needs the db still open\n    db.close();\n    // A saved query or ad-hoc SQL can carry `content MATCH ?` too, so the same FTS5\n    // punctuation trap applies -- the bound parameters are the search terms there. SQL\n    // without MATCH gets its error verbatim; search advice on a plain typo would mislead.\n    if (/\\bMATCH\\b/i.test(sql)) throw searchError(hinted, params.join(' '));\n    throw hinted;\n  }\n  db.close();\n}\n"],"names":["CONFIG","FORMAT","SCOPE","SEARCH_FLAGS","formatOf","parse","parseK","printWarnings","rowFormatOf","runSql","scopeOf","withDb","format","type","default","config","where","preset","include","multiple","exclude","k","values","noExclude","pickFormat","allowed","String","includes","console","error","join","process","exit","argv","usage","options","positionals","parseArgs","args","help","short","strict","allowPositionals","err","message","log","usageError","undefined","parsed","Number","isInteger","warnings","w","warn","ctx","configPath","fn","cfg","open","db","resolveConfig","close","bindScope","name","resolvePreset","exec","prepare","run","sql","params","label","placeholderCount","match","length","test","statement","setReadBigInts","columns","map","c","printRowStream","iterate","hinted","columnHint","searchError"],"mappings":"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"}

package/dist/cjs/column-hint.d.cts

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

package/dist/cjs/column-hint.d.ts

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

package/dist/cjs/column-hint.js

@@ -0,0 +1,104 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "columnHint", {
+    enumerable: true,
+    get: function() {
+        return columnHint;
+    }
+});
+function _array_like_to_array(arr, len) {
+    if (len == null || len > arr.length) len = arr.length;
+    for(var i = 0, arr2 = new Array(len); i < len; i++)arr2[i] = arr[i];
+    return arr2;
+}
+function _array_without_holes(arr) {
+    if (Array.isArray(arr)) return _array_like_to_array(arr);
+}
+function _iterable_to_array(iter) {
+    if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter);
+}
+function _non_iterable_spread() {
+    throw new TypeError("Invalid attempt to spread non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+function _to_consumable_array(arr) {
+    return _array_without_holes(arr) || _iterable_to_array(arr) || _unsupported_iterable_to_array(arr) || _non_iterable_spread();
+}
+function _unsupported_iterable_to_array(o, minLen) {
+    if (!o) return;
+    if (typeof o === "string") return _array_like_to_array(o, minLen);
+    var n = Object.prototype.toString.call(o).slice(8, -1);
+    if (n === "Object" && o.constructor) n = o.constructor.name;
+    if (n === "Map" || n === "Set") return Array.from(n);
+    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _array_like_to_array(o, minLen);
+}
+// A frontmatter key with punctuation (`plugin-id`, `a.b`) is a real column, but naming it
+// unquoted in SQL parses as an expression: `plugin-id` is `plugin - id`, and SQLite's error
+// names a fragment (`plugin`) the user never wrote. This maps that fragment back to the
+// columns it could have come from, so the error names the actual fix instead.
+function startsWithBoundary(name, prefix) {
+    return name.length > prefix.length && name.startsWith(prefix) && /\W/.test(name[prefix.length]);
+}
+function columnHint(db, err) {
+    var match = /no such column: (\S+)/.exec(err.message);
+    if (!match) return err;
+    var token = match[1];
+    // `f.plugin` -> `plugin`; left as-is when there's no leading alias segment, which also
+    // covers a column literally named `a.b` -- the full-token check below matches that case
+    // directly, so stripping here never needs to special-case it.
+    var aliasStripped = token.replace(/^[A-Za-z_]\w*\./, '');
+    var forms = new Set([
+        token,
+        aliasStripped
+    ]);
+    var columns = db.prepare('PRAGMA table_info(frontmatter)').all().map(function(c) {
+        return c.name;
+    });
+    var candidates = new Set();
+    var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+    try {
+        for(var _iterator = columns[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+            var name = _step.value;
+            var _iteratorNormalCompletion1 = true, _didIteratorError1 = false, _iteratorError1 = undefined;
+            try {
+                for(var _iterator1 = forms[Symbol.iterator](), _step1; !(_iteratorNormalCompletion1 = (_step1 = _iterator1.next()).done); _iteratorNormalCompletion1 = true){
+                    var form = _step1.value;
+                    if (name === form || startsWithBoundary(name, form)) candidates.add(name);
+                }
+            } catch (err) {
+                _didIteratorError1 = true;
+                _iteratorError1 = err;
+            } finally{
+                try {
+                    if (!_iteratorNormalCompletion1 && _iterator1.return != null) {
+                        _iterator1.return();
+                    }
+                } finally{
+                    if (_didIteratorError1) {
+                        throw _iteratorError1;
+                    }
+                }
+            }
+        }
+    } catch (err) {
+        _didIteratorError = true;
+        _iteratorError = err;
+    } finally{
+        try {
+            if (!_iteratorNormalCompletion && _iterator.return != null) {
+                _iterator.return();
+            }
+        } finally{
+            if (_didIteratorError) {
+                throw _iteratorError;
+            }
+        }
+    }
+    if (candidates.size === 0) return err;
+    var quoted = _to_consumable_array(candidates).map(function(name) {
+        return '"'.concat(name.split('"').join('""'), '"');
+    }).join(', ');
+    return new Error("".concat(err.message, " -- ").concat(quoted, " needs double quotes in SQL: unquoted, SQLite parses the punctuation as an operator instead of column syntax."));
+}
+/* CJS INTEROP */ if (exports.__esModule && exports.default) { try { Object.defineProperty(exports.default, '__esModule', { value: true }); for (var key in exports) { exports.default[key] = exports[key]; } } catch (_) {}; module.exports = exports.default; }

package/dist/cjs/column-hint.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["/Users/kevin/Dev/OpenSource/ai/sensemaking/src/column-hint.ts"],"sourcesContent":["import type { DatabaseSync } from 'node:sqlite';\n\n// A frontmatter key with punctuation (`plugin-id`, `a.b`) is a real column, but naming it\n// unquoted in SQL parses as an expression: `plugin-id` is `plugin - id`, and SQLite's error\n// names a fragment (`plugin`) the user never wrote. This maps that fragment back to the\n// columns it could have come from, so the error names the actual fix instead.\n\nfunction startsWithBoundary(name: string, prefix: string): boolean {\n  return name.length > prefix.length && name.startsWith(prefix) && /\\W/.test(name[prefix.length]);\n}\n\nexport function columnHint(db: DatabaseSync, err: Error): Error {\n  const match = /no such column: (\\S+)/.exec(err.message);\n  if (!match) return err;\n  const token = match[1];\n  // `f.plugin` -> `plugin`; left as-is when there's no leading alias segment, which also\n  // covers a column literally named `a.b` -- the full-token check below matches that case\n  // directly, so stripping here never needs to special-case it.\n  const aliasStripped = token.replace(/^[A-Za-z_]\\w*\\./, '');\n  const forms = new Set([token, aliasStripped]);\n  const columns = (db.prepare('PRAGMA table_info(frontmatter)').all() as Array<{ name: string }>).map((c) => c.name);\n  const candidates = new Set<string>();\n  for (const name of columns) {\n    for (const form of forms) {\n      if (name === form || startsWithBoundary(name, form)) candidates.add(name);\n    }\n  }\n  if (candidates.size === 0) return err;\n  const quoted = [...candidates].map((name) => `\"${name.split('\"').join('\"\"')}\"`).join(', ');\n  return new Error(`${err.message} -- ${quoted} needs double quotes in SQL: unquoted, SQLite parses the punctuation as an operator instead of column syntax.`);\n}\n"],"names":["columnHint","startsWithBoundary","name","prefix","length","startsWith","test","db","err","match","exec","message","token","aliasStripped","replace","forms","Set","columns","prepare","all","map","c","candidates","form","add","size","quoted","split","join","Error"],"mappings":";;;;+BAWgBA;;;eAAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAThB,0FAA0F;AAC1F,4FAA4F;AAC5F,wFAAwF;AACxF,8EAA8E;AAE9E,SAASC,mBAAmBC,IAAY,EAAEC,MAAc;IACtD,OAAOD,KAAKE,MAAM,GAAGD,OAAOC,MAAM,IAAIF,KAAKG,UAAU,CAACF,WAAW,KAAKG,IAAI,CAACJ,IAAI,CAACC,OAAOC,MAAM,CAAC;AAChG;AAEO,SAASJ,WAAWO,EAAgB,EAAEC,GAAU;IACrD,IAAMC,QAAQ,wBAAwBC,IAAI,CAACF,IAAIG,OAAO;IACtD,IAAI,CAACF,OAAO,OAAOD;IACnB,IAAMI,QAAQH,KAAK,CAAC,EAAE;IACtB,uFAAuF;IACvF,wFAAwF;IACxF,8DAA8D;IAC9D,IAAMI,gBAAgBD,MAAME,OAAO,CAAC,mBAAmB;IACvD,IAAMC,QAAQ,IAAIC,IAAI;QAACJ;QAAOC;KAAc;IAC5C,IAAMI,UAAU,AAACV,GAAGW,OAAO,CAAC,kCAAkCC,GAAG,GAA+BC,GAAG,CAAC,SAACC;eAAMA,EAAEnB,IAAI;;IACjH,IAAMoB,aAAa,IAAIN;QAClB,kCAAA,2BAAA;;QAAL,QAAK,YAAcC,4BAAd,SAAA,6BAAA,QAAA,yBAAA,iCAAuB;YAAvB,IAAMf,OAAN;gBACE,mCAAA,4BAAA;;gBAAL,QAAK,aAAca,0BAAd,UAAA,8BAAA,SAAA,0BAAA,kCAAqB;oBAArB,IAAMQ,OAAN;oBACH,IAAIrB,SAASqB,QAAQtB,mBAAmBC,MAAMqB,OAAOD,WAAWE,GAAG,CAACtB;gBACtE;;gBAFK;gBAAA;;;yBAAA,8BAAA;wBAAA;;;wBAAA;8BAAA;;;;QAGP;;QAJK;QAAA;;;iBAAA,6BAAA;gBAAA;;;gBAAA;sBAAA;;;;IAKL,IAAIoB,WAAWG,IAAI,KAAK,GAAG,OAAOjB;IAClC,IAAMkB,SAAS,AAAC,qBAAGJ,YAAYF,GAAG,CAAC,SAAClB;eAAS,AAAC,IAA8B,OAA3BA,KAAKyB,KAAK,CAAC,KAAKC,IAAI,CAAC,OAAM;OAAIA,IAAI,CAAC;IACrF,OAAO,IAAIC,MAAM,AAAC,GAAoBH,OAAlBlB,IAAIG,OAAO,EAAC,QAAa,OAAPe,QAAO;AAC/C"}

package/dist/cjs/commands/scope.js

@@ -35,6 +35,7 @@ _export(exports, {
     }
 });
 var _nodepath = require("node:path");
+var _columnhintts = require("../column-hint.js");
 var _indexts = require("../config/index.js");
 function _array_like_to_array(arr, len) {
     if (len == null || len > arr.length) len = arr.length;
@@ -101,7 +102,12 @@ function rawScope(db, cfg, overrides, allPaths) {
 }
 function narrowByWhere(db, paths, where) {
     if (!where) return paths;
-    var whereRows = db.prepare('SELECT "path" FROM frontmatter f WHERE ('.concat(where, ")")).all();
+    var whereRows;
+    try {
+        whereRows = db.prepare('SELECT "path" FROM frontmatter f WHERE ('.concat(where, ")")).all();
+    } catch (err) {
+        throw (0, _columnhintts.columnHint)(db, err);
+    }
     var wherePaths = new Set(whereRows.map(function(r) {
         return r.path;
     }));

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 { DatabaseSync } from 'node:sqlite';\nimport type { ResolvedConfig, SearchOverrides } from '../config/index.ts';\nimport { anyPresetEmbeds, resolveSearch } from '../config/index.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) as of the\n// engines floor (Node >=22.20); scope filtering only ever needs single-pattern matching, so\n// it's used here in JS rather than running 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 function scopeHasEmbeddings(db: DatabaseSync, cfg: ResolvedConfig, scopedPaths: Set<string>): boolean {\n  if (!anyPresetEmbeds(cfg)) return false; // the embeddings table doesn't exist at all in this case\n  const rows = db.prepare('SELECT DISTINCT \"path\" FROM embeddings').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(), which also needs the\n// pre-where set to size the candidate-pool filter.\nexport function rawScope(db: DatabaseSync, cfg: ResolvedConfig, overrides: SearchOverrides, allPaths?: string[]): 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) return new Set((db.prepare('SELECT \"path\" FROM preset_files WHERE preset = ?').all(effective.presetName) as Array<{ path: string }>).map((r) => r.path));\n  const paths = allPaths ?? (db.prepare('SELECT \"path\" FROM frontmatter').all() as Array<{ path: string }>).map((r) => r.path);\n  return new Set(paths.filter((p) => inScope(p, include, exclude)));\n}\n\nexport function narrowByWhere(db: DatabaseSync, paths: Set<string>, where: string | undefined): Set<string> {\n  if (!where) return paths;\n  const whereRows = db.prepare(`SELECT \"path\" FROM frontmatter f WHERE (${where})`).all() as Array<{ path: string }>;\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 function scopedPaths(db: DatabaseSync, cfg: ResolvedConfig, overrides: SearchOverrides): Set<string> {\n  const effective = resolveSearch(cfg, overrides);\n  return narrowByWhere(db, rawScope(db, 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 function materializeScope(db: DatabaseSync, table: string, paths: Set<string>): void {\n  db.exec(`DROP TABLE IF EXISTS ${table}`);\n  db.exec(`CREATE TEMP TABLE ${table} (\"path\" TEXT PRIMARY KEY)`);\n  db.prepare(`INSERT INTO ${table} SELECT DISTINCT value FROM json_each(?1)`).run(JSON.stringify([...paths]));\n}\n\nexport function setupMapScope(db: DatabaseSync, paths: Set<string>): void {\n  materializeScope(db, '_map_scope', paths);\n}\n"],"names":["INTERNAL_COLUMNS","inScope","materializeScope","narrowByWhere","rawScope","scopeHasEmbeddings","scopedPaths","setupMapScope","Set","path","include","exclude","some","g","matchesGlob","db","cfg","anyPresetEmbeds","rows","prepare","all","r","has","overrides","allPaths","effective","resolveSearch","adHocScope","undefined","noExclude","presetName","map","paths","filter","p","where","whereRows","wherePaths","table","exec","run","JSON","stringify"],"mappings":"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"}
+{"version":3,"sources":["/Users/kevin/Dev/OpenSource/ai/sensemaking/src/commands/scope.ts"],"sourcesContent":["import { matchesGlob } from 'node:path';\nimport type { DatabaseSync } from 'node:sqlite';\nimport { columnHint } from '../column-hint.ts';\nimport type { ResolvedConfig, SearchOverrides } from '../config/index.ts';\nimport { anyPresetEmbeds, resolveSearch } from '../config/index.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) as of the\n// engines floor (Node >=22.20); scope filtering only ever needs single-pattern matching, so\n// it's used here in JS rather than running 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 function scopeHasEmbeddings(db: DatabaseSync, cfg: ResolvedConfig, scopedPaths: Set<string>): boolean {\n  if (!anyPresetEmbeds(cfg)) return false; // the embeddings table doesn't exist at all in this case\n  const rows = db.prepare('SELECT DISTINCT \"path\" FROM embeddings').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(), which also needs the\n// pre-where set to size the candidate-pool filter.\nexport function rawScope(db: DatabaseSync, cfg: ResolvedConfig, overrides: SearchOverrides, allPaths?: string[]): 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) return new Set((db.prepare('SELECT \"path\" FROM preset_files WHERE preset = ?').all(effective.presetName) as Array<{ path: string }>).map((r) => r.path));\n  const paths = allPaths ?? (db.prepare('SELECT \"path\" FROM frontmatter').all() as Array<{ path: string }>).map((r) => r.path);\n  return new Set(paths.filter((p) => inScope(p, include, exclude)));\n}\n\nexport function narrowByWhere(db: DatabaseSync, paths: Set<string>, where: string | undefined): Set<string> {\n  if (!where) return paths;\n  let whereRows: Array<{ path: string }>;\n  try {\n    whereRows = db.prepare(`SELECT \"path\" FROM frontmatter f WHERE (${where})`).all() as Array<{ path: string }>;\n  } catch (err) {\n    throw columnHint(db, 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 function scopedPaths(db: DatabaseSync, cfg: ResolvedConfig, overrides: SearchOverrides): Set<string> {\n  const effective = resolveSearch(cfg, overrides);\n  return narrowByWhere(db, rawScope(db, 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 function materializeScope(db: DatabaseSync, table: string, paths: Set<string>): void {\n  db.exec(`DROP TABLE IF EXISTS ${table}`);\n  db.exec(`CREATE TEMP TABLE ${table} (\"path\" TEXT PRIMARY KEY)`);\n  db.prepare(`INSERT INTO ${table} SELECT DISTINCT value FROM json_each(?1)`).run(JSON.stringify([...paths]));\n}\n\nexport function setupMapScope(db: DatabaseSync, paths: Set<string>): void {\n  materializeScope(db, '_map_scope', paths);\n}\n"],"names":["INTERNAL_COLUMNS","inScope","materializeScope","narrowByWhere","rawScope","scopeHasEmbeddings","scopedPaths","setupMapScope","Set","path","include","exclude","some","g","matchesGlob","db","cfg","anyPresetEmbeds","rows","prepare","all","r","has","overrides","allPaths","effective","resolveSearch","adHocScope","undefined","noExclude","presetName","map","paths","filter","p","where","whereRows","err","columnHint","wherePaths","table","exec","run","JSON","stringify"],"mappings":"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"}

package/dist/cjs/db/open.d.cts

@@ -1,7 +1,7 @@
 import { DatabaseSync } from 'node:sqlite';
 import type { ResolvedConfig } from '../config/index.js';
 export declare const DB_FILENAME = "cache.db";
-export declare const SCHEMA_VERSION = "13";
+export declare const SCHEMA_VERSION = "15";
 export interface OpenResult {
     db: DatabaseSync;
     cfg: ResolvedConfig;

package/dist/cjs/db/open.d.ts

@@ -1,7 +1,7 @@
 import { DatabaseSync } from 'node:sqlite';
 import type { ResolvedConfig } from '../config/index.js';
 export declare const DB_FILENAME = "cache.db";
-export declare const SCHEMA_VERSION = "13";
+export declare const SCHEMA_VERSION = "15";
 export interface OpenResult {
     db: DatabaseSync;
     cfg: ResolvedConfig;

package/dist/cjs/db/open.js

@@ -62,7 +62,7 @@ function _unsupported_iterable_to_array(o, minLen) {
     if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _array_like_to_array(o, minLen);
 }
 var DB_FILENAME = 'cache.db';
-var SCHEMA_VERSION = '13';
+var SCHEMA_VERSION = '15';
 // Stemming is English-only, but the segmentation underneath it is what decides coverage:
 // unicode61 splits on spaces, so a language written without them (Chinese, Japanese, Thai)
 // indexes a whole run as one token and word search finds nothing. `content.tokenize` is how

package/dist/cjs/db/open.js.map

@@ -1 +1 @@
-{"version":3,"sources":["/Users/kevin/Dev/OpenSource/ai/sensemaking/src/db/open.ts"],"sourcesContent":["// The Node floor (>=22.20) is explained here and nowhere else: 22.20 is the first release with\n// both FTS5 and row-returning INSERT ... RETURNING. Raise it only for a load-bearing capability.\nimport { mkdirSync, rmSync } from 'node:fs';\nimport { join } from 'node:path';\nimport { DatabaseSync } from 'node:sqlite';\nimport type { Config, ResolvedConfig } from '../config/index.ts';\nimport { contentTokenize, featureSignature, STATE_DIR } from '../config/index.ts';\nimport { SenseError } from '../errors.ts';\nimport { activeFeatures } from '../features/index.ts';\nimport { registerFunctions } from '../sql-functions.ts';\nimport { changedSignatureKeys, rebuildContentTable, reconcile, signatureDiff } from './reconcile.ts';\nimport { getMeta, setMeta } from './shared.ts';\n\nexport const DB_FILENAME = 'cache.db';\n// Cache shape version, independent of the config's own `version`. Bumping it rebuilds\n// existing trees on first query.\nexport const SCHEMA_VERSION = '13';\n\nexport interface OpenResult {\n  db: DatabaseSync;\n  cfg: ResolvedConfig;\n  dbPath: string;\n  parsed: number;\n  warnings: string[];\n}\n\n// Stemming is English-only, but the segmentation underneath it is what decides coverage:\n// unicode61 splits on spaces, so a language written without them (Chinese, Japanese, Thai)\n// indexes a whole run as one token and word search finds nothing. `content.tokenize` is how\n// such a tree picks trigram instead.\nconst DEFAULT_TOKENIZE = 'porter unicode61';\n\n// FTS5 takes its tokenizer as a string literal inside DDL, where nothing can bind, so a\n// configured value has to be concatenated. Probing a throwaway table is what makes that safe\n// and is also the whole validation: anything the linked SQLite accepts passes, anything else\n// fails here with SQLite's own message rather than against the real table. It means no table\n// of which version added which tokenizer has to be maintained.\nfunction resolveTokenize(db: DatabaseSync, cfg: Config): string {\n  const configured = contentTokenize(cfg);\n  if (configured === undefined) return DEFAULT_TOKENIZE;\n  const literal = configured.replace(/'/g, \"''\");\n  try {\n    db.exec('DROP TABLE IF EXISTS temp.sense_tokenize_probe');\n    db.exec(`CREATE VIRTUAL TABLE temp.sense_tokenize_probe USING fts5(x, tokenize = '${literal}')`);\n    db.exec('DROP TABLE IF EXISTS temp.sense_tokenize_probe');\n  } catch (err) {\n    throw new SenseError('CONFIG_INVALID', `content.tokenize \"${configured}\" is not a tokenizer this SQLite accepts (${(err as Error).message}); the built-in choices are unicode61, ascii, porter, and trigram, each with their own options`);\n  }\n  return literal;\n}\n\n// The tokenizer the content table was actually built with, from its own DDL -- the one\n// record that cannot desynchronize from the table. NULL when the table does not exist yet.\nfunction storedTokenize(db: DatabaseSync): string | null {\n  const row = db.prepare(`SELECT sql FROM sqlite_master WHERE name = 'content'`).get() as { sql: string } | undefined;\n  if (!row) return null;\n  const m = row.sql.match(/tokenize = '((?:[^']|'')*)'/);\n  return m ? m[1] : null;\n}\n\n// Content is a separate table (not a column on frontmatter) so `SELECT * FROM frontmatter`\n// can't dump file text into context. Features add their own tables after the core ones.\nfunction ensureSchema(db: DatabaseSync, cfg: Config, tokenize: string): void {\n  db.exec(`CREATE TABLE IF NOT EXISTS frontmatter (\"path\" TEXT PRIMARY KEY, \"_mtime\" REAL, \"_ctime\" REAL, \"_size\" INTEGER, \"_parse_error\" TEXT)`);\n  // IF NOT EXISTS is safe against a tokenizer change: open() compares the table's own DDL\n  // against the resolved tokenizer before this runs, so a stale table is already gone by now.\n  // The three `_seg` sidecars are appended after path, never inserted: bm25(content, ...) and\n  // snippet(content, 2, ...) are documented against the first three columns and keep working\n  // (FTS5 defaults the weights it was not given). Each carries its field's exploded unspaced\n  // runs for text that needs it, and an empty string for text that does not.\n  db.exec(`CREATE VIRTUAL TABLE IF NOT EXISTS content USING fts5(title, summary, text, path UNINDEXED, title_seg, summary_seg, text_seg, tokenize = '${tokenize}')`);\n  // Coverage, not ownership: a path can appear under several presets. path leads the PK so the\n  // per-doc delete is an index hit -- keyed the other way, cold builds went quadratic.\n  db.exec(`CREATE TABLE IF NOT EXISTS preset_files (\"path\" TEXT, preset TEXT, PRIMARY KEY (\"path\", preset))`);\n  db.exec('CREATE INDEX IF NOT EXISTS preset_files_preset ON preset_files(preset)');\n  for (const feature of activeFeatures(cfg)) feature.schema(db);\n  if (getMeta(db, 'schema_version') === null) setMeta(db, 'schema_version', SCHEMA_VERSION);\n  if (getMeta(db, 'features') === null) setMeta(db, 'features', featureSignature(cfg));\n}\n\nexport function docCount(db: DatabaseSync): number {\n  const row = db.prepare('SELECT COUNT(*) AS n FROM frontmatter').get() as { n: number };\n  return row.n;\n}\n\nexport function open(cfg: ResolvedConfig): OpenResult {\n  const stateDir = join(cfg.baseDir, STATE_DIR);\n  mkdirSync(stateDir, { recursive: true });\n  const dbPath = join(stateDir, DB_FILENAME);\n\n  const db = new DatabaseSync(dbPath);\n  db.exec('PRAGMA journal_mode = WAL');\n  // Covers a concurrent watcher's bulk reconcile (~5s for 500 files at 26k notes). A query\n  // that outwaits it still fails loudly.\n  db.exec('PRAGMA busy_timeout = 30000');\n  registerFunctions(db, contentTokenize(cfg) === undefined);\n\n  db.exec('CREATE TABLE IF NOT EXISTS meta (key TEXT PRIMARY KEY, value TEXT)');\n\n  // Before the rebuild branch below, never after: that branch deletes the cache, so a typo'd\n  // tokenizer validated later would cost a full re-index (and re-embed) to reach its own error.\n  const tokenize = resolveTokenize(db, cfg);\n\n  // Schema-version or feature-set mismatch: reconcile only reparses changed files, so an\n  // old cache can't be patched incrementally -- rebuild instead (cheap: nothing expensive lives here).\n  const version = getMeta(db, 'schema_version');\n  const features = getMeta(db, 'features');\n  const wantFeatures = featureSignature(cfg);\n  let tokenizeOnlyRebuild = false;\n  if ((version !== null && version !== SCHEMA_VERSION) || (features !== null && features !== wantFeatures)) {\n    // Indexing derives from presets, so a config edit rebuilding the cache must say so and\n    // name what changed -- silent rebuilds make derived indexing look like a hang or a bug.\n    if (version !== null && version !== SCHEMA_VERSION) {\n      console.error('sense: cache format changed (new sensemaking version); rebuilding the index');\n      db.close();\n      clearCache(cfg);\n      return open(cfg);\n    }\n    const changedKeys = changedSignatureKeys(features ?? '', wantFeatures);\n    // Only the tokenizer moved: frontmatter, links, sections, and embeddings are file-derived\n    // and tokenizer-independent, so they don't need re-deriving. Everything else -- a preset\n    // edit, an embed model change -- still takes the full clear/reopen below.\n    if (changedKeys.size === 1 && changedKeys.has('tokenize')) {\n      console.error('sense: config change (content tokenizer) rebuilds the text index; vectors, links, and sections are kept');\n      db.exec('DROP TABLE content');\n      tokenizeOnlyRebuild = true;\n    } else {\n      const changed = signatureDiff(features ?? '', wantFeatures);\n      console.error(`sense: config change (${changed}) rebuilds the index`);\n      db.close();\n      clearCache(cfg);\n      return open(cfg);\n    }\n  }\n\n  // Meta can lie after a crash between table creation and the signature write; the table's\n  // own DDL cannot. A mismatch here rebuilds no matter what meta says. A tokenize-only rebuild\n  // just dropped content above, so storedTokenize sees no table and this guard is skipped\n  // naturally rather than needing its own case.\n  const stored = storedTokenize(db);\n  if (stored !== null && stored !== tokenize) {\n    console.error('sense: cache was built with a different content tokenizer; rebuilding the index');\n    db.close();\n    clearCache(cfg);\n    return open(cfg);\n  }\n\n  ensureSchema(db, cfg, tokenize);\n\n  let rebuildWarnings: string[] = [];\n  if (tokenizeOnlyRebuild) {\n    rebuildWarnings = rebuildContentTable(db, cfg, cfg.baseDir);\n    setMeta(db, 'features', wantFeatures);\n  }\n\n  // 3x the largest reconcile this cache has recorded, floored at 30s and capped at 10min.\n  // Installed before reconcile() -- that call is the one that races a watcher's transaction.\n  const recordedMaxMs = Number(getMeta(db, 'reconcile_max_ms') ?? '0');\n  db.exec(`PRAGMA busy_timeout = ${Math.min(Math.max(30000, 3 * recordedMaxMs), 600_000)}`);\n\n  const { parsed, warnings } = reconcile(db, cfg, cfg.baseDir);\n\n  return { db, cfg, dbPath, parsed, warnings: [...rebuildWarnings, ...warnings] };\n}\n\n// Deletes the cache directory, and only that. The rebuild is not this function's job: the next\n// open() reconciles, which is what running any command already does, so a verb that bundled the\n// two described the half that was not its own. Manual reset for a doubted cache; the schema and\n// config-signature mismatches below reset themselves.\nexport function clearCache(cfg: ResolvedConfig): void {\n  rmSync(join(cfg.baseDir, STATE_DIR), { recursive: true, force: true });\n}\n"],"names":["DB_FILENAME","SCHEMA_VERSION","clearCache","docCount","open","DEFAULT_TOKENIZE","resolveTokenize","db","cfg","configured","contentTokenize","undefined","literal","replace","exec","err","SenseError","message","storedTokenize","row","prepare","get","m","sql","match","ensureSchema","tokenize","activeFeatures","feature","schema","getMeta","setMeta","featureSignature","n","stateDir","join","baseDir","STATE_DIR","mkdirSync","recursive","dbPath","DatabaseSync","registerFunctions","version","features","wantFeatures","tokenizeOnlyRebuild","console","error","close","changedKeys","changedSignatureKeys","size","has","changed","signatureDiff","stored","rebuildWarnings","rebuildContentTable","recordedMaxMs","Number","Math","min","max","reconcile","parsed","warnings","rmSync","force"],"mappings":"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"}
+{"version":3,"sources":["/Users/kevin/Dev/OpenSource/ai/sensemaking/src/db/open.ts"],"sourcesContent":["// The Node floor (>=22.20) is explained here and nowhere else: 22.20 is the first release with\n// both FTS5 and row-returning INSERT ... RETURNING. Raise it only for a load-bearing capability.\nimport { mkdirSync, rmSync } from 'node:fs';\nimport { join } from 'node:path';\nimport { DatabaseSync } from 'node:sqlite';\nimport type { Config, ResolvedConfig } from '../config/index.ts';\nimport { contentTokenize, featureSignature, STATE_DIR } from '../config/index.ts';\nimport { SenseError } from '../errors.ts';\nimport { activeFeatures } from '../features/index.ts';\nimport { registerFunctions } from '../sql-functions.ts';\nimport { changedSignatureKeys, rebuildContentTable, reconcile, signatureDiff } from './reconcile.ts';\nimport { getMeta, setMeta } from './shared.ts';\n\nexport const DB_FILENAME = 'cache.db';\n// Cache shape version, independent of the config's own `version`. Bumping it rebuilds\n// existing trees on first query.\nexport const SCHEMA_VERSION = '15';\n\nexport interface OpenResult {\n  db: DatabaseSync;\n  cfg: ResolvedConfig;\n  dbPath: string;\n  parsed: number;\n  warnings: string[];\n}\n\n// Stemming is English-only, but the segmentation underneath it is what decides coverage:\n// unicode61 splits on spaces, so a language written without them (Chinese, Japanese, Thai)\n// indexes a whole run as one token and word search finds nothing. `content.tokenize` is how\n// such a tree picks trigram instead.\nconst DEFAULT_TOKENIZE = 'porter unicode61';\n\n// FTS5 takes its tokenizer as a string literal inside DDL, where nothing can bind, so a\n// configured value has to be concatenated. Probing a throwaway table is what makes that safe\n// and is also the whole validation: anything the linked SQLite accepts passes, anything else\n// fails here with SQLite's own message rather than against the real table. It means no table\n// of which version added which tokenizer has to be maintained.\nfunction resolveTokenize(db: DatabaseSync, cfg: Config): string {\n  const configured = contentTokenize(cfg);\n  if (configured === undefined) return DEFAULT_TOKENIZE;\n  const literal = configured.replace(/'/g, \"''\");\n  try {\n    db.exec('DROP TABLE IF EXISTS temp.sense_tokenize_probe');\n    db.exec(`CREATE VIRTUAL TABLE temp.sense_tokenize_probe USING fts5(x, tokenize = '${literal}')`);\n    db.exec('DROP TABLE IF EXISTS temp.sense_tokenize_probe');\n  } catch (err) {\n    throw new SenseError('CONFIG_INVALID', `content.tokenize \"${configured}\" is not a tokenizer this SQLite accepts (${(err as Error).message}); the built-in choices are unicode61, ascii, porter, and trigram, each with their own options`);\n  }\n  return literal;\n}\n\n// The tokenizer the content table was actually built with, from its own DDL -- the one\n// record that cannot desynchronize from the table. NULL when the table does not exist yet.\nfunction storedTokenize(db: DatabaseSync): string | null {\n  const row = db.prepare(`SELECT sql FROM sqlite_master WHERE name = 'content'`).get() as { sql: string } | undefined;\n  if (!row) return null;\n  const m = row.sql.match(/tokenize = '((?:[^']|'')*)'/);\n  return m ? m[1] : null;\n}\n\n// Content is a separate table (not a column on frontmatter) so `SELECT * FROM frontmatter`\n// can't dump file text into context. Features add their own tables after the core ones.\nfunction ensureSchema(db: DatabaseSync, cfg: Config, tokenize: string): void {\n  db.exec(`CREATE TABLE IF NOT EXISTS frontmatter (\"path\" TEXT PRIMARY KEY, \"_mtime\" REAL, \"_ctime\" REAL, \"_size\" INTEGER, \"_parse_error\" TEXT)`);\n  // IF NOT EXISTS is safe against a tokenizer change: open() compares the table's own DDL\n  // against the resolved tokenizer before this runs, so a stale table is already gone by now.\n  // The three `_seg` sidecars are appended after path, never inserted: bm25(content, ...) and\n  // snippet(content, 2, ...) are documented against the first three columns and keep working\n  // (FTS5 defaults the weights it was not given). Each carries its field's exploded unspaced\n  // runs for text that needs it, and an empty string for text that does not.\n  db.exec(`CREATE VIRTUAL TABLE IF NOT EXISTS content USING fts5(title, summary, text, path UNINDEXED, title_seg, summary_seg, text_seg, tokenize = '${tokenize}')`);\n  // Coverage, not ownership: a path can appear under several presets. path leads the PK so the\n  // per-doc delete is an index hit -- keyed the other way, cold builds went quadratic.\n  db.exec(`CREATE TABLE IF NOT EXISTS preset_files (\"path\" TEXT, preset TEXT, PRIMARY KEY (\"path\", preset))`);\n  db.exec('CREATE INDEX IF NOT EXISTS preset_files_preset ON preset_files(preset)');\n  for (const feature of activeFeatures(cfg)) feature.schema(db);\n  if (getMeta(db, 'schema_version') === null) setMeta(db, 'schema_version', SCHEMA_VERSION);\n  if (getMeta(db, 'features') === null) setMeta(db, 'features', featureSignature(cfg));\n}\n\nexport function docCount(db: DatabaseSync): number {\n  const row = db.prepare('SELECT COUNT(*) AS n FROM frontmatter').get() as { n: number };\n  return row.n;\n}\n\nexport function open(cfg: ResolvedConfig): OpenResult {\n  const stateDir = join(cfg.baseDir, STATE_DIR);\n  mkdirSync(stateDir, { recursive: true });\n  const dbPath = join(stateDir, DB_FILENAME);\n\n  const db = new DatabaseSync(dbPath);\n  db.exec('PRAGMA journal_mode = WAL');\n  // Covers a concurrent watcher's bulk reconcile (~5s for 500 files at 26k notes). A query\n  // that outwaits it still fails loudly.\n  db.exec('PRAGMA busy_timeout = 30000');\n  registerFunctions(db, contentTokenize(cfg) === undefined);\n\n  db.exec('CREATE TABLE IF NOT EXISTS meta (key TEXT PRIMARY KEY, value TEXT)');\n\n  // Before the rebuild branch below, never after: that branch deletes the cache, so a typo'd\n  // tokenizer validated later would cost a full re-index (and re-embed) to reach its own error.\n  const tokenize = resolveTokenize(db, cfg);\n\n  // Schema-version or feature-set mismatch: reconcile only reparses changed files, so an\n  // old cache can't be patched incrementally -- rebuild instead (cheap: nothing expensive lives here).\n  const version = getMeta(db, 'schema_version');\n  const features = getMeta(db, 'features');\n  const wantFeatures = featureSignature(cfg);\n  let tokenizeOnlyRebuild = false;\n  if ((version !== null && version !== SCHEMA_VERSION) || (features !== null && features !== wantFeatures)) {\n    // Indexing derives from presets, so a config edit rebuilding the cache must say so and\n    // name what changed -- silent rebuilds make derived indexing look like a hang or a bug.\n    if (version !== null && version !== SCHEMA_VERSION) {\n      console.error('sense: cache format changed (new sensemaking version); rebuilding the index');\n      db.close();\n      clearCache(cfg);\n      return open(cfg);\n    }\n    const changedKeys = changedSignatureKeys(features ?? '', wantFeatures);\n    // Only the tokenizer moved: frontmatter, links, sections, and embeddings are file-derived\n    // and tokenizer-independent, so they don't need re-deriving. Everything else -- a preset\n    // edit, an embed model change -- still takes the full clear/reopen below.\n    if (changedKeys.size === 1 && changedKeys.has('tokenize')) {\n      console.error('sense: config change (content tokenizer) rebuilds the text index; vectors, links, and sections are kept');\n      db.exec('DROP TABLE content');\n      tokenizeOnlyRebuild = true;\n    } else {\n      const changed = signatureDiff(features ?? '', wantFeatures);\n      console.error(`sense: config change (${changed}) rebuilds the index`);\n      db.close();\n      clearCache(cfg);\n      return open(cfg);\n    }\n  }\n\n  // Meta can lie after a crash between table creation and the signature write; the table's\n  // own DDL cannot. A mismatch here rebuilds no matter what meta says. A tokenize-only rebuild\n  // just dropped content above, so storedTokenize sees no table and this guard is skipped\n  // naturally rather than needing its own case.\n  const stored = storedTokenize(db);\n  if (stored !== null && stored !== tokenize) {\n    console.error('sense: cache was built with a different content tokenizer; rebuilding the index');\n    db.close();\n    clearCache(cfg);\n    return open(cfg);\n  }\n\n  ensureSchema(db, cfg, tokenize);\n\n  let rebuildWarnings: string[] = [];\n  if (tokenizeOnlyRebuild) {\n    rebuildWarnings = rebuildContentTable(db, cfg, cfg.baseDir);\n    setMeta(db, 'features', wantFeatures);\n  }\n\n  // 3x the largest reconcile this cache has recorded, floored at 30s and capped at 10min.\n  // Installed before reconcile() -- that call is the one that races a watcher's transaction.\n  const recordedMaxMs = Number(getMeta(db, 'reconcile_max_ms') ?? '0');\n  db.exec(`PRAGMA busy_timeout = ${Math.min(Math.max(30000, 3 * recordedMaxMs), 600_000)}`);\n\n  const { parsed, warnings } = reconcile(db, cfg, cfg.baseDir);\n\n  return { db, cfg, dbPath, parsed, warnings: [...rebuildWarnings, ...warnings] };\n}\n\n// Deletes the cache directory, and only that. The rebuild is not this function's job: the next\n// open() reconciles, which is what running any command already does, so a verb that bundled the\n// two described the half that was not its own. Manual reset for a doubted cache; the schema and\n// config-signature mismatches below reset themselves.\nexport function clearCache(cfg: ResolvedConfig): void {\n  rmSync(join(cfg.baseDir, STATE_DIR), { recursive: true, force: true });\n}\n"],"names":["DB_FILENAME","SCHEMA_VERSION","clearCache","docCount","open","DEFAULT_TOKENIZE","resolveTokenize","db","cfg","configured","contentTokenize","undefined","literal","replace","exec","err","SenseError","message","storedTokenize","row","prepare","get","m","sql","match","ensureSchema","tokenize","activeFeatures","feature","schema","getMeta","setMeta","featureSignature","n","stateDir","join","baseDir","STATE_DIR","mkdirSync","recursive","dbPath","DatabaseSync","registerFunctions","version","features","wantFeatures","tokenizeOnlyRebuild","console","error","close","changedKeys","changedSignatureKeys","size","has","changed","signatureDiff","stored","rebuildWarnings","rebuildContentTable","recordedMaxMs","Number","Math","min","max","reconcile","parsed","warnings","rmSync","force"],"mappings":"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"}

package/dist/cjs/features/embed.js

@@ -48,6 +48,7 @@ var _nodeos = require("node:os");
 var _nodepath = require("node:path");
 var _indexts = require("../config/index.js");
 var _errorsts = require("../errors.js");
+var _fencests = require("../fences.js");
 var _progressts = require("../progress.js");
 var _scants = require("../scan.js");
 function _array_like_to_array(arr, len) {
@@ -311,13 +312,10 @@ function chunksOf(body, search) {
     var offset = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : 0;
     var lines = body.split('\n');
     var starts = [];
-    var inFence = false;
+    var fence = (0, _fencests.fenceTracker)();
     for(var i = 0; i < lines.length; i++){
-        if (/^(```|~~~)/.test(lines[i])) {
-            inFence = !inFence;
-            continue;
-        }
-        if (!inFence && /^#{1,6} +/.test(lines[i])) starts.push(i + 1);
+        if (fence.feed(lines[i])) continue;
+        if (!fence.inFence && /^#{1,6} +/.test(lines[i])) starts.push(i + 1);
     }
     var bounds = starts.length === 0 ? [
         1

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

@@ -1 +1 @@
-{"version":3,"sources":["/Users/kevin/Dev/OpenSource/ai/sensemaking/src/features/embed.ts"],"sourcesContent":["import { existsSync, mkdirSync, readFileSync, renameSync, writeFileSync } from 'node:fs';\nimport { homedir } from 'node:os';\nimport { join } from 'node:path';\nimport type { DatabaseSync } from 'node:sqlite';\nimport type { Config, ResolvedConfig } from '../config/index.ts';\nimport { embedConfig } from '../config/index.ts';\nimport { SenseError } from '../errors.ts';\nimport { progress } from '../progress.ts';\nimport { parseFile } from '../scan.ts';\nimport type { Feature } from './types.ts';\n\n// Heading-based chunks, int8 vectors with a per-vector scale, NULL vector = not yet embedded.\n// Reconcile writes dirty rows; embedding tops up on the next search, so staleness costs recall.\n\n// Storage lever fixed by the bake-off (BENCHMARKING.md): int8 at 256 dims is\n// quality-free vs f32-512 when fused. Queries stay f32 at the same dims.\nconst STORE_DIMS = 256;\n// Seed chunks that participate in a `related` scan; see similarNotes for the measurement.\nconst TARGET_CHUNK_CAP = 16;\nconst BATCH = 64;\n\nexport interface EmbedProvider {\n  id: string; // model identity; participates in the cache key, change -> re-embed\n  dims: number;\n  embed(texts: string[]): Promise<Float32Array[]>;\n}\n\ninterface Chunk {\n  startLine: number;\n  endLine: number;\n  text: string;\n}\n\n// Deterministic, so embed time can re-derive text from stored line ranges. Heading-delimited,\n// preamble kept, whole body when no headings; the title/summary prefix mirrors bm25 weighting.\n//\n// Chunks the body, not the raw file, with `offset` shifting line numbers back onto the raw\n// file so a range stays a direct Read range (sections is 1-indexed over raw too). Chunking raw\n// put the frontmatter block in its own leading chunk on every note with a heading, which made\n// `lines` point at YAML and made frontmatter-only notes near-identical to each other. It also\n// disagreed with FTS, which indexes the body alone.\nfunction chunksOf(body: string, search?: { title: string; summary: string }, offset = 0): Chunk[] {\n  const lines = body.split('\\n');\n  const starts: number[] = [];\n  let inFence = false;\n  for (let i = 0; i < lines.length; i++) {\n    if (/^(```|~~~)/.test(lines[i])) {\n      inFence = !inFence;\n      continue;\n    }\n    if (!inFence && /^#{1,6} +/.test(lines[i])) starts.push(i + 1);\n  }\n  const bounds = starts.length === 0 ? [1] : starts[0] > 1 ? [1, ...starts] : starts;\n  const prefix = [search?.title, search?.summary].filter(Boolean).join('\\n');\n  const chunks: Chunk[] = [];\n  bounds.forEach((start, i) => {\n    const end = i + 1 < bounds.length ? bounds[i + 1] - 1 : lines.length;\n    const text = lines\n      .slice(start - 1, end)\n      .join('\\n')\n      .trim();\n    // A body with nothing in it yields no chunks at all, so a frontmatter-only note has no\n    // vectors rather than a vector of its own YAML.\n    if (text.length > 0) chunks.push({ startLine: start + offset, endLine: end + offset, text: prefix ? `${prefix}\\n${text}` : text });\n  });\n  return chunks;\n}\n\nexport const embed: Feature = {\n  name: 'embed',\n  schema(db) {\n    db.exec(`CREATE TABLE IF NOT EXISTS embeddings (\"path\" TEXT, chunk INTEGER, start_line INTEGER, end_line INTEGER, scale REAL, vector BLOB, PRIMARY KEY (\"path\", chunk))`);\n  },\n  extract(raw, body, search) {\n    // Lines the frontmatter occupies, so body line 1 maps back to its raw line number.\n    return chunksOf(body, search, raw.split('\\n').length - body.split('\\n').length);\n  },\n  remove(db, path) {\n    db.prepare('DELETE FROM embeddings WHERE \"path\" = ?').run(path);\n  },\n  // A tree with no embedding model never had extract() run for the doc (db.ts's per-file\n  // filter skips it), so extracted is undefined here -- store nothing, i.e. no rows.\n  store(db, path, extracted) {\n    if (!extracted) return;\n    const insert = db.prepare('INSERT INTO embeddings (\"path\", chunk, start_line, end_line, scale, vector) VALUES (?, ?, ?, ?, NULL, NULL)');\n    (extracted as Chunk[]).forEach((c, idx) => insert.run(path, idx, c.startLine, c.endLine));\n  },\n  enabledForFile(_cfg, file) {\n    return file.embed;\n  },\n};\n\n// --- static type: Model2Vec safetensors + pure-JS tokenizer, model cached in ~/.cache ---\n// Encode convention from model2vec/model.py: no special tokens, drop unk ids, mean-pool,\n// L2-normalize.\n\nconst MODEL_FILES = ['model.safetensors', 'tokenizer.json'];\n// The pair, for messages that name what a local model directory must contain.\nexport const MODEL_FILENAMES = MODEL_FILES.join(' and ');\n\n// A Hugging Face repo id: one slash, HF's charset. Anything else is a path, used as one rather\n// than flattened into a cache key Windows would reject.\nconst HF_MODEL_ID = /^[A-Za-z0-9][\\w.-]*\\/[A-Za-z0-9][\\w.-]*$/;\n\n// Downloadable iff it names a Hugging Face repo; a local path is the caller's to populate.\nexport function isDownloadable(model: string): boolean {\n  return HF_MODEL_ID.test(model);\n}\n\n// Machine-wide, not per-tree: `.sense/` is the index a rebuild throws away, while a 124 MB\n// model is shared by every tree on the machine. Honors XDG_CACHE_HOME where it is set;\n// elsewhere ~/.cache, which is also where Hugging Face's own libraries keep theirs.\nfunction cacheRoot(): string {\n  const xdg = process.env.XDG_CACHE_HOME;\n  return join(xdg && xdg.length > 0 ? xdg : join(homedir(), '.cache'), 'sensemaking', 'models');\n}\n\n// A model is either a local directory the caller pointed at, or the cache `sense download`\n// fills. Nothing here fetches: an absent model degrades search to its other signals rather\n// than pulling 124 MB out of a command that reads like a query.\nexport function modelDir(model: string): string {\n  if (!HF_MODEL_ID.test(model)) return model;\n  return join(cacheRoot(), model.replace(/\\//g, '--'));\n}\n\n// Both files, so an interrupted download reads as absent and the next one resumes it.\nexport function hasModelFiles(model: string): boolean {\n  const dir = modelDir(model);\n  return MODEL_FILES.every((file) => existsSync(join(dir, file)));\n}\n\n// api providers have nothing to download, so they are never \"missing\" here; an unreachable\n// endpoint surfaces as an EMBED_MODEL error at call time instead.\nexport function modelPresent(cfg: Config): boolean {\n  const e = embedConfig(cfg);\n  if (!e) return false;\n  return e.type === 'api' || hasModelFiles(e.model);\n}\n\nfunction fetchToFile(url: string, dest: string): Promise<void> {\n  return fetch(url).then(async (res) => {\n    if (!res.ok) throw new SenseError('EMBED_MODEL', `model download failed: ${url} -> HTTP ${res.status}`);\n    writeFileSync(`${dest}.part`, Buffer.from(await res.arrayBuffer()));\n    renameSync(`${dest}.part`, dest);\n  });\n}\n\n// The only code path that touches the network for weights. `sense download` calls it; no\n// query ever does. Idempotent: a file already on disk is left alone.\nexport async function downloadModel(model: string, onFile?: (file: string, dir: string) => void): Promise<string> {\n  if (!isDownloadable(model)) {\n    throw new SenseError('EMBED_MODEL', `embed.model \"${model}\" is a local path, not a Hugging Face model id, so there is nothing to download; put model.safetensors and tokenizer.json in that directory, or name a model id like \"minishlab/potion-retrieval-32M\"`);\n  }\n  const dir = modelDir(model);\n  mkdirSync(dir, { recursive: true });\n  for (const file of MODEL_FILES) {\n    if (existsSync(join(dir, file))) continue;\n    onFile?.(file, dir);\n    await fetchToFile(`https://huggingface.co/${model}/resolve/main/${file}`, join(dir, file));\n  }\n  return dir;\n}\n\nasync function staticProvider(model: string): Promise<EmbedProvider> {\n  const dir = modelDir(model);\n  for (const file of MODEL_FILES) {\n    if (!existsSync(join(dir, file))) {\n      // A local path the caller controls gets told what is missing where; only a repo id can\n      // be fixed by downloading.\n      const fix = isDownloadable(model) ? 'run `sense download`' : `expected ${MODEL_FILENAMES} in that directory`;\n      throw new SenseError('EMBED_MODEL_MISSING', `embed model ${model} is not available (looked in ${dir}); ${fix}`);\n    }\n  }\n\n  const raw = readFileSync(join(dir, 'model.safetensors'));\n  const headerLen = Number(raw.readBigUInt64LE(0));\n  const header = JSON.parse(raw.subarray(8, 8 + headerLen).toString('utf8')) as Record<string, { dtype: string; shape: number[]; data_offsets: number[] }>;\n  const entry = Object.entries(header).find(([k]) => k !== '__metadata__');\n  if (!entry || entry[1].dtype !== 'F32') throw new SenseError('EMBED_MODEL', `${model}: expected an F32 safetensors matrix`);\n  const spec = entry[1];\n  const dims = spec.shape[1];\n  const dataStart = raw.byteOffset + 8 + headerLen + spec.data_offsets[0];\n  const matrix = dataStart % 4 === 0 ? new Float32Array(raw.buffer, dataStart, spec.shape[0] * dims) : new Float32Array(raw.buffer.slice(dataStart, dataStart + spec.shape[0] * dims * 4));\n\n  const tokenizerJson = JSON.parse(readFileSync(join(dir, 'tokenizer.json'), 'utf8'));\n  // Lazy import: the tokenizer loads only on the semantic path, never at CLI startup.\n  const { Tokenizer } = await import('@huggingface/tokenizers');\n  const tok = new Tokenizer(tokenizerJson, {});\n  const unkId = tokenizerJson.model?.vocab?.[tokenizerJson.model?.unk_token] ?? -1;\n\n  function one(text: string): Float32Array {\n    // The tokenizer yields undefined (not the unk id) for tokens outside the vocab; an\n    // undefined id would index the matrix at NaN and poison the whole mean-pool -- and the\n    // int8 conversion then stores the NaN vector as all zeros, silently. Keep integers only.\n    const ids = (tok.encode(text, { add_special_tokens: false }).ids as number[]).filter((id) => Number.isInteger(id) && id !== unkId);\n    const v = new Float32Array(dims);\n    if (ids.length === 0) return v;\n    for (const id of ids) {\n      const off = id * dims;\n      for (let d = 0; d < dims; d++) v[d] += matrix[off + d];\n    }\n    let norm = 0;\n    for (let d = 0; d < dims; d++) {\n      v[d] /= ids.length;\n      norm += v[d] * v[d];\n    }\n    norm = Math.sqrt(norm) + 1e-32;\n    for (let d = 0; d < dims; d++) v[d] /= norm;\n    return v;\n  }\n\n  return { id: `static:${model}`, dims, embed: async (texts) => texts.map(one) };\n}\n\n// --- api type: one POST against any OpenAI-compatible /embeddings endpoint ---\n\nasync function apiProvider(model: string, url: string | undefined, keyEnv: string | undefined): Promise<EmbedProvider> {\n  if (!url) throw new SenseError('EMBED_MODEL', 'features.embed.type \"api\" requires a url');\n  const base = url.replace(/\\/+$/, '');\n  const headers: Record<string, string> = { 'content-type': 'application/json' };\n  const key = keyEnv ? process.env[keyEnv] : undefined;\n  if (key) headers.authorization = `Bearer ${key}`;\n\n  async function post(texts: string[]): Promise<Float32Array[]> {\n    const res = await fetch(`${base}/embeddings`, { method: 'POST', headers, body: JSON.stringify({ model, input: texts }) });\n    if (!res.ok) throw new SenseError('EMBED_MODEL', `${base}/embeddings -> HTTP ${res.status}`);\n    const body = (await res.json()) as { data: Array<{ embedding: number[] }> };\n    return body.data.map((d) => Float32Array.from(d.embedding));\n  }\n\n  const dims = (await post(['dimension probe']))[0].length;\n  return { id: `api:${base}:${model}`, dims, embed: post };\n}\n\nconst providers = new Map<string, Promise<EmbedProvider>>();\n\nfunction getProvider(cfg: Config): Promise<EmbedProvider> {\n  const e = embedConfig(cfg);\n  if (!e) throw new SenseError('EMBED_DISABLED', 'this tree has no embedding model: add an \"embed\" block naming one to sense.config.json, then run `sense download`');\n  const sig = `${e.type}:${e.model}:${e.url ?? ''}`;\n  let p = providers.get(sig);\n  if (!p) {\n    p = e.type === 'api' ? apiProvider(e.model, e.url, e.key) : staticProvider(e.model);\n    providers.set(sig, p);\n  }\n  return p;\n}\n\n// Slice + re-normalize (Matryoshka); optionally round through int8 storage.\nfunction toStore(full: Float32Array, dims: number, int8: boolean): { v: Float32Array; scale: number } {\n  const v = new Float32Array(dims);\n  let norm = 0;\n  for (let d = 0; d < dims; d++) norm += full[d] * full[d];\n  norm = Math.sqrt(norm) + 1e-32;\n  for (let d = 0; d < dims; d++) v[d] = full[d] / norm;\n  if (!int8) return { v, scale: 1 };\n  let max = 0;\n  for (let d = 0; d < dims; d++) max = Math.max(max, Math.abs(v[d]));\n  return { v, scale: max / 127 || 1 };\n}\n\n// Embed rows whose vector is NULL, re-deriving chunk text from the files through the\n// same parse + chunker that stored the rows.\nexport async function embedPending(db: DatabaseSync, cfg: Config, baseDir: string): Promise<void> {\n  const provider = await getProvider(cfg); // throws EMBED_DISABLED before touching the table\n  const dirty = db.prepare('SELECT \"path\", chunk FROM embeddings WHERE vector IS NULL ORDER BY \"path\", chunk').all() as Array<{ path: string; chunk: number }>;\n  if (dirty.length === 0) return;\n  const storeDims = Math.min(STORE_DIMS, provider.dims);\n\n  const byPath = new Map<string, number[]>();\n  for (const row of dirty) {\n    const list = byPath.get(row.path) ?? [];\n    list.push(row.chunk);\n    byPath.set(row.path, list);\n  }\n\n  const jobs: Array<{ path: string; chunk: number; text: string }> = [];\n  for (const [path, chunkIdxs] of byPath) {\n    let chunks: Chunk[];\n    try {\n      // presets/embed are irrelevant here -- re-deriving chunk text for a doc that already\n      // has embeddings rows means the tree had an embedding model at reconcile time.\n      chunks = parseFile({ relPath: path, absPath: join(baseDir, path), mtimeMs: 0, ctimeMs: 0, size: 0, presets: [], embed: true }, [embed]).doc.extracted.embed as Chunk[];\n    } catch {\n      continue; // vanished since reconcile; the next reconcile removes its rows\n    }\n    for (const idx of chunkIdxs) if (chunks[idx]) jobs.push({ path, chunk: idx, text: chunks[idx].text });\n  }\n\n  const update = db.prepare('UPDATE embeddings SET scale = ?, vector = ? WHERE \"path\" = ? AND chunk = ?');\n  // The lazy build is the one long silence a first search hits (measured 23s at\n  // 26k notes); progress makes it distinguishable from a hang.\n  const report = progress('embedding chunks', jobs.length);\n  for (let i = 0; i < jobs.length; i += BATCH) {\n    const batch = jobs.slice(i, i + BATCH);\n    const vectors = await provider.embed(batch.map((j) => j.text));\n    db.exec('BEGIN');\n    try {\n      batch.forEach((job, j) => {\n        const { v, scale } = toStore(vectors[j], storeDims, true);\n        const q = new Int8Array(storeDims);\n        for (let d = 0; d < storeDims; d++) q[d] = Math.round(v[d] / scale);\n        update.run(scale, Buffer.from(q.buffer), job.path, job.chunk);\n      });\n      db.exec('COMMIT');\n    } catch (err) {\n      db.exec('ROLLBACK');\n      throw err;\n    }\n    report.tick(Math.min(i + BATCH, jobs.length));\n  }\n  report.finish();\n}\n\n// Dequantised int8 dot products land a little either side of a true cosine, so an identical\n// pair prints 1.001 and undermines a column whose whole job is being a bounded number.\nfunction asCosine(score: number): number {\n  return Math.round(Math.min(1, Math.max(-1, score)) * 1000) / 1000;\n}\n\n// Best chunk per file by cosine, its line range riding along; FTS5 operators are stripped as\n// lexical syntax. Similarity comes back because the fused score cannot express match quality,\n// and nearest-neighbour search always returns a neighbour however far away.\nexport async function semanticCandidates(db: DatabaseSync, cfg: Config, terms: string, fetch: number, allowed?: Set<string>): Promise<Array<{ path: string; lines: string; similarity: number }>> {\n  const baseDir = (cfg as Partial<ResolvedConfig>).baseDir;\n  if (!baseDir) throw new SenseError('EMBED_MODEL', 'semantic expansion needs a config with baseDir (use loadConfig/open)');\n  await embedPending(db, cfg, baseDir);\n\n  const provider = await getProvider(cfg);\n  const storeDims = Math.min(STORE_DIMS, provider.dims);\n  const text = (terms.match(/[\\p{L}\\p{N}]+/gu) ?? []).filter((t) => !['AND', 'OR', 'NOT', 'NEAR'].includes(t)).join(' ');\n  const { v: qv } = toStore((await provider.embed([text]))[0], storeDims, false);\n\n  const rows = db.prepare('SELECT \"path\", start_line, end_line, scale, vector FROM embeddings WHERE vector IS NOT NULL').all() as Array<{\n    path: string;\n    start_line: number;\n    end_line: number;\n    scale: number;\n    vector: Uint8Array;\n  }>;\n\n  const best = new Map<string, { score: number; lines: string }>();\n  for (const row of rows) {\n    if (allowed && !allowed.has(row.path)) continue;\n    const q = new Int8Array(row.vector.buffer, row.vector.byteOffset, Math.min(storeDims, row.vector.byteLength));\n    let dot = 0;\n    for (let d = 0; d < q.length; d++) dot += q[d] * qv[d];\n    const score = dot * row.scale;\n    const existing = best.get(row.path);\n    if (!existing || score > existing.score) best.set(row.path, { score, lines: `L${row.start_line}-${row.end_line}` });\n  }\n  return [...best.entries()]\n    .sort((a, b) => b[1].score - a[1].score)\n    .slice(0, fetch)\n    .map(([path, b]) => ({ path, lines: b.lines, similarity: asCosine(b.score) }));\n}\n\n// Whether a note has any chunk with a vector. Distinguishes \"nothing is near this note\" from\n// \"this note has no text\", which look the same in an empty result.\nexport function hasEmbedding(db: DatabaseSync, path: string): boolean {\n  const row = db.prepare('SELECT 1 AS ok FROM embeddings WHERE \"path\" = ? AND vector IS NOT NULL LIMIT 1').get(path) as { ok: number } | undefined;\n  return row !== undefined;\n}\n\n// Note-to-note similarity is the max cosine over (target chunk, other chunk) pairs, one linear\n// scan of stored vectors. Reads only what is stored, so it stays sync.\nexport function similarNotes(db: DatabaseSync, _cfg: Config, path: string, opts: { exclude: Set<string>; allowed?: Set<string>; k: number }): Array<{ path: string; similarity: number }> {\n  // Cost is target_chunks x stored_chunks, so a heading-dense seed multiplies a full-corpus\n  // scan (12.7s at 201 chunks/note). Sample evenly, so late sections still get a vote.\n  const targetRows = db.prepare('SELECT scale, vector FROM embeddings WHERE \"path\" = ? AND vector IS NOT NULL ORDER BY chunk').all(path) as Array<{ scale: number; vector: Uint8Array }>;\n  if (targetRows.length === 0) return [];\n  const step = Math.max(1, Math.ceil(targetRows.length / TARGET_CHUNK_CAP));\n  const target = targetRows.filter((_, i) => i % step === 0).map((row) => ({ v: new Int8Array(row.vector.buffer, row.vector.byteOffset, row.vector.byteLength), scale: row.scale }));\n\n  const rows = db.prepare('SELECT \"path\", scale, vector FROM embeddings WHERE vector IS NOT NULL').all() as Array<{ path: string; scale: number; vector: Uint8Array }>;\n  const best = new Map<string, number>();\n  for (const row of rows) {\n    if (row.path === path || opts.exclude.has(row.path) || (opts.allowed && !opts.allowed.has(row.path))) continue;\n    const other = new Int8Array(row.vector.buffer, row.vector.byteOffset, row.vector.byteLength);\n    for (const t of target) {\n      let dot = 0;\n      const len = Math.min(t.v.length, other.length);\n      for (let d = 0; d < len; d++) dot += t.v[d] * other[d];\n      const score = dot * t.scale * row.scale;\n      const existing = best.get(row.path);\n      if (existing === undefined || score > existing) best.set(row.path, score);\n    }\n  }\n\n  return [...best.entries()]\n    .sort((a, b) => b[1] - a[1])\n    .slice(0, opts.k)\n    .map(([p, score]) => ({ path: p, similarity: asCosine(score) }));\n}\n"],"names":["MODEL_FILENAMES","downloadModel","embed","embedPending","hasEmbedding","hasModelFiles","isDownloadable","modelDir","modelPresent","semanticCandidates","similarNotes","STORE_DIMS","TARGET_CHUNK_CAP","BATCH","chunksOf","body","search","offset","lines","split","starts","inFence","i","length","test","push","bounds","prefix","title","summary","filter","Boolean","join","chunks","forEach","start","end","text","slice","trim","startLine","endLine","name","schema","db","exec","extract","raw","remove","path","prepare","run","store","extracted","insert","c","idx","enabledForFile","_cfg","file","MODEL_FILES","HF_MODEL_ID","model","cacheRoot","xdg","process","env","XDG_CACHE_HOME","homedir","replace","dir","every","existsSync","cfg","e","embedConfig","type","fetchToFile","url","dest","fetch","then","res","ok","SenseError","status","Buffer","from","arrayBuffer","writeFileSync","renameSync","onFile","mkdirSync","recursive","staticProvider","tokenizerJson","fix","headerLen","header","entry","spec","dims","dataStart","matrix","Tokenizer","tok","unkId","one","ids","encode","add_special_tokens","id","Number","isInteger","v","Float32Array","off","d","norm","Math","sqrt","readFileSync","readBigUInt64LE","JSON","parse","subarray","toString","Object","entries","find","k","dtype","shape","byteOffset","data_offsets","buffer","vocab","unk_token","texts","map","apiProvider","keyEnv","base","headers","key","post","method","stringify","input","json","data","embedding","undefined","authorization","providers","Map","getProvider","sig","p","get","set","toStore","full","int8","scale","max","abs","baseDir","provider","dirty","storeDims","byPath","row","list","jobs","chunkIdxs","update","report","batch","vectors","j","job","q","Int8Array","round","chunk","err","tick","min","all","parseFile","relPath","absPath","mtimeMs","ctimeMs","size","presets","doc","progress","finish","asCosine","score","terms","allowed","qv","rows","best","dot","existing","match","t","includes","has","vector","byteLength","start_line","end_line","sort","a","b","similarity","opts","targetRows","step","ceil","target","_","exclude","other","len"],"mappings":"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"}
+{"version":3,"sources":["/Users/kevin/Dev/OpenSource/ai/sensemaking/src/features/embed.ts"],"sourcesContent":["import { existsSync, mkdirSync, readFileSync, renameSync, writeFileSync } from 'node:fs';\nimport { homedir } from 'node:os';\nimport { join } from 'node:path';\nimport type { DatabaseSync } from 'node:sqlite';\nimport type { Config, ResolvedConfig } from '../config/index.ts';\nimport { embedConfig } from '../config/index.ts';\nimport { SenseError } from '../errors.ts';\nimport { fenceTracker } from '../fences.ts';\nimport { progress } from '../progress.ts';\nimport { parseFile } from '../scan.ts';\nimport type { Feature } from './types.ts';\n\n// Heading-based chunks, int8 vectors with a per-vector scale, NULL vector = not yet embedded.\n// Reconcile writes dirty rows; embedding tops up on the next search, so staleness costs recall.\n\n// Storage lever fixed by the bake-off (BENCHMARKING.md): int8 at 256 dims is\n// quality-free vs f32-512 when fused. Queries stay f32 at the same dims.\nconst STORE_DIMS = 256;\n// Seed chunks that participate in a `related` scan; see similarNotes for the measurement.\nconst TARGET_CHUNK_CAP = 16;\nconst BATCH = 64;\n\nexport interface EmbedProvider {\n  id: string; // model identity; participates in the cache key, change -> re-embed\n  dims: number;\n  embed(texts: string[]): Promise<Float32Array[]>;\n}\n\ninterface Chunk {\n  startLine: number;\n  endLine: number;\n  text: string;\n}\n\n// Deterministic, so embed time can re-derive text from stored line ranges. Heading-delimited,\n// preamble kept, whole body when no headings; the title/summary prefix mirrors bm25 weighting.\n//\n// Chunks the body, not the raw file, with `offset` shifting line numbers back onto the raw\n// file so a range stays a direct Read range (sections is 1-indexed over raw too). Chunking raw\n// put the frontmatter block in its own leading chunk on every note with a heading, which made\n// `lines` point at YAML and made frontmatter-only notes near-identical to each other. It also\n// disagreed with FTS, which indexes the body alone.\nfunction chunksOf(body: string, search?: { title: string; summary: string }, offset = 0): Chunk[] {\n  const lines = body.split('\\n');\n  const starts: number[] = [];\n  const fence = fenceTracker();\n  for (let i = 0; i < lines.length; i++) {\n    if (fence.feed(lines[i])) continue;\n    if (!fence.inFence && /^#{1,6} +/.test(lines[i])) starts.push(i + 1);\n  }\n  const bounds = starts.length === 0 ? [1] : starts[0] > 1 ? [1, ...starts] : starts;\n  const prefix = [search?.title, search?.summary].filter(Boolean).join('\\n');\n  const chunks: Chunk[] = [];\n  bounds.forEach((start, i) => {\n    const end = i + 1 < bounds.length ? bounds[i + 1] - 1 : lines.length;\n    const text = lines\n      .slice(start - 1, end)\n      .join('\\n')\n      .trim();\n    // A body with nothing in it yields no chunks at all, so a frontmatter-only note has no\n    // vectors rather than a vector of its own YAML.\n    if (text.length > 0) chunks.push({ startLine: start + offset, endLine: end + offset, text: prefix ? `${prefix}\\n${text}` : text });\n  });\n  return chunks;\n}\n\nexport const embed: Feature = {\n  name: 'embed',\n  schema(db) {\n    db.exec(`CREATE TABLE IF NOT EXISTS embeddings (\"path\" TEXT, chunk INTEGER, start_line INTEGER, end_line INTEGER, scale REAL, vector BLOB, PRIMARY KEY (\"path\", chunk))`);\n  },\n  extract(raw, body, search) {\n    // Lines the frontmatter occupies, so body line 1 maps back to its raw line number.\n    return chunksOf(body, search, raw.split('\\n').length - body.split('\\n').length);\n  },\n  remove(db, path) {\n    db.prepare('DELETE FROM embeddings WHERE \"path\" = ?').run(path);\n  },\n  // A tree with no embedding model never had extract() run for the doc (db.ts's per-file\n  // filter skips it), so extracted is undefined here -- store nothing, i.e. no rows.\n  store(db, path, extracted) {\n    if (!extracted) return;\n    const insert = db.prepare('INSERT INTO embeddings (\"path\", chunk, start_line, end_line, scale, vector) VALUES (?, ?, ?, ?, NULL, NULL)');\n    (extracted as Chunk[]).forEach((c, idx) => insert.run(path, idx, c.startLine, c.endLine));\n  },\n  enabledForFile(_cfg, file) {\n    return file.embed;\n  },\n};\n\n// --- static type: Model2Vec safetensors + pure-JS tokenizer, model cached in ~/.cache ---\n// Encode convention from model2vec/model.py: no special tokens, drop unk ids, mean-pool,\n// L2-normalize.\n\nconst MODEL_FILES = ['model.safetensors', 'tokenizer.json'];\n// The pair, for messages that name what a local model directory must contain.\nexport const MODEL_FILENAMES = MODEL_FILES.join(' and ');\n\n// A Hugging Face repo id: one slash, HF's charset. Anything else is a path, used as one rather\n// than flattened into a cache key Windows would reject.\nconst HF_MODEL_ID = /^[A-Za-z0-9][\\w.-]*\\/[A-Za-z0-9][\\w.-]*$/;\n\n// Downloadable iff it names a Hugging Face repo; a local path is the caller's to populate.\nexport function isDownloadable(model: string): boolean {\n  return HF_MODEL_ID.test(model);\n}\n\n// Machine-wide, not per-tree: `.sense/` is the index a rebuild throws away, while a 124 MB\n// model is shared by every tree on the machine. Honors XDG_CACHE_HOME where it is set;\n// elsewhere ~/.cache, which is also where Hugging Face's own libraries keep theirs.\nfunction cacheRoot(): string {\n  const xdg = process.env.XDG_CACHE_HOME;\n  return join(xdg && xdg.length > 0 ? xdg : join(homedir(), '.cache'), 'sensemaking', 'models');\n}\n\n// A model is either a local directory the caller pointed at, or the cache `sense download`\n// fills. Nothing here fetches: an absent model degrades search to its other signals rather\n// than pulling 124 MB out of a command that reads like a query.\nexport function modelDir(model: string): string {\n  if (!HF_MODEL_ID.test(model)) return model;\n  return join(cacheRoot(), model.replace(/\\//g, '--'));\n}\n\n// Both files, so an interrupted download reads as absent and the next one resumes it.\nexport function hasModelFiles(model: string): boolean {\n  const dir = modelDir(model);\n  return MODEL_FILES.every((file) => existsSync(join(dir, file)));\n}\n\n// api providers have nothing to download, so they are never \"missing\" here; an unreachable\n// endpoint surfaces as an EMBED_MODEL error at call time instead.\nexport function modelPresent(cfg: Config): boolean {\n  const e = embedConfig(cfg);\n  if (!e) return false;\n  return e.type === 'api' || hasModelFiles(e.model);\n}\n\nfunction fetchToFile(url: string, dest: string): Promise<void> {\n  return fetch(url).then(async (res) => {\n    if (!res.ok) throw new SenseError('EMBED_MODEL', `model download failed: ${url} -> HTTP ${res.status}`);\n    writeFileSync(`${dest}.part`, Buffer.from(await res.arrayBuffer()));\n    renameSync(`${dest}.part`, dest);\n  });\n}\n\n// The only code path that touches the network for weights. `sense download` calls it; no\n// query ever does. Idempotent: a file already on disk is left alone.\nexport async function downloadModel(model: string, onFile?: (file: string, dir: string) => void): Promise<string> {\n  if (!isDownloadable(model)) {\n    throw new SenseError('EMBED_MODEL', `embed.model \"${model}\" is a local path, not a Hugging Face model id, so there is nothing to download; put model.safetensors and tokenizer.json in that directory, or name a model id like \"minishlab/potion-retrieval-32M\"`);\n  }\n  const dir = modelDir(model);\n  mkdirSync(dir, { recursive: true });\n  for (const file of MODEL_FILES) {\n    if (existsSync(join(dir, file))) continue;\n    onFile?.(file, dir);\n    await fetchToFile(`https://huggingface.co/${model}/resolve/main/${file}`, join(dir, file));\n  }\n  return dir;\n}\n\nasync function staticProvider(model: string): Promise<EmbedProvider> {\n  const dir = modelDir(model);\n  for (const file of MODEL_FILES) {\n    if (!existsSync(join(dir, file))) {\n      // A local path the caller controls gets told what is missing where; only a repo id can\n      // be fixed by downloading.\n      const fix = isDownloadable(model) ? 'run `sense download`' : `expected ${MODEL_FILENAMES} in that directory`;\n      throw new SenseError('EMBED_MODEL_MISSING', `embed model ${model} is not available (looked in ${dir}); ${fix}`);\n    }\n  }\n\n  const raw = readFileSync(join(dir, 'model.safetensors'));\n  const headerLen = Number(raw.readBigUInt64LE(0));\n  const header = JSON.parse(raw.subarray(8, 8 + headerLen).toString('utf8')) as Record<string, { dtype: string; shape: number[]; data_offsets: number[] }>;\n  const entry = Object.entries(header).find(([k]) => k !== '__metadata__');\n  if (!entry || entry[1].dtype !== 'F32') throw new SenseError('EMBED_MODEL', `${model}: expected an F32 safetensors matrix`);\n  const spec = entry[1];\n  const dims = spec.shape[1];\n  const dataStart = raw.byteOffset + 8 + headerLen + spec.data_offsets[0];\n  const matrix = dataStart % 4 === 0 ? new Float32Array(raw.buffer, dataStart, spec.shape[0] * dims) : new Float32Array(raw.buffer.slice(dataStart, dataStart + spec.shape[0] * dims * 4));\n\n  const tokenizerJson = JSON.parse(readFileSync(join(dir, 'tokenizer.json'), 'utf8'));\n  // Lazy import: the tokenizer loads only on the semantic path, never at CLI startup.\n  const { Tokenizer } = await import('@huggingface/tokenizers');\n  const tok = new Tokenizer(tokenizerJson, {});\n  const unkId = tokenizerJson.model?.vocab?.[tokenizerJson.model?.unk_token] ?? -1;\n\n  function one(text: string): Float32Array {\n    // The tokenizer yields undefined (not the unk id) for tokens outside the vocab; an\n    // undefined id would index the matrix at NaN and poison the whole mean-pool -- and the\n    // int8 conversion then stores the NaN vector as all zeros, silently. Keep integers only.\n    const ids = (tok.encode(text, { add_special_tokens: false }).ids as number[]).filter((id) => Number.isInteger(id) && id !== unkId);\n    const v = new Float32Array(dims);\n    if (ids.length === 0) return v;\n    for (const id of ids) {\n      const off = id * dims;\n      for (let d = 0; d < dims; d++) v[d] += matrix[off + d];\n    }\n    let norm = 0;\n    for (let d = 0; d < dims; d++) {\n      v[d] /= ids.length;\n      norm += v[d] * v[d];\n    }\n    norm = Math.sqrt(norm) + 1e-32;\n    for (let d = 0; d < dims; d++) v[d] /= norm;\n    return v;\n  }\n\n  return { id: `static:${model}`, dims, embed: async (texts) => texts.map(one) };\n}\n\n// --- api type: one POST against any OpenAI-compatible /embeddings endpoint ---\n\nasync function apiProvider(model: string, url: string | undefined, keyEnv: string | undefined): Promise<EmbedProvider> {\n  if (!url) throw new SenseError('EMBED_MODEL', 'features.embed.type \"api\" requires a url');\n  const base = url.replace(/\\/+$/, '');\n  const headers: Record<string, string> = { 'content-type': 'application/json' };\n  const key = keyEnv ? process.env[keyEnv] : undefined;\n  if (key) headers.authorization = `Bearer ${key}`;\n\n  async function post(texts: string[]): Promise<Float32Array[]> {\n    const res = await fetch(`${base}/embeddings`, { method: 'POST', headers, body: JSON.stringify({ model, input: texts }) });\n    if (!res.ok) throw new SenseError('EMBED_MODEL', `${base}/embeddings -> HTTP ${res.status}`);\n    const body = (await res.json()) as { data: Array<{ embedding: number[] }> };\n    return body.data.map((d) => Float32Array.from(d.embedding));\n  }\n\n  const dims = (await post(['dimension probe']))[0].length;\n  return { id: `api:${base}:${model}`, dims, embed: post };\n}\n\nconst providers = new Map<string, Promise<EmbedProvider>>();\n\nfunction getProvider(cfg: Config): Promise<EmbedProvider> {\n  const e = embedConfig(cfg);\n  if (!e) throw new SenseError('EMBED_DISABLED', 'this tree has no embedding model: add an \"embed\" block naming one to sense.config.json, then run `sense download`');\n  const sig = `${e.type}:${e.model}:${e.url ?? ''}`;\n  let p = providers.get(sig);\n  if (!p) {\n    p = e.type === 'api' ? apiProvider(e.model, e.url, e.key) : staticProvider(e.model);\n    providers.set(sig, p);\n  }\n  return p;\n}\n\n// Slice + re-normalize (Matryoshka); optionally round through int8 storage.\nfunction toStore(full: Float32Array, dims: number, int8: boolean): { v: Float32Array; scale: number } {\n  const v = new Float32Array(dims);\n  let norm = 0;\n  for (let d = 0; d < dims; d++) norm += full[d] * full[d];\n  norm = Math.sqrt(norm) + 1e-32;\n  for (let d = 0; d < dims; d++) v[d] = full[d] / norm;\n  if (!int8) return { v, scale: 1 };\n  let max = 0;\n  for (let d = 0; d < dims; d++) max = Math.max(max, Math.abs(v[d]));\n  return { v, scale: max / 127 || 1 };\n}\n\n// Embed rows whose vector is NULL, re-deriving chunk text from the files through the\n// same parse + chunker that stored the rows.\nexport async function embedPending(db: DatabaseSync, cfg: Config, baseDir: string): Promise<void> {\n  const provider = await getProvider(cfg); // throws EMBED_DISABLED before touching the table\n  const dirty = db.prepare('SELECT \"path\", chunk FROM embeddings WHERE vector IS NULL ORDER BY \"path\", chunk').all() as Array<{ path: string; chunk: number }>;\n  if (dirty.length === 0) return;\n  const storeDims = Math.min(STORE_DIMS, provider.dims);\n\n  const byPath = new Map<string, number[]>();\n  for (const row of dirty) {\n    const list = byPath.get(row.path) ?? [];\n    list.push(row.chunk);\n    byPath.set(row.path, list);\n  }\n\n  const jobs: Array<{ path: string; chunk: number; text: string }> = [];\n  for (const [path, chunkIdxs] of byPath) {\n    let chunks: Chunk[];\n    try {\n      // presets/embed are irrelevant here -- re-deriving chunk text for a doc that already\n      // has embeddings rows means the tree had an embedding model at reconcile time.\n      chunks = parseFile({ relPath: path, absPath: join(baseDir, path), mtimeMs: 0, ctimeMs: 0, size: 0, presets: [], embed: true }, [embed]).doc.extracted.embed as Chunk[];\n    } catch {\n      continue; // vanished since reconcile; the next reconcile removes its rows\n    }\n    for (const idx of chunkIdxs) if (chunks[idx]) jobs.push({ path, chunk: idx, text: chunks[idx].text });\n  }\n\n  const update = db.prepare('UPDATE embeddings SET scale = ?, vector = ? WHERE \"path\" = ? AND chunk = ?');\n  // The lazy build is the one long silence a first search hits (measured 23s at\n  // 26k notes); progress makes it distinguishable from a hang.\n  const report = progress('embedding chunks', jobs.length);\n  for (let i = 0; i < jobs.length; i += BATCH) {\n    const batch = jobs.slice(i, i + BATCH);\n    const vectors = await provider.embed(batch.map((j) => j.text));\n    db.exec('BEGIN');\n    try {\n      batch.forEach((job, j) => {\n        const { v, scale } = toStore(vectors[j], storeDims, true);\n        const q = new Int8Array(storeDims);\n        for (let d = 0; d < storeDims; d++) q[d] = Math.round(v[d] / scale);\n        update.run(scale, Buffer.from(q.buffer), job.path, job.chunk);\n      });\n      db.exec('COMMIT');\n    } catch (err) {\n      db.exec('ROLLBACK');\n      throw err;\n    }\n    report.tick(Math.min(i + BATCH, jobs.length));\n  }\n  report.finish();\n}\n\n// Dequantised int8 dot products land a little either side of a true cosine, so an identical\n// pair prints 1.001 and undermines a column whose whole job is being a bounded number.\nfunction asCosine(score: number): number {\n  return Math.round(Math.min(1, Math.max(-1, score)) * 1000) / 1000;\n}\n\n// Best chunk per file by cosine, its line range riding along; FTS5 operators are stripped as\n// lexical syntax. Similarity comes back because the fused score cannot express match quality,\n// and nearest-neighbour search always returns a neighbour however far away.\nexport async function semanticCandidates(db: DatabaseSync, cfg: Config, terms: string, fetch: number, allowed?: Set<string>): Promise<Array<{ path: string; lines: string; similarity: number }>> {\n  const baseDir = (cfg as Partial<ResolvedConfig>).baseDir;\n  if (!baseDir) throw new SenseError('EMBED_MODEL', 'semantic expansion needs a config with baseDir (use loadConfig/open)');\n  await embedPending(db, cfg, baseDir);\n\n  const provider = await getProvider(cfg);\n  const storeDims = Math.min(STORE_DIMS, provider.dims);\n  const text = (terms.match(/[\\p{L}\\p{N}]+/gu) ?? []).filter((t) => !['AND', 'OR', 'NOT', 'NEAR'].includes(t)).join(' ');\n  const { v: qv } = toStore((await provider.embed([text]))[0], storeDims, false);\n\n  const rows = db.prepare('SELECT \"path\", start_line, end_line, scale, vector FROM embeddings WHERE vector IS NOT NULL').all() as Array<{\n    path: string;\n    start_line: number;\n    end_line: number;\n    scale: number;\n    vector: Uint8Array;\n  }>;\n\n  const best = new Map<string, { score: number; lines: string }>();\n  for (const row of rows) {\n    if (allowed && !allowed.has(row.path)) continue;\n    const q = new Int8Array(row.vector.buffer, row.vector.byteOffset, Math.min(storeDims, row.vector.byteLength));\n    let dot = 0;\n    for (let d = 0; d < q.length; d++) dot += q[d] * qv[d];\n    const score = dot * row.scale;\n    const existing = best.get(row.path);\n    if (!existing || score > existing.score) best.set(row.path, { score, lines: `L${row.start_line}-${row.end_line}` });\n  }\n  return [...best.entries()]\n    .sort((a, b) => b[1].score - a[1].score)\n    .slice(0, fetch)\n    .map(([path, b]) => ({ path, lines: b.lines, similarity: asCosine(b.score) }));\n}\n\n// Whether a note has any chunk with a vector. Distinguishes \"nothing is near this note\" from\n// \"this note has no text\", which look the same in an empty result.\nexport function hasEmbedding(db: DatabaseSync, path: string): boolean {\n  const row = db.prepare('SELECT 1 AS ok FROM embeddings WHERE \"path\" = ? AND vector IS NOT NULL LIMIT 1').get(path) as { ok: number } | undefined;\n  return row !== undefined;\n}\n\n// Note-to-note similarity is the max cosine over (target chunk, other chunk) pairs, one linear\n// scan of stored vectors. Reads only what is stored, so it stays sync.\nexport function similarNotes(db: DatabaseSync, _cfg: Config, path: string, opts: { exclude: Set<string>; allowed?: Set<string>; k: number }): Array<{ path: string; similarity: number }> {\n  // Cost is target_chunks x stored_chunks, so a heading-dense seed multiplies a full-corpus\n  // scan (12.7s at 201 chunks/note). Sample evenly, so late sections still get a vote.\n  const targetRows = db.prepare('SELECT scale, vector FROM embeddings WHERE \"path\" = ? AND vector IS NOT NULL ORDER BY chunk').all(path) as Array<{ scale: number; vector: Uint8Array }>;\n  if (targetRows.length === 0) return [];\n  const step = Math.max(1, Math.ceil(targetRows.length / TARGET_CHUNK_CAP));\n  const target = targetRows.filter((_, i) => i % step === 0).map((row) => ({ v: new Int8Array(row.vector.buffer, row.vector.byteOffset, row.vector.byteLength), scale: row.scale }));\n\n  const rows = db.prepare('SELECT \"path\", scale, vector FROM embeddings WHERE vector IS NOT NULL').all() as Array<{ path: string; scale: number; vector: Uint8Array }>;\n  const best = new Map<string, number>();\n  for (const row of rows) {\n    if (row.path === path || opts.exclude.has(row.path) || (opts.allowed && !opts.allowed.has(row.path))) continue;\n    const other = new Int8Array(row.vector.buffer, row.vector.byteOffset, row.vector.byteLength);\n    for (const t of target) {\n      let dot = 0;\n      const len = Math.min(t.v.length, other.length);\n      for (let d = 0; d < len; d++) dot += t.v[d] * other[d];\n      const score = dot * t.scale * row.scale;\n      const existing = best.get(row.path);\n      if (existing === undefined || score > existing) best.set(row.path, score);\n    }\n  }\n\n  return [...best.entries()]\n    .sort((a, b) => b[1] - a[1])\n    .slice(0, opts.k)\n    .map(([p, score]) => ({ path: p, similarity: asCosine(score) }));\n}\n"],"names":["MODEL_FILENAMES","downloadModel","embed","embedPending","hasEmbedding","hasModelFiles","isDownloadable","modelDir","modelPresent","semanticCandidates","similarNotes","STORE_DIMS","TARGET_CHUNK_CAP","BATCH","chunksOf","body","search","offset","lines","split","starts","fence","fenceTracker","i","length","feed","inFence","test","push","bounds","prefix","title","summary","filter","Boolean","join","chunks","forEach","start","end","text","slice","trim","startLine","endLine","name","schema","db","exec","extract","raw","remove","path","prepare","run","store","extracted","insert","c","idx","enabledForFile","_cfg","file","MODEL_FILES","HF_MODEL_ID","model","cacheRoot","xdg","process","env","XDG_CACHE_HOME","homedir","replace","dir","every","existsSync","cfg","e","embedConfig","type","fetchToFile","url","dest","fetch","then","res","ok","SenseError","status","Buffer","from","arrayBuffer","writeFileSync","renameSync","onFile","mkdirSync","recursive","staticProvider","tokenizerJson","fix","headerLen","header","entry","spec","dims","dataStart","matrix","Tokenizer","tok","unkId","one","ids","encode","add_special_tokens","id","Number","isInteger","v","Float32Array","off","d","norm","Math","sqrt","readFileSync","readBigUInt64LE","JSON","parse","subarray","toString","Object","entries","find","k","dtype","shape","byteOffset","data_offsets","buffer","vocab","unk_token","texts","map","apiProvider","keyEnv","base","headers","key","post","method","stringify","input","json","data","embedding","undefined","authorization","providers","Map","getProvider","sig","p","get","set","toStore","full","int8","scale","max","abs","baseDir","provider","dirty","storeDims","byPath","row","list","jobs","chunkIdxs","update","report","batch","vectors","j","job","q","Int8Array","round","chunk","err","tick","min","all","parseFile","relPath","absPath","mtimeMs","ctimeMs","size","presets","doc","progress","finish","asCosine","score","terms","allowed","qv","rows","best","dot","existing","match","t","includes","has","vector","byteLength","start_line","end_line","sort","a","b","similarity","opts","targetRows","step","ceil","target","_","exclude","other","len"],"mappings":";;;;;;;;;;;QAgGaA;eAAAA;;QAmDSC;eAAAA;;QAjFTC;eAAAA;;QAmMSC;eAAAA;;QAgGNC;eAAAA;;QAzOAC;eAAAA;;QArBAC;eAAAA;;QAeAC;eAAAA;;QAaAC;eAAAA;;QA8LMC;eAAAA;;QA2CNC;eAAAA;;;sBA5W+D;sBACvD;wBACH;uBAGO;wBACD;wBACE;0BACJ;sBACC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAG1B,8FAA8F;AAC9F,gGAAgG;AAEhG,6EAA6E;AAC7E,yEAAyE;AACzE,IAAMC,aAAa;AACnB,0FAA0F;AAC1F,IAAMC,mBAAmB;AACzB,IAAMC,QAAQ;AAcd,8FAA8F;AAC9F,+FAA+F;AAC/F,EAAE;AACF,2FAA2F;AAC3F,+FAA+F;AAC/F,8FAA8F;AAC9F,8FAA8F;AAC9F,oDAAoD;AACpD,SAASC,SAASC,IAAY,EAAEC,MAA2C;QAAEC,SAAAA,iEAAS;IACpF,IAAMC,QAAQH,KAAKI,KAAK,CAAC;IACzB,IAAMC,SAAmB,EAAE;IAC3B,IAAMC,QAAQC,IAAAA,sBAAY;IAC1B,IAAK,IAAIC,IAAI,GAAGA,IAAIL,MAAMM,MAAM,EAAED,IAAK;QACrC,IAAIF,MAAMI,IAAI,CAACP,KAAK,CAACK,EAAE,GAAG;QAC1B,IAAI,CAACF,MAAMK,OAAO,IAAI,YAAYC,IAAI,CAACT,KAAK,CAACK,EAAE,GAAGH,OAAOQ,IAAI,CAACL,IAAI;IACpE;IACA,IAAMM,SAAST,OAAOI,MAAM,KAAK,IAAI;QAAC;KAAE,GAAGJ,MAAM,CAAC,EAAE,GAAG,IAAI;QAAC;KAAa,CAAd,OAAI,qBAAGA,WAAUA;IAC5E,IAAMU,SAAS;QAACd,mBAAAA,6BAAAA,OAAQe,KAAK;QAAEf,mBAAAA,6BAAAA,OAAQgB,OAAO;KAAC,CAACC,MAAM,CAACC,SAASC,IAAI,CAAC;IACrE,IAAMC,SAAkB,EAAE;IAC1BP,OAAOQ,OAAO,CAAC,SAACC,OAAOf;QACrB,IAAMgB,MAAMhB,IAAI,IAAIM,OAAOL,MAAM,GAAGK,MAAM,CAACN,IAAI,EAAE,GAAG,IAAIL,MAAMM,MAAM;QACpE,IAAMgB,OAAOtB,MACVuB,KAAK,CAACH,QAAQ,GAAGC,KACjBJ,IAAI,CAAC,MACLO,IAAI;QACP,uFAAuF;QACvF,gDAAgD;QAChD,IAAIF,KAAKhB,MAAM,GAAG,GAAGY,OAAOR,IAAI,CAAC;YAAEe,WAAWL,QAAQrB;YAAQ2B,SAASL,MAAMtB;YAAQuB,MAAMV,SAAS,AAAC,GAAaU,OAAXV,QAAO,MAAS,OAALU,QAASA;QAAK;IAClI;IACA,OAAOJ;AACT;AAEO,IAAMlC,QAAiB;IAC5B2C,MAAM;IACNC,QAAAA,SAAAA,OAAOC,EAAE;QACPA,GAAGC,IAAI,CAAC;IACV;IACAC,SAAAA,SAAAA,QAAQC,GAAG,EAAEnC,IAAI,EAAEC,MAAM;QACvB,mFAAmF;QACnF,OAAOF,SAASC,MAAMC,QAAQkC,IAAI/B,KAAK,CAAC,MAAMK,MAAM,GAAGT,KAAKI,KAAK,CAAC,MAAMK,MAAM;IAChF;IACA2B,QAAAA,SAAAA,OAAOJ,EAAE,EAAEK,IAAI;QACbL,GAAGM,OAAO,CAAC,2CAA2CC,GAAG,CAACF;IAC5D;IACA,uFAAuF;IACvF,mFAAmF;IACnFG,OAAAA,SAAAA,MAAMR,EAAE,EAAEK,IAAI,EAAEI,SAAS;QACvB,IAAI,CAACA,WAAW;QAChB,IAAMC,SAASV,GAAGM,OAAO,CAAC;QACzBG,UAAsBnB,OAAO,CAAC,SAACqB,GAAGC;mBAAQF,OAAOH,GAAG,CAACF,MAAMO,KAAKD,EAAEf,SAAS,EAAEe,EAAEd,OAAO;;IACzF;IACAgB,gBAAAA,SAAAA,eAAeC,IAAI,EAAEC,IAAI;QACvB,OAAOA,KAAK5D,KAAK;IACnB;AACF;AAEA,2FAA2F;AAC3F,yFAAyF;AACzF,gBAAgB;AAEhB,IAAM6D,cAAc;IAAC;IAAqB;CAAiB;AAEpD,IAAM/D,kBAAkB+D,YAAY5B,IAAI,CAAC;AAEhD,+FAA+F;AAC/F,wDAAwD;AACxD,IAAM6B,cAAc;AAGb,SAAS1D,eAAe2D,KAAa;IAC1C,OAAOD,YAAYrC,IAAI,CAACsC;AAC1B;AAEA,2FAA2F;AAC3F,uFAAuF;AACvF,oFAAoF;AACpF,SAASC;IACP,IAAMC,MAAMC,QAAQC,GAAG,CAACC,cAAc;IACtC,OAAOnC,IAAAA,cAAI,EAACgC,OAAOA,IAAI3C,MAAM,GAAG,IAAI2C,MAAMhC,IAAAA,cAAI,EAACoC,IAAAA,eAAO,KAAI,WAAW,eAAe;AACtF;AAKO,SAAShE,SAAS0D,KAAa;IACpC,IAAI,CAACD,YAAYrC,IAAI,CAACsC,QAAQ,OAAOA;IACrC,OAAO9B,IAAAA,cAAI,EAAC+B,aAAaD,MAAMO,OAAO,CAAC,OAAO;AAChD;AAGO,SAASnE,cAAc4D,KAAa;IACzC,IAAMQ,MAAMlE,SAAS0D;IACrB,OAAOF,YAAYW,KAAK,CAAC,SAACZ;eAASa,IAAAA,kBAAU,EAACxC,IAAAA,cAAI,EAACsC,KAAKX;;AAC1D;AAIO,SAAStD,aAAaoE,GAAW;IACtC,IAAMC,IAAIC,IAAAA,oBAAW,EAACF;IACtB,IAAI,CAACC,GAAG,OAAO;IACf,OAAOA,EAAEE,IAAI,KAAK,SAAS1E,cAAcwE,EAAEZ,KAAK;AAClD;AAEA,SAASe,YAAYC,GAAW,EAAEC,IAAY;IAC5C,OAAOC,MAAMF,KAAKG,IAAI,CAAC,SAAOC;;;;;;wBAC5B,IAAI,CAACA,IAAIC,EAAE,EAAE,MAAM,IAAIC,oBAAU,CAAC,eAAe,AAAC,0BAAwCF,OAAfJ,KAAI,aAAsB,OAAXI,IAAIG,MAAM;;4BACrF,GAAO,OAALN,MAAK;;4BAAQO,OAAOC,IAAI;wBAAC;;4BAAML,IAAIM,WAAW;;;wBAA/DC,qBAAa;4BAAiBH,QAAAA;gCAAY;;;wBAC1CI,IAAAA,kBAAU,EAAC,AAAC,GAAO,OAALX,MAAK,UAAQA;;;;;;QAC7B;;AACF;AAIO,SAAejF,cAAcgE,KAAa,EAAE6B,MAA4C;;YAIvFrB,KAED,2BAAA,mBAAA,gBAAA,WAAA,OAAMX;;;;oBALX,IAAI,CAACxD,eAAe2D,QAAQ;wBAC1B,MAAM,IAAIsB,oBAAU,CAAC,eAAe,AAAC,gBAAqB,OAANtB,OAAM;oBAC5D;oBACMQ,MAAMlE,SAAS0D;oBACrB8B,IAAAA,iBAAS,EAACtB,KAAK;wBAAEuB,WAAW;oBAAK;oBAC5B,kCAAA,2BAAA;;;;;;;;;oBAAA,YAAcjC;;;2BAAd,6BAAA,QAAA;;;;oBAAMD,OAAN;oBACH,IAAIa,IAAAA,kBAAU,EAACxC,IAAAA,cAAI,EAACsC,KAAKX,QAAQ;;;;oBACjCgC,mBAAAA,6BAAAA,OAAShC,MAAMW;oBACf;;wBAAMO,YAAY,AAAC,0BAA+ClB,OAAtBG,OAAM,kBAAqB,OAALH,OAAQ3B,IAAAA,cAAI,EAACsC,KAAKX;;;oBAApF;;;oBAHG;;;;;;;;;;;;oBAAA;oBAAA;;;;;;;6BAAA,6BAAA;4BAAA;;;4BAAA;kCAAA;;;;;;;oBAKL;;wBAAOW;;;;IACT;;AAEA,SAAewB,eAAehC,KAAa;;kBAyBEiC,sBAA7BA,4BAAAA,uBAxBRzB,KACD,2BAAA,mBAAA,gBAAA,WAAA,OAAMX,MAIDqC,KAKJjD,KACAkD,WACAC,QACAC,OAEAC,MACAC,MACAC,WACAC,QAEAR,eAEES,WACFC,KACAC;QAEN,SAASC,IAAItE,IAAY;YACvB,mFAAmF;YACnF,uFAAuF;YACvF,yFAAyF;YACzF,IAAMuE,MAAM,AAACH,IAAII,MAAM,CAACxE,MAAM;gBAAEyE,oBAAoB;YAAM,GAAGF,GAAG,CAAc9E,MAAM,CAAC,SAACiF;uBAAOC,OAAOC,SAAS,CAACF,OAAOA,OAAOL;;YAC5H,IAAMQ,IAAI,IAAIC,aAAad;YAC3B,IAAIO,IAAIvF,MAAM,KAAK,GAAG,OAAO6F;gBACxB,kCAAA,2BAAA;;gBAAL,QAAK,YAAYN,wBAAZ,SAAA,6BAAA,QAAA,yBAAA,iCAAiB;oBAAjB,IAAMG,KAAN;oBACH,IAAMK,MAAML,KAAKV;oBACjB,IAAK,IAAIgB,IAAI,GAAGA,IAAIhB,MAAMgB,IAAKH,CAAC,CAACG,EAAE,IAAId,MAAM,CAACa,MAAMC,EAAE;gBACxD;;gBAHK;gBAAA;;;yBAAA,6BAAA;wBAAA;;;wBAAA;8BAAA;;;;YAIL,IAAIC,OAAO;YACX,IAAK,IAAID,KAAI,GAAGA,KAAIhB,MAAMgB,KAAK;gBAC7BH,CAAC,CAACG,GAAE,IAAIT,IAAIvF,MAAM;gBAClBiG,QAAQJ,CAAC,CAACG,GAAE,GAAGH,CAAC,CAACG,GAAE;YACrB;YACAC,OAAOC,KAAKC,IAAI,CAACF,QAAQ;YACzB,IAAK,IAAID,KAAI,GAAGA,KAAIhB,MAAMgB,KAAKH,CAAC,CAACG,GAAE,IAAIC;YACvC,OAAOJ;QACT;;;;oBA7CM5C,MAAMlE,SAAS0D;oBAChB,kCAAA,2BAAA;;wBAAL,IAAK,YAAcF,kCAAd,6BAAA,QAAA,yBAAA,iCAA2B;4BAArBD,OAAN;4BACH,IAAI,CAACa,IAAAA,kBAAU,EAACxC,IAAAA,cAAI,EAACsC,KAAKX,QAAQ;gCAChC,uFAAuF;gCACvF,2BAA2B;gCACrBqC,MAAM7F,eAAe2D,SAAS,yBAAyB,AAAC,YAA2B,OAAhBjE,iBAAgB;gCACzF,MAAM,IAAIuF,oBAAU,CAAC,uBAAuB,AAAC,eAAmDd,OAArCR,OAAM,iCAAwCkC,OAAT1B,KAAI,OAAS,OAAJ0B;4BAC3G;wBACF;;wBAPK;wBAAA;;;iCAAA,6BAAA;gCAAA;;;gCAAA;sCAAA;;;;oBASCjD,MAAM0E,IAAAA,oBAAY,EAACzF,IAAAA,cAAI,EAACsC,KAAK;oBAC7B2B,YAAYe,OAAOjE,IAAI2E,eAAe,CAAC;oBACvCxB,SAASyB,KAAKC,KAAK,CAAC7E,IAAI8E,QAAQ,CAAC,GAAG,IAAI5B,WAAW6B,QAAQ,CAAC;oBAC5D3B,QAAQ4B,OAAOC,OAAO,CAAC9B,QAAQ+B,IAAI,CAAC;iEAAEC;+BAAOA,MAAM;;oBACzD,IAAI,CAAC/B,SAASA,KAAK,CAAC,EAAE,CAACgC,KAAK,KAAK,OAAO,MAAM,IAAI/C,oBAAU,CAAC,eAAe,AAAC,GAAQ,OAANtB,OAAM;oBAC/EsC,OAAOD,KAAK,CAAC,EAAE;oBACfE,OAAOD,KAAKgC,KAAK,CAAC,EAAE;oBACpB9B,YAAYvD,IAAIsF,UAAU,GAAG,IAAIpC,YAAYG,KAAKkC,YAAY,CAAC,EAAE;oBACjE/B,SAASD,YAAY,MAAM,IAAI,IAAIa,aAAapE,IAAIwF,MAAM,EAAEjC,WAAWF,KAAKgC,KAAK,CAAC,EAAE,GAAG/B,QAAQ,IAAIc,aAAapE,IAAIwF,MAAM,CAACjG,KAAK,CAACgE,WAAWA,YAAYF,KAAKgC,KAAK,CAAC,EAAE,GAAG/B,OAAO;oBAE/KN,gBAAgB4B,KAAKC,KAAK,CAACH,IAAAA,oBAAY,EAACzF,IAAAA,cAAI,EAACsC,KAAK,mBAAmB;oBAErD;;wBAAM;2EAAA,QAAO;;;;oBAA3BkC,YAAc,cAAdA;oBACFC,MAAM,IAAID,UAAUT,eAAe,CAAC;oBACpCW,iBAAQX,wBAAAA,cAAcjC,KAAK,cAAnBiC,6CAAAA,6BAAAA,sBAAqByC,KAAK,cAA1BzC,iDAAAA,0BAA4B,EAACA,uBAAAA,cAAcjC,KAAK,cAAnBiC,2CAAAA,qBAAqB0C,SAAS,CAAC,uCAAI,CAAC;oBAuB/E;;wBAAO;4BAAE1B,IAAI,AAAC,UAAe,OAANjD;4BAASuC,MAAAA;4BAAMtG,OAAO,SAAPA,MAAc2I;;;;;4CAAUA,MAAMC,GAAG,CAAChC;;;;;wBAAK;;;;IAC/E;;AAEA,gFAAgF;AAEhF,SAAeiC,YAAY9E,KAAa,EAAEgB,GAAuB,EAAE+D,MAA0B;;YAErFC,MACAC,SACAC,KAUA3C;QAPN,SAAe4C,KAAKP,KAAe;;oBAC3BxD,KAEAtE;;;;4BAFM;;gCAAMoE,MAAM,AAAC,GAAO,OAAL8D,MAAK,gBAAc;oCAAEI,QAAQ;oCAAQH,SAAAA;oCAASnI,MAAM+G,KAAKwB,SAAS,CAAC;wCAAErF,OAAAA;wCAAOsF,OAAOV;oCAAM;gCAAG;;;4BAAjHxD,MAAM;4BACZ,IAAI,CAACA,IAAIC,EAAE,EAAE,MAAM,IAAIC,oBAAU,CAAC,eAAe,AAAC,GAA6BF,OAA3B4D,MAAK,wBAAiC,OAAX5D,IAAIG,MAAM;4BAC3E;;gCAAMH,IAAImE,IAAI;;;4BAAtBzI,OAAQ;4BACd;;gCAAOA,KAAK0I,IAAI,CAACX,GAAG,CAAC,SAACtB;2CAAMF,aAAa5B,IAAI,CAAC8B,EAAEkC,SAAS;;;;;YAC3D;;;;;oBAXA,IAAI,CAACzE,KAAK,MAAM,IAAIM,oBAAU,CAAC,eAAe;oBACxC0D,OAAOhE,IAAIT,OAAO,CAAC,QAAQ;oBAC3B0E,UAAkC;wBAAE,gBAAgB;oBAAmB;oBACvEC,MAAMH,SAAS5E,QAAQC,GAAG,CAAC2E,OAAO,GAAGW;oBAC3C,IAAIR,KAAKD,QAAQU,aAAa,GAAG,AAAC,UAAa,OAAJT;oBAS7B;;wBAAMC;4BAAM;;;;oBAApB5C,OAAO,AAAC,aAAgC,CAAC,EAAE,CAAChF,MAAM;oBACxD;;wBAAO;4BAAE0F,IAAI,AAAC,OAAcjD,OAARgF,MAAK,KAAS,OAANhF;4BAASuC,MAAAA;4BAAMtG,OAAOkJ;wBAAK;;;;IACzD;;AAEA,IAAMS,YAAY,IAAIC;AAEtB,SAASC,YAAYnF,GAAW;QAGMC;IAFpC,IAAMA,IAAIC,IAAAA,oBAAW,EAACF;IACtB,IAAI,CAACC,GAAG,MAAM,IAAIU,oBAAU,CAAC,kBAAkB;IAC/C,IAAMyE,MAAM,AA7Od,AA6Oe,GAAYnF,OAAVA,EAAEE,IAAI,EAAC,YAAGF,EAAEZ,KAAK,EAAC,KAAe,QAAZY,SAAAA,EAAEI,GAAG,cAALJ,oBAAAA,SAAS;IAC7C,IAAIoF,IAAIJ,UAAUK,GAAG,CAACF;IACtB,IAAI,CAACC,GAAG;QACNA,IAAIpF,EAAEE,IAAI,KAAK,QAAQgE,YAAYlE,EAAEZ,KAAK,EAAEY,EAAEI,GAAG,EAAEJ,EAAEsE,GAAG,IAAIlD,eAAepB,EAAEZ,KAAK;QAClF4F,UAAUM,GAAG,CAACH,KAAKC;IACrB;IACA,OAAOA;AACT;AAEA,4EAA4E;AAC5E,SAASG,QAAQC,IAAkB,EAAE7D,IAAY,EAAE8D,IAAa;IAC9D,IAAMjD,IAAI,IAAIC,aAAad;IAC3B,IAAIiB,OAAO;IACX,IAAK,IAAID,IAAI,GAAGA,IAAIhB,MAAMgB,IAAKC,QAAQ4C,IAAI,CAAC7C,EAAE,GAAG6C,IAAI,CAAC7C,EAAE;IACxDC,OAAOC,KAAKC,IAAI,CAACF,QAAQ;IACzB,IAAK,IAAID,KAAI,GAAGA,KAAIhB,MAAMgB,KAAKH,CAAC,CAACG,GAAE,GAAG6C,IAAI,CAAC7C,GAAE,GAAGC;IAChD,IAAI,CAAC6C,MAAM,OAAO;QAAEjD,GAAAA;QAAGkD,OAAO;IAAE;IAChC,IAAIC,MAAM;IACV,IAAK,IAAIhD,KAAI,GAAGA,KAAIhB,MAAMgB,KAAKgD,MAAM9C,KAAK8C,GAAG,CAACA,KAAK9C,KAAK+C,GAAG,CAACpD,CAAC,CAACG,GAAE;IAChE,OAAO;QAAEH,GAAAA;QAAGkD,OAAOC,MAAM,OAAO;IAAE;AACpC;AAIO,SAAerK,aAAa4C,EAAgB,EAAE6B,GAAW,EAAE8F,OAAe;;mBACzEC,UACAC,OAEAC,WAEAC,QACD,2BAAA,mBAAA,gBAAA,WAAA,OAAMC,KACID,aAAPE,MAKFC,MACD,4BAAA,oBAAA,iBAAA,YAAA,qBAAO7H,MAAM8H,WACZ9I,QAQC,4BAAA,oBAAA,iBAAA,YAAA,QAAMuB,KAGPwH,QAGAC,QACG7J;;;;;4BACD8J,OACAC;;;;oCADAD,QAAQJ,KAAKxI,KAAK,CAAClB,GAAGA,IAAIV;oCAChB;;wCAAM8J,SAASzK,KAAK,CAACmL,MAAMvC,GAAG,CAAC,SAACyC;mDAAMA,EAAE/I,IAAI;;;;oCAAtD8I,UAAU;oCAChBvI,GAAGC,IAAI,CAAC;oCACR,IAAI;wCACFqI,MAAMhJ,OAAO,CAAC,SAACmJ,KAAKD;4CAClB,IAAqBnB,WAAAA,QAAQkB,OAAO,CAACC,EAAE,EAAEV,WAAW,OAA5CxD,IAAa+C,SAAb/C,GAAGkD,QAAUH,SAAVG;4CACX,IAAMkB,IAAI,IAAIC,UAAUb;4CACxB,IAAK,IAAIrD,IAAI,GAAGA,IAAIqD,WAAWrD,IAAKiE,CAAC,CAACjE,EAAE,GAAGE,KAAKiE,KAAK,CAACtE,CAAC,CAACG,EAAE,GAAG+C;4CAC7DY,OAAO7H,GAAG,CAACiH,OAAO9E,OAAOC,IAAI,CAAC+F,EAAE/C,MAAM,GAAG8C,IAAIpI,IAAI,EAAEoI,IAAII,KAAK;wCAC9D;wCACA7I,GAAGC,IAAI,CAAC;oCACV,EAAE,OAAO6I,KAAK;wCACZ9I,GAAGC,IAAI,CAAC;wCACR,MAAM6I;oCACR;oCACAT,OAAOU,IAAI,CAACpE,KAAKqE,GAAG,CAACxK,IAAIV,OAAOoK,KAAKzJ,MAAM;;;;;;oBAC7C;oBA9CiB;;wBAAMuI,YAAYnF;;;oBAA7B+F,WAAW;oBACXC,QAAQ7H,GAAGM,OAAO,CAAC,oFAAoF2I,GAAG;oBAChH,IAAIpB,MAAMpJ,MAAM,KAAK,GAAG;;;oBAClBqJ,YAAYnD,KAAKqE,GAAG,CAACpL,YAAYgK,SAASnE,IAAI;oBAE9CsE,SAAS,IAAIhB;oBACd,kCAAA,2BAAA;;wBAAL,IAAK,YAAac,4BAAb,6BAAA,QAAA,yBAAA,iCAAoB;4BAAdG,MAAN;;4BACGC,QAAOF,cAAAA,OAAOZ,GAAG,CAACa,IAAI3H,IAAI,eAAnB0H,yBAAAA;4BACbE,KAAKpJ,IAAI,CAACmJ,IAAIa,KAAK;4BACnBd,OAAOX,GAAG,CAACY,IAAI3H,IAAI,EAAE4H;wBACvB;;wBAJK;wBAAA;;;iCAAA,6BAAA;gCAAA;;;gCAAA;sCAAA;;;;oBAMCC;oBACD,mCAAA,4BAAA;;wBAAL,IAAK,aAA2BH,6BAA3B,8BAAA,SAAA,0BAAA,kCAAmC;2DAAnC,kBAAO1H,uBAAM8H;4BACZ9I,SAAAA,KAAAA;4BACJ,IAAI;gCACF,qFAAqF;gCACrF,+EAA+E;gCAC/EA,SAAS6J,IAAAA,iBAAS,EAAC;oCAAEC,SAAS9I;oCAAM+I,SAAShK,IAAAA,cAAI,EAACuI,SAAStH;oCAAOgJ,SAAS;oCAAGC,SAAS;oCAAGC,MAAM;oCAAGC,OAAO;oCAAMrM,OAAO;gCAAK;oCAAIA;mCAAQsM,GAAG,CAAChJ,SAAS,CAACtD,KAAK;4BAC7J,EAAE,eAAM;gCACN,UAAU,gEAAgE;4BAC5E;4BACK,mCAAA,4BAAA;;gCAAL,IAAK,aAAagL,gCAAb,8BAAA,SAAA,0BAAA;oCAAMvH,MAAN;oCAAwB,IAAIvB,MAAM,CAACuB,IAAI,EAAEsH,KAAKrJ,IAAI,CAAC;wCAAEwB,MAAAA;wCAAMwI,OAAOjI;wCAAKnB,MAAMJ,MAAM,CAACuB,IAAI,CAACnB,IAAI;oCAAC;;;gCAA9F;gCAAA;;;yCAAA,8BAAA;wCAAA;;;wCAAA;8CAAA;;;;wBACP;;wBAVK;wBAAA;;;iCAAA,8BAAA;gCAAA;;;gCAAA;sCAAA;;;;oBAYC2I,SAASpI,GAAGM,OAAO,CAAC;oBAC1B,8EAA8E;oBAC9E,6DAA6D;oBACvD+H,SAASqB,IAAAA,oBAAQ,EAAC,oBAAoBxB,KAAKzJ,MAAM;oBAC9CD,IAAI;;;yBAAGA,CAAAA,IAAI0J,KAAKzJ,MAAM,AAAD;;;;;;;;;;;;oBAAGD,KAAKV;;;;;;oBAkBtCuK,OAAOsB,MAAM;;;;;;IACf;;AAEA,4FAA4F;AAC5F,uFAAuF;AACvF,SAASC,SAASC,KAAa;IAC7B,OAAOlF,KAAKiE,KAAK,CAACjE,KAAKqE,GAAG,CAAC,GAAGrE,KAAK8C,GAAG,CAAC,CAAC,GAAGoC,UAAU,QAAQ;AAC/D;AAKO,SAAenM,mBAAmBsC,EAAgB,EAAE6B,GAAW,EAAEiI,KAAa,EAAE1H,MAAa,EAAE2H,OAAqB;;YAO3GD,cANRnC,SAIAC,UACAE,WACArI,MACY4H,UAAP2C,IAELC,MAQAC,MACD,2BAAA,mBAAA,gBAAA,WAAA,OAAMlC,KAEHU,GACFyB,KACK1F,GACHoF,OACAO;;;;oBAxBFzC,UAAU,AAAC9F,IAAgC8F,OAAO;oBACxD,IAAI,CAACA,SAAS,MAAM,IAAInF,oBAAU,CAAC,eAAe;oBAClD;;wBAAMpF,aAAa4C,IAAI6B,KAAK8F;;;oBAA5B;oBAEiB;;wBAAMX,YAAYnF;;;oBAA7B+F,WAAW;oBACXE,YAAYnD,KAAKqE,GAAG,CAACpL,YAAYgK,SAASnE,IAAI;oBAC9ChE,OAAO,EAACqK,eAAAA,MAAMO,KAAK,CAAC,2naAAZP,0BAAAA,mBAAsC5K,MAAM,CAAC,SAACoL;+BAAM,CAAC;4BAAC;4BAAO;4BAAM;4BAAO;yBAAO,CAACC,QAAQ,CAACD;uBAAIlL,IAAI,CAAC;oBACvF;;wBAAMwI,SAASzK,KAAK;4BAAEsC;;;;oBAA/B4H,WAAAA;wBAAS,aAA6B,CAAC,EAAE;wBAAES;wBAAW;wBAA7DkC,KAAO3C,SAAV/C;oBAEF2F,OAAOjK,GAAGM,OAAO,CAAC,+FAA+F2I,GAAG;oBAQpHiB,OAAO,IAAInD;oBACZ,kCAAA,2BAAA;;wBAAL,IAAK,YAAakD,2BAAb,6BAAA,QAAA,yBAAA,iCAAmB;4BAAbjC,MAAN;4BACH,IAAI+B,WAAW,CAACA,QAAQS,GAAG,CAACxC,IAAI3H,IAAI,GAAG;4BACjCqI,IAAI,IAAIC,UAAUX,IAAIyC,MAAM,CAAC9E,MAAM,EAAEqC,IAAIyC,MAAM,CAAChF,UAAU,EAAEd,KAAKqE,GAAG,CAAClB,WAAWE,IAAIyC,MAAM,CAACC,UAAU;4BACvGP,MAAM;4BACV,IAAS1F,IAAI,GAAGA,IAAIiE,EAAEjK,MAAM,EAAEgG,IAAK0F,OAAOzB,CAAC,CAACjE,EAAE,GAAGuF,EAAE,CAACvF,EAAE;4BAChDoF,QAAQM,MAAMnC,IAAIR,KAAK;4BACvB4C,WAAWF,KAAK/C,GAAG,CAACa,IAAI3H,IAAI;4BAClC,IAAI,CAAC+J,YAAYP,QAAQO,SAASP,KAAK,EAAEK,KAAK9C,GAAG,CAACY,IAAI3H,IAAI,EAAE;gCAAEwJ,OAAAA;gCAAO1L,OAAO,AAAC,IAAqB6J,OAAlBA,IAAI2C,UAAU,EAAC,KAAgB,OAAb3C,IAAI4C,QAAQ;4BAAG;wBACnH;;wBARK;wBAAA;;;iCAAA,6BAAA;gCAAA;;;gCAAA;sCAAA;;;;oBASL;;wBAAQ,qBAAGV,KAAK9E,OAAO,IACpByF,IAAI,CAAC,SAACC,GAAGC;mCAAMA,CAAC,CAAC,EAAE,CAAClB,KAAK,GAAGiB,CAAC,CAAC,EAAE,CAACjB,KAAK;2BACtCnK,KAAK,CAAC,GAAG0C,QACT2D,GAAG,CAAC;qEAAE1F,kBAAM0K;mCAAQ;gCAAE1K,MAAAA;gCAAMlC,OAAO4M,EAAE5M,KAAK;gCAAE6M,YAAYpB,SAASmB,EAAElB,KAAK;4BAAE;;;;;IAC/E;;AAIO,SAASxM,aAAa2C,EAAgB,EAAEK,IAAY;IACzD,IAAM2H,MAAMhI,GAAGM,OAAO,CAAC,kFAAkF6G,GAAG,CAAC9G;IAC7G,OAAO2H,QAAQpB;AACjB;AAIO,SAASjJ,aAAaqC,EAAgB,EAAEc,IAAY,EAAET,IAAY,EAAE4K,IAAgE;IACzI,0FAA0F;IAC1F,qFAAqF;IACrF,IAAMC,aAAalL,GAAGM,OAAO,CAAC,+FAA+F2I,GAAG,CAAC5I;IACjI,IAAI6K,WAAWzM,MAAM,KAAK,GAAG,OAAO,EAAE;IACtC,IAAM0M,OAAOxG,KAAK8C,GAAG,CAAC,GAAG9C,KAAKyG,IAAI,CAACF,WAAWzM,MAAM,GAAGZ;IACvD,IAAMwN,SAASH,WAAWhM,MAAM,CAAC,SAACoM,GAAG9M;eAAMA,IAAI2M,SAAS;OAAGpF,GAAG,CAAC,SAACiC;eAAS;YAAE1D,GAAG,IAAIqE,UAAUX,IAAIyC,MAAM,CAAC9E,MAAM,EAAEqC,IAAIyC,MAAM,CAAChF,UAAU,EAAEuC,IAAIyC,MAAM,CAACC,UAAU;YAAGlD,OAAOQ,IAAIR,KAAK;QAAC;;IAE/K,IAAMyC,OAAOjK,GAAGM,OAAO,CAAC,yEAAyE2I,GAAG;IACpG,IAAMiB,OAAO,IAAInD;QACZ,kCAAA,2BAAA;;QAAL,QAAK,YAAakD,yBAAb,SAAA,6BAAA,QAAA,yBAAA,iCAAmB;YAAnB,IAAMjC,MAAN;YACH,IAAIA,IAAI3H,IAAI,KAAKA,QAAQ4K,KAAKM,OAAO,CAACf,GAAG,CAACxC,IAAI3H,IAAI,KAAM4K,KAAKlB,OAAO,IAAI,CAACkB,KAAKlB,OAAO,CAACS,GAAG,CAACxC,IAAI3H,IAAI,GAAI;YACtG,IAAMmL,QAAQ,IAAI7C,UAAUX,IAAIyC,MAAM,CAAC9E,MAAM,EAAEqC,IAAIyC,MAAM,CAAChF,UAAU,EAAEuC,IAAIyC,MAAM,CAACC,UAAU;gBACtF,mCAAA,4BAAA;;gBAAL,QAAK,aAAWW,2BAAX,UAAA,8BAAA,SAAA,0BAAA,kCAAmB;oBAAnB,IAAMf,IAAN;oBACH,IAAIH,MAAM;oBACV,IAAMsB,MAAM9G,KAAKqE,GAAG,CAACsB,EAAEhG,CAAC,CAAC7F,MAAM,EAAE+M,MAAM/M,MAAM;oBAC7C,IAAK,IAAIgG,IAAI,GAAGA,IAAIgH,KAAKhH,IAAK0F,OAAOG,EAAEhG,CAAC,CAACG,EAAE,GAAG+G,KAAK,CAAC/G,EAAE;oBACtD,IAAMoF,QAAQM,MAAMG,EAAE9C,KAAK,GAAGQ,IAAIR,KAAK;oBACvC,IAAM4C,WAAWF,KAAK/C,GAAG,CAACa,IAAI3H,IAAI;oBAClC,IAAI+J,aAAaxD,aAAaiD,QAAQO,UAAUF,KAAK9C,GAAG,CAACY,IAAI3H,IAAI,EAAEwJ;gBACrE;;gBAPK;gBAAA;;;yBAAA,8BAAA;wBAAA;;;wBAAA;8BAAA;;;;QAQP;;QAXK;QAAA;;;iBAAA,6BAAA;gBAAA;;;gBAAA;sBAAA;;;;IAaL,OAAO,AAAC,qBAAGK,KAAK9E,OAAO,IACpByF,IAAI,CAAC,SAACC,GAAGC;eAAMA,CAAC,CAAC,EAAE,GAAGD,CAAC,CAAC,EAAE;OAC1BpL,KAAK,CAAC,GAAGuL,KAAK3F,CAAC,EACfS,GAAG,CAAC;iDAAEmB,eAAG2C;eAAY;YAAExJ,MAAM6G;YAAG8D,YAAYpB,SAASC;QAAO;;AACjE"}