sensemaking 0.24.7 → 0.25.0

package/dist/cjs/store/open.js

@@ -14,6 +14,9 @@ _export(exports, {
     },
     get openWithDialect () {
         return openWithDialect;
+    },
+    get prepareDocumentEmbeddings () {
+        return prepareDocumentEmbeddings;
     }
 });
 var _nodediagnostics_channel = require("node:diagnostics_channel");
@@ -21,6 +24,7 @@ var _nodefs = require("node:fs");
 var _nodepath = require("node:path");
 var _indexts = require("../config/index.js");
 var _handoffts = require("../embed/handoff.js");
+var _queryts = require("../embed/query.js");
 var _errorsts = require("../errors.js");
 var _indexts1 = require("../features/index.js");
 var _builderts = require("./builder.js");
@@ -31,6 +35,8 @@ var _lockwaitts = require("./lock-wait.js");
 var _presetscopets = require("./preset-scope.js");
 var _sharedts = require("./shared.js");
 var _signaturets = require("./signature.js");
+var _stagests = require("./stages.js");
+var _transactionts = require("./transaction.js");
 function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
     try {
         var info = gen[key](arg);
@@ -156,11 +162,27 @@ function _ts_generator(thisArg, body) {
         };
     }
 }
-// duckdb/turso hold the cache file for their connection's whole life, so a second command waits.
-// Bounded by this tree's recorded reconcile time (lock-wait.ts), not a fixed guess.
+var CORE_READY_META_KEY = 'core_ready';
 var LOCK_POLL_MS = 50;
 var lockWait = (0, _nodediagnostics_channel.channel)('sensemaking.store.lock-wait');
-function connectUnlocked(dbPath, cfg, configDir, dialect) {
+function notReady(reason) {
+    return new _errorsts.SenseError('INDEX_NOT_READY', "".concat(reason, '; run "sense build" or call build(config) before opening with { build: false }'));
+}
+function normaliseConfig(cfg) {
+    // `baseDir` was the original public open() input. Keep direct API callers working while
+    // making the two ownership paths explicit for every internal operation.
+    if (!cfg.rootDir) {
+        if (!cfg.baseDir) throw new _errorsts.SenseError('CONFIG_INVALID', 'open requires rootDir (or legacy baseDir)');
+        cfg.rootDir = cfg.baseDir;
+    }
+    if (!cfg.configDir) cfg.configDir = cfg.rootDir;
+    return cfg;
+}
+function cachePath(cfg, dialect) {
+    var _cfg_configDir;
+    return (0, _nodepath.join)((_cfg_configDir = cfg.configDir) !== null && _cfg_configDir !== void 0 ? _cfg_configDir : cfg.baseDir, _indexts.STATE_DIR, dialect.filename);
+}
+function connectUnlocked(dbPath, cfg, configDir, dialect, options) {
     return _async_to_generator(function() {
         var budgetMs, deadline, err, _dialect_isLocked;
         return _ts_generator(this, function(_state) {
@@ -178,7 +200,7 @@ function connectUnlocked(dbPath, cfg, configDir, dialect) {
                     ]);
                     return [
                         4,
-                        dialect.connect(dbPath, cfg)
+                        dialect.connect(dbPath, cfg, options)
                     ];
                 case 2:
                     return [
@@ -187,8 +209,10 @@ function connectUnlocked(dbPath, cfg, configDir, dialect) {
                     ];
                 case 3:
                     err = _state.sent();
+                    if (options.existingOnly && !(0, _nodefs.existsSync)(dbPath)) {
+                        throw notReady("the derived index does not exist at ".concat(dbPath));
+                    }
                     if (!((_dialect_isLocked = dialect.isLocked) === null || _dialect_isLocked === void 0 ? void 0 : _dialect_isLocked.call(dialect, err))) throw err;
-                    // Observe a real rejected native connection, never merely the start of an async open.
                     if (lockWait.hasSubscribers) lockWait.publish({
                         store: cfg.store,
                         dbPath: dbPath
@@ -221,9 +245,176 @@ function connectUnlocked(dbPath, cfg, configDir, dialect) {
         });
     })();
 }
-function connectWithDialect(cfg, dialect) {
+function assertCoreSchema(conn) {
+    return _async_to_generator(function() {
+        var _i, _iter, table;
+        return _ts_generator(this, function(_state) {
+            switch(_state.label){
+                case 0:
+                    _i = 0, _iter = [
+                        'frontmatter',
+                        'content',
+                        'preset_files',
+                        'indexed_sources'
+                    ];
+                    _state.label = 1;
+                case 1:
+                    if (!(_i < _iter.length)) return [
+                        3,
+                        5
+                    ];
+                    table = _iter[_i];
+                    return [
+                        4,
+                        conn.prepare("SELECT 1 FROM ".concat(table, " LIMIT 0"))
+                    ];
+                case 2:
+                    return [
+                        4,
+                        _state.sent().all()
+                    ];
+                case 3:
+                    _state.sent();
+                    _state.label = 4;
+                case 4:
+                    _i++;
+                    return [
+                        3,
+                        1
+                    ];
+                case 5:
+                    return [
+                        2
+                    ];
+            }
+        });
+    })();
+}
+function connectExisting(cfg, dialect, requirements) {
+    return _async_to_generator(function() {
+        var _cfg_configDir, configDir, dbPath, _ref, handle, conn, version, features, ready, unused, wantFeatures, _dialect_assertLexicalReady, err;
+        return _ts_generator(this, function(_state) {
+            switch(_state.label){
+                case 0:
+                    configDir = (_cfg_configDir = cfg.configDir) !== null && _cfg_configDir !== void 0 ? _cfg_configDir : cfg.baseDir;
+                    dbPath = cachePath(cfg, dialect);
+                    if (!(0, _nodefs.existsSync)(dbPath)) throw notReady("the derived index does not exist at ".concat(dbPath));
+                    return [
+                        4,
+                        connectUnlocked(dbPath, cfg, configDir, dialect, {
+                            existingOnly: true,
+                            observational: true
+                        })
+                    ];
+                case 1:
+                    _ref = _state.sent(), handle = _ref.handle, conn = _ref.conn;
+                    _state.label = 2;
+                case 2:
+                    _state.trys.push([
+                        2,
+                        12,
+                        ,
+                        14
+                    ]);
+                    _state.label = 3;
+                case 3:
+                    _state.trys.push([
+                        3,
+                        8,
+                        ,
+                        9
+                    ]);
+                    return [
+                        4,
+                        (0, _sharedts.getMeta)(conn, 'schema_version')
+                    ];
+                case 4:
+                    version = _state.sent();
+                    return [
+                        4,
+                        (0, _sharedts.getMeta)(conn, 'features')
+                    ];
+                case 5:
+                    features = _state.sent();
+                    return [
+                        4,
+                        (0, _sharedts.getMeta)(conn, CORE_READY_META_KEY)
+                    ];
+                case 6:
+                    ready = _state.sent();
+                    return [
+                        4,
+                        assertCoreSchema(conn)
+                    ];
+                case 7:
+                    _state.sent();
+                    return [
+                        3,
+                        9
+                    ];
+                case 8:
+                    unused = _state.sent();
+                    if (!(0, _nodefs.existsSync)(dbPath)) throw notReady("the derived index was deleted while opening ".concat(dbPath));
+                    throw notReady("the derived index at ".concat(dbPath, " has no compatible schema"));
+                case 9:
+                    if (version !== dialect.schemaVersion) {
+                        throw notReady("the derived index at ".concat(dbPath, " uses schema ").concat(version !== null && version !== void 0 ? version : 'unknown', ", but this sense version requires ").concat(dialect.schemaVersion));
+                    }
+                    wantFeatures = (0, _indexts.featureSignature)(cfg, _indexts1.FEATURES);
+                    if (features !== wantFeatures) {
+                        throw notReady("the derived index at ".concat(dbPath, " was built for different configuration features"));
+                    }
+                    if (ready !== '1') {
+                        throw notReady("the derived index at ".concat(dbPath, " has an incomplete core build"));
+                    }
+                    if (!requirements.has('lexical')) return [
+                        3,
+                        11
+                    ];
+                    return [
+                        4,
+                        (_dialect_assertLexicalReady = dialect.assertLexicalReady) === null || _dialect_assertLexicalReady === void 0 ? void 0 : _dialect_assertLexicalReady.call(dialect, conn)
+                    ];
+                case 10:
+                    _state.sent();
+                    _state.label = 11;
+                case 11:
+                    if (!(0, _nodefs.existsSync)(dbPath)) throw notReady("the derived index was deleted while opening ".concat(dbPath));
+                    return [
+                        2,
+                        {
+                            handle: handle,
+                            conn: conn,
+                            cfg: cfg,
+                            dbPath: dbPath,
+                            parsed: 0,
+                            warnings: [],
+                            stages: (0, _stagests.stageRecorder)().take(0, 0),
+                            observational: true
+                        }
+                    ];
+                case 12:
+                    err = _state.sent();
+                    return [
+                        4,
+                        dialect.close(handle, {
+                            observational: true
+                        })
+                    ];
+                case 13:
+                    _state.sent();
+                    throw err;
+                case 14:
+                    return [
+                        2
+                    ];
+            }
+        });
+    })();
+}
+function connectForBuild(cfg, dialect, requirements) {
     return _async_to_generator(function() {
-        var _cfg_configDir, _cfg_rootDir, configDir, stateDir, dbPath, _ref, handle, conn, closed, builder, version, features, wantFeatures, forcedPaths, embedInvalidate, featureToggles, _cfg_rootDir1, changedKeys, presetForced, embedKind, toggles, changed, changed1, changed2, _ref1, recordedMaxMs, embedParsed, _tmp, featureParsed, _tmp1, _ref2, parsed, warnings, stages, err;
+        var _cfg_configDir, _cfg_rootDir, configDir, stateDir, dbPath, _ref, handle, conn, closed, builder, version, features, ready, wantFeatures, recoverIncomplete, forcedPaths, embedInvalidate, featureToggles, _cfg_rootDir1, changedKeys, presetForced, embedKind, toggles, changed, changed1, changed2, _ref1, recordedMaxMs, embedParsed, _tmp, featureParsed, _tmp1, _ref2, parsed, warnings, stages, _tmp2, _dialect_prepareLexical, err;
         return _ts_generator(this, function(_state) {
             switch(_state.label){
                 case 0:
@@ -235,15 +426,14 @@ function connectWithDialect(cfg, dialect) {
                     dbPath = (0, _nodepath.join)(stateDir, dialect.filename);
                     return [
                         4,
-                        connectUnlocked(dbPath, cfg, configDir, dialect)
+                        connectUnlocked(dbPath, cfg, configDir, dialect, {
+                            existingOnly: false,
+                            observational: false
+                        })
                     ];
                 case 1:
                     _ref = _state.sent(), handle = _ref.handle, conn = _ref.conn;
-                    // A throw below must release this handle, or the leaked WAL makes the cache file undeletable on
-                    // Windows. `closed` keeps the catch from double-closing a handle a rebuild branch already closed.
                     closed = false;
-                    // Created here, not inside reconcile(): invalidate()/invalidateFeatures() below share its pool
-                    // with the build() call that follows them.
                     builder = (0, _builderts.createBuilder)(conn, cfg, {
                         rootDir: (_cfg_rootDir = cfg.rootDir) !== null && _cfg_rootDir !== void 0 ? _cfg_rootDir : cfg.baseDir,
                         configDir: configDir
@@ -252,9 +442,9 @@ function connectWithDialect(cfg, dialect) {
                 case 2:
                     _state.trys.push([
                         2,
-                        30,
+                        35,
                         ,
-                        34
+                        39
                     ]);
                     return [
                         4,
@@ -274,123 +464,103 @@ function connectWithDialect(cfg, dialect) {
                     ];
                 case 5:
                     features = _state.sent();
+                    return [
+                        4,
+                        (0, _sharedts.getMeta)(conn, CORE_READY_META_KEY)
+                    ];
+                case 6:
+                    ready = _state.sent();
                     wantFeatures = (0, _indexts.featureSignature)(cfg, _indexts1.FEATURES);
-                    if (!(version !== null && version !== dialect.schemaVersion || features !== null && features !== wantFeatures)) return [
-                        3,
-                        17
+                    // `ready=0` may belong to another SQLite builder, so recovery stays in place and lets the
+                    // engine serialize it. It never unlinks the cache.
+                    return [
+                        4,
+                        (0, _sharedts.setMeta)(conn, CORE_READY_META_KEY, '0')
                     ];
+                case 7:
+                    _state.sent();
+                    recoverIncomplete = ready === '0' && (version === null || version === dialect.schemaVersion);
                     if (!(version !== null && version !== dialect.schemaVersion)) return [
                         3,
-                        7
+                        9
                     ];
                     console.error('sense: cache format changed (new sensemaking version); rebuilding the index');
-                    // Close before clearCache deletes the files out from under the still-open handle.
                     closed = true;
                     return [
                         4,
                         dialect.close(handle)
                     ];
-                case 6:
+                case 8:
                     _state.sent();
                     (0, _cachets.clearCache)(cfg);
                     return [
                         2,
-                        connectWithDialect(cfg, dialect)
+                        connectForBuild(cfg, dialect, requirements)
+                    ];
+                case 9:
+                    if (!recoverIncomplete) return [
+                        3,
+                        10
+                    ];
+                    console.error('sense: recovering an incomplete index generation in place');
+                    return [
+                        3,
+                        16
+                    ];
+                case 10:
+                    if (!(features !== null && features !== wantFeatures)) return [
+                        3,
+                        16
                     ];
-                case 7:
                     changedKeys = (0, _signaturets.changedSignatureKeys)(features !== null && features !== void 0 ? features : '', wantFeatures);
-                    // Null (rather than the empty set) when changedKeys isn't preset-only, or a changed
-                    // preset's stored segment can't be parsed back into old include/exclude/vectors -- either
-                    // way the branch below is skipped and the full rebuild stays the fallback.
                     presetForced = (0, _presetscopets.isPresetOnlyChange)(changedKeys) ? (0, _presetscopets.forcedPresetPaths)(cfg, (_cfg_rootDir1 = cfg.rootDir) !== null && _cfg_rootDir1 !== void 0 ? _cfg_rootDir1 : cfg.baseDir, features !== null && features !== void 0 ? features : '', changedKeys) : null;
-                    // Null unless exactly one segment changed and it decomposes into a recognised embed-only
-                    // case (embed-scope.ts): anything else, including embed toggled on/off, stays null.
                     embedKind = changedKeys.size === 1 && changedKeys.has('embed') ? (0, _embedscopets.classifyEmbedChange)(features !== null && features !== void 0 ? features : '', wantFeatures) : null;
-                    // Null (rather than the empty set) when changedKeys isn't feature-toggle-only, or a changed
-                    // feature's stored segment can't be parsed back into old/new on-off -- either way the branch
-                    // below is skipped and the full rebuild stays the fallback.
                     toggles = (0, _featurescopets.isFeatureOnlyChange)(changedKeys) ? (0, _featurescopets.classifyFeatureToggles)(features !== null && features !== void 0 ? features : '', wantFeatures, changedKeys) : null;
                     if (!(changedKeys.size === 1 && changedKeys.has('embed') && (0, _signaturets.embedIdentityAdopted)(features !== null && features !== void 0 ? features : '', wantFeatures))) return [
                         3,
-                        9
+                        11
                     ];
-                    // First sight of a resolved weight identity: the model itself hasn't changed, so
-                    // adopt it into meta with no rebuild and no re-embed.
                     console.error("sense: recorded the embedding model's resolved identity; vectors are unaffected");
-                    return [
-                        4,
-                        (0, _sharedts.setMeta)(conn, 'features', wantFeatures)
-                    ];
-                case 8:
-                    _state.sent();
                     return [
                         3,
-                        17
+                        16
                     ];
-                case 9:
+                case 11:
                     if (!(embedKind !== null)) return [
                         3,
-                        11
+                        12
                     ];
-                    // Chunk boundaries are file-derived, not model-derived (embed.ts's chunksOf), so neither
-                    // case needs any file reparsed for any feature but embed itself.
                     embedInvalidate = embedKind;
                     console.error(embedKind === 'model' ? 'sense: config change (embed settings) invalidates only the stale vectors' : 'sense: config change (embed settings) rebuilds only the embeddings it affects');
-                    return [
-                        4,
-                        (0, _sharedts.setMeta)(conn, 'features', wantFeatures)
-                    ];
-                case 10:
-                    _state.sent();
                     return [
                         3,
-                        17
+                        16
                     ];
-                case 11:
+                case 12:
                     if (!(presetForced !== null)) return [
                         3,
                         13
                     ];
-                    // Membership only: which files a preset covers moved, not a file's own content, a
-                    // global feature, or the embed model. reconcile() already knows how to
-                    // add, update, and remove a file correctly (every cross-feature cascade included); it
-                    // just needs telling which unchanged files to treat as touched (forcedPaths, above).
                     forcedPaths = presetForced;
                     changed = (0, _signaturets.signatureDiff)(features !== null && features !== void 0 ? features : '', wantFeatures);
                     console.error("sense: config change (".concat(changed, ") reparses only the files it affects"));
-                    return [
-                        4,
-                        (0, _sharedts.setMeta)(conn, 'features', wantFeatures)
-                    ];
-                case 12:
-                    _state.sent();
                     return [
                         3,
-                        17
+                        16
                     ];
                 case 13:
                     if (!(toggles !== null)) return [
                         3,
-                        15
+                        14
                     ];
-                    // A feature turned off or on: reconcile.ts's activeFeatures skips a disabled feature's
-                    // hooks entirely, so its rows rot while off -- invalidateFeatures drops them and, for a
-                    // feature turning back on, fully re-derives across every indexed file rather than
-                    // trusting rows written before or during that window.
                     featureToggles = toggles;
                     changed1 = (0, _signaturets.signatureDiff)(features !== null && features !== void 0 ? features : '', wantFeatures);
                     console.error("sense: config change (".concat(changed1, ") reparses only the feature it affects"));
-                    return [
-                        4,
-                        (0, _sharedts.setMeta)(conn, 'features', wantFeatures)
-                    ];
-                case 14:
-                    _state.sent();
                     return [
                         3,
-                        17
+                        16
                     ];
-                case 15:
+                case 14:
                     changed2 = (0, _signaturets.signatureDiff)(features !== null && features !== void 0 ? features : '', wantFeatures);
                     console.error("sense: config change (".concat(changed2, ") rebuilds the index"));
                     closed = true;
@@ -398,29 +568,29 @@ function connectWithDialect(cfg, dialect) {
                         4,
                         dialect.close(handle)
                     ];
-                case 16:
+                case 15:
                     _state.sent();
                     (0, _cachets.clearCache)(cfg);
                     return [
                         2,
-                        connectWithDialect(cfg, dialect)
+                        connectForBuild(cfg, dialect, requirements)
                     ];
-                case 17:
+                case 16:
                     return [
                         4,
                         dialect.ensureSchema(handle, conn, cfg)
                     ];
-                case 18:
+                case 17:
                     _state.sent();
                     if (!dialect.setDerivedBusyTimeout) return [
                         3,
-                        21
+                        20
                     ];
                     return [
                         4,
                         (0, _sharedts.getMeta)(conn, 'reconcile_max_ms')
                     ];
-                case 19:
+                case 18:
                     recordedMaxMs = Number.apply(void 0, [
                         (_ref1 = _state.sent()) !== null && _ref1 !== void 0 ? _ref1 : '0'
                     ]);
@@ -428,60 +598,118 @@ function connectWithDialect(cfg, dialect) {
                         4,
                         dialect.setDerivedBusyTimeout(handle, conn, Math.min(Math.max(30000, 3 * recordedMaxMs), 600000))
                     ];
-                case 20:
+                case 19:
                     _state.sent();
-                    _state.label = 21;
-                case 21:
+                    _state.label = 20;
+                case 20:
                     if (!embedInvalidate) return [
                         3,
-                        23
+                        22
                     ];
                     return [
                         4,
                         builder.invalidate(embedInvalidate)
                     ];
-                case 22:
+                case 21:
                     _tmp = _state.sent().parsed;
                     return [
                         3,
-                        24
+                        23
                     ];
-                case 23:
+                case 22:
                     _tmp = 0;
-                    _state.label = 24;
-                case 24:
+                    _state.label = 23;
+                case 23:
                     embedParsed = _tmp;
                     if (!featureToggles) return [
                         3,
-                        26
+                        25
                     ];
                     return [
                         4,
                         builder.invalidateFeatures(featureToggles)
                     ];
-                case 25:
+                case 24:
                     _tmp1 = _state.sent().parsed;
                     return [
                         3,
-                        27
+                        26
                     ];
-                case 26:
+                case 25:
                     _tmp1 = 0;
-                    _state.label = 27;
-                case 27:
+                    _state.label = 26;
+                case 26:
                     featureParsed = _tmp1;
+                    if (!recoverIncomplete) return [
+                        3,
+                        28
+                    ];
                     return [
                         4,
-                        builder.build(forcedPaths)
+                        builder.recover()
+                    ];
+                case 27:
+                    _tmp2 = _state.sent();
+                    return [
+                        3,
+                        30
                     ];
                 case 28:
-                    _ref2 = _state.sent(), parsed = _ref2.parsed, warnings = _ref2.warnings, stages = _ref2.stages;
-                    // Every open reconciles once and is done with it -- a watcher opens fresh per event instead of holding this connection (src/watch.ts).
                     return [
                         4,
-                        builder.close()
+                        builder.build(forcedPaths)
                     ];
                 case 29:
+                    _tmp2 = _state.sent();
+                    _state.label = 30;
+                case 30:
+                    _ref2 = _tmp2, parsed = _ref2.parsed, warnings = _ref2.warnings, stages = _ref2.stages;
+                    return [
+                        4,
+                        (0, _transactionts.withTransaction)(conn, function() {
+                            return _async_to_generator(function() {
+                                return _ts_generator(this, function(_state) {
+                                    switch(_state.label){
+                                        case 0:
+                                            return [
+                                                4,
+                                                (0, _sharedts.setMeta)(conn, 'features', wantFeatures)
+                                            ];
+                                        case 1:
+                                            _state.sent();
+                                            return [
+                                                4,
+                                                (0, _sharedts.setMeta)(conn, CORE_READY_META_KEY, '1')
+                                            ];
+                                        case 2:
+                                            _state.sent();
+                                            return [
+                                                2
+                                            ];
+                                    }
+                                });
+                            })();
+                        })
+                    ];
+                case 31:
+                    _state.sent();
+                    if (!requirements.has('lexical')) return [
+                        3,
+                        33
+                    ];
+                    return [
+                        4,
+                        (_dialect_prepareLexical = dialect.prepareLexical) === null || _dialect_prepareLexical === void 0 ? void 0 : _dialect_prepareLexical.call(dialect, conn)
+                    ];
+                case 32:
+                    _state.sent();
+                    _state.label = 33;
+                case 33:
+                    return [
+                        4,
+                        builder.close()
+                    ];
+                case 34:
                     _state.sent();
                     return [
                         2,
@@ -492,31 +720,32 @@ function connectWithDialect(cfg, dialect) {
                             dbPath: dbPath,
                             parsed: parsed + embedParsed + featureParsed,
                             warnings: warnings,
-                            stages: stages
+                            stages: stages,
+                            observational: false
                         }
                     ];
-                case 30:
+                case 35:
                     err = _state.sent();
                     return [
                         4,
                         builder.close()
                     ];
-                case 31:
+                case 36:
                     _state.sent();
                     if (!!closed) return [
                         3,
-                        33
+                        38
                     ];
                     return [
                         4,
                         dialect.close(handle)
                     ];
-                case 32:
+                case 37:
                     _state.sent();
-                    _state.label = 33;
-                case 33:
+                    _state.label = 38;
+                case 38:
                     throw err;
-                case 34:
+                case 39:
                     return [
                         2
                     ];
@@ -524,42 +753,164 @@ function connectWithDialect(cfg, dialect) {
         });
     })();
 }
-function openWithDialect(cfg, dialect) {
+function prepareDocumentEmbeddings(store, cfg, allowed) {
     return _async_to_generator(function() {
-        var _ref, handle, conn, resolvedCfg, dbPath, parsed, warnings, stages, store;
+        var preparedSignature, actualSignature, changedKeys, update, result;
         return _ts_generator(this, function(_state) {
             switch(_state.label){
                 case 0:
-                    // `baseDir` was the original public open() input. Keep direct API callers working while
-                    // making the two ownership paths explicit for every internal operation.
-                    if (!cfg.rootDir) {
-                        if (!cfg.baseDir) throw new _errorsts.SenseError('CONFIG_INVALID', 'open requires rootDir (or legacy baseDir)');
-                        cfg.rootDir = cfg.baseDir;
+                    return [
+                        4,
+                        (0, _sharedts.getMeta)(store, 'features')
+                    ];
+                case 1:
+                    preparedSignature = _state.sent();
+                    return [
+                        4,
+                        (0, _queryts.embedPending)(store, cfg, allowed)
+                    ];
+                case 2:
+                    _state.sent();
+                    actualSignature = (0, _indexts.featureSignature)(cfg, _indexts1.FEATURES);
+                    if (preparedSignature === actualSignature) return [
+                        2
+                    ];
+                    changedKeys = (0, _signaturets.changedSignatureKeys)(preparedSignature !== null && preparedSignature !== void 0 ? preparedSignature : '', actualSignature);
+                    if (preparedSignature === null || changedKeys.size !== 1 || !changedKeys.has('embed') || !(0, _signaturets.embedIdentityAdopted)(preparedSignature, actualSignature)) {
+                        throw notReady('the index configuration changed while vectors were being prepared');
                     }
-                    if (!cfg.configDir) cfg.configDir = cfg.rootDir;
                     return [
                         4,
-                        connectWithDialect(cfg, dialect)
+                        store.prepare('UPDATE meta SET value = ? WHERE key = ? AND value = ?')
+                    ];
+                case 3:
+                    update = _state.sent();
+                    return [
+                        4,
+                        update.run(actualSignature, 'features', preparedSignature)
+                    ];
+                case 4:
+                    result = _state.sent();
+                    if (Number(result.changes) !== 1) throw notReady('another build changed the index configuration while vectors were being prepared');
+                    return [
+                        2
+                    ];
+            }
+        });
+    })();
+}
+function openWithDialect(_0, _1) {
+    return _async_to_generator(function(input, dialect) {
+        var options, _options_requirements, cfg, buildEnabled, defaultRequirements, requirements, connected, _tmp, store, err;
+        var _arguments = arguments;
+        return _ts_generator(this, function(_state) {
+            switch(_state.label){
+                case 0:
+                    options = _arguments.length > 2 && _arguments[2] !== void 0 ? _arguments[2] : {};
+                    cfg = normaliseConfig(input);
+                    buildEnabled = options.build !== false;
+                    defaultRequirements = new Set(buildEnabled ? [
+                        'core',
+                        'lexical'
+                    ] : [
+                        'core'
+                    ]);
+                    if (buildEnabled && (0, _indexts.anyPresetEmbeds)(cfg)) defaultRequirements.add('vectors');
+                    requirements = (_options_requirements = options.requirements) !== null && _options_requirements !== void 0 ? _options_requirements : defaultRequirements;
+                    if (!buildEnabled) return [
+                        3,
+                        2
+                    ];
+                    return [
+                        4,
+                        connectForBuild(cfg, dialect, requirements)
                     ];
                 case 1:
-                    _ref = _state.sent(), handle = _ref.handle, conn = _ref.conn, resolvedCfg = _ref.cfg, dbPath = _ref.dbPath, parsed = _ref.parsed, warnings = _ref.warnings, stages = _ref.stages;
-                    store = dialect.createStore(handle, conn, resolvedCfg);
-                    // reconcile ran before this object existed, so its chunk text is keyed by the connection.
-                    (0, _handoffts.rekeyChunkText)(conn, store);
+                    _tmp = _state.sent();
+                    return [
+                        3,
+                        4
+                    ];
+                case 2:
+                    return [
+                        4,
+                        connectExisting(cfg, dialect, requirements)
+                    ];
+                case 3:
+                    _tmp = _state.sent();
+                    _state.label = 4;
+                case 4:
+                    connected = _tmp;
+                    _state.label = 5;
+                case 5:
+                    _state.trys.push([
+                        5,
+                        8,
+                        ,
+                        13
+                    ]);
+                    store = dialect.createStore(connected.handle, connected.conn, connected.cfg, {
+                        observational: connected.observational
+                    });
+                    (0, _handoffts.rekeyChunkText)(connected.conn, store);
+                    if (!(requirements.has('vectors') && buildEnabled)) return [
+                        3,
+                        7
+                    ];
+                    return [
+                        4,
+                        prepareDocumentEmbeddings(store, connected.cfg)
+                    ];
+                case 6:
+                    _state.sent();
+                    _state.label = 7;
+                case 7:
                     return [
                         2,
                         {
                             store: store,
-                            cfg: resolvedCfg,
-                            dbPath: dbPath,
-                            parsed: parsed,
-                            warnings: warnings,
-                            stages: stages
+                            cfg: connected.cfg,
+                            dbPath: connected.dbPath,
+                            parsed: connected.parsed,
+                            warnings: connected.warnings,
+                            stages: connected.stages
                         }
                     ];
+                case 8:
+                    err = _state.sent();
+                    if (!store) return [
+                        3,
+                        10
+                    ];
+                    return [
+                        4,
+                        store.close()
+                    ];
+                case 9:
+                    _state.sent();
+                    return [
+                        3,
+                        12
+                    ];
+                case 10:
+                    return [
+                        4,
+                        dialect.close(connected.handle, {
+                            observational: connected.observational
+                        })
+                    ];
+                case 11:
+                    _state.sent();
+                    _state.label = 12;
+                case 12:
+                    throw err;
+                case 13:
+                    return [
+                        2
+                    ];
             }
         });
-    })();
+    }).apply(this, arguments);
 }
 function docCount(store) {
     return _async_to_generator(function() {