gitnexus 1.6.6-rc.99 → 1.6.6

package/dist/core/ingestion/utils/heap-probe.js

@@ -0,0 +1,39 @@
+/**
+ * Synchronous heap probes for large-repo OOM investigation (#1983).
+ *
+ * Writes to stderr (not pino) so lines flush under CI=1 / gdb attach.
+ * Enabled with `GITNEXUS_DEBUG_HEAP=1` or `GITNEXUS_PROFILE_DEFERRED=1`.
+ */
+import { appendFileSync } from 'node:fs';
+import { parseTruthyEnv } from './env.js';
+import { isDeferredResolutionProfileEnabled } from './deferred-resolution-profile.js';
+export const isDebugHeapEnabled = () => parseTruthyEnv(process.env.GITNEXUS_DEBUG_HEAP) || isDeferredResolutionProfileEnabled();
+export const heapUsedMb = () => Math.round(process.memoryUsage().heapUsed / 1024 / 1024);
+const rssMb = () => Math.round(process.memoryUsage().rss / 1024 / 1024);
+/**
+ * Flush a one-line heap snapshot to stderr.
+ *
+ * stderr is async on a pipe (Linux), so a probe written just before an
+ * OOM-kill is lost in the pipe buffer. For OOM investigation set
+ * `GITNEXUS_HEAP_PROBE_FILE=/path` — each probe is then ALSO appended to
+ * that file with a synchronous `appendFileSync`, whose `write(2)` syscall
+ * completes (data handed to the kernel) before the call returns, so the
+ * last line survives SIGKILL. Includes rss alongside heapUsed so the
+ * native/off-heap gap is visible.
+ */
+export const logHeapProbe = (label, detail) => {
+    if (!isDebugHeapEnabled())
+        return;
+    const suffix = detail ? ` ${detail}` : '';
+    const line = `[gitnexus-heap] ${label} used_mb=${heapUsedMb()} rss_mb=${rssMb()}${suffix}\n`;
+    process.stderr.write(line);
+    const file = process.env.GITNEXUS_HEAP_PROBE_FILE;
+    if (file) {
+        try {
+            appendFileSync(file, line);
+        }
+        catch {
+            // Best-effort diagnostics sink; never let a probe failure abort analyze.
+        }
+    }
+};

package/dist/core/ingestion/utils/heritage-marker.d.ts

@@ -0,0 +1,33 @@
+/**
+ * #1994: shared codec for the synthetic `__heritage__:` / `__property__:` import
+ * markers used by the Ruby and Dart scope resolvers to carry side-effect facts
+ * (mixin includes, attr_accessor properties) through the import channel. Both
+ * languages share the exact `':'`-delimited wire format, so a single encode/decode
+ * pair removes the per-site hand-rolled string handling that produced the #1981
+ * edge-drop. Language-NEUTRAL — keyed only on the literal prefixes; no provider
+ * branching belongs here.
+ */
+export type MarkerKind = 'heritage' | 'property';
+export declare const HERITAGE_MARKER_PREFIX: string;
+export declare const PROPERTY_MARKER_PREFIX: string;
+/**
+ * Build a marker string `<prefix><field>:<field>:...`. The `':'` delimiter IS the
+ * wire format, so a field that itself contains `':'` is structurally invalid and
+ * THROWS — callers must pre-normalize colon-bearing values (e.g. a qualified mixin
+ * arg `Outer::Mixin` → `Outer.Mixin`). This makes the #1981 silent edge-drop a
+ * loud failure instead.
+ */
+export declare function encodeMarker(kind: MarkerKind, fields: readonly string[]): string;
+/**
+ * Parse a marker string back into its kind + positional fields, or `null` if `raw`
+ * is not a marker. Mirrors the historical `slice(PREFIX.length).split(':')`.
+ */
+export declare function decodeMarker(raw: string): {
+    kind: MarkerKind;
+    fields: string[];
+} | null;
+/**
+ * True if `raw` is a synthetic heritage/property marker — exactly the prior
+ * `startsWith('__heritage__:') || startsWith('__property__:')` pair.
+ */
+export declare function isHeritageMarker(raw: string): boolean;

package/dist/core/ingestion/utils/heritage-marker.js

@@ -0,0 +1,41 @@
+const PREFIX_BY_KIND = {
+    heritage: '__heritage__:',
+    property: '__property__:',
+};
+export const HERITAGE_MARKER_PREFIX = PREFIX_BY_KIND.heritage;
+export const PROPERTY_MARKER_PREFIX = PREFIX_BY_KIND.property;
+/**
+ * Build a marker string `<prefix><field>:<field>:...`. The `':'` delimiter IS the
+ * wire format, so a field that itself contains `':'` is structurally invalid and
+ * THROWS — callers must pre-normalize colon-bearing values (e.g. a qualified mixin
+ * arg `Outer::Mixin` → `Outer.Mixin`). This makes the #1981 silent edge-drop a
+ * loud failure instead.
+ */
+export function encodeMarker(kind, fields) {
+    for (const field of fields) {
+        if (field.includes(':')) {
+            throw new Error(`encodeMarker: field "${field}" contains the ':' delimiter; normalize it before encoding`);
+        }
+    }
+    return PREFIX_BY_KIND[kind] + fields.join(':');
+}
+/**
+ * Parse a marker string back into its kind + positional fields, or `null` if `raw`
+ * is not a marker. Mirrors the historical `slice(PREFIX.length).split(':')`.
+ */
+export function decodeMarker(raw) {
+    if (raw.startsWith(PREFIX_BY_KIND.heritage)) {
+        return { kind: 'heritage', fields: raw.slice(PREFIX_BY_KIND.heritage.length).split(':') };
+    }
+    if (raw.startsWith(PREFIX_BY_KIND.property)) {
+        return { kind: 'property', fields: raw.slice(PREFIX_BY_KIND.property.length).split(':') };
+    }
+    return null;
+}
+/**
+ * True if `raw` is a synthetic heritage/property marker — exactly the prior
+ * `startsWith('__heritage__:') || startsWith('__property__:')` pair.
+ */
+export function isHeritageMarker(raw) {
+    return raw.startsWith(PREFIX_BY_KIND.heritage) || raw.startsWith(PREFIX_BY_KIND.property);
+}

package/dist/core/ingestion/utils/qualified-name.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Shared qualified-name normalization.
+ *
+ * One canonical transform from a raw, language-specific qualified name
+ * (`Other::Inner`, `pkg\Sub\Type`, `  A . B `) to the `.`-joined form the
+ * graph and the `QualifiedNameIndex` are keyed by (`Other.Inner`, `pkg.Sub.Type`,
+ * `A.B`). Extracted from `class-extractors/generic.ts` so the structure-phase
+ * `buildQualifiedName`, the scope-resolution inheritance resolver, and the
+ * per-language capture emitters all key against ONE normalizer — a raw `::`
+ * qualifier must normalize to the exact key the index already holds, or the
+ * qualified lookup silently misses (issue #1982).
+ *
+ * Do NOT confuse with `heritage-extractors/supertype-alternation.ts`'s
+ * `simplifyRawName`, which collapses a qualified name to its LAST segment
+ * (`Other::Inner` → `Inner`) — that is a tail extractor, not a normalizer, and
+ * using it as a lookup key guarantees a miss.
+ *
+ * Pure string functions; no AST or tree-sitter dependency.
+ */
+/**
+ * Normalize a raw qualified name to the `.`-joined canonical form:
+ * strips whitespace, converts `::` and `\` separators to `.`, collapses
+ * repeated dots, and trims leading/trailing dots.
+ */
+export declare const normalizeQualifiedName: (value: string) => string;
+/**
+ * Split a raw qualified name into its normalized, non-empty segments
+ * (`Other::Inner` → `['Other', 'Inner']`). Returns `[]` for an empty or
+ * separator-only input.
+ */
+export declare const splitQualifiedName: (value: string) => string[];
+/**
+ * Strip a trailing generic argument list at angle-bracket depth 0
+ * (`Models.Box<int>` → `Models.Box`). Constructor and inheritance sites
+ * often carry type arguments that are not part of the indexed def key.
+ */
+export declare function stripTrailingTypeArguments(value: string): string;

package/dist/core/ingestion/utils/qualified-name.js

@@ -0,0 +1,67 @@
+/**
+ * Shared qualified-name normalization.
+ *
+ * One canonical transform from a raw, language-specific qualified name
+ * (`Other::Inner`, `pkg\Sub\Type`, `  A . B `) to the `.`-joined form the
+ * graph and the `QualifiedNameIndex` are keyed by (`Other.Inner`, `pkg.Sub.Type`,
+ * `A.B`). Extracted from `class-extractors/generic.ts` so the structure-phase
+ * `buildQualifiedName`, the scope-resolution inheritance resolver, and the
+ * per-language capture emitters all key against ONE normalizer — a raw `::`
+ * qualifier must normalize to the exact key the index already holds, or the
+ * qualified lookup silently misses (issue #1982).
+ *
+ * Do NOT confuse with `heritage-extractors/supertype-alternation.ts`'s
+ * `simplifyRawName`, which collapses a qualified name to its LAST segment
+ * (`Other::Inner` → `Inner`) — that is a tail extractor, not a normalizer, and
+ * using it as a lookup key guarantees a miss.
+ *
+ * Pure string functions; no AST or tree-sitter dependency.
+ */
+/**
+ * Normalize a raw qualified name to the `.`-joined canonical form:
+ * strips whitespace, converts `::` and `\` separators to `.`, collapses
+ * repeated dots, and trims leading/trailing dots.
+ */
+export const normalizeQualifiedName = (value) => value
+    .replace(/\s+/g, '')
+    .replace(/^::/, '')
+    .replace(/::/g, '.')
+    .replace(/\\/g, '.')
+    .replace(/\.+/g, '.')
+    .replace(/^\.+|\.+$/g, '');
+/**
+ * Split a raw qualified name into its normalized, non-empty segments
+ * (`Other::Inner` → `['Other', 'Inner']`). Returns `[]` for an empty or
+ * separator-only input.
+ */
+export const splitQualifiedName = (value) => {
+    const normalized = normalizeQualifiedName(value);
+    return normalized ? normalized.split('.').filter(Boolean) : [];
+};
+/**
+ * Strip a trailing generic argument list at angle-bracket depth 0
+ * (`Models.Box<int>` → `Models.Box`). Constructor and inheritance sites
+ * often carry type arguments that are not part of the indexed def key.
+ */
+export function stripTrailingTypeArguments(value) {
+    let depth = 0;
+    let ltAt0 = -1;
+    for (let i = 0; i < value.length; i++) {
+        const c = value[i];
+        if (c === '<') {
+            if (depth === 0)
+                ltAt0 = i;
+            depth++;
+        }
+        else if (c === '>') {
+            depth = Math.max(0, depth - 1);
+            if (depth === 0 && ltAt0 >= 0) {
+                const after = value.slice(i + 1).trim();
+                if (after.length === 0)
+                    return value.slice(0, ltAt0);
+                ltAt0 = -1;
+            }
+        }
+    }
+    return value;
+}

package/dist/core/ingestion/variable-extractors/configs/c-cpp.js

@@ -32,6 +32,54 @@ function extractCVarName(node) {
     }
     return undefined;
 }
+/**
+ * Locate the `structured_binding_declarator` inside a `declaration` node, if any.
+ *
+ * C++ structured bindings (`auto [a, b] = pair;`) parse as:
+ *   declaration → init_declarator → structured_binding_declarator → identifier+
+ * The reference form (`auto& [x, y] = tup;`) wraps it one level deeper:
+ *   declaration → init_declarator → reference_declarator → structured_binding_declarator
+ */
+function findStructuredBindingDeclarator(node) {
+    for (let i = 0; i < node.namedChildCount; i++) {
+        const child = node.namedChild(i);
+        if (child?.type !== 'init_declarator')
+            continue;
+        const declarator = child.childForFieldName('declarator');
+        if (declarator?.type === 'structured_binding_declarator')
+            return declarator;
+        // `auto& [x, y]` → reference_declarator wraps the structured_binding_declarator.
+        if (declarator?.type === 'reference_declarator') {
+            const inner = declarator.namedChildren.find((c) => c.type === 'structured_binding_declarator');
+            if (inner)
+                return inner;
+        }
+    }
+    return undefined;
+}
+/**
+ * Extract every bound name from a C/C++ declaration.
+ *
+ * For a structured binding `auto [a, b] = ...;` this returns each bound
+ * identifier (`['a', 'b']`); the binding's `structured_binding_declarator`
+ * lists one `identifier` per name. For an ordinary single-name declaration
+ * (`int n = 0;`) it falls back to the single name extractor so behaviour is
+ * unchanged (issue #1919 F9).
+ */
+function extractCVarNames(node) {
+    const binding = findStructuredBindingDeclarator(node);
+    if (binding !== undefined) {
+        const names = [];
+        for (let i = 0; i < binding.namedChildCount; i++) {
+            const child = binding.namedChild(i);
+            if (child?.type === 'identifier')
+                names.push(child.text);
+        }
+        return names;
+    }
+    const single = extractCVarName(node);
+    return single !== undefined ? [single] : [];
+}
 function extractCVarType(node) {
     const typeNode = node.childForFieldName('type');
     if (typeNode)
@@ -52,6 +100,7 @@ const shared = {
     staticNodeTypes: [],
     variableNodeTypes: ['declaration'],
     extractName: extractCVarName,
+    extractNames: extractCVarNames,
     extractType: extractCVarType,
     extractVisibility(node) {
         // C/C++ visibility is file-scoped by default (static = file-private)

package/dist/core/ingestion/variable-extractors/configs/dart.js

@@ -1,68 +1,79 @@
 // gitnexus/src/core/ingestion/variable-extractors/configs/dart.ts
 import { SupportedLanguages } from '../../../../_shared/index.js';
-import { extractSimpleTypeName } from '../../type-extractors/shared.js';
 /**
  * Dart variable extraction config.
  *
- * Dart has top-level variable and constant declarations:
- * - `const maxSize = 100;`
- * - `final String name = "dart";`
- * - `var counter = 0;`
- * - `int x = 5;`
+ * Top-level Dart variables are NOT wrapped in a `declaration` node (that wrapper
+ * only occurs for class-body members). The structure query (`DART_QUERIES`)
+ * captures them as `@definition.variable` on the loose container node, which is
+ * one of two real shapes:
  *
- * tree-sitter-dart uses:
- * - declaration (with initialized_identifier_list) for file-scope variables
+ *   - `var name = 'x';` / `int x = 5;`
+ *       → initialized_identifier_list > initialized_identifier > identifier
+ *   - `final int count = 3;` / `const a = 1, b = 2;`
+ *       → static_final_declaration_list > static_final_declaration > identifier
+ *
+ * The variable extractor is invoked on that captured container node to enrich
+ * the Variable symbol with name(s)/type/const/mutable metadata.
+ *
+ * NOTE: the const/final modifier (`const_builtin` / `final_builtin`) and the
+ * type annotation (`type_identifier`) are siblings of the captured container —
+ * they live on the parent (program), NOT inside it — so const-ness and the type
+ * are read from the captured node's parent. (This is why the previous
+ * `type_identifier`-as-direct-child read found nothing.)
  */
-function extractDartVarName(node) {
-    // declaration → initialized_variable_definition → identifier
-    for (let i = 0; i < node.namedChildCount; i++) {
-        const child = node.namedChild(i);
-        if (child?.type === 'initialized_variable_definition') {
-            const name = child.childForFieldName('name');
-            if (name)
-                return name.text;
-            // Fallback: first identifier
-            for (let j = 0; j < child.namedChildCount; j++) {
-                const gc = child.namedChild(j);
-                if (gc?.type === 'identifier')
-                    return gc.text;
-            }
-        }
-        // declaration → initialized_identifier_list → initialized_identifier → identifier
-        if (child?.type === 'initialized_identifier_list') {
-            for (let j = 0; j < child.namedChildCount; j++) {
-                const gc = child.namedChild(j);
-                if (gc?.type === 'initialized_identifier') {
-                    const ident = gc.namedChildren.find((c) => c.type === 'identifier');
-                    if (ident)
-                        return ident.text;
-                }
-            }
+/** The `initialized_identifier` / `static_final_declaration` name children. */
+function nameNodes(container) {
+    const out = [];
+    for (let i = 0; i < container.namedChildCount; i++) {
+        const entry = container.namedChild(i);
+        if (!entry)
+            continue;
+        if (entry.type === 'initialized_identifier' || entry.type === 'static_final_declaration') {
+            const ident = entry.firstNamedChild;
+            if (ident?.type === 'identifier')
+                out.push(ident);
         }
     }
-    return undefined;
+    return out;
 }
-function extractDartVarType(node) {
-    for (let i = 0; i < node.namedChildCount; i++) {
-        const child = node.namedChild(i);
-        if (child?.type === 'initialized_variable_definition') {
-            const typeNode = child.childForFieldName('type');
-            if (typeNode)
-                return extractSimpleTypeName(typeNode) ?? typeNode.text?.trim();
-        }
+function extractDartVarNames(node) {
+    return nameNodes(node).map((n) => n.text);
+}
+/**
+ * Scan the container's immediately-preceding siblings (the modifier / type
+ * nodes of THIS declaration), stopping at the previous statement's `;` so a
+ * neighbouring declaration's modifiers/type never bleed in. Top-level Dart
+ * declarations sit as loose siblings under `program` separated by `;`:
+ *   final int count = 3; var name = 'x'; const a = 1, b = 2;
+ * so the leading `type_identifier` / `const_builtin` / `final_builtin` of a
+ * declaration are the siblings between the prior `;` and the captured container.
+ */
+function scanLeadingSiblings(node) {
+    const out = [];
+    let sib = node.previousSibling;
+    while (sib !== null && sib.type !== ';') {
+        out.push(sib);
+        sib = sib.previousSibling;
     }
-    // Look for type_identifier directly on the node
-    for (let i = 0; i < node.namedChildCount; i++) {
-        const child = node.namedChild(i);
-        if (child?.type === 'type_identifier')
-            return child.text;
+    return out;
+}
+/**
+ * The declared type annotation, read from the captured container's leading
+ * sibling `type_identifier`. Returns undefined for inferred (`var`)
+ * declarations, which have an `inferred_type` sibling instead.
+ */
+function extractDartVarType(node) {
+    for (const sib of scanLeadingSiblings(node)) {
+        if (sib.type === 'type_identifier')
+            return sib.text;
     }
     return undefined;
 }
-function hasDartKeyword(node, keyword) {
-    for (let i = 0; i < node.childCount; i++) {
-        const child = node.child(i);
-        if (child?.text === keyword)
+/** Whether a `const_builtin` / `final_builtin` leads this declaration. */
+function hasReadonlyModifier(node) {
+    for (const sib of scanLeadingSiblings(node)) {
+        if (sib.type === 'const_builtin' || sib.type === 'final_builtin')
             return true;
     }
     return false;
@@ -71,24 +82,27 @@ export const dartVariableConfig = {
     language: SupportedLanguages.Dart,
     constNodeTypes: [],
     staticNodeTypes: [],
-    variableNodeTypes: ['declaration'],
-    extractName: extractDartVarName,
+    // The two real top-level container shapes captured as @definition.variable.
+    variableNodeTypes: ['initialized_identifier_list', 'static_final_declaration_list'],
+    extractName: (node) => extractDartVarNames(node)[0],
+    extractNames: extractDartVarNames,
     extractType: extractDartVarType,
-    extractVisibility(node) {
-        const name = extractDartVarName(node);
-        if (!name)
-            return 'public';
-        // Dart convention: underscore prefix = library-private
+    extractVisibilityForName(_node, name) {
+        // Dart convention: underscore prefix = library-private.
         return name.startsWith('_') ? 'private' : 'public';
     },
-    isConst(node) {
-        return hasDartKeyword(node, 'const') || hasDartKeyword(node, 'final');
+    extractVisibility(node) {
+        const first = extractDartVarNames(node)[0];
+        if (!first)
+            return 'public';
+        return first.startsWith('_') ? 'private' : 'public';
     },
+    isConst: hasReadonlyModifier,
     isStatic(_node) {
-        // Top-level Dart variables are not static
+        // Top-level Dart variables are not static.
         return false;
     },
     isMutable(node) {
-        return !hasDartKeyword(node, 'const') && !hasDartKeyword(node, 'final');
+        return !hasReadonlyModifier(node);
     },
 };

package/dist/core/ingestion/variable-extractors/configs/go.js

@@ -15,7 +15,69 @@ import { extractSimpleTypeName } from '../../type-extractors/shared.js';
  *
  * Visibility: uppercase first letter = exported (public), lowercase = unexported (package).
  */
+function goVisibilityForName(name) {
+    const firstChar = name.charAt(0);
+    return firstChar === firstChar.toUpperCase() && firstChar !== firstChar.toLowerCase()
+        ? 'public'
+        : 'package';
+}
+function collectGoSpecNames(spec) {
+    const names = [];
+    for (let i = 0; i < spec.namedChildCount; i++) {
+        const child = spec.namedChild(i);
+        if (!child)
+            continue;
+        if (child.type === 'identifier') {
+            names.push(child.text);
+            continue;
+        }
+        break;
+    }
+    return names;
+}
+function collectGoSpecs(node) {
+    const specs = [];
+    for (let i = 0; i < node.namedChildCount; i++) {
+        const child = node.namedChild(i);
+        if (child?.type === 'var_spec' || child?.type === 'const_spec') {
+            specs.push(child);
+            continue;
+        }
+        if (child?.type === 'var_spec_list') {
+            specs.push(...collectGoSpecs(child));
+        }
+    }
+    return specs;
+}
+function collectGoDeclarationNames(node) {
+    if (node.type === 'short_var_declaration') {
+        const left = node.childForFieldName('left');
+        if (left?.type !== 'expression_list')
+            return [];
+        return left.namedChildren
+            .filter((child) => child.type === 'identifier')
+            .map((child) => child.text);
+    }
+    const names = [];
+    for (const spec of collectGoSpecs(node))
+        names.push(...collectGoSpecNames(spec));
+    return names;
+}
+function findGoSpecForName(node, name) {
+    for (const spec of collectGoSpecs(node)) {
+        if (collectGoSpecNames(spec).includes(name))
+            return spec;
+    }
+    return undefined;
+}
+function extractGoSpecType(spec) {
+    const typeNode = spec.childForFieldName('type');
+    return typeNode ? (extractSimpleTypeName(typeNode) ?? typeNode.text?.trim()) : undefined;
+}
 function extractGoVarName(node) {
+    const firstName = collectGoDeclarationNames(node)[0];
+    if (firstName)
+        return firstName;
     // var_declaration/const_declaration → var_spec/const_spec → identifier
     for (let i = 0; i < node.namedChildCount; i++) {
         const child = node.namedChild(i);
@@ -43,13 +105,10 @@ function extractGoVarName(node) {
     return undefined;
 }
 function extractGoVarType(node) {
-    for (let i = 0; i < node.namedChildCount; i++) {
-        const child = node.namedChild(i);
-        if (child?.type === 'var_spec' || child?.type === 'const_spec') {
-            const typeNode = child.childForFieldName('type');
-            if (typeNode)
-                return extractSimpleTypeName(typeNode) ?? typeNode.text?.trim();
-        }
+    for (const spec of collectGoSpecs(node)) {
+        const typeName = extractGoSpecType(spec);
+        if (typeName)
+            return typeName;
     }
     return undefined;
 }
@@ -60,6 +119,10 @@ export const goVariableConfig = {
     variableNodeTypes: ['var_declaration', 'short_var_declaration'],
     extractName: extractGoVarName,
     extractType: extractGoVarType,
+    extractTypeForName(node, name) {
+        const spec = findGoSpecForName(node, name);
+        return spec ? extractGoSpecType(spec) : undefined;
+    },
     extractVisibility(node) {
         const name = extractGoVarName(node);
         if (!name)
@@ -70,6 +133,10 @@ export const goVariableConfig = {
             ? 'public'
             : 'package';
     },
+    extractNames: collectGoDeclarationNames,
+    extractVisibilityForName(_node, name) {
+        return goVisibilityForName(name);
+    },
     isConst(node) {
         return node.type === 'const_declaration';
     },

package/dist/core/ingestion/variable-extractors/configs/jvm.js

@@ -46,6 +46,18 @@ export const javaVariableConfig = {
         return !hasModifier(node, 'modifiers', 'final');
     },
 };
+/** Single-binding name of a Kotlin property_declaration:
+ *  property_declaration → variable_declaration → simple_identifier. */
+function kotlinSingleVarName(node) {
+    for (let i = 0; i < node.namedChildCount; i++) {
+        const child = node.namedChild(i);
+        if (child?.type === 'variable_declaration') {
+            const ident = child.namedChildren.find((c) => c.type === 'simple_identifier');
+            return ident?.text;
+        }
+    }
+    return undefined;
+}
 /**
  * Kotlin variable extraction config.
  *
@@ -57,16 +69,31 @@ export const kotlinVariableConfig = {
     constNodeTypes: [],
     staticNodeTypes: [],
     variableNodeTypes: ['property_declaration'],
-    extractName(node) {
-        // property_declaration → variable_declaration → simple_identifier
-        for (let i = 0; i < node.namedChildCount; i++) {
-            const child = node.namedChild(i);
-            if (child?.type === 'variable_declaration') {
-                const ident = child.namedChildren.find((c) => c.type === 'simple_identifier');
-                return ident?.text;
+    extractName: kotlinSingleVarName,
+    // F51 (issue #1919): destructuring declarations bind several names at one
+    // node. `val (a, b) = pair` parses as
+    //   property_declaration → multi_variable_declaration
+    //     → variable_declaration → simple_identifier (one per name)
+    // (real-parse-verified). The single-name `extractName` above misses these
+    // entirely. When a multi_variable_declaration is present we return EACH
+    // bound name; the Kotlin `_` placeholder is a discard and is skipped. A
+    // plain single declaration falls through to the existing variable_declaration
+    // shape so `val x = 1` still yields exactly one name (no double-count).
+    extractNames(node) {
+        const multi = node.namedChildren.find((c) => c.type === 'multi_variable_declaration');
+        if (multi !== undefined) {
+            const names = [];
+            for (const decl of multi.namedChildren) {
+                if (decl.type !== 'variable_declaration')
+                    continue;
+                const ident = decl.namedChildren.find((c) => c.type === 'simple_identifier');
+                if (ident !== undefined && ident.text !== '_')
+                    names.push(ident.text);
             }
+            return names;
         }
-        return undefined;
+        const single = kotlinSingleVarName(node);
+        return single !== undefined ? [single] : [];
     },
     extractType(node) {
         // Look for type annotation in variable_declaration child