gitnexus 1.6.5-rc.8 → 1.6.5

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

@@ -30,7 +30,7 @@ import { isRegistryPrimary } from './registry-primary-flag.js';
 import { isVerboseIngestionEnabled } from './utils/verbose.js';
 import { yieldToEventLoop } from './utils/event-loop.js';
 import { parseSourceSafe } from '../tree-sitter/safe-parse.js';
-import { FUNCTION_NODE_TYPES, findEnclosingClassId, findEnclosingClassInfo, genericFuncName, inferFunctionLabel, } from './utils/ast-helpers.js';
+import { CLASS_CONTAINER_TYPES, FUNCTION_NODE_TYPES, findEnclosingClassInfo, genericFuncName, inferFunctionLabel, } from './utils/ast-helpers.js';
 import { typeTagForId, constTagForId, buildCollisionGroups } from './utils/method-props.js';
 import { countCallArguments, inferCallForm, extractReceiverName, extractReceiverNode, extractMixedChain, extractCallArgTypes, } from './utils/call-analysis.js';
 import { buildTypeEnv, isSubclassOf } from './type-env.js';
@@ -39,6 +39,57 @@ import { normalizeFetchURL, routeMatches } from './route-extractors/nextjs.js';
 import { extractTemplateComponents } from './vue-sfc-extractor.js';
 import { extractReturnTypeName, stripNullable } from './type-extractors/shared.js';
 import { logger } from '../logger.js';
+// ── Property-prepass helpers (parity with parse-worker.ts) ──
+// These mirror the sequential-path equivalents in parse-worker.ts so the main-
+// thread `processCalls` pre-pass produces byte-identical Property nodes/symbols
+// to the worker pool. Drift between the two paths breaks the
+// `incremental ≡ --force` invariant the moment a repo crosses the worker
+// threshold between runs.
+/** Walk up to the nearest enclosing class/struct/interface AST node. */
+const findEnclosingClassNode = (node) => {
+    let current = node.parent;
+    while (current) {
+        if (CLASS_CONTAINER_TYPES.has(current.type))
+            return current;
+        current = current.parent;
+    }
+    return null;
+};
+/** No-op SymbolTable stub for FieldExtractorContext — matches parse-worker. */
+const NOOP_SYMBOL_TABLE = {
+    lookupExact: () => undefined,
+    lookupExactFull: () => undefined,
+    lookupExactAll: () => [],
+    lookupCallableByName: () => [],
+    getFiles: () => [][Symbol.iterator](),
+    getStats: () => ({ fileCount: 0 }),
+};
+/**
+ * Extract (and cache) field info for a class node. Cache is passed in so it
+ * stays scoped to a single `processCalls` invocation rather than leaking
+ * across analyze runs (worker uses module-level caching because each worker
+ * process is short-lived; the main thread is not).
+ *
+ * Cache key is `${filePath}:${classNode.startIndex}` — startIndex alone is a
+ * per-file byte offset, so almost every Ruby/Python file's leading class lands
+ * at byte 0 and would collide across files in the shared map.
+ */
+const getFieldInfo = (classNode, provider, context, cache) => {
+    if (!provider.fieldExtractor)
+        return undefined;
+    const cacheKey = `${context.filePath}:${classNode.startIndex}`;
+    const cached = cache.get(cacheKey);
+    if (cached)
+        return cached;
+    const result = provider.fieldExtractor.extract(classNode, context);
+    if (!result?.fields?.length)
+        return undefined;
+    const map = new Map();
+    for (const field of result.fields)
+        map.set(field.name, field);
+    cache.set(cacheKey, map);
+    return map;
+};
 /**
  * Type labels treated as class-like **method-dispatch receivers** by the call
  * resolver — the set walked by the MRO / heritage path for member and static
@@ -577,7 +628,16 @@ importedBindingsMap,
  *  Consulted ONLY when SymbolTable has no unambiguous match (local-first principle). */
 importedReturnTypesMap, 
 /** Phase 14 E3: cross-file RAW return types for for-loop element extraction. Keyed by filePath → Map<calleeName, rawReturnType>. */
-importedRawReturnTypesMap, heritageMap, bindingAccumulator) => {
+importedRawReturnTypesMap, heritageMap, bindingAccumulator, 
+/**
+ * Optional cache for compiled `Parser.Query` objects keyed by language name.
+ * When provided, compiled queries are reused across calls instead of being
+ * re-compiled from the query string for every file. Callers that invoke
+ * `processCalls` many times with single-file batches (e.g. the cross-file
+ * propagation phase) should pass a long-lived map here to avoid O(N)
+ * query recompilation overhead.
+ */
+compiledQueryCache) => {
     const parser = await loadParser();
     const collectedHeritage = [];
     const pendingWrites = [];
@@ -627,7 +687,11 @@ importedRawReturnTypesMap, heritageMap, bindingAccumulator) => {
         let matches;
         try {
             const lang = parser.getLanguage();
-            const query = new Parser.Query(lang, queryStr);
+            let query = compiledQueryCache?.get(language);
+            if (!query) {
+                query = new Parser.Query(lang, queryStr);
+                compiledQueryCache?.set(language, query);
+            }
             matches = query.matches(tree.rootNode);
         }
         catch (queryError) {
@@ -702,6 +766,111 @@ importedRawReturnTypesMap, heritageMap, bindingAccumulator) => {
         }
         prepared.push({ file, language, provider, tree, matches, parentMap, typeEnv });
     }
+    // ── Property-registration pre-pass ──
+    // Register all routed properties (e.g. Ruby attr_accessor) BEFORE the
+    // resolution loop so cross-file field-type lookups (e.g.
+    // `user.address.save → Address#save`) succeed regardless of file
+    // processing order. This MUST stay in lockstep with the equivalent
+    // worker-path block in parse-worker.ts (kind === 'properties') — any
+    // divergence between the two paths breaks the `incremental ≡ --force`
+    // invariant once a repo crosses the worker threshold between runs.
+    const fieldInfoCache = new Map();
+    for (const { file, language, provider, matches, typeEnv } of prepared) {
+        const callRouter = provider.callRouter;
+        if (!callRouter)
+            continue;
+        matches.forEach((match) => {
+            const captureMap = {};
+            match.captures.forEach((c) => (captureMap[c.name] = c.node));
+            if (!captureMap['call'])
+                return;
+            const callNameNode = captureMap['call.name'];
+            if (!callNameNode)
+                return;
+            const routed = callRouter(callNameNode.text, captureMap['call']);
+            if (!routed || routed.kind !== 'properties')
+                return;
+            const propEnclosingInfo = findEnclosingClassInfo(captureMap['call'], file.path, provider.resolveEnclosingOwner);
+            const propEnclosingClassId = propEnclosingInfo?.classId ?? null;
+            // Enrich routed properties with FieldExtractor metadata so types
+            // discovered from constructor assignments (e.g. `@address = Address.new`)
+            // are propagated even when the routing payload itself lacks declaredType.
+            let routedFieldMap;
+            if (provider.fieldExtractor && typeEnv) {
+                const classNode = findEnclosingClassNode(captureMap['call']);
+                if (classNode) {
+                    routedFieldMap = getFieldInfo(classNode, provider, {
+                        typeEnv,
+                        symbolTable: NOOP_SYMBOL_TABLE,
+                        filePath: file.path,
+                        language,
+                    }, fieldInfoCache);
+                }
+            }
+            const fileId = generateId('File', file.path);
+            for (const item of routed.items) {
+                const routedFieldInfo = routedFieldMap?.get(item.propName);
+                const propQualifiedName = propEnclosingInfo
+                    ? `${propEnclosingInfo.className}.${item.propName}`
+                    : item.propName;
+                const nodeId = generateId('Property', `${file.path}:${propQualifiedName}`);
+                graph.addNode({
+                    id: nodeId,
+                    label: 'Property',
+                    properties: {
+                        name: item.propName,
+                        filePath: file.path,
+                        startLine: item.startLine,
+                        endLine: item.endLine,
+                        language,
+                        isExported: true,
+                        description: item.accessorType,
+                        ...(item.declaredType
+                            ? { declaredType: item.declaredType }
+                            : routedFieldInfo?.type
+                                ? { declaredType: routedFieldInfo.type }
+                                : {}),
+                        ...(routedFieldInfo?.visibility !== undefined
+                            ? { visibility: routedFieldInfo.visibility }
+                            : {}),
+                        ...(routedFieldInfo?.isStatic !== undefined
+                            ? { isStatic: routedFieldInfo.isStatic }
+                            : {}),
+                        ...(routedFieldInfo?.isReadonly !== undefined
+                            ? { isReadonly: routedFieldInfo.isReadonly }
+                            : {}),
+                    },
+                });
+                ctx.model.symbols.add(file.path, item.propName, nodeId, 'Property', {
+                    ...(propEnclosingClassId ? { ownerId: propEnclosingClassId } : {}),
+                    ...(item.declaredType
+                        ? { declaredType: item.declaredType }
+                        : routedFieldInfo?.type
+                            ? { declaredType: routedFieldInfo.type }
+                            : {}),
+                });
+                const relId = generateId('DEFINES', `${fileId}->${nodeId}`);
+                graph.addRelationship({
+                    id: relId,
+                    sourceId: fileId,
+                    targetId: nodeId,
+                    type: 'DEFINES',
+                    confidence: 1.0,
+                    reason: '',
+                });
+                if (propEnclosingClassId) {
+                    graph.addRelationship({
+                        id: generateId('HAS_PROPERTY', `${propEnclosingClassId}->${nodeId}`),
+                        sourceId: propEnclosingClassId,
+                        targetId: nodeId,
+                        type: 'HAS_PROPERTY',
+                        confidence: 1.0,
+                        reason: '',
+                    });
+                }
+            }
+        });
+    }
     // ── Resolution loop: verify constructor bindings and resolve calls ──
     // The accumulator (if present) is now fully populated from the preparation
     // loop above, so verifyConstructorBindings sees all provider bindings
@@ -753,7 +922,13 @@ importedRawReturnTypesMap, heritageMap, bindingAccumulator) => {
                     // Defer resolution: Ruby attr_accessor properties are registered during
                     // this same loop, so cross-file lookups fail if the declaring file hasn't
                     // been processed yet. Collect now, resolve after all files are done.
-                    pendingWrites.push({ receiverTypeName, propertyName, filePath: file.path, srcId });
+                    pendingWrites.push({
+                        receiverTypeName,
+                        propertyName,
+                        filePath: file.path,
+                        srcId,
+                        line: captureMap['assignment'].startPosition.row + 1,
+                    });
                 }
                 // Assignment-only capture (no @call sibling): skip the rest of this
                 // forEach iteration — this acts as a `continue` in the match loop.
@@ -842,47 +1017,8 @@ importedRawReturnTypesMap, heritageMap, bindingAccumulator) => {
                     case 'import':
                         return;
                     case 'properties': {
-                        const fileId = generateId('File', file.path);
-                        const propEnclosingClassId = findEnclosingClassId(captureMap['call'], file.path);
-                        for (const item of routed.items) {
-                            const nodeId = generateId('Property', `${file.path}:${item.propName}`);
-                            graph.addNode({
-                                id: nodeId,
-                                label: 'Property',
-                                properties: {
-                                    name: item.propName,
-                                    filePath: file.path,
-                                    startLine: item.startLine,
-                                    endLine: item.endLine,
-                                    language,
-                                    isExported: true,
-                                    description: item.accessorType,
-                                },
-                            });
-                            ctx.model.symbols.add(file.path, item.propName, nodeId, 'Property', {
-                                ...(propEnclosingClassId ? { ownerId: propEnclosingClassId } : {}),
-                                ...(item.declaredType ? { declaredType: item.declaredType } : {}),
-                            });
-                            const relId = generateId('DEFINES', `${fileId}->${nodeId}`);
-                            graph.addRelationship({
-                                id: relId,
-                                sourceId: fileId,
-                                targetId: nodeId,
-                                type: 'DEFINES',
-                                confidence: 1.0,
-                                reason: '',
-                            });
-                            if (propEnclosingClassId) {
-                                graph.addRelationship({
-                                    id: generateId('HAS_PROPERTY', `${propEnclosingClassId}->${nodeId}`),
-                                    sourceId: propEnclosingClassId,
-                                    targetId: nodeId,
-                                    type: 'HAS_PROPERTY',
-                                    confidence: 1.0,
-                                    reason: '',
-                                });
-                            }
-                        }
+                        // Properties already registered in the pre-pass above.
+                        // Skip to avoid duplicate nodes/edges.
                         return;
                     }
                     case 'call':
@@ -1116,7 +1252,7 @@ importedRawReturnTypesMap, heritageMap, bindingAccumulator) => {
         const fieldOwner = resolveFieldOwnership(pw.receiverTypeName, pw.propertyName, pw.filePath, ctx);
         if (fieldOwner) {
             graph.addRelationship({
-                id: generateId('ACCESSES', `${pw.srcId}:${fieldOwner.nodeId}:write`),
+                id: generateId('ACCESSES', `${pw.srcId}:${fieldOwner.nodeId}:write${pw.line !== undefined ? `:${pw.line}` : ''}`),
                 sourceId: pw.srcId,
                 targetId: fieldOwner.nodeId,
                 type: 'ACCESSES',
@@ -2315,7 +2451,7 @@ export const processAssignmentsFromExtracted = (graph, assignments, ctx, constru
         if (!fieldOwner)
             continue;
         graph.addRelationship({
-            id: generateId('ACCESSES', `${asn.sourceId}:${fieldOwner.nodeId}:write`),
+            id: generateId('ACCESSES', `${asn.sourceId}:${fieldOwner.nodeId}:write${asn.line !== undefined ? `:${asn.line}` : ''}`),
             sourceId: asn.sourceId,
             targetId: fieldOwner.nodeId,
             type: 'ACCESSES',

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

@@ -1,5 +1,27 @@
 // gitnexus/src/core/ingestion/class-extractors/configs/c-cpp.ts
 import { SupportedLanguages } from '../../../../_shared/index.js';
+import { extractTemplateArguments, stripTemplateArguments, } from '../../utils/template-arguments.js';
+function shouldSkipCppTemplateDuplicateCapture(captureMap, definitionName, capturedName) {
+    if (captureMap['template-arguments'] !== undefined)
+        return false;
+    if (!definitionName)
+        return false;
+    const argsFromDefinitionName = extractTemplateArguments(definitionName);
+    if (argsFromDefinitionName === undefined)
+        return false;
+    const argsFromCaptureName = capturedName ? extractTemplateArguments(capturedName) : undefined;
+    // Generic class capture emits only `List`, while the specialization-aware
+    // capture emits `List` + `@declaration.template-arguments`. Skip the former
+    // when the declaration name itself is templated to avoid duplicate class defs.
+    return argsFromCaptureName === undefined;
+}
+function extractCppTemplateArgumentsWithFallback(captureMap, definitionName, capturedName) {
+    return ((captureMap['template-arguments']
+        ? extractTemplateArguments(captureMap['template-arguments'].text)
+        : undefined) ??
+        (definitionName ? extractTemplateArguments(definitionName) : undefined) ??
+        (capturedName ? extractTemplateArguments(capturedName) : undefined));
+}
 export const cClassConfig = {
     language: SupportedLanguages.C,
     typeDeclarationNodes: ['struct_specifier', 'enum_specifier'],
@@ -8,4 +30,20 @@ export const cppClassConfig = {
     language: SupportedLanguages.CPlusPlus,
     typeDeclarationNodes: ['class_specifier', 'struct_specifier', 'enum_specifier'],
     ancestorScopeNodeTypes: ['namespace_definition', 'class_specifier', 'struct_specifier'],
+    extractName: (node) => {
+        const nameNode = node.childForFieldName?.('name');
+        if (!nameNode)
+            return undefined;
+        if (nameNode.type !== 'template_type')
+            return undefined;
+        return stripTemplateArguments(nameNode.text);
+    },
+    extractTemplateArguments: (node) => {
+        const nameNode = node.childForFieldName?.('name');
+        if (!nameNode || nameNode.type !== 'template_type')
+            return undefined;
+        return extractTemplateArguments(nameNode.text);
+    },
+    shouldSkipClassCapture: ({ captureMap, definitionNode, nameNode }) => shouldSkipCppTemplateDuplicateCapture(captureMap, definitionNode?.childForFieldName?.('name')?.text, nameNode?.text),
+    extractTemplateArgumentsFromCapture: ({ captureMap, definitionNode, nameNode }) => extractCppTemplateArgumentsWithFallback(captureMap, definitionNode?.childForFieldName?.('name')?.text, nameNode?.text),
 };

package/dist/core/ingestion/class-extractors/generic.js

@@ -116,10 +116,12 @@ export function createClassExtractor(config) {
             (isClassLikeLabel(fallback?.type) ? fallback.type : undefined);
         if (!name || !type)
             return null;
+        const templateArguments = config.extractTemplateArguments?.(node);
         return {
             name,
             type,
             qualifiedName: buildQualifiedName(node, name) || name,
+            ...(templateArguments !== undefined ? { templateArguments } : {}),
         };
     };
     return {
@@ -131,5 +133,11 @@ export function createClassExtractor(config) {
         extractQualifiedName(node, simpleName) {
             return extract(node, { name: simpleName })?.qualifiedName ?? null;
         },
+        shouldSkipClassCapture(context) {
+            return config.shouldSkipClassCapture?.(context) ?? false;
+        },
+        extractTemplateArgumentsFromCapture(context) {
+            return config.extractTemplateArgumentsFromCapture?.(context);
+        },
     };
 }

package/dist/core/ingestion/class-types.d.ts

@@ -5,6 +5,12 @@ export interface ExtractedClassSymbol {
     name: string;
     type: ClassLikeNodeLabel;
     qualifiedName: string;
+    templateArguments?: string[];
+}
+export interface ClassCaptureContext {
+    captureMap: Record<string, SyntaxNode>;
+    definitionNode: SyntaxNode | null;
+    nameNode: SyntaxNode | undefined;
 }
 /**
  * Cross-language qualified type names are normalized to dot-separated scope
@@ -21,6 +27,10 @@ export interface ClassExtractor {
         type?: NodeLabel | null;
     }): ExtractedClassSymbol | null;
     extractQualifiedName(node: SyntaxNode, simpleName: string): string | null;
+    shouldSkipClassCapture?(context: ClassCaptureContext & {
+        nodeLabel: ClassLikeNodeLabel;
+    }): boolean;
+    extractTemplateArgumentsFromCapture?(context: ClassCaptureContext): string[] | undefined;
 }
 export interface ClassExtractionConfig {
     language: SupportedLanguages;
@@ -31,4 +41,9 @@ export interface ClassExtractionConfig {
     extractName?: (node: SyntaxNode) => string | undefined;
     extractType?: (node: SyntaxNode) => ClassLikeNodeLabel | undefined;
     extractScopeSegments?: (node: SyntaxNode) => string[] | null | undefined;
+    extractTemplateArguments?: (node: SyntaxNode) => string[] | undefined;
+    shouldSkipClassCapture?(context: ClassCaptureContext & {
+        nodeLabel: ClassLikeNodeLabel;
+    }): boolean;
+    extractTemplateArgumentsFromCapture?(context: ClassCaptureContext): string[] | undefined;
 }

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

@@ -20,6 +20,23 @@ const __dirname = dirname(__filename);
 const leidenPath = resolve(__dirname, '..', '..', '..', 'vendor', 'leiden', 'index.cjs');
 const _require = createRequire(import.meta.url);
 const leiden = _require(leidenPath);
+/**
+ * Deterministic PRNG (mulberry32) seed for the vendored Leiden algorithm.
+ * Vendored Leiden defaults `rng: Math.random`, which makes community
+ * assignment non-deterministic across runs. Passing a seeded RNG gives us
+ * reproducible community/modularity output, which is required for the
+ * incremental-indexing equivalence test (incremental ≡ full rebuild).
+ */
+const LEIDEN_SEED = 0xc0de;
+function createSeededRng(seed) {
+    let s = seed >>> 0;
+    return () => {
+        s = (s + 0x6d2b79f5) >>> 0;
+        let t = Math.imul(s ^ (s >>> 15), 1 | s);
+        t = (t + Math.imul(t ^ (t >>> 7), 61 | t)) ^ t;
+        return ((t ^ (t >>> 14)) >>> 0) / 4294967296;
+    };
+}
 // ============================================================================
 // COMMUNITY COLORS (for visualization)
 // ============================================================================
@@ -83,6 +100,7 @@ export const processCommunities = async (knowledgeGraph, onProgress) => {
             Promise.resolve(leiden.detailed(graph, {
                 resolution: isLarge ? 2.0 : 1.0,
                 maxIterations: isLarge ? 3 : 0,
+                rng: createSeededRng(LEIDEN_SEED),
             })),
             new Promise((_, reject) => setTimeout(() => reject(new Error('Leiden timeout')), LEIDEN_TIMEOUT_MS)),
         ]);

package/dist/core/ingestion/import-resolvers/standard.d.ts

@@ -28,3 +28,8 @@ export declare const resolveImportPath: (currentFile: string, importPath: string
 export declare function resolveStandard(rawImportPath: string, filePath: string, ctx: ResolveCtx, language: SupportedLanguages): ImportResult;
 /** Create a reusable standard-resolution strategy for a given language. */
 export declare function createStandardStrategy(language: SupportedLanguages): ImportResolverStrategy;
+/**
+ * Strip a JS-family extension from a path, returning the stem.
+ * Returns `null` if the path does not end with a JS-family extension.
+ */
+export declare function stripJsExtension(path: string): string | null;

package/dist/core/ingestion/import-resolvers/standard.js

@@ -52,6 +52,13 @@ export const resolveImportPath = (currentFile, importPath, allFiles, allFileList
                 const resolved = tryResolveWithExtensions(rewritten, allFiles);
                 if (resolved)
                     return cache(resolved);
+                // ESM fallback: strip .js/.jsx/.mjs/.cjs and retry with TS equivalents
+                const strippedAlias = stripJsExtension(rewritten);
+                if (strippedAlias !== null) {
+                    const esmResolved = tryResolveWithExtensions(strippedAlias, allFiles);
+                    if (esmResolved)
+                        return cache(esmResolved);
+                }
                 // Try suffix matching as fallback
                 const parts = rewritten.split('/').filter(Boolean);
                 const suffixResult = suffixResolve(parts, normalizedFileList, allFileList, index);
@@ -108,7 +115,17 @@ export const resolveImportPath = (currentFile, importPath, allFiles, allFileList
     const basePath = currentDir.join('/');
     if (importPath.startsWith('.')) {
         const resolved = tryResolveWithExtensions(basePath, allFiles);
-        return cache(resolved);
+        if (resolved)
+            return cache(resolved);
+        // TypeScript ESM: imports use .js/.jsx/.mjs/.cjs but source files are
+        // .ts/.tsx/.mts/.cts. Strip the JS-family extension and re-resolve.
+        if (language === SupportedLanguages.TypeScript || language === SupportedLanguages.JavaScript) {
+            const stripped = stripJsExtension(basePath);
+            if (stripped !== null) {
+                return cache(tryResolveWithExtensions(stripped, allFiles));
+            }
+        }
+        return cache(null);
     }
     // ---- Generic package/absolute import resolution (suffix matching) ----
     // Java wildcards are handled in processImports, not here
@@ -140,3 +157,16 @@ export function resolveStandard(rawImportPath, filePath, ctx, language) {
 export function createStandardStrategy(language) {
     return (raw, fp, ctx) => resolveStandard(raw, fp, ctx, language);
 }
+// ============================================================================
+// ESM extension helpers
+// ============================================================================
+/** JS-family extensions that TypeScript ESM maps to TS equivalents. */
+const JS_EXTENSION_PATTERN = /\.(js|jsx|mjs|cjs)$/;
+/**
+ * Strip a JS-family extension from a path, returning the stem.
+ * Returns `null` if the path does not end with a JS-family extension.
+ */
+export function stripJsExtension(path) {
+    const match = JS_EXTENSION_PATTERN.exec(path);
+    return match ? path.slice(0, -match[0].length) : null;
+}

package/dist/core/ingestion/import-resolvers/utils.js

@@ -8,8 +8,12 @@ export const EXTENSIONS = [
     // TypeScript/JavaScript
     '.tsx',
     '.ts',
+    '.mts',
+    '.cts',
     '.jsx',
     '.js',
+    '.mjs',
+    '.cjs',
     '.vue',
     '/index.tsx',
     '/index.ts',

package/dist/core/ingestion/languages/c-cpp.js

@@ -38,6 +38,7 @@ import { cCallConfig, cppCallConfig } from '../call-extractors/configs/c-cpp.js'
 import { createHeritageExtractor } from '../heritage-extractors/generic.js';
 import { stripUeMacros } from '../cpp-ue-preprocessor.js';
 import { emitCScopeCaptures, interpretCImport, interpretCTypeBinding, cArityCompatibility, cBindingScopeFor, cImportOwningScope, cReceiverBinding, } from './c/index.js';
+import { emitCppScopeCaptures, interpretCppImport, interpretCppTypeBinding, cppArityCompatibility, cppBindingScopeFor, cppImportOwningScope, cppReceiverBinding, } from './cpp/index.js';
 const C_BUILT_INS = new Set([
     'printf',
     'fprintf',
@@ -269,12 +270,20 @@ const cCppExtractFunctionName = (node) => {
     }
     return { funcName, label };
 };
-/** Check if a C/C++ function_definition is inside a class or struct body.
+/** Check if a C/C++ function_definition is inside a class or struct body
+ *  (and NOT a friend declaration).
  *  Used by cppLabelOverride to skip duplicate function captures
- *  that are already covered by definition.method queries. */
+ *  that are already covered by definition.method queries.
+ *  Friend functions are free functions defined inside class bodies —
+ *  they must NOT be skipped (ISO C++ hidden-friend idiom). */
 function isCppInsideClassOrStruct(functionNode) {
     let ancestor = functionNode?.parent ?? null;
     while (ancestor) {
+        // Friend declarations: the function_definition is wrapped in
+        // `friend_declaration` → `field_declaration_list` → class_specifier.
+        // These are free functions, not methods — don't skip them.
+        if (ancestor.type === 'friend_declaration')
+            return false;
         if (ancestor.type === 'class_specifier' || ancestor.type === 'struct_specifier')
             return true;
         ancestor = ancestor.parent;
@@ -408,4 +417,13 @@ export const cppProvider = defineLanguage({
     heritageExtractor: createHeritageExtractor(SupportedLanguages.CPlusPlus),
     labelOverride: cppLabelOverride,
     builtInNames: C_BUILT_INS,
+    // ── RFC #909 Ring 3: scope-based resolution hooks (RFC §5) ──────────
+    emitScopeCaptures: emitCppScopeCaptures,
+    interpretImport: interpretCppImport,
+    interpretTypeBinding: interpretCppTypeBinding,
+    bindingScopeFor: cppBindingScopeFor,
+    importOwningScope: cppImportOwningScope,
+    receiverBinding: cppReceiverBinding,
+    arityCompatibility: cppArityCompatibility,
+    // mergeBindings + resolveImportTarget live on ScopeResolver (see cpp/scope-resolver.ts).
 });