sensemaking 0.25.0 → 0.26.0

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

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

package/dist/cjs/commands/search.d.cts

@@ -1,6 +1,7 @@
 import type { ResolvedConfig } from '../config/index.js';
-import type { Row } from '../output/output.js';
 import type { Store } from '../store/types.js';
+import type { SearchResultVia } from './signals.js';
+export type { SearchResultVia } from './signals.js';
 export declare const SNIPPET_CHAR_LIMIT_DEFAULT = 80;
 export declare const SNIPPET_COUNT_LIMIT_DEFAULT = 1;
 export declare function computeSnippets(text: string, terms: string[], charLimit: number, countLimit: number): {
@@ -8,6 +9,7 @@ export declare function computeSnippets(text: string, terms: string[], charLimit
     offset: number;
 };
 export declare function lineNumberAt(text: string, offset: number): number;
+/** Options for the root {@link search} API. */
 export interface SearchOptions {
     k?: number;
     where?: string;
@@ -17,6 +19,27 @@ export interface SearchOptions {
     noExclude?: boolean;
     snippetCharLimit?: number;
     snippetCountLimit?: number;
+    /** Cancels supported provider I/O and stops between phases after active native work finishes. */
+    signal?: AbortSignal;
 }
-export declare function hydrateSearchRows(store: Store, cfg: ResolvedConfig, rows: Row[], matchedPaths: Set<string>, terms: string, opts?: Pick<SearchOptions, 'snippetCharLimit' | 'snippetCountLimit'>): Promise<void>;
-export declare function search(store: Store, cfg: ResolvedConfig, terms: string, opts?: SearchOptions): Promise<Row[]>;
+export type SearchResult = {
+    path: string;
+    title: string;
+    summary: string;
+    snippets: string[];
+    via: SearchResultVia;
+    score: number;
+    lines: string | null;
+    similarity?: number | null;
+};
+export interface SearchHydrationRow {
+    path: string;
+    snippets?: string[];
+    lines?: string | null;
+}
+export declare function hydrateSearchRows(store: Store, cfg: ResolvedConfig, rows: SearchHydrationRow[], matchedPaths: Set<string>, terms: string, opts?: Pick<SearchOptions, 'snippetCharLimit' | 'snippetCountLimit'>): Promise<void>;
+/**
+ * Searches one committed published generation. Provider work precedes the final read transaction;
+ * cancellation waits for active native work and transaction cleanup before rejection.
+ */
+export declare function search(store: Store, cfg: ResolvedConfig, terms: string, opts?: SearchOptions): Promise<SearchResult[]>;

package/dist/cjs/commands/search.d.ts

@@ -1,6 +1,7 @@
 import type { ResolvedConfig } from '../config/index.js';
-import type { Row } from '../output/output.js';
 import type { Store } from '../store/types.js';
+import type { SearchResultVia } from './signals.js';
+export type { SearchResultVia } from './signals.js';
 export declare const SNIPPET_CHAR_LIMIT_DEFAULT = 80;
 export declare const SNIPPET_COUNT_LIMIT_DEFAULT = 1;
 export declare function computeSnippets(text: string, terms: string[], charLimit: number, countLimit: number): {
@@ -8,6 +9,7 @@ export declare function computeSnippets(text: string, terms: string[], charLimit
     offset: number;
 };
 export declare function lineNumberAt(text: string, offset: number): number;
+/** Options for the root {@link search} API. */
 export interface SearchOptions {
     k?: number;
     where?: string;
@@ -17,6 +19,27 @@ export interface SearchOptions {
     noExclude?: boolean;
     snippetCharLimit?: number;
     snippetCountLimit?: number;
+    /** Cancels supported provider I/O and stops between phases after active native work finishes. */
+    signal?: AbortSignal;
 }
-export declare function hydrateSearchRows(store: Store, cfg: ResolvedConfig, rows: Row[], matchedPaths: Set<string>, terms: string, opts?: Pick<SearchOptions, 'snippetCharLimit' | 'snippetCountLimit'>): Promise<void>;
-export declare function search(store: Store, cfg: ResolvedConfig, terms: string, opts?: SearchOptions): Promise<Row[]>;
+export type SearchResult = {
+    path: string;
+    title: string;
+    summary: string;
+    snippets: string[];
+    via: SearchResultVia;
+    score: number;
+    lines: string | null;
+    similarity?: number | null;
+};
+export interface SearchHydrationRow {
+    path: string;
+    snippets?: string[];
+    lines?: string | null;
+}
+export declare function hydrateSearchRows(store: Store, cfg: ResolvedConfig, rows: SearchHydrationRow[], matchedPaths: Set<string>, terms: string, opts?: Pick<SearchOptions, 'snippetCharLimit' | 'snippetCountLimit'>): Promise<void>;
+/**
+ * Searches one committed published generation. Provider work precedes the final read transaction;
+ * cancellation waits for active native work and transaction cleanup before rejection.
+ */
+export declare function search(store: Store, cfg: ResolvedConfig, terms: string, opts?: SearchOptions): Promise<SearchResult[]>;

package/dist/cjs/commands/search.js

@@ -28,6 +28,7 @@ _export(exports, {
         return search;
     }
 });
+var _nodediagnostics_channel = require("node:diagnostics_channel");
 var _stemmer = require("stemmer");
 var _indexts = require("../config/index.js");
 var _queryts = require("../embed/query.js");
@@ -38,6 +39,7 @@ var _searcherrorts = require("../output/search-error.js");
 var _segmentts = require("../text/segment.js");
 var _scopets = require("./scope.js");
 var _signalsts = require("./signals.js");
+var _snapshotts = require("./snapshot.js");
 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];
@@ -225,6 +227,7 @@ function _unsupported_iterable_to_array(o, minLen) {
 }
 var SNIPPET_CHAR_LIMIT_DEFAULT = 80;
 var SNIPPET_COUNT_LIMIT_DEFAULT = 1;
+var searchCandidatesRead = (0, _nodediagnostics_channel.channel)('sensemaking.search.candidates-read');
 // Bare terms from an FTS5 query string: strips operators/quoting, not real terms, so the
 // snippet scan matches what the query matched -- FTS5 operators are uppercase-only, so this is too.
 function extractBareTerms(query) {
@@ -765,29 +768,35 @@ function hydrateSearchRows(_0, _1, _2, _3, _4) {
 }
 function search(store, cfg, terms) {
     var opts = arguments.length > 3 && arguments[3] !== void 0 ? arguments[3] : {};
+    var _opts_signal;
+    if ((_opts_signal = opts.signal) === null || _opts_signal === void 0 ? void 0 : _opts_signal.aborted) return Promise.reject(opts.signal.reason);
     return (0, _serialqueryts.serialQuery)(store, function() {
         return searchIndexed(store, cfg, terms, opts);
     });
 }
-function searchIndexed(store, cfg, terms, opts) {
+function readSearchScope(store, cfg, terms, opts) {
     return _async_to_generator(function() {
-        var effective, k, signals, allPaths, scopePaths, scopeActive, allowedPaths, err1, fetch, wantsVectors, e, semanticEnabled, _tmp, scope, whereJoin, whereCond, scopeCond, candidates, matchRows, hasEmptyPhrase, hasBareSyntaxOnly, syntaxError, err2, matchedPaths, chunkLines, chunkSimilarity, ref, where, similarityCol, selectStmt, rows, _iteratorNormalCompletion, _didIteratorError, _iteratorError, _iterator, _step, row;
+        var signature, effective, allPaths, scopePaths, allowedPaths, err, wantsVectors, semanticEligible, _tmp;
         return _ts_generator(this, function(_state) {
             switch(_state.label){
                 case 0:
-                    validateSearchOptions(opts);
+                    return [
+                        4,
+                        (0, _snapshotts.assertQuerySnapshot)(store, cfg)
+                    ];
+                case 1:
+                    signature = _state.sent();
                     effective = (0, _indexts.resolveSearch)(cfg, opts);
-                    k = effective.k, signals = effective.signals;
                     return [
                         4,
                         store.prepare('SELECT "path" FROM frontmatter')
                     ];
-                case 1:
+                case 2:
                     return [
                         4,
                         _state.sent().all()
                     ];
-                case 2:
+                case 3:
                     allPaths = _state.sent().map(function(r) {
                         return r.path;
                     });
@@ -795,65 +804,191 @@ function searchIndexed(store, cfg, terms, opts) {
                         4,
                         (0, _scopets.rawScope)(store, cfg, opts, allPaths)
                     ];
-                case 3:
-                    scopePaths = _state.sent();
-                    scopeActive = scopePaths.size < allPaths.length;
-                    _state.label = 4;
                 case 4:
+                    scopePaths = _state.sent();
+                    _state.label = 5;
+                case 5:
                     _state.trys.push([
-                        4,
-                        6,
+                        5,
+                        7,
                         ,
-                        7
+                        8
                     ]);
                     return [
                         4,
                         (0, _scopets.narrowByWhere)(store, scopePaths, effective.where)
                     ];
-                case 5:
+                case 6:
                     allowedPaths = _state.sent();
                     return [
                         3,
-                        7
+                        8
                     ];
-                case 6:
-                    err1 = _state.sent();
-                    throw (0, _searcherrorts.searchError)(err1, terms, effective.where);
                 case 7:
-                    fetch = Math.max(k * 3, 30);
-                    // A downloadable HF id proceeds -- getProvider fetches it lazily on consent. Only a
-                    // local path with missing files errors here, since nothing will ever fetch it for itself.
-                    wantsVectors = signals.vectors !== undefined;
+                    err = _state.sent();
+                    throw (0, _searcherrorts.searchError)(err, terms, effective.where);
+                case 8:
+                    wantsVectors = effective.signals.vectors !== undefined;
                     if (!wantsVectors) return [
                         3,
-                        9
+                        10
                     ];
-                    e = (0, _indexts.embedConfig)(cfg); // validate.ts guarantees this is set whenever "vectors" is declared
-                    if ((0, _storets.localModelMissing)(e)) {
-                        throw new _errorsts.SenseError('EMBED_MODEL_MISSING', 'preset "'.concat(effective.presetName, '" searches with vectors, but the local model path "').concat(e.model, '" is missing ').concat(_storets.MODEL_FILENAMES, '; point embed.model at a directory containing them, or drop "vectors" from that preset\'s signals to search without them'));
-                    }
                     return [
                         4,
                         (0, _queryts.ensureDocumentEmbeddings)(store, cfg, allowedPaths)
                     ];
-                case 8:
-                    _state.sent();
-                    _state.label = 9;
                 case 9:
+                    _state.sent();
+                    _state.label = 10;
+                case 10:
                     _tmp = wantsVectors;
                     if (!_tmp) return [
                         3,
-                        11
+                        12
                     ];
                     return [
                         4,
                         (0, _scopets.scopeHasEmbeddings)(store, cfg, allowedPaths)
                     ];
-                case 10:
-                    _tmp = _state.sent();
-                    _state.label = 11;
                 case 11:
-                    semanticEnabled = _tmp;
+                    _tmp = _state.sent();
+                    _state.label = 12;
+                case 12:
+                    semanticEligible = _tmp;
+                    return [
+                        2,
+                        {
+                            signature: signature,
+                            effective: effective,
+                            allPaths: allPaths,
+                            scopePaths: scopePaths,
+                            allowedPaths: allowedPaths,
+                            semanticEligible: semanticEligible
+                        }
+                    ];
+            }
+        });
+    })();
+}
+function needsSemanticPreparation(result) {
+    return !Array.isArray(result);
+}
+function searchIndexed(store, cfg, terms, opts) {
+    return _async_to_generator(function() {
+        var _opts_signal, _opts_signal1, _opts_signal2, _opts_signal3, _opts_signal4, initial, wantsVectors, e, prepared, preparedSignature, _opts_signal5, preflight, _opts_signal6, result;
+        return _ts_generator(this, function(_state) {
+            switch(_state.label){
+                case 0:
+                    validateSearchOptions(opts);
+                    initial = (0, _indexts.resolveSearch)(cfg, opts);
+                    (_opts_signal = opts.signal) === null || _opts_signal === void 0 ? void 0 : _opts_signal.throwIfAborted();
+                    // A downloadable HF id proceeds -- getProvider fetches it lazily on consent. Only a
+                    // local path with missing files errors here, since nothing will ever fetch it for itself.
+                    wantsVectors = initial.signals.vectors !== undefined;
+                    if (wantsVectors) {
+                        e = (0, _indexts.embedConfig)(cfg); // validate.ts guarantees this is set whenever "vectors" is declared
+                        if ((0, _storets.localModelMissing)(e)) {
+                            throw new _errorsts.SenseError('EMBED_MODEL_MISSING', 'preset "'.concat(initial.presetName, '" searches with vectors, but the local model path "').concat(e.model, '" is missing ').concat(_storets.MODEL_FILENAMES, '; point embed.model at a directory containing them, or drop "vectors" from that preset\'s signals to search without them'));
+                        }
+                    }
+                    if (!wantsVectors) return [
+                        3,
+                        3
+                    ];
+                    return [
+                        4,
+                        store.transaction(function() {
+                            return readSearchScope(store, cfg, terms, opts);
+                        })
+                    ];
+                case 1:
+                    preflight = _state.sent();
+                    (_opts_signal5 = opts.signal) === null || _opts_signal5 === void 0 ? void 0 : _opts_signal5.throwIfAborted();
+                    if (!preflight.semanticEligible) return [
+                        3,
+                        3
+                    ];
+                    preparedSignature = preflight.signature;
+                    return [
+                        4,
+                        (0, _queryts.prepareSemanticQuery)(cfg, terms, {
+                            signal: opts.signal
+                        })
+                    ];
+                case 2:
+                    prepared = _state.sent();
+                    (_opts_signal6 = opts.signal) === null || _opts_signal6 === void 0 ? void 0 : _opts_signal6.throwIfAborted();
+                    _state.label = 3;
+                case 3:
+                    (_opts_signal1 = opts.signal) === null || _opts_signal1 === void 0 ? void 0 : _opts_signal1.throwIfAborted();
+                    return [
+                        4,
+                        store.transaction(function() {
+                            return searchSnapshot(store, cfg, terms, opts, prepared, preparedSignature);
+                        })
+                    ];
+                case 4:
+                    result = _state.sent();
+                    (_opts_signal2 = opts.signal) === null || _opts_signal2 === void 0 ? void 0 : _opts_signal2.throwIfAborted();
+                    if (!needsSemanticPreparation(result)) return [
+                        2,
+                        result
+                    ];
+                    // The scope became vector-eligible after an empty/ineligible preflight. Leave that snapshot,
+                    // prepare once, then take a fresh final snapshot rather than waiting on the provider inside it.
+                    preparedSignature = result.signature;
+                    return [
+                        4,
+                        (0, _queryts.prepareSemanticQuery)(cfg, terms, {
+                            signal: opts.signal
+                        })
+                    ];
+                case 5:
+                    prepared = _state.sent();
+                    (_opts_signal3 = opts.signal) === null || _opts_signal3 === void 0 ? void 0 : _opts_signal3.throwIfAborted();
+                    return [
+                        4,
+                        store.transaction(function() {
+                            return searchSnapshot(store, cfg, terms, opts, prepared, preparedSignature);
+                        })
+                    ];
+                case 6:
+                    result = _state.sent();
+                    (_opts_signal4 = opts.signal) === null || _opts_signal4 === void 0 ? void 0 : _opts_signal4.throwIfAborted();
+                    if (needsSemanticPreparation(result)) throw new _errorsts.SenseError('INDEX_NOT_READY', 'the semantic search scope changed while its query was being prepared; retry the search against a stable published index');
+                    return [
+                        2,
+                        result
+                    ];
+            }
+        });
+    })();
+}
+function searchSnapshot(store, cfg, terms, opts, prepared, preparedSignature) {
+    return _async_to_generator(function() {
+        var _ref, signature, effective, allPaths, scopePaths, allowedPaths, semanticEligible, k, signals, fetch, scopeActive, semanticEnabled, scope, whereJoin, whereCond, scopeCond, candidates, matchRows, hasEmptyPhrase, hasBareSyntaxOnly, syntaxError, err1, matchedPaths, chunkLines, chunkSimilarity, ref, where, similarityCol, selectStmt, rows, _iteratorNormalCompletion, _didIteratorError, _iteratorError, _iterator, _step, row;
+        return _ts_generator(this, function(_state) {
+            switch(_state.label){
+                case 0:
+                    return [
+                        4,
+                        readSearchScope(store, cfg, terms, opts)
+                    ];
+                case 1:
+                    _ref = _state.sent(), signature = _ref.signature, effective = _ref.effective, allPaths = _ref.allPaths, scopePaths = _ref.scopePaths, allowedPaths = _ref.allowedPaths, semanticEligible = _ref.semanticEligible;
+                    if (prepared !== undefined && signature !== preparedSignature) {
+                        throw new _errorsts.SenseError('INDEX_NOT_READY', 'the index configuration changed while the semantic query was being prepared; retry after the current build finishes, or rebuild the index for this configuration');
+                    }
+                    if (semanticEligible && prepared === undefined) return [
+                        2,
+                        {
+                            signature: signature
+                        }
+                    ];
+                    k = effective.k, signals = effective.signals;
+                    fetch = Math.max(k * 3, 30);
+                    scopeActive = scopePaths.size < allPaths.length;
+                    semanticEnabled = semanticEligible && prepared !== undefined;
                     // --where applies inside the candidate query (a post-filter would drop matches ranked past
                     // the pool) and again on the final select, for link-derived rows.
                     scope = effective.where;
@@ -861,16 +996,16 @@ function searchIndexed(store, cfg, terms, opts) {
                     whereCond = scope ? "AND (".concat(scope, ")") : '';
                     if (!scopeActive) return [
                         3,
-                        13
+                        3
                     ];
                     return [
                         4,
                         (0, _scopets.materializeScope)(store, '_search_scope', scopePaths)
                     ];
-                case 12:
+                case 2:
                     _state.sent();
-                    _state.label = 13;
-                case 13:
+                    _state.label = 3;
+                case 3:
                     scopeCond = scopeActive ? 'AND content.path IN (SELECT "path" FROM _search_scope)' : '';
                     candidates = new Map();
                     matchRows = [];
@@ -880,32 +1015,32 @@ function searchIndexed(store, cfg, terms, opts) {
                     hasBareSyntaxOnly = RegExp("[()]", "u").test(terms.replace(/"[^"]*"/g, ' '));
                     if (!(signals.words !== undefined && terms.trim() !== '' && (RegExp("[\\u0041-\\u005A\\u0061-\\u007A\\u00AA\\u00B5\\u00BA\\u00C0-\\u00D6\\u00D8-\\u00F6\\u00F8-\\u02C1\\u02C6-\\u02D1\\u02E0-\\u02E4\\u02EC\\u02EE\\u0370-\\u0374\\u0376-\\u0377\\u037A-\\u037D\\u037F\\u0386\\u0388-\\u038A\\u038C\\u038E-\\u03A1\\u03A3-\\u03F5\\u03F7-\\u0481\\u048A-\\u052F\\u0531-\\u0556\\u0559\\u0560-\\u0588\\u05D0-\\u05EA\\u05EF-\\u05F2\\u0620-\\u064A\\u066E-\\u066F\\u0671-\\u06D3\\u06D5\\u06E5-\\u06E6\\u06EE-\\u06EF\\u06FA-\\u06FC\\u06FF\\u0710\\u0712-\\u072F\\u074D-\\u07A5\\u07B1\\u07CA-\\u07EA\\u07F4-\\u07F5\\u07FA\\u0800-\\u0815\\u081A\\u0824\\u0828\\u0840-\\u0858\\u0860-\\u086A\\u0870-\\u0887\\u0889-\\u088F\\u08A0-\\u08C9\\u0904-\\u0939\\u093D\\u0950\\u0958-\\u0961\\u0971-\\u0980\\u0985-\\u098C\\u098F-\\u0990\\u0993-\\u09A8\\u09AA-\\u09B0\\u09B2\\u09B6-\\u09B9\\u09BD\\u09CE\\u09DC-\\u09DD\\u09DF-\\u09E1\\u09F0-\\u09F1\\u09FC\\u0A05-\\u0A0A\\u0A0F-\\u0A10\\u0A13-\\u0A28\\u0A2A-\\u0A30\\u0A32-\\u0A33\\u0A35-\\u0A36\\u0A38-\\u0A39\\u0A59-\\u0A5C\\u0A5E\\u0A72-\\u0A74\\u0A85-\\u0A8D\\u0A8F-\\u0A91\\u0A93-\\u0AA8\\u0AAA-\\u0AB0\\u0AB2-\\u0AB3\\u0AB5-\\u0AB9\\u0ABD\\u0AD0\\u0AE0-\\u0AE1\\u0AF9\\u0B05-\\u0B0C\\u0B0F-\\u0B10\\u0B13-\\u0B28\\u0B2A-\\u0B30\\u0B32-\\u0B33\\u0B35-\\u0B39\\u0B3D\\u0B5C-\\u0B5D\\u0B5F-\\u0B61\\u0B71\\u0B83\\u0B85-\\u0B8A\\u0B8E-\\u0B90\\u0B92-\\u0B95\\u0B99-\\u0B9A\\u0B9C\\u0B9E-\\u0B9F\\u0BA3-\\u0BA4\\u0BA8-\\u0BAA\\u0BAE-\\u0BB9\\u0BD0\\u0C05-\\u0C0C\\u0C0E-\\u0C10\\u0C12-\\u0C28\\u0C2A-\\u0C39\\u0C3D\\u0C58-\\u0C5A\\u0C5C-\\u0C5D\\u0C60-\\u0C61\\u0C80\\u0C85-\\u0C8C\\u0C8E-\\u0C90\\u0C92-\\u0CA8\\u0CAA-\\u0CB3\\u0CB5-\\u0CB9\\u0CBD\\u0CDC-\\u0CDE\\u0CE0-\\u0CE1\\u0CF1-\\u0CF2\\u0D04-\\u0D0C\\u0D0E-\\u0D10\\u0D12-\\u0D3A\\u0D3D\\u0D4E\\u0D54-\\u0D56\\u0D5F-\\u0D61\\u0D7A-\\u0D7F\\u0D85-\\u0D96\\u0D9A-\\u0DB1\\u0DB3-\\u0DBB\\u0DBD\\u0DC0-\\u0DC6\\u0E01-\\u0E30\\u0E32-\\u0E33\\u0E40-\\u0E46\\u0E81-\\u0E82\\u0E84\\u0E86-\\u0E8A\\u0E8C-\\u0EA3\\u0EA5\\u0EA7-\\u0EB0\\u0EB2-\\u0EB3\\u0EBD\\u0EC0-\\u0EC4\\u0EC6\\u0EDC-\\u0EDF\\u0F00\\u0F40-\\u0F47\\u0F49-\\u0F6C\\u0F88-\\u0F8C\\u1000-\\u102A\\u103F\\u1050-\\u1055\\u105A-\\u105D\\u1061\\u1065-\\u1066\\u106E-\\u1070\\u1075-\\u1081\\u108E\\u10A0-\\u10C5\\u10C7\\u10CD\\u10D0-\\u10FA\\u10FC-\\u1248\\u124A-\\u124D\\u1250-\\u1256\\u1258\\u125A-\\u125D\\u1260-\\u1288\\u128A-\\u128D\\u1290-\\u12B0\\u12B2-\\u12B5\\u12B8-\\u12BE\\u12C0\\u12C2-\\u12C5\\u12C8-\\u12D6\\u12D8-\\u1310\\u1312-\\u1315\\u1318-\\u135A\\u1380-\\u138F\\u13A0-\\u13F5\\u13F8-\\u13FD\\u1401-\\u166C\\u166F-\\u167F\\u1681-\\u169A\\u16A0-\\u16EA\\u16F1-\\u16F8\\u1700-\\u1711\\u171F-\\u1731\\u1740-\\u1751\\u1760-\\u176C\\u176E-\\u1770\\u1780-\\u17B3\\u17D7\\u17DC\\u1820-\\u1878\\u1880-\\u1884\\u1887-\\u18A8\\u18AA\\u18B0-\\u18F5\\u1900-\\u191E\\u1950-\\u196D\\u1970-\\u1974\\u1980-\\u19AB\\u19B0-\\u19C9\\u1A00-\\u1A16\\u1A20-\\u1A54\\u1AA7\\u1B05-\\u1B33\\u1B45-\\u1B4C\\u1B83-\\u1BA0\\u1BAE-\\u1BAF\\u1BBA-\\u1BE5\\u1C00-\\u1C23\\u1C4D-\\u1C4F\\u1C5A-\\u1C7D\\u1C80-\\u1C8A\\u1C90-\\u1CBA\\u1CBD-\\u1CBF\\u1CE9-\\u1CEC\\u1CEE-\\u1CF3\\u1CF5-\\u1CF6\\u1CFA\\u1D00-\\u1DBF\\u1E00-\\u1F15\\u1F18-\\u1F1D\\u1F20-\\u1F45\\u1F48-\\u1F4D\\u1F50-\\u1F57\\u1F59\\u1F5B\\u1F5D\\u1F5F-\\u1F7D\\u1F80-\\u1FB4\\u1FB6-\\u1FBC\\u1FBE\\u1FC2-\\u1FC4\\u1FC6-\\u1FCC\\u1FD0-\\u1FD3\\u1FD6-\\u1FDB\\u1FE0-\\u1FEC\\u1FF2-\\u1FF4\\u1FF6-\\u1FFC\\u2071\\u207F\\u2090-\\u209C\\u2102\\u2107\\u210A-\\u2113\\u2115\\u2119-\\u211D\\u2124\\u2126\\u2128\\u212A-\\u212D\\u212F-\\u2139\\u213C-\\u213F\\u2145-\\u2149\\u214E\\u2183-\\u2184\\u2C00-\\u2CE4\\u2CEB-\\u2CEE\\u2CF2-\\u2CF3\\u2D00-\\u2D25\\u2D27\\u2D2D\\u2D30-\\u2D67\\u2D6F\\u2D80-\\u2D96\\u2DA0-\\u2DA6\\u2DA8-\\u2DAE\\u2DB0-\\u2DB6\\u2DB8-\\u2DBE\\u2DC0-\\u2DC6\\u2DC8-\\u2DCE\\u2DD0-\\u2DD6\\u2DD8-\\u2DDE\\u2E2F\\u3005-\\u3006\\u3031-\\u3035\\u303B-\\u303C\\u3041-\\u3096\\u309D-\\u309F\\u30A1-\\u30FA\\u30FC-\\u30FF\\u3105-\\u312F\\u3131-\\u318E\\u31A0-\\u31BF\\u31F0-\\u31FF\\u3400-\\u4DBF\\u4E00-\\uA48C\\uA4D0-\\uA4FD\\uA500-\\uA60C\\uA610-\\uA61F\\uA62A-\\uA62B\\uA640-\\uA66E\\uA67F-\\uA69D\\uA6A0-\\uA6E5\\uA717-\\uA71F\\uA722-\\uA788\\uA78B-\\uA7DC\\uA7F1-\\uA801\\uA803-\\uA805\\uA807-\\uA80A\\uA80C-\\uA822\\uA840-\\uA873\\uA882-\\uA8B3\\uA8F2-\\uA8F7\\uA8FB\\uA8FD-\\uA8FE\\uA90A-\\uA925\\uA930-\\uA946\\uA960-\\uA97C\\uA984-\\uA9B2\\uA9CF\\uA9E0-\\uA9E4\\uA9E6-\\uA9EF\\uA9FA-\\uA9FE\\uAA00-\\uAA28\\uAA40-\\uAA42\\uAA44-\\uAA4B\\uAA60-\\uAA76\\uAA7A\\uAA7E-\\uAAAF\\uAAB1\\uAAB5-\\uAAB6\\uAAB9-\\uAABD\\uAAC0\\uAAC2\\uAADB-\\uAADD\\uAAE0-\\uAAEA\\uAAF2-\\uAAF4\\uAB01-\\uAB06\\uAB09-\\uAB0E\\uAB11-\\uAB16\\uAB20-\\uAB26\\uAB28-\\uAB2E\\uAB30-\\uAB5A\\uAB5C-\\uAB69\\uAB70-\\uABE2\\uAC00-\\uD7A3\\uD7B0-\\uD7C6\\uD7CB-\\uD7FB\\uF900-\\uFA6D\\uFA70-\\uFAD9\\uFB00-\\uFB06\\uFB13-\\uFB17\\uFB1D\\uFB1F-\\uFB28\\uFB2A-\\uFB36\\uFB38-\\uFB3C\\uFB3E\\uFB40-\\uFB41\\uFB43-\\uFB44\\uFB46-\\uFBB1\\uFBD3-\\uFD3D\\uFD50-\\uFD8F\\uFD92-\\uFDC7\\uFDF0-\\uFDFB\\uFE70-\\uFE74\\uFE76-\\uFEFC\\uFF21-\\uFF3A\\uFF41-\\uFF5A\\uFF66-\\uFFBE\\uFFC2-\\uFFC7\\uFFCA-\\uFFCF\\uFFD2-\\uFFD7\\uFFDA-\\uFFDC\\u{10000}-\\u{1000B}\\u{1000D}-\\u{10026}\\u{10028}-\\u{1003A}\\u{1003C}-\\u{1003D}\\u{1003F}-\\u{1004D}\\u{10050}-\\u{1005D}\\u{10080}-\\u{100FA}\\u{10280}-\\u{1029C}\\u{102A0}-\\u{102D0}\\u{10300}-\\u{1031F}\\u{1032D}-\\u{10340}\\u{10342}-\\u{10349}\\u{10350}-\\u{10375}\\u{10380}-\\u{1039D}\\u{103A0}-\\u{103C3}\\u{103C8}-\\u{103CF}\\u{10400}-\\u{1049D}\\u{104B0}-\\u{104D3}\\u{104D8}-\\u{104FB}\\u{10500}-\\u{10527}\\u{10530}-\\u{10563}\\u{10570}-\\u{1057A}\\u{1057C}-\\u{1058A}\\u{1058C}-\\u{10592}\\u{10594}-\\u{10595}\\u{10597}-\\u{105A1}\\u{105A3}-\\u{105B1}\\u{105B3}-\\u{105B9}\\u{105BB}-\\u{105BC}\\u{105C0}-\\u{105F3}\\u{10600}-\\u{10736}\\u{10740}-\\u{10755}\\u{10760}-\\u{10767}\\u{10780}-\\u{10785}\\u{10787}-\\u{107B0}\\u{107B2}-\\u{107BA}\\u{10800}-\\u{10805}\\u{10808}\\u{1080A}-\\u{10835}\\u{10837}-\\u{10838}\\u{1083C}\\u{1083F}-\\u{10855}\\u{10860}-\\u{10876}\\u{10880}-\\u{1089E}\\u{108E0}-\\u{108F2}\\u{108F4}-\\u{108F5}\\u{10900}-\\u{10915}\\u{10920}-\\u{10939}\\u{10940}-\\u{10959}\\u{10980}-\\u{109B7}\\u{109BE}-\\u{109BF}\\u{10A00}\\u{10A10}-\\u{10A13}\\u{10A15}-\\u{10A17}\\u{10A19}-\\u{10A35}\\u{10A60}-\\u{10A7C}\\u{10A80}-\\u{10A9C}\\u{10AC0}-\\u{10AC7}\\u{10AC9}-\\u{10AE4}\\u{10B00}-\\u{10B35}\\u{10B40}-\\u{10B55}\\u{10B60}-\\u{10B72}\\u{10B80}-\\u{10B91}\\u{10C00}-\\u{10C48}\\u{10C80}-\\u{10CB2}\\u{10CC0}-\\u{10CF2}\\u{10D00}-\\u{10D23}\\u{10D4A}-\\u{10D65}\\u{10D6F}-\\u{10D85}\\u{10E80}-\\u{10EA9}\\u{10EB0}-\\u{10EB1}\\u{10EC2}-\\u{10EC7}\\u{10F00}-\\u{10F1C}\\u{10F27}\\u{10F30}-\\u{10F45}\\u{10F70}-\\u{10F81}\\u{10FB0}-\\u{10FC4}\\u{10FE0}-\\u{10FF6}\\u{11003}-\\u{11037}\\u{11071}-\\u{11072}\\u{11075}\\u{11083}-\\u{110AF}\\u{110D0}-\\u{110E8}\\u{11103}-\\u{11126}\\u{11144}\\u{11147}\\u{11150}-\\u{11172}\\u{11176}\\u{11183}-\\u{111B2}\\u{111C1}-\\u{111C4}\\u{111DA}\\u{111DC}\\u{11200}-\\u{11211}\\u{11213}-\\u{1122B}\\u{1123F}-\\u{11240}\\u{11280}-\\u{11286}\\u{11288}\\u{1128A}-\\u{1128D}\\u{1128F}-\\u{1129D}\\u{1129F}-\\u{112A8}\\u{112B0}-\\u{112DE}\\u{11305}-\\u{1130C}\\u{1130F}-\\u{11310}\\u{11313}-\\u{11328}\\u{1132A}-\\u{11330}\\u{11332}-\\u{11333}\\u{11335}-\\u{11339}\\u{1133D}\\u{11350}\\u{1135D}-\\u{11361}\\u{11380}-\\u{11389}\\u{1138B}\\u{1138E}\\u{11390}-\\u{113B5}\\u{113B7}\\u{113D1}\\u{113D3}\\u{11400}-\\u{11434}\\u{11447}-\\u{1144A}\\u{1145F}-\\u{11461}\\u{11480}-\\u{114AF}\\u{114C4}-\\u{114C5}\\u{114C7}\\u{11580}-\\u{115AE}\\u{115D8}-\\u{115DB}\\u{11600}-\\u{1162F}\\u{11644}\\u{11680}-\\u{116AA}\\u{116B8}\\u{11700}-\\u{1171A}\\u{11740}-\\u{11746}\\u{11800}-\\u{1182B}\\u{118A0}-\\u{118DF}\\u{118FF}-\\u{11906}\\u{11909}\\u{1190C}-\\u{11913}\\u{11915}-\\u{11916}\\u{11918}-\\u{1192F}\\u{1193F}\\u{11941}\\u{119A0}-\\u{119A7}\\u{119AA}-\\u{119D0}\\u{119E1}\\u{119E3}\\u{11A00}\\u{11A0B}-\\u{11A32}\\u{11A3A}\\u{11A50}\\u{11A5C}-\\u{11A89}\\u{11A9D}\\u{11AB0}-\\u{11AF8}\\u{11BC0}-\\u{11BE0}\\u{11C00}-\\u{11C08}\\u{11C0A}-\\u{11C2E}\\u{11C40}\\u{11C72}-\\u{11C8F}\\u{11D00}-\\u{11D06}\\u{11D08}-\\u{11D09}\\u{11D0B}-\\u{11D30}\\u{11D46}\\u{11D60}-\\u{11D65}\\u{11D67}-\\u{11D68}\\u{11D6A}-\\u{11D89}\\u{11D98}\\u{11DB0}-\\u{11DDB}\\u{11EE0}-\\u{11EF2}\\u{11F02}\\u{11F04}-\\u{11F10}\\u{11F12}-\\u{11F33}\\u{11FB0}\\u{12000}-\\u{12399}\\u{12480}-\\u{12543}\\u{12F90}-\\u{12FF0}\\u{13000}-\\u{1342F}\\u{13441}-\\u{13446}\\u{13460}-\\u{143FA}\\u{14400}-\\u{14646}\\u{16100}-\\u{1611D}\\u{16800}-\\u{16A38}\\u{16A40}-\\u{16A5E}\\u{16A70}-\\u{16ABE}\\u{16AD0}-\\u{16AED}\\u{16B00}-\\u{16B2F}\\u{16B40}-\\u{16B43}\\u{16B63}-\\u{16B77}\\u{16B7D}-\\u{16B8F}\\u{16D40}-\\u{16D6C}\\u{16E40}-\\u{16E7F}\\u{16EA0}-\\u{16EB8}\\u{16EBB}-\\u{16ED3}\\u{16F00}-\\u{16F4A}\\u{16F50}\\u{16F93}-\\u{16F9F}\\u{16FE0}-\\u{16FE1}\\u{16FE3}\\u{16FF2}-\\u{16FF3}\\u{17000}-\\u{18CD5}\\u{18CFF}-\\u{18D1E}\\u{18D80}-\\u{18DF2}\\u{1AFF0}-\\u{1AFF3}\\u{1AFF5}-\\u{1AFFB}\\u{1AFFD}-\\u{1AFFE}\\u{1B000}-\\u{1B122}\\u{1B132}\\u{1B150}-\\u{1B152}\\u{1B155}\\u{1B164}-\\u{1B167}\\u{1B170}-\\u{1B2FB}\\u{1BC00}-\\u{1BC6A}\\u{1BC70}-\\u{1BC7C}\\u{1BC80}-\\u{1BC88}\\u{1BC90}-\\u{1BC99}\\u{1D400}-\\u{1D454}\\u{1D456}-\\u{1D49C}\\u{1D49E}-\\u{1D49F}\\u{1D4A2}\\u{1D4A5}-\\u{1D4A6}\\u{1D4A9}-\\u{1D4AC}\\u{1D4AE}-\\u{1D4B9}\\u{1D4BB}\\u{1D4BD}-\\u{1D4C3}\\u{1D4C5}-\\u{1D505}\\u{1D507}-\\u{1D50A}\\u{1D50D}-\\u{1D514}\\u{1D516}-\\u{1D51C}\\u{1D51E}-\\u{1D539}\\u{1D53B}-\\u{1D53E}\\u{1D540}-\\u{1D544}\\u{1D546}\\u{1D54A}-\\u{1D550}\\u{1D552}-\\u{1D6A5}\\u{1D6A8}-\\u{1D6C0}\\u{1D6C2}-\\u{1D6DA}\\u{1D6DC}-\\u{1D6FA}\\u{1D6FC}-\\u{1D714}\\u{1D716}-\\u{1D734}\\u{1D736}-\\u{1D74E}\\u{1D750}-\\u{1D76E}\\u{1D770}-\\u{1D788}\\u{1D78A}-\\u{1D7A8}\\u{1D7AA}-\\u{1D7C2}\\u{1D7C4}-\\u{1D7CB}\\u{1DF00}-\\u{1DF1E}\\u{1DF25}-\\u{1DF2A}\\u{1E030}-\\u{1E06D}\\u{1E100}-\\u{1E12C}\\u{1E137}-\\u{1E13D}\\u{1E14E}\\u{1E290}-\\u{1E2AD}\\u{1E2C0}-\\u{1E2EB}\\u{1E4D0}-\\u{1E4EB}\\u{1E5D0}-\\u{1E5ED}\\u{1E5F0}\\u{1E6C0}-\\u{1E6DE}\\u{1E6E0}-\\u{1E6E2}\\u{1E6E4}-\\u{1E6E5}\\u{1E6E7}-\\u{1E6ED}\\u{1E6F0}-\\u{1E6F4}\\u{1E6FE}-\\u{1E6FF}\\u{1E7E0}-\\u{1E7E6}\\u{1E7E8}-\\u{1E7EB}\\u{1E7ED}-\\u{1E7EE}\\u{1E7F0}-\\u{1E7FE}\\u{1E800}-\\u{1E8C4}\\u{1E900}-\\u{1E943}\\u{1E94B}\\u{1EE00}-\\u{1EE03}\\u{1EE05}-\\u{1EE1F}\\u{1EE21}-\\u{1EE22}\\u{1EE24}\\u{1EE27}\\u{1EE29}-\\u{1EE32}\\u{1EE34}-\\u{1EE37}\\u{1EE39}\\u{1EE3B}\\u{1EE42}\\u{1EE47}\\u{1EE49}\\u{1EE4B}\\u{1EE4D}-\\u{1EE4F}\\u{1EE51}-\\u{1EE52}\\u{1EE54}\\u{1EE57}\\u{1EE59}\\u{1EE5B}\\u{1EE5D}\\u{1EE5F}\\u{1EE61}-\\u{1EE62}\\u{1EE64}\\u{1EE67}-\\u{1EE6A}\\u{1EE6C}-\\u{1EE72}\\u{1EE74}-\\u{1EE77}\\u{1EE79}-\\u{1EE7C}\\u{1EE7E}\\u{1EE80}-\\u{1EE89}\\u{1EE8B}-\\u{1EE9B}\\u{1EEA1}-\\u{1EEA3}\\u{1EEA5}-\\u{1EEA9}\\u{1EEAB}-\\u{1EEBB}\\u{20000}-\\u{2A6DF}\\u{2A700}-\\u{2B81D}\\u{2B820}-\\u{2CEAD}\\u{2CEB0}-\\u{2EBE0}\\u{2EBF0}-\\u{2EE5D}\\u{2F800}-\\u{2FA1D}\\u{30000}-\\u{3134A}\\u{31350}-\\u{33479}\\u0030-\\u0039\\u00B2-\\u00B3\\u00B9\\u00BC-\\u00BE\\u0660-\\u0669\\u06F0-\\u06F9\\u07C0-\\u07C9\\u0966-\\u096F\\u09E6-\\u09EF\\u09F4-\\u09F9\\u0A66-\\u0A6F\\u0AE6-\\u0AEF\\u0B66-\\u0B6F\\u0B72-\\u0B77\\u0BE6-\\u0BF2\\u0C66-\\u0C6F\\u0C78-\\u0C7E\\u0CE6-\\u0CEF\\u0D58-\\u0D5E\\u0D66-\\u0D78\\u0DE6-\\u0DEF\\u0E50-\\u0E59\\u0ED0-\\u0ED9\\u0F20-\\u0F33\\u1040-\\u1049\\u1090-\\u1099\\u1369-\\u137C\\u16EE-\\u16F0\\u17E0-\\u17E9\\u17F0-\\u17F9\\u1810-\\u1819\\u1946-\\u194F\\u19D0-\\u19DA\\u1A80-\\u1A89\\u1A90-\\u1A99\\u1B50-\\u1B59\\u1BB0-\\u1BB9\\u1C40-\\u1C49\\u1C50-\\u1C59\\u2070\\u2074-\\u2079\\u2080-\\u2089\\u2150-\\u2182\\u2185-\\u2189\\u2460-\\u249B\\u24EA-\\u24FF\\u2776-\\u2793\\u2CFD\\u3007\\u3021-\\u3029\\u3038-\\u303A\\u3192-\\u3195\\u3220-\\u3229\\u3248-\\u324F\\u3251-\\u325F\\u3280-\\u3289\\u32B1-\\u32BF\\uA620-\\uA629\\uA6E6-\\uA6EF\\uA830-\\uA835\\uA8D0-\\uA8D9\\uA900-\\uA909\\uA9D0-\\uA9D9\\uA9F0-\\uA9F9\\uAA50-\\uAA59\\uABF0-\\uABF9\\uFF10-\\uFF19\\u{10107}-\\u{10133}\\u{10140}-\\u{10178}\\u{1018A}-\\u{1018B}\\u{102E1}-\\u{102FB}\\u{10320}-\\u{10323}\\u{10341}\\u{1034A}\\u{103D1}-\\u{103D5}\\u{104A0}-\\u{104A9}\\u{10858}-\\u{1085F}\\u{10879}-\\u{1087F}\\u{108A7}-\\u{108AF}\\u{108FB}-\\u{108FF}\\u{10916}-\\u{1091B}\\u{109BC}-\\u{109BD}\\u{109C0}-\\u{109CF}\\u{109D2}-\\u{109FF}\\u{10A40}-\\u{10A48}\\u{10A7D}-\\u{10A7E}\\u{10A9D}-\\u{10A9F}\\u{10AEB}-\\u{10AEF}\\u{10B58}-\\u{10B5F}\\u{10B78}-\\u{10B7F}\\u{10BA9}-\\u{10BAF}\\u{10CFA}-\\u{10CFF}\\u{10D30}-\\u{10D39}\\u{10D40}-\\u{10D49}\\u{10E60}-\\u{10E7E}\\u{10F1D}-\\u{10F26}\\u{10F51}-\\u{10F54}\\u{10FC5}-\\u{10FCB}\\u{11052}-\\u{1106F}\\u{110F0}-\\u{110F9}\\u{11136}-\\u{1113F}\\u{111D0}-\\u{111D9}\\u{111E1}-\\u{111F4}\\u{112F0}-\\u{112F9}\\u{11450}-\\u{11459}\\u{114D0}-\\u{114D9}\\u{11650}-\\u{11659}\\u{116C0}-\\u{116C9}\\u{116D0}-\\u{116E3}\\u{11730}-\\u{1173B}\\u{118E0}-\\u{118F2}\\u{11950}-\\u{11959}\\u{11BF0}-\\u{11BF9}\\u{11C50}-\\u{11C6C}\\u{11D50}-\\u{11D59}\\u{11DA0}-\\u{11DA9}\\u{11DE0}-\\u{11DE9}\\u{11F50}-\\u{11F59}\\u{11FC0}-\\u{11FD4}\\u{12400}-\\u{1246E}\\u{16130}-\\u{16139}\\u{16A60}-\\u{16A69}\\u{16AC0}-\\u{16AC9}\\u{16B50}-\\u{16B59}\\u{16B5B}-\\u{16B61}\\u{16D70}-\\u{16D79}\\u{16E80}-\\u{16E96}\\u{16FF4}-\\u{16FF6}\\u{1CCF0}-\\u{1CCF9}\\u{1D2C0}-\\u{1D2D3}\\u{1D2E0}-\\u{1D2F3}\\u{1D360}-\\u{1D378}\\u{1D7CE}-\\u{1D7FF}\\u{1E140}-\\u{1E149}\\u{1E2F0}-\\u{1E2F9}\\u{1E4F0}-\\u{1E4F9}\\u{1E5F1}-\\u{1E5FA}\\u{1E8C7}-\\u{1E8CF}\\u{1E950}-\\u{1E959}\\u{1EC71}-\\u{1ECAB}\\u{1ECAD}-\\u{1ECAF}\\u{1ECB1}-\\u{1ECB4}\\u{1ED01}-\\u{1ED2D}\\u{1ED2F}-\\u{1ED3D}\\u{1F100}-\\u{1F10C}\\u{1FBF0}-\\u{1FBF9}_]", "u").test(terms) || hasBareSyntaxOnly) && !hasEmptyPhrase)) return [
                         3,
-                        17
+                        7
                     ];
                     syntaxError = (0, _searcherrorts.bareTermSyntaxError)(terms);
                     if (syntaxError) throw syntaxError;
-                    _state.label = 14;
-                case 14:
+                    _state.label = 4;
+                case 4:
                     _state.trys.push([
-                        14,
-                        16,
+                        4,
+                        6,
                         ,
-                        17
+                        7
                     ]);
                     return [
                         4,
                         (0, _signalsts.wordsCandidates)(store, candidates, terms, whereJoin, whereCond, scopeCond, fetch, signals.words)
                     ];
-                case 15:
+                case 5:
                     matchRows = _state.sent();
                     return [
                         3,
-                        17
+                        7
                     ];
-                case 16:
-                    err2 = _state.sent();
-                    throw (0, _searcherrorts.searchError)(err2, terms, scope);
-                case 17:
+                case 6:
+                    err1 = _state.sent();
+                    throw (0, _searcherrorts.searchError)(err1, terms, scope);
+                case 7:
                     // Every store's lexical `snippets` is NULL; the snippet text is always computed below.
                     // Distinguish from via='link' rows, which never appear in matchRows.
                     matchedPaths = new Set(matchRows.map(function(r) {
@@ -913,35 +1048,35 @@ function searchIndexed(store, cfg, terms, opts) {
                     }));
                     if (!(signals.links !== undefined)) return [
                         3,
-                        19
+                        9
                     ];
                     return [
                         4,
                         (0, _signalsts.linksCandidates)(store, candidates, matchRows, allPaths, allowedPaths, fetch, signals.links)
                     ];
-                case 18:
+                case 8:
                     _state.sent();
-                    _state.label = 19;
-                case 19:
+                    _state.label = 9;
+                case 9:
                     chunkLines = new Map();
                     chunkSimilarity = new Map();
-                    if (!semanticEnabled) return [
+                    if (!(semanticEnabled && signals.vectors !== undefined && prepared !== undefined)) return [
                         3,
-                        21
+                        11
                     ];
                     return [
                         4,
-                        (0, _signalsts.vectorsCandidates)(store, cfg, candidates, terms, fetch, allowedPaths, signals.vectors)
+                        (0, _signalsts.vectorsCandidates)(store, prepared, candidates, fetch, allowedPaths, allPaths.length, signals.vectors)
                     ];
-                case 20:
+                case 10:
                     ref = _state.sent(), chunkLines = ref.chunkLines, chunkSimilarity = ref.chunkSimilarity, ref;
-                    _state.label = 21;
-                case 21:
+                    _state.label = 11;
+                case 11:
                     return [
                         4,
                         store.exec('DROP TABLE IF EXISTS _search')
                     ];
-                case 22:
+                case 12:
                     _state.sent();
                     // DOUBLE, not REAL: sqlite's REAL is an 8-byte double but duckdb's is a 4-byte float, and the
                     // rounded score/similarity are printed at full precision in rows.
@@ -949,11 +1084,11 @@ function searchIndexed(store, cfg, terms, opts) {
                         4,
                         store.exec('CREATE TEMP TABLE _search ("path" TEXT PRIMARY KEY, score DOUBLE, via TEXT, lines TEXT, similarity DOUBLE)')
                     ];
-                case 23:
+                case 13:
                     _state.sent();
                     if (!(candidates.size > 0)) return [
                         3,
-                        25
+                        15
                     ];
                     return [
                         4,
@@ -969,10 +1104,10 @@ function searchIndexed(store, cfg, terms, opts) {
                             ];
                         }))
                     ];
-                case 24:
+                case 14:
                     _state.sent();
-                    _state.label = 25;
-                case 25:
+                    _state.label = 15;
+                case 15:
                     // Reapplies --where even though _search is already scope+where filtered, since the join to
                     // frontmatter is already needed for the path column.
                     where = scope ? "WHERE (".concat(scope, ")") : '';
@@ -981,16 +1116,21 @@ function searchIndexed(store, cfg, terms, opts) {
                     similarityCol = semanticEnabled ? ', _search.similarity' : '';
                     return [
                         4,
-                        store.prepare('SELECT f."path" AS path, content.title, content.summary, NULL AS snippets, _search.via, round(_search.score, 4) AS score, _search.lines'.concat(similarityCol, '\n       FROM _search JOIN frontmatter f ON f."path" = _search."path" JOIN content ON content.path = _search."path"\n       ').concat(where, " ORDER BY _search.score DESC LIMIT ?"))
+                        store.prepare('SELECT f."path" AS path, content.title, content.summary, NULL AS snippets, _search.via, round(_search.score, 4) AS score, _search.lines'.concat(similarityCol, '\n       FROM _search JOIN frontmatter f ON f."path" = _search."path" JOIN content ON content.path = _search."path"\n       ').concat(where, ' ORDER BY _search.score DESC, _search."path" ASC LIMIT ?'))
                     ];
-                case 26:
+                case 16:
                     selectStmt = _state.sent();
                     return [
                         4,
                         selectStmt.all(k)
                     ];
-                case 27:
+                case 17:
                     rows = _state.sent();
+                    if (searchCandidatesRead.hasSubscribers) searchCandidatesRead.publish({
+                        paths: rows.map(function(row) {
+                            return row.path;
+                        })
+                    });
                     _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
                     try {
                         for(_iterator = rows[Symbol.iterator](); !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
@@ -1015,7 +1155,7 @@ function searchIndexed(store, cfg, terms, opts) {
                         4,
                         hydrateSearchRows(store, cfg, rows, matchedPaths, terms, opts)
                     ];
-                case 28:
+                case 18:
                     _state.sent();
                     return [
                         2,