gitnexus 1.6.4-rc.2 → 1.6.4-rc.21

package/dist/core/lbug/extension-loader.js

@@ -0,0 +1,184 @@
+import { spawn } from 'child_process';
+import { fileURLToPath } from 'node:url';
+const DEFAULT_EXTENSION_INSTALL_TIMEOUT_MS = 15_000;
+const EXTENSION_NAME_PATTERN = /^[A-Za-z][A-Za-z0-9_]*$/;
+const alreadyAvailable = (message) => message.includes('already loaded') ||
+    message.includes('already installed') ||
+    message.includes('already exists');
+const resolvePolicyFromEnv = () => {
+    const raw = process.env.GITNEXUS_LBUG_EXTENSION_INSTALL;
+    if (raw === 'load-only' || raw === 'never' || raw === 'auto')
+        return raw;
+    return 'auto';
+};
+export const getExtensionInstallTimeoutMs = () => {
+    const raw = process.env.GITNEXUS_LBUG_EXTENSION_INSTALL_TIMEOUT_MS;
+    const parsed = raw ? Number(raw) : NaN;
+    return Number.isFinite(parsed) && parsed > 0 ? parsed : DEFAULT_EXTENSION_INSTALL_TIMEOUT_MS;
+};
+export const getExtensionInstallChildProcessArgs = (extensionName) => {
+    const childScript = new URL('../../../scripts/install-duckdb-extension.mjs', import.meta.url);
+    return [fileURLToPath(childScript), extensionName];
+};
+/**
+ * Run `INSTALL <extension>` in a short-lived child Node process so the parent
+ * event loop is never blocked by DuckDB's synchronous network call.
+ *
+ * The child opens its own scratch LadybugDB, executes the install, and exits.
+ * If the child exceeds `timeoutMs` the parent kills it with SIGKILL and
+ * resolves with `timedOut: true`.
+ */
+export const installDuckDbExtensionOutOfProcess = async (extensionName, timeoutMs = getExtensionInstallTimeoutMs()) => {
+    if (!EXTENSION_NAME_PATTERN.test(extensionName)) {
+        throw new Error(`Invalid DuckDB extension name: ${extensionName}`);
+    }
+    return await new Promise((resolve) => {
+        const child = spawn(process.execPath, getExtensionInstallChildProcessArgs(extensionName), {
+            env: {
+                ...process.env,
+                GITNEXUS_LBUG_EXTENSION_NAME: extensionName,
+            },
+            stdio: ['ignore', 'ignore', 'pipe'],
+            windowsHide: true,
+        });
+        let stderr = '';
+        child.stderr?.setEncoding('utf8');
+        child.stderr?.on('data', (chunk) => {
+            stderr = (stderr + chunk).slice(-4000);
+        });
+        let settled = false;
+        const timer = setTimeout(() => {
+            if (settled)
+                return;
+            settled = true;
+            child.kill('SIGKILL');
+            resolve({
+                success: false,
+                timedOut: true,
+                message: `INSTALL ${extensionName} timed out after ${timeoutMs}ms`,
+            });
+        }, timeoutMs);
+        child.on('error', (err) => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(timer);
+            resolve({ success: false, timedOut: false, message: err.message });
+        });
+        child.on('exit', (code, signal) => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(timer);
+            resolve({
+                success: code === 0,
+                timedOut: false,
+                message: code === 0
+                    ? `INSTALL ${extensionName} completed`
+                    : `INSTALL ${extensionName} failed with ${signal ?? `exit code ${code}`}${stderr ? `: ${stderr.trim()}` : ''}`,
+            });
+        });
+    });
+};
+/**
+ * Centralized lifecycle manager for optional LadybugDB extensions.
+ *
+ * Always tries `LOAD EXTENSION <name>` first — it is per-connection,
+ * idempotent, and never touches the network. If `LOAD` fails and the active
+ * policy permits, the manager runs a single bounded out-of-process `INSTALL`
+ * attempt per process and retries `LOAD`. Capability outcomes are cached so
+ * unavailable extensions degrade search features without ever blocking
+ * subsequent analyze or query calls.
+ *
+ * Policy precedence (most specific wins):
+ *   per-call `opts.policy` → constructor `options.policy` → env → `auto`
+ */
+export class ExtensionManager {
+    options;
+    capabilities = new Map();
+    installAttempted = new Map();
+    warnedKeys = new Set();
+    constructor(options = {}) {
+        this.options = options;
+    }
+    /** Reset cached capability and install state. Test-only. */
+    reset() {
+        this.capabilities.clear();
+        this.installAttempted.clear();
+        this.warnedKeys.clear();
+    }
+    /** Snapshot of currently-known optional extension capabilities. */
+    getCapabilities() {
+        return Array.from(this.capabilities.values());
+    }
+    /**
+     * Ensure an optional extension is loaded on the supplied connection.
+     *
+     * Returns `true` when the extension is usable on `query`, `false` when it
+     * is unavailable. Never throws on install failure — analyze and query
+     * paths are expected to degrade gracefully.
+     */
+    async ensure(query, name, label, opts = {}) {
+        if (!EXTENSION_NAME_PATTERN.test(name)) {
+            throw new Error(`Invalid DuckDB extension name: ${name}`);
+        }
+        const policy = opts.policy ?? this.options.policy ?? resolvePolicyFromEnv();
+        const timeoutMs = opts.installTimeoutMs ?? this.options.installTimeoutMs ?? getExtensionInstallTimeoutMs();
+        const warn = this.options.warn ?? console.warn;
+        if (policy === 'never') {
+            this.markUnavailable(name, label, 'extension install policy is "never"', warn);
+            return false;
+        }
+        if (await this.tryLoad(query, name)) {
+            this.markLoaded(name);
+            return true;
+        }
+        if (policy === 'load-only') {
+            this.markUnavailable(name, label, 'load-only policy: extension not pre-installed', warn);
+            return false;
+        }
+        let install = this.installAttempted.get(name);
+        if (!install) {
+            const installFn = this.options.installExtension ?? installDuckDbExtensionOutOfProcess;
+            install = await installFn(name, timeoutMs);
+            this.installAttempted.set(name, install);
+        }
+        if (!install.success) {
+            this.markUnavailable(name, label, install.message, warn);
+            return false;
+        }
+        if (await this.tryLoad(query, name)) {
+            this.markLoaded(name);
+            return true;
+        }
+        this.markUnavailable(name, label, `LOAD ${name} failed after successful INSTALL`, warn);
+        return false;
+    }
+    async tryLoad(query, name) {
+        try {
+            await query(`LOAD EXTENSION ${name}`);
+            return true;
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            return alreadyAvailable(msg);
+        }
+    }
+    markLoaded(name) {
+        this.capabilities.set(name, { name, loaded: true });
+    }
+    markUnavailable(name, label, reason, warn) {
+        this.capabilities.set(name, { name, loaded: false, reason });
+        const key = `${name}:${reason}`;
+        if (this.warnedKeys.has(key))
+            return;
+        this.warnedKeys.add(key);
+        warn(`GitNexus: ${label} extension unavailable; continuing without ${label} features. ${reason}`);
+    }
+}
+/** Process-wide singleton shared by core and pool adapters. */
+export const extensionManager = new ExtensionManager();
+/** Snapshot of which optional DuckDB extensions are loaded in this process. */
+export const getExtensionCapabilities = () => extensionManager.getCapabilities();
+/** Test-only: clear the singleton's cached capability and install state. */
+export const resetExtensionState = () => extensionManager.reset();

package/dist/core/lbug/lbug-adapter.d.ts

@@ -1,6 +1,7 @@
 import lbug from '@ladybugdb/core';
 import { KnowledgeGraph } from '../graph/types.js';
 import type { CachedEmbedding } from '../embeddings/types.js';
+import { type ExtensionEnsureOptions } from './extension-loader.js';
 /** Factory for creating WriteStreams — injectable for testing. */
 export type WriteStreamFactory = (filePath: string) => import('fs').WriteStream;
 /** Result of splitting the relationship CSV into per-label-pair files. */
@@ -122,23 +123,24 @@ export declare const deleteNodesForFile: (filePath: string, dbPath?: string) =>
 }>;
 export declare const getEmbeddingTableName: () => string;
 /**
- * Load the FTS extension (required before using FTS functions).
+ * Load the FTS extension on the supplied connection (or the singleton
+ * writable connection when none is given).
  *
- * Safe to call multiple times — when invoked without arguments, tracks loaded
- * state via module-level `ftsLoaded`. When invoked with an explicit
- * connection, loads on that connection and returns whether the load
- * succeeded — letting callers (e.g. the pool adapter) track their own state.
- *
- * Tries `LOAD EXTENSION fts` first so previously-cached installs skip the
- * network entirely; falls back to `INSTALL` + `LOAD` only when the extension
- * hasn't been cached yet.
+ * Delegates to the shared `ExtensionManager` so install policy (auto /
+ * load-only / never), out-of-process bounded INSTALL, and capability
+ * caching are owned in one place. The module-level `ftsLoaded` flag is
+ * kept purely as a per-call short-circuit on the singleton writable
+ * connection so repeated callers (e.g. createFTSIndex) avoid an extra
+ * `LOAD` round-trip per invocation. Pool adapter callers pass
+ * `{ policy: 'load-only' }` so query paths never block on a network install.
  */
-export declare const loadFTSExtension: (targetConn?: lbug.Connection) => Promise<boolean>;
+export declare const loadFTSExtension: (targetConn?: lbug.Connection, opts?: ExtensionEnsureOptions) => Promise<boolean>;
 /**
- * Load the VECTOR extension (required before using QUERY_VECTOR_INDEX).
- * Safe to call multiple times -- tracks loaded state via module-level vectorExtensionLoaded.
+ * Load the VECTOR extension on the supplied connection (or the singleton
+ * writable connection when none is given). Returns false when VECTOR is
+ * unavailable so semantic search can fall back to exact scan.
  */
-export declare const loadVectorExtension: () => Promise<void>;
+export declare const loadVectorExtension: (targetConn?: lbug.Connection, opts?: ExtensionEnsureOptions) => Promise<boolean>;
 /**
  * Create a full-text search index on a table
  * @param tableName - The node table name (e.g., 'File', 'CodeSymbol')
@@ -150,10 +152,9 @@ export declare const createFTSIndex: (tableName: string, indexName: string, prop
 /**
  * Lazy-create an FTS index, caching the fact in-process.
  *
- * Used by `queryFTS` so that `analyze` doesn't pay the ~440 ms × 5 fixed
- * LadybugDB cost up-front (it dominates analyze on small repos). Instead,
- * the cost is moved to the first `query`/`context` call in a session,
- * where it's amortised across many lookups.
+ * Kept for writable maintenance paths that need to lazily materialize an
+ * index. Read-only query paths must not call this; production analysis owns
+ * creating the configured search indexes before the database is served.
  *
  * Safe to call repeatedly — the in-process Set guarantees only the first
  * call hits LadybugDB. `closeLbug` clears the cache so re-init starts fresh.

package/dist/core/lbug/lbug-adapter.js

@@ -7,6 +7,8 @@ import path from 'path';
 import lbug from '@ladybugdb/core';
 import { NODE_TABLES, REL_TABLE_NAME, SCHEMA_QUERIES, EMBEDDING_TABLE_NAME, STALE_HASH_SENTINEL, } from './schema.js';
 import { streamAllCSVsToDisk } from './csv-generator.js';
+import { extensionManager } from './extension-loader.js';
+import { isVectorExtensionSupportedByPlatform } from '../platform/capabilities.js';
 /**
  * Split a relationship CSV into per-label-pair files on disk.
  *
@@ -112,11 +114,9 @@ let ftsLoaded = false;
 let vectorExtensionLoaded = false;
 /**
  * In-process cache of FTS indexes that have been ensured against the current
- * connection. Prevents repeated `CALL CREATE_FTS_INDEX` round-trips inside a
- * single CLI/MCP session — the first call to `ensureFTSIndex` for a given
- * `(tableName, indexName)` pays the LadybugDB cost (~440 ms even when the
- * index already exists on disk), subsequent calls are a Set lookup. Cleared
- * by `closeLbug` so a re-init starts fresh.
+ * writable connection. Prevents repeated `CALL CREATE_FTS_INDEX` round-trips
+ * for callers that explicitly opt into `ensureFTSIndex`. Cleared by
+ * `closeLbug` so a re-init starts fresh.
  *
  * Key format: `${tableName}:${indexName}`.
  */
@@ -289,8 +289,9 @@ const doInitLbug = async (dbPath) => {
             }
         }
     }
-    // Load VECTOR extension for semantic search support
-    await loadVectorExtension();
+    // FTS powers baseline search, so initialize it with the core DB. VECTOR is
+    // only required for semantic embeddings and is probed lazily there.
+    await loadFTSExtension();
     currentDbPath = dbPath;
     return { db, conn };
 };
@@ -761,8 +762,9 @@ export const executeWithReusedStatement = async (cypher, paramsList) => {
             }
         }
         catch (e) {
-            // Log the error and continue with next batch
-            console.warn('Batch execution error:', e);
+            const msg = e instanceof Error ? e.message : String(e);
+            const queryPreview = cypher.replace(/\s+/g, ' ').slice(0, 120);
+            throw new Error(`Batch execution failed for rows ${i + 1}-${i + subBatch.length}: ${msg} (${queryPreview})`);
         }
         // Note: LadybugDB PreparedStatement doesn't require explicit close()
     }
@@ -1025,18 +1027,18 @@ export const getEmbeddingTableName = () => EMBEDDING_TABLE_NAME;
 // Full-Text Search (FTS) Functions
 // ============================================================================
 /**
- * Load the FTS extension (required before using FTS functions).
- *
- * Safe to call multiple times — when invoked without arguments, tracks loaded
- * state via module-level `ftsLoaded`. When invoked with an explicit
- * connection, loads on that connection and returns whether the load
- * succeeded — letting callers (e.g. the pool adapter) track their own state.
+ * Load the FTS extension on the supplied connection (or the singleton
+ * writable connection when none is given).
  *
- * Tries `LOAD EXTENSION fts` first so previously-cached installs skip the
- * network entirely; falls back to `INSTALL` + `LOAD` only when the extension
- * hasn't been cached yet.
+ * Delegates to the shared `ExtensionManager` so install policy (auto /
+ * load-only / never), out-of-process bounded INSTALL, and capability
+ * caching are owned in one place. The module-level `ftsLoaded` flag is
+ * kept purely as a per-call short-circuit on the singleton writable
+ * connection so repeated callers (e.g. createFTSIndex) avoid an extra
+ * `LOAD` round-trip per invocation. Pool adapter callers pass
+ * `{ policy: 'load-only' }` so query paths never block on a network install.
  */
-export const loadFTSExtension = async (targetConn) => {
+export const loadFTSExtension = async (targetConn, opts = {}) => {
     const useModuleState = targetConn === undefined;
     if (useModuleState && ftsLoaded)
         return true;
@@ -1044,61 +1046,30 @@ export const loadFTSExtension = async (targetConn) => {
     if (!c) {
         throw new Error('LadybugDB not initialized. Call initLbug first.');
     }
-    const markLoaded = () => {
-        if (useModuleState)
-            ftsLoaded = true;
-        return true;
-    };
-    try {
-        // Try loading locally first (no network required)
-        await c.query('LOAD EXTENSION fts');
-        return markLoaded();
-    }
-    catch {
-        // Fall back to install + load (requires network)
-        try {
-            await c.query('INSTALL fts');
-            await c.query('LOAD EXTENSION fts');
-            return markLoaded();
-        }
-        catch (err) {
-            const msg = err?.message || '';
-            if (msg.includes('already loaded') ||
-                msg.includes('already installed') ||
-                msg.includes('already exists')) {
-                return markLoaded();
-            }
-            console.error('GitNexus: FTS extension load failed:', msg);
-            return false;
-        }
-    }
+    const loaded = await extensionManager.ensure((sql) => c.query(sql), 'fts', 'FTS', opts);
+    if (loaded && useModuleState)
+        ftsLoaded = true;
+    return loaded;
 };
 /**
- * Load the VECTOR extension (required before using QUERY_VECTOR_INDEX).
- * Safe to call multiple times -- tracks loaded state via module-level vectorExtensionLoaded.
+ * Load the VECTOR extension on the supplied connection (or the singleton
+ * writable connection when none is given). Returns false when VECTOR is
+ * unavailable so semantic search can fall back to exact scan.
  */
-export const loadVectorExtension = async () => {
-    if (vectorExtensionLoaded)
-        return;
-    if (!conn) {
+export const loadVectorExtension = async (targetConn, opts = {}) => {
+    const useModuleState = targetConn === undefined;
+    if (useModuleState && vectorExtensionLoaded)
+        return true;
+    if (!isVectorExtensionSupportedByPlatform())
+        return false;
+    const c = targetConn ?? conn;
+    if (!c) {
         throw new Error('LadybugDB not initialized. Call initLbug first.');
     }
-    try {
-        await conn.query('INSTALL VECTOR');
-        await conn.query('LOAD EXTENSION VECTOR');
+    const loaded = await extensionManager.ensure((sql) => c.query(sql), 'VECTOR', 'VECTOR', opts);
+    if (loaded && useModuleState)
         vectorExtensionLoaded = true;
-    }
-    catch (err) {
-        const msg = err?.message || '';
-        if (msg.includes('already loaded') ||
-            msg.includes('already installed') ||
-            msg.includes('already exists')) {
-            vectorExtensionLoaded = true;
-        }
-        else {
-            console.error('GitNexus: VECTOR extension load failed:', msg);
-        }
-    }
+    return loaded;
 };
 /**
  * Create a full-text search index on a table
@@ -1111,7 +1082,9 @@ export const createFTSIndex = async (tableName, indexName, properties, stemmer =
     if (!conn) {
         throw new Error('LadybugDB not initialized. Call initLbug first.');
     }
-    await loadFTSExtension();
+    if (!(await loadFTSExtension())) {
+        return;
+    }
     const propList = properties.map((p) => `'${p}'`).join(', ');
     const query = `CALL CREATE_FTS_INDEX('${tableName}', '${indexName}', [${propList}], stemmer := '${stemmer}')`;
     try {
@@ -1126,10 +1099,9 @@ export const createFTSIndex = async (tableName, indexName, properties, stemmer =
 /**
  * Lazy-create an FTS index, caching the fact in-process.
  *
- * Used by `queryFTS` so that `analyze` doesn't pay the ~440 ms × 5 fixed
- * LadybugDB cost up-front (it dominates analyze on small repos). Instead,
- * the cost is moved to the first `query`/`context` call in a session,
- * where it's amortised across many lookups.
+ * Kept for writable maintenance paths that need to lazily materialize an
+ * index. Read-only query paths must not call this; production analysis owns
+ * creating the configured search indexes before the database is served.
  *
  * Safe to call repeatedly — the in-process Set guarantees only the first
  * call hits LadybugDB. `closeLbug` clears the cache so re-init starts fresh.

package/dist/core/lbug/pool-adapter.js

@@ -122,7 +122,6 @@ function closeOne(repoId) {
                 // for the same dbPath reuse it instead of hitting a file lock.
                 shared.refCount = 0;
                 shared.ftsLoaded = false;
-                shared.vectorLoaded = false;
             }
             else {
                 shared.db.close().catch(() => { });
@@ -248,7 +247,7 @@ async function doInitLbug(repoId, dbPath) {
                 false, // enableCompression (default)
                 true);
                 restoreStdout();
-                shared = { db, refCount: 0, ftsLoaded: false, vectorLoaded: false };
+                shared = { db, refCount: 0, ftsLoaded: false };
                 dbCache.set(dbPath, shared);
                 break;
             }
@@ -284,19 +283,11 @@ async function doInitLbug(repoId, dbPath) {
     // Load FTS extension once per shared Database.
     // Done BEFORE pool registration so no concurrent checkout can grab
     // the connection while the async FTS load is in progress.
+    // policy: 'load-only' — the read pool must never trigger a network
+    // install; analyze owns extension installation. If LOAD fails, search
+    // features degrade gracefully and the user-facing query path proceeds.
     if (!shared.ftsLoaded) {
-        shared.ftsLoaded = await loadFTSExtension(available[0]);
-    }
-    // Load VECTOR extension once per shared Database for semantic search support.
-    if (!shared.vectorLoaded) {
-        try {
-            await available[0].query('INSTALL VECTOR');
-            await available[0].query('LOAD EXTENSION VECTOR');
-            shared.vectorLoaded = true;
-        }
-        catch {
-            // VECTOR extension may not be available
-        }
+        shared.ftsLoaded = await loadFTSExtension(available[0], { policy: 'load-only' });
     }
     // Register pool entry only after all connections are pre-warmed and FTS is
     // loaded.  Concurrent executeQuery calls see either "not initialized"
@@ -335,7 +326,7 @@ export async function initLbugWithDb(repoId, existingDb, dbPath) {
     // closeOne() respects the external flag and skips db.close().
     let shared = dbCache.get(dbPath);
     if (!shared) {
-        shared = { db: existingDb, refCount: 0, ftsLoaded: false, vectorLoaded: false, external: true };
+        shared = { db: existingDb, refCount: 0, ftsLoaded: false, external: true };
         dbCache.set(dbPath, shared);
     }
     shared.refCount++;
@@ -349,20 +340,11 @@ export async function initLbugWithDb(repoId, existingDb, dbPath) {
     finally {
         preWarmActive = false;
     }
-    // Load FTS extension if not already loaded on this Database
+    // Load FTS extension if not already loaded on this Database.
+    // policy: 'load-only' — same contract as initLbug above; the read pool
+    // must not block on a network install during query execution.
     if (!shared.ftsLoaded) {
-        shared.ftsLoaded = await loadFTSExtension(available[0]);
-    }
-    // Load VECTOR extension for semantic search support
-    if (!shared.vectorLoaded) {
-        try {
-            await available[0].query('INSTALL VECTOR');
-            await available[0].query('LOAD EXTENSION VECTOR');
-            shared.vectorLoaded = true;
-        }
-        catch {
-            // VECTOR extension may not be available
-        }
+        shared.ftsLoaded = await loadFTSExtension(available[0], { policy: 'load-only' });
     }
     pool.set(repoId, {
         db: existingDb,

package/dist/core/platform/capabilities.d.ts

@@ -0,0 +1,24 @@
+export type CapabilityStatus = 'available' | 'degraded' | 'unavailable';
+export type SemanticSearchMode = 'vector-index' | 'exact-scan' | 'unavailable';
+export interface RuntimeFingerprint {
+    platform: NodeJS.Platform;
+    arch: string;
+    node: string;
+    gitnexus: string;
+    ladybugdb?: string;
+    onnxruntime?: string;
+}
+export interface RuntimeCapabilities {
+    graph: CapabilityStatus;
+    fts: CapabilityStatus;
+    vector: CapabilityStatus;
+    semanticMode: SemanticSearchMode;
+    exactScanLimit: number;
+    reason?: string;
+}
+export declare const DEFAULT_EXACT_SCAN_LIMIT = 10000;
+export declare const getExactScanLimit: () => number;
+export declare const getRuntimeFingerprint: () => RuntimeFingerprint;
+export declare const isVectorExtensionSupportedByPlatform: (platform?: NodeJS.Platform) => boolean;
+export declare const getRuntimeCapabilities: () => RuntimeCapabilities;
+export declare const defaultEmbeddingThreads: () => number;

package/dist/core/platform/capabilities.js

@@ -0,0 +1,54 @@
+import os from 'os';
+import { createRequire } from 'module';
+const require = createRequire(import.meta.url);
+const packageVersion = (name) => {
+    try {
+        return require(`${name}/package.json`).version;
+    }
+    catch {
+        return undefined;
+    }
+};
+const gitnexusVersion = () => {
+    try {
+        return require('../../../package.json').version;
+    }
+    catch {
+        return 'unknown';
+    }
+};
+const parsePositiveInt = (value, fallback) => {
+    if (value === undefined)
+        return fallback;
+    const parsed = Number(value);
+    return Number.isInteger(parsed) && parsed > 0 ? parsed : fallback;
+};
+export const DEFAULT_EXACT_SCAN_LIMIT = 10_000;
+export const getExactScanLimit = () => parsePositiveInt(process.env.GITNEXUS_SEMANTIC_EXACT_SCAN_LIMIT, DEFAULT_EXACT_SCAN_LIMIT);
+export const getRuntimeFingerprint = () => ({
+    platform: process.platform,
+    arch: process.arch,
+    node: process.version,
+    gitnexus: gitnexusVersion(),
+    ladybugdb: packageVersion('@ladybugdb/core'),
+    onnxruntime: packageVersion('onnxruntime-node'),
+});
+export const isVectorExtensionSupportedByPlatform = (platform = process.platform) => platform !== 'win32';
+export const getRuntimeCapabilities = () => {
+    const vector = isVectorExtensionSupportedByPlatform() ? 'available' : 'unavailable';
+    const exactScanLimit = getExactScanLimit();
+    return {
+        graph: 'available',
+        fts: 'available',
+        vector,
+        semanticMode: vector === 'available' ? 'vector-index' : 'exact-scan',
+        exactScanLimit,
+        reason: vector === 'unavailable'
+            ? 'LadybugDB VECTOR is disabled on this platform; semantic search uses exact scan when embeddings exist.'
+            : undefined,
+    };
+};
+export const defaultEmbeddingThreads = () => {
+    const available = typeof os.availableParallelism === 'function' ? os.availableParallelism() : os.cpus().length;
+    return Math.max(1, Math.min(4, Math.floor(available / 2) || 1));
+};