gitnexus 1.6.10-rc.4 → 1.6.10-rc.6

package/dist/cli/doctor.js

@@ -5,6 +5,7 @@ import { getLocalEmbeddingRuntimeBlocker, localEmbeddingPrefixUnloadableMessage,
 import { isPrefixRuntimeLoadable, resolveEmbeddingRuntime, } from '../core/embeddings/runtime-install.js';
 import { cudaRedirectDoctorStatus } from '../core/embeddings/onnxruntime-node-resolver.js';
 import { checkLbugNative, probeFtsExtensionLoad } from '../core/lbug/native-check.js';
+import { diagnoseExtensionLoad } from '../core/lbug/extension-load-error.js';
 import { getExtensionInstallPolicy } from '../core/lbug/extension-loader.js';
 import { t } from './i18n/index.js';
 function isCombiningMark(codePoint) {
@@ -116,6 +117,15 @@ export const doctorCommand = async () => {
     console.log(`  ${label('doctor.labels.fullTextSearch', 18)}${ftsProbe.loaded ? 'available' : 'unavailable'}`);
     if (!ftsProbe.loaded && ftsProbe.reason) {
         console.log(`  ${padDisplayEnd('', 18)}${ftsProbe.reason}`);
+        // Add an actionable remedy for recognized failure classes (#2374). The
+        // Windows missing-dependency case is the point of this: the raw error 126
+        // ("specified module could not be found") is opaque, so name the fix (VC++
+        // redist, then OpenSSL) instead of leaving the user to reinstall in vain.
+        // `unknown`'s remedy is "run doctor", which would be circular here.
+        const { kind, remedy } = diagnoseExtensionLoad(ftsProbe.reason);
+        if (kind !== 'unknown') {
+            console.log(`  ${padDisplayEnd('', 18)}${remedy}`);
+        }
     }
     console.log(`  ${label('doctor.labels.vectorIndex', 18)}${capabilities.vector}`);
     console.log(`  ${label('doctor.labels.semanticMode', 18)}${capabilities.semanticMode}`);

package/dist/core/group/extractors/manifest-extractor.js

@@ -7,6 +7,10 @@ import { logger } from '../../logger.js';
 // reserved-keyword labels `Macro` and `Union`, and LadybugDB's parser rejects
 // a disjunction that names a reserved keyword (#2325) — which the resolver's
 // try/catch then swallowed. `labels(n) IN` has no such collision.
+// This list overlaps `ingestion/utils/symbol-labels.ts` (SYMBOL_NODE_LABELS) but
+// is a deliberate SUBSET — it omits `Namespace`/`Variable`/`Module`. Unifying the
+// two would widen which nodes resolve as contract symbols and must update the
+// #2325 test, so they are intentionally kept separate for now.
 export const CUSTOM_CONTRACT_RESOLVE_QUERY = `MATCH (n)
    WHERE labels(n) IN ['Function','Method','Class','Interface','Struct','Enum','Trait','Constructor','TypeAlias','Impl','Macro','Union','Typedef','Property','Record','Delegate','Annotation','Template','Const','Static','CodeElement']
      AND n.name = $symbolName

package/dist/core/ingestion/cobol/jcl-processor.js

@@ -17,6 +17,7 @@
  */
 import { parseJcl } from './jcl-parser.js';
 import { generateId } from '../../../lib/utils.js';
+import { toZeroBasedLine } from '../utils/line-base.js';
 /**
  * Process JCL files and integrate into the knowledge graph.
  *
@@ -71,8 +72,8 @@ function integrateJclResults(graph, parsed, filePath, moduleNames) {
             properties: {
                 name: job.name,
                 filePath,
-                startLine: job.line,
-                endLine: job.line,
+                startLine: toZeroBasedLine(job.line),
+                endLine: toZeroBasedLine(job.line),
                 description: `jcl-job${classPart}${msgPart}`,
             },
         });
@@ -105,8 +106,8 @@ function integrateJclResults(graph, parsed, filePath, moduleNames) {
             properties: {
                 name: step.name,
                 filePath,
-                startLine: step.line,
-                endLine: step.line,
+                startLine: toZeroBasedLine(step.line),
+                endLine: toZeroBasedLine(step.line),
                 description: `jcl-step${pgmPart}${procPart}`,
             },
         });
@@ -170,8 +171,8 @@ function integrateJclResults(graph, parsed, filePath, moduleNames) {
                 properties: {
                     name: dd.dataset,
                     filePath,
-                    startLine: dd.line,
-                    endLine: dd.line,
+                    startLine: toZeroBasedLine(dd.line),
+                    endLine: toZeroBasedLine(dd.line),
                     description: `jcl-dataset${dispPart}`,
                 },
             });
@@ -202,8 +203,8 @@ function integrateJclResults(graph, parsed, filePath, moduleNames) {
             properties: {
                 name: proc.name,
                 filePath,
-                startLine: proc.line,
-                endLine: proc.line,
+                startLine: toZeroBasedLine(proc.line),
+                endLine: toZeroBasedLine(proc.line),
                 description: 'jcl-proc-instream',
             },
         });

package/dist/core/ingestion/cobol-processor.js

@@ -14,6 +14,7 @@
  */
 import path from 'node:path';
 import { generateId } from '../../lib/utils.js';
+import { toZeroBasedLine } from './utils/line-base.js';
 import { SupportedLanguages } from '../../_shared/index.js';
 import { preprocessCobolSource, extractCobolSymbolsWithRegex, } from './cobol/cobol-preprocessor.js';
 import { expandCopies } from './cobol/cobol-copy-expander.js';
@@ -275,8 +276,8 @@ function mapToGraph(graph, extracted, file, copyResolutions, moduleNodeIds) {
             properties: {
                 name: extracted.programName,
                 filePath,
-                startLine: 1,
-                endLine: lines.length,
+                startLine: toZeroBasedLine(1),
+                endLine: toZeroBasedLine(lines.length),
                 language: SupportedLanguages.Cobol,
                 isExported: true,
                 description: metaDesc || undefined,
@@ -310,8 +311,8 @@ function mapToGraph(graph, extracted, file, copyResolutions, moduleNodeIds) {
             properties: {
                 name: prog.name,
                 filePath,
-                startLine: prog.startLine,
-                endLine: prog.endLine,
+                startLine: toZeroBasedLine(prog.startLine),
+                endLine: toZeroBasedLine(prog.endLine),
                 language: SupportedLanguages.Cobol,
                 isExported: true,
                 description: `nested-program${prog.isCommon ? ' common' : ''}`,
@@ -349,8 +350,8 @@ function mapToGraph(graph, extracted, file, copyResolutions, moduleNodeIds) {
             properties: {
                 name: sec.name,
                 filePath,
-                startLine: sec.line,
-                endLine: nextLine,
+                startLine: toZeroBasedLine(sec.line),
+                endLine: toZeroBasedLine(nextLine),
                 language: SupportedLanguages.Cobol,
                 isExported: true,
             },
@@ -379,8 +380,8 @@ function mapToGraph(graph, extracted, file, copyResolutions, moduleNodeIds) {
             properties: {
                 name: para.name,
                 filePath,
-                startLine: para.line,
-                endLine: nextLine,
+                startLine: toZeroBasedLine(para.line),
+                endLine: toZeroBasedLine(nextLine),
                 language: SupportedLanguages.Cobol,
                 isExported: true,
             },
@@ -412,8 +413,8 @@ function mapToGraph(graph, extracted, file, copyResolutions, moduleNodeIds) {
             properties: {
                 name: item.name,
                 filePath,
-                startLine: item.line,
-                endLine: item.line,
+                startLine: toZeroBasedLine(item.line),
+                endLine: toZeroBasedLine(item.line),
                 language: SupportedLanguages.Cobol,
                 description: `level:${item.level} section:${item.section}${item.pic ? ` pic:${item.pic}` : ''}`,
             },
@@ -506,8 +507,8 @@ function mapToGraph(graph, extracted, file, copyResolutions, moduleNodeIds) {
                 properties: {
                     name: `CALL ${call.target}`,
                     filePath,
-                    startLine: call.line,
-                    endLine: call.line,
+                    startLine: toZeroBasedLine(call.line),
+                    endLine: toZeroBasedLine(call.line),
                     language: SupportedLanguages.Cobol,
                     description: 'dynamic-call (target is a data item, not resolvable statically)',
                 },
@@ -619,8 +620,8 @@ function mapToGraph(graph, extracted, file, copyResolutions, moduleNodeIds) {
             properties: {
                 name: `EXEC SQL ${sql.operation}`,
                 filePath,
-                startLine: sql.line,
-                endLine: sql.line,
+                startLine: toZeroBasedLine(sql.line),
+                endLine: toZeroBasedLine(sql.line),
                 language: SupportedLanguages.Cobol,
                 description: `tables:[${sql.tables.join(',')}] cursors:[${sql.cursors.join(',')}]`,
             },
@@ -691,8 +692,8 @@ function mapToGraph(graph, extracted, file, copyResolutions, moduleNodeIds) {
             properties: {
                 name: `EXEC CICS ${cics.command}`,
                 filePath,
-                startLine: cics.line,
-                endLine: cics.line,
+                startLine: toZeroBasedLine(cics.line),
+                endLine: toZeroBasedLine(cics.line),
                 language: SupportedLanguages.Cobol,
                 description: [
                     cics.mapName && `map:${cics.mapName}`,
@@ -726,8 +727,8 @@ function mapToGraph(graph, extracted, file, copyResolutions, moduleNodeIds) {
                     properties: {
                         name: `CICS ${cics.command} ${cics.programName}`,
                         filePath,
-                        startLine: cics.line,
-                        endLine: cics.line,
+                        startLine: toZeroBasedLine(cics.line),
+                        endLine: toZeroBasedLine(cics.line),
                         language: SupportedLanguages.Cobol,
                         description: `cics-dynamic-program (target is data item ${cics.programName})`,
                     },
@@ -879,8 +880,8 @@ function mapToGraph(graph, extracted, file, copyResolutions, moduleNodeIds) {
             properties: {
                 name: entry.name,
                 filePath,
-                startLine: entry.line,
-                endLine: entry.line,
+                startLine: toZeroBasedLine(entry.line),
+                endLine: toZeroBasedLine(entry.line),
                 language: SupportedLanguages.Cobol,
                 isExported: true,
                 description: entry.parameters.length > 0 ? `using:${entry.parameters.join(',')}` : undefined,
@@ -1014,8 +1015,8 @@ function mapToGraph(graph, extracted, file, copyResolutions, moduleNodeIds) {
             properties: {
                 name: `EXEC DLI ${dli.verb}`,
                 filePath,
-                startLine: dli.line,
-                endLine: dli.line,
+                startLine: toZeroBasedLine(dli.line),
+                endLine: toZeroBasedLine(dli.line),
                 language: SupportedLanguages.Cobol,
                 description: [
                     dli.segmentName && `segment:${dli.segmentName}`,
@@ -1148,8 +1149,8 @@ function mapToGraph(graph, extracted, file, copyResolutions, moduleNodeIds) {
             properties: {
                 name: fd.selectName,
                 filePath,
-                startLine: fd.line,
-                endLine: fd.line,
+                startLine: toZeroBasedLine(fd.line),
+                endLine: toZeroBasedLine(fd.line),
                 language: SupportedLanguages.Cobol,
                 description: `assign:${fd.assignTo}${fd.isOptional ? ' optional' : ''}${fd.organization ? ` org:${fd.organization}` : ''}${fd.access ? ` access:${fd.access}` : ''}`,
             },
@@ -1231,8 +1232,8 @@ function mapToGraph(graph, extracted, file, copyResolutions, moduleNodeIds) {
                 properties: {
                     name: `CANCEL ${cancel.target}`,
                     filePath,
-                    startLine: cancel.line,
-                    endLine: cancel.line,
+                    startLine: toZeroBasedLine(cancel.line),
+                    endLine: toZeroBasedLine(cancel.line),
                     language: SupportedLanguages.Cobol,
                     description: 'dynamic-cancel (target is a data item, not resolvable statically)',
                 },

package/dist/core/ingestion/emit-references.js

@@ -44,6 +44,7 @@
  * ancestor scope, and if THAT produces nothing either the edge is
  * skipped (with a count returned in `EmitStats.skippedNoCaller`).
  */
+import { toZeroBasedLine } from './utils/line-base.js';
 /**
  * Drain `referenceIndex.bySourceScope` into graph edges.
  *
@@ -95,8 +96,8 @@ export function emitScopeGraph(input) {
             properties: {
                 name: scope.kind,
                 filePath: scope.filePath,
-                startLine: scope.range.startLine,
-                endLine: scope.range.endLine,
+                startLine: toZeroBasedLine(scope.range.startLine),
+                endLine: toZeroBasedLine(scope.range.endLine),
                 description: `Scope: ${scope.kind}`,
             },
         });

package/dist/core/ingestion/markdown-processor.js

@@ -7,6 +7,7 @@
  */
 import path from 'node:path';
 import { generateId } from '../../lib/utils.js';
+import { toZeroBasedLine } from './utils/line-base.js';
 const HEADING_RE = /^(#{1,6})\s+(.+)$/;
 const LINK_RE = /\[([^\]]*)\]\(([^)]+)\)/g;
 const MD_EXTENSIONS = new Set(['.md', '.mdx']);
@@ -59,8 +60,8 @@ export const processMarkdown = (graph, files, allPathSet) => {
                 properties: {
                     name: heading,
                     filePath: file.path,
-                    startLine: lineNum,
-                    endLine,
+                    startLine: toZeroBasedLine(lineNum),
+                    endLine: toZeroBasedLine(endLine),
                     level,
                     description: `h${level}`,
                 },

package/dist/core/ingestion/utils/line-base.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Convert a 1-based source line number to the 0-based convention used by
+ * GraphNode `startLine`/`endLine`.
+ *
+ * The graph layer stores line numbers 0-based (tree-sitter `startPosition.row`),
+ * and this is load-bearing: the taint/PDG/CFG join and the MCP consumers all add
+ * `+ 1` to recover 1-based (see `summary-harvest-driver.ts` — "Function/Method
+ * node startLine is 0-based"). Most emitters get 0-based for free from
+ * tree-sitter. The exceptions are the regex-based COBOL/JCL processors (their
+ * parsers use `lineNum = i + 1`) and the scope-capture path (`Capture` ranges
+ * are 1-based per RFC §2.1). Those must convert to 0-based when they build a
+ * graph node, or the exact-content slice in `csv-generator.ts` drops the
+ * symbol's declaration line (#2379) and reported line numbers are off (#2377).
+ *
+ * Apply this ONLY at the graph-node `startLine:`/`endLine:` assignment. The
+ * parser-internal 1-based values (`.line`, `prog.startLine`) stay 1-based —
+ * they feed `L${line}` node/edge IDs and line-range containment checks that
+ * must not shift. The clamp guards degenerate inputs (line 0 / empty files).
+ */
+export declare const toZeroBasedLine: (oneBasedLine: number) => number;

package/dist/core/ingestion/utils/line-base.js

@@ -0,0 +1,20 @@
+/**
+ * Convert a 1-based source line number to the 0-based convention used by
+ * GraphNode `startLine`/`endLine`.
+ *
+ * The graph layer stores line numbers 0-based (tree-sitter `startPosition.row`),
+ * and this is load-bearing: the taint/PDG/CFG join and the MCP consumers all add
+ * `+ 1` to recover 1-based (see `summary-harvest-driver.ts` — "Function/Method
+ * node startLine is 0-based"). Most emitters get 0-based for free from
+ * tree-sitter. The exceptions are the regex-based COBOL/JCL processors (their
+ * parsers use `lineNum = i + 1`) and the scope-capture path (`Capture` ranges
+ * are 1-based per RFC §2.1). Those must convert to 0-based when they build a
+ * graph node, or the exact-content slice in `csv-generator.ts` drops the
+ * symbol's declaration line (#2379) and reported line numbers are off (#2377).
+ *
+ * Apply this ONLY at the graph-node `startLine:`/`endLine:` assignment. The
+ * parser-internal 1-based values (`.line`, `prog.startLine`) stay 1-based —
+ * they feed `L${line}` node/edge IDs and line-range containment checks that
+ * must not shift. The clamp guards degenerate inputs (line 0 / empty files).
+ */
+export const toZeroBasedLine = (oneBasedLine) => Math.max(0, oneBasedLine - 1);

package/dist/core/ingestion/utils/symbol-labels.d.ts

@@ -0,0 +1,21 @@
+import type { NodeLabel } from '../../../_shared/index.js';
+/**
+ * Graph-node labels that represent a resolvable code symbol — a definition with
+ * its own source span (function, type, member, module-like container).
+ *
+ * These get EXACT source-span content in the FTS index: `csv-generator.ts`
+ * slices exactly `[startLine, endLine]` for them (no ±2 padding), while every
+ * other label keeps the context window. That exactness depends on the 0-based
+ * `startLine`/`endLine` invariant enforced by `line-base.ts` — the slice is only
+ * correct because all emitters store 0-based lines. Keep the two together.
+ *
+ * Single source of truth so the set can't silently drift the way the inline copy
+ * did in #2379.
+ *
+ * NOTE: `group/extractors/manifest-extractor.ts`'s `CUSTOM_CONTRACT_RESOLVE_QUERY`
+ * carries a near-identical hand-list that is intentionally a SUBSET — it excludes
+ * `Namespace`, `Variable`, `Module`. Unifying the two needs a contract-resolution
+ * behavior check (would widen which nodes resolve as contract symbols), so it is
+ * deliberately left separate for now.
+ */
+export declare const SYMBOL_NODE_LABELS: ReadonlySet<NodeLabel>;

package/dist/core/ingestion/utils/symbol-labels.js

@@ -0,0 +1,45 @@
+/**
+ * Graph-node labels that represent a resolvable code symbol — a definition with
+ * its own source span (function, type, member, module-like container).
+ *
+ * These get EXACT source-span content in the FTS index: `csv-generator.ts`
+ * slices exactly `[startLine, endLine]` for them (no ±2 padding), while every
+ * other label keeps the context window. That exactness depends on the 0-based
+ * `startLine`/`endLine` invariant enforced by `line-base.ts` — the slice is only
+ * correct because all emitters store 0-based lines. Keep the two together.
+ *
+ * Single source of truth so the set can't silently drift the way the inline copy
+ * did in #2379.
+ *
+ * NOTE: `group/extractors/manifest-extractor.ts`'s `CUSTOM_CONTRACT_RESOLVE_QUERY`
+ * carries a near-identical hand-list that is intentionally a SUBSET — it excludes
+ * `Namespace`, `Variable`, `Module`. Unifying the two needs a contract-resolution
+ * behavior check (would widen which nodes resolve as contract symbols), so it is
+ * deliberately left separate for now.
+ */
+export const SYMBOL_NODE_LABELS = new Set([
+    'Function',
+    'Method',
+    'Class',
+    'Interface',
+    'CodeElement',
+    'Struct',
+    'Enum',
+    'Macro',
+    'Typedef',
+    'Union',
+    'Namespace',
+    'Trait',
+    'Impl',
+    'TypeAlias',
+    'Const',
+    'Static',
+    'Variable',
+    'Property',
+    'Record',
+    'Delegate',
+    'Annotation',
+    'Constructor',
+    'Template',
+    'Module',
+]);

package/dist/core/lbug/csv-generator.js

@@ -17,6 +17,7 @@ import path from 'path';
 import { NODE_TABLES } from './schema.js';
 import { RelPairRouter } from './rel-pair-routing.js';
 import { parseTruthyEnv } from '../ingestion/utils/env.js';
+import { SYMBOL_NODE_LABELS } from '../ingestion/utils/symbol-labels.js';
 import { applyCjkSegmentationIfEnabled } from '../search/cjk-segmentation.js';
 /**
  * Deterministic output ordering — optional (out-of-core / windowed-resolve
@@ -187,6 +188,10 @@ class FileContentCache {
 export const normalizeFtsText = (text) => text.replace(/[\r\n\t]+/g, ' ');
 /** Composes both FTS-text transforms for the `description` column — one place for the six emission sites below to call, instead of repeating the composition. */
 const formatFtsDescription = (description) => normalizeFtsText(applyCjkSegmentationIfEnabled(description));
+// Labels that get exact source-span content (no ±2 window). Single source of
+// truth in `symbol-labels.ts` — see there for why the exactness depends on the
+// 0-based line invariant. Kept as a named alias to read intent at the use site.
+const EXACT_SYMBOL_CONTENT_LABELS = SYMBOL_NODE_LABELS;
 const extractContent = async (node, contentCache) => {
     const filePath = node.properties.filePath;
     const content = await contentCache.get(filePath);
@@ -209,8 +214,9 @@ const extractContent = async (node, contentCache) => {
     if (startLine === undefined || endLine === undefined)
         return '';
     const lines = content.split('\n');
-    const start = Math.max(0, startLine - 2);
-    const end = Math.min(lines.length - 1, endLine + 2);
+    const exactSymbolContent = EXACT_SYMBOL_CONTENT_LABELS.has(node.label);
+    const start = Math.max(0, exactSymbolContent ? startLine : startLine - 2);
+    const end = Math.min(lines.length - 1, exactSymbolContent ? endLine : endLine + 2);
     const snippet = lines.slice(start, end + 1).join('\n');
     const MAX_SNIPPET = 5000;
     const capped = snippet.length > MAX_SNIPPET ? snippet.slice(0, MAX_SNIPPET) + '\n... [truncated]' : snippet;

package/dist/core/lbug/extension-load-error.d.ts

@@ -0,0 +1,67 @@
+export type ExtensionLoadErrorKind = 'missing_file' | 'corrupt_file' | 'missing_dependency' | 'unknown';
+export interface ExtensionLoadDiagnosis {
+    readonly kind: ExtensionLoadErrorKind;
+    /** Actionable, literal-English remedy suited to the class. */
+    readonly remedy: string;
+}
+/**
+ * On-disk file corruption / wrong-platform. FORCE INSTALL re-downloads.
+ * Kept byte-identical to `FILE_CORRUPTION_SIGNATURES` in
+ * scripts/install-duckdb-extension.mjs (that `.mjs` cannot import this `.ts`;
+ * the duplication is deliberate — the two serve different call sites). Note
+ * `/not a valid/i` already covers Windows error 193 ("is not a valid Win32
+ * application"), so a truncated Windows download is caught here, before the
+ * missing-dependency branch.
+ */
+export declare const FILE_CORRUPTION_SIGNATURES: readonly RegExp[];
+/**
+ * Classify a collapsed LadybugDB LOAD error. Order is most-specific-first and is
+ * load-bearing: corrupt-file is tested before missing-dependency so a truncated
+ * Windows download (error 193, matched by `/not a valid/i`) routes to
+ * FORCE-reinstall rather than to the runtime-install remedy.
+ */
+export declare function classifyExtensionLoadError(reason: string | undefined | null): ExtensionLoadDiagnosis;
+/** Well-formedness of the extension binary for the host platform + arch. */
+export type ExtensionBinaryState = 'absent' | 'corrupt' | 'valid' | 'indeterminate';
+/**
+ * Pull the extension file path out of lbug's load error. lbug's wrapper is
+ * English regardless of OS language — `Failed to load library: {path} which is
+ * needed by extension: {name}` (real lbug), or the quoted `Failed to load
+ * library '{path}': {reason}` variant — so the path is recoverable in any locale.
+ * Only paths ending in `.lbug_extension` are accepted, so a regex misfire can
+ * never point the inspector at an arbitrary file.
+ */
+export declare function extractExtensionPath(reason: string | undefined | null): string | null;
+/**
+ * A structural verdict on a binary header. `indeterminate` means the probe could
+ * not prove validity OR corruption from what it read (e.g. the PE header sits past
+ * the BINARY_HEADER_BYTES window) — the caller defers to the string classifier
+ * rather than assert a false verdict.
+ */
+type HeaderVerdict = 'valid' | 'corrupt' | 'indeterminate';
+/**
+ * Decide whether a binary header is a well-formed shared library for the given
+ * platform + architecture — using only the file's structure, no localized text.
+ * Pure and injectable (platform/arch as params) so every format+arch combination
+ * is unit-testable regardless of the host it runs on.
+ */
+export declare function classifyBinaryHeader(buf: Buffer, bytesRead: number, platform: NodeJS.Platform, arch: string): HeaderVerdict;
+/**
+ * Best-effort language-independent inspection of the extension file. Reads the
+ * header and classifies it; never throws — a missing file is `absent`, an
+ * unreadable one is `indeterminate`.
+ */
+export declare function inspectExtensionBinary(extensionPath: string | null | undefined): ExtensionBinaryState;
+/**
+ * Diagnose a LadybugDB load failure, preferring a LANGUAGE-INDEPENDENT structural
+ * check of the extension binary over the localized error text:
+ *   - file absent             → missing_file
+ *   - present but malformed    → corrupt_file       (bad magic / wrong architecture)
+ *   - present and well-formed   → missing_dependency (a valid binary the loader rejected)
+ * The path comes from lbug's own English wrapper, so this holds in any OS display
+ * language. When the file cannot be located or read, it falls back to the string
+ * classifier (which still carries the language-independent hedged fallback). This
+ * is the entry point every surface should call.
+ */
+export declare function diagnoseExtensionLoad(reason: string | undefined | null): ExtensionLoadDiagnosis;
+export {};