sensemaking 0.27.0 → 0.28.0

package/dist/cjs/store/native.js

@@ -14,12 +14,16 @@ _export(exports, {
     },
     get packageNodeModules () {
         return packageNodeModules;
+    },
+    get peerRange () {
+        return peerRange;
     }
 });
 var _nodefs = require("node:fs");
 var _nodemodule = /*#__PURE__*/ _interop_require_default(require("node:module"));
 var _nodepath = require("node:path");
 var _nodeurl = require("node:url");
+var _semver = /*#__PURE__*/ _interop_require_default(require("semver"));
 var _errorsts = require("../errors.js");
 function _array_like_to_array(arr, len) {
     if (len == null || len > arr.length) len = arr.length;
@@ -212,19 +216,33 @@ function _unsupported_iterable_to_array(o, minLen) {
 // ~110MB), so it is required lazily inside the gated branch below, not for every store/index.ts load.
 var _require = typeof require === 'undefined' ? _nodemodule.default.createRequire(require("url").pathToFileURL(__filename).toString()) : require;
 var _dirname = (0, _nodepath.dirname)(typeof __filename !== 'undefined' ? __filename : (0, _nodeurl.fileURLToPath)(require("url").pathToFileURL(__filename).toString()));
-function packageNodeModules() {
+// Walks up from this file's own directory rather than a fixed dot-count: it sits at a
+// different depth under src/ than under built dist/{cjs,esm}/store output.
+function packageRoot() {
     var dir = _dirname;
     for(;;){
         var candidate = (0, _nodepath.join)(dir, 'package.json');
         if ((0, _nodefs.existsSync)(candidate)) {
-            var pkg = JSON.parse((0, _nodefs.readFileSync)(candidate, 'utf8'));
-            if (pkg.name === 'sensemaking') return (0, _nodepath.join)(dir, 'node_modules');
+            var manifest = JSON.parse((0, _nodefs.readFileSync)(candidate, 'utf8'));
+            if (manifest.name === 'sensemaking') return {
+                dir: dir,
+                manifest: manifest
+            };
         }
         var parent = (0, _nodepath.dirname)(dir);
         if (parent === dir) throw new Error('could not locate the sensemaking package root to install a native dependency into');
         dir = parent;
     }
 }
+function packageNodeModules() {
+    return (0, _nodepath.join)(packageRoot().dir, 'node_modules');
+}
+function peerRange(pkg) {
+    var _packageRoot_manifest_peerDependencies;
+    var range = (_packageRoot_manifest_peerDependencies = packageRoot().manifest.peerDependencies) === null || _packageRoot_manifest_peerDependencies === void 0 ? void 0 : _packageRoot_manifest_peerDependencies[pkg];
+    if (!range) throw new Error("sensemaking's package.json declares no peerDependencies entry for ".concat(pkg));
+    return range;
+}
 var installing = new Map();
 // De-dupes concurrent installs: since the install is async, concurrent callers await the same
 // in-flight promise, keyed by specifier and target. A failed install is not cached, so a later call retries.
@@ -241,6 +259,13 @@ function installOnce(specifier, nodeModulesPath) {
     }
     return promise;
 }
+function readPackageMetadata(pkgDir) {
+    try {
+        return JSON.parse((0, _nodefs.readFileSync)((0, _nodepath.join)(pkgDir, 'package.json'), 'utf8'));
+    } catch (unused) {
+        return undefined;
+    }
+}
 // Node caches a bare specifier's resolution, including a "not found" miss, for the process
 // lifetime; use the installed entry directly, as a URL for ESM and a path for CJS.
 function resolveEntrySpecifier(importName, nodeModulesPath) {
@@ -253,32 +278,12 @@ function resolveEntrySpecifier(importName, nodeModulesPath) {
     var entryPath = (0, _nodepath.join)(pkgDir, entry);
     return typeof require === 'undefined' ? (0, _nodeurl.pathToFileURL)(entryPath).href : entryPath;
 }
-function readPackageMetadata(pkgDir) {
-    try {
-        return JSON.parse((0, _nodefs.readFileSync)((0, _nodepath.join)(pkgDir, 'package.json'), 'utf8'));
-    } catch (unused) {
-        return undefined;
-    }
-}
-function targetPackageMetadata(importName, nodeModulesPath) {
-    var pkgDir = _nodepath.join.apply(void 0, [
-        nodeModulesPath
-    ].concat(_to_consumable_array(importName.split('/'))));
-    return {
-        exists: (0, _nodefs.existsSync)(pkgDir),
-        metadata: readPackageMetadata(pkgDir)
-    };
-}
-function resolvedPackageMetadata(importName) {
+function resolvedVersion(importName) {
     try {
         var dir = (0, _nodepath.dirname)(_require.resolve(importName));
         for(;;){
-            var manifest = (0, _nodepath.join)(dir, 'package.json');
-            if ((0, _nodefs.existsSync)(manifest)) {
-                var pkg = readPackageMetadata(dir);
-                if (!pkg) return undefined;
-                if (pkg.name === importName) return pkg;
-            }
+            var pkg = readPackageMetadata(dir);
+            if ((pkg === null || pkg === void 0 ? void 0 : pkg.name) === importName) return pkg.version;
             var parent = (0, _nodepath.dirname)(dir);
             if (parent === dir) return undefined;
             dir = parent;
@@ -287,35 +292,26 @@ function resolvedPackageMetadata(importName) {
         return undefined;
     }
 }
-function versionContractError(descriptor, installed) {
-    var _descriptor_installSpec;
-    var installSpec = (_descriptor_installSpec = descriptor.installSpec) !== null && _descriptor_installSpec !== void 0 ? _descriptor_installSpec : descriptor.pkg;
-    var detail = installed ? "".concat(descriptor.pkg, "@").concat(installed, " is installed") : "".concat(descriptor.pkg, " has missing or unreadable version metadata");
-    return new _errorsts.SenseError('STORE_DEPENDENCY_MISSING', 'store "'.concat(descriptor.store, '" needs ').concat(installSpec, ", but ").concat(detail, "; refusing to overwrite it -- run `npm install ").concat(installSpec, "` yourself and try again"));
-}
-function assertExpectedVersion(descriptor, metadata) {
-    if (!descriptor.version) return;
-    if (!(metadata === null || metadata === void 0 ? void 0 : metadata.version) || metadata.version !== descriptor.version) throw versionContractError(descriptor, metadata === null || metadata === void 0 ? void 0 : metadata.version);
+// Any installed version is used; one outside the tested range is reported, not refused (the store's engine check decides).
+function reportVersion(descriptor, version) {
+    if (version && _semver.default.satisfies(version, descriptor.range)) return;
+    console.error('sense: store "'.concat(descriptor.store, '" using ').concat(descriptor.pkg, "@").concat(version !== null && version !== void 0 ? version : 'unknown version', " (tested ").concat(descriptor.range, ")"));
 }
 function loadOrInstall(_0, _1) {
     return _async_to_generator(function(descriptor, nodeModulesPath) {
-        var importName, target, loaded, unused, _descriptor_installSpec, _descriptor_installSpec1, installSpec, displaySpec, installErr, loaded1, loadErr;
+        var importName, api, version, unused, spec, installSpec, installErr, _readPackageMetadata, api1, version1, loadErr;
         var _arguments = arguments;
         return _ts_generator(this, function(_state) {
             switch(_state.label){
                 case 0:
                     importName = _arguments.length > 2 && _arguments[2] !== void 0 ? _arguments[2] : descriptor.pkg;
-                    if (descriptor.version) {
-                        target = targetPackageMetadata(importName, nodeModulesPath);
-                        if (target.exists) assertExpectedVersion(descriptor, target.metadata);
-                    }
                     _state.label = 1;
                 case 1:
                     _state.trys.push([
                         1,
                         3,
                         ,
-                        11
+                        4
                     ]);
                     return [
                         4,
@@ -324,43 +320,53 @@ function loadOrInstall(_0, _1) {
                         })
                     ];
                 case 2:
-                    loaded = _state.sent();
+                    api = _state.sent();
+                    version = resolvedVersion(importName);
+                    reportVersion(descriptor, version);
                     return [
-                        3,
-                        11
+                        2,
+                        {
+                            api: api,
+                            version: version
+                        }
                     ];
                 case 3:
                     unused = _state.sent();
-                    installSpec = (_descriptor_installSpec = descriptor.installSpec) !== null && _descriptor_installSpec !== void 0 ? _descriptor_installSpec : importName;
-                    displaySpec = (_descriptor_installSpec1 = descriptor.installSpec) !== null && _descriptor_installSpec1 !== void 0 ? _descriptor_installSpec1 : descriptor.pkg;
-                    console.error('sense: store "'.concat(descriptor.store, '" needs ').concat(displaySpec, "; installing it now (one-time download, ").concat(descriptor.sizeHint, ")..."));
-                    _state.label = 4;
+                    return [
+                        3,
+                        4
+                    ];
                 case 4:
+                    spec = "".concat(descriptor.pkg, "@").concat(descriptor.range);
+                    installSpec = "".concat(importName, "@").concat(descriptor.range);
+                    console.error('sense: store "'.concat(descriptor.store, '" needs ').concat(spec, "; installing it now (one-time download, ").concat(descriptor.sizeHint, ")..."));
+                    _state.label = 5;
+                case 5:
                     _state.trys.push([
-                        4,
-                        6,
+                        5,
+                        7,
                         ,
-                        7
+                        8
                     ]);
                     return [
                         4,
                         installOnce(installSpec, nodeModulesPath)
                     ];
-                case 5:
+                case 6:
                     _state.sent();
                     return [
                         3,
-                        7
+                        8
                     ];
-                case 6:
-                    installErr = _state.sent();
-                    throw new _errorsts.SenseError('STORE_DEPENDENCY_MISSING', 'store "'.concat(descriptor.store, '" needs ').concat(displaySpec, ", and installing it automatically failed (").concat(installErr.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 ").concat(displaySpec, "` yourself and try again"));
                 case 7:
+                    installErr = _state.sent();
+                    throw new _errorsts.SenseError('STORE_DEPENDENCY_MISSING', 'store "'.concat(descriptor.store, '" needs ').concat(spec, ", and installing it automatically failed (").concat(installErr.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 ").concat(spec, "` yourself and try again"));
+                case 8:
                     _state.trys.push([
-                        7,
-                        9,
+                        8,
+                        10,
                         ,
-                        10
+                        11
                     ]);
                     return [
                         4,
@@ -368,26 +374,25 @@ function loadOrInstall(_0, _1) {
                             return /*#__PURE__*/ _interop_require_wildcard(require(p));
                         })
                     ];
-                case 8:
-                    loaded1 = _state.sent();
-                    assertExpectedVersion(descriptor, targetPackageMetadata(importName, nodeModulesPath).metadata);
+                case 9:
+                    api1 = _state.sent();
+                    version1 = (_readPackageMetadata = readPackageMetadata(_nodepath.join.apply(void 0, [
+                        nodeModulesPath
+                    ].concat(_to_consumable_array(importName.split('/')))))) === null || _readPackageMetadata === void 0 ? void 0 : _readPackageMetadata.version;
+                    reportVersion(descriptor, version1);
                     return [
                         2,
-                        loaded1
+                        {
+                            api: api1,
+                            version: version1
+                        }
                     ];
-                case 9:
-                    loadErr = _state.sent();
-                    throw new _errorsts.SenseError('STORE_DEPENDENCY_MISSING', 'store "'.concat(descriptor.store, '" installed ').concat(displaySpec, " but it could not be loaded (").concat(loadErr.message, "); it may not be available for this platform (").concat(process.platform, "-").concat(process.arch, ") -- run `npm install ").concat(displaySpec, "` to see the underlying error"));
                 case 10:
-                    return [
-                        3,
-                        11
-                    ];
+                    loadErr = _state.sent();
+                    throw new _errorsts.SenseError('STORE_DEPENDENCY_MISSING', 'store "'.concat(descriptor.store, '" installed ').concat(spec, " but it could not be loaded (").concat(loadErr.message, "); it may not be available for this platform (").concat(process.platform, "-").concat(process.arch, ") -- run `npm install ").concat(spec, "` to see the underlying error"));
                 case 11:
-                    if (descriptor.version) assertExpectedVersion(descriptor, resolvedPackageMetadata(importName));
                     return [
-                        2,
-                        loaded
+                        2
                     ];
             }
         });

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

@@ -1 +1 @@
-{"version":3,"sources":["/Users/kevin/Dev/OpenSource/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
                     ];