sweet-search 2.4.2 → 2.5.2

package/core/infrastructure/init-config.js

@@ -0,0 +1,216 @@
+/**
+ * Shared reader/writer for the init-managed `.sweet-search/config.json`
+ * file. Owned by the infrastructure layer because both `scripts/init.js`
+ * (writer) and `core/search/sweet-search.js` (reader) need it; placing
+ * the helper here avoids a runtime → scripts dependency that would break
+ * the DDD boundary check.
+ *
+ * The file shape is documented in `scripts/init.js::buildConfig` — this
+ * module only loads/writes raw JSON, never validates business invariants.
+ */
+
+import { existsSync, readFileSync, renameSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+
+import { LATE_INTERACTION_CONFIG } from './config/ranking.js';
+
+export const INIT_DATA_DIR_NAME = '.sweet-search';
+export const INIT_CONFIG_FILE_NAME = 'config.json';
+
+/**
+ * Path to the project's persisted init config. Pure path math — does not
+ * verify the file exists.
+ */
+export function getInitConfigPath(projectRoot) {
+  return join(projectRoot, INIT_DATA_DIR_NAME, INIT_CONFIG_FILE_NAME);
+}
+
+/**
+ * Load the persisted init config. Returns null when the file is missing
+ * or unparseable — never throws. Callers fall back to defaults / env.
+ *
+ * @param {string} projectRootOrDataDir - either the project root or the
+ *   `.sweet-search/` directory itself (init.js passes the latter).
+ */
+export function loadInitConfig(projectRootOrDataDir) {
+  const candidates = [
+    join(projectRootOrDataDir, INIT_CONFIG_FILE_NAME),
+    join(projectRootOrDataDir, INIT_DATA_DIR_NAME, INIT_CONFIG_FILE_NAME),
+  ];
+  for (const p of candidates) {
+    if (existsSync(p)) {
+      try {
+        return JSON.parse(readFileSync(p, 'utf-8'));
+      } catch {
+        return null;
+      }
+    }
+  }
+  return null;
+}
+
+/**
+ * Atomically write the init config (tmp + rename). Caller passes a
+ * directory that already exists (init.js's `ensureDataDir`). Returns
+ * the path that was written.
+ */
+export function writeInitConfig(dataDir, config) {
+  const configPath = join(dataDir, INIT_CONFIG_FILE_NAME);
+  const tmpPath = configPath + '.tmp';
+  writeFileSync(tmpPath, JSON.stringify(config, null, 2) + '\n', 'utf-8');
+  renameSync(tmpPath, configPath);
+  return configPath;
+}
+
+/**
+ * Convenience accessor for the LI-policy section of the persisted init
+ * config. Returns `{ liModel, searchReranking }` if either field is
+ * present, otherwise an empty object — the resolver treats absent fields
+ * as "fall through to auto / config defaults".
+ */
+export function readPersistedLiPolicy(projectRoot) {
+  const cfg = loadInitConfig(projectRoot);
+  if (!cfg || typeof cfg !== 'object') return {};
+  const li = cfg.runtime?.li;
+  if (!li || typeof li !== 'object') return {};
+  const out = {};
+  if (typeof li.model === 'string') out.liModel = li.model;
+  if (typeof li.searchReranking === 'string') out.searchReranking = li.searchReranking;
+  return out;
+}
+
+// ---------------------------------------------------------------------------
+// Runtime LI model resolution (Phase 4 follow-up).
+//
+// Background: scripts/init.js writes the user's chosen LI variant into
+// `runtime.li.model` of `.sweet-search/config.json` (one of 'lateon-code',
+// 'lateon-code-edge', or 'none'). However the runtime late-interaction
+// machinery — encodeQuery, the LI index header check, the native model
+// loader, the CoreML cascade dispatcher, the indexer, the prewarm hook —
+// all read `LATE_INTERACTION_CONFIG.model` directly from
+// `core/infrastructure/config/ranking.js`, which only honours
+// `process.env.SWEET_SEARCH_LATE_INTERACTION_MODEL`. Without this bridge
+// an edge-only init would silently boot the standard model on every search,
+// breaking `read-semantic`, ColGrep, and every encodeQuery path even when
+// the persisted choice is correct.
+//
+// `applyPersistedLiModel` closes that gap. It is called from one place per
+// process entry point (SweetSearch ctor, read-semantic CLI/API, server
+// startup, prewarm hook) and is fully idempotent + cheap.
+//
+// Precedence (most-specific wins):
+//   1. explicit env var SWEET_SEARCH_LATE_INTERACTION_MODEL  (CI / scripts)
+//   2. persisted runtime.li.model in .sweet-search/config.json
+//   3. config default ('lateon-code')
+//
+// `'none'` from persisted config maps to the same disabled state the
+// indexer's `--no-late-interaction` flag uses (`model = false`), so
+// `LATE_INTERACTION_CONFIG.enabled` collapses to false everywhere LI is
+// consulted.
+// ---------------------------------------------------------------------------
+
+const VALID_RUNTIME_LI_MODEL_IDS = new Set([
+  'lateon-code',
+  'lateon-code-edge',
+  'none',
+]);
+
+/**
+ * Resolve the active LI runtime model id given precedence inputs. Pure;
+ * does no I/O of its own. Caller passes in the persisted record (or null).
+ *
+ * Returns one of:
+ *   - 'lateon-code'      → standard variant
+ *   - 'lateon-code-edge' → edge variant
+ *   - false              → LI disabled (matches index-codebase-v21's `--no-late-interaction`)
+ *
+ * @param {string|null|undefined} persistedModel
+ * @param {object} [env=process.env]
+ * @param {string} [defaultModel='lateon-code']
+ */
+export function resolveRuntimeLiModel(
+  persistedModel,
+  env = process.env,
+  defaultModel = 'lateon-code',
+) {
+  // 1. Explicit env override always wins (preserves the CI/script contract
+  //    documented on LATE_INTERACTION_CONFIG.model).
+  const fromEnv = env?.SWEET_SEARCH_LATE_INTERACTION_MODEL;
+  if (typeof fromEnv === 'string' && fromEnv.length > 0) {
+    if (fromEnv === 'none') return false;
+    if (fromEnv === 'false') return false;
+    return fromEnv;
+  }
+  // 2. Persisted choice from .sweet-search/config.json.
+  if (typeof persistedModel === 'string' && VALID_RUNTIME_LI_MODEL_IDS.has(persistedModel)) {
+    if (persistedModel === 'none') return false;
+    return persistedModel;
+  }
+  // 3. Default — preserves the historical 'lateon-code' fallback.
+  return defaultModel;
+}
+
+/**
+ * Apply the persisted LI model choice from `.sweet-search/config.json`
+ * to the global `LATE_INTERACTION_CONFIG.model`, honouring the precedence
+ * ladder documented above. Idempotent + cheap; safe to call from every
+ * runtime entry point.
+ *
+ * Returns a small report object so the caller can log / surface the
+ * decision when verbose. Never throws.
+ *
+ *   {
+ *     applied:   'lateon-code' | 'lateon-code-edge' | false,
+ *     before:    <prior LATE_INTERACTION_CONFIG.model>,
+ *     source:    'env' | 'persisted' | 'default',
+ *     persistedModel: <raw persisted value or null>,
+ *     changed:   boolean,
+ *   }
+ *
+ * @param {string} projectRoot
+ * @param {object} [opts]
+ * @param {object} [opts.env=process.env]
+ * @param {boolean} [opts.force=false] — when true, applies even if the
+ *   active value already matches (used by tests resetting state).
+ */
+export function applyPersistedLiModel(projectRoot, opts = {}) {
+  const env = opts.env ?? process.env;
+
+  const before = LATE_INTERACTION_CONFIG.model;
+
+  let persistedModel = null;
+  try {
+    const persisted = readPersistedLiPolicy(projectRoot);
+    persistedModel = typeof persisted.liModel === 'string' ? persisted.liModel : null;
+  } catch {
+    persistedModel = null;
+  }
+
+  const resolved = resolveRuntimeLiModel(persistedModel, env, 'lateon-code');
+
+  let source;
+  if (typeof env?.SWEET_SEARCH_LATE_INTERACTION_MODEL === 'string'
+      && env.SWEET_SEARCH_LATE_INTERACTION_MODEL.length > 0) {
+    source = 'env';
+  } else if (persistedModel != null && VALID_RUNTIME_LI_MODEL_IDS.has(persistedModel)) {
+    source = 'persisted';
+  } else {
+    source = 'default';
+  }
+
+  if (opts.force === true || resolved !== before) {
+    // Mutates the shared LATE_INTERACTION_CONFIG singleton — this is the
+    // entire point of this helper. The ESM namespace binding is read-only
+    // but the OBJECT it references is the same reference every consumer
+    // (encodeQuery, indexer, native-inference, prewarm) holds.
+    LATE_INTERACTION_CONFIG.model = resolved;
+  }
+
+  return {
+    applied: resolved,
+    before,
+    source,
+    persistedModel,
+    changed: resolved !== before,
+  };
+}

package/core/infrastructure/language-patterns/registry-core.js

@@ -82,12 +82,30 @@ export const CORE_LANGUAGES = {
       relationships: {
         extends: /class\s+\w+\s+extends\s+(\w+)/,
         implements: /class\s+\w+(?:\s+extends\s+\w+)?\s+implements\s+([\w,\s]+)/,
+        // TS-specific: interface extends interface(s). Captures the
+        // comma-separated list (with optional generics) — splitting is
+        // handled by expandRelationshipTargets() via MULTI_TARGET_TYPES.
+        // Capture is lazy and bounded by either the opening `{` of the
+        // body or end-of-line, which covers both `extends X {`,
+        // `extends X {}` (empty body) and continuation-line `extends X`.
+        interfaceExtends: /^(?:export\s+)?interface\s+\w+(?:<[^>]*>)?\s+extends\s+([\w,\s<>.]+?)\s*(?:\{|$)/,
+        // TS-specific: explicit type-only imports/re-exports.
+        // The body of `import { type Foo, Bar }` (mixed inline-type
+        // imports) is still picked up by the regular `import` pattern
+        // for module-level dependency tracking; we don't try to split
+        // type/value at member level in regex.
+        typeImport: /^import\s+type\s+(?:\{[^}]+\}|\*\s+as\s+\w+|\w+)\s+from\s+['"]([^'"]+)['"]/,
+        typeReexport: /^export\s+type\s+(?:\{[^}]+\}|\*)\s+from\s+['"]([^'"]+)['"]/,
         import: /import\s+(?:\{([^}]+)\}|(\w+))\s+from\s+['"]([^'"]+)['"]/,
         require: /(?:const|let|var)\s+(?:\{[^}]+\}|\w+)\s*=\s*require\s*\(\s*['"]([^'"]+)['"]\s*\)/,
         reexport: /export\s+(?:\{[^}]+\}|\*)\s+from\s+['"]([^'"]+)['"]/,
         dynamicImport: /(?:await\s+)?import\s*\(\s*['"]([^'"]+)['"]\s*\)/,
         methodCall: /(\w+)\s*\.\s*(\w+)\s*\(/,
         decorator: /^@(\w+(?:\.\w+)*)/,
+        // TS-specific: generic constraints `<T extends Bar>`. JSX is
+        // safe because `<Component prop=...>` has no `extends` keyword;
+        // matching is conservative on the literal `extends` token.
+        genericConstraint: /<\s*\w+\s+extends\s+(\w+)/,
       },
       skipCallObjects: ["console", "Math", "JSON", "Object", "Array", "Promise", "process", "Buffer", "Date"],
     },

package/core/infrastructure/model-registry.js

@@ -103,6 +103,18 @@ export const MODEL_REGISTRY = {
     ],
   },
 
+  'lateon-code-edge-fp32': {
+    hfId: 'lightonai/LateOn-Code-edge',
+    profile: 'full',
+    description: 'Late interaction edge model (FP32 safetensors, backbone 256d, 2-stage projection) for native inference',
+    files: [
+      { path: 'model.safetensors', sizeBytes: 67195976, sha256: '7ffc36b8ff71367249cd5220dbdd4bdbe177bc0e305b2e978a8b598bd8296f04' },
+      { path: '1_Dense/model.safetensors', sizeBytes: 524376, sha256: '9efb17fcb2106cd8fcb01d57a9cd9c997a487ad20630ec8e44ce3f9d89efe0a7' },
+      { path: '2_Dense/model.safetensors', sizeBytes: 98392, sha256: 'a7a388138b3c4bb1a81c8c3bcb9de123f1e652b9e9464a72707ca19ee86a26b1' },
+      { path: 'config.json', sizeBytes: 1252, sha256: null },
+    ],
+  },
+
   'ms-marco-tinybert': {
     hfId: 'Xenova/ms-marco-TinyBERT-L-2-v2',
     profile: 'full',

package/core/infrastructure/native-inference.js

@@ -55,6 +55,7 @@ import { getModelCacheDir, fetchModel } from './model-fetcher.js';
 import { getModelEntry } from './model-registry.js';
 import { getCoremlCascadeResolvedDirs } from './coreml-cascade.js';
 import { detectHardwareCapability } from './hardware-capability.js';
+import { LATE_INTERACTION_CONFIG } from './config/ranking.js';
 
 const require = createRequire(import.meta.url);
 
@@ -63,12 +64,21 @@ const require = createRequire(import.meta.url);
 let _addon = null;
 let _embeddingModel = null;
 let _embeddingModelLoadPromise = null; // race-gate for concurrent first calls
-let _liModel = null;
-let _liModelLoadPromise = null;
+// Per-variant LI model cache. Keyed by FP32 registry key
+// ('lateon-code-fp32' or 'lateon-code-edge-fp32') so a variant swap
+// inside a single process (e.g. ORT-eval session followed by native
+// indexing) doesn't return a stale model. Each entry is
+// `{ model, promise }` where `promise` race-gates concurrent first
+// calls and `model` becomes non-null on resolution.
+const _liModels = new Map();
 let _embTokenizer = null;
 let _embTokenizerLoadPromise = null;
-let _liTokenizer = null;
-let _liTokenizerLoadPromise = null;
+// Per-variant LI tokenizer cache. Keyed by tokenizer source key
+// (matches the ORT-side registry key — `lateon-code` /
+// `lateon-code-edge`). Standard and edge tokenizer.json files are
+// byte-identical today but per-variant resolution is correct and
+// future-proof.
+const _liTokenizers = new Map();
 let _available = null;
 let _coremlCascadeLogged = false;
 
@@ -123,12 +133,17 @@ function propagateCudaComputeCapToAddonEnv() {
  * Logged exactly once per process so a mis-configured cascade surfaces
  * at startup instead of silently falling through on every call.
  *
+ * Routes the LI cascade dir to `coreml-cascade/li/` (standard) or
+ * `coreml-cascade/li-edge/` (edge) based on the active variant in
+ * `LATE_INTERACTION_CONFIG`. The embed cascade is shared.
+ *
  * Always returns an object — never throws. The returned dirs can be
  * `null`, which the Rust addon treats as "CoreML path disabled" and
  * falls back to candle unconditionally.
  */
 function resolveCoremlCascadeForAddon() {
-  const resolved = getCoremlCascadeResolvedDirs();
+  const liVariantKey = LATE_INTERACTION_CONFIG.model;
+  const resolved = getCoremlCascadeResolvedDirs(liVariantKey);
   if (!_coremlCascadeLogged) {
     _coremlCascadeLogged = true;
     const hw = detectHardwareCapability();
@@ -137,7 +152,7 @@ function resolveCoremlCascadeForAddon() {
     if (resolved.embedDir || resolved.liDir) {
       process.stderr.write(
         `[NativeInference] CoreML cascade: ${resolved.status}` +
-        ` (embed=${resolved.embedDir ? 'yes' : 'no'}, li=${resolved.liDir ? 'yes' : 'no'},` +
+        ` (embed=${resolved.embedDir ? 'yes' : 'no'}, li=${resolved.liDir ? 'yes' : 'no'} [${liVariantKey}],` +
         ` chip=${hw.brandString || 'unknown'})\n`
       );
     } else if (hw.coremlCascadeEligible) {
@@ -327,57 +342,117 @@ export async function nativeEmbed(texts, options = {}) {
 // ─── Late Interaction Model ───
 
 /**
- * Load the native LI model (LateOn-Code FP32 safetensors + projection).
- * Returns the model instance or null if unavailable. Race-gated.
+ * Resolve the active LI variant from `LATE_INTERACTION_CONFIG`. Returns
+ * the manifest the native loaders need (registry keys + projection
+ * paths and dims). Pure helper — no I/O, no caching.
+ *
+ * Falls back to the standard `lateon-code` entry if the active config
+ * is missing fields (defensive — every shipping config has them).
  */
-export async function getNativeLiModel() {
-  if (_liModel) return _liModel;
-  if (_liModelLoadPromise) return _liModelLoadPromise;
-  _liModelLoadPromise = (async () => {
+export function resolveNativeLiVariant() {
+  const cfg = LATE_INTERACTION_CONFIG.activeModel;
+  const cfgKey = LATE_INTERACTION_CONFIG.model;
+  if (!cfg) {
+    throw new Error(
+      `[NativeInference] LATE_INTERACTION_CONFIG.model='${cfgKey}' is not a known variant`,
+    );
+  }
+  const fp32RegistryKey = cfg.nativeRegistryKey || `${cfgKey}-fp32`;
+  return {
+    cfgKey,                                   // 'lateon-code' | 'lateon-code-edge'
+    fp32RegistryKey,                          // 'lateon-code-fp32' | 'lateon-code-edge-fp32'
+    tokenizerKey: cfgKey,                     // tokenizer lives next to the ORT model
+    projectionPaths: cfg.projectionPaths,     // ['1_Dense/...'] | ['1_Dense/...', '2_Dense/...']
+    projectionDims: cfg.projectionDims,       // [128] | [512, 48]
+    tokenDimension: cfg.tokenDimension,       // 128 | 48
+  };
+}
+
+/**
+ * Internal: load the native LI model for a specific variant on the
+ * default device. Race-gated per variant via the `_liModels` Map so
+ * concurrent first callers share one load. Returns null if the addon
+ * isn't available or required files are missing.
+ */
+async function loadNativeLiVariantOnDefaultDevice(variant) {
+  const cached = _liModels.get(variant.fp32RegistryKey);
+  if (cached?.model) return cached.model;
+  if (cached?.promise) return cached.promise;
+
+  const promise = (async () => {
     const addon = loadAddon();
     if (!addon?.NativeLateInteractionModel) return null;
 
-    await fetchModel('lateon-code-fp32');
+    await fetchModel(variant.fp32RegistryKey);
 
-    const entry = getModelEntry('lateon-code-fp32');
+    const entry = getModelEntry(variant.fp32RegistryKey);
     const modelDir = getModelCacheDir(entry.hfId);
     const backbonePath = join(modelDir, 'model.safetensors');
-    const projPath = join(modelDir, '1_Dense', 'model.safetensors');
     const configPath = join(modelDir, 'config.json');
+    const projAbsPaths = variant.projectionPaths.map((p) => join(modelDir, p));
 
-    if (!existsSync(backbonePath) || !existsSync(projPath) || !existsSync(configPath)) return null;
+    if (!existsSync(backbonePath) || !existsSync(configPath)) return null;
+    if (!projAbsPaths.every(existsSync)) return null;
 
     // Resolve the CoreML cascade dir for ModernBERT LI. Same contract
-    // as the embedding model above — see that comment.
+    // as the embedding model above — see that comment. The dir
+    // depends on the active variant (`coreml-cascade/li/` vs
+    // `coreml-cascade/li-edge/`).
     const cascade = resolveCoremlCascadeForAddon();
 
     const t0 = Date.now();
-    _liModel = addon.NativeLateInteractionModel.load(
+    const model = addon.NativeLateInteractionModel.load(
       backbonePath,
-      projPath,
+      projAbsPaths,
+      variant.projectionDims,
       configPath,
       cascade.liDir || undefined,
     );
-    console.log(`[NativeInference] LI model loaded in ${Date.now() - t0}ms (dim: ${_liModel.dim}, device: ${addon.nativeInferenceDevice()})`);
+    console.log(
+      `[NativeInference] LI model '${variant.cfgKey}' loaded in ${Date.now() - t0}ms `
+      + `(dim: ${model.dim}, device: ${addon.nativeInferenceDevice()})`,
+    );
 
-    return _liModel;
+    const slot = _liModels.get(variant.fp32RegistryKey);
+    if (slot) slot.model = model;
+    return model;
   })();
-  return _liModelLoadPromise;
+
+  _liModels.set(variant.fp32RegistryKey, { model: null, promise });
+  return promise;
+}
+
+/**
+ * Load the native LI model for the currently-configured variant.
+ * Returns the model instance or null if unavailable. Race-gated per
+ * variant.
+ */
+export async function getNativeLiModel() {
+  const variant = resolveNativeLiVariant();
+  return loadNativeLiVariantOnDefaultDevice(variant);
 }
 
 /**
- * Get or create the LI tokenizer. Race-gated.
+ * Get or create the LI tokenizer for the currently-configured variant.
+ * Race-gated per variant via the `_liTokenizers` Map.
  */
 async function getLiTokenizer() {
-  if (_liTokenizer) return _liTokenizer;
-  if (_liTokenizerLoadPromise) return _liTokenizerLoadPromise;
-  _liTokenizerLoadPromise = (async () => {
-    const entry = getModelEntry('lateon-code');
+  const variant = resolveNativeLiVariant();
+  const cached = _liTokenizers.get(variant.tokenizerKey);
+  if (cached?.tokenizer) return cached.tokenizer;
+  if (cached?.promise) return cached.promise;
+
+  const promise = (async () => {
+    const entry = getModelEntry(variant.tokenizerKey);
     const tokenizerPath = join(getModelCacheDir(entry.hfId), 'tokenizer.json');
-    _liTokenizer = await createTokenizer(tokenizerPath);
-    return _liTokenizer;
+    const tokenizer = await createTokenizer(tokenizerPath);
+    const slot = _liTokenizers.get(variant.tokenizerKey);
+    if (slot) slot.tokenizer = tokenizer;
+    return tokenizer;
   })();
-  return _liTokenizerLoadPromise;
+
+  _liTokenizers.set(variant.tokenizerKey, { tokenizer: null, promise });
+  return promise;
 }
 
 /**
@@ -457,7 +532,11 @@ export function isNativeEmbeddingModelLoaded() {
 }
 
 export function isNativeLiModelLoaded() {
-  return _liModel != null;
+  // True only when the *active* variant is loaded — a stale standard
+  // model lingering after a config swap to edge would otherwise
+  // mask the fact that edge encoding still has to load.
+  const variant = resolveNativeLiVariant();
+  return _liModels.get(variant.fp32RegistryKey)?.model != null;
 }
 
 // ─── Device-explicit loading ───
@@ -518,28 +597,32 @@ export async function loadNativeEmbeddingModelWithDevice(deviceKind, cascadeDirO
 }
 
 /**
- * Load the native LI model on a specific device.
+ * Load the native LI model on a specific device for the
+ * currently-configured variant. Race-gated per variant.
  */
 export async function loadNativeLiModelWithDevice(deviceKind, cascadeDirOverride) {
-  if (_liModel) return _liModel;
-  if (_liModelLoadPromise) return _liModelLoadPromise;
+  const variant = resolveNativeLiVariant();
+  const cached = _liModels.get(variant.fp32RegistryKey);
+  if (cached?.model) return cached.model;
+  if (cached?.promise) return cached.promise;
 
-  _liModelLoadPromise = (async () => {
+  const promise = (async () => {
     const addon = loadAddon();
     if (!addon?.NativeLateInteractionModel?.loadWithDevice) return null;
 
     // See loadNativeEmbeddingModelWithDevice for why this is CUDA-only.
     if (deviceKind === 'cuda') propagateCudaComputeCapToAddonEnv();
 
-    await fetchModel('lateon-code-fp32');
+    await fetchModel(variant.fp32RegistryKey);
 
-    const entry = getModelEntry('lateon-code-fp32');
+    const entry = getModelEntry(variant.fp32RegistryKey);
     const modelDir = getModelCacheDir(entry.hfId);
     const backbonePath = join(modelDir, 'model.safetensors');
-    const projPath = join(modelDir, '1_Dense', 'model.safetensors');
     const configPath = join(modelDir, 'config.json');
+    const projAbsPaths = variant.projectionPaths.map((p) => join(modelDir, p));
 
-    if (!existsSync(backbonePath) || !existsSync(projPath) || !existsSync(configPath)) return null;
+    if (!existsSync(backbonePath) || !existsSync(configPath)) return null;
+    if (!projAbsPaths.every(existsSync)) return null;
 
     // CUDA has no cascade — see the matching comment in
     // loadNativeEmbeddingModelWithDevice.
@@ -550,19 +633,26 @@ export async function loadNativeLiModelWithDevice(deviceKind, cascadeDirOverride
     );
 
     const t0 = Date.now();
-    _liModel = addon.NativeLateInteractionModel.loadWithDevice(
+    const model = addon.NativeLateInteractionModel.loadWithDevice(
       backbonePath,
-      projPath,
+      projAbsPaths,
+      variant.projectionDims,
       configPath,
       cascadeDir,
       deviceKind,
     );
-    console.log(`[NativeInference] LI model loaded in ${Date.now() - t0}ms (dim: ${_liModel.dim}, device: ${deviceKind})`);
+    console.log(
+      `[NativeInference] LI model '${variant.cfgKey}' loaded in ${Date.now() - t0}ms `
+      + `(dim: ${model.dim}, device: ${deviceKind})`,
+    );
 
-    return _liModel;
+    const slot = _liModels.get(variant.fp32RegistryKey);
+    if (slot) slot.model = model;
+    return model;
   })();
 
-  return _liModelLoadPromise;
+  _liModels.set(variant.fp32RegistryKey, { model: null, promise });
+  return promise;
 }
 
 // ─── Warmup primitives ───
@@ -575,10 +665,14 @@ export async function warmupNativeEmbeddingModel() {
 }
 
 export async function warmupNativeLiModel() {
-  if (!_liModel?.warmupForward) return;
+  // Warm up only the *active* variant — warming up an unused stale
+  // variant would be wasted Metal queue time.
+  const variant = resolveNativeLiVariant();
+  const model = _liModels.get(variant.fp32RegistryKey)?.model;
+  if (!model?.warmupForward) return;
   const t0 = Date.now();
-  await _liModel.warmupForward();
-  console.log(`[NativeInference] LI warmup forward in ${Date.now() - t0}ms`);
+  await model.warmupForward();
+  console.log(`[NativeInference] LI warmup forward (${variant.cfgKey}) in ${Date.now() - t0}ms`);
 }
 
 // ─── Cleanup ───
@@ -586,12 +680,10 @@ export async function warmupNativeLiModel() {
 export function unloadNativeModels() {
   _embeddingModel = null;
   _embeddingModelLoadPromise = null;
-  _liModel = null;
-  _liModelLoadPromise = null;
+  _liModels.clear();
   _embTokenizer = null;
   _embTokenizerLoadPromise = null;
-  _liTokenizer = null;
-  _liTokenizerLoadPromise = null;
+  _liTokenizers.clear();
   _addon = null;
   _available = null;
   _coremlCascadeLogged = false;