sensemaking 0.24.7 → 0.25.0

package/dist/cjs/store/index.js

@@ -1,5 +1,5 @@
-// Rows -> a backing store: registry + openStore(cfg). Parsing lives in scan.ts; everything
-// beyond frontmatter + content lives in src/features/.
+// Rows -> a backing store: registry + the public open/build boundary. Parsing lives in scan.ts;
+// everything beyond frontmatter + content lives in src/features/.
 "use strict";
 Object.defineProperty(exports, "__esModule", {
     value: true
@@ -20,6 +20,9 @@ _export(exports, {
     get SCHEMA_VERSION () {
         return _opents1.SCHEMA_VERSION;
     },
+    get buildIndex () {
+        return buildIndex;
+    },
     get clearCache () {
         return _cachets.clearCache;
     },
@@ -29,22 +32,31 @@ _export(exports, {
     get getMeta () {
         return _sharedts.getMeta;
     },
+    get lexicalReadiness () {
+        return lexicalReadiness;
+    },
     get openStore () {
         return openStore;
     },
+    get openStoreFor () {
+        return openStoreFor;
+    },
     get setMeta () {
         return _sharedts.setMeta;
+    },
+    get storeFilename () {
+        return storeFilename;
     }
 });
 var _indexts = require("../config/index.js");
 var _errorsts = require("../errors.js");
+var _cachets = require("./cache.js");
 var _opents = require("./duckdb/open.js");
 var _storets = require("./duckdb/store.js");
 var _opents1 = require("./sqlite/open.js");
 var _storets1 = require("./sqlite/store.js");
 var _opents2 = require("./turso/open.js");
 var _storets2 = require("./turso/store.js");
-var _cachets = require("./cache.js");
 var _opents3 = require("./open.js");
 var _sharedts = require("./shared.js");
 var _typests = require("./types.js");
@@ -74,6 +86,48 @@ 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 _object_without_properties(source, excluded) {
+    if (source == null) return {};
+    var target = {}, sourceKeys, key, i;
+    if (typeof Reflect !== "undefined" && Reflect.ownKeys) {
+        sourceKeys = Reflect.ownKeys(Object(source));
+        for(i = 0; i < sourceKeys.length; i++){
+            key = sourceKeys[i];
+            if (excluded.indexOf(key) >= 0) continue;
+            if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue;
+            target[key] = source[key];
+        }
+        return target;
+    }
+    target = _object_without_properties_loose(source, excluded);
+    if (Object.getOwnPropertySymbols) {
+        sourceKeys = Object.getOwnPropertySymbols(source);
+        for(i = 0; i < sourceKeys.length; i++){
+            key = sourceKeys[i];
+            if (excluded.indexOf(key) >= 0) continue;
+            if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue;
+            target[key] = source[key];
+        }
+    }
+    return target;
+}
+function _object_without_properties_loose(source, excluded) {
+    if (source == null) return {};
+    var target = {}, sourceKeys = Object.getOwnPropertyNames(source), key, i;
+    for(i = 0; i < sourceKeys.length; i++){
+        key = sourceKeys[i];
+        if (excluded.indexOf(key) >= 0) continue;
+        if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue;
+        target[key] = source[key];
+    }
+    return target;
+}
 function _ts_generator(thisArg, body) {
     var f, y, t, _ = {
         label: 0,
@@ -173,19 +227,20 @@ function _ts_generator(thisArg, body) {
         };
     }
 }
-// Capabilities are checked against the registry entry before opening (no wasted connect/reconcile
-// work for a config that cannot be satisfied), then the store itself opens.
 var REGISTRY = {
     sqlite: {
         capabilities: _storets1.CAPABILITIES,
+        filename: _opents1.DB_FILENAME,
         open: _opents1.openSqlite
     },
     duckdb: {
         capabilities: _storets.CAPABILITIES,
+        filename: _opents.DB_FILENAME,
         open: _opents.openDuckdb
     },
     turso: {
         capabilities: _storets2.CAPABILITIES,
+        filename: _opents2.DB_FILENAME,
         open: _opents2.openTurso
     }
 };
@@ -194,22 +249,176 @@ function entryFor(name) {
     if (!entry) throw new _errorsts.SenseError('STORE_UNKNOWN', 'unknown backing store "'.concat(name, '"; available: ').concat(Object.keys(REGISTRY).join(', ')));
     return entry;
 }
-function openStore(cfg) {
+function requirementsFor(cfg) {
+    var requirements = new Set([
+        'core',
+        'lexical'
+    ]);
+    if ((0, _indexts.anyPresetEmbeds)(cfg)) requirements.add('vectors');
+    return requirements;
+}
+function validateRequirements(cfg, entry, requirements) {
+    if (requirements.has('vectors') && (0, _indexts.anyPresetEmbeds)(cfg) && !entry.capabilities.has('vectors')) {
+        var name = (0, _indexts.storeName)(cfg);
+        throw new _errorsts.SenseError('STORE_CAPABILITY_MISSING', 'store "'.concat(name, '" does not implement "vectors" in this build, but this config\'s "embed" block is in use by at least one preset; remove or narrow it, or set "store" to a store that supports vectors (sqlite)'));
+    }
+}
+function openStoreFor(cfg, options) {
     return _async_to_generator(function() {
-        var name, entry;
+        var _options_requirements, entry;
         return _ts_generator(this, function(_state) {
-            name = (0, _indexts.storeName)(cfg);
-            entry = entryFor(name);
-            // The one unambiguous, config-level capability need: an embed block some preset actually uses
-            // for vectors. Lexical search has no such signal at this level (every preset defaults to "words"), so a store lacking it fails loudly at first use.
-            if ((0, _indexts.anyPresetEmbeds)(cfg) && !entry.capabilities.has('vectors')) {
-                throw new _errorsts.SenseError('STORE_CAPABILITY_MISSING', 'store "'.concat(name, '" does not implement "vectors" in this build, but this config\'s "embed" block is in use by at least one preset; remove or narrow it, or set "store" to a store that supports vectors (sqlite)'));
-            }
+            entry = entryFor((0, _indexts.storeName)(cfg));
+            validateRequirements(cfg, entry, (_options_requirements = options.requirements) !== null && _options_requirements !== void 0 ? _options_requirements : new Set([
+                'core'
+            ]));
             return [
                 2,
-                entry.open(cfg)
+                entry.open(cfg, options)
             ];
         });
     })();
 }
+function openStore(_0) {
+    return _async_to_generator(function(cfg) {
+        var options, buildEnabled;
+        var _arguments = arguments;
+        return _ts_generator(this, function(_state) {
+            options = _arguments.length > 1 && _arguments[1] !== void 0 ? _arguments[1] : {};
+            buildEnabled = options.build !== false;
+            return [
+                2,
+                openStoreFor(cfg, {
+                    build: buildEnabled,
+                    requirements: buildEnabled ? requirementsFor(cfg) : new Set([
+                        'core'
+                    ])
+                })
+            ];
+        });
+    }).apply(this, arguments);
+}
+function lexicalReadiness(cfg) {
+    return _async_to_generator(function() {
+        var opened, err;
+        return _ts_generator(this, function(_state) {
+            switch(_state.label){
+                case 0:
+                    _state.trys.push([
+                        0,
+                        2,
+                        ,
+                        3
+                    ]);
+                    return [
+                        4,
+                        openStoreFor(cfg, {
+                            build: false,
+                            requirements: new Set([
+                                'core',
+                                'lexical'
+                            ])
+                        })
+                    ];
+                case 1:
+                    opened = _state.sent();
+                    return [
+                        3,
+                        3
+                    ];
+                case 2:
+                    err = _state.sent();
+                    if (_instanceof(err, _errorsts.SenseError) && err.code === 'INDEX_NOT_READY') return [
+                        2,
+                        {
+                            ready: false,
+                            error: err.message
+                        }
+                    ];
+                    throw err;
+                case 3:
+                    _state.trys.push([
+                        3,
+                        ,
+                        4,
+                        6
+                    ]);
+                    return [
+                        2,
+                        {
+                            ready: true,
+                            error: null
+                        }
+                    ];
+                case 4:
+                    return [
+                        4,
+                        opened.store.close()
+                    ];
+                case 5:
+                    _state.sent();
+                    return [
+                        7
+                    ];
+                case 6:
+                    return [
+                        2
+                    ];
+            }
+        });
+    })();
+}
+function buildIndex(_0) {
+    return _async_to_generator(function(cfg) {
+        var options, opened, _store, result;
+        var _arguments = arguments;
+        return _ts_generator(this, function(_state) {
+            switch(_state.label){
+                case 0:
+                    options = _arguments.length > 1 && _arguments[1] !== void 0 ? _arguments[1] : {};
+                    if (options.force) (0, _cachets.clearCache)(cfg);
+                    return [
+                        4,
+                        openStoreFor(cfg, {
+                            build: true,
+                            requirements: requirementsFor(cfg)
+                        })
+                    ];
+                case 1:
+                    opened = _state.sent();
+                    _state.label = 2;
+                case 2:
+                    _state.trys.push([
+                        2,
+                        ,
+                        3,
+                        5
+                    ]);
+                    _store = opened.store, result = _object_without_properties(opened, [
+                        "store"
+                    ]);
+                    return [
+                        2,
+                        result
+                    ];
+                case 3:
+                    return [
+                        4,
+                        opened.store.close()
+                    ];
+                case 4:
+                    _state.sent();
+                    return [
+                        7
+                    ];
+                case 5:
+                    return [
+                        2
+                    ];
+            }
+        });
+    }).apply(this, arguments);
+}
+function storeFilename(cfg) {
+    return entryFor((0, _indexts.storeName)(cfg)).filename;
+}
 /* CJS INTEROP */ if (exports.__esModule && exports.default) { try { Object.defineProperty(exports.default, '__esModule', { value: true }); for (var key in exports) { exports.default[key] = exports[key]; } } catch (_) {}; module.exports = exports.default; }

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

@@ -1 +1 @@
-{"version":3,"sources":["/Users/kevin/Dev/OpenSource/ai/sensemaking/src/store/index.ts"],"sourcesContent":["// Rows -> a backing store: registry + openStore(cfg). Parsing lives in scan.ts; everything\n// beyond frontmatter + content lives in src/features/.\n\nimport type { ResolvedConfig, StoreName } from '../config/index.ts';\nimport { anyPresetEmbeds, storeName } from '../config/index.ts';\nimport { SenseError } from '../errors.ts';\nimport { openDuckdb } from './duckdb/open.ts';\nimport { CAPABILITIES as DUCKDB_CAPABILITIES } from './duckdb/store.ts';\nimport type { OpenResult } from './open.ts';\nimport { openSqlite } from './sqlite/open.ts';\nimport { CAPABILITIES as SQLITE_CAPABILITIES } from './sqlite/store.ts';\nimport { openTurso } from './turso/open.ts';\nimport { CAPABILITIES as TURSO_CAPABILITIES } from './turso/store.ts';\nimport type { Capability } from './types.ts';\n\ninterface StoreEntry {\n  capabilities: ReadonlySet<Capability>;\n  open: (cfg: ResolvedConfig) => Promise<OpenResult>;\n}\n\n// Capabilities are checked against the registry entry before opening (no wasted connect/reconcile\n// work for a config that cannot be satisfied), then the store itself opens.\nconst REGISTRY: Record<StoreName, StoreEntry> = {\n  sqlite: { capabilities: SQLITE_CAPABILITIES, open: openSqlite },\n  duckdb: { capabilities: DUCKDB_CAPABILITIES, open: openDuckdb },\n  turso: { capabilities: TURSO_CAPABILITIES, open: openTurso },\n};\n\nfunction entryFor(name: StoreName): StoreEntry {\n  const entry = REGISTRY[name];\n  if (!entry) throw new SenseError('STORE_UNKNOWN', `unknown backing store \"${name}\"; available: ${Object.keys(REGISTRY).join(', ')}`);\n  return entry;\n}\n\nexport async function openStore(cfg: ResolvedConfig): Promise<OpenResult> {\n  const name = storeName(cfg);\n  const entry = entryFor(name);\n\n  // The one unambiguous, config-level capability need: an embed block some preset actually uses\n  // for vectors. Lexical search has no such signal at this level (every preset defaults to \"words\"), so a store lacking it fails loudly at first use.\n  if (anyPresetEmbeds(cfg) && !entry.capabilities.has('vectors')) {\n    throw new SenseError('STORE_CAPABILITY_MISSING', `store \"${name}\" does not implement \"vectors\" in this build, but this config's \"embed\" block is in use by at least one preset; remove or narrow it, or set \"store\" to a store that supports vectors (sqlite)`);\n  }\n\n  return entry.open(cfg);\n}\n\nexport { clearCache } from './cache.ts';\nexport type { OpenResult } from './open.ts';\nexport { docCount } from './open.ts';\nexport { getMeta, setMeta } from './shared.ts';\nexport { DB_FILENAME, SCHEMA_VERSION } from './sqlite/open.ts';\nexport type { Stages } from './stages.ts';\nexport type { Capability, Connection, DocumentStore, LexicalHit, LexicalIndex, LexicalQueryOptions, RawStatement, RunResult, SqlSession, Statement, Store, VectorCandidate, VectorSimilar, VectorStore, VectorWriteRow } from './types.ts';\nexport { CAPABILITY_NAMES } from './types.ts';\n"],"names":["CAPABILITY_NAMES","DB_FILENAME","SCHEMA_VERSION","clearCache","docCount","getMeta","openStore","setMeta","REGISTRY","sqlite","capabilities","SQLITE_CAPABILITIES","open","openSqlite","duckdb","DUCKDB_CAPABILITIES","openDuckdb","turso","TURSO_CAPABILITIES","openTurso","entryFor","name","entry","SenseError","Object","keys","join","cfg","storeName","anyPresetEmbeds","has"],"mappings":"AAAA,2FAA2F;AAC3F,uDAAuD;;;;;;;;;;;;QAqD9CA;eAAAA,yBAAgB;;QAHhBC;eAAAA,oBAAW;;QAAEC;eAAAA,uBAAc;;QAJ3BC;eAAAA,mBAAU;;QAEVC;eAAAA,iBAAQ;;QACRC;eAAAA,iBAAO;;QAhBMC;eAAAA;;QAgBJC;eAAAA,iBAAO;;;uBA9CkB;wBAChB;sBACA;uBACyB;uBAEzB;wBACyB;uBAC1B;wBACyB;uBAmCxB;uBAEF;wBACQ;uBAIA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAlCjC,kGAAkG;AAClG,4EAA4E;AAC5E,IAAMC,WAA0C;IAC9CC,QAAQ;QAAEC,cAAcC,sBAAmB;QAAEC,MAAMC,mBAAU;IAAC;IAC9DC,QAAQ;QAAEJ,cAAcK,qBAAmB;QAAEH,MAAMI,kBAAU;IAAC;IAC9DC,OAAO;QAAEP,cAAcQ,sBAAkB;QAAEN,MAAMO,kBAAS;IAAC;AAC7D;AAEA,SAASC,SAASC,IAAe;IAC/B,IAAMC,QAAQd,QAAQ,CAACa,KAAK;IAC5B,IAAI,CAACC,OAAO,MAAM,IAAIC,oBAAU,CAAC,iBAAiB,AAAC,0BAA8CC,OAArBH,MAAK,kBAAiD,OAAjCG,OAAOC,IAAI,CAACjB,UAAUkB,IAAI,CAAC;IAC5H,OAAOJ;AACT;AAEO,SAAehB,UAAUqB,GAAmB;;YAC3CN,MACAC;;YADAD,OAAOO,IAAAA,kBAAS,EAACD;YACjBL,QAAQF,SAASC;YAEvB,8FAA8F;YAC9F,oJAAoJ;YACpJ,IAAIQ,IAAAA,wBAAe,EAACF,QAAQ,CAACL,MAAMZ,YAAY,CAACoB,GAAG,CAAC,YAAY;gBAC9D,MAAM,IAAIP,oBAAU,CAAC,4BAA4B,AAAC,UAAc,OAALF,MAAK;YAClE;YAEA;;gBAAOC,MAAMV,IAAI,CAACe;;;IACpB"}
+{"version":3,"sources":["/Users/kevin/Dev/OpenSource/ai/sensemaking/src/store/index.ts"],"sourcesContent":["// Rows -> a backing store: registry + the public open/build boundary. Parsing lives in scan.ts;\n// everything beyond frontmatter + content lives in src/features/.\n\nimport type { ResolvedConfig, StoreName } from '../config/index.ts';\nimport { anyPresetEmbeds, storeName } from '../config/index.ts';\nimport { SenseError } from '../errors.ts';\nimport { clearCache } from './cache.ts';\nimport { DB_FILENAME as DUCKDB_FILENAME, openDuckdb } from './duckdb/open.ts';\nimport { CAPABILITIES as DUCKDB_CAPABILITIES } from './duckdb/store.ts';\nimport type { BuildRequirement, InternalOpenOptions, OpenOptions, OpenResult } from './open.ts';\nimport { openSqlite, DB_FILENAME as SQLITE_FILENAME } from './sqlite/open.ts';\nimport { CAPABILITIES as SQLITE_CAPABILITIES } from './sqlite/store.ts';\nimport type { Stages } from './stages.ts';\nimport { openTurso, DB_FILENAME as TURSO_FILENAME } from './turso/open.ts';\nimport { CAPABILITIES as TURSO_CAPABILITIES } from './turso/store.ts';\nimport type { Capability } from './types.ts';\n\ninterface StoreEntry {\n  capabilities: ReadonlySet<Capability>;\n  filename: string;\n  open: (cfg: ResolvedConfig, options?: InternalOpenOptions) => Promise<OpenResult>;\n}\n\nconst REGISTRY: Record<StoreName, StoreEntry> = {\n  sqlite: { capabilities: SQLITE_CAPABILITIES, filename: SQLITE_FILENAME, open: openSqlite },\n  duckdb: { capabilities: DUCKDB_CAPABILITIES, filename: DUCKDB_FILENAME, open: openDuckdb },\n  turso: { capabilities: TURSO_CAPABILITIES, filename: TURSO_FILENAME, open: openTurso },\n};\n\nfunction entryFor(name: StoreName): StoreEntry {\n  const entry = REGISTRY[name];\n  if (!entry) throw new SenseError('STORE_UNKNOWN', `unknown backing store \"${name}\"; available: ${Object.keys(REGISTRY).join(', ')}`);\n  return entry;\n}\n\nfunction requirementsFor(cfg: ResolvedConfig): Set<BuildRequirement> {\n  const requirements = new Set<BuildRequirement>(['core', 'lexical']);\n  if (anyPresetEmbeds(cfg)) requirements.add('vectors');\n  return requirements;\n}\n\nfunction validateRequirements(cfg: ResolvedConfig, entry: StoreEntry, requirements: ReadonlySet<BuildRequirement>): void {\n  if (requirements.has('vectors') && anyPresetEmbeds(cfg) && !entry.capabilities.has('vectors')) {\n    const name = storeName(cfg);\n    throw new SenseError('STORE_CAPABILITY_MISSING', `store \"${name}\" does not implement \"vectors\" in this build, but this config's \"embed\" block is in use by at least one preset; remove or narrow it, or set \"store\" to a store that supports vectors (sqlite)`);\n  }\n}\n\nexport async function openStoreFor(cfg: ResolvedConfig, options: InternalOpenOptions): Promise<OpenResult> {\n  const entry = entryFor(storeName(cfg));\n  validateRequirements(cfg, entry, options.requirements ?? new Set<BuildRequirement>(['core']));\n  return entry.open(cfg, options);\n}\n\nexport async function openStore(cfg: ResolvedConfig, options: OpenOptions = {}): Promise<OpenResult> {\n  const buildEnabled = options.build !== false;\n  return openStoreFor(cfg, {\n    build: buildEnabled,\n    requirements: buildEnabled ? requirementsFor(cfg) : new Set<BuildRequirement>(['core']),\n  });\n}\n\nexport async function lexicalReadiness(cfg: ResolvedConfig): Promise<{ ready: boolean; error: string | null }> {\n  let opened: OpenResult;\n  try {\n    opened = await openStoreFor(cfg, { build: false, requirements: new Set<BuildRequirement>(['core', 'lexical']) });\n  } catch (err) {\n    if (err instanceof SenseError && err.code === 'INDEX_NOT_READY') return { ready: false, error: err.message };\n    throw err;\n  }\n  try {\n    return { ready: true, error: null };\n  } finally {\n    await opened.store.close();\n  }\n}\n\nexport interface BuildOptions {\n  force?: boolean;\n}\n\nexport interface BuildResult {\n  cfg: ResolvedConfig;\n  dbPath: string;\n  parsed: number;\n  warnings: string[];\n  stages: Stages;\n}\n\nexport async function buildIndex(cfg: ResolvedConfig, options: BuildOptions = {}): Promise<BuildResult> {\n  if (options.force) clearCache(cfg);\n  const opened = await openStoreFor(cfg, { build: true, requirements: requirementsFor(cfg) });\n  try {\n    const { store: _store, ...result } = opened;\n    return result;\n  } finally {\n    await opened.store.close();\n  }\n}\n\nexport function storeFilename(cfg: ResolvedConfig): string {\n  return entryFor(storeName(cfg)).filename;\n}\n\nexport type { OpenOptions, OpenResult } from './open.ts';\nexport { docCount } from './open.ts';\nexport { getMeta, setMeta } from './shared.ts';\nexport { DB_FILENAME, SCHEMA_VERSION } from './sqlite/open.ts';\nexport type { Stages } from './stages.ts';\nexport type { Capability, Connection, DocumentStore, LexicalHit, LexicalIndex, LexicalQueryOptions, RawStatement, RunResult, SqlSession, Statement, Store, VectorCandidate, VectorSimilar, VectorStore, VectorWriteRow } from './types.ts';\nexport { CAPABILITY_NAMES } from './types.ts';\nexport { clearCache };\n"],"names":["CAPABILITY_NAMES","DB_FILENAME","SCHEMA_VERSION","buildIndex","clearCache","docCount","getMeta","lexicalReadiness","openStore","openStoreFor","setMeta","storeFilename","REGISTRY","sqlite","capabilities","SQLITE_CAPABILITIES","filename","SQLITE_FILENAME","open","openSqlite","duckdb","DUCKDB_CAPABILITIES","DUCKDB_FILENAME","openDuckdb","turso","TURSO_CAPABILITIES","TURSO_FILENAME","openTurso","entryFor","name","entry","SenseError","Object","keys","join","requirementsFor","cfg","requirements","Set","anyPresetEmbeds","add","validateRequirements","has","storeName","options","buildEnabled","build","opened","err","code","ready","error","message","store","close","_store","result","force"],"mappings":"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"}

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

@@ -1,6 +1,13 @@
 import type { ResolvedConfig } from '../config/index.js';
 import type { Stages } from './stages.js';
 import type { OpenDialect, Store } from './types.js';
+export type BuildRequirement = 'core' | 'lexical' | 'vectors';
+export interface OpenOptions {
+    build?: boolean;
+}
+export interface InternalOpenOptions extends OpenOptions {
+    requirements?: ReadonlySet<BuildRequirement>;
+}
 export interface OpenResult {
     store: Store;
     cfg: ResolvedConfig;
@@ -9,5 +16,6 @@ export interface OpenResult {
     warnings: string[];
     stages: Stages;
 }
-export declare function openWithDialect<Handle>(cfg: ResolvedConfig, dialect: OpenDialect<Handle>): Promise<OpenResult>;
+export declare function prepareDocumentEmbeddings(store: Store, cfg: ResolvedConfig, allowed?: ReadonlySet<string>): Promise<void>;
+export declare function openWithDialect<Handle>(input: ResolvedConfig, dialect: OpenDialect<Handle>, options?: InternalOpenOptions): Promise<OpenResult>;
 export declare function docCount(store: Store): Promise<number>;

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

@@ -1,6 +1,13 @@
 import type { ResolvedConfig } from '../config/index.js';
 import type { Stages } from './stages.js';
 import type { OpenDialect, Store } from './types.js';
+export type BuildRequirement = 'core' | 'lexical' | 'vectors';
+export interface OpenOptions {
+    build?: boolean;
+}
+export interface InternalOpenOptions extends OpenOptions {
+    requirements?: ReadonlySet<BuildRequirement>;
+}
 export interface OpenResult {
     store: Store;
     cfg: ResolvedConfig;
@@ -9,5 +16,6 @@ export interface OpenResult {
     warnings: string[];
     stages: Stages;
 }
-export declare function openWithDialect<Handle>(cfg: ResolvedConfig, dialect: OpenDialect<Handle>): Promise<OpenResult>;
+export declare function prepareDocumentEmbeddings(store: Store, cfg: ResolvedConfig, allowed?: ReadonlySet<string>): Promise<void>;
+export declare function openWithDialect<Handle>(input: ResolvedConfig, dialect: OpenDialect<Handle>, options?: InternalOpenOptions): Promise<OpenResult>;
 export declare function docCount(store: Store): Promise<number>;