sensemaking 0.27.1 → 0.28.0

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

@@ -1 +1 @@
-{"version":3,"sources":["/Users/kevin/Dev/open-source/ai/sensemaking/src/store/native.ts"],"sourcesContent":["import { existsSync, readFileSync } from 'node:fs';\nimport Module from 'node:module';\nimport { dirname, join } from 'node:path';\nimport { fileURLToPath, pathToFileURL } from 'node:url';\nimport { SenseError } from '../errors.ts';\n\n// A store's optional native package, and the strings its error messages and install notice name.\nexport interface NativeDescriptor {\n  store: string;\n  pkg: string;\n  sizeHint: string;\n  /** Optional exact package version required by this native binding. */\n  version?: string;\n  /** npm specifier used only when installation is required (imports stay bare). */\n  installSpec?: string;\n}\n\n// install-module-linked is small, but a target native package can be large (@duckdb/node-api's\n// ~110MB), so it is required lazily inside the gated branch below, not for every store/index.ts load.\nconst _require = typeof require === 'undefined' ? Module.createRequire(import.meta.url) : require;\nconst _dirname = dirname(typeof __filename !== 'undefined' ? __filename : fileURLToPath(import.meta.url));\n\n// Walks up from this file's own directory rather than a fixed dot-count: it sits at a\n// different depth under src/ than under built dist/{cjs,esm}/store output.\nexport function packageNodeModules(): string {\n  let dir = _dirname;\n  for (;;) {\n    const candidate = join(dir, 'package.json');\n    if (existsSync(candidate)) {\n      const pkg = JSON.parse(readFileSync(candidate, 'utf8')) as { name?: string };\n      if (pkg.name === 'sensemaking') return join(dir, 'node_modules');\n    }\n    const parent = dirname(dir);\n    if (parent === dir) throw new Error('could not locate the sensemaking package root to install a native dependency into');\n    dir = parent;\n  }\n}\n\nconst installing = new Map<string, Promise<void>>();\n\n// De-dupes concurrent installs: since the install is async, concurrent callers await the same\n// in-flight promise, keyed by specifier and target. A failed install is not cached, so a later call retries.\nfunction installOnce(specifier: string, nodeModulesPath: string): Promise<void> {\n  const key = `${specifier}\\n${nodeModulesPath}`;\n  let promise = installing.get(key);\n  if (!promise) {\n    const installModuleLinked = (_require('install-module-linked') as { default: (specifier: string, nodeModulesPath: string) => Promise<string> }).default;\n    promise = installModuleLinked(specifier, nodeModulesPath).then(\n      () => {},\n      (err) => {\n        installing.delete(key);\n        throw err;\n      }\n    );\n    installing.set(key, promise);\n  }\n  return promise;\n}\n\n// Node caches a bare specifier's resolution, including a \"not found\" miss, for the process\n// lifetime; use the installed entry directly, as a URL for ESM and a path for CJS.\nfunction resolveEntrySpecifier(importName: string, nodeModulesPath: string): string {\n  const pkgDir = join(nodeModulesPath, ...importName.split('/'));\n  const pkg = JSON.parse(readFileSync(join(pkgDir, 'package.json'), 'utf8')) as { main?: string; exports?: string };\n  const entry = typeof pkg.exports === 'string' ? pkg.exports : (pkg.main ?? 'index.js');\n  const entryPath = join(pkgDir, entry);\n  return typeof require === 'undefined' ? pathToFileURL(entryPath).href : entryPath;\n}\n\ntype PackageMetadata = { name?: string; version?: string };\n\nfunction readPackageMetadata(pkgDir: string): PackageMetadata | undefined {\n  try {\n    return JSON.parse(readFileSync(join(pkgDir, 'package.json'), 'utf8')) as PackageMetadata;\n  } catch {\n    return undefined;\n  }\n}\n\nfunction targetPackageMetadata(importName: string, nodeModulesPath: string): { exists: boolean; metadata?: PackageMetadata } {\n  const pkgDir = join(nodeModulesPath, ...importName.split('/'));\n  return { exists: existsSync(pkgDir), metadata: readPackageMetadata(pkgDir) };\n}\n\nfunction resolvedPackageMetadata(importName: string): PackageMetadata | undefined {\n  try {\n    let dir = dirname(_require.resolve(importName));\n    for (;;) {\n      const manifest = join(dir, 'package.json');\n      if (existsSync(manifest)) {\n        const pkg = readPackageMetadata(dir);\n        if (!pkg) return undefined;\n        if (pkg.name === importName) return pkg;\n      }\n      const parent = dirname(dir);\n      if (parent === dir) return undefined;\n      dir = parent;\n    }\n  } catch {\n    return undefined;\n  }\n}\n\nfunction versionContractError(descriptor: NativeDescriptor, installed?: string): SenseError {\n  const installSpec = descriptor.installSpec ?? descriptor.pkg;\n  const detail = installed ? `${descriptor.pkg}@${installed} is installed` : `${descriptor.pkg} has missing or unreadable version metadata`;\n  return new SenseError('STORE_DEPENDENCY_MISSING', `store \"${descriptor.store}\" needs ${installSpec}, but ${detail}; refusing to overwrite it -- run \\`npm install ${installSpec}\\` yourself and try again`);\n}\n\nfunction assertExpectedVersion(descriptor: NativeDescriptor, metadata: PackageMetadata | undefined): void {\n  if (!descriptor.version) return;\n  if (!metadata?.version || metadata.version !== descriptor.version) throw versionContractError(descriptor, metadata?.version);\n}\n\n// Import-then-install-then-retry, over an injectable importName so the failure path can be\n// exercised in tests without a real native binding. Thrown errors always name descriptor.pkg.\nexport async function loadOrInstall<T>(descriptor: NativeDescriptor, nodeModulesPath: string, importName: string = descriptor.pkg): Promise<T> {\n  if (descriptor.version) {\n    const target = targetPackageMetadata(importName, nodeModulesPath);\n    if (target.exists) assertExpectedVersion(descriptor, target.metadata);\n  }\n  let loaded: T;\n  try {\n    loaded = (await import(importName)) as T;\n  } catch {\n    const installSpec = descriptor.installSpec ?? importName;\n    const displaySpec = descriptor.installSpec ?? descriptor.pkg;\n    console.error(`sense: store \"${descriptor.store}\" needs ${displaySpec}; installing it now (one-time download, ${descriptor.sizeHint})...`);\n    try {\n      await installOnce(installSpec, nodeModulesPath);\n    } catch (installErr) {\n      throw new SenseError(\n        'STORE_DEPENDENCY_MISSING',\n        `store \"${descriptor.store}\" needs ${displaySpec}, and installing it automatically failed (${(installErr as Error).message}); this can happen offline, in a sandboxed environment, or when node_modules is read-only or owned by another user (e.g. under a global install) -- run \\`npm install ${displaySpec}\\` yourself and try again`\n      );\n    }\n    try {\n      const loaded = (await import(resolveEntrySpecifier(importName, nodeModulesPath))) as T;\n      assertExpectedVersion(descriptor, targetPackageMetadata(importName, nodeModulesPath).metadata);\n      return loaded;\n    } catch (loadErr) {\n      throw new SenseError('STORE_DEPENDENCY_MISSING', `store \"${descriptor.store}\" installed ${displaySpec} but it could not be loaded (${(loadErr as Error).message}); it may not be available for this platform (${process.platform}-${process.arch}) -- run \\`npm install ${displaySpec}\\` to see the underlying error`);\n    }\n  }\n  if (descriptor.version) assertExpectedVersion(descriptor, resolvedPackageMetadata(importName));\n  return loaded;\n}\n"],"names":["loadOrInstall","packageNodeModules","_require","require","Module","createRequire","_dirname","dirname","__filename","fileURLToPath","dir","candidate","join","existsSync","pkg","JSON","parse","readFileSync","name","parent","Error","installing","Map","installOnce","specifier","nodeModulesPath","key","promise","get","installModuleLinked","default","then","err","delete","set","resolveEntrySpecifier","importName","pkgDir","split","entry","exports","main","entryPath","pathToFileURL","href","readPackageMetadata","undefined","targetPackageMetadata","exists","metadata","resolvedPackageMetadata","resolve","manifest","versionContractError","descriptor","installed","installSpec","detail","SenseError","store","assertExpectedVersion","version","target","loaded","displaySpec","installErr","loadErr","console","error","sizeHint","message","process","platform","arch"],"mappings":"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"}
+{"version":3,"sources":["/Users/kevin/Dev/open-source/ai/sensemaking/src/store/native.ts"],"sourcesContent":["import { existsSync, readFileSync } from 'node:fs';\nimport Module from 'node:module';\nimport { dirname, join } from 'node:path';\nimport { fileURLToPath, pathToFileURL } from 'node:url';\nimport semver from 'semver';\nimport { SenseError } from '../errors.ts';\n\n// A store's optional native package, and the strings its error messages and install notice name.\nexport interface NativeDescriptor {\n  store: string;\n  pkg: string;\n  sizeHint: string;\n  /** The tested semver range: sensemaking's own `peerDependencies` entry for `pkg` (see `peerRange`). */\n  range: string;\n}\n\n// A loaded native package and the version that actually resolved, which the store's engine identity records.\nexport interface NativeModule<T> {\n  api: T;\n  version: string | undefined;\n}\n\n// install-module-linked is small, but a target native package can be large (@duckdb/node-api's\n// ~110MB), so it is required lazily inside the gated branch below, not for every store/index.ts load.\nconst _require = typeof require === 'undefined' ? Module.createRequire(import.meta.url) : require;\nconst _dirname = dirname(typeof __filename !== 'undefined' ? __filename : fileURLToPath(import.meta.url));\n\ntype PackageMetadata = { name?: string; version?: string; peerDependencies?: Record<string, string> };\n\n// Walks up from this file's own directory rather than a fixed dot-count: it sits at a\n// different depth under src/ than under built dist/{cjs,esm}/store output.\nfunction packageRoot(): { dir: string; manifest: PackageMetadata } {\n  let dir = _dirname;\n  for (;;) {\n    const candidate = join(dir, 'package.json');\n    if (existsSync(candidate)) {\n      const manifest = JSON.parse(readFileSync(candidate, 'utf8')) as PackageMetadata;\n      if (manifest.name === 'sensemaking') return { dir, manifest };\n    }\n    const parent = dirname(dir);\n    if (parent === dir) throw new Error('could not locate the sensemaking package root to install a native dependency into');\n    dir = parent;\n  }\n}\n\nexport function packageNodeModules(): string {\n  return join(packageRoot().dir, 'node_modules');\n}\n\n// The published contract for an optional native package: the range it is tested against.\nexport function peerRange(pkg: string): string {\n  const range = packageRoot().manifest.peerDependencies?.[pkg];\n  if (!range) throw new Error(`sensemaking's package.json declares no peerDependencies entry for ${pkg}`);\n  return range;\n}\n\nconst installing = new Map<string, Promise<void>>();\n\n// De-dupes concurrent installs: since the install is async, concurrent callers await the same\n// in-flight promise, keyed by specifier and target. A failed install is not cached, so a later call retries.\nfunction installOnce(specifier: string, nodeModulesPath: string): Promise<void> {\n  const key = `${specifier}\\n${nodeModulesPath}`;\n  let promise = installing.get(key);\n  if (!promise) {\n    const installModuleLinked = (_require('install-module-linked') as { default: (specifier: string, nodeModulesPath: string) => Promise<string> }).default;\n    promise = installModuleLinked(specifier, nodeModulesPath).then(\n      () => {},\n      (err) => {\n        installing.delete(key);\n        throw err;\n      }\n    );\n    installing.set(key, promise);\n  }\n  return promise;\n}\n\nfunction readPackageMetadata(pkgDir: string): PackageMetadata | undefined {\n  try {\n    return JSON.parse(readFileSync(join(pkgDir, 'package.json'), 'utf8')) as PackageMetadata;\n  } catch {\n    return undefined;\n  }\n}\n\n// Node caches a bare specifier's resolution, including a \"not found\" miss, for the process\n// lifetime; use the installed entry directly, as a URL for ESM and a path for CJS.\nfunction resolveEntrySpecifier(importName: string, nodeModulesPath: string): string {\n  const pkgDir = join(nodeModulesPath, ...importName.split('/'));\n  const pkg = JSON.parse(readFileSync(join(pkgDir, 'package.json'), 'utf8')) as { main?: string; exports?: string };\n  const entry = typeof pkg.exports === 'string' ? pkg.exports : (pkg.main ?? 'index.js');\n  const entryPath = join(pkgDir, entry);\n  return typeof require === 'undefined' ? pathToFileURL(entryPath).href : entryPath;\n}\n\nfunction resolvedVersion(importName: string): string | undefined {\n  try {\n    let dir = dirname(_require.resolve(importName));\n    for (;;) {\n      const pkg = readPackageMetadata(dir);\n      if (pkg?.name === importName) return pkg.version;\n      const parent = dirname(dir);\n      if (parent === dir) return undefined;\n      dir = parent;\n    }\n  } catch {\n    return undefined;\n  }\n}\n\n// Any installed version is used; one outside the tested range is reported, not refused (the store's engine check decides).\nfunction reportVersion(descriptor: NativeDescriptor, version: string | undefined): void {\n  if (version && semver.satisfies(version, descriptor.range)) return;\n  console.error(`sense: store \"${descriptor.store}\" using ${descriptor.pkg}@${version ?? 'unknown version'} (tested ${descriptor.range})`);\n}\n\n// Import-then-install-then-retry, over an injectable importName so the failure path can be\n// exercised in tests without a real native binding. Thrown errors always name descriptor.pkg.\nexport async function loadOrInstall<T>(descriptor: NativeDescriptor, nodeModulesPath: string, importName: string = descriptor.pkg): Promise<NativeModule<T>> {\n  try {\n    const api = (await import(importName)) as T;\n    const version = resolvedVersion(importName);\n    reportVersion(descriptor, version);\n    return { api, version };\n  } catch {\n    // Not resolvable here: install the newest version npm would pick for the tested range.\n  }\n  const spec = `${descriptor.pkg}@${descriptor.range}`;\n  const installSpec = `${importName}@${descriptor.range}`;\n  console.error(`sense: store \"${descriptor.store}\" needs ${spec}; installing it now (one-time download, ${descriptor.sizeHint})...`);\n  try {\n    await installOnce(installSpec, nodeModulesPath);\n  } catch (installErr) {\n    throw new SenseError(\n      'STORE_DEPENDENCY_MISSING',\n      `store \"${descriptor.store}\" needs ${spec}, and installing it automatically failed (${(installErr as Error).message}); this can happen offline, in a sandboxed environment, or when node_modules is read-only or owned by another user (e.g. under a global install) -- run \\`npm install ${spec}\\` yourself and try again`\n    );\n  }\n  try {\n    const api = (await import(resolveEntrySpecifier(importName, nodeModulesPath))) as T;\n    const version = readPackageMetadata(join(nodeModulesPath, ...importName.split('/')))?.version;\n    reportVersion(descriptor, version);\n    return { api, version };\n  } catch (loadErr) {\n    throw new SenseError('STORE_DEPENDENCY_MISSING', `store \"${descriptor.store}\" installed ${spec} but it could not be loaded (${(loadErr as Error).message}); it may not be available for this platform (${process.platform}-${process.arch}) -- run \\`npm install ${spec}\\` to see the underlying error`);\n  }\n}\n"],"names":["loadOrInstall","packageNodeModules","peerRange","_require","require","Module","createRequire","_dirname","dirname","__filename","fileURLToPath","packageRoot","dir","candidate","join","existsSync","manifest","JSON","parse","readFileSync","name","parent","Error","pkg","range","peerDependencies","installing","Map","installOnce","specifier","nodeModulesPath","key","promise","get","installModuleLinked","default","then","err","delete","set","readPackageMetadata","pkgDir","undefined","resolveEntrySpecifier","importName","split","entry","exports","main","entryPath","pathToFileURL","href","resolvedVersion","resolve","version","reportVersion","descriptor","semver","satisfies","console","error","store","api","spec","installSpec","installErr","loadErr","sizeHint","SenseError","message","process","platform","arch"],"mappings":"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"}

package/dist/cjs/store/open.js

@@ -29,6 +29,7 @@ var _errorsts = require("../errors.js");
 var _indexts1 = require("../features/index.js");
 var _builderts = require("./builder.js");
 var _cachets = require("./cache.js");
+var _enginets = require("./engine.js");
 var _lockwaitts = require("./lock-wait.js");
 var _readinessts = require("./readiness.js");
 var _sharedts = require("./shared.js");
@@ -316,7 +317,7 @@ function assertCoreSchema(conn) {
 }
 function connectExisting(cfg, dialect, requirements) {
     return _async_to_generator(function() {
-        var _cfg_configDir, configDir, dbPath, _ref, handle, conn, state, unused, _state_version, wantFeatures, _dialect_assertLexicalReady, err;
+        var _cfg_configDir, configDir, dbPath, _ref, handle, conn, _dialect_engineIdentity, state, unused, _state_version, engine, _state_engine, wantFeatures, _dialect_assertLexicalReady, err;
         return _ts_generator(this, function(_state) {
             switch(_state.label){
                 case 0:
@@ -336,9 +337,9 @@ function connectExisting(cfg, dialect, requirements) {
                 case 2:
                     _state.trys.push([
                         2,
-                        9,
+                        10,
                         ,
-                        11
+                        12
                     ]);
                     _state.label = 3;
                 case 3:
@@ -352,7 +353,7 @@ function connectExisting(cfg, dialect, requirements) {
                         4,
                         (0, _transactionts.withTransaction)(conn, function() {
                             return _async_to_generator(function() {
-                                var version, features, ready;
+                                var version, features, ready, engine;
                                 return _ts_generator(this, function(_state) {
                                     switch(_state.label){
                                         case 0:
@@ -376,16 +377,23 @@ function connectExisting(cfg, dialect, requirements) {
                                             ready = _state.sent();
                                             return [
                                                 4,
-                                                assertCoreSchema(conn)
+                                                (0, _sharedts.getMeta)(conn, _enginets.ENGINE_IDENTITY_META_KEY)
                                             ];
                                         case 4:
+                                            engine = _state.sent();
+                                            return [
+                                                4,
+                                                assertCoreSchema(conn)
+                                            ];
+                                        case 5:
                                             _state.sent();
                                             return [
                                                 2,
                                                 {
                                                     version: version,
                                                     features: features,
-                                                    ready: ready
+                                                    ready: ready,
+                                                    engine: engine
                                                 }
                                             ];
                                     }
@@ -408,6 +416,16 @@ function connectExisting(cfg, dialect, requirements) {
                         ;
                         throw notReady("the derived index at ".concat(dbPath, " uses schema ").concat((_state_version = state.version) !== null && _state_version !== void 0 ? _state_version : 'unknown', ", but this sense version requires ").concat(dialect.schemaVersion));
                     }
+                    return [
+                        4,
+                        (_dialect_engineIdentity = dialect.engineIdentity) === null || _dialect_engineIdentity === void 0 ? void 0 : _dialect_engineIdentity.call(dialect)
+                    ];
+                case 7:
+                    engine = _state.sent();
+                    if (engine !== undefined && state.engine !== engine) {
+                        ;
+                        throw notReady("the derived index at ".concat(dbPath, " was built with ").concat((_state_engine = state.engine) !== null && _state_engine !== void 0 ? _state_engine : 'an unrecorded engine', ", but this process loads ").concat(engine));
+                    }
                     wantFeatures = (0, _indexts.featureSignature)(cfg, _indexts1.FEATURES);
                     if (!(0, _readinessts.isPublishedFeatureSignature)(state.features, wantFeatures)) {
                         throw notReady("the derived index at ".concat(dbPath, " was built for different configuration features"));
@@ -417,16 +435,16 @@ function connectExisting(cfg, dialect, requirements) {
                     }
                     if (!requirements.has('lexical')) return [
                         3,
-                        8
+                        9
                     ];
                     return [
                         4,
                         (_dialect_assertLexicalReady = dialect.assertLexicalReady) === null || _dialect_assertLexicalReady === void 0 ? void 0 : _dialect_assertLexicalReady.call(dialect, conn)
                     ];
-                case 7:
-                    _state.sent();
-                    _state.label = 8;
                 case 8:
+                    _state.sent();
+                    _state.label = 9;
+                case 9:
                     if (!(0, _nodefs.existsSync)(dbPath)) throw notReady("the derived index was deleted while opening ".concat(dbPath));
                     return [
                         2,
@@ -441,7 +459,7 @@ function connectExisting(cfg, dialect, requirements) {
                             observational: true
                         }
                     ];
-                case 9:
+                case 10:
                     err = _state.sent();
                     return [
                         4,
@@ -449,10 +467,10 @@ function connectExisting(cfg, dialect, requirements) {
                             observational: true
                         })
                     ];
-                case 10:
+                case 11:
                     _state.sent();
                     throw err;
-                case 11:
+                case 12:
                     return [
                         2
                     ];
@@ -463,7 +481,7 @@ function connectExisting(cfg, dialect, requirements) {
 function connectForBuild(cfg, dialect, requirements) {
     var cacheReplaced = arguments.length > 3 && arguments[3] !== void 0 ? arguments[3] : false;
     return _async_to_generator(function() {
-        var _cfg_configDir, configDir, stateDir, dbPath, _ref, handle, conn, closed, builder, _dialect_prepareConnection, version, _ref1, recordedMaxMs, _ref2, parsed, warnings, stages, messages, _iteratorNormalCompletion, _didIteratorError, _iteratorError, _iterator, _step, message, _dialect_prepareLexical, err, cleanupTasks, builderToClose, cleanup, cleanupErrors;
+        var _cfg_configDir, configDir, stateDir, dbPath, _ref, handle, conn, closed, builder, _dialect_engineIdentity, _dialect_prepareConnection, version, engine, builtWith, _tmp, engineChanged, _dialect_checkEngine, _ref1, recordedMaxMs, _ref2, parsed, warnings, stages, messages, _iteratorNormalCompletion, _didIteratorError, _iteratorError, _iterator, _step, message, _dialect_prepareLexical, err, cleanupTasks, builderToClose, cleanup, cleanupErrors;
         return _ts_generator(this, function(_state) {
             switch(_state.label){
                 case 0:
@@ -487,9 +505,9 @@ function connectForBuild(cfg, dialect, requirements) {
                 case 2:
                     _state.trys.push([
                         2,
-                        17,
+                        23,
                         ,
-                        19
+                        25
                     ]);
                     return [
                         4,
@@ -503,52 +521,94 @@ function connectForBuild(cfg, dialect, requirements) {
                     ];
                 case 4:
                     version = _state.sent();
-                    if (!(version !== null && version !== dialect.schemaVersion)) return [
+                    return [
+                        4,
+                        (_dialect_engineIdentity = dialect.engineIdentity) === null || _dialect_engineIdentity === void 0 ? void 0 : _dialect_engineIdentity.call(dialect)
+                    ];
+                case 5:
+                    engine = _state.sent();
+                    if (!(version === null)) return [
                         3,
                         6
                     ];
-                    console.error('sense: cache format changed (new sensemaking version); rebuilding the index');
+                    _tmp = null;
+                    return [
+                        3,
+                        8
+                    ];
+                case 6:
+                    return [
+                        4,
+                        (0, _sharedts.getMeta)(conn, _enginets.ENGINE_IDENTITY_META_KEY)
+                    ];
+                case 7:
+                    _tmp = _state.sent();
+                    _state.label = 8;
+                case 8:
+                    builtWith = _tmp;
+                    engineChanged = version !== null && engine !== undefined && builtWith !== engine;
+                    if (!(version !== null && (version !== dialect.schemaVersion || engineChanged))) return [
+                        3,
+                        10
+                    ];
+                    console.error(version !== dialect.schemaVersion ? 'sense: cache format changed (new sensemaking version); rebuilding the index' : "sense: index was built with ".concat(builtWith !== null && builtWith !== void 0 ? builtWith : 'an unrecorded engine', "; rebuilding it with ").concat(engine));
                     return [
                         4,
                         dialect.close(handle)
                     ];
-                case 5:
+                case 9:
                     _state.sent();
                     closed = true;
-                    if (cacheReplaced) throw notReady("the derived index at ".concat(dbPath, " still reports incompatible schema ").concat(version, " after cache replacement"));
+                    if (cacheReplaced) throw notReady("the derived index at ".concat(dbPath, " still reports incompatible schema ").concat(version, " or engine ").concat(builtWith !== null && builtWith !== void 0 ? builtWith : 'unrecorded', " after cache replacement"));
                     (0, _cachets.clearCache)(cfg);
                     return [
                         2,
                         connectForBuild(cfg, dialect, requirements, true)
                     ];
-                case 6:
+                case 10:
                     if (!(version === null)) return [
                         3,
-                        8
+                        14
                     ];
+                    return [
+                        4,
+                        (_dialect_checkEngine = dialect.checkEngine) === null || _dialect_checkEngine === void 0 ? void 0 : _dialect_checkEngine.call(dialect)
+                    ];
+                case 11:
+                    _state.sent();
                     return [
                         4,
                         dialect.ensureCoreSchema(handle, conn)
                     ];
-                case 7:
+                case 12:
                     _state.sent();
-                    _state.label = 8;
-                case 8:
+                    if (!(engine !== undefined)) return [
+                        3,
+                        14
+                    ];
+                    return [
+                        4,
+                        (0, _sharedts.setMeta)(conn, _enginets.ENGINE_IDENTITY_META_KEY, engine)
+                    ];
+                case 13:
+                    _state.sent();
+                    _state.label = 14;
+                case 14:
                     return [
                         4,
                         (_dialect_prepareConnection = dialect.prepareConnection) === null || _dialect_prepareConnection === void 0 ? void 0 : _dialect_prepareConnection.call(dialect, handle, conn, cfg)
                     ];
-                case 9:
+                case 15:
                     _state.sent();
                     if (!dialect.setDerivedBusyTimeout) return [
                         3,
-                        12
+                        18
                     ];
                     return [
                         4,
                         (0, _sharedts.getMeta)(conn, 'reconcile_max_ms')
                     ];
-                case 10:
+                case 16:
                     recordedMaxMs = Number.apply(void 0, [
                         (_ref1 = _state.sent()) !== null && _ref1 !== void 0 ? _ref1 : '0'
                     ]);
@@ -556,10 +616,10 @@ function connectForBuild(cfg, dialect, requirements) {
                         4,
                         dialect.setDerivedBusyTimeout(handle, conn, Math.min(Math.max(30000, 3 * recordedMaxMs), 600000))
                     ];
-                case 11:
+                case 17:
                     _state.sent();
-                    _state.label = 12;
-                case 12:
+                    _state.label = 18;
+                case 18:
                     builder = (0, _builderts.createBuilder)(conn, cfg, dialect.reconcileDialect, function(snapshotCfg) {
                         return dialect.ensureFeatureSchema(handle, conn, snapshotCfg);
                     });
@@ -567,7 +627,7 @@ function connectForBuild(cfg, dialect, requirements) {
                         4,
                         builder.build()
                     ];
-                case 13:
+                case 19:
                     _ref2 = _state.sent(), parsed = _ref2.parsed, warnings = _ref2.warnings, stages = _ref2.stages, messages = _ref2.messages;
                     _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
                     try {
@@ -591,21 +651,21 @@ function connectForBuild(cfg, dialect, requirements) {
                     }
                     if (!requirements.has('lexical')) return [
                         3,
-                        15
+                        21
                     ];
                     return [
                         4,
                         (_dialect_prepareLexical = dialect.prepareLexical) === null || _dialect_prepareLexical === void 0 ? void 0 : _dialect_prepareLexical.call(dialect, conn)
                     ];
-                case 14:
+                case 20:
                     _state.sent();
-                    _state.label = 15;
-                case 15:
+                    _state.label = 21;
+                case 21:
                     return [
                         4,
                         builder.close()
                     ];
-                case 16:
+                case 22:
                     _state.sent();
                     return [
                         2,
@@ -620,7 +680,7 @@ function connectForBuild(cfg, dialect, requirements) {
                             observational: false
                         }
                     ];
-                case 17:
+                case 23:
                     err = _state.sent();
                     cleanupTasks = [];
                     if (builder) {
@@ -636,7 +696,7 @@ function connectForBuild(cfg, dialect, requirements) {
                         4,
                         Promise.allSettled(cleanupTasks)
                     ];
-                case 18:
+                case 24:
                     cleanup = _state.sent();
                     cleanupErrors = cleanup.filter(function(result) {
                         return result.status === 'rejected';
@@ -647,7 +707,7 @@ function connectForBuild(cfg, dialect, requirements) {
                         err
                     ].concat(_to_consumable_array(cleanupErrors)), 'opening the derived index failed and cleanup also failed');
                     throw err;
-                case 19:
+                case 25:
                     return [
                         2
                     ];

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

@@ -1 +1 @@
-{"version":3,"sources":["/Users/kevin/Dev/open-source/ai/sensemaking/src/store/open.ts"],"sourcesContent":["import { channel } from 'node:diagnostics_channel';\nimport { existsSync, mkdirSync } from 'node:fs';\nimport { join } from 'node:path';\nimport type { ResolvedConfig } from '../config/index.ts';\nimport { anyPresetEmbeds, featureSignature, STATE_DIR } from '../config/index.ts';\nimport { rekeyChunkText } from '../embed/handoff.ts';\nimport { embedPending } from '../embed/query.ts';\nimport type { EmbedCallOptions } from '../embed/types.ts';\nimport { SenseError } from '../errors.ts';\nimport { FEATURES } from '../features/index.ts';\nimport { createBuilder } from './builder.ts';\nimport { clearCache } from './cache.ts';\nimport { lockWaitBudgetMs } from './lock-wait.ts';\nimport { CORE_READY_META_KEY, FEATURE_SIGNATURE_META_KEY, isCoreReady, isPublishedFeatureSignature } from './readiness.ts';\nimport { getMeta } from './shared.ts';\nimport { changedSignatureKeys, embedIdentityAdopted } from './signature.ts';\nimport type { Stages } from './stages.ts';\nimport { stageRecorder } from './stages.ts';\nimport { withTransaction } from './transaction.ts';\nimport type { Connection, OpenDialect, Store } from './types.ts';\n\nexport type BuildRequirement = 'core' | 'lexical' | 'vectors';\n\n/** Options for the root `open(config, options)` API. */\nexport interface OpenOptions {\n  /** Prepares configured capabilities by default; `false` opens compatible published state without repair. */\n  build?: boolean;\n  /** Cancels supported provider I/O and stops between phases after active native work finishes. */\n  signal?: AbortSignal;\n}\n\nexport interface InternalOpenOptions extends OpenOptions {\n  requirements?: ReadonlySet<BuildRequirement>;\n}\n\nexport interface OpenResult {\n  store: Store;\n  cfg: ResolvedConfig;\n  dbPath: string;\n  parsed: number;\n  warnings: string[];\n  stages: Stages;\n}\n\ninterface ConnectResult<Handle> {\n  handle: Handle;\n  conn: Connection;\n  cfg: ResolvedConfig;\n  dbPath: string;\n  parsed: number;\n  warnings: string[];\n  stages: Stages;\n  observational: boolean;\n}\n\nconst LOCK_POLL_MS = 50;\nconst lockWait = channel('sensemaking.store.lock-wait');\n\nfunction notReady(reason: string): SenseError {\n  return new SenseError('INDEX_NOT_READY', `${reason}; run \"sense build\" or call build(config) before opening with { build: false }`);\n}\n\nfunction normaliseConfig(cfg: ResolvedConfig): ResolvedConfig {\n  // `baseDir` was the original public open() input. Keep direct API callers working while\n  // making the two ownership paths explicit for every internal operation.\n  if (!cfg.rootDir) {\n    if (!cfg.baseDir) throw new SenseError('CONFIG_INVALID', 'open requires rootDir (or legacy baseDir)');\n    cfg.rootDir = cfg.baseDir;\n  }\n  if (!cfg.configDir) cfg.configDir = cfg.rootDir;\n  return cfg;\n}\n\nfunction cachePath<Handle>(cfg: ResolvedConfig, dialect: OpenDialect<Handle>): string {\n  return join(cfg.configDir ?? cfg.baseDir, STATE_DIR, dialect.filename);\n}\n\nasync function connectUnlocked<Handle>(dbPath: string, cfg: ResolvedConfig, configDir: string, dialect: OpenDialect<Handle>, options: { existingOnly: boolean; observational: boolean }): Promise<{ handle: Handle; conn: Connection }> {\n  const budgetMs = lockWaitBudgetMs(configDir);\n  const deadline = Date.now() + budgetMs;\n  for (;;) {\n    try {\n      return await dialect.connect(dbPath, cfg, options);\n    } catch (err) {\n      if (options.existingOnly && !existsSync(dbPath)) {\n        throw notReady(`the derived index does not exist at ${dbPath}`);\n      }\n      if (!dialect.isLocked?.(err as Error)) throw err;\n      if (lockWait.hasSubscribers) lockWait.publish({ store: cfg.store, dbPath });\n      if (Date.now() >= deadline) {\n        throw new SenseError('STORE_BUSY', `another sense process is using this tree's ${cfg.store} cache (${dbPath}) and did not release it within ${Math.round(budgetMs / 1000)}s; wait for that command to finish, or set \"store\" to \"sqlite\" in sense.config.json, which serves concurrent commands`);\n      }\n      await new Promise((resolve) => setTimeout(resolve, LOCK_POLL_MS));\n    }\n  }\n}\n\nasync function assertCoreSchema(conn: Connection): Promise<void> {\n  for (const table of ['frontmatter', 'content', 'preset_files', 'indexed_sources']) {\n    await (await conn.prepare(`SELECT 1 FROM ${table} LIMIT 0`)).all();\n  }\n}\n\nasync function connectExisting<Handle>(cfg: ResolvedConfig, dialect: OpenDialect<Handle>, requirements: ReadonlySet<BuildRequirement>): Promise<ConnectResult<Handle>> {\n  const configDir = cfg.configDir ?? cfg.baseDir;\n  const dbPath = cachePath(cfg, dialect);\n  if (!existsSync(dbPath)) throw notReady(`the derived index does not exist at ${dbPath}`);\n\n  const { handle, conn } = await connectUnlocked(dbPath, cfg, configDir, dialect, { existingOnly: true, observational: true });\n  try {\n    let state: { version: string | null; features: string | null; ready: string | null };\n    try {\n      state = await withTransaction(conn, async () => {\n        const version = await getMeta(conn, 'schema_version');\n        const features = await getMeta(conn, FEATURE_SIGNATURE_META_KEY);\n        const ready = await getMeta(conn, CORE_READY_META_KEY);\n        await assertCoreSchema(conn);\n        return { version, features, ready };\n      });\n    } catch {\n      if (!existsSync(dbPath)) throw notReady(`the derived index was deleted while opening ${dbPath}`);\n      throw notReady(`the derived index at ${dbPath} has no compatible schema`);\n    }\n\n    if (state.version !== dialect.schemaVersion) {\n      throw notReady(`the derived index at ${dbPath} uses schema ${state.version ?? 'unknown'}, but this sense version requires ${dialect.schemaVersion}`);\n    }\n    const wantFeatures = featureSignature(cfg, FEATURES);\n    if (!isPublishedFeatureSignature(state.features, wantFeatures)) {\n      throw notReady(`the derived index at ${dbPath} was built for different configuration features`);\n    }\n    if (!isCoreReady(state.ready)) {\n      throw notReady(`the derived index at ${dbPath} has an incomplete core build`);\n    }\n    if (requirements.has('lexical')) {\n      await dialect.assertLexicalReady?.(conn);\n    }\n    if (!existsSync(dbPath)) throw notReady(`the derived index was deleted while opening ${dbPath}`);\n\n    return {\n      handle,\n      conn,\n      cfg,\n      dbPath,\n      parsed: 0,\n      warnings: [],\n      stages: stageRecorder().take(0, 0),\n      observational: true,\n    };\n  } catch (err) {\n    await dialect.close(handle, { observational: true });\n    throw err;\n  }\n}\n\nasync function connectForBuild<Handle>(cfg: ResolvedConfig, dialect: OpenDialect<Handle>, requirements: ReadonlySet<BuildRequirement>, cacheReplaced = false): Promise<ConnectResult<Handle>> {\n  const configDir = cfg.configDir ?? cfg.baseDir;\n  const stateDir = join(configDir, STATE_DIR);\n  mkdirSync(stateDir, { recursive: true });\n  const dbPath = join(stateDir, dialect.filename);\n\n  const { handle, conn } = await connectUnlocked(dbPath, cfg, configDir, dialect, { existingOnly: false, observational: false });\n  let closed = false;\n  let builder: ReturnType<typeof createBuilder> | undefined;\n  try {\n    await conn.exec('CREATE TABLE IF NOT EXISTS meta (key TEXT PRIMARY KEY, value TEXT)');\n\n    const version = await getMeta(conn, 'schema_version');\n    if (version !== null && version !== dialect.schemaVersion) {\n      console.error('sense: cache format changed (new sensemaking version); rebuilding the index');\n      await dialect.close(handle);\n      closed = true;\n      if (cacheReplaced) throw notReady(`the derived index at ${dbPath} still reports incompatible schema ${version} after cache replacement`);\n      clearCache(cfg);\n      return connectForBuild(cfg, dialect, requirements, true);\n    }\n\n    if (version === null) await dialect.ensureCoreSchema(handle, conn);\n    await dialect.prepareConnection?.(handle, conn, cfg);\n\n    if (dialect.setDerivedBusyTimeout) {\n      const recordedMaxMs = Number((await getMeta(conn, 'reconcile_max_ms')) ?? '0');\n      await dialect.setDerivedBusyTimeout(handle, conn, Math.min(Math.max(30000, 3 * recordedMaxMs), 600_000));\n    }\n\n    builder = createBuilder(conn, cfg, dialect.reconcileDialect, (snapshotCfg) => dialect.ensureFeatureSchema(handle, conn, snapshotCfg));\n    const { parsed, warnings, stages, messages } = await builder.build();\n    for (const message of messages) console.error(message);\n\n    // Lexical preparation is a separate capability stage. A failure leaves core usable and the\n    // dialect's own lexical marker stale, so unrelated map/peek/path/sql commands stay available.\n    if (requirements.has('lexical')) {\n      await dialect.prepareLexical?.(conn);\n    }\n\n    await builder.close();\n    return { handle, conn, cfg, dbPath, parsed, warnings, stages, observational: false };\n  } catch (err) {\n    const cleanupTasks: Array<Promise<void>> = [];\n    if (builder) {\n      const builderToClose = builder;\n      cleanupTasks.push(Promise.resolve().then(() => builderToClose.close()));\n    }\n    if (!closed) cleanupTasks.push(Promise.resolve().then(() => dialect.close(handle)));\n    const cleanup = await Promise.allSettled(cleanupTasks);\n    const cleanupErrors = cleanup.filter((result): result is PromiseRejectedResult => result.status === 'rejected').map((result) => result.reason);\n    if (cleanupErrors.length > 0) throw new AggregateError([err, ...cleanupErrors], 'opening the derived index failed and cleanup also failed');\n    throw err;\n  }\n}\n\n// A static provider can resolve its identity while embedding. Publish it only after vectors\n// succeed and only when the durable signature still matches the prepared generation.\nexport async function prepareDocumentEmbeddings(store: Store, cfg: ResolvedConfig, allowed?: ReadonlySet<string>, options: EmbedCallOptions = {}): Promise<void> {\n  options.signal?.throwIfAborted();\n  const preparedSignature = await getMeta(store, FEATURE_SIGNATURE_META_KEY);\n  options.signal?.throwIfAborted();\n  await embedPending(store, cfg, allowed, preparedSignature, options);\n  options.signal?.throwIfAborted();\n  const actualSignature = featureSignature(cfg, FEATURES);\n  if (preparedSignature === actualSignature) return;\n\n  const changedKeys = changedSignatureKeys(preparedSignature ?? '', actualSignature);\n  if (preparedSignature === null || changedKeys.size !== 1 || !changedKeys.has('embed') || !embedIdentityAdopted(preparedSignature, actualSignature)) {\n    throw notReady('the index configuration changed while vectors were being prepared');\n  }\n\n  await store.transaction(async () => {\n    options.signal?.throwIfAborted();\n    const update = await store.prepare('UPDATE meta SET value = ? WHERE key = ? AND value = ?');\n    options.signal?.throwIfAborted();\n    const result = await update.run(actualSignature, FEATURE_SIGNATURE_META_KEY, preparedSignature);\n    options.signal?.throwIfAborted();\n    if (Number(result.changes) !== 1) throw notReady('another build changed the index configuration while vectors were being prepared');\n  });\n}\n\nexport async function openWithDialect<Handle>(input: ResolvedConfig, dialect: OpenDialect<Handle>, options: InternalOpenOptions = {}): Promise<OpenResult> {\n  options.signal?.throwIfAborted();\n  const cfg = normaliseConfig(input);\n  const buildEnabled = options.build !== false;\n  const defaultRequirements = new Set<BuildRequirement>(buildEnabled ? ['core', 'lexical'] : ['core']);\n  if (buildEnabled && anyPresetEmbeds(cfg)) defaultRequirements.add('vectors');\n  const requirements = options.requirements ?? defaultRequirements;\n  const connected = buildEnabled ? await connectForBuild(cfg, dialect, requirements) : await connectExisting(cfg, dialect, requirements);\n  let store: Store | undefined;\n  try {\n    store = dialect.createStore(connected.handle, connected.conn, connected.cfg, { observational: connected.observational });\n    rekeyChunkText(connected.conn, store);\n    if (requirements.has('vectors') && buildEnabled) await prepareDocumentEmbeddings(store, connected.cfg, undefined, { signal: options.signal });\n    options.signal?.throwIfAborted();\n    return {\n      store,\n      cfg: connected.cfg,\n      dbPath: connected.dbPath,\n      parsed: connected.parsed,\n      warnings: connected.warnings,\n      stages: connected.stages,\n    };\n  } catch (err) {\n    const cleanup = await Promise.allSettled([Promise.resolve().then(() => (store ? store.close() : dialect.close(connected.handle, { observational: connected.observational })))]);\n    if (cleanup[0].status === 'rejected') throw new AggregateError([err, cleanup[0].reason], 'opening the derived index failed and cleanup also failed');\n    throw err;\n  }\n}\n\nexport async function docCount(store: Store): Promise<number> {\n  const stmt = await store.prepare('SELECT COUNT(*) AS n FROM frontmatter');\n  return ((await stmt.get()) as { n: number }).n;\n}\n"],"names":["docCount","openWithDialect","prepareDocumentEmbeddings","LOCK_POLL_MS","lockWait","channel","notReady","reason","SenseError","normaliseConfig","cfg","rootDir","baseDir","configDir","cachePath","dialect","join","STATE_DIR","filename","connectUnlocked","dbPath","options","budgetMs","deadline","err","lockWaitBudgetMs","Date","now","connect","existingOnly","existsSync","isLocked","hasSubscribers","publish","store","Math","round","Promise","resolve","setTimeout","assertCoreSchema","conn","table","prepare","all","connectExisting","requirements","handle","state","wantFeatures","observational","withTransaction","version","features","ready","getMeta","FEATURE_SIGNATURE_META_KEY","CORE_READY_META_KEY","schemaVersion","featureSignature","FEATURES","isPublishedFeatureSignature","isCoreReady","has","assertLexicalReady","parsed","warnings","stages","stageRecorder","take","close","connectForBuild","cacheReplaced","stateDir","closed","builder","recordedMaxMs","messages","message","cleanupTasks","builderToClose","cleanup","cleanupErrors","mkdirSync","recursive","exec","console","error","clearCache","ensureCoreSchema","prepareConnection","setDerivedBusyTimeout","Number","min","max","createBuilder","reconcileDialect","snapshotCfg","ensureFeatureSchema","build","prepareLexical","push","then","allSettled","filter","result","status","map","length","AggregateError","allowed","preparedSignature","actualSignature","changedKeys","signal","throwIfAborted","embedPending","changedSignatureKeys","size","embedIdentityAdopted","transaction","update","run","changes","input","buildEnabled","defaultRequirements","connected","Set","anyPresetEmbeds","add","createStore","rekeyChunkText","undefined","stmt","get","n"],"mappings":";;;;;;;;;;;QA0QsBA;eAAAA;;QA7BAC;eAAAA;;QAxBAC;eAAAA;;;uCArNE;sBACc;wBACjB;uBAEwC;yBAC9B;uBACF;wBAEF;wBACF;yBACK;uBACH;0BACM;2BACyE;wBAClF;2BACmC;wBAE7B;6BACE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAqChC,IAAMC,eAAe;AACrB,IAAMC,WAAWC,IAAAA,gCAAO,EAAC;AAEzB,SAASC,SAASC,MAAc;IAC9B,OAAO,IAAIC,oBAAU,CAAC,mBAAmB,AAAC,GAAS,OAAPD,QAAO;AACrD;AAEA,SAASE,gBAAgBC,GAAmB;IAC1C,wFAAwF;IACxF,wEAAwE;IACxE,IAAI,CAACA,IAAIC,OAAO,EAAE;QAChB,IAAI,CAACD,IAAIE,OAAO,EAAE,MAAM,IAAIJ,oBAAU,CAAC,kBAAkB;QACzDE,IAAIC,OAAO,GAAGD,IAAIE,OAAO;IAC3B;IACA,IAAI,CAACF,IAAIG,SAAS,EAAEH,IAAIG,SAAS,GAAGH,IAAIC,OAAO;IAC/C,OAAOD;AACT;AAEA,SAASI,UAAkBJ,GAAmB,EAAEK,OAA4B;QAC9DL;IAAZ,OAAOM,IAAAA,cAAI,GAACN,iBAAAA,IAAIG,SAAS,cAAbH,4BAAAA,iBAAiBA,IAAIE,OAAO,EAAEK,kBAAS,EAAEF,QAAQG,QAAQ;AACvE;AAEA,SAAeC,gBAAwBC,MAAc,EAAEV,GAAmB,EAAEG,SAAiB,EAAEE,OAA4B,EAAEM,OAA0D;;YAC/KC,UACAC,UAIKC,KAIFT;;;;oBATHO,WAAWG,IAAAA,4BAAgB,EAACZ;oBAC5BU,WAAWG,KAAKC,GAAG,KAAKL;;;;;;;;;oBAGnB;;wBAAMP,QAAQa,OAAO,CAACR,QAAQV,KAAKW;;;oBAA1C;;wBAAO;;;oBACAG;oBACP,IAAIH,QAAQQ,YAAY,IAAI,CAACC,IAAAA,kBAAU,EAACV,SAAS;wBAC/C,MAAMd,SAAS,AAAC,uCAA6C,OAAPc;oBACxD;oBACA,IAAI,GAACL,oBAAAA,QAAQgB,QAAQ,cAAhBhB,wCAAAA,uBAAAA,SAAmBS,OAAe,MAAMA;oBAC7C,IAAIpB,SAAS4B,cAAc,EAAE5B,SAAS6B,OAAO,CAAC;wBAAEC,OAAOxB,IAAIwB,KAAK;wBAAEd,QAAAA;oBAAO;oBACzE,IAAIM,KAAKC,GAAG,MAAMJ,UAAU;wBAC1B,MAAM,IAAIf,oBAAU,CAAC,cAAc,AAAC,8CAAiEY,OAApBV,IAAIwB,KAAK,EAAC,YAAmDC,OAAzCf,QAAO,oCAA8D,OAA5Be,KAAKC,KAAK,CAACd,WAAW,OAAM;oBAC5K;oBACA;;wBAAM,IAAIe,QAAQ,SAACC;mCAAYC,WAAWD,SAASnC;;;;oBAAnD;;;;;;;;;;;;;;;;IAGN;;AAEA,SAAeqC,iBAAiBC,IAAgB;;gBAC1B,OAATC;;;;4BAAS;wBAAC;wBAAe;wBAAW;wBAAgB;;;;+BAA3C;;;;oBAATA,QAAS;oBACX;;wBAAMD,KAAKE,OAAO,CAAC,AAAC,iBAAsB,OAAND,OAAM;;;oBAAjD;;wBAAO,cAAsDE,GAAG;;;oBAAhE;;;;;;;;;;;;;;IAEJ;;AAEA,SAAeC,gBAAwBnC,GAAmB,EAAEK,OAA4B,EAAE+B,YAA2C;;YACjHpC,gBAAZG,WACAO,QAGmB,MAAjB2B,QAAQN,MAEVO,eAe2DA,gBAEzDC,cAQElC,6BAcDS;;;;oBA7CHX,aAAYH,iBAAAA,IAAIG,SAAS,cAAbH,4BAAAA,iBAAiBA,IAAIE,OAAO;oBACxCQ,SAASN,UAAUJ,KAAKK;oBAC9B,IAAI,CAACe,IAAAA,kBAAU,EAACV,SAAS,MAAMd,SAAS,AAAC,uCAA6C,OAAPc;oBAEtD;;wBAAMD,gBAAgBC,QAAQV,KAAKG,WAAWE,SAAS;4BAAEc,cAAc;4BAAMqB,eAAe;wBAAK;;;oBAAjG,OAAA,eAAjBH,SAAiB,KAAjBA,QAAQN,OAAS,KAATA;;;;;;;;;;;;;;;;;oBAIJ;;wBAAMU,IAAAA,8BAAe,EAACV,MAAM;;oCAC5BW,SACAC,UACAC;;;;4CAFU;;gDAAMC,IAAAA,iBAAO,EAACd,MAAM;;;4CAA9BW,UAAU;4CACC;;gDAAMG,IAAAA,iBAAO,EAACd,MAAMe,uCAA0B;;;4CAAzDH,WAAW;4CACH;;gDAAME,IAAAA,iBAAO,EAACd,MAAMgB,gCAAmB;;;4CAA/CH,QAAQ;4CACd;;gDAAMd,iBAAiBC;;;4CAAvB;4CACA;;gDAAO;oDAAEW,SAAAA;oDAASC,UAAAA;oDAAUC,OAAAA;gDAAM;;;;4BACpC;;;;oBANAN,QAAQ;;;;;;;oBAQR,IAAI,CAAClB,IAAAA,kBAAU,EAACV,SAAS,MAAMd,SAAS,AAAC,+CAAqD,OAAPc;oBACvF,MAAMd,SAAS,AAAC,wBAA8B,OAAPc,QAAO;;oBAGhD,IAAI4B,MAAMI,OAAO,KAAKrC,QAAQ2C,aAAa,EAAE;;wBAC3C,MAAMpD,SAAS,AA7HrB,AA6HsB,+BAAuBc,QAAO,iBAA8EL,QAA/DiC,iBAAAA,MAAMI,OAAO,cAAbJ,4BAAAA,iBAAiB,WAAU,sCAA0D,OAAtBjC,QAAQ2C,aAAa;oBACnJ;oBACMT,eAAeU,IAAAA,yBAAgB,EAACjD,KAAKkD,kBAAQ;oBACnD,IAAI,CAACC,IAAAA,wCAA2B,EAACb,MAAMK,QAAQ,EAAEJ,eAAe;wBAC9D,MAAM3C,SAAS,AAAC,wBAA8B,OAAPc,QAAO;oBAChD;oBACA,IAAI,CAAC0C,IAAAA,wBAAW,EAACd,MAAMM,KAAK,GAAG;wBAC7B,MAAMhD,SAAS,AAAC,wBAA8B,OAAPc,QAAO;oBAChD;yBACI0B,aAAaiB,GAAG,CAAC,YAAjBjB;;;;oBACF;;yBAAM/B,8BAAAA,QAAQiD,kBAAkB,cAA1BjD,kDAAAA,iCAAAA,SAA6B0B;;;oBAAnC;;;oBAEF,IAAI,CAACX,IAAAA,kBAAU,EAACV,SAAS,MAAMd,SAAS,AAAC,+CAAqD,OAAPc;oBAEvF;;wBAAO;4BACL2B,QAAAA;4BACAN,MAAAA;4BACA/B,KAAAA;4BACAU,QAAAA;4BACA6C,QAAQ;4BACRC,QAAQ;4BACRC,QAAQC,IAAAA,uBAAa,IAAGC,IAAI,CAAC,GAAG;4BAChCnB,eAAe;wBACjB;;;oBACO1B;oBACP;;wBAAMT,QAAQuD,KAAK,CAACvB,QAAQ;4BAAEG,eAAe;wBAAK;;;oBAAlD;oBACA,MAAM1B;;;;;;;IAEV;;AAEA,SAAe+C,gBAAwB7D,GAAmB,EAAEK,OAA4B,EAAE+B,YAA2C;QAAE0B,gBAAAA,iEAAgB;;YACnI9D,gBAAZG,WACA4D,UAEArD,QAEmB,MAAjB2B,QAAQN,MACZiC,QACAC,SAeI5D,4BAXAqC,SAc0B,OAAxBwB,eAKuC,OAAvCX,QAAQC,UAAUC,QAAQU,UAC7B,2BAAA,mBAAA,gBAAA,WAAA,OAAMC,SAKH/D,yBAKDS,KACDuD,cAEEC,gBAIFC,SACAC;;;;oBAjDFrE,aAAYH,iBAAAA,IAAIG,SAAS,cAAbH,4BAAAA,iBAAiBA,IAAIE,OAAO;oBACxC6D,WAAWzD,IAAAA,cAAI,EAACH,WAAWI,kBAAS;oBAC1CkE,IAAAA,iBAAS,EAACV,UAAU;wBAAEW,WAAW;oBAAK;oBAChChE,SAASJ,IAAAA,cAAI,EAACyD,UAAU1D,QAAQG,QAAQ;oBAErB;;wBAAMC,gBAAgBC,QAAQV,KAAKG,WAAWE,SAAS;4BAAEc,cAAc;4BAAOqB,eAAe;wBAAM;;;oBAAnG,OAAA,eAAjBH,SAAiB,KAAjBA,QAAQN,OAAS,KAATA;oBACZiC,SAAS;;;;;;;;;oBAGX;;wBAAMjC,KAAK4C,IAAI,CAAC;;;oBAAhB;oBAEgB;;wBAAM9B,IAAAA,iBAAO,EAACd,MAAM;;;oBAA9BW,UAAU;yBACZA,CAAAA,YAAY,QAAQA,YAAYrC,QAAQ2C,aAAa,AAAD,GAApDN;;;;oBACFkC,QAAQC,KAAK,CAAC;oBACd;;wBAAMxE,QAAQuD,KAAK,CAACvB;;;oBAApB;oBACA2B,SAAS;oBACT,IAAIF,eAAe,MAAMlE,SAAS,AAAC,wBAAmE8C,OAA5ChC,QAAO,uCAA6C,OAARgC,SAAQ;oBAC9GoC,IAAAA,mBAAU,EAAC9E;oBACX;;wBAAO6D,gBAAgB7D,KAAKK,SAAS+B,cAAc;;;yBAGjDM,CAAAA,YAAY,IAAG,GAAfA;;;;oBAAkB;;wBAAMrC,QAAQ0E,gBAAgB,CAAC1C,QAAQN;;;oBAAvC;;;oBACtB;;yBAAM1B,6BAAAA,QAAQ2E,iBAAiB,cAAzB3E,iDAAAA,gCAAAA,SAA4BgC,QAAQN,MAAM/B;;;oBAAhD;yBAEIK,QAAQ4E,qBAAqB,EAA7B5E;;;;oBAC4B;;wBAAMwC,IAAAA,iBAAO,EAACd,MAAM;;;oBAA5CmC,gBAAgBgB;yBAAQ,QAAA,2BAAA,mBAAA,QAA4C;;oBAC1E;;wBAAM7E,QAAQ4E,qBAAqB,CAAC5C,QAAQN,MAAMN,KAAK0D,GAAG,CAAC1D,KAAK2D,GAAG,CAAC,OAAO,IAAIlB,gBAAgB;;;oBAA/F;;;oBAGFD,UAAUoB,IAAAA,wBAAa,EAACtD,MAAM/B,KAAKK,QAAQiF,gBAAgB,EAAE,SAACC;+BAAgBlF,QAAQmF,mBAAmB,CAACnD,QAAQN,MAAMwD;;oBACzE;;wBAAMtB,QAAQwB,KAAK;;;oBAAnB,QAAA,eAAvClC,SAAuC,MAAvCA,QAAQC,WAA+B,MAA/BA,UAAUC,SAAqB,MAArBA,QAAQU,WAAa,MAAbA;oBAC7B,kCAAA,2BAAA;;wBAAL,IAAK,YAAiBA,+BAAjB,6BAAA,QAAA,yBAAA;4BAAMC,UAAN;4BAA2BQ,QAAQC,KAAK,CAACT;;;wBAAzC;wBAAA;;;iCAAA,6BAAA;gCAAA;;;gCAAA;sCAAA;;;;yBAIDhC,aAAaiB,GAAG,CAAC,YAAjBjB;;;;oBACF;;yBAAM/B,0BAAAA,QAAQqF,cAAc,cAAtBrF,8CAAAA,6BAAAA,SAAyB0B;;;oBAA/B;;;oBAGF;;wBAAMkC,QAAQL,KAAK;;;oBAAnB;oBACA;;wBAAO;4BAAEvB,QAAAA;4BAAQN,MAAAA;4BAAM/B,KAAAA;4BAAKU,QAAAA;4BAAQ6C,QAAAA;4BAAQC,UAAAA;4BAAUC,QAAAA;4BAAQjB,eAAe;wBAAM;;;oBAC5E1B;oBACDuD;oBACN,IAAIJ,SAAS;wBACLK,iBAAiBL;wBACvBI,aAAasB,IAAI,CAAChE,QAAQC,OAAO,GAAGgE,IAAI,CAAC;mCAAMtB,eAAeV,KAAK;;oBACrE;oBACA,IAAI,CAACI,QAAQK,aAAasB,IAAI,CAAChE,QAAQC,OAAO,GAAGgE,IAAI,CAAC;+BAAMvF,QAAQuD,KAAK,CAACvB;;oBAC1D;;wBAAMV,QAAQkE,UAAU,CAACxB;;;oBAAnCE,UAAU;oBACVC,gBAAgBD,QAAQuB,MAAM,CAAC,SAACC;+BAA4CA,OAAOC,MAAM,KAAK;uBAAYC,GAAG,CAAC,SAACF;+BAAWA,OAAOlG,MAAM;;oBAC7I,IAAI2E,cAAc0B,MAAM,GAAG,GAAG,MAAM,IAAIC,eAAe;wBAACrF;sBAAD,OAAM,qBAAG0D,iBAAgB;oBAChF,MAAM1D;;;;;;;IAEV;;AAIO,SAAetB;wCAA0BgC,KAAY,EAAExB,GAAmB,EAAEoG,OAA6B;YAAEzF,SAChHA,iBAEAA,kBAEAA,kBAHM0F,mBAIAC,iBAGAC;;;;;oBAT0G5F,UAAAA,oEAA4B,CAAC;qBAC7IA,kBAAAA,QAAQ6F,MAAM,cAAd7F,sCAAAA,gBAAgB8F,cAAc;oBACJ;;wBAAM5D,IAAAA,iBAAO,EAACrB,OAAOsB,uCAA0B;;;oBAAnEuD,oBAAoB;qBAC1B1F,mBAAAA,QAAQ6F,MAAM,cAAd7F,uCAAAA,iBAAgB8F,cAAc;oBAC9B;;wBAAMC,IAAAA,qBAAY,EAAClF,OAAOxB,KAAKoG,SAASC,mBAAmB1F;;;oBAA3D;qBACAA,mBAAAA,QAAQ6F,MAAM,cAAd7F,uCAAAA,iBAAgB8F,cAAc;oBACxBH,kBAAkBrD,IAAAA,yBAAgB,EAACjD,KAAKkD,kBAAQ;oBACtD,IAAImD,sBAAsBC,iBAAiB;;;oBAErCC,cAAcI,IAAAA,iCAAoB,EAACN,8BAAAA,+BAAAA,oBAAqB,IAAIC;oBAClE,IAAID,sBAAsB,QAAQE,YAAYK,IAAI,KAAK,KAAK,CAACL,YAAYlD,GAAG,CAAC,YAAY,CAACwD,IAAAA,iCAAoB,EAACR,mBAAmBC,kBAAkB;wBAClJ,MAAM1G,SAAS;oBACjB;oBAEA;;wBAAM4B,MAAMsF,WAAW,CAAC;;oCACtBnG,iBAEAA,kBAEAA,kBAHMoG,QAEAhB;;;;6CAHNpF,kBAAAA,QAAQ6F,MAAM,cAAd7F,sCAAAA,gBAAgB8F,cAAc;4CACf;;gDAAMjF,MAAMS,OAAO,CAAC;;;4CAA7B8E,SAAS;6CACfpG,mBAAAA,QAAQ6F,MAAM,cAAd7F,uCAAAA,iBAAgB8F,cAAc;4CACf;;gDAAMM,OAAOC,GAAG,CAACV,iBAAiBxD,uCAA0B,EAAEuD;;;4CAAvEN,SAAS;6CACfpF,mBAAAA,QAAQ6F,MAAM,cAAd7F,uCAAAA,iBAAgB8F,cAAc;4CAC9B,IAAIvB,OAAOa,OAAOkB,OAAO,MAAM,GAAG,MAAMrH,SAAS;;;;;;4BACnD;;;;oBAPA;;;;;;IAQF;;AAEO,SAAeL;wCAAwB2H,KAAqB,EAAE7G,OAA4B;YAAEM,SAM5EA,uBALrBA,iBACMX,KACAmH,cACAC,qBAEAhF,cACAiF,iBACF7F,OAKFb,kBASOG,KACDyD;;;;;oBAvByF5D,UAAAA,oEAA+B,CAAC;qBACjIA,kBAAAA,QAAQ6F,MAAM,cAAd7F,sCAAAA,gBAAgB8F,cAAc;oBACxBzG,MAAMD,gBAAgBmH;oBACtBC,eAAexG,QAAQ8E,KAAK,KAAK;oBACjC2B,sBAAsB,IAAIE,IAAsBH;wBAAgB;wBAAQ;;wBAAc;;oBAC5F,IAAIA,gBAAgBI,IAAAA,wBAAe,EAACvH,MAAMoH,oBAAoBI,GAAG,CAAC;oBAC5DpF,gBAAezB,wBAAAA,QAAQyB,YAAY,cAApBzB,mCAAAA,wBAAwByG;yBAC3BD,cAAAA;;;;oBAAe;;wBAAMtD,gBAAgB7D,KAAKK,SAAS+B;;;2BAApC;;;;;;oBAAoD;;wBAAMD,gBAAgBnC,KAAKK,SAAS+B;;;2BAApC;;;oBAA/EiF;;;;;;;;;oBAGJ7F,QAAQnB,QAAQoH,WAAW,CAACJ,UAAUhF,MAAM,EAAEgF,UAAUtF,IAAI,EAAEsF,UAAUrH,GAAG,EAAE;wBAAEwC,eAAe6E,UAAU7E,aAAa;oBAAC;oBACtHkF,IAAAA,yBAAc,EAACL,UAAUtF,IAAI,EAAEP;yBAC3BY,CAAAA,aAAaiB,GAAG,CAAC,cAAc8D,YAAW,GAA1C/E;;;;oBAA6C;;wBAAM5C,0BAA0BgC,OAAO6F,UAAUrH,GAAG,EAAE2H,WAAW;4BAAEnB,QAAQ7F,QAAQ6F,MAAM;wBAAC;;;oBAA1F;;;qBACjD7F,mBAAAA,QAAQ6F,MAAM,cAAd7F,uCAAAA,iBAAgB8F,cAAc;oBAC9B;;wBAAO;4BACLjF,OAAAA;4BACAxB,KAAKqH,UAAUrH,GAAG;4BAClBU,QAAQ2G,UAAU3G,MAAM;4BACxB6C,QAAQ8D,UAAU9D,MAAM;4BACxBC,UAAU6D,UAAU7D,QAAQ;4BAC5BC,QAAQ4D,UAAU5D,MAAM;wBAC1B;;;oBACO3C;oBACS;;wBAAMa,QAAQkE,UAAU;4BAAElE,QAAQC,OAAO,GAAGgE,IAAI,CAAC;uCAAOpE,QAAQA,MAAMoC,KAAK,KAAKvD,QAAQuD,KAAK,CAACyD,UAAUhF,MAAM,EAAE;oCAAEG,eAAe6E,UAAU7E,aAAa;gCAAC;;;;;oBAAnK+B,UAAU;oBAChB,IAAIA,OAAO,CAAC,EAAE,CAACyB,MAAM,KAAK,YAAY,MAAM,IAAIG;wBAAgBrF;wBAAKyD,OAAO,CAAC,EAAE,CAAC1E,MAAM;uBAAG;oBACzF,MAAMiB;;;;;;;IAEV;;AAEO,SAAexB,SAASkC,KAAY;;YACnCoG;;;;oBAAO;;wBAAMpG,MAAMS,OAAO,CAAC;;;oBAA3B2F,OAAO;oBACJ;;wBAAMA,KAAKC,GAAG;;;oBAAvB;;wBAAS,cAAoCC,CAAC;;;;IAChD"}
+{"version":3,"sources":["/Users/kevin/Dev/open-source/ai/sensemaking/src/store/open.ts"],"sourcesContent":["import { channel } from 'node:diagnostics_channel';\nimport { existsSync, mkdirSync } from 'node:fs';\nimport { join } from 'node:path';\nimport type { ResolvedConfig } from '../config/index.ts';\nimport { anyPresetEmbeds, featureSignature, STATE_DIR } from '../config/index.ts';\nimport { rekeyChunkText } from '../embed/handoff.ts';\nimport { embedPending } from '../embed/query.ts';\nimport type { EmbedCallOptions } from '../embed/types.ts';\nimport { SenseError } from '../errors.ts';\nimport { FEATURES } from '../features/index.ts';\nimport { createBuilder } from './builder.ts';\nimport { clearCache } from './cache.ts';\nimport { ENGINE_IDENTITY_META_KEY } from './engine.ts';\nimport { lockWaitBudgetMs } from './lock-wait.ts';\nimport { CORE_READY_META_KEY, FEATURE_SIGNATURE_META_KEY, isCoreReady, isPublishedFeatureSignature } from './readiness.ts';\nimport { getMeta, setMeta } from './shared.ts';\nimport { changedSignatureKeys, embedIdentityAdopted } from './signature.ts';\nimport type { Stages } from './stages.ts';\nimport { stageRecorder } from './stages.ts';\nimport { withTransaction } from './transaction.ts';\nimport type { Connection, OpenDialect, Store } from './types.ts';\n\nexport type BuildRequirement = 'core' | 'lexical' | 'vectors';\n\n/** Options for the root `open(config, options)` API. */\nexport interface OpenOptions {\n  /** Prepares configured capabilities by default; `false` opens compatible published state without repair. */\n  build?: boolean;\n  /** Cancels supported provider I/O and stops between phases after active native work finishes. */\n  signal?: AbortSignal;\n}\n\nexport interface InternalOpenOptions extends OpenOptions {\n  requirements?: ReadonlySet<BuildRequirement>;\n}\n\nexport interface OpenResult {\n  store: Store;\n  cfg: ResolvedConfig;\n  dbPath: string;\n  parsed: number;\n  warnings: string[];\n  stages: Stages;\n}\n\ninterface ConnectResult<Handle> {\n  handle: Handle;\n  conn: Connection;\n  cfg: ResolvedConfig;\n  dbPath: string;\n  parsed: number;\n  warnings: string[];\n  stages: Stages;\n  observational: boolean;\n}\n\nconst LOCK_POLL_MS = 50;\nconst lockWait = channel('sensemaking.store.lock-wait');\n\nfunction notReady(reason: string): SenseError {\n  return new SenseError('INDEX_NOT_READY', `${reason}; run \"sense build\" or call build(config) before opening with { build: false }`);\n}\n\nfunction normaliseConfig(cfg: ResolvedConfig): ResolvedConfig {\n  // `baseDir` was the original public open() input. Keep direct API callers working while\n  // making the two ownership paths explicit for every internal operation.\n  if (!cfg.rootDir) {\n    if (!cfg.baseDir) throw new SenseError('CONFIG_INVALID', 'open requires rootDir (or legacy baseDir)');\n    cfg.rootDir = cfg.baseDir;\n  }\n  if (!cfg.configDir) cfg.configDir = cfg.rootDir;\n  return cfg;\n}\n\nfunction cachePath<Handle>(cfg: ResolvedConfig, dialect: OpenDialect<Handle>): string {\n  return join(cfg.configDir ?? cfg.baseDir, STATE_DIR, dialect.filename);\n}\n\nasync function connectUnlocked<Handle>(dbPath: string, cfg: ResolvedConfig, configDir: string, dialect: OpenDialect<Handle>, options: { existingOnly: boolean; observational: boolean }): Promise<{ handle: Handle; conn: Connection }> {\n  const budgetMs = lockWaitBudgetMs(configDir);\n  const deadline = Date.now() + budgetMs;\n  for (;;) {\n    try {\n      return await dialect.connect(dbPath, cfg, options);\n    } catch (err) {\n      if (options.existingOnly && !existsSync(dbPath)) {\n        throw notReady(`the derived index does not exist at ${dbPath}`);\n      }\n      if (!dialect.isLocked?.(err as Error)) throw err;\n      if (lockWait.hasSubscribers) lockWait.publish({ store: cfg.store, dbPath });\n      if (Date.now() >= deadline) {\n        throw new SenseError('STORE_BUSY', `another sense process is using this tree's ${cfg.store} cache (${dbPath}) and did not release it within ${Math.round(budgetMs / 1000)}s; wait for that command to finish, or set \"store\" to \"sqlite\" in sense.config.json, which serves concurrent commands`);\n      }\n      await new Promise((resolve) => setTimeout(resolve, LOCK_POLL_MS));\n    }\n  }\n}\n\nasync function assertCoreSchema(conn: Connection): Promise<void> {\n  for (const table of ['frontmatter', 'content', 'preset_files', 'indexed_sources']) {\n    await (await conn.prepare(`SELECT 1 FROM ${table} LIMIT 0`)).all();\n  }\n}\n\nasync function connectExisting<Handle>(cfg: ResolvedConfig, dialect: OpenDialect<Handle>, requirements: ReadonlySet<BuildRequirement>): Promise<ConnectResult<Handle>> {\n  const configDir = cfg.configDir ?? cfg.baseDir;\n  const dbPath = cachePath(cfg, dialect);\n  if (!existsSync(dbPath)) throw notReady(`the derived index does not exist at ${dbPath}`);\n\n  const { handle, conn } = await connectUnlocked(dbPath, cfg, configDir, dialect, { existingOnly: true, observational: true });\n  try {\n    let state: { version: string | null; features: string | null; ready: string | null; engine: string | null };\n    try {\n      state = await withTransaction(conn, async () => {\n        const version = await getMeta(conn, 'schema_version');\n        const features = await getMeta(conn, FEATURE_SIGNATURE_META_KEY);\n        const ready = await getMeta(conn, CORE_READY_META_KEY);\n        const engine = await getMeta(conn, ENGINE_IDENTITY_META_KEY);\n        await assertCoreSchema(conn);\n        return { version, features, ready, engine };\n      });\n    } catch {\n      if (!existsSync(dbPath)) throw notReady(`the derived index was deleted while opening ${dbPath}`);\n      throw notReady(`the derived index at ${dbPath} has no compatible schema`);\n    }\n\n    if (state.version !== dialect.schemaVersion) {\n      throw notReady(`the derived index at ${dbPath} uses schema ${state.version ?? 'unknown'}, but this sense version requires ${dialect.schemaVersion}`);\n    }\n    const engine = await dialect.engineIdentity?.();\n    if (engine !== undefined && state.engine !== engine) {\n      throw notReady(`the derived index at ${dbPath} was built with ${state.engine ?? 'an unrecorded engine'}, but this process loads ${engine}`);\n    }\n    const wantFeatures = featureSignature(cfg, FEATURES);\n    if (!isPublishedFeatureSignature(state.features, wantFeatures)) {\n      throw notReady(`the derived index at ${dbPath} was built for different configuration features`);\n    }\n    if (!isCoreReady(state.ready)) {\n      throw notReady(`the derived index at ${dbPath} has an incomplete core build`);\n    }\n    if (requirements.has('lexical')) {\n      await dialect.assertLexicalReady?.(conn);\n    }\n    if (!existsSync(dbPath)) throw notReady(`the derived index was deleted while opening ${dbPath}`);\n\n    return {\n      handle,\n      conn,\n      cfg,\n      dbPath,\n      parsed: 0,\n      warnings: [],\n      stages: stageRecorder().take(0, 0),\n      observational: true,\n    };\n  } catch (err) {\n    await dialect.close(handle, { observational: true });\n    throw err;\n  }\n}\n\nasync function connectForBuild<Handle>(cfg: ResolvedConfig, dialect: OpenDialect<Handle>, requirements: ReadonlySet<BuildRequirement>, cacheReplaced = false): Promise<ConnectResult<Handle>> {\n  const configDir = cfg.configDir ?? cfg.baseDir;\n  const stateDir = join(configDir, STATE_DIR);\n  mkdirSync(stateDir, { recursive: true });\n  const dbPath = join(stateDir, dialect.filename);\n\n  const { handle, conn } = await connectUnlocked(dbPath, cfg, configDir, dialect, { existingOnly: false, observational: false });\n  let closed = false;\n  let builder: ReturnType<typeof createBuilder> | undefined;\n  try {\n    await conn.exec('CREATE TABLE IF NOT EXISTS meta (key TEXT PRIMARY KEY, value TEXT)');\n\n    const version = await getMeta(conn, 'schema_version');\n    const engine = await dialect.engineIdentity?.();\n    const builtWith = version === null ? null : await getMeta(conn, ENGINE_IDENTITY_META_KEY);\n    const engineChanged = version !== null && engine !== undefined && builtWith !== engine;\n    if (version !== null && (version !== dialect.schemaVersion || engineChanged)) {\n      console.error(version !== dialect.schemaVersion ? 'sense: cache format changed (new sensemaking version); rebuilding the index' : `sense: index was built with ${builtWith ?? 'an unrecorded engine'}; rebuilding it with ${engine}`);\n      await dialect.close(handle);\n      closed = true;\n      if (cacheReplaced) throw notReady(`the derived index at ${dbPath} still reports incompatible schema ${version} or engine ${builtWith ?? 'unrecorded'} after cache replacement`);\n      clearCache(cfg);\n      return connectForBuild(cfg, dialect, requirements, true);\n    }\n\n    if (version === null) {\n      await dialect.checkEngine?.();\n      await dialect.ensureCoreSchema(handle, conn);\n      if (engine !== undefined) await setMeta(conn, ENGINE_IDENTITY_META_KEY, engine);\n    }\n    await dialect.prepareConnection?.(handle, conn, cfg);\n\n    if (dialect.setDerivedBusyTimeout) {\n      const recordedMaxMs = Number((await getMeta(conn, 'reconcile_max_ms')) ?? '0');\n      await dialect.setDerivedBusyTimeout(handle, conn, Math.min(Math.max(30000, 3 * recordedMaxMs), 600_000));\n    }\n\n    builder = createBuilder(conn, cfg, dialect.reconcileDialect, (snapshotCfg) => dialect.ensureFeatureSchema(handle, conn, snapshotCfg));\n    const { parsed, warnings, stages, messages } = await builder.build();\n    for (const message of messages) console.error(message);\n\n    // Lexical preparation is a separate capability stage. A failure leaves core usable and the\n    // dialect's own lexical marker stale, so unrelated map/peek/path/sql commands stay available.\n    if (requirements.has('lexical')) {\n      await dialect.prepareLexical?.(conn);\n    }\n\n    await builder.close();\n    return { handle, conn, cfg, dbPath, parsed, warnings, stages, observational: false };\n  } catch (err) {\n    const cleanupTasks: Array<Promise<void>> = [];\n    if (builder) {\n      const builderToClose = builder;\n      cleanupTasks.push(Promise.resolve().then(() => builderToClose.close()));\n    }\n    if (!closed) cleanupTasks.push(Promise.resolve().then(() => dialect.close(handle)));\n    const cleanup = await Promise.allSettled(cleanupTasks);\n    const cleanupErrors = cleanup.filter((result): result is PromiseRejectedResult => result.status === 'rejected').map((result) => result.reason);\n    if (cleanupErrors.length > 0) throw new AggregateError([err, ...cleanupErrors], 'opening the derived index failed and cleanup also failed');\n    throw err;\n  }\n}\n\n// A static provider can resolve its identity while embedding. Publish it only after vectors\n// succeed and only when the durable signature still matches the prepared generation.\nexport async function prepareDocumentEmbeddings(store: Store, cfg: ResolvedConfig, allowed?: ReadonlySet<string>, options: EmbedCallOptions = {}): Promise<void> {\n  options.signal?.throwIfAborted();\n  const preparedSignature = await getMeta(store, FEATURE_SIGNATURE_META_KEY);\n  options.signal?.throwIfAborted();\n  await embedPending(store, cfg, allowed, preparedSignature, options);\n  options.signal?.throwIfAborted();\n  const actualSignature = featureSignature(cfg, FEATURES);\n  if (preparedSignature === actualSignature) return;\n\n  const changedKeys = changedSignatureKeys(preparedSignature ?? '', actualSignature);\n  if (preparedSignature === null || changedKeys.size !== 1 || !changedKeys.has('embed') || !embedIdentityAdopted(preparedSignature, actualSignature)) {\n    throw notReady('the index configuration changed while vectors were being prepared');\n  }\n\n  await store.transaction(async () => {\n    options.signal?.throwIfAborted();\n    const update = await store.prepare('UPDATE meta SET value = ? WHERE key = ? AND value = ?');\n    options.signal?.throwIfAborted();\n    const result = await update.run(actualSignature, FEATURE_SIGNATURE_META_KEY, preparedSignature);\n    options.signal?.throwIfAborted();\n    if (Number(result.changes) !== 1) throw notReady('another build changed the index configuration while vectors were being prepared');\n  });\n}\n\nexport async function openWithDialect<Handle>(input: ResolvedConfig, dialect: OpenDialect<Handle>, options: InternalOpenOptions = {}): Promise<OpenResult> {\n  options.signal?.throwIfAborted();\n  const cfg = normaliseConfig(input);\n  const buildEnabled = options.build !== false;\n  const defaultRequirements = new Set<BuildRequirement>(buildEnabled ? ['core', 'lexical'] : ['core']);\n  if (buildEnabled && anyPresetEmbeds(cfg)) defaultRequirements.add('vectors');\n  const requirements = options.requirements ?? defaultRequirements;\n  const connected = buildEnabled ? await connectForBuild(cfg, dialect, requirements) : await connectExisting(cfg, dialect, requirements);\n  let store: Store | undefined;\n  try {\n    store = dialect.createStore(connected.handle, connected.conn, connected.cfg, { observational: connected.observational });\n    rekeyChunkText(connected.conn, store);\n    if (requirements.has('vectors') && buildEnabled) await prepareDocumentEmbeddings(store, connected.cfg, undefined, { signal: options.signal });\n    options.signal?.throwIfAborted();\n    return {\n      store,\n      cfg: connected.cfg,\n      dbPath: connected.dbPath,\n      parsed: connected.parsed,\n      warnings: connected.warnings,\n      stages: connected.stages,\n    };\n  } catch (err) {\n    const cleanup = await Promise.allSettled([Promise.resolve().then(() => (store ? store.close() : dialect.close(connected.handle, { observational: connected.observational })))]);\n    if (cleanup[0].status === 'rejected') throw new AggregateError([err, cleanup[0].reason], 'opening the derived index failed and cleanup also failed');\n    throw err;\n  }\n}\n\nexport async function docCount(store: Store): Promise<number> {\n  const stmt = await store.prepare('SELECT COUNT(*) AS n FROM frontmatter');\n  return ((await stmt.get()) as { n: number }).n;\n}\n"],"names":["docCount","openWithDialect","prepareDocumentEmbeddings","LOCK_POLL_MS","lockWait","channel","notReady","reason","SenseError","normaliseConfig","cfg","rootDir","baseDir","configDir","cachePath","dialect","join","STATE_DIR","filename","connectUnlocked","dbPath","options","budgetMs","deadline","err","lockWaitBudgetMs","Date","now","connect","existingOnly","existsSync","isLocked","hasSubscribers","publish","store","Math","round","Promise","resolve","setTimeout","assertCoreSchema","conn","table","prepare","all","connectExisting","requirements","handle","state","engine","wantFeatures","observational","withTransaction","version","features","ready","getMeta","FEATURE_SIGNATURE_META_KEY","CORE_READY_META_KEY","ENGINE_IDENTITY_META_KEY","schemaVersion","engineIdentity","undefined","featureSignature","FEATURES","isPublishedFeatureSignature","isCoreReady","has","assertLexicalReady","parsed","warnings","stages","stageRecorder","take","close","connectForBuild","cacheReplaced","stateDir","closed","builder","builtWith","engineChanged","recordedMaxMs","messages","message","cleanupTasks","builderToClose","cleanup","cleanupErrors","mkdirSync","recursive","exec","console","error","clearCache","checkEngine","ensureCoreSchema","setMeta","prepareConnection","setDerivedBusyTimeout","Number","min","max","createBuilder","reconcileDialect","snapshotCfg","ensureFeatureSchema","build","prepareLexical","push","then","allSettled","filter","result","status","map","length","AggregateError","allowed","preparedSignature","actualSignature","changedKeys","signal","throwIfAborted","embedPending","changedSignatureKeys","size","embedIdentityAdopted","transaction","update","run","changes","input","buildEnabled","defaultRequirements","connected","Set","anyPresetEmbeds","add","createStore","rekeyChunkText","stmt","get","n"],"mappings":"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"}

package/dist/cjs/store/sqlite/engine.d.cts

@@ -0,0 +1,12 @@
+import { type EnginePatch } from '../engine.js';
+export declare const SQLITE_ENGINE = "node:sqlite";
+export declare const SQLITE_VERSION: string | undefined;
+export declare const TOKENIZE = "porter unicode61";
+export interface SqliteFtsBuilders {
+    createContent(): string;
+    rankedMatch(whereJoin: string, whereCond: string, scopeCond: string, limit: number): string;
+}
+export declare const SQLITE_FTS_BUILDERS: SqliteFtsBuilders;
+export declare const SQLITE_PATCHES: readonly EnginePatch<SqliteFtsBuilders>[];
+export declare const sqliteIdentity: () => string;
+export declare function sqliteFts(): SqliteFtsBuilders;

package/dist/cjs/store/sqlite/engine.d.ts

@@ -0,0 +1,12 @@
+import { type EnginePatch } from '../engine.js';
+export declare const SQLITE_ENGINE = "node:sqlite";
+export declare const SQLITE_VERSION: string | undefined;
+export declare const TOKENIZE = "porter unicode61";
+export interface SqliteFtsBuilders {
+    createContent(): string;
+    rankedMatch(whereJoin: string, whereCond: string, scopeCond: string, limit: number): string;
+}
+export declare const SQLITE_FTS_BUILDERS: SqliteFtsBuilders;
+export declare const SQLITE_PATCHES: readonly EnginePatch<SqliteFtsBuilders>[];
+export declare const sqliteIdentity: () => string;
+export declare function sqliteFts(): SqliteFtsBuilders;

package/dist/cjs/store/sqlite/engine.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: Object.getOwnPropertyDescriptor(all, name).get
+    });
+}
+_export(exports, {
+    get SQLITE_ENGINE () {
+        return SQLITE_ENGINE;
+    },
+    get SQLITE_FTS_BUILDERS () {
+        return SQLITE_FTS_BUILDERS;
+    },
+    get SQLITE_PATCHES () {
+        return SQLITE_PATCHES;
+    },
+    get SQLITE_VERSION () {
+        return SQLITE_VERSION;
+    },
+    get TOKENIZE () {
+        return TOKENIZE;
+    },
+    get sqliteFts () {
+        return sqliteFts;
+    },
+    get sqliteIdentity () {
+        return sqliteIdentity;
+    }
+});
+var _enginets = require("../engine.js");
+var SQLITE_ENGINE = 'node:sqlite';
+var SQLITE_VERSION = process.versions.sqlite;
+var TOKENIZE = 'porter unicode61';
+var SQLITE_FTS_BUILDERS = {
+    createContent: function createContent() {
+        return "CREATE VIRTUAL TABLE IF NOT EXISTS content USING fts5(title, summary, text, path UNINDEXED, title_seg, summary_seg, text_seg, tokenize = '".concat(TOKENIZE, "')");
+    },
+    rankedMatch: function rankedMatch(whereJoin, whereCond, scopeCond, limit) {
+        return "SELECT content.path AS path FROM content ".concat(whereJoin, " WHERE content MATCH ? ").concat(whereCond, " ").concat(scopeCond, " ORDER BY bm25(content, 10.0, 5.0, 1.0, 0, 10.0, 5.0, 1.0) LIMIT ").concat(limit);
+    }
+};
+var SQLITE_PATCHES = [];
+var sqliteIdentity = function sqliteIdentity() {
+    return (0, _enginets.engineIdentity)(SQLITE_ENGINE, SQLITE_VERSION);
+};
+function sqliteFts() {
+    return (0, _enginets.selectBuilders)(SQLITE_FTS_BUILDERS, SQLITE_PATCHES, SQLITE_VERSION);
+}
+/* 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/sqlite/engine.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["/Users/kevin/Dev/open-source/ai/sensemaking/src/store/sqlite/engine.ts"],"sourcesContent":["import { type EnginePatch, engineIdentity, selectBuilders } from '../engine.ts';\n\n// node:sqlite is Node's bundled SQLite, so its version changes with Node rather than with an npm install.\nexport const SQLITE_ENGINE = 'node:sqlite';\nexport const SQLITE_VERSION: string | undefined = process.versions.sqlite;\n\n// unicode61 splits on spaces, so a language written without them indexes a whole run as one\n// token and word search finds nothing; the `_seg` sidecars (always populated) cover that case.\nexport const TOKENIZE = 'porter unicode61';\n\n// Every FTS5 statement this store depends on; a SQLite version that behaves differently gets a SQLITE_PATCHES entry.\nexport interface SqliteFtsBuilders {\n  // The `_seg` sidecars are appended after path, never inserted: bm25() and snippet(content, 2)\n  // are documented against the first three columns. Each holds its field's exploded unspaced runs.\n  createContent(): string;\n  // One bound parameter, the FTS5 MATCH expression; ranked by field-weighted bm25.\n  rankedMatch(whereJoin: string, whereCond: string, scopeCond: string, limit: number): string;\n}\n\nexport const SQLITE_FTS_BUILDERS: SqliteFtsBuilders = {\n  createContent: () => `CREATE VIRTUAL TABLE IF NOT EXISTS content USING fts5(title, summary, text, path UNINDEXED, title_seg, summary_seg, text_seg, tokenize = '${TOKENIZE}')`,\n  rankedMatch: (whereJoin, whereCond, scopeCond, limit) => `SELECT content.path AS path FROM content ${whereJoin} WHERE content MATCH ? ${whereCond} ${scopeCond} ORDER BY bm25(content, 10.0, 5.0, 1.0, 0, 10.0, 5.0, 1.0) LIMIT ${limit}`,\n};\n\nexport const SQLITE_PATCHES: readonly EnginePatch<SqliteFtsBuilders>[] = [];\n\nexport const sqliteIdentity = (): string => engineIdentity(SQLITE_ENGINE, SQLITE_VERSION);\n\nexport function sqliteFts(): SqliteFtsBuilders {\n  return selectBuilders(SQLITE_FTS_BUILDERS, SQLITE_PATCHES, SQLITE_VERSION);\n}\n"],"names":["SQLITE_ENGINE","SQLITE_FTS_BUILDERS","SQLITE_PATCHES","SQLITE_VERSION","TOKENIZE","sqliteFts","sqliteIdentity","process","versions","sqlite","createContent","rankedMatch","whereJoin","whereCond","scopeCond","limit","engineIdentity","selectBuilders"],"mappings":";;;;;;;;;;;QAGaA;eAAAA;;QAgBAC;eAAAA;;QAKAC;eAAAA;;QApBAC;eAAAA;;QAIAC;eAAAA;;QAoBGC;eAAAA;;QAFHC;eAAAA;;;wBA1BoD;AAG1D,IAAMN,gBAAgB;AACtB,IAAMG,iBAAqCI,QAAQC,QAAQ,CAACC,MAAM;AAIlE,IAAML,WAAW;AAWjB,IAAMH,sBAAyC;IACpDS,eAAe,SAAfA;eAAqB,AAAC,6IAAqJ,OAATN,UAAS;;IAC3KO,aAAa,SAAbA,YAAcC,WAAWC,WAAWC,WAAWC;eAAU,AAAC,4CAA8EF,OAAnCD,WAAU,2BAAsCE,OAAbD,WAAU,KAAgFE,OAA7ED,WAAU,qEAAyE,OAANC;;AACpO;AAEO,IAAMb,iBAA4D,EAAE;AAEpE,IAAMI,iBAAiB;WAAcU,IAAAA,wBAAc,EAAChB,eAAeG;;AAEnE,SAASE;IACd,OAAOY,IAAAA,wBAAc,EAAChB,qBAAqBC,gBAAgBC;AAC7D"}

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

@@ -9,6 +9,7 @@ Object.defineProperty(exports, "queryLexical", {
     }
 });
 var _segmentts = require("../../text/segment.js");
+var _enginets = require("./engine.js");
 function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
     try {
         var info = gen[key](arg);
@@ -134,10 +135,9 @@ function _ts_generator(thisArg, body) {
         };
     }
 }
-var WEIGHTED_BM25 = 'bm25(content, 10.0, 5.0, 1.0, 0, 10.0, 5.0, 1.0)';
 function queryLexical(conn, terms, opts) {
     return _async_to_generator(function() {
-        var whereJoin, whereCond, scopeCond, limit, query, sql, stmt;
+        var whereJoin, whereCond, scopeCond, limit, query, stmt;
         return _ts_generator(this, function(_state) {
             switch(_state.label){
                 case 0:
@@ -149,10 +149,9 @@ function queryLexical(conn, terms, opts) {
                         2,
                         []
                     ];
-                    sql = "SELECT content.path AS path FROM content ".concat(whereJoin, " WHERE content MATCH ? ").concat(whereCond, " ").concat(scopeCond, " ORDER BY ").concat(WEIGHTED_BM25, " LIMIT ").concat(limit);
                     return [
                         4,
-                        conn.prepare(sql)
+                        conn.prepare((0, _enginets.sqliteFts)().rankedMatch(whereJoin, whereCond, scopeCond, limit))
                     ];
                 case 1:
                     stmt = _state.sent();