gitnexus 1.6.6-rc.99 → 1.6.6

package/dist/core/ingestion/languages/cpp/capture-side-channel.d.ts

@@ -0,0 +1,65 @@
+/**
+ * C++ capture-time side-channel serialization (#1983).
+ *
+ * `emitCppScopeCaptures` populates several MODULE-LEVEL maps as a side effect
+ * that are NOT part of the returned `ParsedFile`'s scopes/defs:
+ *
+ *   - `argInfoBySite` / `noAdlSites`            (adl.ts)
+ *   - `inlineNamespaceRangesByFile`             (inline-namespaces.ts)
+ *   - `fileLocalNames` / `anonymousNamespaceRangesByFile` (file-local-linkage.ts)
+ *   - `dependentBasesByFile` / `dependentPackBaseClassesByFile` (two-phase-lookup.ts)
+ *
+ * On the worker path those maps are filled in the WORKER process and lost
+ * across the worker→main MessageChannel (and the disk-backed parsedfile-store),
+ * because scope-resolution reuses the serialized `ParsedFile` and SKIPS the
+ * main-thread re-extraction — the entire point of #1983 is to avoid a
+ * main-thread tree-sitter re-parse on huge `.h`/`.cpp` repos (the OOM).
+ *
+ * This module snapshots the per-file slice of those maps into a plain,
+ * JSON-serializable object (carried on `ParsedFile.captureSideChannel`) and
+ * restores it on the main thread WITHOUT any parse. It is the data-only
+ * replacement for the removed re-parse `replayCaptureSideChannel` hook.
+ *
+ * The derived state each `populateOwners` / `populateWorkspaceOwners` pass
+ * builds (resolved scope-id Sets, `dependentBaseNodeIds`, etc.) is recomputed
+ * on the main thread from these restored capture-time maps, so only the
+ * capture-time maps need to cross the boundary.
+ */
+import type { ParsedFile } from '../../../../_shared/index.js';
+import { type CppAdlSideChannel } from './adl.js';
+import { type CppFileLocalSideChannel } from './file-local-linkage.js';
+import { type CppTwoPhaseSideChannel } from './two-phase-lookup.js';
+/**
+ * Plain JSON-serializable composite of every C++ capture-time side-channel
+ * slice for one file. Carried opaquely on `ParsedFile.captureSideChannel`.
+ */
+export interface CppCaptureSideChannel {
+    /**
+     * Discriminant tag — the single generic `ParsedFile.captureSideChannel`
+     * field is shared with C (`{ kind: 'c' }`) and Kotlin (`{ kind: 'kotlin' }`).
+     * `applyCppCaptureSideChannel` checks this first so a foreign-language
+     * payload reaching the C++ apply (or vice-versa) is cleanly ignored. In
+     * practice apply only runs for the matching provider (one language per file),
+     * but the tag makes it robust and consistent with the C/Kotlin snapshots.
+     */
+    readonly kind: 'cpp';
+    readonly adl: CppAdlSideChannel;
+    /** Inline-namespace source-range keys recorded for this file. */
+    readonly inlineNamespaceRanges: readonly string[];
+    readonly fileLocal: CppFileLocalSideChannel;
+    readonly twoPhase: CppTwoPhaseSideChannel;
+}
+/**
+ * `LanguageProvider.collectCaptureSideChannel` implementation for C++.
+ * Returns `undefined` when this file recorded no side-channel state at all, so
+ * the produced `ParsedFile` carries the field only when there's data to ship.
+ */
+export declare function collectCppCaptureSideChannel(filePath: string): CppCaptureSideChannel | undefined;
+/**
+ * `ScopeResolver.applyCaptureSideChannel` implementation for C++. Reads the
+ * worker-serialized snapshot from `parsed.captureSideChannel` and writes it
+ * back into the module-level maps. Tolerant of `undefined` (file carried no
+ * data) and of an unexpected shape (defensive — never throws on a malformed
+ * snapshot). Does NO tree-sitter parse.
+ */
+export declare function applyCppCaptureSideChannel(parsed: ParsedFile): void;

package/dist/core/ingestion/languages/cpp/capture-side-channel.js

@@ -0,0 +1,78 @@
+/**
+ * C++ capture-time side-channel serialization (#1983).
+ *
+ * `emitCppScopeCaptures` populates several MODULE-LEVEL maps as a side effect
+ * that are NOT part of the returned `ParsedFile`'s scopes/defs:
+ *
+ *   - `argInfoBySite` / `noAdlSites`            (adl.ts)
+ *   - `inlineNamespaceRangesByFile`             (inline-namespaces.ts)
+ *   - `fileLocalNames` / `anonymousNamespaceRangesByFile` (file-local-linkage.ts)
+ *   - `dependentBasesByFile` / `dependentPackBaseClassesByFile` (two-phase-lookup.ts)
+ *
+ * On the worker path those maps are filled in the WORKER process and lost
+ * across the worker→main MessageChannel (and the disk-backed parsedfile-store),
+ * because scope-resolution reuses the serialized `ParsedFile` and SKIPS the
+ * main-thread re-extraction — the entire point of #1983 is to avoid a
+ * main-thread tree-sitter re-parse on huge `.h`/`.cpp` repos (the OOM).
+ *
+ * This module snapshots the per-file slice of those maps into a plain,
+ * JSON-serializable object (carried on `ParsedFile.captureSideChannel`) and
+ * restores it on the main thread WITHOUT any parse. It is the data-only
+ * replacement for the removed re-parse `replayCaptureSideChannel` hook.
+ *
+ * The derived state each `populateOwners` / `populateWorkspaceOwners` pass
+ * builds (resolved scope-id Sets, `dependentBaseNodeIds`, etc.) is recomputed
+ * on the main thread from these restored capture-time maps, so only the
+ * capture-time maps need to cross the boundary.
+ */
+import { collectCppAdlSideChannel, applyCppAdlSideChannel } from './adl.js';
+import { collectCppInlineNamespaceSideChannel, applyCppInlineNamespaceSideChannel, } from './inline-namespaces.js';
+import { collectCppFileLocalSideChannel, applyCppFileLocalSideChannel, } from './file-local-linkage.js';
+import { collectCppTwoPhaseSideChannel, applyCppTwoPhaseSideChannel, } from './two-phase-lookup.js';
+/**
+ * `LanguageProvider.collectCaptureSideChannel` implementation for C++.
+ * Returns `undefined` when this file recorded no side-channel state at all, so
+ * the produced `ParsedFile` carries the field only when there's data to ship.
+ */
+export function collectCppCaptureSideChannel(filePath) {
+    const adl = collectCppAdlSideChannel(filePath);
+    const inlineNamespaceRanges = collectCppInlineNamespaceSideChannel(filePath);
+    const fileLocal = collectCppFileLocalSideChannel(filePath);
+    const twoPhase = collectCppTwoPhaseSideChannel(filePath);
+    const isEmpty = adl.argInfoBySite.length === 0 &&
+        adl.noAdlSites.length === 0 &&
+        inlineNamespaceRanges.length === 0 &&
+        fileLocal.fileLocalNames.length === 0 &&
+        fileLocal.anonymousNamespaceRanges.length === 0 &&
+        twoPhase.dependentBases.length === 0 &&
+        twoPhase.dependentPackBaseClasses.length === 0;
+    if (isEmpty)
+        return undefined;
+    return { kind: 'cpp', adl, inlineNamespaceRanges, fileLocal, twoPhase };
+}
+/**
+ * `ScopeResolver.applyCaptureSideChannel` implementation for C++. Reads the
+ * worker-serialized snapshot from `parsed.captureSideChannel` and writes it
+ * back into the module-level maps. Tolerant of `undefined` (file carried no
+ * data) and of an unexpected shape (defensive — never throws on a malformed
+ * snapshot). Does NO tree-sitter parse.
+ */
+export function applyCppCaptureSideChannel(parsed) {
+    const data = parsed.captureSideChannel;
+    if (data === undefined || data === null || typeof data !== 'object')
+        return;
+    // Discriminant guard — the generic `captureSideChannel` field is shared
+    // with C (`{ kind: 'c' }`) and Kotlin (`{ kind: 'kotlin' }`); cleanly
+    // ignore a non-C++ payload rather than mis-applying it.
+    if (data.kind !== 'cpp')
+        return;
+    if (data.adl !== undefined)
+        applyCppAdlSideChannel(parsed.filePath, data.adl);
+    if (data.inlineNamespaceRanges !== undefined) {
+        applyCppInlineNamespaceSideChannel(parsed.filePath, data.inlineNamespaceRanges);
+    }
+    if (data.fileLocal !== undefined)
+        applyCppFileLocalSideChannel(parsed.filePath, data.fileLocal);
+    if (data.twoPhase !== undefined)
+        applyCppTwoPhaseSideChannel(parsed.filePath, data.twoPhase);
+}

package/dist/core/ingestion/languages/cpp/captures.js

@@ -1,11 +1,12 @@
-import { findNodeAtRange, nodeToCapture, syntheticCapture, } from '../../utils/ast-helpers.js';
+import { nodeIfType, nodeToCapture, syntheticCapture, } from '../../utils/ast-helpers.js';
 import { getCppParser, getCppScopeQuery } from './query.js';
 import { getTreeSitterBufferSize } from '../../constants.js';
 import { parseSourceSafe } from '../../../tree-sitter/safe-parse.js';
+import { normalizeQualifiedName } from '../../utils/qualified-name.js';
 import { splitCppInclude, splitCppUsingDecl } from './import-decomposer.js';
 import { classifyCppParameterType, computeCppDeclarationArity, computeCppCallArity, } from './arity-metadata.js';
 import { markCppAnonymousNamespaceRange, markFileLocal } from './file-local-linkage.js';
-import { markCppDependentBase } from './two-phase-lookup.js';
+import { markCppDependentBase, markCppDependentPackBase } from './two-phase-lookup.js';
 import { markCppAdlSiteArgs, markCppAdlSiteNoAdl } from './adl.js';
 import { markCppInlineNamespaceRange } from './inline-namespaces.js';
 import { extractCppTemplateConstraints } from './constraint-extractor.js';
@@ -18,23 +19,34 @@ export function emitCppScopeCaptures(sourceText, filePath, cachedTree) {
     }
     const rawMatches = getCppScopeQuery().matches(tree.rootNode);
     const out = [];
-    // Track ranges where typedef-struct was captured as @declaration.struct
+    // Track ranges where typedef-struct/enum was captured as its concrete type
     // so we can suppress the duplicate @declaration.typedef match.
-    const structTypedefRanges = new Set();
+    const concreteTypedefRanges = new Set();
     for (const m of rawMatches) {
         const grouped = {};
+        // Parallel tag -> captured SyntaxNode map. The tree-sitter query already
+        // hands us each matched node as `c.node`, so anchors resolve via a
+        // type-guarded lookup (`nodeIfType`) instead of re-deriving them with
+        // `findNodeAtRange(tree.rootNode, ...)` per match — the
+        // O(matches × rootChildren) root-walk fixed for go #1848 / python #1918 /
+        // rust/csharp #1915 / java, mirrored here for C++ (#1951). Each C++
+        // scope-query anchor used below captures directly ON the node the old
+        // root-walk re-derived (verified against CPP_SCOPE_QUERY in query.ts and a
+        // real-parse AST probe), so the type check is exact.
+        const nodeMap = {};
         for (const c of m.captures) {
             const tag = '@' + c.name;
             if (tag.startsWith('@_'))
                 continue;
             grouped[tag] = nodeToCapture(tag, c.node);
+            nodeMap[tag] = c.node;
         }
         if (Object.keys(grouped).length === 0)
             continue;
         // ── Handle #include statements ──────────────────────────────────
+        // `@import.statement` is captured directly on the `preproc_include` node.
         if (grouped['@import.statement'] !== undefined) {
-            const anchor = grouped['@import.statement'];
-            const includeNode = findNodeAtRange(tree.rootNode, anchor.range, 'preproc_include');
+            const includeNode = nodeIfType(nodeMap['@import.statement'], 'preproc_include');
             if (includeNode !== null) {
                 const split = splitCppInclude(includeNode);
                 if (split !== null) {
@@ -44,9 +56,9 @@ export function emitCppScopeCaptures(sourceText, filePath, cachedTree) {
             }
         }
         // ── Handle using declarations (using namespace / using name) ────
+        // `@import.using-decl` is captured directly on the `using_declaration` node.
         if (grouped['@import.using-decl'] !== undefined) {
-            const anchor = grouped['@import.using-decl'];
-            const usingNode = findNodeAtRange(tree.rootNode, anchor.range, 'using_declaration');
+            const usingNode = nodeIfType(nodeMap['@import.using-decl'], 'using_declaration');
             if (usingNode !== null) {
                 const split = splitCppUsingDecl(usingNode);
                 if (split !== null) {
@@ -55,26 +67,30 @@ export function emitCppScopeCaptures(sourceText, filePath, cachedTree) {
                 }
             }
         }
-        // ── Track typedef-struct ranges ─────────────────────────────────
-        const structAnchor = grouped['@declaration.struct'] ?? grouped['@declaration.class'];
-        if (structAnchor !== undefined) {
-            const r = structAnchor.range;
-            structTypedefRanges.add(`${r.startLine}:${r.startCol}:${r.endLine}:${r.endCol}`);
+        // ── Track concrete typedef ranges ───────────────────────────────
+        const concreteTypeAnchor = grouped['@declaration.struct'] ??
+            grouped['@declaration.class'] ??
+            grouped['@declaration.enum'];
+        if (concreteTypeAnchor !== undefined) {
+            const r = concreteTypeAnchor.range;
+            concreteTypedefRanges.add(`${r.startLine}:${r.startCol}:${r.endLine}:${r.endCol}`);
         }
         // Suppress @declaration.typedef if the same range was already captured
         const typedefAnchor = grouped['@declaration.typedef'];
         if (typedefAnchor !== undefined) {
             const r = typedefAnchor.range;
             const key = `${r.startLine}:${r.startCol}:${r.endLine}:${r.endCol}`;
-            if (structTypedefRanges.has(key))
+            if (concreteTypedefRanges.has(key))
                 continue;
         }
         // ── Enrich function/method declarations with arity metadata ─────
-        const declAnchor = grouped['@declaration.function'] ?? grouped['@declaration.method'];
-        if (declAnchor !== undefined) {
-            const fnNode = findNodeAtRange(tree.rootNode, declAnchor.range, 'function_definition') ??
-                findNodeAtRange(tree.rootNode, declAnchor.range, 'declaration') ??
-                findNodeAtRange(tree.rootNode, declAnchor.range, 'field_declaration');
+        // `@declaration.function` / `@declaration.method` capture directly on the
+        // `function_definition` (definitions/templates), `declaration` (free/
+        // constructor prototypes), or `field_declaration` (class-body method
+        // prototypes) node — the node the old findNodeAtRange re-derived.
+        const declAnchorNode = nodeMap['@declaration.function'] ?? nodeMap['@declaration.method'];
+        if (declAnchorNode !== undefined) {
+            const fnNode = nodeIfType(declAnchorNode, 'function_definition', 'declaration', 'field_declaration');
             if (fnNode !== null) {
                 const arity = computeCppDeclarationArity(fnNode);
                 if (arity.parameterCount !== undefined) {
@@ -126,9 +142,9 @@ export function emitCppScopeCaptures(sourceText, filePath, cachedTree) {
             }
         }
         // ── Detect static variables (file-local linkage) ────────────────
-        const varDeclAnchor = grouped['@declaration.variable'];
-        if (varDeclAnchor !== undefined) {
-            const varNode = findNodeAtRange(tree.rootNode, varDeclAnchor.range, 'declaration');
+        // `@declaration.variable` is captured directly on the `declaration` node.
+        if (grouped['@declaration.variable'] !== undefined) {
+            const varNode = nodeIfType(nodeMap['@declaration.variable'], 'declaration');
             if (varNode !== null) {
                 if (hasStaticStorageClass(varNode) || isInsideAnonymousNamespace(varNode)) {
                     const nameText = grouped['@declaration.name']?.text;
@@ -139,20 +155,28 @@ export function emitCppScopeCaptures(sourceText, filePath, cachedTree) {
             }
         }
         // ── Enrich call references with arity ───────────────────────────
+        // `@reference.call.free` / `.member` capture on the `call_expression` (plain
+        // / member / template calls) or on the `binary_expression` (the operator-call
+        // patterns: `a + b`, `lhs << rhs`); `@reference.call.qualified` always on the
+        // `call_expression`. The captured node IS the node the old findNodeAtRange
+        // re-derived (verified against CPP_SCOPE_QUERY + a real-parse probe).
         const callAnchor = grouped['@reference.call.free'] ??
             grouped['@reference.call.member'] ??
             grouped['@reference.call.qualified'];
+        const callAnchorNode = nodeMap['@reference.call.free'] ??
+            nodeMap['@reference.call.member'] ??
+            nodeMap['@reference.call.qualified'];
         const operatorAnchor = grouped['@reference.operator'];
         if (operatorAnchor !== undefined) {
-            const operatorNode = callAnchor !== undefined
-                ? findNodeAtRange(tree.rootNode, callAnchor.range, 'binary_expression')
-                : null;
+            // When `@reference.operator` fires, the co-captured call anchor is the
+            // enclosing `binary_expression` itself, so a type guard reproduces the
+            // old findNodeAtRange(callAnchor.range, 'binary_expression').
+            const operatorNode = callAnchorNode !== undefined ? nodeIfType(callAnchorNode, 'binary_expression') : null;
             if (operatorNode !== null && isPrimitiveOnlyBinaryOperator(operatorNode))
                 continue;
         }
-        if (callAnchor !== undefined && grouped['@reference.arity'] === undefined) {
-            const callNode = findNodeAtRange(tree.rootNode, callAnchor.range, 'call_expression') ??
-                findNodeAtRange(tree.rootNode, callAnchor.range, 'binary_expression');
+        if (callAnchorNode !== undefined && grouped['@reference.arity'] === undefined) {
+            const callNode = nodeIfType(callAnchorNode, 'call_expression', 'binary_expression');
             if (callNode?.type === 'call_expression') {
                 grouped['@reference.arity'] = syntheticCapture('@reference.arity', callNode, String(computeCppCallArity(callNode)));
             }
@@ -161,22 +185,32 @@ export function emitCppScopeCaptures(sourceText, filePath, cachedTree) {
             }
         }
         if (operatorAnchor !== undefined && grouped['@reference.name'] === undefined) {
-            grouped['@reference.name'] = syntheticCapture('@reference.name', findNodeAtRange(tree.rootNode, operatorAnchor.range, operatorAnchor.text) ?? tree.rootNode, `operator${operatorAnchor.text}`);
+            // The old code did `findNodeAtRange(tree.rootNode, operatorAnchor.range,
+            // operatorAnchor.text)`, searching for a node of type `+` / `<<` at the
+            // operator-token range. That token is an UNNAMED grammar node, and
+            // findNodeAtRange only descends `namedChild`ren, so the search NEVER hit
+            // and ALWAYS fell back to `tree.rootNode`. Use `tree.rootNode` directly to
+            // preserve the exact synthetic-capture range while dropping the root-walk.
+            grouped['@reference.name'] = syntheticCapture('@reference.name', tree.rootNode, `operator${operatorAnchor.text}`);
         }
         // ── Enrich constructor calls (new Foo()) with arity ─────────────
+        // `@reference.call.constructor` is captured directly on the `new_expression`.
         const ctorCallAnchor = grouped['@reference.call.constructor'];
+        const ctorCallAnchorNode = nodeMap['@reference.call.constructor'];
         if (ctorCallAnchor !== undefined && grouped['@reference.arity'] === undefined) {
-            const newNode = findNodeAtRange(tree.rootNode, ctorCallAnchor.range, 'new_expression');
+            const newNode = nodeIfType(ctorCallAnchorNode, 'new_expression');
             if (newNode !== null) {
                 grouped['@reference.arity'] = syntheticCapture('@reference.arity', newNode, String(computeCppCallArity(newNode)));
             }
         }
         // ── Synthesize argument types for overload narrowing ────────────
+        // The any-call anchor is either the call/operator anchor (`call_expression`
+        // / `binary_expression`) or the constructor anchor (`new_expression`); the
+        // captured node IS what the old findNodeAtRange re-derived.
         const anyCallAnchor = callAnchor ?? ctorCallAnchor;
+        const anyCallAnchorNode = callAnchorNode ?? ctorCallAnchorNode;
         if (anyCallAnchor !== undefined && grouped['@reference.parameter-types'] === undefined) {
-            const cNode = findNodeAtRange(tree.rootNode, anyCallAnchor.range, 'call_expression') ??
-                findNodeAtRange(tree.rootNode, anyCallAnchor.range, 'new_expression') ??
-                findNodeAtRange(tree.rootNode, anyCallAnchor.range, 'binary_expression');
+            const cNode = nodeIfType(anyCallAnchorNode, 'call_expression', 'new_expression', 'binary_expression');
             if (cNode !== null) {
                 const argTypes = cNode.type === 'binary_expression'
                     ? inferCppBinaryOperatorArgTypes(cNode, grouped['@reference.call.free'] !== undefined)
@@ -201,9 +235,11 @@ export function emitCppScopeCaptures(sourceText, filePath, cachedTree) {
         // `@declaration.namespace` fires only for NAMED namespaces (the query
         // requires a `name: (namespace_identifier)` child). Use the unconditional
         // `@scope.namespace` capture so the anonymous-namespace branch also runs.
-        const namespaceScopeAnchor = grouped['@declaration.namespace'] ?? grouped['@scope.namespace'];
-        if (namespaceScopeAnchor !== undefined) {
-            const nsNode = findNodeAtRange(tree.rootNode, namespaceScopeAnchor.range, 'namespace_definition');
+        // `@declaration.namespace` and `@scope.namespace` both capture directly on
+        // the `namespace_definition` node.
+        const namespaceScopeAnchorNode = nodeMap['@declaration.namespace'] ?? nodeMap['@scope.namespace'];
+        if (namespaceScopeAnchorNode !== undefined) {
+            const nsNode = nodeIfType(namespaceScopeAnchorNode, 'namespace_definition');
             if (nsNode !== null) {
                 // Range coords stored in the shared Range shape use 1-based
                 // line numbers (see `ast-helpers.ts` rangeForNode where
@@ -232,7 +268,11 @@ export function emitCppScopeCaptures(sourceText, filePath, cachedTree) {
         // qualified `Ns::f(s)` and member `obj.f(s)` calls bypass the
         // free-call fallback entirely (handled by receiver-bound-calls).
         if (grouped['@reference.call.free'] !== undefined) {
-            const freeCallNode = findNodeAtRange(tree.rootNode, grouped['@reference.call.free'].range, 'call_expression');
+            // `@reference.call.free` captures on a `call_expression` (plain/template
+            // free call) or a `binary_expression` (the `lhs << rhs` operator-call
+            // pattern). The old findNodeAtRange filtered to `call_expression`, so the
+            // `binary_expression` case yields null here — `nodeIfType` matches exactly.
+            const freeCallNode = nodeIfType(nodeMap['@reference.call.free'], 'call_expression');
             if (freeCallNode !== null) {
                 const adlAnchorRange = grouped['@reference.call.free'].range;
                 if (isParenthesizedFunctionCall(freeCallNode)) {
@@ -254,7 +294,8 @@ export function emitCppScopeCaptures(sourceText, filePath, cachedTree) {
         if (grouped['@type-binding.assignment'] !== undefined &&
             grouped['@type-binding.type']?.text === 'auto') {
             const anchor = grouped['@type-binding.assignment'];
-            const declNode = findNodeAtRange(tree.rootNode, anchor.range, 'declaration');
+            // `@type-binding.assignment` is captured directly on the `declaration` node.
+            const declNode = nodeIfType(nodeMap['@type-binding.assignment'], 'declaration');
             if (declNode !== null) {
                 const declarator = declNode.childForFieldName('declarator');
                 if (declarator?.type === 'init_declarator') {
@@ -303,7 +344,7 @@ export function emitCppScopeCaptures(sourceText, filePath, cachedTree) {
     // captures consumed by the registry-primary graph bridge. The lookup name
     // is normalized to the bare class name so `Base<T>` / `outer::v1::Base<T>`
     // resolve through V1's simple-name `findClassBindingInScope('Base')`.
-    emitCppInheritanceCaptures(tree.rootNode, out);
+    emitCppInheritanceCaptures(tree.rootNode, out, filePath);
     // ── Detect dependent-base relationships for two-phase template lookup ──
     // Walk the tree once, finding every `template_declaration` whose
     // child is a class/struct definition with a `base_class_clause` whose
@@ -351,7 +392,7 @@ function isCppUnsupportedReturnTypeDeclarator(funcDeclarator) {
  * here instead of introducing a C++-only name-resolution lane in shared
  * ingestion infrastructure.
  */
-function emitCppInheritanceCaptures(root, out) {
+function emitCppInheritanceCaptures(root, out, filePath) {
     const stack = [root];
     while (stack.length > 0) {
         const node = stack.pop();
@@ -359,12 +400,27 @@ function emitCppInheritanceCaptures(root, out) {
             const baseClause = findChildOfType(node, ['base_class_clause']);
             if (baseClause !== null) {
                 for (const base of iterBaseClasses(baseClause)) {
-                    const baseName = extractBaseLookupName(base);
+                    if (base.isPackExpansion) {
+                        markClassWithPackExpandedBase(filePath, node);
+                        continue;
+                    }
+                    const baseName = extractBaseLookupName(base.node);
                     if (baseName.length === 0)
                         continue;
+                    // Preserve the qualified form (`Other::Inner`, template-stripped) when the
+                    // source wrote one, so a same-tail nested base resolves to the matching
+                    // qualified node instead of the first-inserted same-tail one (#1982). The
+                    // bare `@reference.name` stays the V1 simple-name contract; the qualifier
+                    // is an additive sidecar resolution tries first (see resolveInheritanceBaseInScope).
+                    const qualifiedBaseName = extractQualifiedBaseName(base.node);
                     out.push({
-                        '@reference.inherits': nodeToCapture('@reference.inherits', base),
-                        '@reference.name': syntheticCapture('@reference.name', base, baseName),
+                        '@reference.inherits': nodeToCapture('@reference.inherits', base.node),
+                        '@reference.name': syntheticCapture('@reference.name', base.node, baseName),
+                        ...(qualifiedBaseName.length > 0 && qualifiedBaseName !== baseName
+                            ? {
+                                '@reference.qualified-name': syntheticCapture('@reference.qualified-name', base.node, qualifiedBaseName),
+                            }
+                            : {}),
                     });
                 }
             }
@@ -404,9 +460,12 @@ function detectCppDependentBases(root, filePath) {
                     const baseClause = findChildOfType(classNode, ['base_class_clause']);
                     if (baseClause !== null) {
                         for (const base of iterBaseClasses(baseClause)) {
-                            if (isBaseDependent(base, params)) {
-                                const baseName = extractBaseLookupName(base);
-                                const baseQualifier = extractBaseLookupQualifier(base);
+                            if (base.isPackExpansion || isBaseDependent(base.node, params)) {
+                                if (base.isPackExpansion) {
+                                    markClassWithPackExpandedBase(filePath, classNode);
+                                }
+                                const baseName = extractBaseLookupName(base.node);
+                                const baseQualifier = extractBaseLookupQualifier(base.node);
                                 if (baseName !== '') {
                                     markCppDependentBase(filePath, className, baseName, baseQualifier);
                                 }
@@ -457,6 +516,11 @@ function collectTemplateParameterNames(templateDecl) {
     }
     return names;
 }
+function markClassWithPackExpandedBase(filePath, classNode) {
+    const className = getTypeIdentifierName(classNode);
+    if (className !== '')
+        markCppDependentPackBase(filePath, className);
+}
 /** Yield each base-class entry from a `base_class_clause`. */
 function* iterBaseClasses(baseClause) {
     for (let i = 0; i < baseClause.childCount; i++) {
@@ -468,10 +532,24 @@ function* iterBaseClasses(baseClause) {
         if (child.type === 'type_identifier' ||
             child.type === 'template_type' ||
             child.type === 'qualified_identifier') {
-            yield child;
+            yield { node: child, isPackExpansion: isFollowedByPackExpansion(baseClause, i) };
         }
     }
 }
+function isFollowedByPackExpansion(baseClause, childIndex) {
+    for (let i = childIndex + 1; i < baseClause.childCount; i++) {
+        const sibling = baseClause.child(i);
+        if (sibling === null)
+            continue;
+        if (sibling.type === '...' || (!sibling.isNamed && sibling.text === '...'))
+            return true;
+        if (sibling.type === ',' || sibling.type === 'access_specifier')
+            return false;
+        if (sibling.isNamed)
+            return false;
+    }
+    return false;
+}
 /**
  * A base is dependent when:
  *   - it's a `template_type` and its argument list contains a
@@ -564,6 +642,40 @@ function extractBaseLookupName(baseNode) {
     }
     return '';
 }
+/**
+ * Like `extractBaseLookupName` but PRESERVES the namespace/class qualifier
+ * (`Other::Inner`, `ns::v1::Base`) while stripping template arguments
+ * (`ns::Base<T>` → `ns::Base`). Returns `''` for shapes it can't qualify, and
+ * returns the bare name unchanged for an unqualified base (the emit site then
+ * skips the sidecar capture). Powers `@reference.qualified-name` so #1982
+ * resolution can pick the matching same-tail nested base via the full-path
+ * QualifiedNameIndex instead of the first-inserted same-tail sibling.
+ */
+function extractQualifiedBaseName(baseNode) {
+    if (baseNode.type === 'template_type') {
+        const nameNode = baseNode.childForFieldName('name');
+        return nameNode !== null ? extractQualifiedBaseName(nameNode) : '';
+    }
+    if (baseNode.type === 'qualified_identifier') {
+        // No template args anywhere → the raw text already IS the qualified name.
+        if (!baseNode.text.includes('<'))
+            return baseNode.text;
+        // Template args present: reconstruct scope::name, recursing to strip them.
+        const scopeNode = baseNode.childForFieldName('scope');
+        const nameNode = baseNode.childForFieldName('name');
+        const left = scopeNode !== null ? extractQualifiedBaseName(scopeNode) : '';
+        const right = nameNode !== null ? extractQualifiedBaseName(nameNode) : '';
+        if (left.length > 0 && right.length > 0)
+            return `${left}::${right}`;
+        return right.length > 0 ? right : left;
+    }
+    if (baseNode.type === 'namespace_identifier' ||
+        baseNode.type === 'type_identifier' ||
+        baseNode.type === 'identifier') {
+        return baseNode.text;
+    }
+    return '';
+}
 /** Extract the syntactic namespace qualifier from a base class node.
  *  For `detail::Inner<T>`, returns `'detail'`.
  *  For unqualified bases (`Inner<T>`, `Base<int>`), returns `''`.
@@ -1225,7 +1337,7 @@ function lookupAdlIdentifierType(identNode) {
                 inner = next;
                 continue;
             }
-            if (inner.type === 'reference_declarator' || inner.type === 'rvalue_reference_declarator') {
+            if (inner.type === 'reference_declarator') {
                 // reference_declarator has a single child (the inner declarator).
                 let next = null;
                 for (let j = 0; j < inner.namedChildCount; j++) {
@@ -1362,7 +1474,7 @@ function extractAdlTypeNamespace(typeNode) {
     if (typeNode.type === 'qualified_identifier') {
         const scope = typeNode.childForFieldName('scope');
         if (scope !== null)
-            return normalizeCppNamespaceQName(scope.text);
+            return normalizeQualifiedName(scope.text);
         return extractNamespaceFromQualifiedText(typeNode.text);
     }
     return '';
@@ -1430,16 +1542,12 @@ function findTemplateTypeNode(typeNode) {
     }
     return null;
 }
-function normalizeCppNamespaceQName(text) {
-    const normalized = text.replace(/^::/, '').replace(/::$/, '').replace(/::/g, '.');
-    return normalized;
-}
 function extractNamespaceFromQualifiedText(text) {
     const cleaned = text.replace(/\s+/g, '');
     const idx = cleaned.lastIndexOf('::');
     if (idx <= 0)
         return '';
-    return normalizeCppNamespaceQName(cleaned.slice(0, idx));
+    return normalizeQualifiedName(cleaned.slice(0, idx));
 }
 /**
  * Walk a declarator node chain, unwrapping pointer/reference/function/

package/dist/core/ingestion/languages/cpp/file-local-linkage.d.ts

@@ -16,6 +16,24 @@ export declare function markCppAnonymousNamespaceRange(filePath: string, range:
  *  the cross-file unqualified-lookup exclusion that applies to ordinary
  *  named namespaces. */
 export declare function isCppAnonymousNamespaceScope(scopeId: ScopeId): boolean;
+/**
+ * Plain-data, JSON-serializable snapshot of the per-file capture-time
+ * file-local-linkage state. Carried on `ParsedFile.captureSideChannel` across
+ * the worker→main boundary (#1983). The derived sets (`nonGloballyVisibleNodeIds`,
+ * `anonymousNamespaceScopeIds`) are recomputed by `populateCppNonGloballyVisible`
+ * / `populateCppAnonymousNamespaceScopes` during `populateOwners`, so only the
+ * two capture-time maps cross the boundary.
+ */
+export interface CppFileLocalSideChannel {
+    /** File-local symbol names (static / anonymous-namespace) in this file. */
+    readonly fileLocalNames: readonly string[];
+    /** Anonymous-namespace source-range keys recorded for this file. */
+    readonly anonymousNamespaceRanges: readonly string[];
+}
+/** Snapshot this file's file-local-linkage capture state for the side-channel. */
+export declare function collectCppFileLocalSideChannel(filePath: string): CppFileLocalSideChannel;
+/** Restore this file's file-local-linkage capture state from the side-channel. */
+export declare function applyCppFileLocalSideChannel(filePath: string, data: CppFileLocalSideChannel): void;
 /** Clear tracked file-local names (call at start of each resolution pass). */
 export declare function clearFileLocalNames(): void;
 /** Resolve recorded anonymous-namespace source ranges to `ScopeId`s.
@@ -62,57 +80,5 @@ export declare function populateCppNonGloballyVisible(parsed: {
  * workspace registry walk.
  */
 export declare function isCppDefGloballyVisible(filePath: string, nodeId: string): boolean;
-/**
- * Return the names visible through a C++ wildcard import (`#include` or
- * `using namespace`).
- *
- * ## Contract
- *
- * C++ unqualified name lookup only sees names at the importer's enclosing
- * scope. Class members and namespace-nested symbols are NOT visible by
- * unqualified lookup from a free function in an including TU — they must
- * be reached via `Class::method`, `ns::name`, or a working `using`
- * declaration. The filter below enforces that contract for header
- * propagation: only defs whose nearest enclosing scope is the header's
- * `Module` scope are emitted as wildcard-binding names.
- *
- * ## Why scope-aware and not predicate-on-qualifiedName
- *
- * A naive `def.qualifiedName.indexOf('.') === -1` check is unreliable
- * because `populateClassOwnedMembers`
- * (`gitnexus/src/core/ingestion/scope-resolution/scope/walkers.ts`)
- * only dot-qualifies `qualifiedName` for `Class` scopes. Namespace-nested
- * defs (`namespace ns { void foo(); }`) arrive in `localDefs` with
- * `qualifiedName === 'foo'` and `ownerId === undefined`, indistinguishable
- * from a top-level free function. The structural truth lives in
- * `Scope.ownedDefs`: each scope lists what it structurally owns; the
- * Module scope owns only top-level symbols. We look the def up by
- * `nodeId` against the scope tree to identify its owning kind.
- *
- * ## `localDefs` consumer survey (recorded for future maintainers)
- *
- * Other consumers of `ParsedFile.localDefs` were audited at the time
- * this filter was introduced (see PR #1520 / plan
- * `docs/plans/2026-05-12-002-fix-cpp-resolver-followups-plan.md`):
- *
- *   - `finalize-orchestrator.ts:113,163` — flattens defs into a workspace
- *     registry keyed by `ownerId` + `qualifiedName`; class-owned and
- *     namespace-owned symbols are registered under their owner, not as
- *     unqualified names. Not a leak surface.
- *   - `csharp/namespace-siblings.ts:307`, `go/expand-wildcards.ts:86`,
- *     `php/scope-resolver.ts:141,151`, `c/static-linkage.ts:51` — other
- *     languages' own wildcard / sibling expansions. Each owns its own
- *     visibility contract.
- *   - `receiver-bound-calls.ts:99`, `reconcile-ownership.ts:66,119`,
- *     `mro.ts:61` — keyed by `ownerId` for member lookup, never used
- *     as unqualified bindings.
- *   - `go/interface-impls.ts:40,53`, `go/package-siblings.ts:41` — Go-
- *     specific, sibling-package scoped.
- *
- * No other consumer treats `localDefs` as a flat unqualified-binding
- * set the way this function did before the fix. If a future consumer
- * does, mirror this filter or harden registration so class/namespace
- * members never enter `localDefs` unqualified.
- */
 export declare function expandCppWildcardNames(targetModuleScope: ScopeId, parsedFiles: readonly ParsedFile[]): readonly string[];
 export {};