sensemaking 0.24.7 → 0.25.0

package/dist/cjs/scan/pool.js.map

@@ -1 +1 @@
-{"version":3,"sources":["/Users/kevin/Dev/OpenSource/ai/sensemaking/src/scan/pool.ts"],"sourcesContent":["import { createRequire } from 'node:module';\n// Type-only: erased at build, but keeps depcheck's usage check satisfied for the tier-2\n// `_require` below (see coding-standards' deferral tiers).\nimport type * as TinypoolNS from 'tinypool';\nimport type { Config } from '../config/index.ts';\nimport type { Feature } from '../features/types.ts';\nimport { resolveWorkerFile } from '../lib/worker-file.ts';\nimport type { ParsedDoc } from '../scan/index.ts';\nimport type { ParseTask, ParseTaskResult, ParseWorkerData } from '../workers/parse.ts';\nimport type { FileStat } from './list.ts';\nimport { reviveError } from './worker-error.ts';\n\n// Tinypool is ESM-only; our floor (>=22.20) has native require(esm), so the tier-2 house deferral reaches it.\nconst _require = typeof require === 'undefined' ? createRequire(import.meta.url) : require;\n\n// parseMs is worker-side only (see workers/parse.ts); absent on the serial path.\nexport type FileResult = { doc: ParsedDoc; warnings: string[]; parseMs?: number };\n\n// One Tinypool per instance, created lazily on first dispatch and reused by every later call:\n// a builder owns one of these for its whole lifetime instead of paying pool startup per reconcile.\nexport class ParsePool {\n  private pool: TinypoolNS.Tinypool | undefined;\n  // Tinypools this instance has constructed. One dispatch or a hundred should leave it at 1;\n  // it is how a caller, and the specs, observe that a lifetime reuses its pool rather than churning one.\n  poolsCreated = 0;\n\n  private ensure(workerData: ParseWorkerData, maxWorkers: number): TinypoolNS.Tinypool {\n    if (!this.pool) {\n      const { Tinypool } = _require('tinypool') as typeof TinypoolNS;\n      this.pool = new Tinypool({ filename: resolveWorkerFile('parse'), minThreads: maxWorkers, maxThreads: maxWorkers, workerData });\n      this.poolsCreated++;\n    }\n    return this.pool;\n  }\n\n  // Never the tree: a worker task carries one FileStat and returns only what parseFile returns --\n  // extracted text and feature values, never the token tree.\n  async run(files: FileStat[], features: Feature[], cfg: Config, onParsed: ((done: number) => void) | undefined, maxWorkers: number): Promise<FileResult[]> {\n    // cfg and the feature selection are constant for the dispatch, so they cross once per worker\n    // as workerData. Features carry closures and cannot cross at all; only their names do.\n    const workerData: ParseWorkerData = { cfg, featureNames: features.map((feature) => feature.name) };\n    const pool = this.ensure(workerData, maxWorkers);\n    let done = 0;\n    // Promise.all over a mapped array is load-bearing: the resolved array keeps `files` order\n    // regardless of task completion order, which first-seen column order depends on downstream.\n    return Promise.all(\n      files.map(async (file): Promise<FileResult> => {\n        const result = (await pool.run(file as ParseTask)) as ParseTaskResult;\n        if (!result.ok) throw reviveError(result.error);\n        onParsed?.(++done);\n        return { doc: result.doc, warnings: result.warnings, parseMs: result.parseMs };\n      })\n    );\n  }\n\n  // A pool never created costs nothing to destroy.\n  async close(): Promise<void> {\n    if (!this.pool) return;\n    const pool = this.pool;\n    this.pool = undefined;\n    await pool.destroy();\n  }\n}\n"],"names":["ParsePool","_require","require","createRequire","poolsCreated","ensure","workerData","maxWorkers","pool","Tinypool","filename","resolveWorkerFile","minThreads","maxThreads","run","files","features","cfg","onParsed","done","featureNames","map","feature","name","Promise","all","file","result","ok","reviveError","error","doc","warnings","parseMs","close","undefined","destroy"],"mappings":";;;;+BAoBaA;;;eAAAA;;;0BApBiB;4BAMI;6BAIN;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAE5B,8GAA8G;AAC9G,IAAMC,WAAW,OAAOC,YAAY,cAAcC,IAAAA,yBAAa,EAAC,uDAAmBD;AAO5E,IAAA,AAAMF,0BAAN;;aAAMA;gCAAAA;QAEX,2FAA2F;QAC3F,uGAAuG;aACvGI,eAAe;;iBAJJJ;IAMX,OAAQK,MAOP,GAPD,SAAQA,OAAOC,UAA2B,EAAEC,UAAkB;QAC5D,IAAI,CAAC,IAAI,CAACC,IAAI,EAAE;YACd,IAAM,AAAEC,WAAaR,SAAS,YAAtBQ;YACR,IAAI,CAACD,IAAI,GAAG,IAAIC,SAAS;gBAAEC,UAAUC,IAAAA,+BAAiB,EAAC;gBAAUC,YAAYL;gBAAYM,YAAYN;gBAAYD,YAAAA;YAAW;YAC5H,IAAI,CAACF,YAAY;QACnB;QACA,OAAO,IAAI,CAACI,IAAI;IAClB;IAEA,gGAAgG;IAChG,2DAA2D;IAC3D,OAAMM,GAgBL,GAhBD,SAAMA,IAAIC,KAAiB,EAAEC,QAAmB,EAAEC,GAAW,EAAEC,QAA8C,EAAEX,UAAkB;;gBAGzHD,YACAE,MACFW;;gBAJJ,6FAA6F;gBAC7F,uFAAuF;gBACjFb,aAA8B;oBAAEW,KAAAA;oBAAKG,cAAcJ,SAASK,GAAG,CAAC,SAACC;+BAAYA,QAAQC,IAAI;;gBAAE;gBAC3Ff,OAAO,IAAI,CAACH,MAAM,CAACC,YAAYC;gBACjCY,OAAO;gBACX,0FAA0F;gBAC1F,4FAA4F;gBAC5F;;oBAAOK,QAAQC,GAAG,CAChBV,MAAMM,GAAG,CAAC,SAAOK;;gCACTC;;;;wCAAU;;4CAAMnB,KAAKM,GAAG,CAACY;;;wCAAzBC,SAAU;wCAChB,IAAI,CAACA,OAAOC,EAAE,EAAE,MAAMC,IAAAA,0BAAW,EAACF,OAAOG,KAAK;wCAC9CZ,qBAAAA,+BAAAA,SAAW,EAAEC;wCACb;;4CAAO;gDAAEY,KAAKJ,OAAOI,GAAG;gDAAEC,UAAUL,OAAOK,QAAQ;gDAAEC,SAASN,OAAOM,OAAO;4CAAC;;;;wBAC/E;;;;QAEJ;;IAEA,iDAAiD;IACjD,OAAMC,KAKL,GALD,SAAMA;;gBAEE1B;;;;wBADN,IAAI,CAAC,IAAI,CAACA,IAAI,EAAE;;;wBACVA,OAAO,IAAI,CAACA,IAAI;wBACtB,IAAI,CAACA,IAAI,GAAG2B;wBACZ;;4BAAM3B,KAAK4B,OAAO;;;wBAAlB;;;;;;QACF;;WAzCWpC"}
+{"version":3,"sources":["/Users/kevin/Dev/OpenSource/ai/sensemaking/src/scan/pool.ts"],"sourcesContent":["import { createRequire } from 'node:module';\nimport { isDeepStrictEqual } from 'node:util';\n// Type-only: erased at build, but keeps depcheck's usage check satisfied for the tier-2\n// `_require` below (see coding-standards' deferral tiers).\nimport type * as TinypoolNS from 'tinypool';\nimport type { Config } from '../config/index.ts';\nimport type { Feature } from '../features/types.ts';\nimport { resolveWorkerFile } from '../lib/worker-file.ts';\nimport type { ParsedDoc } from '../scan/index.ts';\nimport type { ParseTask, ParseTaskResult, ParseWorkerData } from '../workers/parse.ts';\nimport type { FileStat } from './list.ts';\nimport { reviveError } from './worker-error.ts';\n\n// Tinypool is ESM-only; our floor (>=22.20) has native require(esm), so the tier-2 house deferral reaches it.\nconst _require = typeof require === 'undefined' ? createRequire(import.meta.url) : require;\n\n// parseMs is worker-side only (see workers/parse.ts); absent on the serial path.\nexport type FileResult = { doc: ParsedDoc; warnings: string[]; parseMs?: number };\n\n// Created lazily and reused while dispatch context stays equivalent. A builder owns one instance\n// for its lifetime instead of paying pool startup for unchanged reconciles.\nexport class ParsePool {\n  private pool: TinypoolNS.Tinypool | undefined;\n  private workerData: ParseWorkerData | undefined;\n  private operation: Promise<void> = Promise.resolve();\n  // Tinypools this instance has constructed. Repeated equivalent dispatches leave this unchanged;\n  // a context change or close followed by run constructs another pool.\n  poolsCreated = 0;\n\n  private enqueue<T>(operation: () => Promise<T>): Promise<T> {\n    const result = this.operation.then(operation);\n    this.operation = result.then(\n      () => undefined,\n      () => undefined\n    );\n    return result;\n  }\n\n  private async ensure(workerData: ParseWorkerData, maxWorkers: number): Promise<TinypoolNS.Tinypool> {\n    if (this.pool && !isDeepStrictEqual(this.workerData, workerData)) await this.destroy();\n    if (!this.pool) {\n      const { Tinypool } = _require('tinypool') as typeof TinypoolNS;\n      this.pool = new Tinypool({ filename: resolveWorkerFile('parse'), minThreads: maxWorkers, maxThreads: maxWorkers, workerData });\n      this.workerData = workerData;\n      this.poolsCreated++;\n    }\n    return this.pool;\n  }\n\n  // Never the tree: a worker task carries one FileStat and returns only what parseFile returns --\n  // extracted text and feature values, never the token tree.\n  run(files: FileStat[], features: Feature[], cfg: Config, onParsed: ((done: number) => void) | undefined, maxWorkers: number): Promise<FileResult[]> {\n    // Snapshot at invocation so caller mutation cannot change queued work or its reuse baseline.\n    const workerData: ParseWorkerData = { cfg: structuredClone(cfg), featureNames: [...new Set(features.map((feature) => feature.name))].sort() };\n    return this.enqueue(() => this.dispatch(files, workerData, onParsed, maxWorkers));\n  }\n\n  private async dispatch(files: FileStat[], workerData: ParseWorkerData, onParsed: ((done: number) => void) | undefined, maxWorkers: number): Promise<FileResult[]> {\n    const pool = await this.ensure(workerData, maxWorkers);\n    let done = 0;\n    const settled = await Promise.allSettled(\n      files.map(async (file): Promise<FileResult> => {\n        const result = (await pool.run(file as ParseTask)) as ParseTaskResult;\n        if (!result.ok) throw reviveError(result.error);\n        onParsed?.(++done);\n        return { doc: result.doc, warnings: result.warnings, parseMs: result.parseMs };\n      })\n    );\n    const results: FileResult[] = [];\n    const failures: unknown[] = [];\n    for (const result of settled) {\n      if (result.status === 'fulfilled') results.push(result.value);\n      else failures.push(result.reason);\n    }\n    if (failures.length === 1) throw failures[0];\n    if (failures.length > 1) throw new AggregateError(failures, `${failures.length} parse tasks failed`);\n    // allSettled preserves input order, which downstream first-seen column order depends on.\n    return results;\n  }\n\n  private async destroy(): Promise<void> {\n    if (!this.pool) return;\n    const pool = this.pool;\n    this.pool = undefined;\n    this.workerData = undefined;\n    await pool.destroy();\n  }\n\n  // A pool never created costs nothing to destroy. Queuing lets active dispatches drain first.\n  close(): Promise<void> {\n    return this.enqueue(() => this.destroy());\n  }\n}\n"],"names":["ParsePool","_require","require","createRequire","operation","Promise","resolve","poolsCreated","enqueue","result","then","undefined","ensure","workerData","maxWorkers","Tinypool","pool","isDeepStrictEqual","destroy","filename","resolveWorkerFile","minThreads","maxThreads","run","files","features","cfg","onParsed","structuredClone","featureNames","Set","map","feature","name","sort","dispatch","done","settled","results","failures","allSettled","file","ok","reviveError","error","doc","warnings","parseMs","status","push","value","reason","length","AggregateError","close"],"mappings":"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"}

package/dist/cjs/store/builder.d.cts

@@ -1,4 +1,4 @@
-import type { Config } from '../config/index.js';
+import { type Config } from '../config/index.js';
 import type { EmbedChangeKind } from './embed-scope.js';
 import type { FeatureToggle } from './feature-scope.js';
 import { type ReconcilePaths } from './reconcile.js';
@@ -10,6 +10,11 @@ export interface Builder {
         warnings: string[];
         stages: Stages;
     }>;
+    recover(): Promise<{
+        parsed: number;
+        warnings: string[];
+        stages: Stages;
+    }>;
     invalidate(kind: EmbedChangeKind): Promise<{
         parsed: number;
     }>;

package/dist/cjs/store/builder.d.ts

@@ -1,4 +1,4 @@
-import type { Config } from '../config/index.js';
+import { type Config } from '../config/index.js';
 import type { EmbedChangeKind } from './embed-scope.js';
 import type { FeatureToggle } from './feature-scope.js';
 import { type ReconcilePaths } from './reconcile.js';
@@ -10,6 +10,11 @@ export interface Builder {
         warnings: string[];
         stages: Stages;
     }>;
+    recover(): Promise<{
+        parsed: number;
+        warnings: string[];
+        stages: Stages;
+    }>;
     invalidate(kind: EmbedChangeKind): Promise<{
         parsed: number;
     }>;

package/dist/cjs/store/builder.js

@@ -8,10 +8,11 @@ Object.defineProperty(exports, "createBuilder", {
         return createBuilder;
     }
 });
+var _indexts = require("../config/index.js");
 var _embedts = require("../features/embed.js");
-var _indexts = require("../features/index.js");
+var _indexts1 = require("../features/index.js");
 var _rankts = require("../features/rank.js");
-var _indexts1 = require("../scan/index.js");
+var _indexts2 = require("../scan/index.js");
 var _poolts = require("../scan/pool.js");
 var _reparsets = require("../scan/reparse.js");
 var _featurescopets = require("./feature-scope.js");
@@ -196,7 +197,7 @@ function rebuildEmbeddings(conn, cfg, baseDir, dialect, pool) {
                     ]));
                     // A file added since the last build has no row yet; leaving it for build() to insert avoids a
                     // primary-key collision between this INSERT and build()'s own insert for the same new file.
-                    files = (0, _indexts1.listFiles)(cfg, baseDir).filter(function(f) {
+                    files = (0, _indexts2.listFiles)(cfg, baseDir).filter(function(f) {
                         return f.embed && existingPaths.has(f.relPath);
                     });
                     if (files.length === 0) return [
@@ -280,7 +281,7 @@ function invalidateFeatureTable(conn, cfg, baseDir, dialect, pool, toggle) {
             switch(_state.label){
                 case 0:
                     table = _featurescopets.NARROW_FEATURE_TABLE[toggle.name];
-                    feature = _indexts.FEATURES.find(function(f) {
+                    feature = _indexts1.FEATURES.find(function(f) {
                         return f.name === toggle.name;
                     });
                     if (!feature) throw new Error('invalidateFeatureTable: no registered feature named "'.concat(toggle.name, '"'));
@@ -303,7 +304,7 @@ function invalidateFeatureTable(conn, cfg, baseDir, dialect, pool, toggle) {
                         }
                     ];
                 case 2:
-                    files = (0, _indexts1.listFiles)(cfg, baseDir);
+                    files = (0, _indexts2.listFiles)(cfg, baseDir);
                     return [
                         4,
                         (0, _reparsets.reparseFiles)(files, [
@@ -594,12 +595,141 @@ function invalidateFeatureToggles(conn, cfg, baseDir, dialect, pool, toggles) {
         });
     })();
 }
+function recoverIncomplete(conn, cfg, paths, dialect, pool) {
+    return _async_to_generator(function() {
+        var disabled, _iteratorNormalCompletion, _didIteratorError, _iteratorError, _iterator, _step, feature, err, toggles, embeddingsTable, forcedPaths;
+        return _ts_generator(this, function(_state) {
+            switch(_state.label){
+                case 0:
+                    disabled = _indexts1.FEATURES.filter(function(feature) {
+                        return !(0, _indexts.featureEnabled)(cfg, feature.name);
+                    });
+                    _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+                    _state.label = 1;
+                case 1:
+                    _state.trys.push([
+                        1,
+                        6,
+                        7,
+                        8
+                    ]);
+                    _iterator = disabled[Symbol.iterator]();
+                    _state.label = 2;
+                case 2:
+                    if (!!(_iteratorNormalCompletion = (_step = _iterator.next()).done)) return [
+                        3,
+                        5
+                    ];
+                    feature = _step.value;
+                    if (!(feature.name !== 'embed')) return [
+                        3,
+                        4
+                    ];
+                    return [
+                        4,
+                        feature.schema(conn)
+                    ];
+                case 3:
+                    _state.sent();
+                    _state.label = 4;
+                case 4:
+                    _iteratorNormalCompletion = true;
+                    return [
+                        3,
+                        2
+                    ];
+                case 5:
+                    return [
+                        3,
+                        8
+                    ];
+                case 6:
+                    err = _state.sent();
+                    _didIteratorError = true;
+                    _iteratorError = err;
+                    return [
+                        3,
+                        8
+                    ];
+                case 7:
+                    try {
+                        if (!_iteratorNormalCompletion && _iterator.return != null) {
+                            _iterator.return();
+                        }
+                    } finally{
+                        if (_didIteratorError) {
+                            throw _iteratorError;
+                        }
+                    }
+                    return [
+                        7
+                    ];
+                case 8:
+                    toggles = disabled.filter(function(feature) {
+                        return feature.name !== 'embed';
+                    }).map(function(feature) {
+                        return {
+                            name: feature.name,
+                            turnedOn: false
+                        };
+                    });
+                    return [
+                        4,
+                        invalidateFeatureToggles(conn, cfg, paths.rootDir, dialect, pool, toggles)
+                    ];
+                case 9:
+                    _state.sent();
+                    if (!disabled.some(function(feature) {
+                        return feature.name === 'embed';
+                    })) return [
+                        3,
+                        13
+                    ];
+                    return [
+                        4,
+                        conn.prepare("SELECT name FROM sqlite_master WHERE type = 'table' AND name = 'embeddings'")
+                    ];
+                case 10:
+                    embeddingsTable = _state.sent();
+                    return [
+                        4,
+                        embeddingsTable.all()
+                    ];
+                case 11:
+                    if (!(_state.sent().length > 0)) return [
+                        3,
+                        13
+                    ];
+                    return [
+                        4,
+                        (0, _transactionts.withTransaction)(conn, function() {
+                            return conn.exec('DELETE FROM embeddings');
+                        }, dialect.beginMode())
+                    ];
+                case 12:
+                    _state.sent();
+                    _state.label = 13;
+                case 13:
+                    forcedPaths = new Set((0, _indexts2.listFiles)(cfg, paths.rootDir).map(function(file) {
+                        return file.relPath;
+                    }));
+                    return [
+                        2,
+                        (0, _reconcilets.reconcile)(conn, cfg, paths, dialect, pool, forcedPaths)
+                    ];
+            }
+        });
+    })();
+}
 function createBuilder(conn, cfg, paths, dialect) {
     var pool = new _poolts.ParsePool();
     return {
         build: function build(forcedPaths) {
             return (0, _reconcilets.reconcile)(conn, cfg, paths, dialect, pool, forcedPaths);
         },
+        recover: function recover() {
+            return recoverIncomplete(conn, cfg, paths, dialect, pool);
+        },
         invalidate: function invalidate(kind) {
             return kind === 'model' ? nullEmbedVectors(conn, dialect) : rebuildEmbeddings(conn, cfg, paths.rootDir, dialect, pool);
         },

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

@@ -1 +1 @@
-{"version":3,"sources":["/Users/kevin/Dev/OpenSource/ai/sensemaking/src/store/builder.ts"],"sourcesContent":["import type { Config } from '../config/index.ts';\nimport { embed } from '../features/embed.ts';\nimport { FEATURES } from '../features/index.ts';\nimport { rank } from '../features/rank.ts';\nimport type { ReconcileDelta } from '../features/types.ts';\nimport { listFiles } from '../scan/index.ts';\nimport { ParsePool } from '../scan/pool.ts';\nimport { reparseFiles } from '../scan/reparse.ts';\nimport type { EmbedChangeKind } from './embed-scope.ts';\nimport type { FeatureToggle } from './feature-scope.ts';\nimport { NARROW_FEATURE_TABLE } from './feature-scope.ts';\nimport { type ReconcilePaths, reconcile } from './reconcile.ts';\nimport { getColumns } from './shared.ts';\nimport type { Stages } from './stages.ts';\nimport { withTransaction } from './transaction.ts';\nimport type { Connection, ReconcileDialect } from './types.ts';\n\n// Owns bringing a store's index current: the write half `Store` (types.ts) deliberately does not\n// carry. A one-shot open calls build() once; a watcher calls it repeatedly on the same instance.\nexport interface Builder {\n  // forcedPaths (open.ts's preset-only narrow rebuild) applies to this call alone, not future ones.\n  build(forcedPaths?: ReadonlySet<string>): Promise<{ parsed: number; warnings: string[]; stages: Stages }>;\n  // Narrow embed invalidation (open.ts, embed-scope.ts's classifyEmbedChange): 'model' nulls every\n  // vector/scale in place; 'chunk' rebuilds every embedding row. Neither touches another table.\n  invalidate(kind: EmbedChangeKind): Promise<{ parsed: number }>;\n  // Narrow feature-toggle invalidation (open.ts, feature-scope.ts's classifyFeatureToggles): a\n  // toggle drops (or, turning back on, fully re-derives) that feature's own table; rank instead\n  // nulls or recomputes its `_rank` column, since rows written while a feature was off are\n  // untrustworthy (reconcile.ts's activeFeatures skips a disabled feature's hooks entirely).\n  invalidateFeatures(toggles: FeatureToggle[]): Promise<{ parsed: number }>;\n  // Releases the parse worker pool, if this lifetime ever created one; never the connection.\n  close(): Promise<void>;\n  // Pools this lifetime has constructed, so reuse is observable rather than inferred.\n  readonly poolsCreated: number;\n}\n\n// 'model': the provider or model name moved but chunk boundaries did not, so only the vector\n// values are stale. No reparse, and no table but embeddings is touched.\nasync function nullEmbedVectors(conn: Connection, dialect: ReconcileDialect): Promise<{ parsed: number }> {\n  await withTransaction(conn, () => conn.exec('UPDATE embeddings SET vector = NULL, scale = NULL'), dialect.beginMode());\n  return { parsed: 0 };\n}\n\n// 'chunk': chunkTokens or the chunk version moved, so chunk boundaries genuinely changed. Rebuilds\n// every embedding row through the embed feature's own remove/store, touching no other table.\nasync function rebuildEmbeddings(conn: Connection, cfg: Config, baseDir: string, dialect: ReconcileDialect, pool: ParsePool): Promise<{ parsed: number }> {\n  const existingStmt = await conn.prepare('SELECT \"path\" FROM frontmatter');\n  const existingPaths = new Set((await existingStmt.all()).map((r) => (r as { path: string }).path));\n  // A file added since the last build has no row yet; leaving it for build() to insert avoids a\n  // primary-key collision between this INSERT and build()'s own insert for the same new file.\n  const files = listFiles(cfg, baseDir).filter((f) => f.embed && existingPaths.has(f.relPath));\n  if (files.length === 0) return { parsed: 0 };\n\n  const { docs } = await reparseFiles(files, [embed], cfg, new Set(), undefined, { pool });\n  const paths = docs.map((d) => d.relPath);\n  const delta: ReconcileDelta = { files, reparsed: paths, added: [], vanished: [] };\n  await withTransaction(\n    conn,\n    async () => {\n      await embed.remove?.(conn, paths, delta);\n      await embed.store?.(\n        conn,\n        docs.map((d) => ({ path: d.relPath, extracted: d.extracted.embed })),\n        delta\n      );\n    },\n    dialect.beginMode()\n  );\n  return { parsed: docs.length };\n}\n\n// One feature's own table, dropped and (turning on) fully re-derived across every indexed file.\n// Rows left over from before this feature was disabled are untrustworthy by construction (files\n// added, edited, or deleted got no remove/store for it), so this never diffs against them --\n// dropping every row and reparsing the whole tree is the only safe path back to consistent state.\nasync function invalidateFeatureTable(conn: Connection, cfg: Config, baseDir: string, dialect: ReconcileDialect, pool: ParsePool, toggle: FeatureToggle): Promise<{ parsed: number }> {\n  const table = NARROW_FEATURE_TABLE[toggle.name];\n  const feature = FEATURES.find((f) => f.name === toggle.name);\n  if (!feature) throw new Error(`invalidateFeatureTable: no registered feature named \"${toggle.name}\"`);\n\n  if (!toggle.turnedOn) {\n    await withTransaction(conn, () => conn.exec(`DELETE FROM ${table}`), dialect.beginMode());\n    return { parsed: 0 };\n  }\n\n  const files = listFiles(cfg, baseDir);\n  const { docs } = await reparseFiles(files, [feature], cfg, new Set(), undefined, { pool });\n  const docsForFeature = docs.map((d) => ({ path: d.relPath, extracted: d.extracted[feature.name] }));\n  const paths = docs.map((d) => d.relPath);\n  // Every path counts as added, not just touched: nothing stale to diff against. Links resolves\n  // dst inside store() itself when added.length equals files.length (a cold build).\n  const delta: ReconcileDelta = { files, reparsed: paths, added: paths, vanished: [] };\n  await withTransaction(\n    conn,\n    async () => {\n      await conn.exec(`DELETE FROM ${table}`);\n      await feature.store?.(conn, docsForFeature, delta);\n      await feature.afterReconcile?.(conn, delta);\n    },\n    dialect.beginMode()\n  );\n  return { parsed: docs.length };\n}\n\n// rank has no table of its own: frontmatter._rank is the only state it owns. Guarded on column\n// presence, since links can toggle off while rank has never been enabled for this tree.\nasync function nullRank(conn: Connection, dialect: ReconcileDialect): Promise<void> {\n  const columns = await getColumns(conn);\n  if (!columns.has('_rank')) return;\n  await withTransaction(conn, () => conn.exec('UPDATE frontmatter SET \"_rank\" = NULL'), dialect.beginMode());\n}\n\n// Whole-tree and reparse-free: PageRank is computed from the links table, not from files, so\n// turning rank back on needs no reparseFiles pass at all.\nasync function rerunRank(conn: Connection, dialect: ReconcileDialect): Promise<void> {\n  const delta: ReconcileDelta = { files: [], reparsed: [], added: [], vanished: [] };\n  await withTransaction(\n    conn,\n    async () => {\n      await rank.afterReconcile?.(conn, delta);\n    },\n    dialect.beginMode()\n  );\n}\n\nasync function invalidateFeatureToggles(conn: Connection, cfg: Config, baseDir: string, dialect: ReconcileDialect, pool: ParsePool, toggles: FeatureToggle[]): Promise<{ parsed: number }> {\n  const byName = new Map(toggles.map((toggle) => [toggle.name, toggle]));\n  let parsed = 0;\n\n  // links first, if present: rank's rerun below (whether from its own toggle or the co-change\n  // rankToggle carries) must read the links table after it is back in its new state.\n  const linksToggle = byName.get('links');\n  if (linksToggle) {\n    parsed += (await invalidateFeatureTable(conn, cfg, baseDir, dialect, pool, linksToggle)).parsed;\n    // Unconditional, per rank's dependency on links: nulling is a no-op (guarded) when rank was\n    // never enabled for this tree, so this is safe even when no feature:rank segment changed.\n    if (!linksToggle.turnedOn) await nullRank(conn, dialect);\n  }\n\n  // rank's effective on/off (featureEnabled's links dependency) only appears as a changed\n  // `feature:rank` segment when it actually flips -- whether that's rank's own config or a\n  // links toggle taking it along -- so honoring it here is complete on its own.\n  const rankToggle = byName.get('rank');\n  if (rankToggle) {\n    if (rankToggle.turnedOn) await rerunRank(conn, dialect);\n    else await nullRank(conn, dialect);\n  }\n\n  for (const toggle of toggles) {\n    if (toggle.name === 'links' || toggle.name === 'rank') continue;\n    parsed += (await invalidateFeatureTable(conn, cfg, baseDir, dialect, pool, toggle)).parsed;\n  }\n  return { parsed };\n}\n\n// The pool is created at most once, lazily, on whichever build() or invalidate() call first\n// needs it, and reused by every later call on this instance.\nexport function createBuilder(conn: Connection, cfg: Config, paths: ReconcilePaths, dialect: ReconcileDialect): Builder {\n  const pool = new ParsePool();\n  return {\n    build: (forcedPaths) => reconcile(conn, cfg, paths, dialect, pool, forcedPaths),\n    invalidate: (kind) => (kind === 'model' ? nullEmbedVectors(conn, dialect) : rebuildEmbeddings(conn, cfg, paths.rootDir, dialect, pool)),\n    invalidateFeatures: (toggles) => invalidateFeatureToggles(conn, cfg, paths.rootDir, dialect, pool, toggles),\n    close: () => pool.close(),\n    get poolsCreated() {\n      return pool.poolsCreated;\n    },\n  };\n}\n"],"names":["createBuilder","nullEmbedVectors","conn","dialect","withTransaction","exec","beginMode","parsed","rebuildEmbeddings","cfg","baseDir","pool","existingStmt","existingPaths","files","docs","paths","delta","prepare","Set","all","map","r","path","listFiles","filter","f","embed","has","relPath","length","reparseFiles","undefined","d","reparsed","added","vanished","remove","store","extracted","invalidateFeatureTable","toggle","table","feature","docsForFeature","NARROW_FEATURE_TABLE","name","FEATURES","find","Error","turnedOn","afterReconcile","nullRank","columns","getColumns","rerunRank","rank","invalidateFeatureToggles","toggles","byName","linksToggle","rankToggle","Map","get","ParsePool","build","forcedPaths","reconcile","invalidate","kind","rootDir","invalidateFeatures","close","poolsCreated"],"mappings":"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"}
+{"version":3,"sources":["/Users/kevin/Dev/OpenSource/ai/sensemaking/src/store/builder.ts"],"sourcesContent":["import { type Config, featureEnabled } from '../config/index.ts';\nimport { embed } from '../features/embed.ts';\nimport { FEATURES } from '../features/index.ts';\nimport { rank } from '../features/rank.ts';\nimport type { ReconcileDelta } from '../features/types.ts';\nimport { listFiles } from '../scan/index.ts';\nimport { ParsePool } from '../scan/pool.ts';\nimport { reparseFiles } from '../scan/reparse.ts';\nimport type { EmbedChangeKind } from './embed-scope.ts';\nimport type { FeatureToggle } from './feature-scope.ts';\nimport { NARROW_FEATURE_TABLE } from './feature-scope.ts';\nimport { type ReconcilePaths, reconcile } from './reconcile.ts';\nimport { getColumns } from './shared.ts';\nimport type { Stages } from './stages.ts';\nimport { withTransaction } from './transaction.ts';\nimport type { Connection, ReconcileDialect } from './types.ts';\n\n// Owns bringing a store's index current: the write half `Store` (types.ts) deliberately does not\n// carry. A one-shot open calls build() once; a watcher calls it repeatedly on the same instance.\nexport interface Builder {\n  // forcedPaths (open.ts's preset-only narrow rebuild) applies to this call alone, not future ones.\n  build(forcedPaths?: ReadonlySet<string>): Promise<{ parsed: number; warnings: string[]; stages: Stages }>;\n  // Repairs an incomplete generation in place, including state owned by disabled features.\n  recover(): Promise<{ parsed: number; warnings: string[]; stages: Stages }>;\n  // Narrow embed invalidation (open.ts, embed-scope.ts's classifyEmbedChange): 'model' nulls every\n  // vector/scale in place; 'chunk' rebuilds every embedding row. Neither touches another table.\n  invalidate(kind: EmbedChangeKind): Promise<{ parsed: number }>;\n  // Narrow feature-toggle invalidation (open.ts, feature-scope.ts's classifyFeatureToggles): a\n  // toggle drops (or, turning back on, fully re-derives) that feature's own table; rank instead\n  // nulls or recomputes its `_rank` column, since rows written while a feature was off are\n  // untrustworthy (reconcile.ts's activeFeatures skips a disabled feature's hooks entirely).\n  invalidateFeatures(toggles: FeatureToggle[]): Promise<{ parsed: number }>;\n  // Releases the parse worker pool, if this lifetime ever created one; never the connection.\n  close(): Promise<void>;\n  // Pools this lifetime has constructed, so reuse is observable rather than inferred.\n  readonly poolsCreated: number;\n}\n\n// 'model': the provider or model name moved but chunk boundaries did not, so only the vector\n// values are stale. No reparse, and no table but embeddings is touched.\nasync function nullEmbedVectors(conn: Connection, dialect: ReconcileDialect): Promise<{ parsed: number }> {\n  await withTransaction(conn, () => conn.exec('UPDATE embeddings SET vector = NULL, scale = NULL'), dialect.beginMode());\n  return { parsed: 0 };\n}\n\n// 'chunk': chunkTokens or the chunk version moved, so chunk boundaries genuinely changed. Rebuilds\n// every embedding row through the embed feature's own remove/store, touching no other table.\nasync function rebuildEmbeddings(conn: Connection, cfg: Config, baseDir: string, dialect: ReconcileDialect, pool: ParsePool): Promise<{ parsed: number }> {\n  const existingStmt = await conn.prepare('SELECT \"path\" FROM frontmatter');\n  const existingPaths = new Set((await existingStmt.all()).map((r) => (r as { path: string }).path));\n  // A file added since the last build has no row yet; leaving it for build() to insert avoids a\n  // primary-key collision between this INSERT and build()'s own insert for the same new file.\n  const files = listFiles(cfg, baseDir).filter((f) => f.embed && existingPaths.has(f.relPath));\n  if (files.length === 0) return { parsed: 0 };\n\n  const { docs } = await reparseFiles(files, [embed], cfg, new Set(), undefined, { pool });\n  const paths = docs.map((d) => d.relPath);\n  const delta: ReconcileDelta = { files, reparsed: paths, added: [], vanished: [] };\n  await withTransaction(\n    conn,\n    async () => {\n      await embed.remove?.(conn, paths, delta);\n      await embed.store?.(\n        conn,\n        docs.map((d) => ({ path: d.relPath, extracted: d.extracted.embed })),\n        delta\n      );\n    },\n    dialect.beginMode()\n  );\n  return { parsed: docs.length };\n}\n\n// One feature's own table, dropped and (turning on) fully re-derived across every indexed file.\n// Rows left over from before this feature was disabled are untrustworthy by construction (files\n// added, edited, or deleted got no remove/store for it), so this never diffs against them --\n// dropping every row and reparsing the whole tree is the only safe path back to consistent state.\nasync function invalidateFeatureTable(conn: Connection, cfg: Config, baseDir: string, dialect: ReconcileDialect, pool: ParsePool, toggle: FeatureToggle): Promise<{ parsed: number }> {\n  const table = NARROW_FEATURE_TABLE[toggle.name];\n  const feature = FEATURES.find((f) => f.name === toggle.name);\n  if (!feature) throw new Error(`invalidateFeatureTable: no registered feature named \"${toggle.name}\"`);\n\n  if (!toggle.turnedOn) {\n    await withTransaction(conn, () => conn.exec(`DELETE FROM ${table}`), dialect.beginMode());\n    return { parsed: 0 };\n  }\n\n  const files = listFiles(cfg, baseDir);\n  const { docs } = await reparseFiles(files, [feature], cfg, new Set(), undefined, { pool });\n  const docsForFeature = docs.map((d) => ({ path: d.relPath, extracted: d.extracted[feature.name] }));\n  const paths = docs.map((d) => d.relPath);\n  // Every path counts as added, not just touched: nothing stale to diff against. Links resolves\n  // dst inside store() itself when added.length equals files.length (a cold build).\n  const delta: ReconcileDelta = { files, reparsed: paths, added: paths, vanished: [] };\n  await withTransaction(\n    conn,\n    async () => {\n      await conn.exec(`DELETE FROM ${table}`);\n      await feature.store?.(conn, docsForFeature, delta);\n      await feature.afterReconcile?.(conn, delta);\n    },\n    dialect.beginMode()\n  );\n  return { parsed: docs.length };\n}\n\n// rank has no table of its own: frontmatter._rank is the only state it owns. Guarded on column\n// presence, since links can toggle off while rank has never been enabled for this tree.\nasync function nullRank(conn: Connection, dialect: ReconcileDialect): Promise<void> {\n  const columns = await getColumns(conn);\n  if (!columns.has('_rank')) return;\n  await withTransaction(conn, () => conn.exec('UPDATE frontmatter SET \"_rank\" = NULL'), dialect.beginMode());\n}\n\n// Whole-tree and reparse-free: PageRank is computed from the links table, not from files, so\n// turning rank back on needs no reparseFiles pass at all.\nasync function rerunRank(conn: Connection, dialect: ReconcileDialect): Promise<void> {\n  const delta: ReconcileDelta = { files: [], reparsed: [], added: [], vanished: [] };\n  await withTransaction(\n    conn,\n    async () => {\n      await rank.afterReconcile?.(conn, delta);\n    },\n    dialect.beginMode()\n  );\n}\n\nasync function invalidateFeatureToggles(conn: Connection, cfg: Config, baseDir: string, dialect: ReconcileDialect, pool: ParsePool, toggles: FeatureToggle[]): Promise<{ parsed: number }> {\n  const byName = new Map(toggles.map((toggle) => [toggle.name, toggle]));\n  let parsed = 0;\n\n  // links first, if present: rank's rerun below (whether from its own toggle or the co-change\n  // rankToggle carries) must read the links table after it is back in its new state.\n  const linksToggle = byName.get('links');\n  if (linksToggle) {\n    parsed += (await invalidateFeatureTable(conn, cfg, baseDir, dialect, pool, linksToggle)).parsed;\n    // Unconditional, per rank's dependency on links: nulling is a no-op (guarded) when rank was\n    // never enabled for this tree, so this is safe even when no feature:rank segment changed.\n    if (!linksToggle.turnedOn) await nullRank(conn, dialect);\n  }\n\n  // rank's effective on/off (featureEnabled's links dependency) only appears as a changed\n  // `feature:rank` segment when it actually flips -- whether that's rank's own config or a\n  // links toggle taking it along -- so honoring it here is complete on its own.\n  const rankToggle = byName.get('rank');\n  if (rankToggle) {\n    if (rankToggle.turnedOn) await rerunRank(conn, dialect);\n    else await nullRank(conn, dialect);\n  }\n\n  for (const toggle of toggles) {\n    if (toggle.name === 'links' || toggle.name === 'rank') continue;\n    parsed += (await invalidateFeatureTable(conn, cfg, baseDir, dialect, pool, toggle)).parsed;\n  }\n  return { parsed };\n}\n\nasync function recoverIncomplete(conn: Connection, cfg: Config, paths: ReconcilePaths, dialect: ReconcileDialect, pool: ParsePool): Promise<{ parsed: number; warnings: string[]; stages: Stages }> {\n  const disabled = FEATURES.filter((feature) => !featureEnabled(cfg, feature.name));\n  for (const feature of disabled) {\n    if (feature.name !== 'embed') await feature.schema(conn);\n  }\n\n  const toggles: FeatureToggle[] = disabled.filter((feature) => feature.name !== 'embed').map((feature) => ({ name: feature.name, turnedOn: false }));\n  await invalidateFeatureToggles(conn, cfg, paths.rootDir, dialect, pool, toggles);\n  if (disabled.some((feature) => feature.name === 'embed')) {\n    const embeddingsTable = await conn.prepare(\"SELECT name FROM sqlite_master WHERE type = 'table' AND name = 'embeddings'\");\n    if ((await embeddingsTable.all()).length > 0) await withTransaction(conn, () => conn.exec('DELETE FROM embeddings'), dialect.beginMode());\n  }\n\n  const forcedPaths = new Set(listFiles(cfg, paths.rootDir).map((file) => file.relPath));\n  return reconcile(conn, cfg, paths, dialect, pool, forcedPaths);\n}\n\n// The pool is created at most once, lazily, on whichever build() or invalidate() call first\n// needs it, and reused by every later call on this instance.\nexport function createBuilder(conn: Connection, cfg: Config, paths: ReconcilePaths, dialect: ReconcileDialect): Builder {\n  const pool = new ParsePool();\n  return {\n    build: (forcedPaths) => reconcile(conn, cfg, paths, dialect, pool, forcedPaths),\n    recover: () => recoverIncomplete(conn, cfg, paths, dialect, pool),\n    invalidate: (kind) => (kind === 'model' ? nullEmbedVectors(conn, dialect) : rebuildEmbeddings(conn, cfg, paths.rootDir, dialect, pool)),\n    invalidateFeatures: (toggles) => invalidateFeatureToggles(conn, cfg, paths.rootDir, dialect, pool, toggles),\n    close: () => pool.close(),\n    get poolsCreated() {\n      return pool.poolsCreated;\n    },\n  };\n}\n"],"names":["createBuilder","nullEmbedVectors","conn","dialect","withTransaction","exec","beginMode","parsed","rebuildEmbeddings","cfg","baseDir","pool","existingStmt","existingPaths","files","docs","paths","delta","prepare","Set","all","map","r","path","listFiles","filter","f","embed","has","relPath","length","reparseFiles","undefined","d","reparsed","added","vanished","remove","store","extracted","invalidateFeatureTable","toggle","table","feature","docsForFeature","NARROW_FEATURE_TABLE","name","FEATURES","find","Error","turnedOn","afterReconcile","nullRank","columns","getColumns","rerunRank","rank","invalidateFeatureToggles","toggles","byName","linksToggle","rankToggle","Map","get","recoverIncomplete","disabled","embeddingsTable","forcedPaths","featureEnabled","schema","rootDir","some","file","reconcile","ParsePool","build","recover","invalidate","kind","invalidateFeatures","close","poolsCreated"],"mappings":";;;;+BAgLgBA;;;eAAAA;;;uBAhL4B;uBACtB;wBACG;sBACJ;wBAEK;sBACA;yBACG;8BAGQ;2BACU;wBACpB;6BAEK;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAwBhC,6FAA6F;AAC7F,wEAAwE;AACxE,SAAeC,iBAAiBC,IAAgB,EAAEC,OAAyB;;;;;oBACzE;;wBAAMC,IAAAA,8BAAe,EAACF,MAAM;mCAAMA,KAAKG,IAAI,CAAC;2BAAsDF,QAAQG,SAAS;;;oBAAnH;oBACA;;wBAAO;4BAAEC,QAAQ;wBAAE;;;;IACrB;;AAEA,mGAAmG;AACnG,6FAA6F;AAC7F,SAAeC,kBAAkBN,IAAgB,EAAEO,GAAW,EAAEC,OAAe,EAAEP,OAAyB,EAAEQ,IAAe;;YACnHC,cACAC,kBAGAC,OAGEC,MACFC,OACAC;;;;oBATe;;wBAAMf,KAAKgB,OAAO,CAAC;;;oBAAlCN,eAAe;wBACKO;oBAAK;;wBAAMP,aAAaQ,GAAG;;;oBAA/CP,gBAAgB,IAAA,CAAA,EAAA,MAAIM;;wBAAK,cAA0BE,GAAG,CAAC,SAACC;mCAAM,AAACA,EAAuBC,IAAI;;sBAAC;oBACjG,8FAA8F;oBAC9F,4FAA4F;oBACtFT,QAAQU,IAAAA,mBAAS,EAACf,KAAKC,SAASe,MAAM,CAAC,SAACC;+BAAMA,EAAEC,KAAK,IAAId,cAAce,GAAG,CAACF,EAAEG,OAAO;;oBAC1F,IAAIf,MAAMgB,MAAM,KAAK,GAAG;;wBAAO;4BAAEvB,QAAQ;wBAAE;;oBAE1B;;wBAAMwB,IAAAA,uBAAY,EAACjB;4BAAQa,cAAK;2BAAGlB,KAAK,IAAIU,OAAOa,WAAW;4BAAErB,MAAAA;wBAAK;;;oBAA9EI,OAAS,cAATA;oBACFC,QAAQD,KAAKM,GAAG,CAAC,SAACY;+BAAMA,EAAEJ,OAAO;;oBACjCZ,QAAwB;wBAAEH,OAAAA;wBAAOoB,UAAUlB;wBAAOmB,KAAK;wBAAMC,QAAQ;oBAAK;oBAChF;;wBAAMhC,IAAAA,8BAAe,EACnBF,MACA;;oCACQyB,eACAA;;;;4CADN;;iDAAMA,gBAAAA,cAAK,CAACU,MAAM,cAAZV,oCAAAA,mBAAAA,cAAK,EAAUzB,MAAMc,OAAOC;;;4CAAlC;4CACA;;iDAAMU,eAAAA,cAAK,CAACW,KAAK,cAAXX,mCAAAA,kBAAAA,cAAK,EACTzB,MACAa,KAAKM,GAAG,CAAC,SAACY;2DAAO;wDAAEV,MAAMU,EAAEJ,OAAO;wDAAEU,WAAWN,EAAEM,SAAS,CAACZ,KAAK;oDAAC;oDACjEV;;;4CAHF;;;;;;4BAKF;2BACAd,QAAQG,SAAS;;;oBAVnB;oBAYA;;wBAAO;4BAAEC,QAAQQ,KAAKe,MAAM;wBAAC;;;;IAC/B;;AAEA,gGAAgG;AAChG,gGAAgG;AAChG,6FAA6F;AAC7F,kGAAkG;AAClG,SAAeU,uBAAuBtC,IAAgB,EAAEO,GAAW,EAAEC,OAAe,EAAEP,OAAyB,EAAEQ,IAAe,EAAE8B,MAAqB;;YAC/IC,OACAC,SAQA7B,OACEC,MACF6B,gBACA5B,OAGAC;;;;oBAfAyB,QAAQG,oCAAoB,CAACJ,OAAOK,IAAI,CAAC;oBACzCH,UAAUI,kBAAQ,CAACC,IAAI,CAAC,SAACtB;+BAAMA,EAAEoB,IAAI,KAAKL,OAAOK,IAAI;;oBAC3D,IAAI,CAACH,SAAS,MAAM,IAAIM,MAAM,AAAC,wDAAmE,OAAZR,OAAOK,IAAI,EAAC;yBAE9F,CAACL,OAAOS,QAAQ,EAAhB;;;;oBACF;;wBAAM9C,IAAAA,8BAAe,EAACF,MAAM;mCAAMA,KAAKG,IAAI,CAAC,AAAC,eAAoB,OAANqC;2BAAUvC,QAAQG,SAAS;;;oBAAtF;oBACA;;wBAAO;4BAAEC,QAAQ;wBAAE;;;oBAGfO,QAAQU,IAAAA,mBAAS,EAACf,KAAKC;oBACZ;;wBAAMqB,IAAAA,uBAAY,EAACjB;4BAAQ6B;2BAAUlC,KAAK,IAAIU,OAAOa,WAAW;4BAAErB,MAAAA;wBAAK;;;oBAAhFI,OAAS,cAATA;oBACF6B,iBAAiB7B,KAAKM,GAAG,CAAC,SAACY;+BAAO;4BAAEV,MAAMU,EAAEJ,OAAO;4BAAEU,WAAWN,EAAEM,SAAS,CAACI,QAAQG,IAAI,CAAC;wBAAC;;oBAC1F9B,QAAQD,KAAKM,GAAG,CAAC,SAACY;+BAAMA,EAAEJ,OAAO;;oBACvC,8FAA8F;oBAC9F,kFAAkF;oBAC5EZ,QAAwB;wBAAEH,OAAAA;wBAAOoB,UAAUlB;wBAAOmB,OAAOnB;wBAAOoB,QAAQ;oBAAK;oBACnF;;wBAAMhC,IAAAA,8BAAe,EACnBF,MACA;;oCAEQyC,gBACAA;;;;4CAFN;;gDAAMzC,KAAKG,IAAI,CAAC,AAAC,eAAoB,OAANqC;;;4CAA/B;4CACA;;iDAAMC,iBAAAA,QAAQL,KAAK,cAAbK,qCAAAA,oBAAAA,SAAgBzC,MAAM0C,gBAAgB3B;;;4CAA5C;4CACA;;iDAAM0B,0BAAAA,QAAQQ,cAAc,cAAtBR,8CAAAA,6BAAAA,SAAyBzC,MAAMe;;;4CAArC;;;;;;4BACF;2BACAd,QAAQG,SAAS;;;oBAPnB;oBASA;;wBAAO;4BAAEC,QAAQQ,KAAKe,MAAM;wBAAC;;;;IAC/B;;AAEA,+FAA+F;AAC/F,wFAAwF;AACxF,SAAesB,SAASlD,IAAgB,EAAEC,OAAyB;;YAC3DkD;;;;oBAAU;;wBAAMC,IAAAA,oBAAU,EAACpD;;;oBAA3BmD,UAAU;oBAChB,IAAI,CAACA,QAAQzB,GAAG,CAAC,UAAU;;;oBAC3B;;wBAAMxB,IAAAA,8BAAe,EAACF,MAAM;mCAAMA,KAAKG,IAAI,CAAC;2BAA0CF,QAAQG,SAAS;;;oBAAvG;;;;;;IACF;;AAEA,6FAA6F;AAC7F,0DAA0D;AAC1D,SAAeiD,UAAUrD,IAAgB,EAAEC,OAAyB;;YAC5Dc;;;;oBAAAA,QAAwB;wBAAEH,KAAK;wBAAMoB,QAAQ;wBAAMC,KAAK;wBAAMC,QAAQ;oBAAK;oBACjF;;wBAAMhC,IAAAA,8BAAe,EACnBF,MACA;;oCACQsD;;;;4CAAN;;iDAAMA,uBAAAA,YAAI,CAACL,cAAc,cAAnBK,2CAAAA,0BAAAA,YAAI,EAAkBtD,MAAMe;;;4CAAlC;;;;;;4BACF;2BACAd,QAAQG,SAAS;;;oBALnB;;;;;;IAOF;;AAEA,SAAemD,yBAAyBvD,IAAgB,EAAEO,GAAW,EAAEC,OAAe,EAAEP,OAAyB,EAAEQ,IAAe,EAAE+C,OAAwB;;YACpJC,QACFpD,QAIEqD,aAWAC,YAMD,2BAAA,mBAAA,gBAAA,WAAA,OAAMpB;;;;oBAtBLkB,SAAS,IAAIG,IAAIJ,QAAQrC,GAAG,CAAC,SAACoB;+BAAW;4BAACA,OAAOK,IAAI;4BAAEL;yBAAO;;oBAChElC,SAAS;oBAEb,4FAA4F;oBAC5F,mFAAmF;oBAC7EqD,cAAcD,OAAOI,GAAG,CAAC;yBAC3BH,aAAAA;;;;oBACS;;wBAAMpB,uBAAuBtC,MAAMO,KAAKC,SAASP,SAASQ,MAAMiD;;;oBAA3ErD,SAAAA,SAAU,AAAC,cAA8EA,MAAM;yBAG3F,CAACqD,YAAYV,QAAQ,EAArB;;;;oBAAuB;;wBAAME,SAASlD,MAAMC;;;oBAArB;;;oBAG7B,wFAAwF;oBACxF,yFAAyF;oBACzF,8EAA8E;oBACxE0D,aAAaF,OAAOI,GAAG,CAAC;yBAC1BF,YAAAA;;;;yBACEA,WAAWX,QAAQ,EAAnBW;;;;oBAAqB;;wBAAMN,UAAUrD,MAAMC;;;oBAAtB;;;;;;oBACpB;;wBAAMiD,SAASlD,MAAMC;;;oBAArB;;;oBAGF,kCAAA,2BAAA;;;;;;;;;oBAAA,YAAgBuD;;;2BAAhB,6BAAA,QAAA;;;;oBAAMjB,SAAN;oBACH,IAAIA,OAAOK,IAAI,KAAK,WAAWL,OAAOK,IAAI,KAAK,QAAQ;;;;oBAC5C;;wBAAMN,uBAAuBtC,MAAMO,KAAKC,SAASP,SAASQ,MAAM8B;;;oBAA3ElC,SAAAA,SAAU,AAAC,cAAyEA,MAAM;;;oBAFvF;;;;;;;;;;;;oBAAA;oBAAA;;;;;;;6BAAA,6BAAA;4BAAA;;;4BAAA;kCAAA;;;;;;;oBAIL;;wBAAO;4BAAEA,QAAAA;wBAAO;;;;IAClB;;AAEA,SAAeyD,kBAAkB9D,IAAgB,EAAEO,GAAW,EAAEO,KAAqB,EAAEb,OAAyB,EAAEQ,IAAe;;YACzHsD,UACD,2BAAA,mBAAA,gBAAA,WAAA,OAAMtB,cAILe,SAGEQ,iBAIFC;;;;oBAZAF,WAAWlB,kBAAQ,CAACtB,MAAM,CAAC,SAACkB;+BAAY,CAACyB,IAAAA,uBAAc,EAAC3D,KAAKkC,QAAQG,IAAI;;oBAC1E,kCAAA,2BAAA;;;;;;;;;oBAAA,YAAiBmB;;;2BAAjB,6BAAA,QAAA;;;;oBAAMtB,UAAN;yBACCA,CAAAA,QAAQG,IAAI,KAAK,OAAM,GAAvBH;;;;oBAA0B;;wBAAMA,QAAQ0B,MAAM,CAACnE;;;oBAArB;;;oBAD3B;;;;;;;;;;;;oBAAA;oBAAA;;;;;;;6BAAA,6BAAA;4BAAA;;;4BAAA;kCAAA;;;;;;;oBAICwD,UAA2BO,SAASxC,MAAM,CAAC,SAACkB;+BAAYA,QAAQG,IAAI,KAAK;uBAASzB,GAAG,CAAC,SAACsB;+BAAa;4BAAEG,MAAMH,QAAQG,IAAI;4BAAEI,UAAU;wBAAM;;oBAChJ;;wBAAMO,yBAAyBvD,MAAMO,KAAKO,MAAMsD,OAAO,EAAEnE,SAASQ,MAAM+C;;;oBAAxE;yBACIO,SAASM,IAAI,CAAC,SAAC5B;+BAAYA,QAAQG,IAAI,KAAK;wBAA5CmB;;;;oBACsB;;wBAAM/D,KAAKgB,OAAO,CAAC;;;oBAArCgD,kBAAkB;oBACnB;;wBAAMA,gBAAgB9C,GAAG;;;yBAA1B,CAAA,AAAC,cAA6BU,MAAM,GAAG,CAAA,GAAvC;;;;oBAA0C;;wBAAM1B,IAAAA,8BAAe,EAACF,MAAM;mCAAMA,KAAKG,IAAI,CAAC;2BAA2BF,QAAQG,SAAS;;;oBAAxF;;;oBAG1C6D,cAAc,IAAIhD,IAAIK,IAAAA,mBAAS,EAACf,KAAKO,MAAMsD,OAAO,EAAEjD,GAAG,CAAC,SAACmD;+BAASA,KAAK3C,OAAO;;oBACpF;;wBAAO4C,IAAAA,sBAAS,EAACvE,MAAMO,KAAKO,OAAOb,SAASQ,MAAMwD;;;;IACpD;;AAIO,SAASnE,cAAcE,IAAgB,EAAEO,GAAW,EAAEO,KAAqB,EAAEb,OAAyB;IAC3G,IAAMQ,OAAO,IAAI+D,iBAAS;IAC1B,OAAO;QACLC,OAAO,SAAPA,MAAQR;mBAAgBM,IAAAA,sBAAS,EAACvE,MAAMO,KAAKO,OAAOb,SAASQ,MAAMwD;;QACnES,SAAS,SAATA;mBAAeZ,kBAAkB9D,MAAMO,KAAKO,OAAOb,SAASQ;;QAC5DkE,YAAY,SAAZA,WAAaC;mBAAUA,SAAS,UAAU7E,iBAAiBC,MAAMC,WAAWK,kBAAkBN,MAAMO,KAAKO,MAAMsD,OAAO,EAAEnE,SAASQ;;QACjIoE,oBAAoB,SAApBA,mBAAqBrB;mBAAYD,yBAAyBvD,MAAMO,KAAKO,MAAMsD,OAAO,EAAEnE,SAASQ,MAAM+C;;QACnGsB,OAAO,SAAPA;mBAAarE,KAAKqE,KAAK;;QACvB,IAAIC;YACF,OAAOtE,KAAKsE,YAAY;QAC1B;IACF;AACF"}

package/dist/cjs/store/duckdb/lexical.d.cts

@@ -4,6 +4,8 @@ interface FtsIndexState {
     orderedMacroReady: boolean;
 }
 export declare function markContentStale(conn: Connection): Promise<void>;
+export declare function prepareFts(conn: Connection): Promise<void>;
+export declare function assertFtsReady(conn: Connection): Promise<void>;
 export declare function queryLexical(conn: Connection, terms: string, opts: LexicalQueryOptions, state: FtsIndexState): Promise<LexicalHit[]>;
 export declare function createLexicalIndex(conn: Connection): {
     query: (terms: string, opts: LexicalQueryOptions) => Promise<LexicalHit[]>;

package/dist/cjs/store/duckdb/lexical.d.ts

@@ -4,6 +4,8 @@ interface FtsIndexState {
     orderedMacroReady: boolean;
 }
 export declare function markContentStale(conn: Connection): Promise<void>;
+export declare function prepareFts(conn: Connection): Promise<void>;
+export declare function assertFtsReady(conn: Connection): Promise<void>;
 export declare function queryLexical(conn: Connection, terms: string, opts: LexicalQueryOptions, state: FtsIndexState): Promise<LexicalHit[]>;
 export declare function createLexicalIndex(conn: Connection): {
     query: (terms: string, opts: LexicalQueryOptions) => Promise<LexicalHit[]>;

package/dist/cjs/store/duckdb/lexical.js

@@ -11,12 +11,18 @@ function _export(target, all) {
     });
 }
 _export(exports, {
+    get assertFtsReady () {
+        return assertFtsReady;
+    },
     get createLexicalIndex () {
         return createLexicalIndex;
     },
     get markContentStale () {
         return markContentStale;
     },
+    get prepareFts () {
+        return prepareFts;
+    },
     get queryLexical () {
         return queryLexical;
     }
@@ -60,6 +66,12 @@ function _async_to_generator(fn) {
         });
     };
 }
+function _instanceof(left, right) {
+    "@swc/helpers - instanceof";
+    if (right != null && typeof Symbol !== "undefined" && right[Symbol.hasInstance]) {
+        return !!right[Symbol.hasInstance](left);
+    } else return left instanceof right;
+}
 function _iterable_to_array(iter) {
     if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) {
         return Array.from(iter);
@@ -283,6 +295,31 @@ function stateFor(conn) {
         });
     })();
 }
+function hasFtsArtifact(conn) {
+    return _async_to_generator(function() {
+        var stmt;
+        return _ts_generator(this, function(_state) {
+            switch(_state.label){
+                case 0:
+                    return [
+                        4,
+                        conn.prepare("\n    SELECT 1 AS ready\n    FROM duckdb_functions()\n    WHERE schema_name = 'fts_main_content'\n      AND function_name = 'match_bm25'\n      AND function_type = 'macro'\n    LIMIT 1\n  ")
+                    ];
+                case 1:
+                    stmt = _state.sent();
+                    return [
+                        4,
+                        stmt.get()
+                    ];
+                case 2:
+                    return [
+                        2,
+                        _state.sent() !== undefined
+                    ];
+            }
+        });
+    })();
+}
 function markContentStale(conn) {
     return _async_to_generator(function() {
         return _ts_generator(this, function(_state) {
@@ -403,21 +440,36 @@ function splitTerms(terms) {
 }
 // No incremental update (verified 1.5.5: PRAGMA create_fts_index is rebuild-only), so this pays
 // the full rebuild whenever `state.stale`, which meta.fts_stale keeps true across processes until cleared below.
-function ensureFtsFresh(conn, state) {
+function rebuildFts(conn, state) {
     return _async_to_generator(function() {
+        var _tmp;
         return _ts_generator(this, function(_state) {
             switch(_state.label){
                 case 0:
-                    if (!state.stale) return [
-                        2
-                    ];
-                    state.orderedMacroReady = false;
                     return [
                         4,
                         conn.exec('INSTALL fts; LOAD fts;')
                     ];
                 case 1:
                     _state.sent();
+                    _tmp = !state.stale;
+                    if (!_tmp) return [
+                        3,
+                        3
+                    ];
+                    return [
+                        4,
+                        hasFtsArtifact(conn)
+                    ];
+                case 2:
+                    _tmp = _state.sent();
+                    _state.label = 3;
+                case 3:
+                    if (_tmp) return [
+                        2
+                    ];
+                    state.stale = true;
+                    state.orderedMacroReady = false;
                     return [
                         4,
                         (0, _transactionts.withTransaction)(conn, function() {
@@ -449,7 +501,7 @@ function ensureFtsFresh(conn, state) {
                             })();
                         })
                     ];
-                case 2:
+                case 4:
                     _state.sent();
                     state.stale = false;
                     return [
@@ -459,6 +511,86 @@ function ensureFtsFresh(conn, state) {
         });
     })();
 }
+function prepareFts(conn) {
+    return _async_to_generator(function() {
+        var _tmp;
+        return _ts_generator(this, function(_state) {
+            switch(_state.label){
+                case 0:
+                    _tmp = [
+                        conn
+                    ];
+                    return [
+                        4,
+                        stateFor(conn)
+                    ];
+                case 1:
+                    return [
+                        4,
+                        rebuildFts.apply(void 0, _tmp.concat([
+                            _state.sent()
+                        ]))
+                    ];
+                case 2:
+                    _state.sent();
+                    return [
+                        2
+                    ];
+            }
+        });
+    })();
+}
+function assertFtsReady(conn) {
+    return _async_to_generator(function() {
+        var state, err;
+        return _ts_generator(this, function(_state) {
+            switch(_state.label){
+                case 0:
+                    return [
+                        4,
+                        stateFor(conn)
+                    ];
+                case 1:
+                    state = _state.sent();
+                    if (state.stale) throw new _errorsts.SenseError('INDEX_NOT_READY', 'the DuckDB lexical index is missing or stale; run `sense build` (or library build(config)) before lexical querying with build disabled');
+                    _state.label = 2;
+                case 2:
+                    _state.trys.push([
+                        2,
+                        5,
+                        ,
+                        6
+                    ]);
+                    return [
+                        4,
+                        conn.exec('LOAD fts;')
+                    ];
+                case 3:
+                    _state.sent();
+                    return [
+                        4,
+                        hasFtsArtifact(conn)
+                    ];
+                case 4:
+                    if (!_state.sent()) {
+                        throw new _errorsts.SenseError('INDEX_NOT_READY', 'the DuckDB lexical index artifact is missing; run `sense build` (or library build(config)) before lexical querying with build disabled');
+                    }
+                    return [
+                        3,
+                        6
+                    ];
+                case 5:
+                    err = _state.sent();
+                    if (_instanceof(err, _errorsts.SenseError)) throw err;
+                    throw new _errorsts.SenseError('INDEX_NOT_READY', "the DuckDB lexical extension is not prepared (".concat(err.message, "); run `sense build` (or library build(config))"));
+                case 6:
+                    return [
+                        2
+                    ];
+            }
+        });
+    })();
+}
 // Field-weighted fragments (title 10 / summary 5 / text 1), with params emitted in the exact left-to-right order the assembled SQL needs for positional `?` binding.
 // score/gate params stay in separate arrays until joined at the end, since the SQL puts every score part before every gate part; sharing one array would shift binds once a query has both words and substrings (PRINCIPLES: no-silent-modes).
 function buildScoreAndGate(words, bareWords, phraseWords, substrings) {
@@ -588,7 +720,7 @@ function queryLexical(conn, terms, opts, state) {
                     ];
                     return [
                         4,
-                        ensureFtsFresh(conn, state)
+                        assertFtsReady(conn)
                     ];
                 case 1:
                     _state.sent();